ops

type DBSync interface {
	// SyncMove updates the moved node's path/parent in the DB.
	SyncMove(ctx context.Context, storageID int64, src, dst string)
	// SyncSoftDelete flags the node deleted and retags it to the trash path
	// (storage_key keeps the original path so Restore works).
	SyncSoftDelete(ctx context.Context, storageID int64, src, trashRel string)
	// SyncHardDelete drops the node's rows (and everything below a folder)
	// when its bytes are gone for good: the driver could not move it to the
	// trash and deleted it outright, it was already missing, or a move across
	// storages took it away. Nothing of it is listed in the trash.
	SyncHardDelete(ctx context.Context, storageID int64, src string)
	// SyncCopy inserts a DB node for the freshly written copy.
	SyncCopy(ctx context.Context, storageID int64, src, dst string)
	// SyncCopyAcross inserts a DB node for a copy whose two ends live in
	// DIFFERENT storages. SyncCopy cannot serve this: it reads the source
	// node and writes the new one under ONE storage id, so a cross-storage
	// paste mirrored through it would either find no source node or attach
	// the copy to the wrong depo — the listing would then show the file
	// where it is not.
	SyncCopyAcross(ctx context.Context, srcStorageID int64, src string, dstStorageID int64, dst string)
}

type Job func(ctx context.Context, progress func(done int)) error

type Op struct {
	ID        int64  `json:"id"`
	Kind      string `json:"kind"`
	StorageID int64  `json:"storage_id"`
	// DestStorageID is the storage the destination lives in. It equals
	// StorageID for the ordinary same-storage copy/move; a different value is
	// what makes an op CROSS-STORAGE (paste from one depo into another),
	// which the worker serves by streaming bytes between the two drivers.
	// Zero means "same as StorageID" — the shape every row written before
	// this column existed has.
	DestStorageID int64    `json:"dest_storage_id,omitempty"`
	Sources       []string `json:"sources"`
	Dest          string   `json:"dest,omitempty"`
	Total         int      `json:"total"`
	Done          int      `json:"done"`
	// BytesTotal / BytesDone are a running cross-storage transfer's byte
	// counters (issue #27), merged in from memory by Get/List — never stored.
	// BytesTotal 0 with BytesDone > 0 means the total is not known (yet).
	BytesTotal int64 `json:"bytes_total,omitempty"`
	BytesDone  int64 `json:"bytes_done,omitempty"`
	// ObjectsTotal / ObjectsDone count the objects a running same-storage
	// copy, move or delete has found and finished inside its sources: one
	// folder on an object store is one source and minutes of objects, which
	// the source counts above cannot show. From the storage driver's tally
	// (storage.Tally); live counters like the bytes, never stored.
	ObjectsTotal int64 `json:"objects_total,omitempty"`
	ObjectsDone  int64 `json:"objects_done,omitempty"`
	Failed       int   `json:"failed"`
	// Skipped counts items the op deliberately left alone (migration 00075):
	// a thumbnail repair's files no engine draws, or end-to-end encrypted.
	Skipped int    `json:"skipped,omitempty"`
	Status  string `json:"status"`
	Error   string `json:"error,omitempty"`
	// ErrorCode / ErrorEngine classify a failed APP job for the client, which
	// says it in the person's language (lib/errorWords `jobFailure`) and keeps
	// `Error` — English, sometimes plumbing — for an administrator's second
	// line. Filled by the plugin Decorator, never stored.
	ErrorCode   string `json:"error_code,omitempty"`
	ErrorEngine string `json:"error_engine,omitempty"`
	// ErrorParams are the values ErrorCode's sentence takes, kept on the row
	// with the code (errcode.go); ErrorText is that sentence in the reader's
	// language, made when the row is read (sayErrors) - what every client
	// prints. Error stays the English detail.
	ErrorParams map[string]string `json:"error_params,omitempty"`
	ErrorText   string            `json:"error_text,omitempty"`
	CreatedAt   time.Time         `json:"created_at"`
	StartedAt   *time.Time        `json:"started_at,omitempty"`
	FinishedAt  *time.Time        `json:"finished_at,omitempty"`
	// Plugin fields are filled by the Decorator for OpPluginAction rows and
	// never stored here: which plugin/action ran, the action's label in the
	// caller's locale, the last progress message, and the committed outputs.
	Plugin  string     `json:"plugin,omitempty"`
	Action  string     `json:"action,omitempty"`
	Label   string     `json:"label,omitempty"`
	Message string     `json:"message,omitempty"`
	Outputs []OpOutput `json:"outputs,omitempty"`
	// Open is where a FINISHED plugin job sends the person who queued it: one
	// of its outputs (adapter-qualified) and the app's own screen to start
	// there - the job result's `surface.open` (wasmplugin openAfter). The
	// client that queued the job follows it; nobody else's does. Filled by the
	// Decorator, never stored here.
	Open *OpOpen `json:"open,omitempty"`
	// ActorID is who asked for this op. The worker runs on a server-lifetime
	// context long after the request that queued the work is gone, so the only
	// way a pasted file can be attributed to the person who pasted it is for
	// the queue row to carry them (migration 00038). nil is SYSTEM — a row
	// queued before the column existed, or by something that is not a person.
	ActorID *int64 `json:"actor_id,omitempty"`
	// Cancellable is advertised rather than inferred from the operation kind.
	Cancellable bool `json:"cancellable"`
	// Summary is where a trash job stands, said in the reader's language
	// (say.go): a restore, a permanent delete or "empty the trash". Filled by
	// Get/List for those kinds, never stored.
	Summary string `json:"summary,omitempty"`
	// contains filtered or unexported fields
}

type OpOpen struct {
	Path   string `json:"path"`
	Action string `json:"action,omitempty"`
	View   string `json:"view,omitempty"`
}

type OpOutput struct {
	Path string `json:"path"`
}

type PluginRunner interface {
	RunPluginAction(ctx context.Context, op *Op, live func(done, total int64)) error
}

type Purger interface {
	PurgeNode(ctx context.Context, storageID, nodeID int64) error
}

type RenameSync interface {
	NameTaken(ctx context.Context, storageID int64, src, dst string) (bool, error)
	SyncRename(ctx context.Context, storageID int64, src, dst string)
}

type RestoreFencer interface {
	RestoreFence(ctx context.Context, storageID, nodeID int64) []string
}

type Restorer interface {
	RestoreNode(ctx context.Context, storageID, nodeID int64) error
}

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

type Skipped struct {
	// Path is the entry's source path, storage-relative.
	Path string `json:"path"`
	// Reason is the source driver's own link state (storage.LinkBroken,
	// LinkOutsideRoot, LinkUnresolved), or SkipCycle / SkipTooDeep.
	Reason string `json:"reason"`
}

type SkipsError struct {
	Skipped []Skipped
	// SourceKept is set by a MOVE that did not delete its source because of
	// the entries above (crossTransfer).
	SourceKept bool
}

type Taken func(rel string) bool

type ThumbRefusal struct {
	StorageID int64
	Code      string
}

type ThumbRepairCounts struct {
	Processed int
	OK        int
	Failed    int
	Skipped   int
	// Refused are the storages the run would not repair, with why.
	Refused []ThumbRefusal
}

type ThumbRepairJob struct {
	// StorageID is the storage; 0 is every storage in Reach.
	StorageID int64
	// Path is a file, or a folder with everything in it, inside StorageID:
	// storage-relative. "" is the whole storage.
	Path string
	// Mode is ThumbRepairFix or ThumbRepairRebuild.
	Mode string
	// Reach is the storages the asker may repair: nil every one, empty none.
	Reach []int64
}

type ThumbRepairRequest struct {
	Job ThumbRepairJob
	// Tenant is TenantKey of the caller.
	Tenant string
}

type ThumbRepairer interface {
	// CountRepair is how many files the job would draw right now.
	CountRepair(ctx context.Context, job ThumbRepairJob) (int, error)
	// RunRepair draws them, calling progress as it goes.
	RunRepair(ctx context.Context, job ThumbRepairJob, progress func(ThumbRepairCounts)) (ThumbRepairCounts, error)
}

type TransferHooks struct {
	OnDir  func(src, dst string)
	OnFile func(src, dst string, size int64)
	// OnBytes is told how many new bytes were read from a source file, while
	// they stream (issue #27). Unlike the two above it fires before
	// verification — it measures motion, not completion.
	OnBytes func(n int64)
}

type TrashEmptier interface {
	Tally(ctx context.Context, job trash.EmptyJob) (count int, bytes int64, err error)
	RunEmpty(ctx context.Context, job trash.EmptyJob, started func() bool, progress func(trash.PurgeResult)) (trash.PurgeResult, error)
}

type TrashEmptyRequest struct {
	// StorageID narrows the run to one storage; 0 is every storage in Reach.
	StorageID int64
	// OlderThanDays: 0 is everything that is in the trash when it is asked.
	OlderThanDays int
	// Reach is the storages the caller may empty (trash.Reach): nil every one.
	Reach []int64
	// Tenant is TenantKey of the caller: whose run it is.
	Tenant string
}

type UploadCommitter interface {
	CommitUpload(ctx context.Context, uploadID string) error
}

type Viewer struct {
	All        bool
	StorageIDs []int64
	Tenant     string
	// Own narrows the viewer to the rows Actor queued. A row carries its
	// sources and its destination: paths inside folders the viewer may hold
	// no grant for, which the tenant scope above does not look at. Set for
	// everybody but an administrator (the handlers' opsViewer); a row that
	// names nobody (queued before actor_id existed, or by something that is
	// not a person) is then nobody's, and Actor 0 reaches no row at all.
	Own   bool
	Actor int64
}