// virtual machine
	vm1 = &fakeInstance{Cluster: cls1, Namespace: namespace.Static("echo"), Service: "vm", DeployAsVM: true}
	// headless
	headless1 = &fakeInstance{Cluster: cls1, Namespace: namespace.Static("echo"), Service: "headless", Headless: true}
	// naked pod (uninjected)
	naked1 = &fakeInstance{Cluster: cls1, Namespace: namespace.Static("echo"), Service: "naked", Subsets: []echo.SubsetConfig{{

	Naked         echo.Instances
	Headless      echo.Instances
	HeadlessNaked echo.Instances
)

const (
	ASvc             = "a"
	BSvc             = "b"
	CSvc             = "c"
	DSvc             = "d"
	ESvc             = "e"
	MultiversionSvc  = "multiversion"
	VMSvc            = "vm"
	HeadlessSvc      = "headless"
	NakedSvc         = "naked"
	HeadlessNakedSvc = "headless-naked"
	ExternalSvc      = "external"
)

	Sotw        WorkloadClass = "sotw"
	TProxy      WorkloadClass = "tproxy"
	Naked       WorkloadClass = "naked"
	External    WorkloadClass = "external"
	StatefulSet WorkloadClass = "statefulset"
	Headless    WorkloadClass = "headless"
	Captured    WorkloadClass = "captured"
	Waypoint    WorkloadClass = "waypoint"
	Standard    WorkloadClass = "standard"

		AutoTCPServer,
		AutoHTTP,
		AutoGRPC,
		AutoHTTPS,
		HTTPInstance,
		HTTPLocalHost,
		TCPWorkloadOnly,
		HTTPWorkloadOnly,
		TCPForHTTP,
	}
}

// Headless returns a modified version of All for use with headless services.
func Headless() echo.Ports {
	all := All()
	headlessPorts := make([]echo.Port, len(all))
	for i, p := range all {
		if !p.IsWorkloadOnly() {
			p.ServicePort = p.WorkloadPort
		}

	// IsHeadlessService is added by Controller to an Endpoint denoting if its parent
	// Service is Headless. The existence of this label can be used further by other
	// controllers and kube-proxy to check if the Endpoint objects should be replicated when
	// using Headless Services
	IsHeadlessService = "service.kubernetes.io/headless"

	// LabelNodeExcludeBalancers specifies that the node should not be considered as a target

					if !netutil.IsValidIPAddress(instance.Address) {
						continue
					}
					// TODO(stevenctl): headless across-networks https://github.com/istio/istio/issues/38327
					sameNetwork := cfg.Node.InNetwork(instance.Network)
					sameCluster := cfg.Node.InCluster(instance.Locality.ClusterID)
					// For all k8s headless services, populate the dns table with the endpoint IPs as k8s does.

	// IPv6 only echo app to be used by tests if running in dual-stack mode
	E echo.Instances
	// Standard echo app with TPROXY interception mode to be used by tests
	Tproxy echo.Instances
	// Headless echo app to be used by tests
	Headless echo.Instances
	// StatefulSet echo app to be used by tests
	StatefulSet echo.Instances
	// ProxylessGRPC echo app to be used by tests
	ProxylessGRPC echo.Instances

---
# Source: loki/templates/single-binary/service-headless.yaml
apiVersion: v1
kind: Service
metadata:
  name: loki-headless
  namespace: istio-system
  labels:
    helm.sh/chart: loki-6.6.3
    app.kubernetes.io/name: loki
    app.kubernetes.io/instance: loki
    app.kubernetes.io/version: "3.0.0"
    app.kubernetes.io/managed-by: Helm
    variant: headless
    prometheus.io/service-monitor: "false"

var _ config.Value = &configs{}

func (c *configs) String() string {
	buf := &bytes.Buffer{}
	for _, cc := range *c {
		_, _ = fmt.Fprintf(buf, "FQDN:     %s\n", cc.ClusterLocalFQDN())
		_, _ = fmt.Fprintf(buf, "Headless: %v\n", cc.Headless)
		_, _ = fmt.Fprintf(buf, "VM:       %v\n", cc.DeployAsVM)
		if cc.DeployAsVM {
			_, _ = fmt.Fprintf(buf, "VMDistro: %s\n", cc.VMDistro)
		}
		if cc.Cluster.Name() != "" {

apiVersion: release-notes/v2
kind: feature
area: traffic-management
releaseNotes:
- |
  **Enabled** discovering cross-cluster, same network, endpoints for headless services when `ISTIO_META_DNS_CAPTURE` and
  `ISTIO_META_DNS_AUTO_ALLOCATE` are enabled in `ProxyConfig.proxyMetadata`. This can be disabled by setting