return this;
    }

    public ArtifactResolutionRequest setServers(List<Server> servers) {
        this.servers = servers;

        return this;
    }

    public List<Server> getServers() {
        if (servers == null) {
            servers = new ArrayList<>();
        }

        return servers;
    }

    public ArtifactResolutionRequest setMirrors(List<Mirror> mirrors) {

	}
	return hosts, listeners, err
}

func startHTTPServer(listener net.Listener, handler http.Handler) (server *httptest.Server) {
	server = httptest.NewUnstartedServer(handler)
	server.Config.Addr = listener.Addr().String()
	server.Listener = listener
	server.Start()
	return server
}

func dummyRequestValidate(r *http.Request) error {
	return nil
}

                }
            }
        }

        List<Server> servers = settings.getServers();

        if (servers != null) {
            Set<String> serverIds = new HashSet<>();

            for (int i = 0; i < servers.size(); i++) {
                Server server = servers.get(i);

                validateStringNotEmpty(problems, "servers.server[" + i + "].id", server.getId(), null);

If you don't specify the `servers` parameter and `root_path` is equal to `/`, the `servers` property in the generated OpenAPI schema will be omitted entirely by default, which is the equivalent of a single server with a `url` value of `/`.

///

### Disable automatic server from `root_path` { #disable-automatic-server-from-root-path }

					errStr = fmt.Sprintf("no results for uploads upon first attempt, concurrency %d and duration %s",
						opts.concurrencyStart, opts.duration)
				}

				result.PUTStats.Servers = append(result.PUTStats.Servers, madmin.SpeedTestStatServer{
					Endpoint:         throughputHighestResults[i].Endpoint,
					ThroughputPerSec: throughputHighestResults[i].Uploads / uint64(durationSecs),

### High availability

A stand-alone MinIO server would go down if the server hosting the drives goes offline. In contrast, a distributed MinIO setup with _m_ servers and _n_ drives will have your data safe as long as _m/2_ servers or _m*n_/2 or more drives are online.

import jcifs.internal.smb1.net.NetServerEnum2Response;
import jcifs.internal.smb1.trans.SmbComTransaction;

/**
 * Iterator for enumerating network servers.
 *
 * This class provides iteration over network servers discovered
 * through NetBIOS server enumeration requests.
 */
public class NetServerEnumIterator implements CloseableIterator<FileEntry> {

    participant Proxy as Proxy/Load Balancer
    participant Server as FastAPI Server

    Client->>Proxy: HTTPS Request<br/>Host: mysuperapp.com<br/>Path: /items

    Note over Proxy: Proxy adds forwarded headers

    Proxy->>Server: HTTP Request<br/>X-Forwarded-For: [client IP]<br/>X-Forwarded-Proto: https<br/>X-Forwarded-Host: mysuperapp.com<br/>Path: /items

    Note over Server: Server interprets headers<br/>(if --forwarded-allow-ips is set)

from fastapi import FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot

app = FastAPI(
    servers=[
        {"url": "/", "description": "Default, relative server"},
        {
            "url": "http://staging.localhost.tiangolo.com:8000",
            "description": "Staging but actually localhost still",
        },
        {"url": "https://prod.example.com"},
    ]
)


@app.get("/foo")

/**
 * SMB1 NetServerEnum2 request message for enumerating network servers in a domain or workgroup.
 * This class implements the SMB1 transaction to query for available servers, supporting various
 * server types and filtering options for network browsing functionality.
 */
public class NetServerEnum2 extends SmbComTransaction {

    /**
     * Server type filter for all servers
     */
    public static final int SV_TYPE_ALL = 0xFFFFFFFF;