}

	return istioService
}

func ExternalNameEndpoints(svc *model.Service) []*model.IstioEndpoint {
	if svc.Attributes.ExternalName == "" {
		return nil
	}
	out := make([]*model.IstioEndpoint, 0, len(svc.Ports))

	discoverabilityPolicy := model.AlwaysDiscoverable
	if features.EnableMCSServiceDiscovery {

			g := NewWithT(t)

			view := (&model.Proxy{
				Metadata: &model.NodeMetadata{
					RequestedNetworkView: c.networkView,
				},
			}).GetView()

			actual := view.IsVisible(&model.IstioEndpoint{
				Network: network.ID(c.network),
			})

			g.Expect(actual).To(Equal(c.visible))
		})
	}

	ds := xds.NewFakeDiscoveryServer(t, xds.FakeOptions{})
	sd := ds.MemRegistry
	sd.AddHTTPService("fortio1.fortio.svc.cluster.local", "10.10.10.1", 8081)
	sd.SetEndpoints("fortio1.fortio.svc.cluster.local", "", []*model.IstioEndpoint{
		{
			Address:         "127.0.0.1",
			EndpointPort:    uint32(14056),
			ServicePortName: "http-main",
		},
	})
	return ds
}

// on the DR, original endpoint TLSMode (based on injection of sidecar), and PeerAuthentication settings.
func (c *mtlsChecker) checkMtlsEnabled(ep *model.IstioEndpoint, isWaypoint bool) bool {
	if drMode := c.destinationRule; drMode != nil {
		return *drMode == networkingapi.ClientTLSSettings_ISTIO_MUTUAL
	}

		return nil
	}

	// we make port 80 same as endpoint port, otherwise, it's distinct
	target := port.Port
	if target != 80 {
		target += 1000
	}

	return &model.ServiceInstance{
		Endpoint: &model.IstioEndpoint{
			Address:         MakeIP(service, version),
			EndpointPort:    uint32(target),
			ServicePortName: port.Name,
			Labels:          map[string]string{"version": fmt.Sprintf("v%d", version)},
			Locality:        locality,

}

func (gc GatewayContext) GetService(hostname, namespace string) *model.Service {
	return gc.ps.ServiceIndex.HostnameAndNamespace[host.Name(hostname)][namespace]
}

func instancesEmpty(m map[int][]*model.IstioEndpoint) bool {
	for _, instances := range m {
		if len(instances) > 0 {
			return false
		}
	}
	return true