syncer

type API interface {
	List(ctx context.Context, kind npm.Kind) ([]npm.Resource, error)
	Create(ctx context.Context, resource npm.Resource) (npm.Resource, error)
	Update(ctx context.Context, id int, resource npm.Resource) (npm.Resource, error)
	Delete(ctx context.Context, kind npm.Kind, id int) error
	// SetEnabled toggles a resource through the dedicated /enable and
	// /disable endpoints. Neither API accepts `enabled` in a create or
	// update body.
	SetEnabled(ctx context.Context, kind npm.Kind, id int, enabled bool) error
	// ListCertificates backs the automatic certificate selection.
	ListCertificates(ctx context.Context) ([]npm.Certificate, error)
	// ListAccessLists resolves access lists referenced by name.
	ListAccessLists(ctx context.Context) ([]npm.AccessList, error)
	// Dialect reports what the server accepts: the flavour, which decides
	// whether NPMplus-only settings can be sent at all, and the fields a
	// release has added or retired - the meta object above all.
	Dialect() npm.Dialect
	// Recheck notices a server upgrade and re-probes the dialect if the
	// version changed. Called on the periodic resync.
	Recheck(ctx context.Context) error
}

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

type Debouncer[T any] struct {
	// Interval is the quiet period after the last event.
	Interval time.Duration
	// MaxWait caps how long a continuous stream of events can delay a batch.
	// Zero disables the cap.
	MaxWait time.Duration
	// Now is injectable for tests; defaults to time.Now.
	Now func() time.Time
}

type Entry struct {
	// ID is the id NPM assigned to the resource.
	ID int
	// Hash fingerprints the configuration last written to NPM.
	Hash string
	// Container is the container the resource was derived from.
	Container string
	// Index is the label index inside that container.
	Index int
	// Enabled is the enabled state last observed for the resource. It is
	// tracked separately from Hash because it is not part of the write
	// payload: both APIs toggle it through /enable and /disable.
	Enabled bool
	// Certificate is the certificate id attached to the resource, reported by
	// the /status endpoint.
	Certificate int
	// Running mirrors the container state at the time of the last run.
	Running bool
}

type Metrics struct {
	Runs             uint64
	RunErrors        uint64
	Created          uint64
	Updated          uint64
	Deleted          uint64
	Failed           uint64
	Skipped          uint64
	DeletionsBlocked uint64
	// CertificateClass counts how often a certificate was chosen by match
	// class ("exact", "wildcard", ...).
	CertificateClass map[string]uint64
	// Managed is the number of resources currently under management.
	Managed int
	// ManagedByKind breaks that down per collection.
	ManagedByKind map[npm.Kind]int
	// LastRun is when the most recent reconcile finished.
	LastRun time.Time
	// LastDuration is how long it took.
	LastDuration time.Duration
}

type Options struct {
	DeleteOrphans   bool
	AdoptExisting   bool
	DryRun          bool
	ResyncInterval  time.Duration
	ShutdownTimeout time.Duration
	// Kinds limits reconciliation to a subset of resource types. Empty means
	// all four.
	Kinds []npm.Kind
	// CertificatePartial decides what happens when no single certificate
	// covers every domain of a host.
	CertificatePartial certs.Partial
	// CertificateAutoCreate requests a Let's Encrypt certificate when the
	// automatic selection finds nothing.
	CertificateAutoCreate bool
	// MigrateFromRedth takes over hosts created by Redth/npm-docker-sync and
	// re-stamps them as ours.
	MigrateFromRedth bool
	// CertificatePoll is how often the certificate list is checked for
	// changes; a change triggers a reconcile so a certificate created in the
	// UI reaches its hosts without a restart. 0 disables the poll.
	CertificatePoll time.Duration
	// OnStop decides what happens to the resources of a container that is
	// stopped but still exists.
	OnStop docker.OnStop
	// StopGrace is how long a stopped container is ignored, so a restart or a
	// recreate does not produce a disable/enable cycle.
	StopGrace time.Duration
	// InstanceID identifies this sync instance. Resources carrying another
	// instance's id are never touched, which lets several Docker hosts drive
	// one NPM.
	InstanceID string
	// LabelPrefix is the namespace in use. A resource created from a
	// different prefix means the configuration changed under us, and a run
	// that would delete because of it is stopped.
	LabelPrefix string
	// DeleteGuard is the largest share of the managed resources a single run
	// may delete (0.5 = half). 0 disables the guard.
	DeleteGuard float64
	// DeleteGuardMin is how many deletions a run must reach before the guard
	// looks at the share at all, so small setups stay usable.
	DeleteGuardMin int
}

type ResourceStatus struct {
	Kind        npm.Kind `json:"kind"`
	Key         string   `json:"key"`
	ID          int      `json:"id"`
	Container   string   `json:"container"`
	Index       int      `json:"index"`
	Enabled     bool     `json:"enabled"`
	Running     bool     `json:"container_running"`
	Certificate int      `json:"certificate_id"`
	// LastError is why the resource was last rejected, if it was.
	LastError string `json:"last_error,omitempty"`
	// RetryAfter is when the backoff of a failed resource expires.
	RetryAfter *time.Time `json:"retry_after,omitempty"`
}

type Result struct {
	Created   int `json:"created"`
	Updated   int `json:"updated"`
	Deleted   int `json:"deleted"`
	Unchanged int `json:"unchanged"`
	Skipped   int `json:"skipped"`
	Failed    int `json:"failed"`
}

type Status struct {
	LastRun time.Time
	Managed int
	Failed  int
	Err     error
	// Stream is the health of the Docker event subscription. A stream that
	// has been down for a while means changes are only noticed by the
	// periodic resync.
	Stream docker.StreamStatus
	// Blocked names the safety rule that stopped this run from deleting, if
	// one did.
	Blocked string
}

type StreamSource interface {
	StreamStatus() docker.StreamStatus
}

type TargetSource interface {
	// Snapshot returns the desired resources plus what the parser learned
	// about the containers - above all which of them are protected from
	// deletion because their labels could not be read.
	Snapshot(ctx context.Context) (docker.Snapshot, error)
}

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