internal

package

Go to main page

Versions in this module

v1

v1.1.3-rc-with-build

Dec 9, 2021

v1.1.3-rc

Dec 9, 2021

v1.1.2-rc

Nov 25, 2021

v1.1.1

Nov 12, 2021

Changes in this version

+ const GP

+ const GPLogsDirectory

+ const MysqlCheckGTIDs

+ const PgReadyRename

+ const RedisPassword

+ const SQLServerDBConcurrency

+ const SQLServerReuseProxy

+ const SerializerTypeSetting

+ const StoragePrefixSetting

+ const StreamBackupNameLength

+ const UseCopyComposerSetting

+ var GPAllowedSettings = map[string]bool

+ var GPDefaultSettings = map[string]string

+ var RedisAllowedSettings = map[string]bool

+ var SQLServerDefaultSettings = map[string]string

+ func ConfigurePGArchiveStatusManager() (fsutil.DataFolder, error)

+ func ConfigureStoragePrefix(folder storage.Folder) storage.Folder

+ func DecryptBytes(archiveReader io.ReadCloser) (io.ReadCloser, error)

+ func DeleteBackups(folder storage.Folder, backups []string) error

+ func DeleteGarbage(folder storage.Folder, garbage []string) error

+ func ExtractAllWithSleeper(tarInterpreter TarInterpreter, files []ReaderMaker, sleeper Sleeper) error

+ func ExtractDeleteModifierFromArgs(args []string) (int, string)

+ func ExtractDeleteRetainAfterModifierFromArgs(args []string) (int, string, string)

+ func FindPermanentBackups(folder storage.Folder, metaFetcher GenericMetaFetcher) map[string]bool

+ func FormatTime(backupTime time.Time) string

+ func FormatTimeInner(backupTime time.Time, timeFormat string) string

+ func GetGarbageFromPrefix(folders []storage.Folder, nonGarbage []BackupTime) []string

+ func PrettyFormatTime(backupTime time.Time) string

+ func SortBackupTimeSlices(backupTimes []BackupTime)

+ func SortTimedBackup(backups []TimedBackup)

+ func SplitPurgingBackups(backups []TimedBackup, retainCount *int, retainAfter *time.Time) (purge, retain map[string]bool, err error)

type Backup

+ func (backup *Backup) FetchDto(dto interface{}, path string) error

type BackupObject

+ func FindBackupObjects(folder storage.Folder) ([]BackupObject, error)

type BackupSelector

+ func CreateTargetDeleteBackupSelector(cmd *cobra.Command, args []string, targetUserData string, ...) (BackupSelector, error)

type DeleteHandler

+ func (h *DeleteHandler) DeleteBeforeTargetWhere(target BackupObject, confirmed bool, selector func(object storage.Object) bool) error

+ func (h *DeleteHandler) FindTargetBefore(beforeStr string, modifier int) (BackupObject, error)

+ func (h *DeleteHandler) FindTargetRetainAfter(retentionCount int, afterStr string, modifier int) (BackupObject, error)

type DeleteHandlerOption

+ func IsIgnoredFunc(isIgnored func(storage.Object) bool) DeleteHandlerOption

+ type DtoSerializer interface

+ Marshal func(dto interface{}) (io.Reader, error)

+ Unmarshal func(reader io.Reader, dto interface{}) error

+ func NewDtoSerializer() (DtoSerializer, error)

+ type DtoSerializerType string

+ const RegularJSONSerializer

+ const StreamedJSONSerializer

+ type ExponentialSleeper struct

+ func NewExponentialSleeper(startSleepDuration, sleepDurationBound time.Duration) *ExponentialSleeper

+ func (sleeper *ExponentialSleeper) Sleep()

+ type RegularJSON struct

+ func (r RegularJSON) Marshal(dto interface{}) (io.Reader, error)

+ func (r RegularJSON) Unmarshal(reader io.Reader, dto interface{}) error

+ type Sleeper interface

+ Sleep func()

+ type StreamedJSON struct

+ func (s StreamedJSON) Marshal(dto interface{}) (io.Reader, error)

+ func (s StreamedJSON) Unmarshal(reader io.Reader, dto interface{}) error

+ type TimedBackup interface

+ IsPermanent func() bool

+ Name func() string

+ StartTime func() time.Time

+ type UnknownSerializerTypeError struct

+ func NewUnknownSerializerTypeError(serializerType DtoSerializerType) UnknownSerializerTypeError

+ func (err UnknownSerializerTypeError) Error() string

type Uploader

+ PGArchiveStatusManager asm.ArchiveStatusManager

v1.1.1-rc

Nov 12, 2021

v0

v0.2.22

May 12, 2021

Changes in this version

+ const AwsAccessKeyID

+ const DeleteTargetExamples

+ const DeleteTargetUsageExample

+ const DeleteTargetUserDataDescription

+ const DeleteTargetUserDataFlag

+ const FDB

+ const FetchTargetUserDataSetting

+ const HTTPExposeExpVar

+ const HTTPExposePprof

+ const HTTPListen

+ const MONGO

+ const MYSQL

+ const OplogPushStatsExposeHTTP

+ const PG

+ const PrefetchDir

+ const REDIS

+ const SQLSERVER

+ const UploadWalMetadata

+ const YcKmsKeyIDSetting

+ var CommonAllowedSettings = map[string]bool

+ var ErrorSizeTrackingDisabled = fmt.Errorf("size tracking disabled by DisableSizeTracking method")

+ var HTTPSettingExposeFuncs = map[string]func(webserver.WebServer)

+ var MongoAllowedSettings = map[string]bool

+ var MongoDefaultSettings = map[string]string

+ var MysqlAllowedSettings = map[string]bool

+ var PGAllowedSettings = map[string]bool

+ var PGDefaultSettings = map[string]string

+ var SQLServerAllowedSettings = map[string]bool

+ func ConfigureCompressor() (compression.Compressor, error)

+ func ConfigureSettings(currentType string)

+ func DeleteTargetArgsValidator(cmd *cobra.Command, args []string) error

+ func DownloadFileTo(folder storage.Folder, fileName string, dstPath string) error

+ func ExtractDeleteTargetModifierFromArgs(args []string) int

+ func FolderSize(folder storage.Folder, path string) (int64, error)

+ func GetPermanentBackups(folder storage.Folder, metaFetcher GenericMetaFetcher) map[string]bool

+ func GetRelativeArchiveDataFolderPath() string

+ func UnwrapLatestModifier(backupName string, folder storage.Folder) (string, error)

+ func WriteAsJSON(data interface{}, output io.Writer, pretty bool) error

type Backup

+ Folder storage.Folder

+ func (backup *Backup) AssureExists() error

+ func (backup *Backup) FetchMetadata(metadataDto interface{}) error

+ func (backup *Backup) SentinelExists() (bool, error)

+ func (backup *Backup) UploadMetadata(metadataDto interface{}) error

+ func (backup *Backup) UploadSentinel(sentinelDto interface{}) error

+ type BackupMarkHandler struct

+ func NewBackupMarkHandler(metaInteractor GenericMetaInteractor, storageRootFolder storage.Folder) BackupMarkHandler

+ func (h *BackupMarkHandler) GetBackupsToMark(backupName string, toPermanent bool) ([]string, error)

+ func (h *BackupMarkHandler) MarkBackup(backupName string, toPermanent bool)

type BackupObject

+ func NewDefaultBackupObject(object storage.Object) BackupObject

+ GetBackupName func() string

+ GetBaseBackupName func() string

+ GetIncrementFromName func() string

type BackupSelector

+ func NewTargetBackupSelector(targetUserData, targetName string, metaFetcher GenericMetaFetcher) (BackupSelector, error)

+ type DefaultBackupObject struct

+ func (o DefaultBackupObject) GetBackupName() string

+ func (o DefaultBackupObject) GetBackupTime() time.Time

+ func (o DefaultBackupObject) GetBaseBackupName() string

+ func (o DefaultBackupObject) GetIncrementFromName() string

+ func (o DefaultBackupObject) IsFullBackup() bool

type DeleteHandler

+ func (h *DeleteHandler) DeleteTargets(targets []BackupObject, confirmed bool) error

+ func (h *DeleteHandler) HandleDeleteEverything(args []string, permanentBackups map[string]bool, confirmed bool)

+ func (h *DeleteHandler) HandleDeleteTarget(targetSelector BackupSelector, confirmed, findFull bool)

+ type ErrWaiter interface

+ Wait func() error

+ type GenericMetaFetcher interface

+ Fetch func(backupName string, backupFolder storage.Folder) (GenericMetadata, error)

+ type GenericMetaInteractor interface

+ type GenericMetaSetter interface

+ SetIsPermanent func(backupName string, backupFolder storage.Folder, isPermanent bool) error

+ SetUserData func(backupName string, backupFolder storage.Folder, userData interface{}) error

+ type GenericMetadata struct

+ BackupName string

+ CompressedSize int64

+ FinishTime time.Time

+ Hostname string

+ IncrementDetails IncrementDetailsFetcher

+ IsIncremental bool

+ IsPermanent bool

+ StartTime time.Time

+ UncompressedSize int64

+ UserData interface{}

+ type IncrementDetails struct

+ IncrementCount int

+ IncrementFrom string

+ IncrementFullName string

+ type IncrementDetailsFetcher interface

+ Fetch func() (isIncremental bool, details IncrementDetails, err error)

+ type MetaConstructor interface

+ Finalize func(backupName string) error

+ Init func() error

+ MetaInfo func() interface{}

+ type NopIncrementDetailsFetcher struct

+ func (idf *NopIncrementDetailsFetcher) Fetch() (bool, IncrementDetails, error)

type Sentinel

+ Path string

type TarBallQueue

+ func NewTarBallQueue(tarSizeThreshold int64, tarBallMaker TarBallMaker) *TarBallQueue

+ func (tarQueue *TarBallQueue) DequeCtx(ctx context.Context) (TarBall, error)

type Uploader

+ func (uploader *Uploader) Finish()

+ func (uploader *Uploader) RawDataSize() (int64, error)

+ func (uploader *Uploader) UploadedDataSize() (int64, error)

type UploaderProvider

+ RawDataSize func() (int64, error)

+ UploadedDataSize func() (int64, error)

type WithSizeReader

+ func NewWithSizeReader(underlying io.Reader, readSize *int64) *WithSizeReader

v0.2.21

Mar 16, 2021

Changes in this version

+ const DeltaFromNameSetting

+ const DeltaFromUserDataSetting

+ const TargetUserDataSetting

+ func UnmarshalSentinelUserData(userDataStr string) interface

+ type BackupNameSelector struct

+ func NewBackupNameSelector(backupName string) (BackupNameSelector, error)

+ func (s BackupNameSelector) Select(folder storage.Folder) (string, error)

+ type BackupSelector interface

+ Select func(folder storage.Folder) (string, error)

+ type LatestBackupSelector struct

+ func NewLatestBackupSelector() LatestBackupSelector

+ func (s LatestBackupSelector) Select(folder storage.Folder) (string, error)

+ type UserDataBackupSelector struct

+ func NewUserDataBackupSelector(userDataRaw string) UserDataBackupSelector

+ func (s UserDataBackupSelector) Select(folder storage.Folder) (string, error)

v0.2.20

Feb 20, 2021

Changes in this version

+ const MaxDelayedSegmentsCount

+ const PatternTimelineAndLogSegNo

+ const SQLServerBlobLockFile

+ const WalVerifyIntegrityCheck

+ const WalVerifyTimelineCheck

+ const YcKmsKeyIdSetting

+ const YcSaKeyFileSetting

+ func DefaultHandleBackupListWithTarget(folder storage.Folder, targetPath string)

+ func ExtractDeleteEverythingModifierFromArgs(args []string) int

+ func GetBackupSentinelObjects(folder storage.Folder) ([]storage.Object, error)

+ func GetPermanentObjects(folder storage.Folder) (map[string]bool, map[string]bool)

+ func HandleBackupListWithFlagsAndTarget(folder storage.Folder, pretty bool, json bool, detail bool, targetPath string)

+ func IsPermanent(objectName string, permanentBackups, permanentWals map[string]bool) bool

+ func ParseTimelineFromString(timelineString string) (uint32, error)

+ func TryFetchTimelineAndLogSegNo(objectName string) (uint32, uint64, bool)

+ type BackupConfig struct

type BackupDetail

+ func GetBackupDetails(folder storage.Folder, backupTime BackupTime) (BackupDetail, error)

+ func GetBackupDetailsWithTarget(folder storage.Folder, backupTime BackupTime, targetPath string) (BackupDetail, error)

+ func GetBackupsDetails(folder storage.Folder, backups []BackupTime) ([]BackupDetail, error)

+ func GetBackupsDetailsWithTarget(folder storage.Folder, backups []BackupTime, targetPath string) ([]BackupDetail, error)

+ type BackupObject interface

+ GetBackupTime func() time.Time

+ IsFullBackup func() bool

type BackupSentinelDto

+ func NewBackupSentinelDto(backupStartLSN, backupFinishLSN uint64, bc *BackupConfig, pgVersion int, ...) *BackupSentinelDto

type BackupTime

+ func GetBackupTimeSlices(backups []storage.Object) []BackupTime

+ func GetBackups(folder storage.Folder) (backups []BackupTime, err error)

+ func GetBackupsAndGarbageWithTarget(folder storage.Folder, targetPath string) (backups []BackupTime, garbage []string, err error)

+ func GetBackupsWithTarget(folder storage.Folder, targetPath string) (backups []BackupTime, err error)

+ type DeleteHandler struct

+ Folder storage.Folder

+ func NewDeleteHandler(folder storage.Folder, backups []BackupObject, ...) *DeleteHandler

+ func (h *DeleteHandler) DeleteBeforeTarget(target BackupObject, confirmed bool) error

+ func (h *DeleteHandler) DeleteEverything(confirmed bool)

+ func (h *DeleteHandler) FindTargetBeforeName(name string, modifier int) (BackupObject, error)

+ func (h *DeleteHandler) FindTargetBeforeTime(timeLine time.Time, modifier int) (BackupObject, error)

+ func (h *DeleteHandler) FindTargetByName(bname string) (BackupObject, error)

+ func (h *DeleteHandler) FindTargetRetain(retentionCount, modifier int) (BackupObject, error)

+ func (h *DeleteHandler) FindTargetRetainAfterName(retentionCount int, name string, modifier int) (BackupObject, error)

+ func (h *DeleteHandler) FindTargetRetainAfterTime(retentionCount int, timeLine time.Time, modifier int) (BackupObject, error)

+ func (h *DeleteHandler) HandleDeleteBefore(args []string, confirmed bool)

+ func (h *DeleteHandler) HandleDeleteRetain(args []string, confirmed bool)

+ func (h *DeleteHandler) HandleDeleteRetainAfter(args []string, confirmed bool)

+ type DeleteHandlerOption func(h *DeleteHandler)

+ func IsPermanentFunc(isPermanent func(storage.Object) bool) DeleteHandlerOption

type ExponentialRetrier

+ func (retrier *ExponentialRetrier) Retry()

+ type FileNotExistError struct

+ func (err FileNotExistError) Error() string

+ type IntegrityCheckDetails []*IntegrityScanSegmentSequence

+ func (sequences IntegrityCheckDetails) NewPlainTextReader() (io.Reader, error)

+ type IntegrityCheckRunner struct

+ func NewIntegrityCheckRunner(rootFolder storage.Folder, walFolderFilenames []string, ...) (IntegrityCheckRunner, error)

+ func (check IntegrityCheckRunner) Run() (WalVerifyCheckResult, error)

+ func (check IntegrityCheckRunner) Type() WalVerifyCheckType

+ type IntegrityScanSegmentSequence struct

+ EndSegment string

+ SegmentsCount int

+ StartSegment string

+ Status ScannedSegmentStatus

+ TimelineId uint32

type ScannedSegmentStatus

+ func (status ScannedSegmentStatus) MarshalText() ([]byte, error)

+ type TimelineCheckDetails struct

+ CurrentTimelineId uint32

+ HighestStorageTimelineId uint32

+ func (details TimelineCheckDetails) NewPlainTextReader() (io.Reader, error)

+ type TimelineCheckRunner struct

+ func NewTimelineCheckRunner(walFolderFilenames []string, currentSegment WalSegmentDescription) (TimelineCheckRunner, error)

+ func (check TimelineCheckRunner) Name() string

+ func (check TimelineCheckRunner) Run() (WalVerifyCheckResult, error)

+ func (check TimelineCheckRunner) Type() WalVerifyCheckType

+ type UnknownWalVerifyCheckError struct

+ func NewUnknownWalVerifyCheckError(checkType WalVerifyCheckType) UnknownWalVerifyCheckError

+ func (err UnknownWalVerifyCheckError) Error() string

type UploadObject

+ func GetMetadataUploadObject(backupName string, meta *ExtendedMetadataDto) (UploadObject, error)

type WalSegmentDescription

+ func NewWalSegmentDescription(name string) (WalSegmentDescription, error)

+ type WalVerifyCheckDetails interface

+ NewPlainTextReader func() (io.Reader, error)

+ type WalVerifyCheckResult struct

+ Details WalVerifyCheckDetails

+ Status WalVerifyCheckStatus

+ type WalVerifyCheckRunner interface

+ Run func() (WalVerifyCheckResult, error)

+ Type func() WalVerifyCheckType

+ func BuildWalVerifyCheckRunner(checkType WalVerifyCheckType, rootFolder storage.Folder, ...) (WalVerifyCheckRunner, error)

+ type WalVerifyCheckStatus int

+ const StatusFailure

+ const StatusOk

+ const StatusWarning

+ func (status WalVerifyCheckStatus) MarshalText() ([]byte, error)

+ func (status WalVerifyCheckStatus) String() string

+ type WalVerifyCheckType int

+ func (checkType WalVerifyCheckType) MarshalText() (text []byte, err error)

+ func (checkType WalVerifyCheckType) String() string

v0.2.19

Nov 30, 2020

Changes in this version

+ const PgWalSize

+ var Turbo bool

+ func ParseTimelineFromBackupName(backupName string) (uint32, error)

+ func SetWalSize(sizeMb uint64)

+ type IncorrectBackupNameError struct

+ func (err IncorrectBackupNameError) Error() string

+ type NoCorrectBackupFoundError struct

+ func (err NoCorrectBackupFoundError) Error() string

v0.2.18

Nov 6, 2020

Changes in this version

+ const AwsAccessKeyId

+ const AwsSecretAccessKey

+ const EndpointPortSetting

+ const EndpointSourceSetting

+ const FnvPrime

+ const MaxCorruptBlocksInFileDesc

+ const MysqlTakeBinlogsFromMaster

+ const NSums

+ const OplogReplayIgnoreErrorCodes

+ const OplogReplayOplogAlwaysUpsert

+ const OplogReplayOplogApplicationMode

+ const PdChecksumLen

+ const PdChecksumOffset

+ const PgSlotName

+ const StoreAllCorruptBlocksSetting

+ const TimelineLostSegmentStatus

+ const TimelineOkStatus

+ const UseRatingComposerSetting

+ const VerifyPageChecksumsSetting

+ func DownloadAndDecompressStorageFile(folder storage.Folder, fileName string) (io.ReadCloser, error)

+ func FolderFromConfig(configFile string) (storage.Folder, error)

+ func GetBoolSettingDefault(setting string, def bool) (bool, error)

+ func GetLastWalFilename(backup *Backup) (string, error)

+ func GetPgSlotName() (pgSlotName string)

+ func HandleWALReceive(uploader *WalUploader)

+ func HandleWalShow(rootFolder storage.Folder, showBackups bool, outputWriter WalShowOutputWriter)

+ func HandleWalVerify(rootFolder storage.Folder, startWalSegment WalSegmentDescription, ...)

+ func ReadIncrementLocations(filePath string, fileSize int64, lsn uint64) ([]walparser.BlockLocation, error)

+ func ValidateSlotName(pgSlotName string) (err error)

+ func VerifyPagedFileBase(path string, fileInfo os.FileInfo, pagedFile io.Reader) ([]uint32, error)

+ func VerifyPagedFileIncrement(path string, fileInfo os.FileInfo, increment io.Reader) ([]uint32, error)

type BackupFileDescription

+ CorruptBlocks *CorruptBlocksInfo

+ UpdatesCount uint64

+ func (desc *BackupFileDescription) SetCorruptBlocks(corruptBlockNumbers []uint32, storeAllBlocks bool)

type Bundle

+ TarBallComposer TarBallComposer

+ TarBallQueue *TarBallQueue

+ func (bundle *Bundle) PackTarballs() (TarFileSets, error)

+ func (bundle *Bundle) SetupComposer(composerMaker TarBallComposerMaker) (err error)

+ type BundleFiles interface

+ AddFile func(tarHeader *tar.Header, fileInfo os.FileInfo, isIncremented bool)

+ AddFileWithCorruptBlocks func(tarHeader *tar.Header, fileInfo os.FileInfo, isIncremented bool, ...)

+ AddSkippedFile func(tarHeader *tar.Header, fileInfo os.FileInfo)

+ GetUnderlyingMap func() *sync.Map

+ type ComposeFileInfo struct

+ func NewComposeFileInfo(path string, fileInfo os.FileInfo, wasInBase, isIncremented bool, ...) *ComposeFileInfo

+ type ComposeRatingEvaluator interface

+ Evaluate func(path string, updatesCount uint64, wasInBase bool) uint64

+ type CorruptBlocksInfo struct

+ CorruptBlocksCount int

+ SomeCorruptBlocks []uint32

+ type DefaultComposeRatingEvaluator struct

+ func NewDefaultComposeRatingEvaluator(incrementFromFiles BackupFileList) *DefaultComposeRatingEvaluator

+ func (evaluator *DefaultComposeRatingEvaluator) Evaluate(path string, updatesCount uint64, wasInBase bool) uint64

+ type HistoryFileNotFoundError struct

+ func (err HistoryFileNotFoundError) Error() string

+ type IgnoredFileError struct

+ func (err IgnoredFileError) Error() string

type NOPTarBall

+ func (tarBall *NOPTarBall) Name() string

+ type PgChecksummablePage [DatabasePageSize / int64(NSums*sizeofInt32)][NSums]uint32

+ type PgDatabaseInfo struct

+ type PgDatabasePage [DatabasePageSize]byte

type PgQueryRunner

+ func (queryRunner *PgQueryRunner) BuildGetDatabasesQuery() (string, error)

+ func (queryRunner *PgQueryRunner) BuildStatisticsQuery() (string, error)

+ func (queryRunner *PgQueryRunner) GetParameter(parameterName string) (string, error)

+ func (queryRunner *PgQueryRunner) GetPhysicalSlotInfo(slotName string) (PhysicalSlot, error)

+ func (queryRunner *PgQueryRunner) GetWalSegmentBytes() (segBlocks uint64, err error)

+ type PgRelationStat struct

+ type PhysicalSlot struct

+ Active bool

+ Exists bool

+ Name string

+ RestartLSN pglogrepl.LSN

+ func NewPhysicalSlot(name string, exists bool, active bool, restartLSN string) (slot PhysicalSlot, err error)

+ type ProcessMessageResult int

+ const ProcessMessageCopyDone

+ const ProcessMessageMismatch

+ const ProcessMessageOK

+ const ProcessMessageReplyRequested

+ const ProcessMessageSegmentGap

+ const ProcessMessageUnknown

+ type RatedComposeFileInfo struct

+ type RatingTarBallComposer struct

+ func NewRatingTarBallComposer(tarSizeThreshold uint64, updateRatingEvaluator ComposeRatingEvaluator, ...) (*RatingTarBallComposer, error)

+ func (c *RatingTarBallComposer) AddFile(info *ComposeFileInfo)

+ func (c *RatingTarBallComposer) AddHeader(fileInfoHeader *tar.Header, info os.FileInfo) error

+ func (c *RatingTarBallComposer) GetFiles() BundleFiles

+ func (c *RatingTarBallComposer) PackTarballs() (TarFileSets, error)

+ func (c *RatingTarBallComposer) SkipFile(tarHeader *tar.Header, fileInfo os.FileInfo)

+ type RatingTarBallComposerMaker struct

+ func NewRatingTarBallComposerMaker(relFileStats RelFileStatistics, filePackerOptions TarBallFilePackerOptions) (*RatingTarBallComposerMaker, error)

+ func (maker *RatingTarBallComposerMaker) Make(bundle *Bundle) (TarBallComposer, error)

+ type ReachedStopSegmentError struct

+ func (err ReachedStopSegmentError) Error() string

+ type RegularBundleFiles struct

+ func (files *RegularBundleFiles) AddFile(tarHeader *tar.Header, fileInfo os.FileInfo, isIncremented bool)

+ func (files *RegularBundleFiles) AddFileWithCorruptBlocks(tarHeader *tar.Header, fileInfo os.FileInfo, isIncremented bool, ...)

+ func (files *RegularBundleFiles) AddSkippedFile(tarHeader *tar.Header, fileInfo os.FileInfo)

+ func (files *RegularBundleFiles) GetUnderlyingMap() *sync.Map

+ type RegularTarBallComposer struct

+ func NewRegularTarBallComposer(tarBallQueue *TarBallQueue, tarBallFilePacker *TarBallFilePacker, ...) *RegularTarBallComposer

+ func (c *RegularTarBallComposer) AddFile(info *ComposeFileInfo)

+ func (c *RegularTarBallComposer) AddHeader(fileInfoHeader *tar.Header, info os.FileInfo) error

+ func (c *RegularTarBallComposer) GetFiles() BundleFiles

+ func (c *RegularTarBallComposer) PackTarballs() (TarFileSets, error)

+ func (c *RegularTarBallComposer) SkipFile(tarHeader *tar.Header, fileInfo os.FileInfo)

+ type RegularTarBallComposerMaker struct

+ func NewRegularTarBallComposerMaker(filePackerOptions TarBallFilePackerOptions) *RegularTarBallComposerMaker

+ func (maker *RegularTarBallComposerMaker) Make(bundle *Bundle) (TarBallComposer, error)

+ type RelFileStatistics map[walparser.RelFileNode]PgRelationStat

+ type ScannedSegmentDescription struct

+ type ScannedSegmentStatus int

+ const Found

+ const Lost

+ const ProbablyDelayed

+ const ProbablyUploading

+ func (status ScannedSegmentStatus) MarshalJSON() ([]byte, error)

+ func (status ScannedSegmentStatus) String() string

+ type SegmentScanConfig struct

+ MissingSegmentStatus ScannedSegmentStatus

+ ScanSegmentsLimit int

+ StopOnFirstFoundSegment bool

+ UnlimitedScan bool

+ type SkippedFileError struct

+ func (err SkippedFileError) Error() string

+ type StatBundleFiles struct

+ func (files *StatBundleFiles) AddFile(tarHeader *tar.Header, fileInfo os.FileInfo, isIncremented bool)

+ func (files *StatBundleFiles) AddFileWithCorruptBlocks(tarHeader *tar.Header, fileInfo os.FileInfo, isIncremented bool, ...)

+ func (files *StatBundleFiles) AddSkippedFile(tarHeader *tar.Header, fileInfo os.FileInfo)

+ func (files *StatBundleFiles) GetUnderlyingMap() *sync.Map

type StorageTarBall

+ func (tarBall *StorageTarBall) Name() string

type TarBall

+ Name func() string

+ type TarBallComposer interface

+ AddFile func(info *ComposeFileInfo)

+ AddHeader func(header *tar.Header, fileInfo os.FileInfo) error

+ GetFiles func() BundleFiles

+ PackTarballs func() (TarFileSets, error)

+ SkipFile func(tarHeader *tar.Header, fileInfo os.FileInfo)

+ type TarBallComposerMaker interface

+ Make func(bundle *Bundle) (TarBallComposer, error)

+ func NewTarBallComposerMaker(composerType TarBallComposerType, conn *pgx.Conn, ...) (TarBallComposerMaker, error)

+ type TarBallComposerType int

+ const RatingComposer

+ const RegularComposer

+ type TarBallFilePacker struct

+ func (p *TarBallFilePacker) PackFileIntoTar(cfi *ComposeFileInfo, tarBall TarBall) error

+ func (p *TarBallFilePacker) UpdateDeltaMap(deltaMap PagedFileDeltaMap)

+ type TarBallFilePackerOptions struct

+ func NewTarBallFilePackerOptions(verifyPageChecksums, storeAllCorruptBlocks bool) TarBallFilePackerOptions

+ type TarBallQueue struct

+ AllTarballsSize *int64

+ LastCreatedTarball TarBall

+ TarBallMaker TarBallMaker

+ TarSizeThreshold int64

+ func (tarQueue *TarBallQueue) CheckSizeAndEnqueueBack(tarBall TarBall) error

+ func (tarQueue *TarBallQueue) CloseTarball(tarBall TarBall) error

+ func (tarQueue *TarBallQueue) Deque() TarBall

+ func (tarQueue *TarBallQueue) EnqueueBack(tarBall TarBall)

+ func (tarQueue *TarBallQueue) FinishQueue() error

+ func (tarQueue *TarBallQueue) FinishTarBall(tarBall TarBall) error

+ func (tarQueue *TarBallQueue) NewTarBall(dedicatedUploader bool) TarBall

+ func (tarQueue *TarBallQueue) StartQueue() error

+ type TarFileSets map[string][]string

+ type TarFilesCollection struct

+ func (collection *TarFilesCollection) AddFile(file *RatedComposeFileInfo)

+ type TimeLineHistFile struct

+ Filename string

+ TimeLineID uint32

+ func NewTimeLineHistFile(timelineid uint32, filename string, body []byte) (TimeLineHistFile, error)

+ func (tlh TimeLineHistFile) LSNToTimeLine(lsn pglogrepl.LSN) (uint32, error)

+ func (tlh TimeLineHistFile) Name() string

+ func (tlh TimeLineHistFile) Read(p []byte) (n int, err error)

+ type TimeLineHistFileRow struct

+ Comment string

+ StartLSN pglogrepl.LSN

+ TimeLineID uint32

+ type TimelineHistoryRecord struct

+ func NewTimelineHistoryRecord(timeline uint32, lsn uint64, comment string) *TimelineHistoryRecord

+ type TimelineInfo struct

+ Backups []*BackupDetail

+ EndSegment string

+ Id uint32

+ MissingSegments []string

+ ParentId uint32

+ SegmentRangeSize uint64

+ SegmentsCount int

+ StartSegment string

+ Status string

+ SwitchPointLsn uint64

+ func NewTimelineInfo(walSegments *WalSegmentsSequence, historyRecords []*TimelineHistoryRecord) (*TimelineInfo, error)

+ type WalIntegrityScanSegmentSequence struct

+ EndSegment string

+ SegmentsCount int

+ StartSegment string

+ Status ScannedSegmentStatus

+ TimelineId uint32

+ type WalSegment struct

+ StartLSN pglogrepl.LSN

+ TimeLine uint32

+ func NewWalSegment(timeline uint32, location pglogrepl.LSN, walSegmentBytes uint64) *WalSegment

+ func (seg *WalSegment) Name() string

+ func (seg *WalSegment) NextWalSegment() (*WalSegment, error)

+ func (seg *WalSegment) Read(p []byte) (n int, err error)

+ func (seg *WalSegment) Stream(conn *pgconn.PgConn, standbyMessageTimeout time.Duration) (ProcessMessageResult, error)

+ type WalSegmentDescription struct

+ Number WalSegmentNo

+ Timeline uint32

+ func QueryCurrentWalSegment() WalSegmentDescription

+ func (desc WalSegmentDescription) GetFileName() string

+ type WalSegmentNotFoundError struct

+ func (err WalSegmentNotFoundError) Error() string

+ type WalSegmentRunner struct

+ func NewWalSegmentRunner(startWalSegment WalSegmentDescription, segments map[WalSegmentDescription]bool, ...) *WalSegmentRunner

+ func (r *WalSegmentRunner) Current() WalSegmentDescription

+ func (r *WalSegmentRunner) ForceMoveNext()

+ func (r *WalSegmentRunner) Next() (WalSegmentDescription, error)

+ type WalSegmentScanner struct

+ ScannedSegments []ScannedSegmentDescription

+ func NewWalSegmentScanner(walSegmentRunner *WalSegmentRunner) *WalSegmentScanner

+ func (scanner *WalSegmentScanner) AddScannedSegment(description WalSegmentDescription, status ScannedSegmentStatus)

+ func (scanner *WalSegmentScanner) GetMissingSegmentsDescriptions() []WalSegmentDescription

+ func (scanner *WalSegmentScanner) Scan(config SegmentScanConfig) error

+ type WalSegmentsSequence struct

+ func NewSegmentsSequence(id uint32, segmentNo WalSegmentNo) *WalSegmentsSequence

+ func (seq *WalSegmentsSequence) AddWalSegmentNo(number WalSegmentNo)

+ func (seq *WalSegmentsSequence) FindMissingSegments() ([]WalSegmentDescription, error)

+ type WalShowJsonOutputWriter struct

+ func (writer *WalShowJsonOutputWriter) Write(timelineInfos []*TimelineInfo) error

+ type WalShowOutputType int

+ const JsonOutput

+ const TableOutput

+ type WalShowOutputWriter interface

+ Write func(timelineInfos []*TimelineInfo) error

+ func NewWalShowOutputWriter(outputType WalShowOutputType, output io.Writer, includeBackups bool) WalShowOutputWriter

+ type WalShowTableOutputWriter struct

+ func (writer *WalShowTableOutputWriter) Write(timelineInfos []*TimelineInfo) error

+ type WalStorageStatus int

+ const Failure

+ const Ok

+ const Warning

+ func (storageStatus WalStorageStatus) MarshalJSON() ([]byte, error)

+ func (storageStatus WalStorageStatus) String() string

+ type WalVerifyJsonOutputWriter struct

+ func (writer *WalVerifyJsonOutputWriter) Write(result WalVerifyResult) error

+ type WalVerifyOutputType int

+ const WalVerifyJsonOutput

+ const WalVerifyTableOutput

+ type WalVerifyOutputWriter interface

+ Write func(result WalVerifyResult) error

+ func NewWalVerifyOutputWriter(outputType WalVerifyOutputType, output io.Writer) WalVerifyOutputWriter

+ type WalVerifyResult struct

+ IntegrityScanResult []*WalIntegrityScanSegmentSequence

+ StorageStatus WalStorageStatus

+ type WalVerifyTableOutputWriter struct

+ func (writer *WalVerifyTableOutputWriter) Write(result WalVerifyResult) error

v0.2.17

Aug 14, 2020

Changes in this version

+ const GoMaxProcs

+ const HttpExposeExpVar

+ const HttpExposePprof

+ const HttpListen

+ const MongoDBLastWriteUpdateInterval

+ const OplogArchiveTimeoutInterval

+ const OplogPITRDiscoveryInterval

+ const OplogPushPrimaryCheckInterval

+ const OplogPushStatsEnabled

+ const OplogPushStatsExposeHttp

+ const OplogPushStatsLoggingInterval

+ const OplogPushStatsUpdateInterval

+ const OplogPushWaitForBecomePrimary

+ const SQLServerBlobCertFile

+ const SQLServerBlobDebug

+ const SQLServerBlobHostname

+ const SQLServerBlobKeyFile

+ const SQLServerConnectionString

+ const SkipRedundantTarsSetting

+ const UseReverseUnpackSetting

+ var HttpSettingExposeFuncs = map[string]func(webserver.WebServer)

+ func CheckAllowedSettings(config *viper.Viper)

+ func ConfigureAndRunDefaultWebServer() error

+ func ConfigureFolderForSpecificConfig(config *viper.Viper) (storage.Folder, error)

+ func ConfigureFolderFromConfig(configFile string) (storage.Folder, error)

+ func CreateFileFromIncrement(increment io.Reader, target ReadWriterAt) (int64, error)

+ func GetBoolSetting(setting string, def bool) (bool, error)

+ func GetDurationSetting(setting string) (time.Duration, error)

+ func GetIncrementHeaderFields(increment io.Reader) (uint64, uint32, []byte, error)

+ func GetOplogPITRDiscoveryIntervalSetting() (*time.Duration, error)

+ func GetPgFetcherNew(dbDataDirectory, fileMask, restoreSpecPath string, skipRedundantTars bool) func(folder storage.Folder, backup Backup)

+ func GetPgFetcherOld(dbDataDirectory, fileMask, restoreSpecPath string) func(folder storage.Folder, backup Backup)

+ func GetStreamName(backupName string, extension string) string

+ func HandleCopy(fromConfigFile string, toConfigFile string, backupName string, ...)

+ func ReadConfigFromFile(config *viper.Viper, configFile string)

+ func RestoreMissingPages(base io.Reader, target ReadWriterAt) error

+ func SentinelNameFromBackup(backupName string) string

+ func SetDefaultValues(config *viper.Viper)

+ func StartCopy(infos []CopyingInfo) (bool, error)

+ func StreamBackupToCommandStdin(cmd *exec.Cmd, backup *Backup) error

+ func WritePagesFromIncrement(increment io.Reader, target ReadWriterAt, overwriteExisting bool) (int64, error)

+ type BackupFileOptions struct

+ type BackupFileUnwrapper struct

type BackupTime

+ func GetBackupsAndGarbage(folder storage.Folder) (backups []BackupTime, garbage []string, err error)

type Bundle

+ AllTarballsSize *int64

+ func (bundle *Bundle) CloseTarball(tarBall TarBall) error

+ type CatchupFileUnwrapper struct

+ func (u *CatchupFileUnwrapper) UnwrapExistingFile(reader io.Reader, header *tar.Header, file *os.File) (*FileUnwrapResult, error)

+ func (u *CatchupFileUnwrapper) UnwrapNewFile(reader io.Reader, header *tar.Header, file *os.File) (*FileUnwrapResult, error)

+ type CopyingInfo struct

+ From storage.Folder

+ Object storage.Object

+ To storage.Folder

+ func BuildCopyingInfos(from storage.Folder, to storage.Folder, objects []storage.Object, ...) (infos []CopyingInfo)

+ func GetAllCopyingInfo(from storage.Folder, to storage.Folder) ([]CopyingInfo, error)

+ func GetBackupCopyingInfo(backup *Backup, from storage.Folder, to storage.Folder) ([]CopyingInfo, error)

+ func GetHistoryCopyingInfo(backup *Backup, from storage.Folder, to storage.Folder) ([]CopyingInfo, error)

+ type DefaultFileUnwrapper struct

+ func (u *DefaultFileUnwrapper) UnwrapExistingFile(reader io.Reader, header *tar.Header, file *os.File) (*FileUnwrapResult, error)

+ func (u *DefaultFileUnwrapper) UnwrapNewFile(reader io.Reader, header *tar.Header, file *os.File) (*FileUnwrapResult, error)

+ type FetchConfig struct

+ func NewFetchConfig(backupName, dbDataDirectory string, folder storage.Folder, ...) *FetchConfig

+ func (fc *FetchConfig) SkipRedundantFiles(unwrapResult *UnwrapResult)

type FileTarInterpreter

+ UnwrapResult *UnwrapResult

+ func (tarInterpreter *FileTarInterpreter) AddFileUnwrapResult(result *FileUnwrapResult, fileName string)

+ type FileUnwrapResult struct

+ func NewCompletedResult() *FileUnwrapResult

+ func NewCreatedFromIncrementResult(missingBlockCount int64) *FileUnwrapResult

+ func NewSkippedResult() *FileUnwrapResult

+ func NewWroteIncrementBlocksResult(restoredBlockCount int64) *FileUnwrapResult

+ type FileUnwrapResultType int

+ const Completed

+ const CreatedFromIncrement

+ const Skipped

+ const WroteIncrementBlocks

+ type FileUnwrapperType int

+ const CatchupBackupFileUnwrapper

+ const DefaultBackupFileUnwrapper

+ type IBackupFileUnwrapper interface

+ UnwrapExistingFile func(reader io.Reader, header *tar.Header, file *os.File) (*FileUnwrapResult, error)

+ UnwrapNewFile func(reader io.Reader, header *tar.Header, file *os.File) (*FileUnwrapResult, error)

+ func NewFileUnwrapper(unwrapperType FileUnwrapperType, options *BackupFileOptions) IBackupFileUnwrapper

+ type ReadWriterAt interface

+ Name func() string

+ Size func() int64

+ func NewReadWriterAtFrom(file *os.File) (ReadWriterAt, error)

+ type ReadWriterAtFileImpl struct

+ func (rw *ReadWriterAtFileImpl) Size() int64

+ type UnwrapResult struct

type Uploader

+ func (uploader *Uploader) Compression() compression.Compressor

+ func (uploader *Uploader) DisableSizeTracking()

+ type UploaderProvider interface

+ Compression func() compression.Compressor

+ DisableSizeTracking func()

+ PushStream func(stream io.Reader) (string, error)

+ PushStreamToDestination func(stream io.Reader, dstPath string) error

+ Upload func(path string, content io.Reader) error

+ UploadFile func(file NamedReader) error

v0.2.16

May 11, 2020

Changes in this version

+ var RequiredSettings = make(map[string]bool)

+ func AddConfigFlags(Cmd *cobra.Command)

+ func AssertRequiredSettingsSet() error

+ type FakeASM struct

+ func NewFakeASM() *FakeASM

+ func (asm *FakeASM) IsWalAlreadyUploaded(walFilePath string) bool

v0.2.15

Mar 24, 2020

Changes in this version

+ const LibsodiumKeyPathSetting

+ const LibsodiumKeySetting

+ const MongoDBLastWriteUpdateSeconds

+ const MongoDBUriSetting

+ const MysqlBackupPrepareCmd

+ const MysqlBinlogDstSetting

+ const MysqlBinlogReplayCmd

+ const MysqlDatasourceNameSetting

+ const MysqlSslCaSetting

+ const NameStreamRestoreCmd

+ const OplogArchiveAfterSize

+ const OplogArchiveTimeoutSetting

+ var MaxTime = time.Unix(1<<63 - 62135596801, 999999999)

+ func DecompressDecryptBytes(dst io.Writer, archiveReader io.ReadCloser, ...) error

+ func DefaultHandleBackupList(folder storage.Folder)

+ func DeleteRetainAfterArgsValidator(cmd *cobra.Command, args []string) error

+ func DownloadFile(folder storage.Folder, filename, ext string, writeCloser io.WriteCloser) error

+ func FindTargetRetainAfterName(folder storage.Folder, retentionCount int, name string, modifier int, ...) (storage.Object, error)

+ func FindTargetRetainAfterTime(folder storage.Folder, retentionCount int, timeLine time.Time, modifier int, ...) (storage.Object, error)

+ func GetCommandSetting(variableName string) (*exec.Cmd, error)

+ func GetCommandSettingContext(ctx context.Context, variableName string) (*exec.Cmd, error)

+ func GetCommandStreamFetcher(cmd *exec.Cmd) func(folder storage.Folder, backup Backup)

+ func GetLastWriteUpdateInterval() (time.Duration, error)

+ func GetOplogArchiveAfterSize() (int, error)

+ func GetOplogArchiveTimeout() (time.Duration, error)

+ func GetRequiredSetting(setting string) (string, error)

+ func HandleCatchupFetch(folder storage.Folder, dbDirectory, backupName string)

+ func HandleCatchupPush(uploader *WalUploader, archiveDirectory string, fromLSN uint64)

+ func HandleDeletaRetainAfter(folder storage.Folder, args []string, confirmed bool, ...)

+ func PrepareDirs(fileName string, targetPath string) error

+ func TryDownloadFile(folder storage.Folder, path string) (walFileReader io.ReadCloser, exists bool, err error)

+ type DecompressionError struct

+ type ErrorLogger interface

+ FatalOnError func(err error)

+ type InfoLogger interface

+ Println func(v ...interface{})

+ type Logging struct

+ ErrorLogger ErrorLogger

+ InfoLogger InfoLogger

type Uploader

+ func ConfigureUploaderWithoutCompressMethod() (uploader *Uploader, err error)

+ type WalUploader struct

+ func ConfigureWalUploader() (uploader *WalUploader, err error)

+ func ConfigureWalUploaderWithoutCompressMethod() (uploader *WalUploader, err error)

+ func NewWalUploader(compressor compression.Compressor, uploadingLocation storage.Folder, ...) *WalUploader

+ func (walUploader *WalUploader) FlushFiles()

+ func (walUploader *WalUploader) UploadWalFile(file NamedReader) error

v0.2.14

Dec 4, 2019

Changes in this version

+ func CheckPgVersionAndPgControl(archiveDirectory string)

+ func GetLogsDstSettings(operationLogsDstEnvVariable string) (dstFolder string, err error)

+ func GetPgFetcher(dbDataDirectory, fileMask, restoreSpecPath string) func(folder storage.Folder, backup Backup)

+ func GetStreamFetcher(writeCloser io.WriteCloser) func(folder storage.Folder, backup Backup)

+ func ParseTS(endTSEnvVar string) (endTS *time.Time, err error)

+ type ArchiveStatusManager interface

+ func NewNopASM() ArchiveStatusManager

type DataFolder

+ func ConfigureArchiveStatusManager() (DataFolder, error)

+ type DataFolderASM struct

+ func NewDataFolderASM(folder DataFolder) DataFolderASM

type LogFetchSettings

+ GetDestFolderPath func() (string, error)

+ GetEndTS func() (*time.Time, error)

+ type NopASM struct

type Uploader

+ ArchiveStatusManager ArchiveStatusManager

+ func ConfigureMockUploaderWithoutCompressMethod() (uploader *Uploader, err error)

v0.2.13

Oct 8, 2019

Changes in this version

+ const BasePrefix

+ const DeleteBeforeUsageExample

+ const DeleteEverythingExamples

+ const DeleteEverythingUsageExample

+ const DeleteRetainUsageExample

+ const ForceDeleteModifier

+ const PgDatabaseSetting

+ const PgPasswordSetting

+ const PgSslModeSetting

+ const TablespaceFolder

+ const Tablespaces

+ var AllowedSettings = map[string]bool

+ var BasePrefixMissingError = fmt.Errorf("Base prefix not set while working with tablespaces.\n")

+ var StringModifiersDeleteEverything = []string

+ func DeleteEverything(folder storage.Folder, confirmed bool, args []string)

+ func DeleteEverythingArgsValidator(cmd *cobra.Command, args []string) error

+ func IsAllowedSetting(setting string, AllowedSettings map[string]bool) (exists bool)

+ func ReadRestoreSpec(path string, spec *TablespaceSpec) (err error)

+ type BackupFromFuture struct

+ func NewBackupFromFuture(backupName string) BackupFromFuture

+ func (err BackupFromFuture) Error() string

+ type BackupFromOtherBD struct

+ func NewBackupFromOtherBD() BackupFromOtherBD

+ func (err BackupFromOtherBD) Error() string

type BackupSentinelDto

+ CompressedSize int64

+ SystemIdentifier *uint64

+ TablespaceSpec *TablespaceSpec

+ UncompressedSize int64

type Bundle

+ TablespaceSpec TablespaceSpec

type ExtendedMetadataDto

+ CompressedSize int64

+ SystemIdentifier *uint64

+ UncompressedSize int64

+ UserData interface{}

type PgQueryRunner

+ SystemIdentifier *uint64

+ func (queryRunner *PgQueryRunner) BuildGetSystemIdentifier() string

+ type TablespaceLocation struct

+ Location string

+ Symlink string

+ type TablespaceSpec struct

+ func NewTablespaceSpec(basePrefix string) TablespaceSpec

+ func (spec *TablespaceSpec) AddTablespace(symlinkName string, actualLocation string)

+ func (spec *TablespaceSpec) BasePrefix() (string, bool)

+ func (spec *TablespaceSpec) Empty() bool

+ func (spec *TablespaceSpec) IsTablespaceSymlink(path string) (bool, error)

+ func (spec *TablespaceSpec) Length() int

+ func (spec *TablespaceSpec) Location(symlinkName string) (TablespaceLocation, bool)

+ func (spec *TablespaceSpec) MakeTablespaceSymlinkPath(path string) (string, error)

+ func (spec *TablespaceSpec) MarshalJSON() ([]byte, error)

+ func (spec *TablespaceSpec) SetBasePrefix(basePrefix string)

+ func (spec *TablespaceSpec) TablespaceLocations() []TablespaceLocation

+ func (spec *TablespaceSpec) TablespaceNames() []string

+ func (spec *TablespaceSpec) UnmarshalJSON(b []byte) error

+ type WithSizeReader struct

+ func (reader *WithSizeReader) Read(p []byte) (n int, err error)

v0.2.12

Sep 4, 2019

Changes in this version

+ const NameStreamCreateCmd

+ func DownloadLogFiles(logFiles []storage.Object, logFolder storage.Folder, handlers LogFetchHandlers) ([]storage.Object, error)

+ func FetchLogs(folder storage.Folder, startTS time.Time, endTS *time.Time, ...) (fetched []storage.Object, err error)

+ func FetchStreamSentinel(backup *Backup, sentinelDto interface{}) error

+ func GetDeltaRange(firstUsedLsn, firstNotUsedLsn uint64) (DeltaNo, DeltaNo)

+ func GetLogsCoveringInterval(folder storage.Folder, start time.Time, end *time.Time) ([]storage.Object, error)

+ func GetNameStreamCreateCmd() []string

+ func GetWalSegmentRange(firstNotUsedDeltaNo DeltaNo, firstNotUsedLsn uint64) (WalSegmentNo, WalSegmentNo)

+ func HandleBackupMark(uploader *Uploader, backupName string, toPermanent bool)

+ func LogFileShouldBeFetched(backupStartUploadTime time.Time, endTS *time.Time, object storage.Object) bool

+ func MarkBackup(uploader *Uploader, folder storage.Folder, backupName string, toPermanent bool)

+ func StartCommand(command []string) (waitFunc func() error, stdout io.ReadCloser)

+ func WriteAsJson(data interface{}, output io.Writer, pretty bool) error

+ type BackupAlreadyThisTypePermanentError struct

+ func NewBackupAlreadyThisTypePermanentError(backupName string, permanentType string) BackupAlreadyThisTypePermanentError

+ type BackupHasPermanentBackupInFutureError struct

+ func NewBackupHasPermanentBackupInFutureError(backupName string) BackupHasPermanentBackupInFutureError

+ type DeltaNo uint64

+ func NewDeltaNoFromFilename(filename string) (DeltaNo, error)

+ func NewDeltaNoFromFilenameNoError(filename string) DeltaNo

+ func NewDeltaNoFromLsn(lsn uint64) DeltaNo

+ func NewDeltaNoFromWalSegmentNo(walSegmentNo WalSegmentNo) DeltaNo

+ func (deltaNo DeltaNo) Add(n uint64) DeltaNo

+ func (deltaNo DeltaNo) FirstLsn() uint64

+ func (deltaNo DeltaNo) FirstWalSegmentNo() WalSegmentNo

+ func (deltaNo DeltaNo) GetFilename(timeline uint32) string

+ func (deltaNo DeltaNo) Next() DeltaNo

+ func (deltaNo DeltaNo) Previous() DeltaNo

+ func (deltaNo DeltaNo) Sub(n uint64) DeltaNo

+ type LogFetchHandlers interface

+ DownloadLogTo func(logFolder storage.Folder, logName string, dstLogFilePath string) error

+ GetLogFilePath func(pathToLog string) (string, error)

+ HandleAbortFetch func(string) error

+ ShouldBeAborted func(pathToLog string) (bool, error)

+ type LogFetchSettings interface

+ GetDstEnv func() string

+ GetEndTsEnv func() string

+ GetLogFolderPath func() string

type PagedFileDeltaMap

+ func GetDeltaMap(folder storage.Folder, timeline uint32, firstUsedLSN, firstNotUsedLSN uint64) (PagedFileDeltaMap, error)

+ func (deltaMap *PagedFileDeltaMap) AddLocationToDelta(location walparser.BlockLocation)

+ func (deltaMap *PagedFileDeltaMap) AddLocationsToDelta(locations []walparser.BlockLocation)

+ func (deltaMap *PagedFileDeltaMap) GetLocationsFromDeltas(folder storage.Folder, timeline uint32, first, last DeltaNo) error

+ func (deltaMap *PagedFileDeltaMap) GetLocationsFromWals(folder storage.Folder, timeline uint32, first, last WalSegmentNo, ...) error

type UploadObject

+ func GetMarkedBackupMetadataToUpload(folder storage.Folder, backupName string, toPermanent bool) ([]UploadObject, error)

+ type WalSegmentNo uint64

+ func NewWalSegmentNo(lsn uint64) WalSegmentNo

+ func NewWalSegmentNoFromFilename(filename string) (WalSegmentNo, error)

+ func NewWalSegmentNoFromFilenameNoError(filename string) WalSegmentNo

+ func (walSegmentNo WalSegmentNo) Add(n uint64) WalSegmentNo

+ func (walSegmentNo WalSegmentNo) FirstLsn() uint64

+ func (walSegmentNo WalSegmentNo) GetFilename(timeline uint32) string

+ func (walSegmentNo WalSegmentNo) Next() WalSegmentNo

+ func (walSegmentNo WalSegmentNo) Previous() WalSegmentNo

+ func (walSegmentNo WalSegmentNo) Sub(n uint64) WalSegmentNo

v0.2.11

Aug 12, 2019

v0.2.10

Jul 31, 2019

Changes in this version

+ const CompressionMethodSetting

+ const ConfirmFlag

+ const CseKmsIDSetting

+ const CseKmsRegionSetting

+ const DeleteBeforeExamples

+ const DeleteRetainExamples

+ const DeleteShortDescription

+ const DeltaMaxStepsSetting

+ const DeltaOriginSetting

+ const DiskRateLimitSetting

+ const DownloadConcurrencySetting

+ const GpgKeyIDSetting

+ const LogLevelSetting

+ const MinAllowedConcurrency

+ const NetworkRateLimitSetting

+ const PgDataSetting

+ const PgHostSetting

+ const PgPortSetting

+ const PgUserSetting

+ const PgpKeyPassphraseSetting

+ const PgpKeyPathSetting

+ const PgpKeySetting

+ const PreventWalOverwriteSetting

+ const SentinelUserDataSetting

+ const StreamPrefix

+ const TarSizeThresholdSetting

+ const UploadConcurrencySetting

+ const UploadDiskConcurrencySetting

+ const UploadQueueSetting

+ const UseWalDeltaSetting

+ const UserSetting

+ var CfgFile string

+ var DeprecatedExternalGpgMessage = fmt.Sprintf(..., PgpKeySetting, PgpKeyPathSetting)

+ var StringModifiers = []string

+ func CompressAndEncrypt(source io.Reader, compressor compression.Compressor, crypter crypto.Crypter) io.Reader

+ func ConfigureCrypter() crypto.Crypter

+ func DeleteBeforeArgsValidator(cmd *cobra.Command, args []string) error

+ func DeleteBeforeTarget(folder storage.Folder, target storage.Object, confirmed bool, ...) error

+ func DeleteRetainArgsValidator(cmd *cobra.Command, args []string) error

+ func DownloadAndDecompressStream(backup *Backup) error

+ func DownloadAndDecompressWALFile(folder storage.Folder, walFileName string) (io.ReadCloser, error)

+ func DownloadOplogFiles(oplogFiles []storage.Object, oplogFolder storage.Folder, oplogDstFolder string, ...) error

+ func FileIsPiped(stream *os.File) bool

+ func FindTarget(folder storage.Folder, compare func(object1, object2 storage.Object) bool, ...) (storage.Object, error)

+ func FindTargetBeforeTime(folder storage.Folder, timeLine time.Time, modifier int, ...) (storage.Object, error)

+ func FindTargetRetain(folder storage.Folder, retentionCount, modifier int, ...) (storage.Object, error)

+ func GetBeforeChoiceFunc(name string, modifier int, isFullBackup func(object storage.Object) bool) func(object storage.Object) bool

+ func GetDataFolderPath() string

+ func GetLastDecompressor() (compression.Decompressor, error)

+ func GetMaxConcurrency(concurrencyType string) (int, error)

+ func GetMaxDownloadConcurrency() (int, error)

+ func GetMaxUploadConcurrency() (int, error)

+ func GetMaxUploadDiskConcurrency() (int, error)

+ func GetMaxUploadQueue() (int, error)

+ func GetOperationLogsCoveringInterval(folder storage.Folder, start time.Time, end *time.Time) ([]storage.Object, error)

+ func GetOperationLogsSettings(OperationLogEndTsSetting string, operationLogsDstSetting string) (endTS *time.Time, dstFolder string, err error)

+ func GetRetainChoiceFunc(retentionCount, modifier int, isFullBackup func(object storage.Object) bool) func(object storage.Object) bool

+ func GetSetting(key string) (value string, ok bool)

+ func GetWaleCompatibleSetting(key string) (value string, exists bool)

+ func HandleBackupListWithFlags(folder storage.Folder, pretty bool, json bool, detail bool)

+ func HandleDeleteBefore(folder storage.Folder, args []string, confirmed bool, ...)

+ func HandleStreamFetch(backupName string, folder storage.Folder, ...)

+ func InitConfig()

+ func SetLastDecompressor(decompressor compression.Decompressor) error

+ func UploadMetadata(uploader *Uploader, sentinelDto *BackupSentinelDto, backupName string, ...) error

+ func WriteBackupList(backups []BackupTime, output io.Writer)

+ func WriteBackupListAsJson(backups []BackupTime, output io.Writer, pretty bool)

+ func WriteBackupListDetails(backupDetails []BackupDetail, output io.Writer)

+ func WriteBackupListDetailsAsJson(backupDetails []BackupDetail, output io.Writer, pretty bool)

+ func WritePrettyBackupList(backups []BackupTime, output io.Writer)

+ func WritePrettyBackupListDetails(backupDetails []BackupDetail, output io.Writer)

type Backup

+ SentinelDto *BackupSentinelDto

+ func (backup *Backup) FetchMeta() (ExtendedMetadataDto, error)

+ func (backup *Backup) FetchSentinelData() ([]byte, error)

+ func (backup *Backup) GetFilesToUnwrap(fileMask string) (map[string]bool, error)

+ func (backup *Backup) GetMetadataPath() string

+ func (backup *Backup) GetSentinel() (BackupSentinelDto, error)

+ type BackupDetail struct

type BackupSentinelDto

+ TarFileSets map[string][]string

+ func (dto *BackupSentinelDto) IsIncremental() bool

+ type CachedDecompressor struct

+ FileExtension string

+ type CompressAndEncryptError struct

+ func (err CompressAndEncryptError) Error() string

type DataFolder

+ CreateFile func(filename string) error

+ DeleteFile func(filename string) error

+ FileExists func(filename string) bool

type DiskDataFolder

+ func (folder *DiskDataFolder) CreateFile(filename string) error

+ func (folder *DiskDataFolder) DeleteFile(filename string) error

+ func (folder *DiskDataFolder) FileExists(filename string) bool

+ type ExtendedMetadataDto struct

+ DataDir string

+ DatetimeFormat string

+ FinishLsn uint64

+ FinishTime time.Time

+ Hostname string

+ IsPermanent bool

+ PgVersion int

+ StartLsn uint64

+ StartTime time.Time

type Extension

+ RegisterCommands func(cmd *cobra.Command)

+ type InvalidConcurrencyValueError struct

+ func NewInvalidConcurrencyValueError(concurrencyType string, value int) InvalidConcurrencyValueError

+ func (err InvalidConcurrencyValueError) Error() string

type NamedReaderImpl

+ func NewNamedReaderImpl(reader io.Reader, name string) *NamedReaderImpl

+ type UnmarshallingError struct

+ func NewUnmarshallingError(subject string, err error) UnmarshallingError

+ func (err UnmarshallingError) Error() string

+ type UnsetRequiredSettingError struct

+ func NewUnsetRequiredSettingError(settingName string) UnsetRequiredSettingError

+ func (err UnsetRequiredSettingError) Error() string

+ type UploadObject struct

+ Content io.Reader

+ Path string

+ func GetImpermanentBackupMetadataBefore(baseBackupFolder storage.Folder, backupName string) ([]UploadObject, error)

type Uploader

+ Failed atomic.Value

+ func (uploader *Uploader) PushStream(stream io.Reader) (string, error)

+ func (uploader *Uploader) PushStreamToDestination(stream io.Reader, dstPath string) error

+ func (uploader *Uploader) UploadMultiple(objects []UploadObject) error

v0.2.9

Apr 22, 2019

v0.2.8

Apr 5, 2019

Changes in this version

+ const FindFullDeleteModifier

+ const FullDeleteModifier

+ const NoDeleteModifier

+ func ConfigureFolder() (storage.Folder, error)

+ func ConfigureLimiters() error

+ func ConfigureLogging() error

+ func FindFirstLaterOrEqualTime(folder storage.Folder, timeLine time.Time, ...) (storage.Object, error)

+ func FindTargetBeforeName(folder storage.Folder, name string, modifier int) (storage.Object, error)

+ func HandleDeleteRetain(folder storage.Folder, retantionCount int, modifier int, dryRun bool)

+ func RegisterExtensionCommands(rootCmd *cobra.Command)

+ type ForbiddenActionError struct

+ func NewForbiddenActionError(message string) ForbiddenActionError

+ func (err ForbiddenActionError) Error() string

+ type UnconfiguredStorageError struct

+ func NewUnconfiguredStorageError(storagePrefixVariants []string) UnconfiguredStorageError

+ func (err UnconfiguredStorageError) Error() string

type UnsupportedFileTypeError

+ func (err UnsupportedFileTypeError) Error() string

type Uploader

+ func ConfigureUploader() (uploader *Uploader, err error)

v0.2.7

Mar 5, 2019

Changes in this version

+ const WaleFileHost

+ var Extensions []Extension

+ var StorageAdapters = []StorageAdapter

+ func DecompressWALFile(dst io.Writer, archiveReader io.ReadCloser, decompressor Decompressor) error

+ func DeleteWALBefore(walSkipFileName string, walFolder storage.Folder)

+ func DownloadWALFileTo(folder storage.Folder, walFileName string, dstPath string) error

+ func GetLatestBackupName(folder storage.Folder) (string, error)

+ func GetSettingValue(key string) string

+ func LoadExtensions(path string) error

+ func SanitizePath(path string) string

+ func UploadSentinel(uploader *Uploader, sentinelDto *BackupSentinelDto, backupName string) error

+ func UploadWALFile(uploader *Uploader, walFilePath string) error

type Backup

+ func (backup *Backup) GetStopSentinelPath() string

+ type Extension interface

+ Execute func(command string, uploader *Uploader, folder storage.Folder, args []string)

+ Flush func(time BackupTime, folder storage.Folder)

+ GetAllowedConfigKeys func() map[string]*string

+ HasCommand func(command string) bool

+ TryPrintHelp func(command string, args []string) bool

+ func GetExtensionByCommandName(commandName string) (Extension, bool)

+ type SentinelMarshallingError struct

+ func NewSentinelMarshallingError(sentinelName string, err error) SentinelMarshallingError

+ func (err SentinelMarshallingError) Error() string

+ type StorageAdapter struct

type Uploader

+ Compressor Compressor

+ UploadingFolder storage.Folder

+ func (uploader *Uploader) Upload(path string, content io.Reader) error

v0.2.6

Feb 21, 2019

Changes in this version

+ func DecryptSecretKey(entityList openpgp.EntityList, passphrase string) error

+ func ReadKey(path string) (io.Reader, error)

+ func ReadPGPKey(path string) (openpgp.EntityList, error)

type OpenPGPCrypter

+ ArmoredKey string

+ ArmoredKeyPath string

+ IsUseArmoredKey bool

+ IsUseArmoredKeyPath bool

+ IsUseKeyRingId bool

+ func (crypter *OpenPGPCrypter) ConfigurePGPCrypter()

v0.2.5

Feb 20, 2019

Changes in this version

+ var UnwrapAll map[string]bool = nil

v0.2.4

Jan 22, 2019

Changes in this version

+ func IsPgControlRequired(backup *Backup, sentinelDto BackupSentinelDto) bool

type Backup

+ func (backup *Backup) FetchSentinel() (BackupSentinelDto, error)

v0.2.3

Jan 9, 2019

v0.2.2

Dec 26, 2018

v0.2.1

Dec 18, 2018

Changes in this version

+ const BackupLabelFilename

+ const BaseBackupPath

+ const BlocksInRelFile

+ const BrotliAlgorithmName

+ const BrotliFileExtension

+ const CompressedBlockMaxSize

+ const DatabasePageSize

+ const DefaultDataBurstRateLimit

+ const DefaultDataFolderPath

+ const DefaultSpcNode

+ const DefaultStreamingPartSizeFor10Concurrency

+ const DefaultTablespace

+ const DefaultTarSizeThreshold

+ const DeleteUsageText

+ const DeltaFilenameSuffix

+ const GlobalTablespace

+ const GpgBin

+ const LatestString

+ const Lz4AlgorithmName

+ const Lz4FileExtension

+ const LzmaAlgorithmName

+ const LzmaFileExtension

+ const LzoFileExtension

+ const LzopBlockSize

+ const NoSuchKeyAWSErrorCode

+ const NonDefaultTablespace

+ const NotFoundAWSErrorCode

+ const PartFilenameSuffix

+ const PgControl

+ const PgControlPath

+ const RecordPartFilename

+ const RelFileSizeBound

+ const SentinelSuffix

+ const SignatureMagicNumber

+ const TablespaceMapFilename

+ const TarPartitionFolderName

+ const TotalBgUploadedLimit

+ const VersionStr

+ const WalFileInDelta

+ const WalPath

+ const WalSegmentSize

+ const ZstdAlgorithmName

+ const ZstdFileExtension

+ var CompressingAlgorithms = []string

+ var Compressors = map[string]Compressor

+ var Decompressors = []Decompressor

+ var DiskLimiter *rate.Limiter

+ var ExcludedFilenames = make(map[string]Empty)

+ var IncrementFileHeader = []byte

+ var MaxExtractRetryWait = 5 * time.Minute

+ var MaxRetries = 15

+ var MinExtractRetryWait = time.Minute

+ var NetworkLimiter *rate.Limiter

+ var TerminalLocation = *walparser.NewBlockLocation(0, 0, 0, 0)

+ var UtilityFilePaths = map[string]bool

+ var WalgConfig *map[string]string

+ func ApplyFileIncrement(fileName string, increment io.Reader) error

+ func CleanupPrefetchDirectories(walFileName string, location string, cleaner Cleaner)

+ func ComputeDeletionSkiplineAndPrintIntentions(backups []BackupTime, target *Backup) (skipLine int, walSkipFileName string)

+ func Configure() (uploader *Uploader, destinationFolder StorageFolder, err error)

+ func Connect() (*pgx.Conn, error)

+ func CreateFileWith(filePath string, content io.Reader) error

+ func CreateUploaderAPI(svc s3iface.S3API, partsize, concurrency int) s3manageriface.UploaderAPI

+ func DecryptAndDecompressTar(writer io.Writer, readerMaker ReaderMaker, crypter Crypter) error

+ func ExtractAll(tarInterpreter TarInterpreter, files []ReaderMaker) error

+ func ExtractBlockLocations(records []walparser.XLogRecord) []walparser.BlockLocation

+ func FastCopy(dst io.Writer, src io.Reader) (int64, error)

+ func GetBaseFilesToUnwrap(backupFileStates BackupFileList, currentFilesToUnwrap map[string]bool) (map[string]bool, error)

+ func GetDeltaFilenameFor(walFilename string) (string, error)

+ func GetFileExtension(filePath string) string

+ func GetFileRelativePath(fileAbsPath string, directoryPath string) string

+ func GetKeyRingId() string

+ func GetNextWalFilename(name string) (string, error)

+ func GetPositionInDelta(walFilename string) int

+ func GetPrefetchLocations(location string, walFileName string) (prefetchLocation string, runningLocation string, runningFile string, ...)

+ func GetRelFileIdFrom(filePath string) (int, error)

+ func GetRelFileNodeFrom(filePath string) (*walparser.RelFileNode, error)

+ func GetRestoredBackupFilesToUnwrap(sentinelDto BackupSentinelDto) map[string]bool

+ func GetSentinelUserData() interface

+ func HandleBackupFetch(backupName string, folder StorageFolder, dbDataDirectory string, mem bool)

+ func HandleBackupList(folder StorageFolder)

+ func HandleBackupPush(archiveDirectory string, uploader *Uploader)

+ func HandleDelete(folder StorageFolder, args []string)

+ func HandleWALFetch(folder StorageFolder, walFileName string, location string, ...)

+ func HandleWALPrefetch(folder StorageFolder, walFileName string, location string, uploader *Uploader)

+ func HandleWALPush(uploader *Uploader, walFilePath string)

+ func IsDirectoryEmpty(directoryPath string) (bool, error)

+ func JoinS3Path(elem ...string) string

+ func LookupConfigValue(key string) (value string, ok bool)

+ func NewDiskLimitReader(r io.ReadCloser) io.ReadCloser

+ func NewLzoReader(r io.Reader) (io.ReadCloser, error)

+ func NewLzoWriter(w io.Writer) io.WriteCloser

+ func NewNetworkLimitReader(r io.ReadCloser) io.ReadCloser

+ func OpenFileWithDir(filePath string) (*os.File, error)

+ func PackFileTo(tarBall TarBall, fileInfoHeader *tar.Header, fileContent io.Reader) (fileSize int64, err error)

+ func ParseWALFilename(name string) (timelineId uint32, logSegNo uint64, err error)

+ func ReadIncrementFileHeader(reader io.Reader) error

+ func ReadIncrementalFile(filePath string, fileSize int64, lsn uint64, deltaBitmap *roaring.Bitmap) (fileReader io.ReadCloser, size int64, err error)

+ func ReadLocationsFrom(reader io.Reader) ([]walparser.BlockLocation, error)

+ func ReaderMakersToFilePaths(readerMakers []ReaderMaker) []string

+ func ResolveSymlink(path string) string

+ func SelectRelFileBlocks(bitmap *roaring.Bitmap, relFileId int) *roaring.Bitmap

+ func ShouldPrefault(name string) (lsn uint64, shouldPrefault bool, timelineId uint32, err error)

+ func ToBytes(x interface{}) []byte

+ func ToPartFilename(deltaFilename string) string

+ func TryDownloadWALFile(folder StorageFolder, walPath string) (walFileReader io.ReadCloser, exists bool, err error)

+ func WriteLocationsTo(writer io.Writer, locations []walparser.BlockLocation) error

+ type ArchiveNonExistenceError struct

+ func NewArchiveNonExistenceError(archiveName string) ArchiveNonExistenceError

+ func (err ArchiveNonExistenceError) Error() string

+ type Backup struct

+ BaseBackupFolder StorageFolder

+ Name string

+ func GetBackupByName(backupName string, folder StorageFolder) (*Backup, error)

+ func NewBackup(baseBackupFolder StorageFolder, name string) *Backup

+ func (backup *Backup) CheckExistence() (bool, error)

+ func (backup *Backup) GetTarNames() ([]string, error)

+ type BackupFileDescription struct

+ IsIncremented bool

+ IsSkipped bool

+ MTime time.Time

+ func NewBackupFileDescription(isIncremented, isSkipped bool, modTime time.Time) *BackupFileDescription

+ type BackupFileList map[string]BackupFileDescription

+ type BackupNonExistenceError struct

+ func NewBackupNonExistenceError(backupName string) BackupNonExistenceError

+ func (err BackupNonExistenceError) Error() string

+ type BackupSentinelDto struct

+ BackupFinishLSN *uint64

+ BackupStartLSN *uint64

+ Files BackupFileList

+ IncrementCount *int

+ IncrementFrom *string

+ IncrementFromLSN *uint64

+ IncrementFullName *string

+ PgVersion int

+ UserData interface{}

+ type BackupTime struct

+ BackupName string

+ Time time.Time

+ WalFileName string

+ type BgUploader struct

+ func NewBgUploader(walFilePath string, maxParallelWorkers int32, uploader *Uploader) *BgUploader

+ func (bgUploader *BgUploader) Start()

+ func (bgUploader *BgUploader) Stop()

+ type BlockLocationReader struct

+ func NewBlockLocationReader(underlying io.Reader) *BlockLocationReader

+ func (reader *BlockLocationReader) ReadNextLocation() (*walparser.BlockLocation, error)

+ type BlockLocationWriter struct

+ Underlying io.Writer

+ func NewBlockLocationWriter(underlying io.Writer) *BlockLocationWriter

+ func (locationWriter *BlockLocationWriter) WriteLocation(location walparser.BlockLocation) error

+ type BrotliCompressor struct

+ func (compressor BrotliCompressor) FileExtension() string

+ func (compressor BrotliCompressor) NewWriter(writer io.Writer) ReaderFromWriteCloser

+ type BrotliDecompressor struct

+ func (decompressor BrotliDecompressor) Decompress(dst io.Writer, src io.Reader) error

+ func (decompressor BrotliDecompressor) FileExtension() string

+ type BrotliReaderFromWriter struct

+ func NewBrotliReaderFromWriter(dst io.Writer) *BrotliReaderFromWriter

+ func (writer *BrotliReaderFromWriter) ReadFrom(reader io.Reader) (n int64, err error)

+ type Bundle struct

+ ArchiveDirectory string

+ Crypter OpenPGPCrypter

+ DeltaMap PagedFileDeltaMap

+ Files *sync.Map

+ IncrementFromFiles BackupFileList

+ IncrementFromLsn *uint64

+ Replica bool

+ Sentinel *Sentinel

+ TarBall TarBall

+ TarBallMaker TarBallMaker

+ TarSizeThreshold int64

+ Timeline uint32

+ func NewBundle(archiveDirectory string, incrementFromLsn *uint64, ...) *Bundle

+ func (bundle *Bundle) CheckSizeAndEnqueueBack(tarBall TarBall) error

+ func (bundle *Bundle) Deque() TarBall

+ func (bundle *Bundle) DownloadDeltaMap(folder StorageFolder, backupStartLSN uint64) error

+ func (bundle *Bundle) EnqueueBack(tarBall TarBall)

+ func (bundle *Bundle) FinishQueue() error

+ func (bundle *Bundle) GetFileRelPath(fileAbsPath string) string

+ func (bundle *Bundle) GetFiles() *sync.Map

+ func (bundle *Bundle) GetIncrementBaseFiles() BackupFileList

+ func (bundle *Bundle) GetIncrementBaseLsn() *uint64

+ func (bundle *Bundle) HandleWalkedFSObject(path string, info os.FileInfo, err error) error

+ func (bundle *Bundle) NewTarBall(dedicatedUploader bool)

+ func (bundle *Bundle) PrefaultWalkedFSObject(path string, info os.FileInfo, err error) error

+ func (bundle *Bundle) StartBackup(conn *pgx.Conn, backup string) (backupName string, lsn uint64, version int, err error)

+ func (bundle *Bundle) StartQueue()

+ func (bundle *Bundle) UploadLabelFiles(conn *pgx.Conn) (uint64, error)

+ func (bundle *Bundle) UploadPgControl(compressorFileExtension string) error

+ type BytesPerWalSegmentError struct

+ func NewBytesPerWalSegmentError() BytesPerWalSegmentError

+ func (err BytesPerWalSegmentError) Error() string

+ type CachedKey struct

+ Body []byte

+ KeyId string

+ type CantDiscardWalDataError struct

+ func NewCantDiscardWalDataError() CantDiscardWalDataError

+ func (err CantDiscardWalDataError) Error() string

+ type CantOverwriteWalFileError struct

+ func NewCantOverwriteWalFileError(walFilePath string) CantOverwriteWalFileError

+ func (err CantOverwriteWalFileError) Error() string

+ type CascadeWriteCloser struct

+ Underlying io.Closer

+ func (cascadeCloser *CascadeWriteCloser) Close() error

+ type Cleaner interface

+ GetFiles func(directory string) ([]string, error)

+ Remove func(file string)

+ type CompressingPipeWriter struct

+ Input io.Reader

+ NewCompressingWriter func(io.Writer) ReaderFromWriteCloser

+ Output io.Reader

+ func (pipeWriter *CompressingPipeWriter) Compress(crypter Crypter)

+ type CompressingPipeWriterError struct

+ func NewCompressingPipeWriterError(reason string) CompressingPipeWriterError

+ func (err CompressingPipeWriterError) Error() string

+ type Compressor interface

+ FileExtension func() string

+ NewWriter func(writer io.Writer) ReaderFromWriteCloser

+ type Crypter interface

+ Decrypt func(reader io.ReadCloser) (io.Reader, error)

+ Encrypt func(writer io.WriteCloser) (io.WriteCloser, error)

+ IsUsed func() bool

+ type CrypterUseMischiefError struct

+ func NewCrypterUseMischiefError() CrypterUseMischiefError

+ func (err CrypterUseMischiefError) Error() string

+ type DataFolder interface

+ CleanFolder func() error

+ OpenReadonlyFile func(filename string) (io.ReadCloser, error)

+ OpenWriteOnlyFile func(filename string) (io.WriteCloser, error)

+ type Decompressor interface

+ Decompress func(dst io.Writer, src io.Reader) error

+ FileExtension func() string

+ type DelayWriteCloser struct

+ func (delayWriteCloser *DelayWriteCloser) Close() error

+ func (delayWriteCloser *DelayWriteCloser) Write(p []byte) (n int, err error)

+ type DeleteCommandArguments struct

+ Before bool

+ BeforeTime *time.Time

+ FindFull bool

+ Full bool

+ Retain bool

+ Target string

+ func ParseDeleteArguments(args []string, fallBackFunc func()) (result DeleteCommandArguments)

+ type DeltaFile struct

+ Locations []walparser.BlockLocation

+ WalParser *walparser.WalParser

+ func LoadDeltaFile(reader io.Reader) (*DeltaFile, error)

+ func NewDeltaFile(walParser *walparser.WalParser) (*DeltaFile, error)

+ func (deltaFile *DeltaFile) Save(writer io.Writer) error

+ type DeltaFileChanWriter struct

+ BlockLocationConsumer chan walparser.BlockLocation

+ DeltaFile *DeltaFile

+ func NewDeltaFileChanWriter(deltaFile *DeltaFile) *DeltaFileChanWriter

+ func (writer *DeltaFileChanWriter) Consume(waitGroup *sync.WaitGroup)

+ type DeltaFileManager struct

+ CanceledDeltaFiles map[string]bool

+ DeltaFileWriters *LazyCache

+ PartFiles *LazyCache

+ func NewDeltaFileManager(dataFolder DataFolder) *DeltaFileManager

+ func (manager *DeltaFileManager) CancelRecording(walFilename string)

+ func (manager *DeltaFileManager) CombinePartFile(deltaFilename string, partFile *WalPartFile) error

+ func (manager *DeltaFileManager) FlushDeltaFiles(uploader *Uploader, completedPartFiles map[string]bool)

+ func (manager *DeltaFileManager) FlushFiles(uploader *Uploader)

+ func (manager *DeltaFileManager) FlushPartFiles() (completedPartFiles map[string]bool)

+ func (manager *DeltaFileManager) GetBlockLocationConsumer(deltaFilename string) (chan walparser.BlockLocation, error)

+ func (manager *DeltaFileManager) GetPartFile(deltaFilename string) (*WalPartFile, error)

+ func (manager *DeltaFileManager) LoadDeltaFileWriter(deltaFilename string) (deltaFileWriter *DeltaFileChanWriter, err error)

+ func (manager *DeltaFileManager) LoadPartFile(partFilename string) (*WalPartFile, error)

+ type DeltaFileWriterNotFoundError struct

+ func NewDeltaFileWriterNotFoundError(filename string) DeltaFileWriterNotFoundError

+ func (err DeltaFileWriterNotFoundError) Error() string

+ type DiskDataFolder struct

+ func NewDiskDataFolder(folderPath string) (*DiskDataFolder, error)

+ func (folder *DiskDataFolder) CleanFolder() error

+ func (folder *DiskDataFolder) OpenReadonlyFile(filename string) (io.ReadCloser, error)

+ func (folder *DiskDataFolder) OpenWriteOnlyFile(filename string) (io.WriteCloser, error)

+ type Empty struct

+ type EmptyWriteIgnorer struct

+ func (e EmptyWriteIgnorer) Write(p []byte) (int, error)

+ type ExponentialRetrier struct

+ func NewExponentialRetrier(startSleepDuration, sleepDurationBound time.Duration) *ExponentialRetrier

+ type FSFolder struct

+ func NewFSFolder(rootPath string, subPath string) *FSFolder

+ func (folder *FSFolder) DeleteObjects(objectRelativePaths []string) error

+ func (folder *FSFolder) EnsureExists() error

+ func (folder *FSFolder) Exists(objectRelativePath string) (bool, error)

+ func (folder *FSFolder) GetFilePath(objectRelativePath string) string

+ func (folder *FSFolder) GetPath() string

+ func (folder *FSFolder) GetSubFolder(subFolderRelativePath string) StorageFolder

+ func (folder *FSFolder) ListFolder() (objects []StorageObject, subFolders []StorageFolder, err error)

+ func (folder *FSFolder) PutObject(name string, content io.Reader) error

+ func (folder *FSFolder) ReadObject(objectRelativePath string) (io.ReadCloser, error)

+ type FSFolderError struct

+ func NewFSFolderError(err error, format string, args ...interface{}) FSFolderError

+ func (err FSFolderError) Error() string

+ type FileStorageObject struct

+ func (object FileStorageObject) GetLastModified() time.Time

+ func (object FileStorageObject) GetName() string

+ type FileSystemCleaner struct

+ func (cleaner FileSystemCleaner) GetFiles(directory string) (files []string, err error)

+ func (cleaner FileSystemCleaner) Remove(file string)

+ type FileTarInterpreter struct

+ DBDataDirectory string

+ FilesToUnwrap map[string]bool

+ Sentinel BackupSentinelDto

+ func NewFileTarInterpreter(dbDataDirectory string, sentinel BackupSentinelDto, ...) *FileTarInterpreter

+ func (tarInterpreter *FileTarInterpreter) Interpret(fileReader io.Reader, fileInfo *tar.Header) error

+ type GSFolder struct

+ func NewGSFolder(bucket *storage.BucketHandle, path string) *GSFolder

+ func (folder *GSFolder) DeleteObjects(objectRelativePaths []string) error

+ func (folder *GSFolder) Exists(objectRelativePath string) (bool, error)

+ func (folder *GSFolder) GetPath() string

+ func (folder *GSFolder) GetSubFolder(subFolderRelativePath string) StorageFolder

+ func (folder *GSFolder) ListFolder() (objects []StorageObject, subFolders []StorageFolder, err error)

+ func (folder *GSFolder) PutObject(name string, content io.Reader) error

+ func (folder *GSFolder) ReadObject(objectRelativePath string) (io.ReadCloser, error)

+ type GSFolderError struct

+ func NewGSFolderError(err error, format string, args ...interface{}) GSFolderError

+ func (err GSFolderError) Error() string

+ type GSStorageObject struct

+ func (object *GSStorageObject) GetLastModified() time.Time

+ func (object *GSStorageObject) GetName() string

+ type GpgKeyExportError struct

+ func NewGpgKeyExportError(text string) GpgKeyExportError

+ func (err GpgKeyExportError) Error() string

+ type IncorrectLogSegNoError struct

+ func NewIncorrectLogSegNoError(name string) IncorrectLogSegNoError

+ func (err IncorrectLogSegNoError) Error() string

+ type IncrementalPageReader struct

+ Blocks []uint32

+ FileSize int64

+ Lsn uint64

+ Next []byte

+ PagedFile ReadSeekCloser

+ func (pageReader *IncrementalPageReader) AdvanceFileReader() error

+ func (pageReader *IncrementalPageReader) Close() error

+ func (pageReader *IncrementalPageReader) DeltaBitmapInitialize(deltaBitmap *roaring.Bitmap)

+ func (pageReader *IncrementalPageReader) DrainMoreData() (succeed bool, err error)

+ func (pageReader *IncrementalPageReader) FullScanInitialize() error

+ func (pageReader *IncrementalPageReader) Read(p []byte) (n int, err error)

+ func (pageReader *IncrementalPageReader) SelectNewValidPage(pageBytes []byte, blockNo uint32) (valid bool)

+ func (pageReader *IncrementalPageReader) WriteDiffMapToHeader(headerWriter io.Writer)

+ type InvalidBlockError struct

+ func NewInvalidBlockError(blockNo uint32) InvalidBlockError

+ func (err InvalidBlockError) Error() string

+ type InvalidIncrementFileHeaderError struct

+ func NewInvalidIncrementFileHeaderError() InvalidIncrementFileHeaderError

+ func (err InvalidIncrementFileHeaderError) Error() string

+ type InvalidWalFileMagicError struct

+ func NewInvalidWalFileMagicError() InvalidWalFileMagicError

+ func (err InvalidWalFileMagicError) Error() string

+ type LazyCache struct

+ func NewLazyCache(load func(key interface{}) (value interface{}, err error)) *LazyCache

+ func (lazyCache *LazyCache) Load(key interface{}) (value interface{}, exists bool, err error)

+ func (lazyCache *LazyCache) LoadExisting(key interface{}) (value interface{}, exists bool)

+ func (lazyCache *LazyCache) Range(reduce func(key, value interface{}) bool)

+ func (lazyCache *LazyCache) Store(key, value interface{})

+ type LimitedReader struct

+ func (r *LimitedReader) Close() error

+ func (r *LimitedReader) Read(buf []byte) (int, error)

+ type Lz4Compressor struct

+ func (compressor Lz4Compressor) FileExtension() string

+ func (compressor Lz4Compressor) NewWriter(writer io.Writer) ReaderFromWriteCloser

+ type Lz4Decompressor struct

+ func (decompressor Lz4Decompressor) Decompress(dst io.Writer, src io.Reader) error

+ func (decompressor Lz4Decompressor) FileExtension() string

+ type Lz4ReaderFromWriter struct

+ func NewLz4ReaderFromWriter(dst io.Writer) *Lz4ReaderFromWriter

+ func (writer *Lz4ReaderFromWriter) ReadFrom(reader io.Reader) (n int64, err error)

+ type LzmaCompressor struct

+ func (compressor LzmaCompressor) FileExtension() string

+ func (compressor LzmaCompressor) NewWriter(writer io.Writer) ReaderFromWriteCloser

+ type LzmaDecompressor struct

+ func (decompressor LzmaDecompressor) Decompress(dst io.Writer, src io.Reader) error

+ func (decompressor LzmaDecompressor) FileExtension() string

+ type LzmaReaderFromWriter struct

+ func NewLzmaReaderFromWriter(dst io.Writer) (*LzmaReaderFromWriter, error)

+ func (writer *LzmaReaderFromWriter) ReadFrom(reader io.Reader) (n int64, err error)

+ type LzoDecompressor struct

+ func (decompressor LzoDecompressor) Decompress(dst io.Writer, src io.Reader) error

+ func (decompressor LzoDecompressor) FileExtension() string

+ type MD5Reader struct

+ func (reader *MD5Reader) Read(p []byte) (n int, err error)

+ func (reader *MD5Reader) Sum() string

+ type NOPTarBall struct

+ func (tarBall *NOPTarBall) AddSize(i int64)

+ func (tarBall *NOPTarBall) AwaitUploads()

+ func (tarBall *NOPTarBall) CloseTar() error

+ func (tarBall *NOPTarBall) Finish(sentinelDto *BackupSentinelDto) error

+ func (tarBall *NOPTarBall) SetUp(crypter Crypter, params ...string)

+ func (tarBall *NOPTarBall) Size() int64

+ func (tarBall *NOPTarBall) TarWriter() *tar.Writer

+ type NOPTarBallMaker struct

+ func (tarBallMaker *NOPTarBallMaker) Make(inheritState bool) TarBall

+ type NamedReader interface

+ Name func() string

+ type NamedReaderImpl struct

+ func (reader *NamedReaderImpl) Name() string

+ type NilWalParserError struct

+ func NewNilWalParserError() NilWalParserError

+ func (err NilWalParserError) Error() string

+ type NoBackupsFoundError struct

+ func NewNoBackupsFoundError() NoBackupsFoundError

+ func (err NoBackupsFoundError) Error() string

+ type NoBitmapFoundError struct

+ func NewNoBitmapFoundError() NoBitmapFoundError

+ func (err NoBitmapFoundError) Error() string

+ type NoFilesToExtractError struct

+ func NewNoFilesToExtractError() NoFilesToExtractError

+ func (err NoFilesToExtractError) Error() string

+ type NoPostgresVersionError struct

+ func NewNoPostgresVersionError() NoPostgresVersionError

+ func (err NoPostgresVersionError) Error() string

+ type NoSentinelUploadError struct

+ func NewNoSentinelUploadError() NoSentinelUploadError

+ func (err NoSentinelUploadError) Error() string

+ type NoSuchFileError struct

+ func NewNoSuchFileError(filename string) NoSuchFileError

+ func (err NoSuchFileError) Error() string

+ type NonEmptyDbDataDirectoryError struct

+ func NewNonEmptyDbDataDirectoryError(dbDataDirectory string) NonEmptyDbDataDirectoryError

+ func (err NonEmptyDbDataDirectoryError) Error() string

+ type NotWalFilenameError struct

+ func NewNotWalFilenameError(filename string) NotWalFilenameError

+ func (err NotWalFilenameError) Error() string

+ type ObjectNotFoundError struct

+ func NewObjectNotFoundError(path string) ObjectNotFoundError

+ func (err ObjectNotFoundError) Error() string

+ type OpenPGPCrypter struct

+ Configured bool

+ KeyRingId string

+ PubKey openpgp.EntityList

+ SecretKey openpgp.EntityList

+ func (crypter *OpenPGPCrypter) ConfigureGPGCrypter()

+ func (crypter *OpenPGPCrypter) Decrypt(reader io.ReadCloser) (io.Reader, error)

+ func (crypter *OpenPGPCrypter) Encrypt(writer io.WriteCloser) (io.WriteCloser, error)

+ func (crypter *OpenPGPCrypter) IsArmed() bool

+ func (crypter *OpenPGPCrypter) IsUsed() bool

+ type PagedFileDeltaMap map[walparser.RelFileNode]*roaring.Bitmap

+ func NewPagedFileDeltaMap() PagedFileDeltaMap

+ func (deltaMap *PagedFileDeltaMap) AddToDelta(location walparser.BlockLocation)

+ func (deltaMap *PagedFileDeltaMap) GetDeltaBitmapFor(filePath string) (*roaring.Bitmap, error)

+ type PgControlNotFoundError struct

+ func NewPgControlNotFoundError() PgControlNotFoundError

+ func (err PgControlNotFoundError) Error() string

+ type PgQueryRunner struct

+ Version int

+ func NewPgQueryRunner(conn *pgx.Conn) (*PgQueryRunner, error)

+ func (queryRunner *PgQueryRunner) BuildGetVersion() string

+ func (queryRunner *PgQueryRunner) BuildStartBackup() (string, error)

+ func (queryRunner *PgQueryRunner) BuildStopBackup() (string, error)

+ func (queryRunner *PgQueryRunner) StartBackup(backup string) (backupName string, lsnString string, inRecovery bool, err error)

+ func (queryRunner *PgQueryRunner) StopBackup() (label string, offsetMap string, lsnStr string, err error)

+ type PostgresPageHeader struct

+ func ParsePostgresPageHeader(reader io.Reader) (*PostgresPageHeader, error)

+ func (header *PostgresPageHeader) IsNew() bool

+ func (header *PostgresPageHeader) IsValid() bool

+ func (header *PostgresPageHeader) Lsn() uint64

+ type QueryRunner interface

+ StartBackup func(backup string) (string, string, bool, error)

+ StopBackup func() (string, string, string, error)

+ type ReadCascadeCloser struct

+ type ReadSeekCloser interface

+ type ReadSeekCloserImpl struct

+ type ReaderFromWriteCloser interface

+ type ReaderMaker interface

+ Path func() string

+ Reader func() (io.ReadCloser, error)

+ type S3Folder struct

+ Bucket *string

+ Path string

+ S3API s3iface.S3API

+ func ConfigureS3Folder() (*S3Folder, error)

+ func NewS3Folder(uploader S3Uploader, s3API s3iface.S3API, bucket, path string) *S3Folder

+ func (folder *S3Folder) DeleteObjects(objectRelativePaths []string) error

+ func (folder *S3Folder) Exists(objectRelativePath string) (bool, error)

+ func (folder *S3Folder) GetPath() string

+ func (folder *S3Folder) GetSubFolder(subFolderRelativePath string) StorageFolder

+ func (folder *S3Folder) ListFolder() (objects []StorageObject, subFolders []StorageFolder, err error)

+ func (folder *S3Folder) PutObject(name string, content io.Reader) error

+ func (folder *S3Folder) ReadObject(objectRelativePath string) (io.ReadCloser, error)

+ type S3StorageObject struct

+ func NewS3StorageObject(object *s3.Object) *S3StorageObject

+ func (object *S3StorageObject) GetLastModified() time.Time

+ func (object *S3StorageObject) GetName() string

+ type S3Uploader struct

+ SSEKMSKeyId string

+ StorageClass string

+ func NewS3Uploader(uploaderAPI s3manageriface.UploaderAPI, ...) *S3Uploader

+ type Saver interface

+ Save func(writer io.Writer) error

+ type Sentinel struct

+ Info os.FileInfo

+ type SseKmsIdNotSetError struct

+ func NewSseKmsIdNotSetError() SseKmsIdNotSetError

+ func (err SseKmsIdNotSetError) Error() string

+ type StorageFolder interface

+ DeleteObjects func(objectRelativePaths []string) error

+ Exists func(objectRelativePath string) (bool, error)

+ GetPath func() string

+ GetSubFolder func(subFolderRelativePath string) StorageFolder

+ ListFolder func() (objects []StorageObject, subFolders []StorageFolder, err error)

+ PutObject func(name string, content io.Reader) error

+ ReadObject func(objectRelativePath string) (io.ReadCloser, error)

+ func ConfigureFSFolder(path string) (StorageFolder, error)

+ func ConfigureGSFolder(prefix string) (StorageFolder, error)

+ type StorageObject interface

+ GetLastModified func() time.Time

+ GetName func() string

+ type StorageReaderMaker struct

+ Folder StorageFolder

+ RelativePath string

+ func NewStorageReaderMaker(folder StorageFolder, relativePath string) *StorageReaderMaker

+ func (readerMaker *StorageReaderMaker) Path() string

+ func (readerMaker *StorageReaderMaker) Reader() (io.ReadCloser, error)

+ type StorageTarBall struct

+ func (tarBall *StorageTarBall) AddSize(i int64)

+ func (tarBall *StorageTarBall) AwaitUploads()

+ func (tarBall *StorageTarBall) CloseTar() error

+ func (tarBall *StorageTarBall) Finish(sentinelDto *BackupSentinelDto) error

+ func (tarBall *StorageTarBall) SetUp(crypter Crypter, names ...string)

+ func (tarBall *StorageTarBall) Size() int64

+ func (tarBall *StorageTarBall) TarWriter() *tar.Writer

+ type StorageTarBallMaker struct

+ func NewStorageTarBallMaker(backupName string, uploader *Uploader) *StorageTarBallMaker

+ func (tarBallMaker *StorageTarBallMaker) Make(dedicatedUploader bool) TarBall

+ type TarBall interface

+ AddSize func(int64)

+ AwaitUploads func()

+ CloseTar func() error

+ Finish func(sentinelDto *BackupSentinelDto) error

+ SetUp func(crypter Crypter, args ...string)

+ Size func() int64

+ TarWriter func() *tar.Writer

+ type TarBallMaker interface

+ Make func(dedicatedUploader bool) TarBall

+ func NewNopTarBallMaker() TarBallMaker

+ type TarInterpreter interface

+ Interpret func(reader io.Reader, header *tar.Header) error

+ type TarSizeError struct

+ func NewTarSizeError(packedFileSize, expectedSize int64) TarSizeError

+ func (err TarSizeError) Error() string

+ type TimeSlice []BackupTime

+ func (timeSlice TimeSlice) Len() int

+ func (timeSlice TimeSlice) Less(i, j int) bool

+ func (timeSlice TimeSlice) Swap(i, j int)

+ type UnexpectedTarDataError struct

+ func NewUnexpectedTarDataError() UnexpectedTarDataError

+ func (err UnexpectedTarDataError) Error() string

+ type UnknownCompressionMethodError struct

+ func NewUnknownCompressionMethodError() UnknownCompressionMethodError

+ func (err UnknownCompressionMethodError) Error() string

+ type UnknownIncrementFileHeaderError struct

+ func NewUnknownIncrementFileHeaderError() UnknownIncrementFileHeaderError

+ func (err UnknownIncrementFileHeaderError) Error() string

+ type UnknownTableSpaceError struct

+ func NewUnknownTableSpaceError() UnknownTableSpaceError

+ func (err UnknownTableSpaceError) Error() string

+ type UnsetEnvVarError struct

+ func NewUnsetEnvVarError(names []string) UnsetEnvVarError

+ func (err UnsetEnvVarError) Error() string

+ type UnsupportedFileTypeError struct

+ func NewUnsupportedFileTypeError(path string, fileFormat string) UnsupportedFileTypeError

+ type UnsupportedPostgresVersionError struct

+ func NewUnsupportedPostgresVersionError(version int) UnsupportedPostgresVersionError

+ func (err UnsupportedPostgresVersionError) Error() string

+ type UntilEOFReader struct

+ func NewUntilEofReader(underlying io.Reader) *UntilEOFReader

+ func (reader *UntilEOFReader) Read(p []byte) (n int, err error)

+ type Uploader struct

+ Success bool

+ func NewUploader(compressor Compressor, uploadingLocation StorageFolder, ...) *Uploader

+ func (uploader *Uploader) Clone() *Uploader

+ func (uploader *Uploader) UploadFile(file NamedReader) error

+ func (uploader *Uploader) UploadWalFile(file NamedReader) error

+ type WalDeltaRecorder struct

+ func NewWalDeltaRecorder(blockLocationConsumer chan walparser.BlockLocation) *WalDeltaRecorder

+ type WalDeltaRecordingReader struct

+ PageDataLeftover []byte

+ PageReader walparser.WalPageReader

+ Recorder *WalDeltaRecorder

+ WalParser walparser.WalParser

+ func NewWalDeltaRecordingReader(walFileReader io.Reader, walFilename string, manager *DeltaFileManager) (*WalDeltaRecordingReader, error)

+ func (reader *WalDeltaRecordingReader) Close() error

+ func (reader *WalDeltaRecordingReader) Read(p []byte) (n int, err error)

+ func (reader *WalDeltaRecordingReader) RecordBlockLocationsFromPage() error

+ type WalPart struct

+ func LoadWalPart(reader io.Reader) (*WalPart, error)

+ func NewWalPart(dataType WalPartDataType, id uint8, data []byte) *WalPart

+ func (part *WalPart) Save(writer io.Writer) error

+ type WalPartDataType uint8

+ const PreviousWalHeadType

+ const WalHeadType

+ const WalTailType

+ type WalPartFile struct

+ PreviousWalHead []byte

+ WalHeads [][]byte

+ WalTails [][]byte

+ func LoadPartFile(reader io.Reader) (*WalPartFile, error)

+ func NewWalPartFile() *WalPartFile

+ func (partFile *WalPartFile) CombineRecords() ([]walparser.XLogRecord, error)

+ func (partFile *WalPartFile) IsComplete() bool

+ func (partFile *WalPartFile) Save(writer io.Writer) error

+ type WalPartRecorder struct

+ func NewWalPartRecorder(walFilename string, manager *DeltaFileManager) (*WalPartRecorder, error)

+ func (recorder *WalPartRecorder) SaveNextWalHead(head []byte) error

+ func (recorder *WalPartRecorder) SavePreviousWalTail(tailData []byte) error

+ type WrongTypeError struct

+ func NewWrongTypeError(desiredType string) WrongTypeError

+ func (err WrongTypeError) Error() string

+ type ZeroReader struct

+ func (z *ZeroReader) Read(p []byte) (int, error)

+ type ZstdCompressor struct

+ func (compressor ZstdCompressor) FileExtension() string

+ func (compressor ZstdCompressor) NewWriter(writer io.Writer) ReaderFromWriteCloser

+ type ZstdDecompressor struct

+ func (decompressor ZstdDecompressor) Decompress(dst io.Writer, src io.Reader) error

+ func (decompressor ZstdDecompressor) FileExtension() string

+ type ZstdReaderFromWriter struct

+ func NewZstdReaderFromWriter(dst io.Writer) *ZstdReaderFromWriter

+ func (writer *ZstdReaderFromWriter) ReadFrom(reader io.Reader) (n int64, err error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL