service

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

type CancelManaging interface {
	Add(rootCtx context.Context, id string, reqID int64) context.Context
	Delete(id string, reqID int64) bool
}

type Event struct {
	Type         EventType
	ID           string
	TimeNano     int64
	ConsultCache bool
}

type EventType string

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

type NodeCacher interface {
	InsertAndCheck(n NodeMini) bool
	IsNewOrUpdated(n NodeMini) bool
	Delete(ID string)
	Get(ID string) (NodeMini, bool)
	Keys() map[string]struct{}
}

type NodeClient struct {
	DockerClient *client.Client
}

type NodeIP struct {
	Name string `json:"name"`
	Addr string `json:"addr"`
	ID   string `json:"id"`
}

type NodeIPSet map[NodeIP]struct{}

type NodeInspector interface {
	NodeInspect(nodeID string) (swarm.Node, error)
	NodeList(ctx context.Context) ([]swarm.Node, error)
}

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

type NodeListening interface {
	ListenForNodeEvents(eventChan chan<- Event)
}

type NodeMini struct {
	ID           string
	Hostname     string
	VersionIndex uint64
	State        swarm.NodeState
	Addr         string
	NodeLabels   map[string]string
	EngineLabels map[string]string
	Role         swarm.NodeRole
	Availability swarm.NodeAvailability
}

type NodePoller struct {
	Client          NodeInspector
	Cache           NodeCacher
	PollingInterval int
	MinifyFunc      func(swarm.Node) NodeMini
	Log             *log.Logger
}

type NodePolling interface {
	Run(eventChan chan<- Event)
}

type Notification struct {
	EventType  EventType
	ID         string
	Parameters string
	TimeNano   int64
	Context    context.Context
	ErrorChan  chan error
}

type NotificationSender interface {
	Create(ctx context.Context, params string) error
	Remove(ctx context.Context, params string) error
	GetCreateAddr() string
	GetRemoveAddr() string
}

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

type NotifyDistributing interface {
	Run(serviceChan <-chan Notification, nodeChan <-chan Notification)
	HasServiceListeners() bool
	HasNodeListeners() bool
}

type NotifyDistributor struct {
	NotifyEndpoints      map[string]NotifyEndpoint
	ServiceCancelManager CancelManaging
	NodeCancelManager    CancelManaging
	// contains filtered or unexported fields
}

type NotifyEndpoint struct {
	ServiceNotifier NotificationSender
	NodeNotifier    NotificationSender
}

type NotifyType string

type SwarmListener struct {
	SSListener SwarmServiceListening
	SSClient   SwarmServiceInspector
	SSCache    SwarmServiceCacher
	SSPoller   SwarmServicePolling

	SSEventChan         chan Event
	SSNotificationChan  chan Notification
	SSInternalEventChan chan Event

	NodeListener NodeListening
	NodeClient   NodeInspector
	NodeCache    NodeCacher
	NodePoller   NodePolling

	NodeEventChan        chan Event
	NodeNotificationChan chan Notification
	NodeInteralEventChan chan Event

	NotifyDistributor NotifyDistributing

	ServiceCancelManager           CancelManaging
	NodeCancelManager              CancelManaging
	IncludeNodeInfo                bool
	UseDockerServiceEvents         bool
	UseDockerNodeEvents            bool
	NotifyCreateServiceImmediately bool
	IgnoreKey                      string
	IncludeKey                     string
	HasServiceListeners            bool
	HasNodeListeners               bool
	Log                            *log.Logger

	StopServiceEventChan chan struct{}
	StopNodeEventChan    chan struct{}
}

type SwarmListening interface {
	Run()
	NotifyServices(consultCache bool)
	NotifyNodes(consultCache bool)
	GetServicesParameters(ctx context.Context) ([]map[string]string, error)
	GetNodesParameters(ctx context.Context) ([]map[string]string, error)
}

type SwarmService struct {
	swarm.Service
	NodeInfo NodeIPSet
}

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

type SwarmServiceCacher interface {
	InsertAndCheck(ss SwarmServiceMini) bool
	IsNewOrUpdated(ss SwarmServiceMini) bool
	Delete(ID string)
	Get(ID string) (SwarmServiceMini, bool)
	Len() int
	Keys() map[string]struct{}
}

type SwarmServiceClient struct {
	DockerClient                 *client.Client
	FilterLabel                  string
	FilterKey                    string
	ScrapeNetLabel               string
	ServiceNamePrefix            string
	IncludeTaskAddressInNodeInfo bool
	Log                          *log.Logger
}

type SwarmServiceInspector interface {
	SwarmServiceInspect(ctx context.Context, serviceID string) (*SwarmService, error)
	SwarmServiceList(ctx context.Context) ([]SwarmService, error)
	GetNodeInfo(ctx context.Context, ss SwarmService) (NodeIPSet, error)
	SwarmServiceRunning(ctx context.Context, serviceID string) (bool, error)
}

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

type SwarmServiceListening interface {
	ListenForServiceEvents(chan<- Event)
}

type SwarmServiceMini struct {
	ID             string
	Name           string
	Labels         map[string]string
	Global         bool
	Replicas       uint64
	ContainerImage string
	NodeInfo       NodeIPSet
}

type SwarmServicePoller struct {
	SSClient        SwarmServiceInspector
	SSCache         SwarmServiceCacher
	PollingInterval int
	IncludeNodeInfo bool
	MinifyFunc      func(SwarmService) SwarmServiceMini
	Log             *log.Logger
}

type SwarmServicePolling interface {
	Run(eventChan chan<- Event)
}