services

type Aggregator interface {
	Run(ctx context.Context)
	Close() error
	Stats() cxoaggregate.Stats
	Ingest(r *cxoregistry.Root)
}

type AggregatorState struct {
	// Name says what the visors publish on this port.
	Name string `json:"name"`
	Port uint16 `json:"port"`
	// Shared is true when the aggregator runs on the host visor's own
	// publisher node for this port instead of a node of its own.
	Shared bool `json:"shared"`
	// Conns are the visor connections on the node; Subscribed of them
	// carry a subscription to the visor's feed.
	Conns      int `json:"conns"`
	Subscribed int `json:"subscribed"`
	// Feeds held in the node's store, the host's own included.
	Feeds int `json:"feeds"`
	// LocalRoots counts Roots taken from the host's own publisher.
	LocalRoots uint64 `json:"local_roots,omitempty"`
	// Consumers are the services in this process taking registrations off the
	// visors' system feeds through this aggregator; Delivered counts handoffs.
	Consumers []string `json:"consumers,omitempty"`
	Delivered uint64   `json:"delivered,omitempty"`
	// Error is why the aggregator is not running, if it is not.
	Error string `json:"error,omitempty"`
}

type Block struct {
	Type string
	Name string
	Raw  json.RawMessage

	// LogLevel is the block's optional "log_level", read here so the
	// supervisor can pick a shared level for the library packages
	// before any service is built. Each factory still reads its own.
	LogLevel string
}

type CXOAggregating interface {
	AggregatorPorts() []uint16
}

type CXOHost interface {
	// CXONode returns the host's node listening on port, or nil when the
	// host publishes nothing there.
	CXONode(port uint16) *node.Node
	// OnLocalRoot registers fn to receive every Root the host publishes
	// on port, starting with the current one.
	OnLocalRoot(port uint16, fn func(*cxoregistry.Root))
}

type CXOSet struct {
	// Stats, when set, names each feed's port on the status page.
	Stats interface {
		NamePort(port uint16, name string)
	}
	// contains filtered or unexported fields
}

type ChartsPager interface {
	ChartsPage() *charts.Page
}

type Common struct {
	// PubKey and SecKey are the service's dmsg identity. A service
	// embedded in a visor uses the visor's instead.
	PubKey cipher.PubKey `json:"public_key,omitempty"`
	SecKey cipher.SecKey `json:"secret_key,omitempty"`

	// Addr is the plain-HTTP listen address.
	Addr string `json:"addr,omitempty"`
	// Mode selects the listeners: "http", "dmsg" or "dual"
	// (see pkg/services/svcmode).
	Mode string `json:"mode,omitempty"`
	// DmsgPort is the dmsghttp listener port (default 80).
	DmsgPort uint16 `json:"dmsg_port,omitempty"`

	// Redis is the redis URL of the service's store. With Testing and no
	// URL, the store is in memory.
	Redis string `json:"redis,omitempty"`
	// RedisPoolSize is the redis connection pool size (default 10).
	RedisPoolSize int `json:"redis_pool_size,omitempty"`
	// EntryTimeout is how long an entry lives without a refresh.
	EntryTimeout Duration `json:"entry_timeout,omitempty"`

	// LogLevel is the minimum log level; Tag names the service's logger.
	LogLevel string `json:"log_level,omitempty"`
	Tag      string `json:"tag,omitempty"`
	// LogHookLevel is the most verbose level kept for /debug/log, info when empty.
	LogHookLevel string `json:"log_hook_level,omitempty"`
	// MetricsAddr exposes Prometheus metrics; empty disables it.
	MetricsAddr string `json:"metrics_addr,omitempty"`
	// PprofMode is cpu, mem, mutex, block, trace or http (see StartPprof);
	// PprofAddr is the address the http mode serves on. An address with
	// no mode means http; neither disables profiling.
	PprofMode string `json:"pprof_mode,omitempty"`
	PprofAddr string `json:"pprof_addr,omitempty"`

	// Testing runs the service for a test network: the store is in memory
	// unless Redis is set, and checks that only make sense on the public
	// network are relaxed. Requests are authenticated as always.
	Testing bool `json:"testing,omitempty"`
	// SurveyWhitelist are the keys allowed to read the service's debug and
	// survey endpoints. Empty means the deployment's list (see SurveyKeys).
	SurveyWhitelist []cipher.PubKey `json:"survey_whitelist,omitempty"`
}

type Duration time.Duration

type Embeddable interface {
	Service
	Embed(ctx context.Context, host Host) (http.Handler, error)
}

type Factory func(raw json.RawMessage, log *logging.Logger) (Service, error)

type File struct {
	Services []Block `json:"services"`
}

type FlagDefaults struct {
	// Gen is the `skywire cli config gen` flag that writes this service's
	// config, e.g. "tpd".
	Gen          string
	Addr         string
	Tag          string
	EntryTimeout time.Duration
}

type Flags struct {
	Common
	ConfigPath string
	KeyFile    string
}

type Host struct {
	// DmsgClient is the host's dmsg client. Nil means the service runs
	// its HTTP surface only and starts none of its CXO publishers or
	// aggregators (tests, or a host without dmsg).
	DmsgClient *dmsg.Client
	// PK and SK are the host's identity. Services that bind a CXO node
	// identity use SK; PK names the host on /health.
	PK cipher.PubKey
	SK cipher.SecKey
	// DmsgAddr is "<pk>:<port>", the dmsg address the service reports on
	// /health as its own.
	DmsgAddr string
	// Log is the host-supplied logger for the service.
	Log *logging.Logger
	// CXO lends the host's CXO nodes to the service's aggregators. Nil
	// when the host has none: the service then builds its own nodes.
	CXO CXOHost
}

type Identity struct {
	PK       cipher.PubKey
	SK       cipher.SecKey
	DmsgPort uint16
	// DmsgAddr is "<pk>:<port>", empty without a key.
	DmsgAddr string
}

type Listener struct {
	// Name prefixes errors, e.g. "address-resolver".
	Name string
	// DefaultAddr is the plain HTTP address when Common.Addr is empty.
	DefaultAddr string
	Handler     http.Handler
	Dmsg        cmdutil.DmsgConfig
	Stats       *charts.ServiceStats
	// OnDmsgServersUpdated receives the dmsg servers the service is on.
	OnDmsgServersUpdated func([]string)
}

type Publisher interface {
	Close() error
	Publisher() *treestore.Publisher
}

type PublisherState struct {
	Name string `json:"name"`
	Port uint16 `json:"port"`
	treestore.PublishState
	node.PublisherStats
}

type Service interface {
	Run(ctx context.Context) error
}

type State struct {
	// Store is the service's data store: "redis" or "memory".
	Store string `json:"store"`
	// NonceStore is where the auth nonces live: "redis", "memory", or
	// "none" (test mode, requests are not authenticated).
	NonceStore string `json:"nonce_store,omitempty"`
	// Aggregators are the CXO fan-in nodes: visors publish a feed and the
	// service subscribes to each (registration, telemetry).
	Aggregators []AggregatorState `json:"cxo_aggregators,omitempty"`
	// Publishers are the CXO feeds the service publishes to the fleet.
	Publishers []PublisherState `json:"cxo_publishers,omitempty"`
}

type Stater interface {
	State() State
}