service

type App types.ServiceConfig

type AppOperation struct {
	App  string
	Kind string
}

type AppStore interface {
	Catalog() (map[string]*ComposeApp, error)
	CategoryMap() (map[string]codegen.CategoryInfo, error)
	ComposeApp(id string) (*ComposeApp, error)
	Recommend() ([]string, error)
	UpdateCatalog() error
	WorkDir() (string, error)
}

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

type BackupCopier interface {
	CopyDirectory(ctx context.Context, source, destinationName, destinationPath string) error
	CopyFile(ctx context.Context, source, destinationName, destinationPath string) error
}

type BackupEntry struct {
	Kind BackupKind `json:"kind"`
	// Path on the host. Empty for an entry that was skipped before it could be
	// resolved, and for a named volume until Docker has been asked where it lives.
	Path string `json:"path"`
	// Service that mounts it, empty for the app's own files
	Service string `json:"service,omitempty"`
	// Target inside the container, for a volume or a bind
	Target string `json:"target,omitempty"`
	// Volume name as the compose file writes it, for a named volume
	Volume string `json:"volume,omitempty"`
	// Skip is why this is not going in the backup. Empty means it is.
	Skip string `json:"skip,omitempty"`
}

type BackupGit struct {
	Remote string `json:"remote"`
	Branch string `json:"branch"`
	Commit string `json:"commit"`
	// An app that follows tags: the mode, the tag the commit was deployed as, and the tag
	// filter. Omitted for a branch app, whose origin stays what older versions wrote.
	Follow      string `json:"follow,omitempty"`
	Tag         string `json:"tag,omitempty"`
	TagPattern  string `json:"tag_pattern,omitempty"`
	Prereleases bool   `json:"prereleases,omitempty"`
}

type BackupHeldApp struct {
	App string `json:"app"`
	// Installed says whether this box runs the app now. A restore of one that is
	// not installs it first, from the backup's own compose file, which is worth
	// saying before the button is pressed.
	Installed bool `json:"installed"`
	// Stamps of its runs, newest first.
	Stamps []string `json:"stamps"`
}

type BackupKind string

type BackupManifest struct {
	// FormatVersion so a later reader knows what it is looking at. A backup outlives
	// the code that wrote it, which is the whole point of one.
	FormatVersion int    `json:"format_version"`
	App           string `json:"app"`
	// Operations, in the order they were planned
	Operations []BackupOperation `json:"operations"`
	// Skipped says what was deliberately left out, with the reason, so the person
	// restoring finds out here rather than by noticing something missing later.
	Skipped []BackupEntry `json:"skipped,omitempty"`
	// ContainersStopped records whether the app was held still while this was
	// copied. A backup taken from a running database may not restore, and the only
	// thing worse than knowing that is not knowing it.
	ContainersStopped bool `json:"containers_stopped"`
	// Git is where the code of an app deployed from its repository comes from. Optional, so
	// the format version stays: an older reader ignores it.
	Git *BackupGit `json:"git,omitempty"`
}

type BackupOperation struct {
	Kind BackupKind `json:"kind"`
	// Source on this host
	Source string `json:"source"`
	// Destination relative to the root of this backup, always with forward slashes
	Destination string `json:"destination"`
	// Directory is true for a folder, false for a single file. rclone copies the
	// two with different calls, and getting it wrong copies a file's parent.
	Directory bool `json:"directory"`
	// Volume is the compose name of the volume this came from, when it came from one
	Volume string `json:"volume,omitempty"`
	// Service that mounted it, and where
	Service string `json:"service,omitempty"`
	Target  string `json:"target,omitempty"`
}

type BackupOptions struct {
	// Destination is the name of an rclone remote this project manages
	Destination string
	// Stamp names this run inside the destination. Passed in, not read from a
	// clock, so a caller can name a run and find it again.
	Stamp string
	// HoldStill stops the app's containers for the length of the copy. Off means a
	// copy taken from a running app, which for anything holding a database may not
	// restore -- the manifest records which was done.
	HoldStill bool
	// Containers answers which containers the app has, for HoldStill. Nil means ask
	// the app, which is what production does; a test supplies its own so that
	// exercising the hold does not require a daemon -- and does not leave the
	// daemon's client goroutines behind for the next test to trip over.
	Containers func(context.Context) (map[string][]codegen.ContainerSummary, error)
}

type BackupRestorer interface {
	RestoreDirectory(ctx context.Context, destinationName, remotePath, hostPath string) error
	RestoreFile(ctx context.Context, destinationName, remotePath, hostPath string) error
	Fetch(ctx context.Context, destinationName, remotePath string) ([]byte, error)
}

type BackupRunRecord struct {
	App         string    `json:"app"`
	Destination string    `json:"destination"`
	Stamp       string    `json:"stamp"`
	StartedAt   time.Time `json:"started_at"`
	FinishedAt  time.Time `json:"finished_at"`
	// Scheduled tells a run that went off by itself from one somebody asked for.
	Scheduled bool `json:"scheduled"`
	// ContainersStopped says whether the app was held still, which decides whether
	// anything holding a database can be trusted to restore.
	ContainersStopped bool `json:"containers_stopped"`
	Copied            int  `json:"copied"`
	SkippedCount      int  `json:"skipped_count"`
	// Error is empty when the run succeeded.
	Error string `json:"error,omitempty"`
	// Restore marks a run that put the app back from a backup rather than one
	// that took a backup. Same log, because a person looking for what happened
	// to an app wants both in one place, newest first.
	Restore bool `json:"restore,omitempty"`
}

type BackupSchedule struct {
	App         string        `json:"app"`
	Destination string        `json:"destination"`
	Every       ScheduleEvery `json:"every"`
	// At is local time, "HH:MM". Local because somebody chose it looking at their
	// own clock, and "back up at 3am" means their 3am.
	At string `json:"at"`
	// Weekday applies to weekly only.
	Weekday time.Weekday `json:"weekday"`
	// Keep is how many runs survive at the destination. Zero keeps everything,
	// which is the safe reading of a field nobody filled in -- deleting backups is
	// not something to do because a number defaulted.
	Keep int `json:"keep"`
	// HoldStill stops the app for the copy.
	HoldStill bool `json:"hold_still"`
	Enabled   bool `json:"enabled"`
	// LastRun is when this last went off, and the only thing that stops it going
	// off again for the same slot.
	LastRun time.Time `json:"last_run"`
}

type ComposeApp codegen.ComposeApp

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

type ContainerVolume struct {
	// Name is the volume's name in Docker.
	Name string `json:"name"`
	// Target is where the container mounts it.
	Target string `json:"target"`
	// Size in bytes, or -1 when the driver cannot say. Shown so nobody deletes
	// 1.4 GB thinking it is a cache.
	Size int64 `json:"size"`
	// Containers is how many containers reference it, this one included, or -1
	// when the daemon cannot say.
	Containers int64 `json:"containers"`
	// Removable is false when this must not be offered for deletion at all.
	Removable bool `json:"removable"`
	// Reason says why, when it is not.
	Reason string `json:"reason,omitempty"`
}

type DockerService interface {
	// image
	IsExistImage(imageName string) bool
	PullImage(ctx context.Context, imageName string) error
	PullLatestImage(ctx context.Context, imageName string) (bool, error)
	RemoveImage(name string) error

	// container
	CheckContainerHealth(id string) (bool, error)
	CreateContainer(m model.CustomizationPostData, id string) (containerID string, err error)
	CreateContainerShellSession(container, row, col string) (hr types.HijackedResponse, err error)
	DescribeContainer(ctx context.Context, name string) (*types.ContainerJSON, error)
	GetContainer(id string) (types.Container, error)
	GetContainerAppList(name, image, state *string) (*[]model.MyAppList, *[]model.MyAppList)
	GetContainerByName(name string) (*types.Container, error)
	GetContainerLog(name string) ([]byte, error)
	GetContainerStats() []model.DockerStatsModel
	RecreateContainer(ctx context.Context, id string, pull bool, force bool) error
	RemoveContainer(name string, update bool) error
	RestartContainer(id string) error
	SampleContainerStats(ctx context.Context, ids []string) map[string]*container.StatsResponse
	VolumeMountpoints(ctx context.Context, names []string) map[string]string
	VolumeUsage(ctx context.Context) map[string]docker.VolumeSpace
	RemoveVolume(ctx context.Context, name string) error
	RenameContainer(name, id string) (err error)
	StartContainer(name string) error
	StopContainer(id string) error

	// network
	GetNetworkList() []network.Summary

	// docker server
	GetServerInfo() (system.Info, error)
}

type ErrAppBusy struct {
	App     string
	Running string
}

type GitAppChanges struct {
	Branch     *string
	AutoDeploy *bool
	Access     *string
	Token      *string
	// WebhookEnabled turns the webhook on, with a new secret when it has none, or off,
	// forgetting the secret.
	WebhookEnabled *bool
	// RegenerateWebhookSecret replaces the secret at once; refused while the webhook is off.
	RegenerateWebhookSecret *bool
	// Follow changes the mode: the folder of a cloned app is put on the branch or detached.
	// TagPattern and Prereleases change the tags an app that follows them may deploy.
	Follow      *string
	TagPattern  *string
	Prereleases *bool
}

type GitAppRegistration struct {
	Name   string
	URL    string
	Branch string
	Access string
	Token  string
	// Follow is gitFollowBranch, empty for the same, or gitFollowTags; TagPattern and
	// Prereleases choose the tags an app that follows them may deploy.
	Follow      string
	TagPattern  string
	Prereleases bool
}

type GitAppView struct {
	App        string           `json:"app"`
	Origin     string           `json:"origin"`
	Dir        string           `json:"dir"`
	Remote     string           `json:"remote"`
	Branch     string           `json:"branch"`
	Access     string           `json:"access"`
	PublicKey  string           `json:"public_key,omitempty"`
	TokenSet   bool             `json:"token_set"`
	AutoDeploy bool             `json:"auto_deploy"`
	AutoPaused bool             `json:"auto_paused"`
	Blocked    bool             `json:"blocked"`
	EnvTracked bool             `json:"env_tracked"`
	Cloned     bool             `json:"cloned"`
	Head       *GitHeadView     `json:"head"`
	Deployed   *GitDeployedView `json:"deployed"`
	Check      *GitCheckView    `json:"check"`
	NewCommits bool             `json:"new_commits"`
	State      string           `json:"state"`
	Operation  *gitOperation    `json:"operation"`
	History    []GitHistoryView `json:"history"`
	Compose    *GitComposeView  `json:"compose"`
	// ComposeExample is set when the last check found no compose file in the repository.
	ComposeExample *string        `json:"compose_example"`
	EnvTemplate    *string        `json:"env_template"`
	BuildLog       string         `json:"build_log"`
	Webhook        GitWebhookView `json:"webhook"`
	// Follow is `branch` or `tags`. TagPattern and Prereleases choose the tags an app that
	// follows them may deploy, and are kept while it follows a branch.
	Follow      string `json:"follow"`
	TagPattern  string `json:"tag_pattern"`
	Prereleases bool   `json:"prereleases"`
}

type GitCheckView struct {
	At           time.Time `json:"at"`
	RemoteCommit string    `json:"remote_commit"`
	RemoteTag    string    `json:"remote_tag"`
	TagMoved     bool      `json:"tag_moved"`
	Error        string    `json:"error"`
}

type GitComposeServiceView struct {
	Name      string   `json:"name"`
	Build     bool     `json:"build"`
	Image     string   `json:"image"`
	Ports     []string `json:"ports"`
	Volumes   []string `json:"volumes"`
	Sensitive []string `json:"sensitive"`
}

type GitComposeView struct {
	Files    []string                `json:"files"`
	Services []GitComposeServiceView `json:"services"`
}

type GitDeployedView struct {
	Commit  string    `json:"commit"`
	Subject string    `json:"subject"`
	At      time.Time `json:"at"`
	Tag     string    `json:"tag"`
}

type GitHeadView struct {
	Commit            string `json:"commit"`
	Subject           string `json:"subject"`
	TrackedFilesClean bool   `json:"tracked_files_clean"`
}

type GitHistoryView struct {
	Commit     string    `json:"commit"`
	Subject    string    `json:"subject"`
	At         time.Time `json:"at"`
	Outcome    string    `json:"outcome"`
	Reason     string    `json:"reason"`
	Revertable bool      `json:"revertable"`
	Tag        string    `json:"tag"`
}

type GitRequestError string

type GitTag struct {
	Name   string `json:"name"`
	Commit string `json:"commit"`
}

type GitWebhookDelivery struct {
	At     time.Time `json:"at"`
	Forge  string    `json:"forge"`
	Event  string    `json:"event"`
	Result string    `json:"result"`
}

type GitWebhookView struct {
	Enabled bool   `json:"enabled"`
	Path    string `json:"path"`
	// Secret is set while the webhook is on.
	Secret       string              `json:"secret,omitempty"`
	LastDelivery *GitWebhookDelivery `json:"last_delivery"`
}

type ProgressDetail struct {
	Current int64 `json:"current"`
	Total   int64 `json:"total"`
}

type PullOut struct {
	Status         StatusType     `json:"status"`
	ProgressDetail ProgressDetail `json:"progressDetail"`
	Id             string         `json:"id"`
}

type ResticCheck struct {
	At    time.Time `json:"at"`
	OK    bool      `json:"ok"`
	Error string    `json:"error,omitempty"`
}

type RestoreInstaller func(ctx context.Context, name string, compose, env []byte) (*ComposeApp, error)

type RestoreOptions struct {
	Destination string
	App         string
	Stamp       string
	// Containers lists the app's containers; nil means ask Docker. A seam for the
	// tests, as on BackupOptions.
	Containers func(ctx context.Context) (map[string][]codegen.ContainerSummary, error)
}

type RestoreReport struct {
	// Restored, in the order it happened, with this host's paths
	Restored []BackupOperation
	// Missing is in the backup and has nowhere to go on this app: a volume it no
	// longer declares, a bind mount it no longer has. Reported, never guessed.
	Missing []BackupOperation
	// Skipped is what the backup itself left out, copied from its manifest so the
	// person restoring finds out here rather than by noticing something absent.
	Skipped []BackupEntry
	// Installed is true when the app was not installed and has been, from the
	// backup's own compose file.
	Installed bool
}

type ScheduleEvery string

type Services interface {
	AppStoreManagement() *AppStoreManagement

	// Git() *GitService
	Compose() *ComposeService
	Docker() DockerService
	Gateway() external.ManagementService
	Notify() external.NotifyService
	MessageBus() *message_bus.ClientWithResponses
}

type StatusType string

type SystemBackupOptions struct {
	Destination string
	Stamp       string
	// HoldStill stops the services that hold the files open for the copy.
	HoldStill bool
}

type SystemRestoreOptions struct {
	Destination string
	Stamp       string
}

type Throttler struct {
	InvokeInterval time.Duration
	LastInvokeTime time.Time
}