// that match less (or, eventually, none) preferences.
    // For instance, with `[NETWORK, REGION, ZONE]`, we will send to:
    // 1. Endpoints matching `[NETWORK, REGION, ZONE]`
    // 2. Endpoints matching `[NETWORK, REGION]`
    // 3. Endpoints matching `[NETWORK]`
    // 4. Any endpoints
    FAILOVER = 2;
  }

	clusterEndpoint = retrieveSortedEndpointClusterSlice(clusterEndpoint)
	fmt.Fprintln(w, "ENDPOINT\tSTATUS\tOUTLIER CHECK\tCLUSTER")
	for _, ce := range clusterEndpoint {
		var endpoint string
		if ce.port != 0 {
			endpoint = ce.address + ":" + strconv.Itoa(ce.port)
		} else {
			endpoint = ce.address
		}

			continue
		}

		// only add the interface for each container if not already in the list
		for _, cId := range endpoint.SharedContainers {
			networkStat, found := networkStats[cId]
			if found && networkStat.Name != endpoint.Name {
				iStat := hcsStatToInterfaceStat(endpointStats, endpoint.Name)

		healthStatus = model.Draining
	}

	ep := &endpoint.LbEndpoint{
		HealthStatus: corev3.HealthStatus(healthStatus),
		LoadBalancingWeight: &wrapperspb.UInt32Value{
			Value: e.GetLoadBalancingWeight(),
		},
		HostIdentifier: &endpoint.LbEndpoint_Endpoint{
			Endpoint: &endpoint.Endpoint{
				Address: addr,
			},
		},
		Metadata: &corev3.Metadata{},
	}

John Howard <******@****.***> 1683594068 -0700

                  traffic that goes from a workload endpoint to the host itself (after
                  the traffic hits the endpoint egress policy). By default Calico
                  blocks traffic from workload endpoints to the host itself with an
                  iptables "DROP" action. If you want to allow some or all traffic
                  from endpoint to host, set this parameter to RETURN or ACCEPT. Use

// returned.
func (adapter *EndpointsAdapter) Create(namespace string, endpoints *corev1.Endpoints) (*corev1.Endpoints, error) {
	endpoints, err := adapter.endpointClient.Endpoints(namespace).Create(context.TODO(), endpoints, metav1.CreateOptions{})
	if err == nil {
		err = adapter.EnsureEndpointSliceFromEndpoints(namespace, endpoints)
	}
	return endpoints, err
}

	endpointsNN := types.NamespacedName{Name: endpoints.Name, Namespace: endpoints.Namespace}
	r.metricsCache.UpdateEndpointPortCache(endpointsNN, epMetrics)

	return r.finalize(endpoints, slices)
}

// reconcileByPortMapping compares the endpoints found in existing slices with
// the list of desired endpoints and returns lists of slices to create, update,
// and delete.

					Namespace:       endpoints.Namespace,
					OwnerReferences: []metav1.OwnerReference{*ownerRef},
				},
				Ports:       ports,
				AddressType: addrType,
				Endpoints:   []discovery.Endpoint{},
			},
		},
		{
			name: "create slice from endpoints with annotations",
			tweakEndpoint: func(ep *v1.Endpoints) {
				annotations := map[string]string{"foo": "bar"}
				ep.Annotations = annotations
			},

		testName: "Endpoints with skip-mirror=true",
		endpoints: &v1.Endpoints{
			ObjectMeta: metav1.ObjectMeta{
				Name: "test-endpoints",
				Labels: map[string]string{
					discovery.LabelSkipMirror: "true",
				},
			},
		},
		shouldMirror: false,
	}, {
		testName: "Endpoints with skip-mirror=invalid",
		endpoints: &v1.Endpoints{
			ObjectMeta: metav1.ObjectMeta{
				Name: "test-endpoints",