}
	return ""
}

// ConvertLocality converts '/' separated locality string to Locality struct.
func ConvertLocality(locality string) *core.Locality {
	if locality == "" {
		return &core.Locality{}
	}

	region, zone, subzone := label.SplitLocalityLabel(locality)
	return &core.Locality{
		Region:  region,
		Zone:    zone,
		SubZone: subzone,
	}
}

		"region2/zone2/subzone2",
	}
	for i, locality := range localities {
		_, _ = i, locality
		m.AddInstance(&model.ServiceInstance{
			Service: svc,
			Endpoint: &model.IstioEndpoint{
				Address:         fmt.Sprintf("10.0.0.%v", i),
				EndpointPort:    80,
				ServicePortName: "http",
				Locality:        model.Locality{Label: locality},
			},
			ServicePort: &model.Port{

		return hosts[i].Name < hosts[j].Name
	})
}

// ConvertLocality converts '/' separated locality string to Locality struct.
func ConvertLocality(locality string) *core.Locality {
	return pm.ConvertLocality(locality)
}

// LocalityToString converts Locality struct to '/' separated locality string.
func LocalityToString(l *core.Locality) string {
	if l == nil {
		return ""
	}
	resp := l.Region
	if l.Zone == "" {

		if err != nil {
			return
		}

		loadAssignment := &endpoint.ClusterLoadAssignment{}
		err = ff.GenerateStruct(loadAssignment)
		if err != nil {
			return
		}

		locality := &core.Locality{}
		err = ff.GenerateStruct(locality)
		if err != nil {
			return
		}

		localityLB := &v1alpha3.LocalityLoadBalancerSetting{}
		err = ff.GenerateStruct(localityLB)
		if err != nil {
			return
		}

				return fmt.Errorf("locality %s wildcard '*' number can not exceed 1 and must be in the end", locality)
			}
		}
		if _, exist := regionZoneSubZoneMap["*"]; exist {
			return fmt.Errorf("locality %s overlap with previous specified ones", locality)
		}

		region, zone, subZone, localityIndex, err := getLocalityParam(locality)
		if err != nil {

	}
	networkID := s.workloadEntryNetwork(wle)
	locality := wle.Locality
	if locality == "" && len(wle.Labels[model.LocalityLabel]) > 0 {
		locality = model.GetLocalityLabel(wle.Labels[model.LocalityLabel])
	}
	labels := labelutil.AugmentLabels(wle.Labels, clusterID, locality, "", networkID)
	return &model.ServiceInstance{
		Endpoint: &model.IstioEndpoint{
			Address:         addr,

            IssueLocality locality, RepositorySystemSession session, Artifact pluginArtifact, String issue);

    /**
     * Reports plugin issues applicable to the plugin as a whole.
     * <p>
     * This method will record extra information as well, like plugin occurrence or declaration location.
     */
    void reportPluginValidationIssue(

        pluginIssues.reportPluginIssue(locality, null, issue);
        mayReportInline(session, locality, issue);
    }

    @Override
    public void reportPluginValidationIssue(
            IssueLocality locality, MavenSession mavenSession, MojoDescriptor mojoDescriptor, String issue) {
        String pluginKey = pluginKey(mojoDescriptor);

		proxy.Locality = &core.Locality{
			Region:  proxy.XdsNode.Locality.GetRegion(),
			Zone:    proxy.XdsNode.Locality.GetZone(),
			SubZone: proxy.XdsNode.Locality.GetSubZone(),
		}
	}
	// add topology labels to proxy labels
	proxy.Labels = labelutil.AugmentLabels(
		proxy.Labels,
		proxy.Metadata.ClusterID,
		util.LocalityToString(proxy.Locality),
		proxy.GetNodeName(),

	if aid := e.azureVMID(); aid != "" {
		md[e.prefixName("vmId")] = aid
	}
	for k, v := range e.azureTags() {
		md[k] = v
	}
	return md
}

// Locality returns the region and zone
func (e *azureEnv) Locality() *core.Locality {
	var l core.Locality
	l.Region = e.azureLocation()
	l.Zone = e.azureZone()
	return &l
}

func (e *azureEnv) Labels() map[string]string {
	return map[string]string{}
}