postgres

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

type Backup struct {
	internal.Backup
	SentinelDto      *BackupSentinelDto // used for storage query caching
	FilesMetadataDto *FilesMetadataDto
}

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

type BackupDetail struct {
	internal.BackupTime
	ExtendedMetadataDto
}

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

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

type BackupHandler struct {
	CurBackupInfo CurBackupInfo

	Arguments BackupArguments
	Workers   BackupWorkers
	PgInfo    BackupPgInfo
	// contains filtered or unexported fields
}

type BackupObject struct {
	storage.Object
	BackupName string
	// contains filtered or unexported fields
}

type BackupPgInfo struct {
	PgDataDirectory string
	// contains filtered or unexported fields
}

type BackupSentinelDto struct {
	BackupStartLSN    *LSN    `json:"LSN"`
	IncrementFromLSN  *LSN    `json:"DeltaLSN,omitempty"`
	IncrementFrom     *string `json:"DeltaFrom,omitempty"`
	IncrementFullName *string `json:"DeltaFullName,omitempty"`
	IncrementCount    *int    `json:"DeltaCount,omitempty"`

	PgVersion        int     `json:"PgVersion"`
	BackupFinishLSN  *LSN    `json:"FinishLSN"`
	SystemIdentifier *uint64 `json:"SystemIdentifier,omitempty"`

	UncompressedSize int64           `json:"UncompressedSize"`
	CompressedSize   int64           `json:"CompressedSize"`
	DataCatalogSize  int64           `json:"DataCatalogSize,omitempty"`
	TablespaceSpec   *TablespaceSpec `json:"Spec"`

	UserData interface{} `json:"UserData,omitempty"`

	FilesMetadataDisabled bool `json:"FilesMetadataDisabled,omitempty"`
}

type BackupSentinelDtoV2 struct {
	BackupSentinelDto
	Version        int       `json:"Version"`
	StartTime      time.Time `json:"StartTime"`
	FinishTime     time.Time `json:"FinishTime"`
	DatetimeFormat string    `json:"DateFmt"`
	Hostname       string    `json:"Hostname"`
	DataDir        string    `json:"DataDir"`
	IsPermanent    bool      `json:"IsPermanent"`
}

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

type BackupTimeSlicesOrder int

type BackupWorkers struct {
	Uploader    internal.Uploader
	Bundle      *Bundle
	QueryRunner *PgQueryRunner
}

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

type Bundle struct {
	internal.Bundle
	Timeline           uint32
	Replica            bool
	IncrementFromLsn   *LSN
	IncrementFromFiles internal.BackupFileList
	IncrementFromName  string
	DeltaMap           PagedFileDeltaMap
	TablespaceSpec     TablespaceSpec
	DataCatalogSize    *int64
	// contains filtered or unexported fields
}

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

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

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

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

type CatchupFileUnwrapper struct {
	BackupFileUnwrapper
}

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

type Cleaner interface {
	GetFiles(directory string) ([]string, error)
	Remove(file string)
}

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

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

type CurBackupInfo struct {
	Name      string
	StartTime time.Time
	// contains filtered or unexported fields
}

type DatabaseObjectsInfo struct {
	Oid int `json:"oid"`
}

type DatabasesByNames map[string]DatabaseObjectsInfo

type DefaultFileUnwrapper struct {
	BackupFileUnwrapper
}

type DeleteHandler struct {
	internal.DeleteHandler
}

type DeltaBackupConfigurator interface {
	Configure(folder storage.Folder, isPermanent bool) (PrevBackupInfo, int, error)
}

type DeltaFile struct {
	Locations []walparser.BlockLocation
	WalParser *walparser.WalParser
}

type DeltaFileChanWriter struct {
	DeltaFile             *DeltaFile
	BlockLocationConsumer chan walparser.BlockLocation
}

type DeltaFileManager struct {
	PartFiles        *internal.LazyCache[string, *WalPartFile]
	DeltaFileWriters *internal.LazyCache[string, *DeltaFileChanWriter]

	CanceledDeltaFiles map[string]bool
	// contains filtered or unexported fields
}

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

type DeltaNo uint64

type DeprecatedSentinelFields struct {
	FilesMetadataDto
	DeltaFromLSN *LSN `json:"DeltaFromLSN,omitempty"`
}

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

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

type ExtendedMetadataDto struct {
	StartTime        time.Time `json:"start_time"`
	FinishTime       time.Time `json:"finish_time"`
	DatetimeFormat   string    `json:"date_fmt"`
	Hostname         string    `json:"hostname"`
	DataDir          string    `json:"data_dir"`
	PgVersion        int       `json:"pg_version"`
	StartLsn         LSN       `json:"start_lsn"`
	FinishLsn        LSN       `json:"finish_lsn"`
	IsPermanent      bool      `json:"is_permanent"`
	SystemIdentifier *uint64   `json:"system_identifier"`

	UncompressedSize int64 `json:"uncompressed_size"`
	CompressedSize   int64 `json:"compressed_size"`

	UserData interface{} `json:"user_data,omitempty"`
}

type ExtractProvider interface {
	Get(backup Backup, filesToUnwrap map[string]bool, skipRedundantTars bool, dbDataDir string, createNewIncrementalFiles bool) (
		interpreter IncrementalTarInterpreter, tarsToExtract []internal.ReaderMaker, pgControlKey string, err error)
}

type ExtractProviderDBSpec struct {
	ExtractProviderImpl
	// contains filtered or unexported fields
}

type ExtractProviderImpl struct {
	FilesToExtractProviderImpl
}

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

type FileTarInterpreter struct {
	DBDataDirectory string
	Sentinel        BackupSentinelDto
	FilesMetadata   FilesMetadataDto
	FilesToUnwrap   map[string]bool
	UnwrapResult    *UnwrapResult
	// contains filtered or unexported fields
}

type FileUnwrapResult struct {
	FileUnwrapResultType
	// contains filtered or unexported fields
}

type FileUnwrapResultType int

type FileUnwrapperType int

type FilesMetadataDto struct {
	Files            internal.BackupFileList `json:"Files,omitempty"`
	TarFileSets      map[string][]string     `json:"TarFileSets,omitempty"`
	DatabasesByNames DatabasesByNames        `json:"DatabasesByNames,omitempty"`
}

type FilesToExtractProvider interface {
	Get(backup Backup, filesToUnwrap map[string]bool, skipRedundantTars bool) (
		tarsToExtract []internal.ReaderMaker, pgControlKey string, err error)
}

type FilesToExtractProviderImpl struct {
}

type GenericMetaFetcher struct{}

type GenericMetaInteractor struct {
	GenericMetaFetcher
	GenericMetaSetter
}

type GenericMetaSetter struct{}

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

type IBackupFileUnwrapper interface {
	UnwrapNewFile(reader io.Reader, header *tar.Header, file *os.File, fsync bool) (*FileUnwrapResult, error)
	UnwrapExistingFile(reader io.Reader, header *tar.Header, file *os.File, fsync bool) (*FileUnwrapResult, error)
}

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

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

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

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

type IncrementalPageReader struct {
	PagedFile ioextensions.ReadSeekCloser
	FileSize  int64
	Lsn       LSN
	Next      []byte
	Blocks    []uint32
}

type IncrementalTarInterpreter interface {
	internal.TarInterpreter
	GetUnwrapResult() *UnwrapResult
}

type IntegrityCheckDetails []*IntegrityScanSegmentSequence

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

type IntegrityScanSegmentSequence struct {
	TimelineID    uint32               `json:"timeline_id"`
	StartSegment  string               `json:"start_segment"`
	EndSegment    string               `json:"end_segment"`
	SegmentsCount int                  `json:"segments_count"`
	Status        ScannedSegmentStatus `json:"status"`
}

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

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

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

type LSN uint64

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

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

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

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

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

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

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

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

type PgAliveWatcher struct {
	Err <-chan error
}

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

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

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

type PgDatabaseInfo struct {
	Name      string
	Oid       walparser.Oid
	TblSpcOid walparser.Oid
}

type PgDatabasePage [DatabasePageSize]byte

type PgQueryRunner struct {
	Connection       *pgx.Conn
	Version          int
	SystemIdentifier *uint64

	Mu sync.Mutex
	// contains filtered or unexported fields
}

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

type PhysicalSlot struct {
	Name       string
	Exists     bool
	Active     bool
	RestartLSN pglogrepl.LSN
}

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

type ProcessMessageResult int

type QueryRunner interface {
	// This call should inform the database that we are going to copy cluster's contents
	// Should fail if backup is currently impossible
	StartBackup(backup string) (string, string, bool, error)
	// Inform database that contents are copied, get information on backup
	StopBackup() (string, string, string, error)
}

type RatedComposeFileInfo struct {
	internal.ComposeFileInfo
	// contains filtered or unexported fields
}

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

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

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

type ReadWriterAt interface {
	io.ReaderAt
	io.WriterAt
	Size() int64
	Name() string
}

type ReadWriterAtFileImpl struct {
	*os.File
	// contains filtered or unexported fields
}

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

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

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

type RelFileStatistics map[walparser.RelFileNode]PgRelationStat

type ScannedSegmentDescription struct {
	WalSegmentDescription
	// contains filtered or unexported fields
}

type ScannedSegmentStatus int

type SegmentScanConfig struct {
	UnlimitedScan bool
	// ScanSegmentsLimit is used in case of UnlimitedScan is set to false
	ScanSegmentsLimit       int
	StopOnFirstFoundSegment bool
	// MissingSegmentStatus is set to all missing segments encountered during scan
	MissingSegmentStatus ScannedSegmentStatus
}

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

type SocketMessageHandler interface {
	Handle(messageBody []byte) error
}

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

type SocketMessageType byte

type StatBundleFiles struct {
	sync.Map
	// contains filtered or unexported fields
}

type StreamingBaseBackup struct {
	TimeLine uint32
	StartLSN pglogrepl.LSN
	EndLSN   pglogrepl.LSN

	UncompressedSize int64

	Files internal.BackupFileList
	// contains filtered or unexported fields
}

type TablespaceLocation struct {
	Location string `json:"loc"`
	Symlink  string `json:"link"`
}

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

type TarBallComposerMaker interface {
	Make(bundle *Bundle) (internal.TarBallComposer, error)
}

type TarBallComposerType int

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

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

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

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

type TarballStreamer struct {

	// files to write to extra tar (teeTar)
	Tee []string

	// io buffer where writer writes data to
	TeeIo *bytes.Buffer

	// list of remaps, remapping input file names to output file names
	Remaps TarballStreamerRemaps
	// list of processed files
	Files internal.BundleFiles
	// contains filtered or unexported fields
}

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

type TarballStreamerRemaps []TarballStreamerRemap

type TimeLineHistFile struct {
	TimeLineID uint32
	Filename   string
	// contains filtered or unexported fields
}

type TimeLineHistFileRow struct {
	TimeLineID uint32
	StartLSN   pglogrepl.LSN
	Comment    string
}

type TimelineCheckDetails struct {
	CurrentTimelineID        uint32 `json:"current_timeline_id"`
	HighestStorageTimelineID uint32 `json:"highest_storage_timeline_id"`
}

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

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

type TimelineInfo struct {
	ID               uint32          `json:"id"`
	ParentID         uint32          `json:"parent_id"`
	SwitchPointLsn   LSN             `json:"switch_point_lsn"`
	StartSegment     string          `json:"start_segment"`
	EndSegment       string          `json:"end_segment"`
	SegmentsCount    int             `json:"segments_count"`
	MissingSegments  []string        `json:"missing_segments"`
	Backups          []*BackupDetail `json:"backups,omitempty"`
	SegmentRangeSize uint64          `json:"segment_range_size"`
	Status           string          `json:"status"`
}

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

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

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

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

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

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

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

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

type WalDeltaRecordingReader struct {
	PageReader       walparser.WalPageReader
	WalParser        walparser.WalParser
	PageDataLeftover []byte
	Recorder         *WalDeltaRecorder
	// contains filtered or unexported fields
}

type WalMetadataDescription struct {
	CreatedTime    time.Time `json:"created_time"`
	DatetimeFormat string    `json:"date_fmt"`
}

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

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

type WalPartDataType uint8

type WalPartFile struct {
	WalTails        [][]byte
	PreviousWalHead []byte
	WalHeads        [][]byte
}

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

type WalSegment struct {
	TimeLine uint32
	StartLSN pglogrepl.LSN
	// contains filtered or unexported fields
}

type WalSegmentDescription struct {
	Number   WalSegmentNo
	Timeline uint32
}

type WalSegmentNo uint64

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

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

type WalSegmentScanner struct {
	ScannedSegments []ScannedSegmentDescription
	// contains filtered or unexported fields
}

type WalSegmentsSequence struct {
	TimelineID        uint32
	WalSegmentNumbers map[WalSegmentNo]bool
	MinSegmentNo      WalSegmentNo
	MaxSegmentNo      WalSegmentNo
}

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

type WalShowOutputType int

type WalShowOutputWriter interface {
	Write(timelineInfos []*TimelineInfo) error
}

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

type WalUploader struct {
	internal.Uploader
	ArchiveStatusManager   asm.ArchiveStatusManager
	PGArchiveStatusManager asm.ArchiveStatusManager
	*DeltaFileManager
}

type WalVerifyCheckDetails interface {
	NewPlainTextReader() (io.Reader, error) // used in plaintext output
}

type WalVerifyCheckResult struct {
	Status  WalVerifyCheckStatus  `json:"status"`
	Details WalVerifyCheckDetails `json:"details"`
}

type WalVerifyCheckRunner interface {
	Type() WalVerifyCheckType
	Run() (WalVerifyCheckResult, error)
}

type WalVerifyCheckStatus int

type WalVerifyCheckType int

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

type WalVerifyOutputType int

type WalVerifyOutputWriter interface {
	Write(results map[WalVerifyCheckType]WalVerifyCheckResult) error
}

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