"metadata": {
      "INSTANCE_IPS": "127.0.1.1",
      "PILOT_SAN": [
        "istiod.istio-system.svc"
      ],
      "GENERATOR": "grpc",
      "NAMESPACE": "test"
    },
    "localisty": {},
    "UserAgentVersionType": "istiov1"
  },
  "certificate_providers": {
    "default": {
      "plugin_name": "file_watcher",
      "config": {

//  limitations under the License.

package locality

import (
	"fmt"
	"strings"
)

type Instance struct {
	Zone   string
	Region string
}

func (l Instance) String() string {
	return fmt.Sprintf("%s/%s", l.Region, l.Zone)
}

func Parse(s string) Instance {
	parts := strings.Split(s, "/")
	if len(parts) != 2 {
		panic("invalid locality string: " + s)
	}
	return Instance{

apiVersion: release-notes/v2
kind: feature
area: traffic-management
releaseNotes:
  - |

kind: feature

area: traffic-management

issue:
- https://github.com/istio/istio/pull/33426
- 33426

releaseNotes:
- |
  **Added** support for overriding the locality of the WorkloadGroup template in
  auto registered WorkloadEntries. Locality overrides can be passed in through

[
    {
        "clusterName": "agent",
        "endpoints": [
            {
                "locality": {},
                "lbEndpoints": [
                    {
                        "endpoint": {
                            "address": {
                                "socketAddress": {
                                    "address": "127.0.0.1",
                                    "portValue": 15020
                                }

    loadBalancingWeight: 3
    locality: {}
  policy:
    overprovisioningFactor: 140
- clusterName: sds-grpc
  endpoints:
  - lbEndpoints:
    - endpoint:
        address:
          pipe:
            path: ./var/run/secrets/workload-spiffe-uds/socket
        healthCheckConfig: {}
      healthStatus: HEALTHY
      loadBalancingWeight: 1
    locality: {}
  policy:
    overprovisioningFactor: 140

		cluster := buildFakeCluster()
		ApplyLocalityLoadBalancer(cluster.LoadAssignment, nil, locality, nil, env.Mesh().LocalityLbSetting, true)
		for _, localityEndpoint := range cluster.LoadAssignment.Endpoints {
			if localityEndpoint.Locality.Region == locality.Region {
				if localityEndpoint.Locality.Zone == locality.Zone {
					if localityEndpoint.Locality.SubZone == locality.SubZone {
						g.Expect(localityEndpoint.Priority).To(Equal(uint32(0)))
						continue

				applyLocalityFailover(locality, loadAssignment, localityLB.Failover)
			}
		} else {
			// Apply default failover settings or user defined region failover settings.
			applyLocalityFailover(locality, loadAssignment, localityLB.Failover)
		}
	}
}

// set locality loadbalancing weight based on user defined weights.
func applyLocalityWeights(
	locality *core.Locality,
	loadAssignment *endpoint.ClusterLoadAssignment,

		n.q.Schedule(wrappedOnDone, deadline)
	}, onDone)
}

func (n *Node) Locality() locality.Instance {
	return n.locality
}

func (n *Node) ShutDown() {
	n.q.ShutDown()
}

type Nodes []*Node

func (nodes Nodes) Select(match locality.Match) Nodes {
	var out Nodes
	for _, n := range nodes {
		if match(n.locality) {
			out = append(out, n)
		}
	}
	return out
}

	return out
}

func (c *Controller) NewEndpointBuilderFromMetadata(proxy *model.Proxy) *EndpointBuilder {
	locality := util.LocalityToString(proxy.Locality)
	out := &EndpointBuilder{
		controller:     c,
		metaNetwork:    proxy.Metadata.Network,
		serviceAccount: proxy.Metadata.ServiceAccount,
		locality: model.Locality{
			Label:     locality,