app

type AsyncJob ¶ added in v0.6.1

type AsyncJob[Status any] interface {
	// Run releases the job into the background and answers nothing: once
	// released there is nobody on the call path left to act on an error, so
	// the outcome lives in the job store and in Wait.
	//
	// The context must NOT be the request's. A request context is canceled
	// when the request ends, and cancellation walks every context derived
	// from it, so a job released with one is canceled the moment the caller
	// goes away — the opposite of what running async exists for. Hand Run a
	// process-scoped context: the server's base context or
	// context.Background().
	Run(ctx context.Context)

	// Wait blocks until Run's job settles and answers its status. It is the
	// request-side half: taking the request's context here is fine, because
	// abandoning a Wait only stops the waiting, never the job. Waiting on a
	// job that was never started blocks until the context is done.
	Wait(ctx context.Context) (Status, error)
}

The layer speaks two contracts. AsyncJob is the registered run: an id and a state in the job store, released into the background to outlive the request that started it. The synchronous contract is tasklet.Tasklet — Execute calls composing into trees, a task holding child tasklets — and a job's body is usually the root of one such tree. The tasklet half already has its name in core/tasklet; this file deliberately mints no second word for the same shape.

type BackupJob ¶ added in v0.6.1

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

BackupJob is one registered create-backup run — the create counterpart of DeleteJob. A job is what a create call makes: the backup artifact is what a successful job leaves behind in storage, a different resource with its own usecase (GetBackup) — the split the v2 API draws between jobs/backup/create, which returns the job, and backups/describe, which reads the artifact.

Registering a job and running it are separate steps: admission happens in NewBackupJob, synchronously, so a duplicate name, an unreachable storage or an artifact directory that is already taken is the caller's immediate answer. Running is Run, which releases the job into the background; Wait blocks on the settlement.

func NewBackupJob(ctx context.Context, params *cfg.Config, store *jobstate.Store, req CreateBackupRequest) (*BackupJob, error)

func (j *BackupJob) Run(ctx context.Context)

func (j *BackupJob) Wait(ctx context.Context) (jobstate.BackupStatus, error)

type BackupSummary ¶

type BackupSummary struct {
	ID            string
	Name          string
	Size          int64
	MilvusVersion string
}

BackupSummary is the artifact summary as list presents it. It is not backuppb.BackupSummary on purpose: that type is the v1 wire shape, and wire shapes belong to the transports, which render this view into whatever their contract says.

type Check ¶

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

Check verifies that a backup run would work: Milvus answers, both storages are reachable, and an object can be copied from the Milvus storage to the backup storage.

func NewCheck(ctx context.Context, params *cfg.Config) (*Check, error)

func (uc *Check) Execute(ctx context.Context, output io.Writer) error

type CreateBackupRequest ¶ added in v0.6.1

type CreateBackupRequest struct {
	// TaskID is the id the job registers under in the job state store.
	TaskID string

	// Option carries the parsed backup parameters: the artifact name the job
	// registers under, strategy, format, collection filter, GC pause and the
	// like. Option.BackupName is also the key the job is visible under to
	// the task APIs, so it must be the one name the transport validated.
	Option backup.Option
}

CreateBackupRequest describes one backup job. It is the transport-neutral whole of what the action accepts: both transports derive the task id from their request-id conventions and parse their own input format into Option before calling.

type DeleteBackupRequest ¶ added in v0.6.1

type DeleteBackupRequest struct {
	TaskID     string
	BackupName string
}

DeleteBackupRequest describes one delete job. TaskID is the id the job registers under in the job store; BackupName is the artifact it removes.

type DeleteJob ¶ added in v0.6.1

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

DeleteJob is one registered delete-backup run — the delete counterpart of BackupJob. Registering (NewDeleteJob) is synchronous and proves the artifact's meta is readable: a delete that cannot prove what it is deleting is refused, so a wrong root path or a corrupted backup is the caller's immediate answer instead of wiping whatever prefix happens to sit under the path.

func NewDeleteJob(ctx context.Context, params *cfg.Config, store *jobstate.Store, req DeleteBackupRequest) (*DeleteJob, error)

func (j *DeleteJob) Run(ctx context.Context)

func (j *DeleteJob) Wait(ctx context.Context) (jobstate.DeleteStatus, error)

type GetBackup ¶

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

GetBackup reads one backup artifact: the persisted meta in the backup storage. The job that produced it is a different resource with its own usecase, GetBackupTask — the two are read separately so transports with a split API (v2) map one endpoint to one usecase, and a transport with a merged contract (v1) does the merging itself.

func NewGetBackup(ctx context.Context, params *cfg.Config) (*GetBackup, error)

func (uc *GetBackup) Execute(ctx context.Context, name string) (*backuppb.BackupInfo, int64, error)

type GetBackupTask ¶

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

GetBackupTask reads the state of one backup job. The job half of a backup lives only in the job state store, so like its sister GetRestore this usecase never touches storage, there is nothing to construct and construction cannot fail.

func NewGetBackupTask(store *jobstate.Store) *GetBackupTask

func (uc *GetBackupTask) Execute(ctx context.Context, req GetBackupTaskRequest) (jobstate.BackupStatus, error)

type GetBackupTaskRequest ¶

type GetBackupTaskRequest struct {
	Name string
	ID   string
}

GetBackupTaskRequest selects the job to read. Name and ID are alternative selectors; the ID wins when both are set, because only the ID can pin down one of several jobs that shared the name.

type GetRestore ¶

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

GetRestore reads the state of one restore job. Restore jobs keep all their state in the job state store, so this is the thinnest usecase in the layer: unlike its sister GetBackup it never touches storage, which also means there is nothing to construct and construction cannot fail.

func NewGetRestore(store *jobstate.Store) *GetRestore

func (uc *GetRestore) Execute(ctx context.Context, id string) (jobstate.RestoreStatus, error)

type ListBackups ¶

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

ListBackups lists the backup artifacts kept in the backup storage.

func NewListBackups(ctx context.Context, params *cfg.Config) (*ListBackups, error)

func (uc *ListBackups) Execute(ctx context.Context) ([]BackupSummary, error)

type MigrateJob ¶ added in v0.6.1

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

MigrateJob is one registered migrate run — the migrate counterpart of DeleteJob. Registering (NewMigrateJob) is synchronous and proves the backup's meta is readable: a migrate that cannot prove what it is uploading is the caller's immediate answer, and there is no task object that can be run unregistered.

func NewMigrateJob(ctx context.Context, params *cfg.Config, store *jobstate.Store, req MigrateRequest) (*MigrateJob, error)

func (j *MigrateJob) Run(ctx context.Context)

func (j *MigrateJob) Wait(ctx context.Context) (jobstate.MigrateStatus, error)

type MigrateRequest ¶ added in v0.6.1

type MigrateRequest struct {
	TaskID     string
	BackupName string
	ClusterID  string
}

MigrateRequest describes one migrate job. TaskID is the id the job registers under in the job store; BackupName is the artifact it uploads; ClusterID is the Zilliz Cloud cluster the backup migrates to.

type RestoreJob ¶ added in v0.6.1

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

RestoreJob is one registered restore job, ready to execute. A job is what a restore call makes: the restored collections are what a successful job leaves behind in the target Milvus.

Registering a job and running it are separate steps: registration happens in NewRestoreJob, synchronously, so a missing backup or an unreadable meta is the caller's immediate answer. Running is Run, which releases the job into the background; Wait blocks on the settlement.

func NewRestoreJob(ctx context.Context, params *cfg.Config, store *jobstate.Store, req RestoreRequest) (*RestoreJob, error)

func (j *RestoreJob) Run(ctx context.Context)

func (j *RestoreJob) Wait(ctx context.Context) (jobstate.RestoreStatus, error)

type RestoreRequest ¶ added in v0.6.1

type RestoreRequest struct {
	// TaskID identifies the restore job in the job state store. The transport
	// defaults it when its contract carries no id.
	TaskID string
	// BackupName names the backup artifact to restore.
	BackupName string

	Plan   *restore.Plan
	Option *restore.Option
}

RestoreRequest selects and shapes one restore. Plan and Option are the restore task's own vocabulary on purpose: each transport translates its grammar into them — the CLI from flags, v1 from its pb fields — and the two grammars do not map onto each other, so there is nothing transport-neutral to put here instead.

type RestoreSecondaryJob ¶ added in v0.6.1

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

RestoreSecondaryJob is one registered secondary-restore job, ready to execute. A secondary restore replays the source cluster's DDL verbatim under the target cluster's id. Registration happens in NewRestoreSecondaryJob, synchronously; running is Run, exactly as on RestoreJob.

func NewRestoreSecondaryJob(ctx context.Context, params *cfg.Config, store *jobstate.Store, req RestoreSecondaryRequest) (*RestoreSecondaryJob, error)

func (j *RestoreSecondaryJob) Run(ctx context.Context)

func (j *RestoreSecondaryJob) Wait(ctx context.Context) (jobstate.RestoreStatus, error)

type RestoreSecondaryRequest ¶ added in v0.6.1

type RestoreSecondaryRequest struct {
	// TaskID identifies the restore job in the job state store. The transport
	// defaults it when its contract carries no id.
	TaskID string
	// BackupName names the backup artifact to restore.
	BackupName string
	// SourceClusterID is the cluster the backup's DDL was taken from.
	SourceClusterID string
	// TargetClusterID is the cluster the DDL is replayed under.
	TargetClusterID string
}

RestoreSecondaryRequest selects one secondary restore.