backup

Documentation

Index

• Constants
• func NewUnzip(dst string) (unzip, io.WriteCloser)
• func NewZip(sourcePath string, level int) (zip, io.ReadCloser)
• type AbortRequest
• type AbortResponse
• type BackupBackendProvider
• type BackupRequest
• type CanCommitResponse
• type CompressionLevel
• type Handler
  • func NewHandler(logger logrus.FieldLogger, authorizer authorizer, schema schemaManger, ...) *Handler
  • func (m *Handler) OnAbort(ctx context.Context, req *AbortRequest) error
  • func (m *Handler) OnCanCommit(ctx context.Context, req *Request) *CanCommitResponse
  • func (m *Handler) OnCommit(ctx context.Context, req *StatusRequest) (err error)
  • func (m *Handler) OnStatus(ctx context.Context, req *StatusRequest) *StatusResponse
• type Op
• type Request
• type Scheduler
  • func NewScheduler(authorizer authorizer, client client, sourcer selector, ...) *Scheduler
  • func (s *Scheduler) Backup(ctx context.Context, pr *models.Principal, req *BackupRequest) (_ *models.BackupCreateResponse, err error)
  • func (s *Scheduler) BackupStatus(ctx context.Context, principal *models.Principal, backend, backupID string) (_ *Status, err error)
  • func (s *Scheduler) RestorationStatus(ctx context.Context, principal *models.Principal, backend, backupID string) (_ *Status, err error)
  • func (s *Scheduler) Restore(ctx context.Context, pr *models.Principal, req *BackupRequest) (_ *models.BackupRestoreResponse, err error)
• type Sourcer
• type Status
• type StatusRequest
• type StatusResponse

Constants

const (
	// BackupFile used by a node to store its metadata
	BackupFile = "backup.json"
	// GlobalBackupFile used by coordinator to store its metadata
	GlobalBackupFile  = "backup_config.json"
	GlobalRestoreFile = "restore_config.json"
)

const (
	// Version > version1 support compression
	Version = "2.0"
)

Version of backup structure

Functions

func NewUnzip

func NewUnzip(dst string) (unzip, io.WriteCloser)

func NewZip

func NewZip(sourcePath string, level int) (zip, io.ReadCloser)

Types

type AbortRequest

type AbortRequest StatusRequest

type AbortResponse

type AbortResponse StatusResponse

type BackupBackendProvider

type BackupBackendProvider interface {
	BackupBackend(backend string) (modulecapabilities.BackupBackend, error)
}

type BackupRequest

type BackupRequest struct {
	// ID is the backup ID
	ID string
	// Backend specify on which backend to store backups (gcs, s3, ..)
	Backend string

	// Include is list of class which need to be backed up
	// The same class cannot appear in both Include and Exclude in the same request
	Include []string
	// Exclude means include all classes but those specified in Exclude
	// The same class cannot appear in both Include and Exclude in the same request
	Exclude []string
}

type CanCommitResponse

type CanCommitResponse struct {
	// Method is the backup operation (create, restore)
	Method Op
	// ID is the backup ID
	ID string
	// Timeout for how long the promise might be hold
	Timeout time.Duration
	// Err error
	Err string
}

type CompressionLevel

type CompressionLevel int

CompressionLevel represents supported compression level

const (
	DefaultCompression CompressionLevel = iota
	BestSpeed
	BestCompression
	HuffmanOnly
)

type Handler

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

func NewHandler

func NewHandler(
	logger logrus.FieldLogger,
	authorizer authorizer,
	schema schemaManger,
	sourcer Sourcer,
	backends BackupBackendProvider,
) *Handler

func (*Handler) OnAbort

func (m *Handler) OnAbort(ctx context.Context, req *AbortRequest) error

OnAbort will be triggered when the coordinator abort the execution of a previous operation

func (*Handler) OnCanCommit

func (m *Handler) OnCanCommit(ctx context.Context, req *Request) *CanCommitResponse

OnCanCommit will be triggered when coordinator asks the node to participate in a distributed backup operation

func (*Handler) OnCommit

func (m *Handler) OnCommit(ctx context.Context, req *StatusRequest) (err error)

OnCommit will be triggered when the coordinator confirms the execution of a previous operation

func (*Handler) OnStatus

func (m *Handler) OnStatus(ctx context.Context, req *StatusRequest) *StatusResponse

type Op

type Op string

Op is the kind of a backup operation

const (
	OpCreate  Op = "create"
	OpRestore Op = "restore"
)

type Request

type Request struct {
	// Method is the backup operation (create, restore)
	Method Op
	// ID is the backup ID
	ID string
	// Backend specify on which backend to store backups (gcs, s3, ..)
	Backend string

	// Classes is list of class which need to be backed up
	Classes []string

	// Duration
	Duration time.Duration

	// ChunkSize represents the desired size for chunks
	// However, during compression, the chunk size might
	// slightly deviate from this value, being either slightly below or above the specified siz
	ChunkSize int

	CPUPercentage int

	CompressionLevel int
}

type Scheduler

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

Scheduler assigns backup operations to coordinators.

func NewScheduler

func NewScheduler(
	authorizer authorizer,
	client client,
	sourcer selector,
	backends BackupBackendProvider,
	nodeResolver nodeResolver,
	logger logrus.FieldLogger,
) *Scheduler

NewScheduler creates a new scheduler with two coordinators

func (*Scheduler) Backup

func (s *Scheduler) Backup(ctx context.Context, pr *models.Principal, req *BackupRequest,
) (_ *models.BackupCreateResponse, err error)

func (*Scheduler) BackupStatus

func (s *Scheduler) BackupStatus(ctx context.Context, principal *models.Principal,
	backend, backupID string,
) (_ *Status, err error)

func (*Scheduler) RestorationStatus

func (s *Scheduler) RestorationStatus(ctx context.Context, principal *models.Principal, backend, backupID string,
) (_ *Status, err error)

func (*Scheduler) Restore

func (s *Scheduler) Restore(ctx context.Context, pr *models.Principal,
	req *BackupRequest,
) (_ *models.BackupRestoreResponse, err error)

type Sourcer

type Sourcer interface {
	// ReleaseBackup signals to the underlying index that the files have been
	// copied (or the operation aborted), and that it is safe for the index to
	// change the files, such as start compactions.
	ReleaseBackup(_ context.Context, id, class string) error

	// Backupable returns whether all given class can be backed up.
	Backupable(_ context.Context, classes []string) error

	// BackupDescriptors returns a channel of class descriptors.
	// Class descriptor records everything needed to restore a class
	// If an error happens a descriptor with an error will be written to the channel just before closing it.
	//
	// BackupDescriptors acquires resources so that a call to ReleaseBackup() is mandatory to free acquired resources.
	BackupDescriptors(_ context.Context, bakid string, classes []string,
	) <-chan backup.ClassDescriptor

	// ClassExists checks whether a class exits or not
	ClassExists(name string) bool

	// ListBackupable returns a list of all classes which can be backed up.
	//
	// A class cannot be backed up either if it doesn't exist or if it has more than one physical shard.
	ListBackupable() []string
}

Sourcer represents the source of artifacts used in the backup

type Status

type Status struct {
	Path        string
	StartedAt   time.Time
	CompletedAt time.Time
	Status      backup.Status
	Err         string
}

type StatusRequest

type StatusRequest struct {
	// Method is the backup operation (create, restore)
	Method Op
	// ID is the backup ID
	ID string
	// Backend specify on which backend to store backups (gcs, s3, ..)
	Backend string
}

type StatusResponse

type StatusResponse struct {
	// Method is the backup operation (create, restore)
	Method Op
	ID     string
	Status backup.Status
	Err    string
}