}
            }
            resultBuf.append("Status of ").append(ping.getClusterName()).append(" is changed to ").append(ping.getClusterStatus())
                    .append('.');
        } else if (status == 0) {
            resultBuf.append(ping.getClusterName()).append(" is alive.");
        } else {
            resultBuf.append(ping.getClusterName()).append(" is not available.");
        }

        return resultBuf.toString();

    private String message = StringUtil.EMPTY;

    public PingResponse(final ClusterHealthResponse response) {
        status = response.getStatus() == ClusterHealthStatus.RED ? 1 : 0;
        clusterName = response.getClusterName();
        clusterStatus = response.getStatus().toString();
        final Set<String> fieldSet = ComponentUtil.getFessConfig().getApiPingEsFieldSet();

                            .setThreads(threads).setTimeout(timeout).setType(type).execute().actionGet(timeout);
            append(buf, "cluster_name", () -> response.getClusterName().value()).append(',');
            final String hotThreads = response.getNodesMap().entrySet().stream().map(e -> {
                final StringBuilder tempBuf = new StringBuilder();

		pc.BinaryPath = ""
	}
	if pc.ControlPlaneAuthPolicy == defaults.ControlPlaneAuthPolicy {
		pc.ControlPlaneAuthPolicy = 0
	}
	if x, ok := pc.GetClusterName().(*meshconfig.ProxyConfig_ServiceCluster); ok {
		if x.ServiceCluster == defaults.GetClusterName().(*meshconfig.ProxyConfig_ServiceCluster).ServiceCluster {
			pc.ClusterName = nil
		}
	}

	if proto.Equal(pc.DrainDuration, defaults.DrainDuration) {

				"This is not recommended and may lead to performance issues. "+
				"CPU count: %d, CPU Limit: %d.", runtime.NumCPU(), CPULimit)
		}
	}

	if x, ok := proxyConfig.GetClusterName().(*meshconfig.ProxyConfig_ServiceCluster); ok {
		if x.ServiceCluster == "" {
			proxyConfig.ClusterName = &meshconfig.ProxyConfig_ServiceCluster{ServiceCluster: serviceCluster}
		}
	}
	// resolve statsd address

            final ClusterHealthResponse response =
                    esClient.admin().cluster().prepareHealth().execute().actionGet(fessConfig.getIndexHealthTimeout());
            engineObj.clusterName = response.getClusterName();
            engineObj.numberOfNodes = response.getNumberOfNodes();
            engineObj.numberOfDataNodes = response.getNumberOfDataNodes();
            engineObj.activePrimaryShards = response.getActivePrimaryShards();

	return tag + "-" + imageType
}

func extractClusterAndNetwork(params InjectionParameters) (string, string) {
	metadata := &params.pod.ObjectMeta
	cluster := params.valuesConfig.asStruct.GetGlobal().GetMultiCluster().GetClusterName()
	// TODO allow overriding the values.global network in injection with the system namespace label
	network := params.valuesConfig.asStruct.GetGlobal().GetNetwork()

              << " instances";
    }
  }

  struct EdgeInfo {
    absl::string_view node_name;
    std::optional<absl::string_view> cluster_name;

    absl::string_view GetClusterName() const {
      return cluster_name ? *cluster_name : "[none]";
    }

    std::pair<absl::string_view, std::optional<absl::string_view>> AsPair()
        const {
      return {node_name, cluster_name};

		errs = multierror.Append(errs, errors.New("config path must be set"))
	}

	if config.BinaryPath == "" {
		errs = multierror.Append(errs, errors.New("binary path must be set"))
	}

	clusterName := config.GetClusterName()
	switch naming := clusterName.(type) {
	case *meshconfig.ProxyConfig_ServiceCluster:
		if naming.ServiceCluster == "" {
			errs = multierror.Append(errs, errors.New("service cluster must be specified"))
		}

}

func (x *MultiClusterConfig) GetEnabled() *wrapperspb.BoolValue {
	if x != nil {
		return x.Enabled
	}
	return nil
}

func (x *MultiClusterConfig) GetClusterName() string {
	if x != nil {
		return x.ClusterName
	}
	return ""
}

func (x *MultiClusterConfig) GetGlobalDomainSuffix() string {
	if x != nil {
		return x.GlobalDomainSuffix
	}