types

type AddressData struct {
	TargetRef   *apiv1.ObjectReference
	NodeName    *string
	Addresses   []string
	Ready       bool
	AddressType discovery.AddressType
}

type EndpointPodMap map[NetworkEndpoint]types.NamespacedName

type EndpointsCalculatorMode string

type EndpointsData struct {
	Meta  *metav1.ObjectMeta
	Ports []PortData
	// Addresses contains both ready and not ready addresses even when it is converted from Endpoints.
	Addresses []AddressData
}

type FakeNetworkEndpointGroupCloud struct {
	NetworkEndpointGroups map[string][]*composite.NetworkEndpointGroup
	NetworkEndpoints      map[string][]*composite.NetworkEndpoint
	Subnetwork            string
	Network               string
	// contains filtered or unexported fields
}

type NegSyncError struct {
	Err          error
	Reason       Reason
	IsErrorState bool
}

type NegSyncer interface {
	// Start starts the syncer. This call is synchronous. It will return after syncer is started.
	Start() error
	// Stop stops the syncer. This call is asynchronous. It will not block until syncer is stopped.
	Stop()
	// Sync signals the syncer to sync NEG. This call is asynchronous. Syncer will sync once it becomes idle.
	Sync() bool
	// IsStopped returns true if syncer is stopped
	IsStopped() bool
	// IsShuttingDown returns true if syncer is shutting down
	IsShuttingDown() bool
}

type NegSyncerKey struct {
	// Namespace of service
	Namespace string
	// Name of service
	Name string
	// Name of neg
	NegName string
	// PortTuple is the port tuple of the service backing the NEG
	PortTuple SvcPortTuple

	// NegType is the type of the network endpoints in this NEG.
	NegType NetworkEndpointType

	// EpCalculatorMode indicates how the endpoints for the NEG are determined.
	// GCE_VM_IP_PORT NEGs get L7Mode or "".
	// In case of GCE_VM_IP NEGs:
	//   The endpoints are nodes selected at random in case of Cluster trafficPolicy(L4ClusterMode).
	//   The endpoints are nodes running backends of this service in case of Local trafficPolicy(L4LocalMode).
	EpCalculatorMode EndpointsCalculatorMode
}

type NegSyncerManager interface {
	// EnsureSyncer ensures corresponding syncers are started and stops any unnecessary syncer
	// portMap is a map of ServicePort Port to TargetPort. Returns counts of successful Neg syncers
	// and failed Neg syncer creations
	EnsureSyncers(namespace, name string, portMap PortInfoMap) (int, int, error)
	// StopSyncer stops all syncers related to the service. This call is asynchronous. It will not wait for all syncers to stop.
	StopSyncer(namespace, name string)
	// Sync signals all syncers related to the service to sync. This call is asynchronous.
	Sync(namespace, name string)
	// SyncNodes signals all syncers watching nodes to sync. This call is asynchronous.
	SyncNodes()
	// GC garbage collects network endpoint group and syncers
	GC() error
	// ShutDown shuts down the manager
	ShutDown()
}

type NetworkEndpoint struct {
	IP   string
	IPv6 string
	Port string
	Node string
}

type NetworkEndpointEntry struct {
	NetworkEndpoint *composite.NetworkEndpoint
	Healths         []*composite.HealthStatusForNetworkEndpoint
}

type NetworkEndpointGroupCloud interface {
	GetNetworkEndpointGroup(name string, zone string, version meta.Version, logger klog.Logger) (*composite.NetworkEndpointGroup, error)
	ListNetworkEndpointGroup(zone string, version meta.Version, logger klog.Logger) ([]*composite.NetworkEndpointGroup, error)
	AggregatedListNetworkEndpointGroup(version meta.Version, logger klog.Logger) (map[*meta.Key]*composite.NetworkEndpointGroup, error)
	CreateNetworkEndpointGroup(neg *composite.NetworkEndpointGroup, zone string, logger klog.Logger) error
	DeleteNetworkEndpointGroup(name string, zone string, version meta.Version, logger klog.Logger) error
	AttachNetworkEndpoints(name, zone string, endpoints []*composite.NetworkEndpoint, version meta.Version, logger klog.Logger) error
	DetachNetworkEndpoints(name, zone string, endpoints []*composite.NetworkEndpoint, version meta.Version, logger klog.Logger) error
	ListNetworkEndpoints(name, zone string, showHealthStatus bool, version meta.Version, logger klog.Logger) ([]*composite.NetworkEndpointWithHealthStatus, error)
	NetworkURL() string
	SubnetworkURL() string
	NetworkProjectID() string
	Region() string
}

type NetworkEndpointGroupNamer interface {
	NEG(namespace, name string, port int32) string
	IsNEG(name string) bool
}

type NetworkEndpointSet map[NetworkEndpoint]struct{}

type NetworkEndpointStore map[meta.Key][]NetworkEndpointEntry

type NetworkEndpointType string

type NetworkEndpointsCalculator interface {
	// CalculateEndpoints computes the NEG endpoints based on service endpoints and the current NEG state and returns a
	// map of zone name to network endpoint set
	CalculateEndpoints(eds []EndpointsData, currentMap map[string]NetworkEndpointSet) (map[string]NetworkEndpointSet, EndpointPodMap, int, error)
	// CalculateEndpointsDegradedMode computes the NEG endpoints using degraded mode calculation
	CalculateEndpointsDegradedMode(eds []EndpointsData, currentMap map[string]NetworkEndpointSet) (map[string]NetworkEndpointSet, EndpointPodMap, error)
	// Mode indicates the mode that the EndpointsCalculator is operating in.
	Mode() EndpointsCalculatorMode
	// ValidateEndpoints validates the NEG endpoint information is correct
	ValidateEndpoints(endpointData []EndpointsData, endpointPodMap EndpointPodMap, dupCount int) error
}

type PortData struct {
	Name string
	Port int32
}

type PortInfo struct {
	// PortTuple is port tuple of a service.
	PortTuple SvcPortTuple

	// NegName is the name of the NEG
	NegName string
	// ReadinessGate indicates if the NEG associated with the port has NEG readiness gate enabled
	// This is enabled with service port is reference by ingress.
	// If the service port is only exposed as stand alone NEG, it should not be enabled.
	ReadinessGate bool
	// EpCalculatorMode indicates if the endpoints for the NEG associated with this port need to
	// be selected at random(L4ClusterMode), or by following service endpoints(L4LocalMode).
	// This is applicable in GCE_VM_IP NEGs where the endpoints are the nodes instead of pods.
	// L7 NEGs will have either "" or L7Mode.
	EpCalculatorMode EndpointsCalculatorMode
	// NetworkInfo specifies the network (K8s and VPC) and subnetwork the service port belongs to.
	NetworkInfo network.NetworkInfo
}

type PortInfoMap map[PortInfoMapKey]PortInfo

type PortInfoMapKey struct {
	// ServicePort is the service port
	ServicePort int32
}

type Reason string

type State string

type StateCountMap map[State]int

type StrategyQuotaError struct {
	Err error
}

type SvcPortTuple struct {
	// Port is the service port number
	Port int32
	// Name is the service port name
	Name string
	// TargetPort is the service target port.
	// This can be a port number or named port
	TargetPort string
}

type SvcPortTupleSet map[SvcPortTuple]struct{}

type TestContext struct {
	KubeClient   kubernetes.Interface
	SvcNegClient svcnegclient.Interface
	Cloud        *gce.Cloud

	NegNamer NetworkEndpointGroupNamer
	L4Namer  namer.L4ResourcesNamer

	IngressInformer            cache.SharedIndexInformer
	PodInformer                cache.SharedIndexInformer
	ServiceInformer            cache.SharedIndexInformer
	NodeInformer               cache.SharedIndexInformer
	EndpointInformer           cache.SharedIndexInformer
	EndpointSliceInformer      cache.SharedIndexInformer
	SvcNegInformer             cache.SharedIndexInformer
	NetworkInformer            cache.SharedIndexInformer
	GKENetworkParamSetInformer cache.SharedIndexInformer

	KubeSystemUID      types.UID
	ResyncPeriod       time.Duration
	NumGCWorkers       int
	EnableDualStackNEG bool
}