migrate

type BlobMode string

type ConcernSummary struct {
	Concern string `json:"concern"`
	Items   int    `json:"items"`
	Bytes   int    `json:"bytes"`
	Refused int    `json:"refused,omitempty"`
}

type Domains struct {
	Workspaces  hub.Store
	Credentials hub.CredentialStore
	Orgs        orgStore
	Links       linkStore
	Runner      runnerStore
	Catalogue   catalogueStore
	SlackApps   slackCatalogueStore
	Slack       slackStore
	Shared      sharedStore
	Channels    channelStore
	SessionKey  sessionKeys
}

type KeptParam struct {
	Name   string `json:"name"`
	Class  string `json:"class"`
	Reason string `json:"reason"`
}

type ModulePlan struct {
	Module string `json:"module"`
	PlanCounts
	Items []PlanItem `json:"items"`
}

type Options struct {
	// DryRun plans and reports and writes nothing, the destination's objects
	// included.
	DryRun bool
	// Overwrite replaces what the destination holds with the source's. Without
	// it a destination value that differs fails the run, naming the key.
	Overwrite bool
	// WritersStopped is the operator's statement that nothing writes to the
	// source. A copy is a snapshot: a write during it is a copy of neither
	// state. A run that writes refuses without it.
	WritersStopped bool
	// Sessions also copies the issuer's logins in progress (sessions, refresh
	// tokens, the codes in flight, the Index sets). An installation's move does
	// not: people sign in again, and only the key ring's schedule is copied, so
	// that a token issued before the move keeps verifying.
	Sessions bool
	// Skip names domains left out (see the Domain constants).
	Skip []string
	// Blobs says whether the controllers' reports are copied.
	Blobs BlobMode
	// ReportBlob, when set, is a Blob name the report is also written to on
	// the destination (not by a dry run).
	ReportBlob string
	// ExportedGitHubApp says which catalogue GitHub Apps of the destination have
	// `export: true`. Nil exports none; a runner App is always
	// exported.
	ExportedGitHubApp func(id string) bool
	// Log receives progress. Nil is silent.
	Log *slog.Logger
	// Now is the clock the copied lifetimes are measured against; nil is
	// time.Now. For tests, which inject the delay between reading and writing.
	Now func() time.Time
}

type PlanCounts struct {
	New       int `json:"new"`
	Same      int `json:"same"`
	Different int `json:"different"`
	Refused   int `json:"refused"`
	// Copied and Missing are what a copy wrote and a verify did not find.
	Copied  int `json:"copied,omitempty"`
	Missing int `json:"missing,omitempty"`
	// Expired is the issuer's records that ran out of lifetime before they were
	// written, and so were skipped.
	Expired int `json:"expired,omitempty"`
}

type PlanItem struct {
	// Concern is `state`, `secret` or `blob`.
	Concern string `json:"concern"`
	// Kind and ID are the item's kind and id on layout v5.
	Kind string `json:"kind"`
	ID   string `json:"id,omitempty"`
	// From is the v4 logical key (State) or the v4 name below the root (secret).
	From string `json:"from"`
	// To is the v5 address: `<module>/<kind>/<id>` for State, the name below
	// the root for a secret. A name ending in `<ref>` has a ref chosen at each
	// write.
	To     string     `json:"to,omitempty"`
	Status PlanStatus `json:"status"`
	// Count is how many records the row stands for; absent is one.
	Count int `json:"count,omitempty"`
	// Secrets is how many credentials the record carries; their v4 and v5
	// families are FromSecret and ToSecret.
	Secrets    int    `json:"secrets,omitempty"`
	FromSecret string `json:"fromSecret,omitempty"`
	ToSecret   string `json:"toSecret,omitempty"`
	// External is the document a consumer reads, which keeps its name.
	External string `json:"external,omitempty"`
	// FromVersion and ToVersion are the versions of a secret on each side.
	FromVersion string `json:"fromVersion,omitempty"`
	ToVersion   string `json:"toVersion,omitempty"`
	// Reason says why an item is refused, or Note what the operator must know.
	Reason string `json:"reason,omitempty"`
	Note   string `json:"note,omitempty"`
	// contains filtered or unexported fields
}

type PlanOptions struct {
	// Skip names domains left out (see the Domain constants).
	Skip []string
	// Sessions also plans the issuer's sessions, refresh tokens, single
	// sign-on records, codes in flight and Index sets. Without it only the key
	// ring and the state secret's fingerprint are planned.
	Sessions bool
	// Blobs says whether the controllers' reports are planned.
	Blobs BlobMode
	// ExportedGitHubApp says which catalogue GitHub Apps have `export: true`.
	ExportedGitHubApp func(id string) bool
	// AppRef is the App each GitHub organisation uses on layout v5
	// (`controllers.github.appRefs`), an override and optional: an organisation
	// without one uses the source's App that installs it, or an App made of the
	// organisation's own (v5orgapp.go).
	AppRef func(org string) string
	// ConfigNames are the secrets the documents declare below internal/config
	// beyond the fixed ones: `providers/google/<provider>/client-id`,
	// `directory/<id>/key`.
	ConfigNames []string
	// CloudflareAccounts are the accounts whose minter credential is planned.
	CloudflareAccounts []string
	// S3Ref and S3RefTo are the `credentialsRef` of the source's and the
	// destination's blob, when they have one.
	S3Ref, S3RefTo string
	// Log receives progress. Nil is silent.
	Log *slog.Logger
	// Now is the clock the remaining lifetime of an issuer record is counted
	// by. Nil is [time.Now].
	Now func() time.Time
}

type PlanReport struct {
	From    string       `json:"from"`
	To      string       `json:"to"`
	Modules []ModulePlan `json:"modules"`
	Totals  PlanCounts   `json:"totals"`
	Notes   []string     `json:"notes,omitempty"`
	// Mode is "copy" or "verify" for those commands; a plan leaves it out.
	Mode   string `json:"mode,omitempty"`
	DryRun bool   `json:"dryRun,omitempty"`
	// Live is a copy that ran without the writers stopped: the first pass, which
	// leaves the issuer out. A final pass is still required.
	Live bool `json:"live,omitempty"`
	// Verify is what a copy found when it read both sides again afterwards.
	Verify *VerifyResult `json:"verify,omitempty"`
	OK     bool          `json:"ok"`
	Error  string        `json:"error,omitempty"`
	// contains filtered or unexported fields
}

type PlanStatus string

type Problem struct {
	Domain string `json:"domain"`
	Kind   string `json:"kind"`
	Key    string `json:"key"`
	Reason string `json:"reason"`
}

type PruneOptions struct {
	PlanOptions
	// DryRun reads, reports the plan hash and deletes nothing.
	DryRun bool
	// Confirm is the plan hash of a dry run; a real run needs it.
	Confirm string
	// SameRoot is true when both sides keep their parameters below one root: a
	// layout v4 name that is also the layout v5 name is then the copy itself.
	SameRoot bool
	// Pause is the wait between two requests (zero is [DefaultPrunePause]) and
	// Backoff the first wait after a throttled one (zero is [DefaultPruneBackoff]).
	Pause, Backoff time.Duration
	// Before is called once, after the plan hash is confirmed and before the
	// first delete. The command records its intent there; an error stops the run
	// with nothing deleted.
	Before func(ctx context.Context, r *PruneReport) error
	// Sleep waits; nil is a context-aware time.Sleep.
	Sleep func(ctx context.Context, d time.Duration) error
}

type PruneReport struct {
	From string `json:"from"`
	To   string `json:"to"`
	// DryRun is a run that deleted nothing.
	DryRun bool `json:"dryRun,omitempty"`
	// PlanHash identifies the parameters to delete and the ones kept; a real
	// run is given it as --confirm-plan.
	PlanHash string `json:"planHash,omitempty"`
	// Verify is what the gate found, by status.
	Verify PlanCounts `json:"verify"`
	// Gate is "passed", or why the run was refused.
	Gate string `json:"gate"`
	// Delete are the parameters to delete (a dry run) or deleted.
	Delete []string `json:"delete"`
	// Deleted counts the parameters a real run removed, in Batches requests.
	Deleted int `json:"deleted,omitempty"`
	Batches int `json:"batches,omitempty"`
	// Kept are the parameters left, with the reason.
	Kept []KeptParam `json:"kept"`
	// LegacyTableItems are the migrated records on the source: the legacy table
	// holds them until it retires; prune does not touch it.
	LegacyTableItems int      `json:"legacyTableItems"`
	Notes            []string `json:"notes,omitempty"`
	OK               bool     `json:"ok"`
	Error            string   `json:"error,omitempty"`
}

type Report struct {
	From        string    `json:"from"`
	To          string    `json:"to"`
	FromAdapter string    `json:"fromAdapter"`
	ToAdapter   string    `json:"toAdapter"`
	DryRun      bool      `json:"dryRun"`
	Overwrite   bool      `json:"overwrite"`
	StartedAt   time.Time `json:"startedAt"`
	FinishedAt  time.Time `json:"finishedAt"`
	Steps       []Step    `json:"steps"`
	Totals      Step      `json:"totals"`
	Conflicts   []Problem `json:"conflicts,omitempty"`
	Unreadable  []Problem `json:"unreadable,omitempty"`
	Mismatches  []Problem `json:"mismatches,omitempty"`
	// Refused are the items the destination would refuse, and why.
	Refused []Problem `json:"refused,omitempty"`
	// Concerns is the summary per concern: state, secrets, blobs.
	Concerns []ConcernSummary `json:"concerns,omitempty"`
	// Notes say what was left out and why (a domain skipped, a side with
	// nothing to read).
	Notes []string `json:"notes,omitempty"`
	// Error is how the run ended, if it did not end well.
	Error string `json:"error,omitempty"`
	// OK is true when the plan had no conflict, nothing unreadable, and, unless
	// this was a dry run, every item verified.
	OK bool `json:"ok"`
}

type SecretTarget struct {
	Module string
	Kind   string
	ID     string
	// V5 is the name below the installation's root, or the family when it
	// holds a `<ref>` the store chooses at each write.
	V5 string
	// Config is true for a name an operator or Pulumi seeds as plain text
	// (below internal/config), which the v4 source delivers by name.
	Config bool
}

type Side struct {
	// Name labels it in the report: the configuration file it came from.
	Name string
	// Stores is the opened ports.
	Stores *store.Stores
	// BlobID identifies where this side keeps blobs, so that two sides that
	// share a place are known to; empty is "nowhere shared".
	BlobID string
}

type Step struct {
	Domain string `json:"domain"`
	Kind   string `json:"kind"`
	// Source is how many readable items the source holds.
	Source int `json:"source"`
	// Unreadable is how many it holds that its store cannot present: they are
	// listed and not copied.
	Unreadable int `json:"unreadable,omitempty"`
	// New is how many the destination lacks, Present how many it already holds
	// with the same value, and Conflicts how many it holds with another.
	New       int `json:"new"`
	Present   int `json:"present"`
	Conflicts int `json:"conflicts,omitempty"`
	// Copied is how many were written: New, and with Overwrite the Conflicts.
	Copied int `json:"copied"`
	// Verified is how many matched on the second read; Mismatched how many did
	// not.
	Verified   int `json:"verified"`
	Mismatched int `json:"mismatched,omitempty"`
	// Refused is how many the destination would refuse (an item over a size
	// limit, an invalid key): they are listed under refused and stop the run
	// before anything is written.
	Refused int `json:"refused,omitempty"`
	// Bytes is the size of the readable source items (a record with its
	// credentials, a blob, a State value); Secrets and SecretBytes are the
	// credentials among them, which go to the Secrets port.
	Bytes       int `json:"bytes"`
	Secrets     int `json:"secrets,omitempty"`
	SecretBytes int `json:"secretBytes,omitempty"`
}

type Target struct {
	Module string
	Kind   string
	ID     string
}

type V5Options struct {
	PlanOptions
	// DryRun reads and reports and writes nothing.
	DryRun bool
	// Overwrite replaces what the destination holds with the source's. Without
	// it a destination value that differs stops the run before any write.
	Overwrite bool
	// WritersStopped is the operator's statement that nothing writes to the
	// source. A run that writes refuses without it.
	WritersStopped bool
	// Before is called once, after the plan is read and every check passed and
	// before the first write, when there is something to write. The command
	// records its intent there; an error stops the run before it writes.
	Before func(ctx context.Context, w Writes) error
	// Wait pauses until the replicas have seen a freeze set a moment ago; nil
	// waits on the clock. A test replaces it.
	Wait func(ctx context.Context, d time.Duration)
}

type VerifyResult struct {
	PlanCounts
	// Problems are the items that did not match.
	Problems []PlanItem `json:"problems,omitempty"`
	OK       bool       `json:"ok"`
}

type Writes struct {
	// Items is how many items are written, New of them absent on the
	// destination and Replaced replacing a value that differs.
	Items, New, Replaced int
	// ReplacedNames are the replaced items, as module/concern/name.
	ReplacedNames []string
}