for (final CrawlerClient client : clientMap.values()) {
                client.setInitParameterMap(params);
            }
        }
    }

    public void setClientMap(final Map<Pattern, CrawlerClient> clientMap) {
        this.clientMap = clientMap;
    }

    @Override
    public void close() {
        clientMap.values().stream().distinct().forEach(client -> {
            try {

func ipv6fix(clientIP string) string {
	return strings.Split(clientIP, "%")[0]
}

func (rw *headerRewriter) Rewrite(req *http.Request) {
	if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
		clientIP = ipv6fix(clientIP)
		if req.Header.Get(xRealIP) == "" {
			req.Header.Set(xRealIP, clientIP)
		}
	}

	xfProto := req.Header.Get(xForwardedProto)

    protected CrawlerContainer crawlerContainer;

    protected Map<String, String> clientMap = new LinkedHashMap<>();

    protected List<CrawlerClientFactory> clientFactoryList = new LinkedList<>();

    protected int maxClientFactorySize = 10000;

    public synchronized void register(final CrawlerClientFactory crawlerClientFactory) {
        clientMap.entrySet().stream().forEach(e -> load(crawlerClientFactory, e.getKey(), e.getValue()));

                properties:
                  clientIP:
                    description: clientIP contains the configurations of Client IP
                      based session affinity.
                    type: object
                    properties:
                      timeoutSeconds:
                        description: timeoutSeconds specifies the seconds of ClientIP

    @Override
    public CrawlerClient getClient(final String url) {
        return factory.getClient(url);
    }

    @Override
    public void setClientMap(final Map<Pattern, CrawlerClient> clientMap) {
        factory.setClientMap(clientMap);
    }

    @Override
    public boolean equals(final Object obj) {
        return factory.equals(obj);
    }

    @Override
    public String toString() {

	s.ServeHTTP(resp.ResponseWriter, req.Request)
}

func (s *legacyRootAPIHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	clientIP := utilnet.GetClientIP(req)
	apiVersions := &metav1.APIVersions{
		ServerAddressByClientCIDRs: s.addresses.ServerAddressByClientCIDRs(clientIP),
		Versions:                   []string{"v1"},
	}

      },
      "queryPageSize": {
        "type": "integer"
      },
      "userAgent": {
        "type": "keyword"
      },
      "referer": {
        "type": "keyword"
      },
      "clientIp": {
        "type": "keyword"
      },
      "userSessionId": {
        "type": "keyword"
      },
      "accessType": {
        "type": "keyword"
      },
      "userInfoId": {
        "type": "keyword"

    ],
    "externalName": "externalNameValue",
    "externalTrafficPolicy": "externalTrafficPolicyValue",
    "healthCheckNodePort": 12,
    "publishNotReadyAddresses": true,
    "sessionAffinityConfig": {
      "clientIP": {
        "timeoutSeconds": 1
      }
    },
    "ipFamilies": [
      "ipFamiliesValue"
    ],
    "ipFamilyPolicy": "ipFamilyPolicyValue",
    "allocateLoadBalancerNodePorts": true,

    protocol: protocolValue
    targetPort: targetPortValue
  publishNotReadyAddresses: true
  selector:
    selectorKey: selectorValue
  sessionAffinity: sessionAffinityValue
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 1
  trafficDistribution: trafficDistributionValue
  type: typeValue
status:
  conditions:
  - lastTransitionTime: "2004-01-01T01:01:01Z"
    message: messageValue
    observedGeneration: 3

    protocol: protocolValue
    targetPort: targetPortValue
  publishNotReadyAddresses: true
  selector:
    selectorKey: selectorValue
  sessionAffinity: sessionAffinityValue
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 1
  type: typeValue
status:
  conditions:
  - lastTransitionTime: "2004-01-01T01:01:01Z"
    message: messageValue
    observedGeneration: 3
    reason: reasonValue