kind: ServiceEntry
metadata:
  name: external-service-locality
spec:
  hosts:
  - {{.Host}}
  location: MESH_EXTERNAL
  ports:
  - name: http
    number: 80
    protocol: HTTP
  resolution: {{.Resolution}}
  endpoints:
  - address: {{.Local}}
    locality: region/zone/subzone
  - address: {{.Remote}}
    locality: notregion/notzone/notsubzone
  {{ if ne .NearLocal "" }}

                        "cluster_name": "sds-grpc",
                        "endpoints": [
                            {
                                "locality": {},
                                "lb_endpoints": [
                                    {
                                        "endpoint": {
                                            "address": {

// Implements XdsCacheEntry interface.
type clusterCache struct {
	clusterName string

	// proxy related cache fields
	proxyVersion    string         // will be matched by envoyfilter patches
	locality        *core.Locality // identifies the locality the cluster is generated for
	proxyClusterID  string         // identifies the kubernetes cluster a proxy is in
	proxySidecar    bool           // identifies if this proxy is a Sidecar
	hbone           bool

	m.nodes.ShutDown()
}

func (m *Instance) NewNodes(count int, serviceTime time.Duration, enableQueueLatency bool, locality locality.Instance) Nodes {
	out := make(Nodes, 0, count)
	for i := 0; i < count; i++ {
		name := fmt.Sprintf("%s_%d", locality, i)
		out = append(out, newNode(name, serviceTime, enableQueueLatency, locality))
	}

	m.nodes = append(m.nodes, out...)

	return out
}

type Unknown struct{}

// Metadata returns an empty map.
func (*Unknown) Metadata() map[string]string {
	return map[string]string{}
}

// Locality returns an empty core.Locality struct.
func (*Unknown) Locality() *core.Locality {
	return &core.Locality{}
}

// Labels returns an empty map.
func (*Unknown) Labels() map[string]string {
	return map[string]string{}
}

type PrioritySelector func(src *mesh2.Client, dest *mesh2.Node) uint32

func LocalityPrioritySelector(src *mesh2.Client, dest *mesh2.Node) uint32 {
	priority := uint32(2)
	if src.Locality().Region == dest.Locality().Region {
		priority = 1
		if src.Locality().Zone == dest.Locality().Zone {
			priority = 0
		}
	}
	return priority

L1:apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management

issue:
  - 45413

releaseNotes:
  - |
    **Fixed** VirtualMachine Workloadentry auto register failed with invalid `istio-locality` label when user specify `istio-locality` in ./etc/istio/pod/labels....

	}
	if len(networkID) > 0 {
		out[label.TopologyNetwork.Name] = networkID.String()
	}
	return out
}

// SplitLocalityLabel splits a locality label into region, zone and subzone strings.
func SplitLocalityLabel(locality string) (region, zone, subzone string) {
	items := strings.Split(locality, "/")
	switch len(items) {
	case 1:
		return items[0], "", ""
	case 2:
		return items[0], items[1], ""
	default:

	// iterating so that it can be used as the weight for the gateway endpoint
	for _, ep := range endpoints {
		lbEndpoints := &LocalityEndpoints{
			llbEndpoints: endpoint.LocalityLbEndpoints{
				Locality: ep.llbEndpoints.Locality,
				Priority: ep.llbEndpoints.Priority,
				// Endpoints and weight will be reset below.
			},
		}

		// Create a map to keep track of the gateways used and their aggregate weights.

	"istio.io/istio/pkg/test/loadbalancersim/locality"
	"istio.io/istio/pkg/test/loadbalancersim/network"
)

type ClientSettings struct {
	RPS      int
	Locality locality.Instance
}

type Client struct {
	mesh *Instance
	s    ClientSettings
}

func (c *Client) Mesh() *Instance {
	return c.mesh
}

func (c *Client) Locality() locality.Instance {
	return c.s.Locality
}