connector

type AgentCheck struct {
	CheckID   string
	ServiceID string
	Name      string
	Namespace string
	Type      string
	Status    string
	Output    string
}

type AgentService struct {
	ID           string
	InstanceId   string
	ClusterId    string
	MicroService MicroService
	Weights      AgentWeights
	Ports        map[MicroServicePort]MicroServicePort
	Tags         []string
	Meta         map[string]interface{}

	GRPCInterface    string
	GRPCMethods      []string
	GRPCInstanceMeta map[string]interface{}

	HealthCheck bool
}

type AgentWeights struct {
	Passing int
	Warning int
}

type Backgrounder interface {
	Run(<-chan struct{})
}

type C2KContext struct {

	// EndpointsKeyToName maps from Kube controller keys to Kube endpoints names.
	// Controller keys are in the form <kube namespace>/<kube endpoints name>
	// e.g. default/foo, and are the keys Kube uses to inform that something
	// changed.
	EndpointsKeyToName map[string]string

	// SourceServices maps from k8s service name to cloud service name.
	// Holds all services extended by prefix and suffix that should be synced to Kube.
	SourceServices map[KubeSvcName]CloudSvcName

	// NativeServices maps from k8s service name to cloud service name.
	// Holds native services without extended by prefix and suffix.
	NativeServices map[KubeSvcName]CloudSvcName

	// CatalogServices holds catalog services
	CatalogServices     []ctv1.NamespacedService
	CatalogServicesHash uint64

	// holds all Kube service
	KubeServiceCache map[KubeSvcKey]*corev1.Service

	// SyncedKubeServiceCache holds all Kube services that were created by this sync process. Keys are Kube service names.
	SyncedKubeServiceCache map[KubeSvcName]*corev1.Service
	SyncedKubeServiceHash  map[KubeSvcName]uint64
}

type CacheController struct {
	Resource Resource
	// contains filtered or unexported fields
}

type CatalogDeregistration struct {
	ctv1.NamespacedService

	Node       string
	ServiceID  string
	ServiceRef string
}

type CatalogRegistration struct {
	Node           string
	Address        string
	NodeMeta       map[string]string
	Service        *AgentService
	Check          *AgentCheck
	SkipNodeUpdate bool
}

type CatalogService struct {
	Node        string
	ServiceID   string
	ServiceName string
	ServiceRef  string
}

type CloudSvcName string

type ConnectController interface {
	BroadcastListener(stopCh <-chan struct{})

	GetConnectorProvider() ctv1.DiscoveryServiceProvider
	GetConnectorNamespace() string
	GetConnectorName() string
	GetConnectorUID() string

	GetConsulConnector(namespace, name string) *ctv1.ConsulConnector
	GetEurekaConnector(namespace, name string) *ctv1.EurekaConnector
	GetNacosConnector(namespace, name string) *ctv1.NacosConnector
	GetZookeeperConnector(namespace, name string) *ctv1.ZookeeperConnector
	GetMachineConnector(namespace, name string) *ctv1.MachineConnector
	GetGatewayConnector(namespace, name string) *ctv1.GatewayConnector
	GetConnector() (connector, spec interface{}, uid string, ok bool)

	Refresh()

	WaitLimiter()

	GetSyncPeriod() time.Duration

	GetC2KContext() *C2KContext
	GetK2CContext() *K2CContext
	GetK2GContext() *K2GContext

	GetClusterSet() string
	SetClusterSet(name, group, zone, region string)

	SetServiceInstanceIDFunc(f ServiceInstanceIDFunc)
	GetServiceInstanceID(name, addr string, port MicroServicePort, protocol MicroServiceProtocol) string

	GetClusterId() string
	GetPassingOnly() bool
	GetC2KFilterTag() string
	GetC2KFilterMetadatas() []ctv1.Metadata
	GetC2KExcludeMetadatas() []ctv1.Metadata
	GetC2KFilterIPRanges() []*cidr.CIDR
	GetC2KExcludeIPRanges() []*cidr.CIDR
	GetK2CFilterIPRanges() []*cidr.CIDR
	GetK2CExcludeIPRanges() []*cidr.CIDR
	GetPrefixTag() string
	GetSuffixTag() string
	GetPrefixMetadata() string
	GetSuffixMetadata() string

	GetC2KFixedHTTPServicePort() *uint32

	GetC2KAppendLabels() map[string]string
	GetC2KAppendAnnotations() map[string]string

	EnableC2KTagStrategy() bool
	GetC2KTagToLabelConversions() map[string]string
	GetC2KTagToAnnotationConversions() map[string]string

	EnableC2KMetadataStrategy() bool
	GetC2KMetadataToLabelConversions() map[string]string
	GetC2KMetadataToAnnotationConversions() map[string]string

	EnableC2KConversions() bool
	GetC2KServiceConversions() map[string]ctv1.ServiceConversion

	GetC2KWithGateway() bool
	GetC2KMultiGateways() bool

	GetNacos2KClusterSet() []string
	GetNacos2KGroupSet() []string

	GetK2CDefaultSync() bool
	GetK2CSyncClusterIPServices() bool
	GetK2CSyncLoadBalancerEndpoints() bool
	GetK2CNodePortSyncType() ctv1.NodePortSyncType

	GetK2CSyncIngress() bool
	GetK2CSyncIngressLoadBalancerIPs() bool

	GetK2CAddServicePrefix() string
	GetK2CAddK8SNamespaceAsServiceSuffix() bool

	GetK2CAppendTagSet() mapset.Set
	GetK2CAppendMetadataSet() mapset.Set

	EnableK2CTagStrategy() bool
	GetK2CTagToLabelConversions() map[string]string
	GetK2CTagToAnnotationConversions() map[string]string

	EnableK2CMetadataStrategy() bool
	GetK2CMetadataToLabelConversions() map[string]string
	GetK2CMetadataToAnnotationConversions() map[string]string

	GetK2CAllowK8SNamespaceSet() mapset.Set
	GetK2CDenyK8SNamespaceSet() mapset.Set

	GetK2CWithGateway() bool
	GetK2CWithGatewayMode() ctv1.WithGatewayMode

	GetConsulNodeName() string
	GetConsulEnableNamespaces() bool
	GetConsulDestinationNamespace() string
	GetConsulEnableK8SNSMirroring() bool
	GetConsulK8SNSMirroringPrefix() string
	GetConsulCrossNamespaceACLPolicy() string
	GetConsulGenerateInternalServiceHealthCheck() bool

	GetEurekaHeartBeatInstance() bool
	GetEurekaHeartBeatPeriod() time.Duration
	GetEurekaCheckServiceInstanceID() bool

	GetNacosGroupId() string
	GetNacosClusterId() string

	GetZookeeperBasePath() string
	GetZookeeperCategory() string
	GetZookeeperAdaptor() string

	GetK2GDefaultSync() bool
	GetK2GAllowK8SNamespaceSet() mapset.Set
	GetK2GDenyK8SNamespaceSet() mapset.Set

	GetViaIngressIPSelector() ctv1.AddrSelector
	GetViaEgressIPSelector() ctv1.AddrSelector

	GetViaIngressAddr() string
	SetViaIngressAddr(ingressAddr string)

	GetViaEgressAddr() string
	SetViaEgressAddr(egressAddr string)

	GetViaIngressHTTPPort() uint
	SetViaIngressHTTPPort(httpPort uint)

	GetViaIngressGRPCPort() uint
	SetViaIngressGRPCPort(grpcPort uint)

	GetViaEgressHTTPPort() uint
	SetViaEgressHTTPPort(httpPort uint)

	GetViaEgressGRPCPort() uint
	SetViaEgressGRPCPort(grpcPort uint)

	GetAuthConsulUsername() string
	GetAuthConsulPassword() string

	GetAuthNacosUsername() string
	GetAuthNacosPassword() string
	GetAuthNacosAccessKey() string
	GetAuthNacosSecretKey() string
	GetAuthNacosNamespaceId() string
	GetAuthNacosTokenTtl() time.Duration

	SyncCloudToK8s() bool
	SyncK8sToCloud() bool
	SyncK8sToGateway() bool

	GetHTTPAddr() string
	GetDeriveNamespace() string
	Purge() bool
	AsInternalServices() bool

	CacheCatalogInstances(key string, catalogFunc func() (interface{}, error)) (interface{}, error)
	CacheRegisterInstance(key string, instance interface{}, registerFunc func() error) error
	CacheDeregisterInstance(key string, deregisterFunc func() error) error
	CacheCleaner(stopCh <-chan struct{})
}

type Event struct {
	// Key is in the form of <namespace>/<name>, e.g. default/pod-abc123,
	// and corresponds to the resource modified.
	Key string
	// Obj holds the resource that was modified at the time of the event
	// occurring. If possible, the resource should be retrieved from the informer
	// cache, instead of using this field because the cache will be more up to
	// date at the time the event is processed.
	// In some cases, such as a delete event, the resource will no longer exist
	// in the cache and then it is useful to have the resource here.
	Obj interface{}
}

type GRPCMeta struct {
	Interface string              `json:"interface,omitempty"`
	Methods   map[string][]string `json:"methods,omitempty"`
}

type K2CContext struct {

	// ServiceMap holds services we should sync to cloud. Keys are the
	// in the form <kube namespace>/<kube svc name>.
	ServiceMap chm.ConcurrentMap[string, *corev1.Service]

	// EndpointsMap uses the same keys as serviceMap but maps to the endpoints
	// of each service.
	EndpointsMap chm.ConcurrentMap[string, *corev1.Endpoints]

	// IngressServiceMap uses the same keys as serviceMap but maps to the ingress
	// of each service if it exists.
	IngressServiceMap chm.ConcurrentMap[string, chm.ConcurrentMap[string, string]]

	// ServiceHostnameMap maps the name of a service to the hostName and port that
	// is provided by the Ingress resource for the service.
	ServiceHostnameMap chm.ConcurrentMap[string, ServiceAddress]

	// registeredServiceMap holds the services in cloud that we've registered from kube.
	// It's populated via cloud's API and lets us diff what is actually in
	// cloud vs. what we expect to be there.
	RegisteredServiceMap chm.ConcurrentMap[string, []*CatalogRegistration]

	// ServiceNames is all namespaces mapped to a set of valid cloud service names
	ServiceNames chm.ConcurrentMap[string, mapset.Set]

	// Namespaces is all namespaces mapped to a map of cloud service ids mapped to their CatalogRegistrations
	Namespaces chm.ConcurrentMap[string, chm.ConcurrentMap[string, *CatalogRegistration]]

	//deregistrations
	Deregs chm.ConcurrentMap[string, *CatalogDeregistration]

	// Watchers is all namespaces mapped to a map of cloud service
	// names mapped to a cancel function for watcher routines
	Watchers chm.ConcurrentMap[string, chm.ConcurrentMap[string, context.CancelFunc]]
}

type K2GContext struct {

	// ServiceMap holds services we should sync to gateway. Keys are the
	// in the form <kube namespace>/<kube svc name>.
	ServiceMap map[string]*corev1.Service

	//
	// Syncer Context
	//
	Services map[string]*corev1.Service
	Deregs   map[string]*corev1.Service
}

type KubeSvcKey string

type KubeSvcName string

type MicroEndpointMeta struct {
	Ports   map[MicroServicePort]MicroServiceProtocol `json:"ports,omitempty"`
	Address MicroServiceAddress                       `json:"address,omitempty"`

	GRPCMeta map[string]interface{} `json:"grpcMeta,omitempty"`

	Native struct {
		ClusterSet     string               `json:"clusterSet,omitempty"`
		ClusterId      string               `json:"clusterId,omitempty"`
		ViaGatewayHTTP string               `json:"viaGatewayHttp,omitempty"`
		ViaGatewayGRPC string               `json:"viaGatewayGrpc,omitempty"`
		ViaGatewayMode ctv1.WithGatewayMode `json:"viaGatewayMode,omitempty"`
	} `json:"native"`
	Local struct {
		InternalService   bool                                      `json:"internalService,omitempty"`
		WithGateway       bool                                      `json:"withGateway,omitempty"`
		WithMultiGateways bool                                      `json:"withMultiGateways,omitempty"`
		BindFgwPorts      map[MicroServicePort]MicroServiceProtocol `json:"bindFgwPorts,omitempty"`
	} `json:"local"`
}

type MicroService struct {
	ctv1.NamespacedService
	// contains filtered or unexported fields
}

type MicroServiceAddress string

type MicroServiceEndpoint struct {
	// contains filtered or unexported fields
}

type MicroServicePort int32

type MicroServiceProtocol string

type MicroServiceVia struct {
	// contains filtered or unexported fields
}

type MicroSvcMeta struct {
	Ports       map[MicroServicePort]MicroServicePort      `json:"-"`
	TargetPorts map[MicroServicePort]MicroServiceProtocol  `json:"ports,omitempty"`
	Endpoints   map[MicroServiceAddress]*MicroEndpointMeta `json:"endpoints,omitempty"`

	GRPCMeta *GRPCMeta `json:"grpcMeta,omitempty"`

	HealthCheck bool `json:"healthcheck,omitempty"`
}

type QueryOptions struct {
	// AllowStale allows any Consul server (non-leader) to service
	// a read. This allows for lower latency and higher throughput
	AllowStale bool

	// Namespace overrides the `default` namespace
	// Note: Namespaces are available only in Consul Enterprise
	Namespace string

	// WaitIndex is used to enable a blocking query. Waits
	// until the timeout or the next index is reached
	WaitIndex uint64

	// WaitTime is used to bound the duration of a wait.
	// Defaults to that of the Config, but can be overridden.
	WaitTime time.Duration

	// Providing a peer name in the query option
	Peer string

	// Filter requests filtering data prior to it being returned. The string
	// is a go-bexpr compatible expression.
	Filter string
	// contains filtered or unexported fields
}

type Resource interface {
	// Informer returns the SharedIndexInformer that the controller will
	// use to watch for changes. An Informer is the long-running task that
	// holds blocking queries to K8S and stores data in a local store.
	Informer() cache.SharedIndexInformer

	// Upsert is the callback called when processing the queue
	// of changes from the Informer. If an error is returned, the given item
	// will be retried.
	Upsert(key string, obj interface{}) error
	// Delete is called on object deletion.
	// obj is the last known state of the object before deletion. In some
	// cases, it may not be up to date with the latest state of the object.
	// If an error is returned, the given item will be retried.
	Delete(key string, obj interface{}) error
}

type ResourceDeleteFunc func(string, interface{}) error

type ResourceUpsertFunc func(string, interface{}) error

type ServiceAddress struct {
	HostName string
	Port     int32
}

type ServiceConversion struct {
	Service CloudSvcName
}

type ServiceDiscoveryClient interface {
	CatalogServices(q *QueryOptions) ([]ctv1.NamespacedService, error)
	CatalogInstances(service string, q *QueryOptions) ([]*AgentService, error)
	RegisteredInstances(service string, q *QueryOptions) ([]*CatalogService, error)
	RegisteredServices(q *QueryOptions) ([]ctv1.NamespacedService, error)
	Register(reg *CatalogRegistration) error
	Deregister(dereg *CatalogDeregistration) error
	EnableNamespaces() bool
	EnsureNamespaceExists(ns string) (bool, error)
	RegisteredNamespace(kubeNS string) string
	MicroServiceProvider() ctv1.DiscoveryServiceProvider
	IsInternalServices() bool
	Close()
}

type ServiceInstanceIDFunc func(name, addr string, port MicroServicePort, protocol MicroServiceProtocol) string