backup

Documentation

Index

• Variables
• func Compress(w io.Writer, compression pbm.CompressionType, level *int) (io.WriteCloser, error)
• func NodeSuits(node *pbm.Node, inf *pbm.NodeInfo) (bool, error)
• func Upload(ctx context.Context, src Source, dst storage.Storage, ...) (int64, error)
• type BCoplogTS
• type Backup
  • func New(cn *pbm.PBM, node *pbm.Node) *Backup
  • func NewPhysical(cn *pbm.PBM, node *pbm.Node) *Backup
  • func (b *Backup) Init(bcp pbm.BackupCmd, opid pbm.OPID, balancer pbm.BalancerMode) error
  • func (b *Backup) Run(ctx context.Context, bcp pbm.BackupCmd, opid pbm.OPID, l *plog.Event) (err error)
• type BackupCursor
  • func NewBackupCursor(n *pbm.Node, l *plog.Event) *BackupCursor
  • func (bc *BackupCursor) Close()
  • func (bc *BackupCursor) Data(ctx context.Context) (bcp *BackupCursorData, err error)
  • func (bc *BackupCursor) Journals(upto primitive.Timestamp) ([]pbm.File, error)
• type BackupCursorData
• type Canceller
• type ErrInsuffRange
  • func (e ErrInsuffRange) Error() string
• type Meta
• type NopCloser
  • func (NopCloser) Close() error
• type Oplog
  • func NewOplog(node *pbm.Node) *Oplog
  • func (ot *Oplog) Cancel()
  • func (ot *Oplog) IsSufficient(from primitive.Timestamp) (bool, error)
  • func (ot *Oplog) LastWrite() (primitive.Timestamp, error)
  • func (ot *Oplog) SetTailingSpan(start, end primitive.Timestamp)
  • func (ot *Oplog) WriteTo(w io.Writer) (int64, error)
• type Source
• type UUID
  • func (id *UUID) IsZero() bool
  • func (id UUID) MarshalBSONValue() (bsontype.Type, []byte, error)
  • func (id *UUID) UnmarshalBSONValue(t bsontype.Type, raw []byte) error

Variables

var ErrCancelled = errors.New("backup canceled")

ErrCancelled means backup was canceled

Functions

func Compress

func Compress(w io.Writer, compression pbm.CompressionType, level *int) (io.WriteCloser, error)

Compress makes a compressed writer from the given one

func NodeSuits

func NodeSuits(node *pbm.Node, inf *pbm.NodeInfo) (bool, error)

NodeSuits checks if node can perform backup

func Upload

func Upload(ctx context.Context, src Source, dst storage.Storage, compression pbm.CompressionType, compressLevel *int, fname string, sizeb int) (int64, error)

Upload writes data to dst from given src and returns an amount of written bytes

Types

type BCoplogTS

type BCoplogTS struct {
	TS primitive.Timestamp `bson:"ts"`
	T  int64               `bson:"t"`
}

type Backup

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

func New

func New(cn *pbm.PBM, node *pbm.Node) *Backup

func NewPhysical

func NewPhysical(cn *pbm.PBM, node *pbm.Node) *Backup

func (*Backup) Init

func (b *Backup) Init(bcp pbm.BackupCmd, opid pbm.OPID, balancer pbm.BalancerMode) error

func (*Backup) Run

func (b *Backup) Run(ctx context.Context, bcp pbm.BackupCmd, opid pbm.OPID, l *plog.Event) (err error)

Run runs backup. TODO: describe flow

type BackupCursor

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

func NewBackupCursor

func NewBackupCursor(n *pbm.Node, l *plog.Event) *BackupCursor

func (*BackupCursor) Close

func (bc *BackupCursor) Close()

func (*BackupCursor) Data

func (bc *BackupCursor) Data(ctx context.Context) (bcp *BackupCursorData, err error)

func (*BackupCursor) Journals

func (bc *BackupCursor) Journals(upto primitive.Timestamp) ([]pbm.File, error)

type BackupCursorData

type BackupCursorData struct {
	Meta *Meta
	Data []pbm.File
}

see https://www.percona.com/blog/2021/06/07/experimental-feature-backupcursorextend-in-percona-server-for-mongodb/

type Canceller

type Canceller interface {
	Cancel()
}

type ErrInsuffRange

type ErrInsuffRange struct {
	primitive.Timestamp
}

func (ErrInsuffRange) Error

func (e ErrInsuffRange) Error() string

type Meta

type Meta struct {
	ID           UUID                `bson:"backupId"`
	DBpath       string              `bson:"dbpath"`
	OplogStart   BCoplogTS           `bson:"oplogStart"`
	OplogEnd     BCoplogTS           `bson:"oplogEnd"`
	CheckpointTS primitive.Timestamp `bson:"checkpointTimestamp"`
}

type NopCloser

type NopCloser struct {
	io.Writer
}

NopCloser wraps an io.Witer as io.WriteCloser with noop Close

func (NopCloser) Close

func (NopCloser) Close() error

Close to satisfy io.WriteCloser interface

type Oplog

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

Oplog is used for reading the Mongodb oplog

func NewOplog

func NewOplog(node *pbm.Node) *Oplog

NewOplog creates a new Oplog instance

func (*Oplog) Cancel

func (ot *Oplog) Cancel()

func (*Oplog) IsSufficient

func (ot *Oplog) IsSufficient(from primitive.Timestamp) (bool, error)

IsSufficient check is oplog is sufficient back from the given date

func (*Oplog) LastWrite

func (ot *Oplog) LastWrite() (primitive.Timestamp, error)

LastWrite returns a timestamp of the last write operation readable by majority reads

func (*Oplog) SetTailingSpan

func (ot *Oplog) SetTailingSpan(start, end primitive.Timestamp)

SetTailingSpan sets oplog tailing window

func (*Oplog) WriteTo

func (ot *Oplog) WriteTo(w io.Writer) (int64, error)

WriteTo writes an oplog slice between start and end timestamps into the given io.Writer

To be sure we have read ALL records up to the specified cluster time. Specifically, to be sure that no operations from the past gonna came after we finished the slicing, we have to tail until some record with ts > endTS. And it might be a noop.

type Source

type Source interface {
	io.WriterTo
}

type UUID

type UUID struct{ uuid.UUID }

UUID represents a UUID as saved in MongoDB

func (*UUID) IsZero

func (id *UUID) IsZero() bool

IsZero implements the bson.Zeroer interface.

func (UUID) MarshalBSONValue

func (id UUID) MarshalBSONValue() (bsontype.Type, []byte, error)

MarshalBSONValue implements the bson.ValueMarshaler interface.

func (*UUID) UnmarshalBSONValue

func (id *UUID) UnmarshalBSONValue(t bsontype.Type, raw []byte) error

UnmarshalBSONValue implements the bson.ValueUnmarshaler interface.