}

func makeServiceMap(proxier *Proxier, allServices ...*v1.Service) {
	for i := range allServices {
		proxier.OnServiceAdd(allServices[i])
	}

	proxier.mu.Lock()
	defer proxier.mu.Unlock()
	proxier.servicesSynced = true
}

func makeEndpointSliceMap(proxier *Proxier, allEpSlices ...*discovery.EndpointSlice) {
	for i := range allEpSlices {
		proxier.OnEndpointSliceAdd(allEpSlices[i])
	}

	var proxier *Proxier

	proxier = &Proxier{ipFamily: v1.IPv4Protocol}
	proxier.OnServiceCIDRsChanged([]string{"172.30.0.0/16", "fd00:10:96::/112"})
	assert.Equal(t, proxier.serviceCIDRs, "172.30.0.0/16")

	proxier.OnServiceCIDRsChanged([]string{"172.30.0.0/16", "172.50.0.0/16", "fd00:10:96::/112", "fd00:172:30::/112"})
	assert.Equal(t, proxier.serviceCIDRs, "172.30.0.0/16,172.50.0.0/16")

          "interval": "1m",
          "intervalFactor": 2,
          "legendFormat": "{{bucket}}",
          "refId": "A"
        }
      ],
      "title": "Total Proxied Head Requests",
      "type": "timeseries"
    },
    {
      "datasource": {
        "type": "prometheus",
        "uid": "${DS_PROMETHEUS}"
      },
      "fieldConfig": {

				Value:       float64(m.Proxied.GetTotal),
			})
			ml = append(ml, MetricV2{
				Description: getClusterReplProxiedHeadOperationsMD(clusterMetricNamespace),
				Value:       float64(m.Proxied.HeadTotal),
			})
			ml = append(ml, MetricV2{
				Description: getClusterReplProxiedPutTaggingOperationsMD(clusterMetricNamespace),
				Value:       float64(m.Proxied.PutTagTotal),
			})

   */
  @Test
  fun connectTimeoutsAttemptsAlternateRoute() {
    val proxySelector = RecordingProxySelector()
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, TestUtil.UNREACHABLE_ADDRESS_IPV4))
    proxySelector.proxies.add(server.toProxyAddress())
    server.enqueue(MockResponse(body = "success!"))
    client =
      client.newBuilder()
        .proxySelector(proxySelector)

			}
		}

		writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
		return
	}

	if !proxy.Proxy { // apply lifecycle rules only locally not for proxied requests
		// Automatically remove the object/version if an expiry lifecycle rule can be applied
		if lc, err := globalLifecycleSys.Get(bucket); err == nil {
			rcfg, err := globalBucketObjectLockSys.Get(bucket)

asource":{"type":"prometheus","uid":"$datasource"},"expr":"sum by (pod) (workload_manager_active_proxy_count{pod=~\"ztunnel-.*\"})","legendFormat":"Active Proxies ({{pod}})"},{"datasource":{"type":"prometheus","uid":"$datasource"},"expr":"sum by (pod) (workload_manager_pending_proxy_count{pod=~\"ztunnel-.*\"})","legendFormat":"Pending Proxies ({{pod}})"}],"title":"Workload Manager","type":"timeseries"}],"refresh":"15s","schemaVersion":39,"templating":{"list":[{"name":"datasource","query":"promet...

		ri.Checksum = oi.Checksum
	}
	if dsc.Synchronous() {
		replicateObject(ctx, ri, o)
	} else {
		globalReplicationPool.queueReplicaTask(ri)
	}
}

// proxyTaggingToRepTarget proxies tagging requests to remote targets for
// active-active replicated setups

	}
	if closes != 1 {
		t.Errorf("after RoundTrip, request body was closed %v times; want 1", closes)
	}
}

// logWritesConn is a net.Conn that logs each Write call to writes
// and then proxies to w.
// It proxies Read calls to a reader it receives from rch.
type logWritesConn struct {
	net.Conn // nil. crash on use.

	w io.Writer

	rch <-chan io.Reader
	r   io.Reader // nil until received by rch

			sm.Queued.Max.Bytes = peer.Queued.Max.Bytes
			sm.Queued.Max.Count = peer.Queued.Max.Count
		}
		sm.ReplicaCount += peer.ReplicaCount
		sm.ReplicaSize += peer.ReplicaSize
		sm.Proxied.Add(madmin.ReplProxyMetric(peer.Proxied))
		for dID, v := range peer.Metrics {
			v2, ok := sm.Metrics[dID]
			if !ok {
				v2 = madmin.SRMetric{}
				v2.Failed.ErrCounts = make(map[string]int)
			}