}

	m := SRMetricsSummary{
		Uptime:        UTCNow().Unix() - globalBootTime.Unix(),
		Queued:        r.qCache.getSiteStats(),
		ActiveWorkers: r.ActiveWorkers(),
		Metrics:       r.srStats.get(),
		Proxied:       r.pCache.getSiteStats(),
		ReplicaSize:   atomic.LoadInt64(&r.srStats.ReplicaSize),
		ReplicaCount:  atomic.LoadInt64(&r.srStats.ReplicaCount),
	}
	return m
}

	// Header indicates a Tag operation was performed on one/more peers successfully, though the
	// current cluster does not have the object yet. This is in a site/bucket replication scenario.
	MinIOTaggingProxied = "X-Minio-Tagging-Proxied"
	// Header indicates the actual replicated object size
	// In case of SSEC objects getting replicated (multipart) actual size would be needed at target
	MinIOReplicationActualObjectSize = "X-Minio-Replication-Actual-Object-Size"

				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),
			})

			}
		}

		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)

		// Requests in federated setups for STS type calls which are
		// performed at '/' resource should be routed by the muxer,
		// the assumption is simply such that requests without a bucket
		// in a federated setup cannot be proxied, so serve them at
		// current server.
		if bucket == "" {
			h.ServeHTTP(w, r)
			return
		}

		// MakeBucket requests should be handled at current endpoint

      }
      return false;
    }

    @Override
    public String toString() {
      return paramString(interfaceType, identity);
    }
  }

  /** Subclasses can override to provide different return value for proxied interface methods. */
  @Nullable Object interfaceMethodCalled(Class<?> interfaceType, Method method) {
    throw new UnsupportedOperationException();
  }

				return
			}
		case "Queued":
			err = z.Queued.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Queued")
				return
			}
		case "Proxied":
			err = z.Proxied.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Proxied")
				return
			}
		case "Metrics":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Metrics")

      }
      return false;
    }

    @Override
    public String toString() {
      return paramString(interfaceType, identity);
    }
  }

  /** Subclasses can override to provide different return value for proxied interface methods. */
  @Nullable Object interfaceMethodCalled(Class<?> interfaceType, Method method) {
    throw new UnsupportedOperationException();
  }

     */
    public synchronized Proxy getActiveProxy() {
        if (activeProxy == null) {
            java.util.List<Proxy> proxies = getProxies();
            if (proxies != null && !proxies.isEmpty()) {
                for (Proxy proxy : proxies) {
                    if (proxy.isActive()) {
                        activeProxy = proxy;
                        break;
                    }

* Dual stack services (Phase II of IPv6DualStack feature) are enabled via the IPVS proxier. iptables proxier does not support dualstack yet. Dualstack iptables proxier is WIP and should catchup soon. ([#82091](https://github.com/kubernetes/kubernetes/pull/82091), [@khenidak](https://github.com/khenidak))
    * to enable, kube-proxy must be have the following flags: