They're also concrete: each URL identifies a specific path (like `/square/okhttp`) and query (like `?q=sharks&lang=en`). Each webserver hosts many URLs.

### [Addresses](https://square.github.io/okhttp/5.x/okhttp/okhttp3/-address/)

        validator.validate(settings, problems);
        assertEquals(1, problems.messages.size());
        assertContains(problems.messages.get(0), "'proxies.proxy.host' for default is missing");
    }

    private static class SimpleProblemCollector implements SettingsProblemCollector {

        List<String> messages = new ArrayList<>();

        @Override

Bir ASGI server'ı manuel olarak kurduysanız, FastAPI uygulamanızı import edebilmesi için genellikle özel bir formatta bir import string geçirmeniz gerekir:

<div class="termy">

```console
$ uvicorn main:app --host 0.0.0.0 --port 80

<span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
```

</div>

/// note | Not

`uvicorn main:app` komutu şunları ifade eder:

        // Create the name service client with mock context
        nameServiceClient = new NameServiceClientImpl(mockContext);
    }

    @Test
    @DisplayName("Should get local host name")
    void testGetLocalName() {
        // When
        NetbiosName localName = nameServiceClient.getLocalName();

        // Then
        assertNotNull(localName, "Local name should not be null");

Se você instalou um servidor ASGI manualmente, normalmente precisará passar uma string de importação em um formato especial para que ele importe sua aplicação FastAPI:

<div class="termy">

```console
$ uvicorn main:app --host 0.0.0.0 --port 80

<span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
```

</div>

/// note | Nota

O comando `uvicorn main:app` refere-se a:

				ignoredPaths = append(ignoredPaths, lp)
			}
		}
		return tmpPaths
	}()

	scheme := "http"
	if globalIsTLS {
		scheme = "https"
	}

	u := &url.URL{
		Scheme: scheme,
		Host:   globalLocalNodeName,
	}

	perfs, err := perf.Run(ctx, paths...)
	return madmin.DriveSpeedTestResult{
		Endpoint: u.String(),
		Version:  Version,
		DrivePerf: func() (results []madmin.DrivePerf) {

   * is running when that time is reached, that task is allowed to complete before this task is
   * started. Similarly the task will be delayed if the host lacks compute resources.
   *
   * @throws RejectedExecutionException if the queue is shut down and the task is not cancelable.
   */
  fun schedule(
    task: Task,
    delayNanos: Long = 0L,
  ) {

		allDriveLabels...)
)

func getCurrentDriveIOStats() map[string]madmin.DiskIOStats {
	types := madmin.MetricsDisk
	driveRealtimeMetrics := collectLocalMetrics(types, collectMetricsOpts{
		hosts: map[string]struct{}{
			globalLocalNodeName: {},
		},
	})

	stats := map[string]madmin.DiskIOStats{}
	for d, m := range driveRealtimeMetrics.ByDisk {
		stats[d] = m.IOStats
	}
	return stats
}

### RBE
rbe_config = use_extension("@xla//third_party/extensions:rbe_config.bzl", "rbe_config_ext")
use_repo(rbe_config, "ml_build_config_platform")

register_execution_platforms("@local_config_platform//:host")

remote_execution_configure = use_extension("@xla//third_party/extensions:remote_execution_configure.bzl", "remote_execution_configure_ext")
use_repo(remote_execution_configure, "local_config_remote_execution")

      # Set up which clang we should use as the cuda / host compiler.
      clang_cuda_compiler_path = set_clang_cuda_compiler_path(environ_cp)
      clang_version = retrieve_clang_version(clang_cuda_compiler_path)
      disable_clang_offsetof_extension(clang_version)
    else:
      # Set up which gcc nvcc should use as the host compiler
      # No need to set this on Windows
      if not is_windows():