}

		// exact hosts are saved separately for map lookup
		if !hName.IsWildCarded() {
			hostsByNamespace[ns].exactHosts.Insert(hName)
		}

		// allHosts contains the exact hosts and wildcard hosts,
		// since SelectVirtualServices will use `Matches` semantic matching.
		hc := hostsByNamespace[ns]
		hc.allHosts = append(hc.allHosts, hName)

					parent.OriginalReference.Name, ptr.OrDefault(parent.OriginalReference.Namespace, k8s.Namespace(obj.Namespace)), ctx.Domain)
				vsHosts = []string{host}
			}
			routes = augmentTLSPortMatch(routes, parent.OriginalReference.Port, vsHosts)
		}

		for i, host := range vsHosts {
			name := fmt.Sprintf("%s-tls-%d-%s", obj.Name, i, constants.KubernetesGatewayName)
			filteredRoutes := routes
			if parent.IsMesh() {

		Timeout: 5 * time.Second,
	}
	var res TestGrid
	res.Hosts = hosts
	ready := make(chan struct{})
	ctx, cancel := context.WithCancel(context.Background())
	res.cancel = cancel
	for i, host := range hosts {
		manager, err := NewManager(ctx, ManagerOptions{
			Dialer: dialer.DialContext,
			Local:  host,
			Hosts:  hosts,
			AuthRequest: func(r *http.Request) error {
				return nil
			},

	hosts := sets.Set[string]{}
	if g == nil {
		return hosts
	}
	if g.ContainsAutoPassthroughGateways {
		for _, tls := range g.MergedServers {
			for _, s := range tls.Servers {
				if s.GetTls().GetMode() == networking.ServerTLSSettings_AUTO_PASSTHROUGH {
					hosts.InsertAll(s.Hosts...)
				}
			}
		}
	}
	return hosts
}

		up -d --build

	add_alias

	mc mb minio/minio-test/
	mc cp ./minio minio/minio-test/to-read/
	mc cp /etc/hosts minio/minio-test/to-read/hosts
	mc anonymous set download minio/minio-test

	verify_checksum_mc ./minio minio/minio-test/to-read/minio

	curl -s http://127.0.0.1:9000/minio-test/to-read/hosts | sha256sum

	MINIO_VERSION=dev /tmp/gopath/bin/docker-compose -f "buildscripts/upgrade-tests/compose.yml" stop
}

					n := 0
					var latency int64
					managers := grid.Managers
					hosts := grid.Hosts
					for pb.Next() {
						// Pick a random manager.
						src, dst := rng.Intn(len(managers)), rng.Intn(len(managers))
						if src == dst {
							dst = (dst + 1) % len(managers)
						}
						local := managers[src]
						conn := local.Connection(hosts[dst])
						if conn == nil {
							b.Fatal("No connection")
						}

				{
					Hosts: []string{"static.example.com"},
					Port:  &networking.Port{Name: "http", Number: 80, Protocol: "HTTP"},
				},
				{
					Hosts: []string{"www.example.com"},
					Port:  &networking.Port{Name: "https", Number: 443, Protocol: "HTTPS"},
					Tls:   &networking.ServerTLSSettings{Mode: networking.ServerTLSSettings_SIMPLE},
				},
				{

)

type collectMetricsOpts struct {
	hosts map[string]struct{}
	disks map[string]struct{}
	jobID string
	depID string
}

func collectLocalMetrics(types madmin.MetricType, opts collectMetricsOpts) (m madmin.RealtimeMetrics) {
	if types == madmin.MetricsNone {
		return
	}

	byHostName := globalMinioAddr
	if len(opts.hosts) > 0 {
		server := getLocalServerProperty(globalEndpoints, &http.Request{

			ingressConfigTemplate := `
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: %s
spec:
  ingressClassName: %s
  tls:
  - hosts: ["foo.example.com"]
    secretName: k8s-ingress-secret-foo
  - hosts: ["bar.example.com"]
    secretName: k8s-ingress-secret-bar
  rules:
  - http:
      paths:
      - backend:
          service:
            name: b
            port:

	// Deprecated. Was added for experimentation only.
	//
	// Deprecated: Marked as deprecated in dns/proto/nds.proto.
	AltHosts []string `protobuf:"bytes,5,rep,name=alt_hosts,json=altHosts,proto3" json:"alt_hosts,omitempty"`
}

func (x *NameTable_NameInfo) Reset() {
	*x = NameTable_NameInfo{}
	if protoimpl.UnsafeEnabled {
		mi := &file_dns_proto_nds_proto_msgTypes[1]