"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

		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,

				if includeConfigType {
					addr = fmt.Sprintf("endpoint/%s", addr)
				}
				fmt.Fprintf(w, "%v\t%v\t%v\t%v\n",
					addr,
					ep.GetHealthStatus().String(),
					util.LocalityToString(llb.Locality),
					eds.ClusterName,
				)
			}
		}
	}

	return w.Flush()
}

func (c *ConfigWriter) retrieveSortedEndpointsSlice(filter EndpointFilter) ([]*endpoint.ClusterLoadAssignment, error) {

		t.Run(v.name, func(tt *testing.T) {
			server, url := setupHTTPServer(v.handlers)
			defer server.Close()
			awsMetadataIPv4URL = url.String()
			locality := NewAWS(false).Locality()
			if !reflect.DeepEqual(locality, v.want) {
				t.Errorf("unexpected locality. want :%v, got :%v", v.want, locality)
			}
		})
	}
}

func TestIsAWS(t *testing.T) {
	cases := []struct {
		name     string
		handlers map[string]handlerFunc

				},
				Metadata: &model.NodeMetadata{
					Labels: labels.Instance{
						"k1":                       "v1",
						label.TopologyNetwork.Name: "mynetwork",
					},
				},
				Locality: &core.Locality{
					Region: "myregion",
				},
			},
			expected: labels.Instance{
				"k1":                       "v1",
				NodeRegionLabelGA:          "myregion",
				label.TopologyNetwork.Name: "mynetwork",

{{- if ne $.Locality "" }}
      istio-locality: {{ $.Locality }}
{{- end }}
  template:
    metadata:
      labels:
        app: {{ $.Service }}
        version: {{ $subset.Version }}
        test.istio.io/class: {{ $.WorkloadClass }}
{{- if $.Compatibility }}
        istio.io/rev: {{ $revision }}
{{- end }}
{{- if ne $.Locality "" }}
        istio-locality: {{ $.Locality }}
{{- end }}