db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-07-15 01:04:37 +02:00
Code Issues Releases Activity

Code cleanup and refactoring to standardize on patterns that have evolved over time.

Browse Source
This commit is contained in:
David Steele
2015-08-29 14:20:46 -04:00
parent d3262822ef
commit 6a9377a0a9
75 changed files with 20842 additions and 13115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -3,3 +3,5 @@
*.swp
test/test
test/vm/.vagrant
test/nytprof.out
test/nytprof/*

8
CHANGELOG.md
View File

@ -3,7 +3,13 @@
## v0.85: DALLAS MILESTONE - UNDER DEVELOPMENT
__No Release Date Set__
*
* Fixed an issue where resumed compressed backups were not preserving existing files.
* Fixed an issue where resume and incr/diff would not ensure that the prior backup has the same compression and hardlink settings.
* Code cleanup and refactoring to standardize on patterns that have evolved over time.
* Experimental support for PostgreSQL 9.5 alpha2. This may break when the control version or WAL magic changes in future versions but will be updated in each pgBackRest release to keep pace. All regression tests pass except for `--target-resume` tests (this functionality has changed in 9.5) and there is no testing yet for `.partial` WAL segments.
## v0.80: DBI Support, Stability, and Convenience Features
__Released August 9, 2015__

2
USERGUIDE.md
View File

@ -261,7 +261,7 @@ Path to the backrest repository where WAL segments, backups, logs, etc are store
The repository serves as both storage and working area for pgBackRest. In a simple installation where the backups are stored locally to the database server there will be only one repository which will contain everything: backups, archives, logs, locks, etc.
If the backups are being done remotely then the backup server's repository will contain backups, archives, locks and logs while the database server's repository will contain only locks and logs. However, if asynchronous archving is enabled then the database server's repository will also contain a spool directory for archive logs that have not yet been pushed to the remote repository.
If the backups are being done remotely then the backup server's repository will contain backups, archives, locks and logs while the database server's repository will contain only locks and logs. However, if asynchronous archiving is enabled then the database server's repository will also contain a spool directory for archive logs that have not yet been pushed to the remote repository.
Each system where pgBackRest is installed should have a repository directory configured. Storage requirements vary based on usage. The main backup repository will need the most space as it contains both backups and WAL segments for whatever retention you have specified. The database repository only needs significant space if asynchronous archiving is enabled and then it will act as an overflow for WAL segments and might need to be large depending on your database activity.

125
bin/pg_backrest
View File

@ -10,33 +10,53 @@ use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
# Convert die to confess to capture the stack trace
$SIG{__DIE__} = sub { Carp::confess @_ };
use File::Basename qw(dirname);
use Scalar::Util qw(blessed);
use lib dirname($0) . '/../lib';
use BackRest::Backup;
use BackRest::Archive;
use BackRest::Backup;
use BackRest::Common::Exception;
use BackRest::Common::Lock;
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::Db;
use BackRest::Exception;
use BackRest::Expire;
use BackRest::File;
use BackRest::Info;
use BackRest::Lock;
use BackRest::Protocol::RemoteMinion;
use BackRest::Protocol::ThreadGroup;
use BackRest::Restore;
use BackRest::ThreadGroup;
use BackRest::Utility;
####################################################################################################################################
# SAFE_EXIT - terminate all threads and SSH connections when the script is terminated
# Operation constants
####################################################################################################################################
sub safe_exit
use constant OP_MAIN => 'Main';
use constant OP_MAIN_SAFE_EXIT => OP_MAIN . '::safeExit';
####################################################################################################################################
# safeExit
#
# Terminate all threads and SSH connections when the script is terminated.
####################################################################################################################################
sub safeExit
{
my $iExitCode = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$iExitCode
) =
logDebugParam
(
OP_MAIN_SAFE_EXIT, \@_,
{name => 'iExitCode', required => false}
);
&log(DEBUG, "safe exit called, terminating threads");
commandStop();
my $iTotal = threadGroupDestroy();
protocolDestroy();
@ -49,9 +69,9 @@ sub safe_exit
&log(ERROR, "process terminated on signal or exception, ${iTotal} threads stopped");
}
$SIG{TERM} = \&safe_exit;
$SIG{HUP} = \&safe_exit;
$SIG{INT} = \&safe_exit;
$SIG{TERM} = \&safeExit;
$SIG{HUP} = \&safeExit;
$SIG{INT} = \&safeExit;
####################################################################################################################################
# START EVAL BLOCK TO CATCH ERRORS AND STOP THREADS
@ -69,7 +89,7 @@ eval
if (commandTest(CMD_REMOTE))
{
# Turn all logging off
log_level_set(OFF, OFF);
logLevelSet(OFF, OFF);
# Create the remote object
my $oRemote = new BackRest::Protocol::RemoteMinion
@ -80,21 +100,24 @@ eval
);
# Process remote requests
safe_exit($oRemote->process());
safeExit($oRemote->process());
}
# Set the log levels
log_level_set(optionGet(OPTION_LOG_LEVEL_FILE), optionGet(OPTION_LOG_LEVEL_CONSOLE));
logLevelSet(optionGet(OPTION_LOG_LEVEL_FILE), optionGet(OPTION_LOG_LEVEL_CONSOLE));
# Set test options
!optionGet(OPTION_TEST) or test_set(optionGet(OPTION_TEST), optionGet(OPTION_TEST_DELAY));
!optionGet(OPTION_TEST) or testSet(optionGet(OPTION_TEST), optionGet(OPTION_TEST_DELAY));
# Log the command start
commandStart();
################################################################################################################################
# Process archive commands
################################################################################################################################
if (commandTest(CMD_ARCHIVE_PUSH) || commandTest(CMD_ARCHIVE_GET))
{
safe_exit(new BackRest::Archive()->process());
safeExit(new BackRest::Archive()->process());
}
################################################################################################################################
@ -102,7 +125,7 @@ eval
################################################################################################################################
if (commandTest(CMD_INFO))
{
safe_exit(new BackRest::Info()->info());
safeExit(new BackRest::Info()->process());
}
################################################################################################################################
@ -113,7 +136,7 @@ eval
################################################################################################################################
# Open the log file
################################################################################################################################
log_file_set(optionGet(OPTION_REPO_PATH) . '/log/' . optionGet(OPTION_STANZA) . '-' . lc(commandGet()));
logFileSet(optionGet(OPTION_REPO_PATH) . '/log/' . optionGet(OPTION_STANZA) . '-' . lc(commandGet()));
################################################################################################################################
# Create the thread group that will be used for parallel processing
@ -144,25 +167,10 @@ eval
# Do the restore
new BackRest::Restore
(
optionGet(OPTION_DB_PATH),
optionGet(OPTION_SET),
optionGet(OPTION_RESTORE_TABLESPACE_MAP, false),
$oFile,
optionGet(OPTION_THREAD_MAX),
optionGet(OPTION_DELTA),
optionGet(OPTION_FORCE),
optionGet(OPTION_TYPE),
optionGet(OPTION_TARGET, false),
optionGet(OPTION_TARGET_EXCLUSIVE, false),
optionGet(OPTION_TARGET_RESUME, false),
optionGet(OPTION_TARGET_TIMELINE, false),
optionGet(OPTION_RESTORE_RECOVERY_SETTING, false),
optionGet(OPTION_STANZA),
$0,
optionGet(OPTION_CONFIG)
)->restore;
$oFile
)->process;
safe_exit(0);
safeExit(0);
}
################################################################################################################################
@ -178,21 +186,10 @@ eval
################################################################################################################################
if (commandTest(CMD_BACKUP))
{
# Run backup_init - parameters required for backup commands
backup_init
new BackRest::Backup
(
$oFile,
new BackRest::Db(),
optionGet(OPTION_TYPE),
optionGet(OPTION_COMPRESS),
optionGet(OPTION_HARDLINK),
optionGet(OPTION_THREAD_MAX),
optionGet(OPTION_THREAD_TIMEOUT, false),
optionGet(OPTION_NO_START_STOP),
optionTest(OPTION_FORCE)
);
backup(optionGet(OPTION_DB_PATH), optionGet(OPTION_START_FAST));
$oFile
)->process();
commandSet(CMD_EXPIRE);
}
@ -202,28 +199,16 @@ eval
################################################################################################################################
if (commandTest(CMD_EXPIRE))
{
backup_init
new BackRest::Expire
(
$oFile
);
backup_expire
(
$oFile->path_get(PATH_BACKUP_CLUSTER),
optionGet(OPTION_RETENTION_FULL, false),
optionGet(OPTION_RETENTION_DIFF, false),
optionGet(OPTION_RETENTION_ARCHIVE_TYPE, false),
optionGet(OPTION_RETENTION_ARCHIVE, false)
);
)->process();
}
# Cleanup backup (should be removed when backup becomes an object)
backup_cleanup();
# Release the command lock
lockRelease();
safe_exit(0);
safeExit(0);
};
####################################################################################################################################
@ -234,11 +219,11 @@ if ($@)
my $oMessage = $@;
# If a backrest exception then return the code - don't confess
if (blessed($oMessage) && $oMessage->isa('BackRest::Exception'))
if (blessed($oMessage) && $oMessage->isa('BackRest::Common::Exception'))
{
safe_exit($oMessage->code());
safeExit($oMessage->code());
}
safe_exit();
safeExit();
confess $oMessage;
}

5
doc/doc.pl
View File

@ -19,8 +19,9 @@ use Pod::Usage qw(pod2usage);
use XML::Checker::Parser;
use lib dirname($0) . '/../lib';
use BackRest::Common::Log;
use BackRest::Common::String;
use BackRest::Config;
use BackRest::Utility;
####################################################################################################################################
# Usage
@ -681,7 +682,7 @@ if ($bQuiet)
$strLogLevel = 'off';
}
log_level_set(undef, uc($strLogLevel));
logLevelSet(undef, uc($strLogLevel));
my $strBasePath = abs_path(dirname($0));

11
doc/xml/changelog.xml
View File

@ -9,7 +9,16 @@
<changelog-release date="XXXX-XX-XX" version="0.85" title="DALLAS MILESTONE - UNDER DEVELOPMENT">
<release-feature-bullet-list>
<release-feature>
<text></text>
<text>Fixed an issue where resumed compressed backups were not preserving existing files.</text>
</release-feature>
<release-feature>
<text>Fixed an issue where resume and incr/diff would not ensure that the prior backup has the same compression and hardlink settings.</text>
</release-feature>
<release-feature>
<text>Code cleanup and refactoring to standardize on patterns that have evolved over time.</text>
</release-feature>
<release-feature>
<text>Experimental support for <postgres/> 9.5 alpha2. This may break when the control version or WAL magic changes in future versions but will be updated in each <backrest/> release to keep pace. All regression tests pass except for <setting>--target-resume</setting> tests (this functionality has changed in 9.5) and there is no testing yet for <file>.partial</file> WAL segments.</text>
</release-feature>
</release-feature-bullet-list>
</changelog-release>

2
doc/xml/userguide.xml
View File

@ -258,7 +258,7 @@
The repository serves as both storage and working area for pgBackRest. In a simple installation where the backups are stored locally to the database server there will be only one repository which will contain everything: backups, archives, logs, locks, etc.
If the backups are being done remotely then the backup server's repository will contain backups, archives, locks and logs while the database server's repository will contain only locks and logs. However, if asynchronous archving is enabled then the database server's repository will also contain a spool directory for archive logs that have not yet been pushed to the remote repository.
If the backups are being done remotely then the backup server's repository will contain backups, archives, locks and logs while the database server's repository will contain only locks and logs. However, if asynchronous archiving is enabled then the database server's repository will also contain a spool directory for archive logs that have not yet been pushed to the remote repository.
Each system where <backrest/> is installed should have a repository directory configured. Storage requirements vary based on usage. The main backup repository will need the most space as it contains both backups and WAL segments for whatever retention you have specified. The database repository only needs significant space if asynchronous archiving is enabled and then it will act as an overflow for WAL segments and might need to be large depending on your database activity.

444
lib/BackRest/Archive.pm
View File

@ -8,28 +8,40 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
use Fcntl qw(SEEK_CUR O_RDONLY O_WRONLY O_CREAT O_EXCL);
our @EXPORT = qw();
use Fcntl qw(SEEK_CUR O_RDONLY O_WRONLY O_CREAT);
use File::Basename qw(dirname basename);
use lib dirname($0);
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Lock;
use BackRest::Common::Log;
use BackRest::ArchiveInfo;
use BackRest::Common::String;
use BackRest::Common::Wait;
use BackRest::Config;
use BackRest::Exception;
use BackRest::File;
use BackRest::Ini;
use BackRest::Lock;
#use BackRest::Protocol::Protocol;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_ARCHIVE => 'Archive';
use constant OP_ARCHIVE_PUSH_CHECK => OP_ARCHIVE . '->pushCheck';
our @EXPORT = qw(OP_ARCHIVE_PUSH_CHECK);
use constant OP_ARCHIVE_GET => OP_ARCHIVE . '->get';
use constant OP_ARCHIVE_GET_CHECK => OP_ARCHIVE . '->getCheck';
push @EXPORT, qw(OP_ARCHIVE_GET_CHECK);
use constant OP_ARCHIVE_GET_PROCESS => OP_ARCHIVE . '->getProcess';
use constant OP_ARCHIVE_NEW => OP_ARCHIVE . '->new';
use constant OP_ARCHIVE_PROCESS => OP_ARCHIVE . '->process';
use constant OP_ARCHIVE_PUSH => OP_ARCHIVE . '->pushProcess';
use constant OP_ARCHIVE_PUSH_CHECK => OP_ARCHIVE . '->pushCheck';
push @EXPORT, qw(OP_ARCHIVE_PUSH_CHECK);
use constant OP_ARCHIVE_PUSH_PROCESS => OP_ARCHIVE . '->pushProcess';
use constant OP_ARCHIVE_RANGE => OP_ARCHIVE . '->range';
use constant OP_ARCHIVE_WAL_FILE_NAME => OP_ARCHIVE . '->walFileName';
use constant OP_ARCHIVE_WAL_INFO => OP_ARCHIVE . '->walInfo';
use constant OP_ARCHIVE_XFER => OP_ARCHIVE . '->xfer';
####################################################################################################################################
# constructor
@ -38,11 +50,26 @@ sub new
{
my $class = shift; # Class name
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_ARCHIVE_NEW
);
# Create the class hash
my $self = {};
bless $self, $class;
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
@ -54,20 +81,40 @@ sub process
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_ARCHIVE_PROCESS
);
my $iResult;
# Process push
if (commandTest(CMD_ARCHIVE_PUSH))
{
return $self->pushProcess();
$iResult = $self->pushProcess();
}
# Process get
if (commandTest(CMD_ARCHIVE_GET))
elsif (commandTest(CMD_ARCHIVE_GET))
{
return $self->getProcess();
$iResult = $self->getProcess();
}
# Else error if any other command is found
else
{
confess &log(ASSERT, "Archive->process() called with invalid command: " . commandGet());
}
# Error if any other command is found
confess &log(ASSERT, "Archive->process() called with invalid command: " . commandGet());
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'iResult', value => $iResult, trace => true}
);
}
################################################################################################################################
@ -77,6 +124,16 @@ sub getProcess
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_ARCHIVE_GET_PROCESS
);
# Make sure the archive file is defined
if (!defined($ARGV[1]))
{
@ -90,10 +147,14 @@ sub getProcess
}
# Info for the Postgres log
&log(INFO, 'getting WAL segment ' . $ARGV[1]);
&log(INFO, 'get WAL segment ' . $ARGV[1]);
# Get the WAL segment
return $self->get($ARGV[1], $ARGV[2]);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'iResult', value => $self->get($ARGV[1], $ARGV[2]), trace => true}
);
}
####################################################################################################################################
@ -105,44 +166,58 @@ sub getProcess
sub walFileName
{
my $self = shift;
my $oFile = shift;
my $strArchiveId = shift;
my $strWalSegment = shift;
my $iWaitSeconds = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile,
$strArchiveId,
$strWalSegment,
$iWaitSeconds
) =
logDebugParam
(
OP_ARCHIVE_WAL_FILE_NAME, \@_,
{name => 'oFile'},
{name => 'strArchiveId'},
{name => 'strWalSegment'},
{name => 'iWaitSeconds', required => false}
);
# Record the start time
my $oWait = waitInit($iWaitSeconds);
# Determine the path where the requested WAL segment is located
my $strArchivePath = dirname($oFile->path_get(PATH_BACKUP_ARCHIVE, "$strArchiveId/${strWalSegment}"));
my $strArchivePath = dirname($oFile->pathGet(PATH_BACKUP_ARCHIVE, "$strArchiveId/${strWalSegment}"));
my @stryWalFileName;
do
{
# Get the name of the requested WAL segment (may have hash info and compression extension)
my @stryWalFileName = $oFile->list(PATH_BACKUP_ABSOLUTE, $strArchivePath,
@stryWalFileName = $oFile->list(PATH_BACKUP_ABSOLUTE, $strArchivePath,
"^${strWalSegment}(-[0-f]+){0,1}(\\.$oFile->{strCompressExtension}){0,1}\$", undef, true);
# If there is only one result then return it
if (@stryWalFileName == 1)
{
return $stryWalFileName[0];
}
# If there is more than one matching archive file then there is a serious issue - likely a bug in the archiver
if (@stryWalFileName > 1)
{
confess &log(ASSERT, @stryWalFileName . " duplicate files found for ${strWalSegment}", ERROR_ARCHIVE_DUPLICATE);
}
}
while (waitMore($oWait));
while (@stryWalFileName == 0 && waitMore($oWait));
# If waiting and no WAL segment was found then throw an error
if (defined($iWaitSeconds))
if (@stryWalFileName == 0 && defined($iWaitSeconds))
{
confess &log(ERROR, "could not find WAL segment ${strWalSegment} after " . waitInterval($oWait) . ' second(s)');
}
return undef;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strWalFileName', value => $stryWalFileName[0]}
);
}
####################################################################################################################################
@ -153,11 +228,18 @@ sub walFileName
sub walInfo
{
my $self = shift;
my $strWalFile = shift;
# Set operation and debug strings
my $strOperation = 'Archive->walInfo';
&log(TRACE, "${strOperation}: " . PATH_ABSOLUTE . ":${strWalFile}");
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strWalFile,
) =
logDebugParam
(
OP_ARCHIVE_WAL_INFO, \@_,
{name => 'strWalFile'}
);
# Open the WAL segment
my $hFile;
@ -238,6 +320,7 @@ sub walInfo
my $iFlag = unpack('S', $tBlock);
# Make sure that the long header is present or there won't be a system id
$iFlag & 2
or confess &log(ERROR, "expected long header in flags " . sprintf("%x", $iFlag));
@ -255,9 +338,13 @@ sub walInfo
my $ullDbSysId = unpack('Q', $tBlock);
&log(TRACE, sprintf("${strOperation}: WAL magic = 0x%X, database system id = ", $iMagic) . $ullDbSysId);
return $strDbVersion, $ullDbSysId;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strDbVersion', value => $strDbVersion},
{name => 'ullDbSysId', value => $ullDbSysId}
);
}
####################################################################################################################################
@ -266,8 +353,20 @@ sub walInfo
sub get
{
my $self = shift;
my $strSourceArchive = shift;
my $strDestinationFile = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strSourceArchive,
$strDestinationFile
) =
logDebugParam
(
OP_ARCHIVE_GET, \@_,
{name => 'strSourceArchive'},
{name => 'strDestinationFile'}
);
# Create the file object
my $oFile = new BackRest::File
@ -281,9 +380,11 @@ sub get
# If the destination file path is not absolute then it is relative to the db data path
if (index($strDestinationFile, '/',) != 0)
{
# !!! If db-path is required this is can be removed.
# !!! db-path should be added as a requirement for the remote settings work.
if (!optionTest(OPTION_DB_PATH))
{
confess &log(ERROR, 'database path must be set if relative xlog paths are used');
confess &log(ERROR, 'option db-path must be set when relative xlog paths are used');
}
$strDestinationFile = optionGet(OPTION_DB_PATH) . "/${strDestinationFile}";
@ -298,15 +399,16 @@ sub get
# 2) There is a hole in the archive stream and a hard error should be returned. However, holes are possible due to
# async archiving and threading - so when to report a hole? Since a hard error will cause PG to terminate, for now
# treat as case #1.
my $iResult = 0;
if (!defined($strArchiveFile))
{
&log(INFO, "${strSourceArchive} was not found in the archive repository");
&log(INFO, "unable to find ${strSourceArchive} in the archive");
return 1;
$iResult = 1;
}
&log(DEBUG, "archive_get: cp ${strArchiveFile} ${strDestinationFile}");
else
{
# Determine if the source file is already compressed
my $bSourceCompressed = $strArchiveFile =~ "^.*\.$oFile->{strCompressExtension}\$" ? true : false;
@ -315,8 +417,14 @@ sub get
PATH_DB_ABSOLUTE, $strDestinationFile, # Destination file
$bSourceCompressed, # Source compression based on detection
false); # Destination is not compressed
}
return 0;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'iResult', value => $iResult}
);
}
####################################################################################################################################
@ -327,21 +435,33 @@ sub getCheck
my $self = shift;
my $oFile = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_ARCHIVE_GET_CHECK
);
my $strArchiveId;
if ($oFile->is_remote(PATH_BACKUP_ARCHIVE))
if ($oFile->isRemote(PATH_BACKUP_ARCHIVE))
{
$strArchiveId = $oFile->{oProtocol}->cmdExecute(OP_ARCHIVE_GET_CHECK, undef, true);
}
else
{
$strArchiveId = (new BackRest::ArchiveInfo($oFile->path_get(PATH_BACKUP_ARCHIVE), true))->archiveId();
$strArchiveId = (new BackRest::ArchiveInfo($oFile->pathGet(PATH_BACKUP_ARCHIVE), true))->archiveId();
}
# Set operation and debug strings
&log(DEBUG, OP_ARCHIVE_GET_CHECK . "=>: archiveId = ${strArchiveId}");
return $strArchiveId;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strArchiveId', value => $strArchiveId, trace => true}
);
}
####################################################################################################################################
@ -351,6 +471,16 @@ sub pushProcess
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_ARCHIVE_PUSH_PROCESS
);
# Make sure the archive push command happens on the db side
if (optionRemoteTypeTest(DB))
{
@ -388,43 +518,40 @@ sub pushProcess
}
}
&log(INFO, 'pushing WAL segment ' . $ARGV[1] . ($bArchiveAsync ? ' asynchronously' : ''));
&log(INFO, 'push WAL segment ' . $ARGV[1] . ($bArchiveAsync ? ' asynchronously' : ''));
$self->push($ARGV[1], $bArchiveAsync);
# Exit if we are not archiving async
if (!$bArchiveAsync)
# Fork is async archiving is enabled
if ($bArchiveAsync)
{
return 0;
}
# Fork and exit the parent process so the async process can continue
# Fork and disable the async archive flag if this is the parent process
if (!optionTest(OPTION_TEST_NO_FORK) || !optionGet(OPTION_TEST_NO_FORK))
{
if (fork())
{
return 0;
}
$bArchiveAsync = fork() == 0 ? true : false;
}
# Else the no-fork flag has been specified for testing
else
{
&log(DEBUG, 'No fork on archive local for TESTING');
logDebugMisc($strOperation, 'no fork on archive local for TESTING');
}
}
}
if ($bArchiveAsync)
{
# Start the async archive push
&log(DEBUG, 'starting async archive-push');
}
logDebugMisc($strOperation, 'start async archive-push');
# Create a lock file to make sure async archive-push does not run more than once
if (!lockAcquire(commandGet(), false))
{
&log(DEBUG, 'another async archive-push process is already running - exiting');
return 0;
logDebugMisc($strOperation, 'async archive-push process is already running - exiting');
}
else
{
# Open the log file
log_file_set(optionGet(OPTION_REPO_PATH) . '/log/' . optionGet(OPTION_STANZA) . '-archive-async');
logFileSet(optionGet(OPTION_REPO_PATH) . '/log/' . optionGet(OPTION_STANZA) . '-archive-async');
# Call the archive_xfer function and continue to loop as long as there are files to process
my $iLogTotal;
@ -435,16 +562,25 @@ sub pushProcess
if ($iLogTotal > 0)
{
&log(DEBUG, "transferred ${iLogTotal} WAL segment(s), calling Archive->xfer() again");
logDebugMisc($strOperation, "transferred ${iLogTotal} WAL segment" .
($iLogTotal > 1 ? 's' : '') . ', calling Archive->xfer() again');
}
else
{
&log(DEBUG, 'transfer found 0 WAL segments - exiting');
logDebugMisc($strOperation, 'transfer found 0 WAL segments - exiting');
}
}
lockRelease();
return 0;
}
}
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'iResult', value => 0, trace => true}
);
}
####################################################################################################################################
@ -453,8 +589,20 @@ sub pushProcess
sub push
{
my $self = shift;
my $strSourceFile = shift;
my $bAsync = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strSourceFile,
$bAsync
) =
logDebugParam
(
OP_ARCHIVE_PUSH, \@_,
{name => 'strSourceFile'},
{name => 'bAsync'}
);
# Create the file object
my $oFile = new BackRest::File
@ -470,7 +618,7 @@ sub push
{
if (!optionTest(OPTION_DB_PATH))
{
confess &log(ERROR, 'database path must be set if relative xlog paths are used');
confess &log(ERROR, 'option db-path must be set when relative xlog paths are used');
}
$strSourceFile = optionGet(OPTION_DB_PATH) . "/${strSourceFile}";
@ -524,6 +672,12 @@ sub push
undef, undef, # User and group
$bArchiveFile); # Append checksum if archive file
}
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
####################################################################################################################################
@ -532,19 +686,32 @@ sub push
sub pushCheck
{
my $self = shift;
my $oFile = shift;
my $strWalSegment = shift;
my $strWalFile = shift;
my $strDbVersion = shift;
my $ullDbSysId = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile,
$strWalSegment,
$strWalFile,
$strDbVersion,
$ullDbSysId
) =
logDebugParam
(
OP_ARCHIVE_PUSH_CHECK, \@_,
{name => 'oFile'},
{name => 'strWalSegment'},
{name => 'strWalFile', required => false},
{name => 'strDbVersion'},
{name => 'ullDbSysId'}
);
# Set operation and debug strings
my $strOperation = OP_ARCHIVE_PUSH_CHECK;
&log(DEBUG, "${strOperation}: " . PATH_BACKUP_ARCHIVE . ":${strWalSegment}");
my $strChecksum;
my $strArchiveId;
if ($oFile->is_remote(PATH_BACKUP_ARCHIVE))
if ($oFile->isRemote(PATH_BACKUP_ARCHIVE))
{
# Build param hash
my %oParamHash;
@ -553,11 +720,8 @@ sub pushCheck
$oParamHash{'db-version'} = $strDbVersion;
$oParamHash{'db-sys-id'} = $ullDbSysId;
# Output remote trace info
&log(TRACE, "${strOperation}: remote (" . $oFile->{oProtocol}->commandParamString(\%oParamHash) . ')');
# Execute the command
my $strResult = $oFile->{oProtocol}->cmdExecute($strOperation, \%oParamHash, true);
my $strResult = $oFile->{oProtocol}->cmdExecute(OP_ARCHIVE_PUSH_CHECK, \%oParamHash, true);
$strArchiveId = (split("\t", $strResult))[0];
$strChecksum = (split("\t", $strResult))[1];
@ -572,11 +736,11 @@ sub pushCheck
# Create the archive path if it does not exist
if (!$oFile->exists(PATH_BACKUP_ARCHIVE))
{
$oFile->path_create(PATH_BACKUP_ARCHIVE);
$oFile->pathCreate(PATH_BACKUP_ARCHIVE);
}
# If the info file exists check db version and system-id
$strArchiveId = (new BackRest::ArchiveInfo($oFile->path_get(PATH_BACKUP_ARCHIVE)))->check($strDbVersion, $ullDbSysId);
$strArchiveId = (new BackRest::ArchiveInfo($oFile->pathGet(PATH_BACKUP_ARCHIVE)))->check($strDbVersion, $ullDbSysId);
# Check if the WAL segment already exists in the archive
$strChecksum = $self->walFileName($oFile, $strArchiveId, $strWalSegment);
@ -598,11 +762,15 @@ sub pushCheck
&log(WARN, "WAL segment ${strWalSegment} already exists in the archive with the same checksum\n" .
"HINT: this is valid in some recovery scenarios but may also indicate a problem");
return $strArchiveId, $strChecksum;
}
return $strArchiveId, $strChecksum;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strArchiveId', value => $strArchiveId},
{name => 'strChecksum', value => $strChecksum}
);
}
####################################################################################################################################
@ -611,8 +779,20 @@ sub pushCheck
sub xfer
{
my $self = shift;
my $strArchivePath = shift;
my $strStopFile = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strArchivePath,
$strStopFile
) =
logDebugParam
(
OP_ARCHIVE_XFER, \@_,
{name => 'strArchivePath'},
{name => 'strStopFile'}
);
# Create a local file object to read archive logs in the local store
my $oFile = new BackRest::File
@ -646,11 +826,12 @@ sub xfer
if ($lFileTotal == 0)
{
&log(DEBUG, 'no archive logs to be copied to backup');
logDebugMisc($strOperation, 'no WAL segments to archive');
return 0;
}
else
{
eval
{
# If the archive repo is remote create a new file object to do the copies
@ -670,7 +851,7 @@ sub xfer
"archive-push-async " . $stryFile[0] . '-' . $stryFile[scalar @stryFile - 1];
# Output files to be moved to backup
&log(INFO, "archive to be copied to backup total ${lFileTotal}, size " . file_size_format($lFileSize));
&log(INFO, "WAL segments to archive: total = ${lFileTotal}, size = " . fileSizeFormat($lFileSize));
# Transfer each file
foreach my $strFile (sort @stryFile)
@ -698,8 +879,14 @@ sub xfer
$strDestinationFile = substr($strDestinationFile, 0, length($strDestinationFile) - 3);
}
&log(DEBUG, "archive ${strFile}, is WAL ${bArchiveFile}, source_compressed = ${bSourceCompressed}, " .
"destination_compress ${bDestinationCompress}, default_compress = " . optionGet(OPTION_COMPRESS));
logDebugMisc
(
$strOperation, undef,
{name => 'strFile', value => $strFile},
{name => 'bArchiveFile', value => $bArchiveFile},
{name => 'bSourceCompressed', value => $bSourceCompressed},
{name => 'bDestinationCompress', value => $bDestinationCompress}
);
# Check that there are no issues with pushing this WAL segment
my $strArchiveId;
@ -750,7 +937,7 @@ sub xfer
if ($iArchiveMaxMB < int($lFileSize / 1024 / 1024))
{
&log(ERROR, "local archive store max size has exceeded limit of ${iArchiveMaxMB}MB" .
&log(ERROR, "local archive queue has exceeded limit of ${iArchiveMaxMB}MB" .
" - WAL segments will be discarded until the stop file (${strStopFile}) is removed");
my $hStopFile;
@ -765,9 +952,14 @@ sub xfer
{
confess $oException;
}
}
# Return number of files indicating that processing should continue
return $lFileTotal;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'lFileTotal', value => $lFileTotal}
);
}
@ -780,21 +972,22 @@ sub xfer
sub range
{
my $self = shift;
my $strArchiveStart = shift;
my $strArchiveStop = shift;
my $bSkipFF = shift;
# strSkipFF default to false
$bSkipFF = defined($bSkipFF) ? $bSkipFF : false;
if ($bSkipFF)
{
&log(TRACE, 'archive_list_get: pre-9.3 database, skipping log FF');
}
else
{
&log(TRACE, 'archive_list_get: post-9.3 database, including log FF');
}
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strArchiveStart,
$strArchiveStop,
$bSkipFF
) =
logDebugParam
(
OP_ARCHIVE_RANGE, \@_,
{name => 'strArchiveStart'},
{name => 'strArchiveStop'},
{name => 'bSkipFF', default => false}
);
# Get the timelines and make sure they match
my $strTimeline = substr($strArchiveStart, 0, 8);
@ -803,7 +996,7 @@ sub range
if ($strTimeline ne substr($strArchiveStop, 0, 8))
{
confess &log(ERROR, "Timelines between ${strArchiveStart} and ${strArchiveStop} differ");
confess &log(ERROR, "timelines differ between ${strArchiveStart} and ${strArchiveStop}");
}
# Iterate through all archive logs between start and stop
@ -830,9 +1023,12 @@ sub range
$iArchiveIdx += 1;
}
&log(TRACE, " archive_list_get: $strArchiveStart:$strArchiveStop (@stryArchive)");
return @stryArchive;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'stryArchive', value => \@stryArchive}
);
}
1;

83
lib/BackRest/ArchiveInfo.pm
View File

@ -2,7 +2,7 @@
# ARCHIVE INFO MODULE
####################################################################################################################################
package BackRest::ArchiveInfo;
use parent 'BackRest::Ini';
use parent 'BackRest::Common::Ini';
use strict;
use warnings FATAL => qw(all);
@ -13,19 +13,21 @@ use File::Basename qw(dirname basename);
use File::stat;
use lib dirname($0);
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::BackupInfo;
use BackRest::Config;
use BackRest::Exception;
use BackRest::File;
use BackRest::Ini;
use BackRest::Manifest;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_ARCHIVE_INFO => 'ArchiveInfo';
use constant OP_ARCHIVE_INFO_ARCHIVE_ID => OP_ARCHIVE_INFO . "->archiveId";
use constant OP_ARCHIVE_INFO_CHECK => OP_ARCHIVE_INFO . "->check";
use constant OP_ARCHIVE_INFO_NEW => OP_ARCHIVE_INFO . "->new";
####################################################################################################################################
@ -55,16 +57,26 @@ use constant INFO_ARCHIVE_KEY_DB_SYSTEM_ID => MANIFEST_
sub new
{
my $class = shift; # Class name
my $strArchiveClusterPath = shift; # Backup cluster path
my $bRequired = shift; # Is archive info required?
logDebug(OP_ARCHIVE_INFO_NEW, DEBUG_CALL, undef, {archiveClusterPath => \$strArchiveClusterPath});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strArchiveClusterPath, # Backup cluster path
$bRequired # Is archive info required?
) =
logDebugParam
(
OP_ARCHIVE_INFO_NEW, \@_,
{name => 'strArchiveClusterPath'},
{name => 'bRequired', default => false}
);
# Build the archive info path/file name
my $strArchiveInfoFile = "${strArchiveClusterPath}/" . ARCHIVE_INFO_FILE;
my $bExists = -e $strArchiveInfoFile ? true : false;
if (!$bExists && defined($bRequired) && $bRequired)
if (!$bExists && $bRequired)
{
confess &log(ERROR, ARCHIVE_INFO_FILE . " does not exist but is required to get WAL segments\n" .
"HINT: Is archive_command configured in postgresql.conf?\n" .
@ -78,7 +90,12 @@ sub new
$self->{bExists} = $bExists;
$self->{strArchiveClusterPath} = $strArchiveClusterPath;
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
@ -89,8 +106,20 @@ sub new
sub check
{
my $self = shift;
my $strDbVersion = shift;
my $ullDbSysId = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strDbVersion,
$ullDbSysId
) =
logDebugParam
(
OP_ARCHIVE_INFO_CHECK, \@_,
{name => 'strDbVersion'},
{name => 'ullDbSysId'}
);
my $bSave = false;
@ -121,12 +150,12 @@ sub check
my $iDbId = 1;
# Fill db section
$self->setNumeric(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_SYSTEM_ID, undef, $ullDbSysId);
$self->numericSet(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_SYSTEM_ID, undef, $ullDbSysId);
$self->set(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_VERSION, undef, $strDbVersion);
$self->setNumeric(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_ID, undef, $iDbId);
$self->numericSet(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_ID, undef, $iDbId);
# Fill db history
$self->setNumeric(INFO_ARCHIVE_SECTION_DB_HISTORY, $iDbId, INFO_ARCHIVE_KEY_DB_ID, $ullDbSysId);
$self->numericSet(INFO_ARCHIVE_SECTION_DB_HISTORY, $iDbId, INFO_ARCHIVE_KEY_DB_ID, $ullDbSysId);
$self->set(INFO_ARCHIVE_SECTION_DB_HISTORY, $iDbId, INFO_ARCHIVE_KEY_DB_VERSION, $strDbVersion);
$bSave = true;
@ -138,7 +167,12 @@ sub check
$self->save();
}
return $self->archiveId();
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strArchiveId', value => $self->archiveId()}
);
}
@ -151,8 +185,23 @@ sub archiveId
{
my $self = shift;
return $self->get(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_VERSION) . "-" .
$self->get(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_ID);
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_ARCHIVE_INFO_ARCHIVE_ID
);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strArchiveId', value => $self->get(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_VERSION) . "-" .
$self->get(INFO_ARCHIVE_SECTION_DB, INFO_ARCHIVE_KEY_DB_ID)}
);
}
1;

835
lib/BackRest/Backup.pm
View File

File diff suppressed because it is too large Load Diff

44
lib/BackRest/BackupCommon.pm
View File

@ -8,25 +8,43 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename;
use lib dirname($0);
use BackRest::Utility;
use BackRest::Common::Log;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_BACKUP_COMMON => 'BackupCommon';
use constant OP_BACKUP_COMMON_REG_EXP_GET => OP_BACKUP_COMMON . '::backupRegExpGet';
####################################################################################################################################
# backupRegExpGet - Generate a regexp depending on the backups that need to be found
####################################################################################################################################
our @EXPORT = qw(backupRegExpGet);
sub backupRegExpGet
{
my $bFull = shift;
my $bDifferential = shift;
my $bIncremental = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$bFull,
$bDifferential,
$bIncremental
) =
logDebugParam
(
OP_BACKUP_COMMON_REG_EXP_GET, \@_,
{name => 'bFull', default => false},
{name => 'bDifferential', default => false},
{name => 'bIncremental', default => false}
);
if (!$bFull && !$bDifferential && !$bIncremental)
{
confess &log(ERROR, 'one parameter must be true');
confess &log(ASSERT, 'one parameter must be true');
}
my $strDateTimeRegExp = "[0-9]{8}\\-[0-9]{6}";
@ -71,10 +89,14 @@ sub backupRegExpGet
$strRegExp .= "\$";
&log(DEBUG, "BackupCommon::backupRegExpGet:" .
" full = ${bFull}, differential = ${bDifferential}, incremental = ${bIncremental}: $strRegExp");
return $strRegExp;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strRegExp', value => $strRegExp}
);
}
push @EXPORT, qw(backupRegExpGet);
1;

124
lib/BackRest/BackupFile.pm
View File

@ -10,30 +10,58 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
use lib dirname($0);
use BackRest::Exception;
use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Common::String;
use BackRest::File;
use BackRest::Manifest;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_BACKUP_FILE => 'BackupFile';
use constant OP_BACKUP_FILE_BACKUP_FILE => OP_BACKUP_FILE . '::backupFile';
use constant OP_BACKUP_FILE_BACKUP_MANIFEST_UPDATE => OP_BACKUP_FILE . '::backupManifestUpdate';
####################################################################################################################################
# backupFile
####################################################################################################################################
sub backupFile
{
my $oFile = shift; # File object
my $strSourceFile = shift; # Source file to backup
my $strDestinationFile = shift; # Destination backup file
my $bDestinationCompress = shift; # Compress destination file
my $strChecksum = shift; # File checksum to be checked
my $lModificationTime = shift; # File modification time
my $lSizeFile = shift; # File size
my $lSizeTotal = shift; # Total size of the files to be copied
my $lSizeCurrent = shift; # Size of files copied so far
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile, # File object
$strSourceFile, # Source file to backup
$strDestinationFile, # Destination backup file
$bDestinationCompress, # Compress destination file
$strChecksum, # File checksum to be checked
$lModificationTime, # File modification time
$lSizeFile, # File size
$lSizeTotal, # Total size of the files to be copied
$lSizeCurrent, # Size of files copied so far
) =
logDebugParam
(
OP_BACKUP_FILE_BACKUP_FILE, \@_,
{name => 'oFile', trace => true},
{name => 'strSourceFile', trace => true},
{name => 'strDestinationFile', trace => true},
{name => 'bDestinationCompress', trace => true},
{name => 'strChecksum', required => false, trace => true},
{name => 'lModificationTime', trace => true},
{name => 'lSizeFile', trace => true},
{name => 'lSizeTotal', trace => true},
{name => 'lSizeCurrent', trace => true}
);
my $bCopyResult; # Copy result
my $bCopyResult = true; # Copy result
my $strCopyChecksum; # Copy checksum
my $lCopySize; # Copy Size
@ -45,7 +73,9 @@ sub backupFile
if (defined($strChecksum))
{
($strCopyChecksum, $lCopySize) = $oFile->hash_size(PATH_BACKUP_TMP, $strDestinationFile);
($strCopyChecksum, $lCopySize) =
$oFile->hashSize(PATH_BACKUP_TMP, $strDestinationFile .
($bDestinationCompress ? '.' . $oFile->{strCompressExtension} : ''), $bDestinationCompress);
$bCopy = !($strCopyChecksum eq $strChecksum && $lCopySize == $lSizeFile);
@ -75,35 +105,61 @@ sub backupFile
{
# If file is missing assume the database removed it (else corruption and nothing we can do!)
&log(INFO, "skip file removed by database: " . $strSourceFile);
return false, $lSizeCurrent, undef, undef;
}
}
# Ouput log
if ($bCopyResult)
{
&log(INFO, (defined($strChecksum) && !$bCopy ? 'checksum resumed file' : 'backup file') .
" $strSourceFile (" . file_size_format($lCopySize) .
" $strSourceFile (" . fileSizeFormat($lCopySize) .
($lSizeTotal > 0 ? ', ' . int($lSizeCurrent * 100 / $lSizeTotal) . '%' : '') . ')' .
($lCopySize != 0 ? " checksum ${strCopyChecksum}" : ''));
return true, $lSizeCurrent, $lCopySize, $strCopyChecksum;
}
our @EXPORT = qw(backupFile);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'bCopyResult', value => $bCopyResult, trace => true},
{name => 'lSizeCurrent', value => $lSizeCurrent, trace => true},
{name => 'lCopySize', value => $lCopySize, trace => true},
{name => 'strCopyChecksum', value => $strCopyChecksum, trace => true}
);
}
push @EXPORT, qw(backupFile);
####################################################################################################################################
# backupManifestUpdate
####################################################################################################################################
sub backupManifestUpdate
{
my $oManifest = shift;
my $strSection = shift;
my $strFile = shift;
my $bCopied = shift;
my $lSize = shift;
my $strChecksum = shift;
my $lManifestSaveSize = shift;
my $lManifestSaveCurrent = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oManifest,
$strSection,
$strFile,
$bCopied,
$lSize,
$strChecksum,
$lManifestSaveSize,
$lManifestSaveCurrent
) =
logDebugParam
(
OP_BACKUP_FILE_BACKUP_MANIFEST_UPDATE, \@_,
{name => 'oManifest', trace => true},
{name => 'strSection', trace => true},
{name => 'strFile', trace => true},
{name => 'bCopied', trace => true},
{name => 'lSize', required => false, trace => true},
{name => 'strChecksum', required => false, trace => true},
{name => 'lManifestSaveSize', trace => true},
{name => 'lManifestSaveCurrent', trace => true}
);
# If copy was successful store the checksum and size
if ($bCopied)
@ -121,7 +177,12 @@ sub backupManifestUpdate
if ($lManifestSaveCurrent >= $lManifestSaveSize)
{
$oManifest->save();
&log(DEBUG, 'manifest saved');
logDebugMisc
(
$strOperation, 'save manifest',
{name => 'lManifestSaveSize', value => $lManifestSaveSize},
{name => 'lManifestSaveCurrent', value => $lManifestSaveCurrent}
);
$lManifestSaveCurrent = 0;
}
@ -132,7 +193,12 @@ sub backupManifestUpdate
$oManifest->remove($strSection, $strFile);
}
return $lManifestSaveCurrent;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'lManifestSaveCurrent', value => $lManifestSaveCurrent, trace => true}
);
}
push @EXPORT, qw(backupManifestUpdate);

196
lib/BackRest/BackupInfo.pm
View File

@ -2,40 +2,43 @@
# BACKUP INFO MODULE
####################################################################################################################################
package BackRest::BackupInfo;
use parent 'BackRest::Ini';
use parent 'BackRest::Common::Ini';
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname basename);
use File::stat;
use lib dirname($0);
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::Exception;
use BackRest::File;
use BackRest::Ini;
use BackRest::Manifest;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_BACKUP_INFO => 'BackupInfo';
use constant OP_INFO_BACKUP_ADD => OP_BACKUP_INFO . "->add";
use constant OP_INFO_BACKUP_CHECK => OP_BACKUP_INFO . "->check";
use constant OP_INFO_BACKUP_DELETE => OP_BACKUP_INFO . "->delete";
use constant OP_INFO_BACKUP_NEW => OP_BACKUP_INFO . "->new";
use constant OP_INFO_BACKUP_BACKUP_ADD => OP_BACKUP_INFO . "->backupAdd";
use constant OP_INFO_BACKUP_BACKUP_REMOVE => OP_BACKUP_INFO . "->backupRemove";
####################################################################################################################################
# File/path constants
####################################################################################################################################
use constant FILE_BACKUP_INFO => 'backup.info'; our @EXPORT = qw(FILE_BACKUP_INFO);
use constant FILE_BACKUP_INFO => 'backup.info';
push @EXPORT, qw(FILE_BACKUP_INFO);
####################################################################################################################################
# Backup info Constants
# Backup info constants
####################################################################################################################################
use constant INFO_BACKUP_SECTION_BACKUP => MANIFEST_SECTION_BACKUP;
push @EXPORT, qw(INFO_BACKUP_SECTION_BACKUP);
@ -104,10 +107,19 @@ use constant INFO_BACKUP_KEY_VERSION => INI_KEY_VERSION;
####################################################################################################################################
sub new
{
my $class = shift; # Class name
my $strBackupClusterPath = shift; # Backup cluster path
my $class = shift;
&log(DEBUG, OP_INFO_BACKUP_NEW . ": backupClusterPath = ${strBackupClusterPath}");
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strBackupClusterPath # Backup cluster path
) =
logDebugParam
(
OP_INFO_BACKUP_NEW, \@_,
{name => 'strBackupClusterPath'}
);
# Build the backup info path/file name
my $strBackupInfoFile = "${strBackupClusterPath}/" . FILE_BACKUP_INFO;
@ -122,7 +134,12 @@ sub new
# Validate the backup info
$self->validate();
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
@ -134,15 +151,31 @@ sub validate
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
) =
logDebugParam
(
OP_INFO_BACKUP_NEW
);
# Remove backups that no longer exist on disk
foreach my $strBackup ($self->keys(INFO_BACKUP_SECTION_BACKUP_CURRENT))
{
if (!-e "$self->{strBackupClusterPath}/${strBackup}")
{
&log(WARN, "backup ${strBackup} is missing from the repository - removed from " . FILE_BACKUP_INFO);
$self->remove(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup);
$self->delete($strBackup);
}
}
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
####################################################################################################################################
@ -153,11 +186,22 @@ sub validate
sub check
{
my $self = shift;
my $oBackupManifest = shift;
my $iCatalogVersion = $oBackupManifest->getNumeric(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_CATALOG);
my $iControlVersion = $oBackupManifest->getNumeric(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_CONTROL);
my $ullDbSysId = $oBackupManifest->getNumeric(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_SYSTEM_ID);
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oBackupManifest
) =
logDebugParam
(
OP_INFO_BACKUP_CHECK, \@_,
{name => 'oBackupManifest', trace => true}
);
my $iCatalogVersion = $oBackupManifest->numericGet(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_CATALOG);
my $iControlVersion = $oBackupManifest->numericGet(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_CONTROL);
my $ullDbSysId = $oBackupManifest->numericGet(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_SYSTEM_ID);
my $strDbVersion = $oBackupManifest->get(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_DB_VERSION);
if (!$self->test(INFO_BACKUP_SECTION_DB))
@ -165,16 +209,16 @@ sub check
my $iHistoryId = 1;
# Fill db section
$self->setNumeric(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_CATALOG, undef, $iCatalogVersion);
$self->setNumeric(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_CONTROL, undef, $iControlVersion);
$self->setNumeric(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_SYSTEM_ID, undef, $ullDbSysId);
$self->numericSet(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_CATALOG, undef, $iCatalogVersion);
$self->numericSet(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_CONTROL, undef, $iControlVersion);
$self->numericSet(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_SYSTEM_ID, undef, $ullDbSysId);
$self->set(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_DB_VERSION, undef, $strDbVersion);
$self->setNumeric(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_HISTORY_ID, undef, $iHistoryId);
$self->numericSet(INFO_BACKUP_SECTION_DB, INFO_BACKUP_KEY_HISTORY_ID, undef, $iHistoryId);
# Fill db history
$self->setNumeric(INFO_BACKUP_SECTION_DB_HISTORY, $iHistoryId, INFO_BACKUP_KEY_CATALOG, $iCatalogVersion);
$self->setNumeric(INFO_BACKUP_SECTION_DB_HISTORY, $iHistoryId, INFO_BACKUP_KEY_CONTROL, $iControlVersion);
$self->setNumeric(INFO_BACKUP_SECTION_DB_HISTORY, $iHistoryId, INFO_BACKUP_KEY_SYSTEM_ID, $ullDbSysId);
$self->numericSet(INFO_BACKUP_SECTION_DB_HISTORY, $iHistoryId, INFO_BACKUP_KEY_CATALOG, $iCatalogVersion);
$self->numericSet(INFO_BACKUP_SECTION_DB_HISTORY, $iHistoryId, INFO_BACKUP_KEY_CONTROL, $iControlVersion);
$self->numericSet(INFO_BACKUP_SECTION_DB_HISTORY, $iHistoryId, INFO_BACKUP_KEY_SYSTEM_ID, $ullDbSysId);
$self->set(INFO_BACKUP_SECTION_DB_HISTORY, $iHistoryId, INFO_BACKUP_KEY_DB_VERSION, $strDbVersion);
}
else
@ -198,23 +242,40 @@ sub check
"\nHINT: this may be a symptom of database or repository corruption!", ERROR_BACKUP_MISMATCH);
}
}
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
####################################################################################################################################
# backupAdd
# add
#
# Add a backup to the info file.
####################################################################################################################################
sub backupAdd
sub add
{
my $self = shift;
my $oFile = shift;
my $oBackupManifest = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile,
$oBackupManifest
) =
logDebugParam
(
OP_INFO_BACKUP_ADD, \@_,
{name => 'oFile', trace => true},
{name => 'oBackupManifest', trace => true}
);
# !!! How best to log these follow-on cases?
my $strBackupLabel = $oBackupManifest->get(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_LABEL);
&log(DEBUG, OP_INFO_BACKUP_BACKUP_ADD . ": backupLabel = ${strBackupLabel}");
# Calculate backup sizes and references
my $lBackupSize = 0;
my $lBackupSizeDelta = 0;
@ -235,7 +296,7 @@ sub backupAdd
my $lFileSize = $oBackupManifest->get($strFileSection, $strFileKey, MANIFEST_SUBKEY_SIZE);
my $strFileReference = $oBackupManifest->get($strFileSection, $strFileKey, MANIFEST_SUBKEY_REFERENCE, false);
my $strFile = $oFile->path_get(PATH_BACKUP_CLUSTER,
my $strFile = $oFile->pathGet(PATH_BACKUP_CLUSTER,
(defined($strFileReference) ? "${strFileReference}" : $strBackupLabel) .
"/${strPath}/${strFileKey}" .
($bCompress ? '.' . $oFile->{strCompressExtension} : ''));
@ -262,7 +323,7 @@ sub backupAdd
}
# Add the manifest.backup size
my $strManifestFile = $oFile->path_get(PATH_BACKUP_CLUSTER, "/${strBackupLabel}/" . FILE_MANIFEST);
my $strManifestFile = $oFile->pathGet(PATH_BACKUP_CLUSTER, "/${strBackupLabel}/" . FILE_MANIFEST);
my $oStat = lstat($strManifestFile);
# Check for errors in stat
@ -273,33 +334,33 @@ sub backupAdd
$lBackupRepoSizeDelta += $oStat->size;
# Set backup size info
$self->setNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_BACKUP_SIZE, $lBackupSize);
$self->setNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_BACKUP_SIZE_DELTA, $lBackupSizeDelta);
$self->setNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_BACKUP_REPO_SIZE, $lBackupRepoSize);
$self->setNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_BACKUP_REPO_SIZE_DELTA,
$self->numericSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_BACKUP_SIZE, $lBackupSize);
$self->numericSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_BACKUP_SIZE_DELTA, $lBackupSizeDelta);
$self->numericSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_BACKUP_REPO_SIZE, $lBackupRepoSize);
$self->numericSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_BACKUP_REPO_SIZE_DELTA,
$lBackupRepoSizeDelta);
# Store information about the backup into the backup section
$self->setBool(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_ARCHIVE_CHECK,
$oBackupManifest->getBool(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_ARCHIVE_CHECK));
$self->setBool(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_ARCHIVE_COPY,
$oBackupManifest->getBool(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_ARCHIVE_COPY));
$self->boolSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_ARCHIVE_CHECK,
$oBackupManifest->boolGet(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_ARCHIVE_CHECK));
$self->boolSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_ARCHIVE_COPY,
$oBackupManifest->boolGet(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_ARCHIVE_COPY));
$self->set(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_ARCHIVE_START,
$oBackupManifest->get(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_ARCHIVE_START, undef, false));
$self->set(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_ARCHIVE_STOP,
$oBackupManifest->get(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_ARCHIVE_STOP, undef, false));
$self->setBool(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_COMPRESS,
$oBackupManifest->getBool(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_COMPRESS));
$self->setNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_FORMAT,
$oBackupManifest->getNumeric(INI_SECTION_BACKREST, INI_KEY_FORMAT));
$self->setBool(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_HARDLINK,
$oBackupManifest->getBool(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_HARDLINK));
$self->setBool(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_START_STOP,
$oBackupManifest->getBool(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_START_STOP));
$self->setNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_TIMESTAMP_START,
$oBackupManifest->getNumeric(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_TIMESTAMP_START));
$self->setNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_TIMESTAMP_STOP,
$oBackupManifest->getNumeric(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_TIMESTAMP_STOP));
$self->boolSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_COMPRESS,
$oBackupManifest->boolGet(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_COMPRESS));
$self->numericSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_FORMAT,
$oBackupManifest->numericGet(INI_SECTION_BACKREST, INI_KEY_FORMAT));
$self->boolSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_HARDLINK,
$oBackupManifest->boolGet(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_HARDLINK));
$self->boolSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_START_STOP,
$oBackupManifest->boolGet(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_START_STOP));
$self->numericSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_TIMESTAMP_START,
$oBackupManifest->numericGet(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_TIMESTAMP_START));
$self->numericSet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_TIMESTAMP_STOP,
$oBackupManifest->numericGet(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_TIMESTAMP_STOP));
$self->set(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_TYPE,
$oBackupManifest->get(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_TYPE));
$self->set(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel, INFO_BACKUP_KEY_VERSION,
@ -322,22 +383,43 @@ sub backupAdd
$self->get(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel));
$self->save();
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
####################################################################################################################################
# backupRemove
# Delete
#
# Remove a backup from the info file.
# Delete a backup from the info file.
####################################################################################################################################
sub backupRemove
sub delete
{
my $self = shift;
my $strBackupLabel = shift;
&log(DEBUG, OP_INFO_BACKUP_BACKUP_REMOVE . ": backupLabel = ${strBackupLabel}");
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strBackupLabel
) =
logDebugParam
(
OP_INFO_BACKUP_DELETE, \@_,
{name => 'strBackupLabel'}
);
$self->remove(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackupLabel);
$self->save();
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
1;

146
lib/BackRest/Common/Exception.pm Normal file
View File

@ -0,0 +1,146 @@
####################################################################################################################################
# COMMON EXCEPTION MODULE
####################################################################################################################################
package BackRest::Common::Exception;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess longmess);
use Exporter qw(import);
our @EXPORT = qw();
####################################################################################################################################
# Exception codes
####################################################################################################################################
use constant ERROR_ASSERT => 100;
push @EXPORT, qw(ERROR_ASSERT);
use constant ERROR_CHECKSUM => 101;
push @EXPORT, qw(ERROR_CHECKSUM);
use constant ERROR_CONFIG => 102;
push @EXPORT, qw(ERROR_CONFIG);
use constant ERROR_FILE_INVALID => 103;
push @EXPORT, qw(ERROR_FILE_INVALID);
use constant ERROR_FORMAT => 104;
push @EXPORT, qw(ERROR_FORMAT);
use constant ERROR_COMMAND_REQUIRED => 105;
push @EXPORT, qw(ERROR_COMMAND_REQUIRED);
use constant ERROR_OPTION_INVALID => 106;
push @EXPORT, qw(ERROR_OPTION_INVALID);
use constant ERROR_OPTION_INVALID_VALUE => 107;
push @EXPORT, qw(ERROR_OPTION_INVALID_VALUE);
use constant ERROR_OPTION_INVALID_RANGE => 108;
push @EXPORT, qw(ERROR_OPTION_INVALID_RANGE);
use constant ERROR_OPTION_INVALID_PAIR => 109;
push @EXPORT, qw(ERROR_OPTION_INVALID_PAIR);
use constant ERROR_OPTION_DUPLICATE_KEY => 110;
push @EXPORT, qw(ERROR_OPTION_DUPLICATE_KEY);
use constant ERROR_OPTION_NEGATE => 111;
push @EXPORT, qw(ERROR_OPTION_NEGATE);
use constant ERROR_OPTION_REQUIRED => 112;
push @EXPORT, qw(ERROR_OPTION_REQUIRED);
use constant ERROR_POSTMASTER_RUNNING => 113;
push @EXPORT, qw(ERROR_POSTMASTER_RUNNING);
use constant ERROR_PROTOCOL => 114;
push @EXPORT, qw(ERROR_PROTOCOL);
use constant ERROR_RESTORE_PATH_NOT_EMPTY => 115;
push @EXPORT, qw(ERROR_RESTORE_PATH_NOT_EMPTY);
use constant ERROR_FILE_OPEN => 116;
push @EXPORT, qw(ERROR_FILE_OPEN);
use constant ERROR_FILE_READ => 117;
push @EXPORT, qw(ERROR_FILE_READ);
use constant ERROR_PARAM_REQUIRED => 118;
push @EXPORT, qw(ERROR_PARAM_REQUIRED);
use constant ERROR_ARCHIVE_MISMATCH => 119;
push @EXPORT, qw(ERROR_ARCHIVE_MISMATCH);
use constant ERROR_ARCHIVE_DUPLICATE => 120;
push @EXPORT, qw(ERROR_ARCHIVE_DUPLICATE);
use constant ERROR_VERSION_NOT_SUPPORTED => 121;
push @EXPORT, qw(ERROR_VERSION_NOT_SUPPORTED);
use constant ERROR_PATH_CREATE => 122;
push @EXPORT, qw(ERROR_PATH_CREATE);
use constant ERROR_COMMAND_INVALID => 123;
push @EXPORT, qw(ERROR_COMMAND_INVALID);
use constant ERROR_HOST_CONNECT => 124;
push @EXPORT, qw(ERROR_HOST_CONNECT);
use constant ERROR_LOCK_ACQUIRE => 125;
push @EXPORT, qw(ERROR_LOCK_ACQUIRE);
use constant ERROR_BACKUP_MISMATCH => 126;
push @EXPORT, qw(ERROR_BACKUP_MISMATCH);
use constant ERROR_FILE_SYNC => 127;
push @EXPORT, qw(ERROR_FILE_SYNC);
use constant ERROR_PATH_OPEN => 128;
push @EXPORT, qw(ERROR_PATH_OPEN);
use constant ERROR_PATH_SYNC => 129;
push @EXPORT, qw(ERROR_PATH_SYNC);
use constant ERROR_FILE_MISSING => 130;
push @EXPORT, qw(ERROR_FILE_MISSING);
use constant ERROR_DB_CONNECT => 131;
push @EXPORT, qw(ERROR_DB_CONNECT);
use constant ERROR_DB_QUERY => 132;
push @EXPORT, qw(ERROR_DB_QUERY);
use constant ERROR_DB_MISMATCH => 133;
push @EXPORT, qw(ERROR_DB_MISMATCH);
use constant ERROR_DB_TIMEOUT => 134;
push @EXPORT, qw(ERROR_DB_TIMEOUT);
use constant ERROR_FILE_REMOVE => 135;
push @EXPORT, qw(ERROR_FILE_REMOVE);
use constant ERROR_PATH_REMOVE => 136;
push @EXPORT, qw(ERROR_PATH_REMOVE);
use constant ERROR_UNKNOWN => 199;
push @EXPORT, qw(ERROR_UNKNOWN);
####################################################################################################################################
# CONSTRUCTOR
####################################################################################################################################
sub new
{
my $class = shift; # Class name
my $iCode = shift; # Error code
my $strMessage = shift; # ErrorMessage
my $strTrace = shift; # Stack trace
# Create the class hash
my $self = {};
bless $self, $class;
# Initialize exception
$self->{iCode} = $iCode;
$self->{strMessage} = $strMessage;
$self->{strTrace} = $strTrace;
return $self;
}
####################################################################################################################################
# CODE
####################################################################################################################################
sub code
{
my $self = shift;
return $self->{iCode};
}
####################################################################################################################################
# MESSAGE
####################################################################################################################################
sub message
{
my $self = shift;
return $self->{strMessage};
}
####################################################################################################################################
# TRACE
####################################################################################################################################
sub trace
{
my $self = shift;
return $self->{strTrace};
}
1;

165
lib/BackRest/Ini.pm → lib/BackRest/Common/Ini.pm
View File

@ -1,13 +1,14 @@
####################################################################################################################################
# INI MODULE
# COMMON INI MODULE
####################################################################################################################################
package BackRest::Ini;
package BackRest::Common::Ini;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use Fcntl qw(:mode O_WRONLY O_CREAT O_TRUNC);
use File::Basename qw(dirname basename);
use IO::Handle;
@ -15,9 +16,10 @@ use JSON::PP;
use Storable qw(dclone);
use lib dirname($0);
use BackRest::Exception;
use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Common::String;
use BackRest::FileCommon;
use BackRest::Utility;
use BackRest::Version;
####################################################################################################################################
@ -31,7 +33,7 @@ use constant OP_INI_SET => OP_INI .
# Version and Format Constants
####################################################################################################################################
use constant BACKREST_VERSION => "$VERSION";
our @EXPORT = qw(BACKREST_VERSION);
push @EXPORT, qw(BACKREST_VERSION);
use constant BACKREST_FORMAT => "$FORMAT";
push @EXPORT, qw(BACKREST_FORMAT);
@ -100,13 +102,12 @@ sub new
if ($iFormat != BACKREST_FORMAT)
{
confess &log(ERROR, "format of ${strFileName} is ${iFormat} but " . BACKREST_FORMAT . ' is required by this ' .
' version of PgBackRest.', ERROR_FORMAT);
confess &log(ERROR, "format of ${strFileName} is ${iFormat} but " . BACKREST_FORMAT . ' is required', ERROR_FORMAT);
}
}
else
{
$self->setNumeric(INI_SECTION_BACKREST, INI_KEY_FORMAT, undef, BACKREST_FORMAT);
$self->numericSet(INI_SECTION_BACKREST, INI_KEY_FORMAT, undef, BACKREST_FORMAT);
$self->set(INI_SECTION_BACKREST, INI_KEY_VERSION, undef, BACKREST_VERSION);
}
@ -265,7 +266,7 @@ sub iniSave
}
# If the value is a hash then convert it to JSON, otherwise store as is
my $strValue = ${$oContent}{"${strSection}"}{"${strKey}"};
my $strValue = ${$oContent}{$strSection}{$strKey};
# If relaxed then store as old-style config
if ($bRelaxed)
@ -322,42 +323,6 @@ sub hash
return $strHash;
}
####################################################################################################################################
# getBool
#
# Get a numeric value.
####################################################################################################################################
sub getBool
{
my $self = shift;
my $strSection = shift;
my $strValue = shift;
my $strSubValue = shift;
my $bRequired = shift;
my $bDefault = shift;
return $self->get($strSection, $strValue, $strSubValue, $bRequired,
defined($bDefault) ? ($bDefault ? INI_TRUE : INI_FALSE) : undef) ? true : false;
}
####################################################################################################################################
# getNumeric
#
# Get a numeric value.
####################################################################################################################################
sub getNumeric
{
my $self = shift;
my $strSection = shift;
my $strValue = shift;
my $strSubValue = shift;
my $bRequired = shift;
my $nDefault = shift;
return $self->get($strSection, $strValue, $strSubValue, $bRequired,
defined($nDefault) ? $nDefault + 0 : undef) + 0;
}
####################################################################################################################################
# get
#
@ -425,35 +390,39 @@ sub get
}
####################################################################################################################################
# setBool
# boolGet
#
# Set a boolean value.
# Get a numeric value.
####################################################################################################################################
sub setBool
sub boolGet
{
my $self = shift;
my $strSection = shift;
my $strKey = shift;
my $strSubKey = shift;
my $bValue = shift;
my $strValue = shift;
my $strSubValue = shift;
my $bRequired = shift;
my $bDefault = shift;
$self->set($strSection, $strKey, $strSubKey, $bValue ? INI_TRUE : INI_FALSE);
return $self->get($strSection, $strValue, $strSubValue, $bRequired,
defined($bDefault) ? ($bDefault ? INI_TRUE : INI_FALSE) : undef) ? true : false;
}
####################################################################################################################################
# setNumeric
# numericGet
#
# Set a numeric value.
# Get a numeric value.
####################################################################################################################################
sub setNumeric
sub numericGet
{
my $self = shift;
my $strSection = shift;
my $strKey = shift;
my $strSubKey = shift;
my $nValue = shift;
my $strValue = shift;
my $strSubValue = shift;
my $bRequired = shift;
my $nDefault = shift;
$self->set($strSection, $strKey, $strSubKey, $nValue + 0);
return $self->get($strSection, $strValue, $strSubValue, $bRequired,
defined($nDefault) ? $nDefault + 0 : undef) + 0;
}
####################################################################################################################################
@ -482,21 +451,53 @@ sub set
}
####################################################################################################################################
# setComment
# boolSet
#
# Set a section comment.
# Set a boolean value.
####################################################################################################################################
sub setComment
sub boolSet
{
my $self = shift;
my $strSection = shift;
my $strComment = shift;
my $strKey = shift;
my $strSubKey = shift;
my $bValue = shift;
my $oContent = $self->{oContent};
${$oContent}{$strSection}{&INI_COMMENT} = $strComment;
$self->set($strSection, $strKey, $strSubKey, $bValue ? INI_TRUE : INI_FALSE);
}
####################################################################################################################################
# numericSet
#
# Set a numeric value.
####################################################################################################################################
sub numericSet
{
my $self = shift;
my $strSection = shift;
my $strKey = shift;
my $strSubKey = shift;
my $nValue = shift;
$self->set($strSection, $strKey, $strSubKey, $nValue + 0);
}
####################################################################################################################################
# commentSet
#
# Set a section comment.
####################################################################################################################################
# sub commentSet
# {
# my $self = shift;
# my $strSection = shift;
# my $strComment = shift;
#
# my $oContent = $self->{oContent};
#
# ${$oContent}{$strSection}{&INI_COMMENT} = $strComment;
# }
####################################################################################################################################
# remove
#
@ -547,22 +548,6 @@ sub keys
return sort(keys(%{$self->{oContent}}));
}
####################################################################################################################################
# testBool
#
# Test a value to see if it equals the supplied test boolean value. If no test value is given, tests that it is defined.
####################################################################################################################################
sub testBool
{
my $self = shift;
my $strSection = shift;
my $strValue = shift;
my $strSubValue = shift;
my $bTest = shift;
return $self->test($strSection, $strValue, $strSubValue, defined($bTest) ? ($bTest ? INI_TRUE : INI_FALSE) : undef);
}
####################################################################################################################################
# test
#
@ -591,4 +576,20 @@ sub test
return false;
}
####################################################################################################################################
# boolTest
#
# Test a value to see if it equals the supplied test boolean value. If no test value is given, tests that it is defined.
####################################################################################################################################
sub boolTest
{
my $self = shift;
my $strSection = shift;
my $strValue = shift;
my $strSubValue = shift;
my $bTest = shift;
return $self->test($strSection, $strValue, $strSubValue, defined($bTest) ? ($bTest ? INI_TRUE : INI_FALSE) : undef);
}
1;

20
lib/BackRest/Lock.pm → lib/BackRest/Common/Lock.pm
View File

@ -1,25 +1,21 @@
####################################################################################################################################
# LOCK MODULE
# COMMON LOCK MODULE
####################################################################################################################################
package BackRest::Lock;
package BackRest::Common::Lock;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use Fcntl qw(:DEFAULT :flock);
use File::Basename qw(dirname);
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::Exception;
use BackRest::Utility;
####################################################################################################################################
# Exported Functions
####################################################################################################################################
our @EXPORT = qw(lockAcquire lockRelease);
####################################################################################################################################
# Global lock type and handle
@ -74,7 +70,7 @@ sub lockAcquire
if (! -e lockPathName(optionGet(OPTION_REPO_PATH)))
{
mkdir (lockPathName(optionGet(OPTION_REPO_PATH)), 0770)
or confess(ERROR, 'unable to create lock path ' . lockPathName(optionGet(OPTION_REPO_PATH)), ERROR_PATH_CREATE);
or confess &log(ERROR, 'unable to create lock path ' . lockPathName(optionGet(OPTION_REPO_PATH)), ERROR_PATH_CREATE);
}
# Attempt to open the lock file
@ -103,6 +99,8 @@ sub lockAcquire
return true;
}
push @EXPORT, qw(lockAcquire);
####################################################################################################################################
# lockRelease
####################################################################################################################################
@ -131,4 +129,6 @@ sub lockRelease
undef($hCurrentLockHandle);
}
push @EXPORT, qw(lockRelease);
1;

667
lib/BackRest/Utility.pm → lib/BackRest/Common/Log.pm
View File

@ -1,59 +1,55 @@
####################################################################################################################################
# UTILITY MODULE
# COMMON LOG MODULE
####################################################################################################################################
package BackRest::Utility;
package BackRest::Common::Log;
use threads;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess longmess);
use Cwd qw(abs_path);
use Exporter qw(import);
our @EXPORT = qw();
use Fcntl qw(:DEFAULT :flock);
use File::Basename;
use File::Path qw(remove_tree);
use JSON::PP;
use POSIX qw(ceil);
use File::Basename qw(dirname);
use Scalar::Util qw(blessed reftype);
use Time::HiRes qw(gettimeofday usleep);
use lib dirname($0) . '/../lib';
use BackRest::Exception;
use BackRest::Common::Exception;
use BackRest::Common::String;
our @EXPORT = qw(version_get
data_hash_build trim common_prefix file_size_format execute
log log_file_set log_level_set test_set test_get test_check
hsleep wait_remainder
timestamp_string_get timestamp_file_string_get
TRACE DEBUG ERROR ASSERT WARN INFO OFF true false
TEST TEST_ENCLOSE TEST_MANIFEST_BUILD TEST_BACKUP_RESUME TEST_BACKUP_NORESUME);
####################################################################################################################################
# Boolean constants
####################################################################################################################################
use constant true => 1;
push @EXPORT, qw(true);
use constant false => 0;
push @EXPORT, qw(false);
# Global constants
use constant
{
true => 1,
false => 0
};
####################################################################################################################################
# Log level constants
####################################################################################################################################
use constant TRACE => 'TRACE';
push @EXPORT, qw(TRACE);
use constant DEBUG => 'DEBUG';
push @EXPORT, qw(DEBUG);
use constant INFO => 'INFO';
push @EXPORT, qw(INFO);
use constant WARN => 'WARN';
push @EXPORT, qw(WARN);
use constant ERROR => 'ERROR';
push @EXPORT, qw(ERROR);
use constant ASSERT => 'ASSERT';
push @EXPORT, qw(ASSERT);
use constant OFF => 'OFF';
push @EXPORT, qw(OFF);
use constant
{
TRACE => 'TRACE',
DEBUG => 'DEBUG',
INFO => 'INFO',
WARN => 'WARN',
ERROR => 'ERROR',
ASSERT => 'ASSERT',
OFF => 'OFF'
};
my $hLogFile;
my $strLogLevelFile = ERROR;
my $strLogLevelConsole = ERROR;
####################################################################################################################################
# Log levels ranked by severity
####################################################################################################################################
my %oLogLevelRank;
my $strLockPath;
my $hLockFile;
$oLogLevelRank{TRACE}{rank} = 6;
$oLogLevelRank{DEBUG}{rank} = 5;
$oLogLevelRank{INFO}{rank} = 4;
@ -63,185 +59,35 @@ $oLogLevelRank{ASSERT}{rank} = 1;
$oLogLevelRank{OFF}{rank} = 0;
####################################################################################################################################
# TEST Constants and Variables
# Module globals
####################################################################################################################################
use constant
{
TEST => 'TEST',
TEST_ENCLOSE => 'PgBaCkReStTeSt',
my $hLogFile;
my $strLogLevelFile = ERROR;
my $strLogLevelConsole = ERROR;
TEST_MANIFEST_BUILD => 'MANIFEST_BUILD',
TEST_BACKUP_RESUME => 'BACKUP_RESUME',
TEST_BACKUP_NORESUME => 'BACKUP_NORESUME',
};
# Test global variables
# Test globals
my $bTest = false;
my $fTestDelay;
####################################################################################################################################
# WAIT_REMAINDER - Wait the remainder of the current second
# Test constants
####################################################################################################################################
sub wait_remainder
{
my $lTimeBegin = gettimeofday();
my $lSleepMs = ceil(((int($lTimeBegin) + 1.05) - $lTimeBegin) * 1000);
use constant TEST => 'TEST';
push @EXPORT, qw(TEST);
use constant TEST_ENCLOSE => 'PgBaCkReStTeSt';
push @EXPORT, qw(TEST_ENCLOSE);
usleep($lSleepMs * 1000);
&log(TRACE, "WAIT_REMAINDER: slept ${lSleepMs}ms: begin ${lTimeBegin}, end " . gettimeofday());
return int($lTimeBegin);
}
use constant TEST_MANIFEST_BUILD => 'MANIFEST_BUILD';
push @EXPORT, qw(TEST_MANIFEST_BUILD);
use constant TEST_BACKUP_RESUME => 'BACKUP_RESUME';
push @EXPORT, qw(TEST_BACKUP_RESUME);
use constant TEST_BACKUP_NORESUME => 'BACKUP_NORESUME';
push @EXPORT, qw(TEST_BACKUP_NORESUME);
####################################################################################################################################
# DATA_HASH_BUILD - Hash a delimited file with header
# logFileSet - set the file messages will be logged to
####################################################################################################################################
sub data_hash_build
{
my $oHashRef = shift;
my $strData = shift;
my $strDelimiter = shift;
my $strUndefinedKey = shift;
my @stryFile = split("\n", $strData);
my @stryHeader = split($strDelimiter, $stryFile[0]);
for (my $iLineIdx = 1; $iLineIdx < scalar @stryFile; $iLineIdx++)
{
my @stryLine = split($strDelimiter, $stryFile[$iLineIdx]);
if (!defined($stryLine[0]) || $stryLine[0] eq '')
{
$stryLine[0] = $strUndefinedKey;
}
for (my $iColumnIdx = 1; $iColumnIdx < scalar @stryHeader; $iColumnIdx++)
{
if (defined(${$oHashRef}{"$stryHeader[0]"}{"$stryLine[0]"}{"$stryHeader[$iColumnIdx]"}))
{
confess 'the first column must be unique to build the hash';
}
if (defined($stryLine[$iColumnIdx]) && $stryLine[$iColumnIdx] ne '')
{
${$oHashRef}{"$stryHeader[0]"}{"$stryLine[0]"}{"$stryHeader[$iColumnIdx]"} = $stryLine[$iColumnIdx];
}
}
}
}
####################################################################################################################################
# TRIM - trim whitespace off strings
####################################################################################################################################
sub trim
{
my $strBuffer = shift;
if (!defined($strBuffer))
{
return undef;
}
$strBuffer =~ s/^\s+|\s+$//g;
return $strBuffer;
}
####################################################################################################################################
# hsleep - wrapper for usleep that takes seconds in fractions and returns time slept in ms
####################################################################################################################################
sub hsleep
{
my $fSecond = shift;
return usleep($fSecond * 1000000);
}
####################################################################################################################################
# COMMON_PREFIX
####################################################################################################################################
sub common_prefix
{
my $strString1 = shift;
my $strString2 = shift;
my $iCommonLen = 0;
my $iCompareLen = length($strString1) < length($strString2) ? length($strString1) : length($strString2);
for (my $iIndex = 0; $iIndex < $iCompareLen; $iIndex++)
{
if (substr($strString1, $iIndex, 1) ne substr($strString2, $iIndex, 1))
{
last;
}
$iCommonLen++;
}
return $iCommonLen;
}
####################################################################################################################################
# FILE_SIZE_FORMAT - Format file sizes in human-readable form
####################################################################################################################################
sub file_size_format
{
my $lFileSize = shift;
if ($lFileSize < 1024)
{
return $lFileSize . 'B';
}
if ($lFileSize < (1024 * 1024))
{
return (int($lFileSize / 102.4) / 10) . 'KB';
}
if ($lFileSize < (1024 * 1024 * 1024))
{
return (int($lFileSize / 1024 / 102.4) / 10) . 'MB';
}
return (int($lFileSize / 1024 / 1024 / 102.4) / 10) . 'GB';
}
####################################################################################################################################
# TIMESTAMP_STRING_GET - Get standard timestamp (or formatted as specified)
####################################################################################################################################
sub timestamp_string_get
{
my $strFormat = shift;
my $lTime = shift;
if (!defined($strFormat))
{
$strFormat = '%4d-%02d-%02d %02d:%02d:%02d';
}
if (!defined($lTime))
{
$lTime = time();
}
my ($iSecond, $iMinute, $iHour, $iMonthDay, $iMonth, $iYear, $iWeekDay, $iYearDay, $bIsDst) = localtime($lTime);
return sprintf($strFormat, $iYear + 1900, $iMonth + 1, $iMonthDay, $iHour, $iMinute, $iSecond);
}
####################################################################################################################################
# TIMESTAMP_FILE_STRING_GET - Get the date and time string formatted for filenames
####################################################################################################################################
sub timestamp_file_string_get
{
return timestamp_string_get('%4d%02d%02d-%02d%02d%02d');
}
####################################################################################################################################
# LOG_FILE_SET - set the file messages will be logged to
####################################################################################################################################
sub log_file_set
sub logFileSet
{
my $strFile = shift;
@ -251,7 +97,7 @@ sub log_file_set
or die "unable to create directory for log file ${strFile}";
}
$strFile .= '-' . timestamp_string_get('%4d%02d%02d') . '.log';
$strFile .= '-' . timestampFormat('%4d%02d%02d') . '.log';
my $bExists = false;
if (-e $strFile)
@ -270,43 +116,12 @@ sub log_file_set
syswrite($hLogFile, "-------------------PROCESS START-------------------\n");
}
####################################################################################################################################
# TEST_SET - set test parameters
####################################################################################################################################
sub test_set
{
my $bTestParam = shift;
my $fTestDelayParam = shift;
# Set defaults
$bTest = defined($bTestParam) ? $bTestParam : false;
$fTestDelay = defined($bTestParam) ? $fTestDelayParam : $fTestDelay;
# Make sure that a delay is specified in test mode
if ($bTest && !defined($fTestDelay))
{
confess &log(ASSERT, 'iTestDelay must be provided when bTest is true');
}
# Test delay should be between 1 and 600 seconds
if (!($fTestDelay >= 0 && $fTestDelay <= 600))
{
confess &log(ERROR, 'test-delay must be between 1 and 600 seconds');
}
}
push @EXPORT, qw(logFileSet);
####################################################################################################################################
# TEST_GET - are we in test mode?
# logLevelSet - set the log level for file and console
####################################################################################################################################
sub test_get
{
return $bTest;
}
####################################################################################################################################
# LOG_LEVEL_SET - set the log level for file and console
####################################################################################################################################
sub log_level_set
sub logLevelSet
{
my $strLevelFileParam = shift;
my $strLevelConsoleParam = shift;
@ -332,30 +147,178 @@ sub log_level_set
}
}
####################################################################################################################################
# TEST_CHECK - Check for a test message
####################################################################################################################################
sub test_check
{
my $strLog = shift;
my $strTest = shift;
push @EXPORT, qw(logLevelSet);
return index($strLog, TEST_ENCLOSE . '-' . $strTest . '-' . TEST_ENCLOSE) != -1;
####################################################################################################################################
# logDebugParam
#
# Log parameters passed to functions.
####################################################################################################################################
use constant DEBUG_PARAM => '()';
sub logDebugParam
{
my $strFunction = shift;
my $oyParamRef = shift;
return logDebugProcess($strFunction, DEBUG_PARAM, undef, $oyParamRef, @_);
}
push @EXPORT, qw(logDebugParam);
####################################################################################################################################
# logDebugReturn
#
# Log values returned from functions.
####################################################################################################################################
use constant DEBUG_RETURN => '=>';
sub logDebugReturn
{
my $strFunction = shift;
return logDebugProcess($strFunction, DEBUG_RETURN, undef, undef, @_);
}
push @EXPORT, qw(logDebugReturn);
####################################################################################################################################
# logDebugMisc
#
# Log misc values and details during execution.
####################################################################################################################################
use constant DEBUG_MISC => '';
sub logDebugMisc
{
my $strFunction = shift;
my $strDetail = shift;
return logDebugProcess($strFunction, DEBUG_MISC, $strDetail, undef, @_);
}
push @EXPORT, qw(logDebugMisc);
####################################################################################################################################
# logDebugProcess
####################################################################################################################################
sub logDebugProcess
{
my $strFunction = shift;
my $strType = shift;
my $strDetail = shift;
my $oyParamRef = shift;
my $iIndex = 0;
my $oParamHash = {};
my @oyResult;
my $bLogTrace = true;
if ($strType eq DEBUG_PARAM)
{
push @oyResult, $strFunction;
}
# Process each parameter hash
my $oParam = shift;
while (defined($oParam))
{
my $strParamName = $$oParam{name};
my $oValue;
# Push the return value into the return value array
if ($strType eq DEBUG_PARAM)
{
if (defined($$oyParamRef[$iIndex]))
{
push(@oyResult, $$oyParamRef[$iIndex]);
}
else
{
push(@oyResult, $${oParam}{default});
$$oParamHash{$strParamName}{default} = true;
}
$oValue = $oyResult[@oyResult - 1];
if (!defined($oValue) && (!defined($${oParam}{required}) || $${oParam}{required}))
{
confess &log(ASSERT, "${strParamName} is required in ${strFunction}");
}
}
else
{
if (ref($$oParam{value}) eq 'ARRAY')
{
if (defined($$oParam{ref}) && $$oParam{ref})
{
push(@oyResult, $$oParam{value});
}
else
{
push(@oyResult, @{$$oParam{value}});
}
}
else
{
push(@oyResult, $$oParam{value});
}
$oValue = $$oParam{value};
}
if (!defined($$oParam{log}) || $$oParam{log})
{
# If the parameter is a hash but not blessed then represent it as a string
# !!! This should go away once the inputs to logDebug can be changed
if (ref($oValue) eq 'HASH' && !blessed($oValue))
{
$$oParamHash{$strParamName}{value} = '[hash]';
}
# Else log the parameter value exactly
else
{
$$oParamHash{$strParamName}{value} = $oValue;
}
# There are certain return values that it's wasteful to generate debug logging for
if (!($strParamName eq 'self') &&
(!defined($$oParam{trace}) || !$$oParam{trace}))
{
$bLogTrace = false;
}
}
# Get the next parameter hash
$oParam = shift;
$iIndex++;
}
if (defined($strDetail) && $iIndex == 0)
{
$bLogTrace = false;
}
logDebugOut($strFunction, $strType, $strDetail, $oParamHash, $bLogTrace ? TRACE : DEBUG);
# If there are one or zero return values then just return a scalar (this will be undef if there are no return values)
if (@oyResult == 1)
{
return $oyResult[0];
}
# Else return an array containing return values
return @oyResult;
}
####################################################################################################################################
# logDebug
# logDebugOut
####################################################################################################################################
use constant DEBUG_CALL => '()';
push @EXPORT, qw(DEBUG_CALL);
use constant DEBUG_RESULT => '=>';
push @EXPORT, qw(DEBUG_RESULT);
use constant DEBUG_MISC => '';
push @EXPORT, qw(DEBUG_MISC);
use constant DEBUG_STRING_MAX_LEN => 1024;
sub logDebug
sub logDebugOut
{
my $strFunction = shift;
my $strType = shift;
@ -379,19 +342,55 @@ sub logDebug
$strParamSet .= ', ';
}
my $strValueRef = ref($$oParamHash{$strParam}) ? $$oParamHash{$strParam} : \$$oParamHash{$strParam};
my $strValueRef;
my $bDefault = false;
if (ref($$oParamHash{$strParam}) eq 'HASH')
{
if (blessed($$oParamHash{$strParam}{value}))
{
$strValueRef = \'[object]';
}
else
{
if (ref($$oParamHash{$strParam}{value}) eq 'ARRAY')
{
$strValueRef = \('(' . join(', ', @{$$oParamHash{$strParam}{value}}) . ')');
}
else
{
$strValueRef = ref($$oParamHash{$strParam}{value}) ? $$oParamHash{$strParam}{value} :
\$$oParamHash{$strParam}{value};
$bDefault = defined($$strValueRef) &&
defined($$oParamHash{$strParam}{default}) ? $$oParamHash{$strParam}{default} : false;
}
}
}
# If this is an ARRAY ref then create a comma-separated list
elsif (ref($$oParamHash{$strParam}) eq 'ARRAY')
{
$strValueRef = \(join(', ', @{$$oParamHash{$strParam}}));
}
# Else get a reference if a reference was not passed
else
{
$strValueRef = ref($$oParamHash{$strParam}) ? $$oParamHash{$strParam} : \$$oParamHash{$strParam};
}
$strParamSet .= "${strParam} = " .
($bDefault ? '<' : '') .
(defined($$strValueRef) ?
($strParam =~ /^is/ ? ($$strValueRef ? 'true' : 'false'):
($strParam =~ /^(b|is)/ ? ($$strValueRef ? 'true' : 'false'):
(length($$strValueRef) > DEBUG_STRING_MAX_LEN ?
substr($$strValueRef, 0, DEBUG_STRING_MAX_LEN) . ' ... [TRUNCATED]':
$$strValueRef)) : '[undef]');
substr($$strValueRef, 0, DEBUG_STRING_MAX_LEN) . ' ... <truncated>':
$$strValueRef)) : '[undef]') .
($bDefault ? '>' : '');
}
if (defined($strMessage))
{
$strMessage = "${strMessage}: ${strParamSet}";
$strMessage = $strMessage . (defined($strParamSet) ? ": ${strParamSet}" : '');
}
else
{
@ -403,24 +402,6 @@ sub logDebug
}
}
push @EXPORT, qw(logDebug);
sub logTrace
{
my $strFunction = shift;
my $strType = shift;
my $strMessage = shift;
my $oParamHash = shift;
if ($oLogLevelRank{&TRACE}{rank} <= $oLogLevelRank{$strLogLevelConsole}{rank} ||
$oLogLevelRank{&TRACE}{rank} <= $oLogLevelRank{$strLogLevelFile}{rank})
{
logDebug($strFunction, $strType, $strMessage, $oParamHash, TRACE);
}
}
push @EXPORT, qw(logTrace);
####################################################################################################################################
# LOG - log messages
####################################################################################################################################
@ -484,7 +465,7 @@ sub log
# Format the message text
my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime(time);
$strMessageFormat = timestamp_string_get() . sprintf('.%03d T%02d', (gettimeofday() - int(gettimeofday())) * 1000,
$strMessageFormat = timestampFormat() . sprintf('.%03d T%02d', (gettimeofday() - int(gettimeofday())) * 1000,
threads->tid()) .
(' ' x (7 - length($strLevel))) . "${strLevel}: ${strMessageFormat}\n";
@ -500,7 +481,7 @@ sub log
# If in test mode and this is a test messsage then delay so the calling process has time to read the message
if ($bTest && $strLevel eq TEST && $fTestDelay > 0)
{
hsleep($fTestDelay);
usleep($fTestDelay * 1000000);
}
}
@ -528,127 +509,55 @@ sub log
# Throw a typed exception if code is defined
if (defined($iCode))
{
return new BackRest::Exception($iCode, $strMessage, longmess());
return new BackRest::Common::Exception($iCode, $strMessage, longmess());
}
# Return the message test so it can be used in a confess
return $strMessage;
}
####################################################################################################################################
####################################################################################################################################
# Wait Functions
####################################################################################################################################
####################################################################################################################################
push @EXPORT, qw(waitInit waitMore waitInterval);
push @EXPORT, qw(log);
####################################################################################################################################
# waitInit
# testSet
#
# Set test parameters.
####################################################################################################################################
sub waitInit
sub testSet
{
my $fWaitTime = shift;
my $fSleep = shift;
my $bTestParam = shift;
my $fTestDelayParam = shift;
# Declare oWait hash
my $oWait = {};
# Set defaults
$bTest = defined($bTestParam) ? $bTestParam : false;
$fTestDelay = defined($bTestParam) ? $fTestDelayParam : $fTestDelay;
# If wait seconds is not defined or 0 then return undef
if (!defined($fWaitTime) || $fWaitTime == 0)
# Make sure that a delay is specified in test mode
if ($bTest && !defined($fTestDelay))
{
return undef;
confess &log(ASSERT, 'iTestDelay must be provided when bTest is true');
}
# Wait seconds can be a minimum of .1
if ($fWaitTime < .1)
# Test delay should be between 1 and 600 seconds
if (!($fTestDelay >= 0 && $fTestDelay <= 600))
{
confess &log(ASSERT, 'fWaitTime cannot be < .1');
}
# If fSleep is not defined set it
if (!defined($fSleep))
{
if ($fWaitTime >= 1)
{
$$oWait{sleep} = .1;
}
else
{
$$oWait{sleep} = $fWaitTime / 10;
}
}
# Else make sure it's not greater than fWaitTime
else
{
# Make sure fsleep is less than fWaitTime
if ($fSleep >= $fWaitTime)
{
confess &log(ASSERT, 'fSleep > fWaitTime - this is useless');
confess &log(ERROR, 'test-delay must be between 1 and 600 seconds');
}
}
# Set variables
$$oWait{wait_time} = $fWaitTime;
$$oWait{time_begin} = gettimeofday();
$$oWait{time_end} = $$oWait{time_begin};
return $oWait;
}
push @EXPORT, qw(testSet);
####################################################################################################################################
# waitMore
# testCheck - Check for a test message
####################################################################################################################################
sub waitMore
sub testCheck
{
my $oWait = shift;
my $strLog = shift;
my $strTest = shift;
# Return if oWait is not defined
if (!defined($oWait))
{
return false;
return index($strLog, TEST_ENCLOSE . '-' . $strTest . '-' . TEST_ENCLOSE) != -1;
}
# Sleep for fSleep time
hsleep($$oWait{sleep});
# Capture the end time
$$oWait{time_end} = gettimeofday();
# Exit if wait time has expired
if ((gettimeofday() - $$oWait{time_begin}) < $$oWait{wait_time})
{
return true;
}
# Else calculate the new sleep time
my $fSleepNext = $$oWait{sleep} + (defined($$oWait{sleep_prev}) ? $$oWait{sleep_prev} : 0);
if ($fSleepNext > $$oWait{wait_time} - ($$oWait{time_end} - $$oWait{time_begin}))
{
$fSleepNext = ($$oWait{wait_time} - ($$oWait{time_end} - $$oWait{time_begin})) + .001
}
$$oWait{sleep_prev} = $$oWait{sleep};
$$oWait{sleep} = $fSleepNext;
return false;
}
####################################################################################################################################
# waitInterval
####################################################################################################################################
sub waitInterval
{
my $oWait = shift;
# Error if oWait is not defined
if (!defined($oWait))
{
confess &log("fWaitTime was not defined in waitInit");
}
return int(($$oWait{time_end} - $$oWait{time_begin}) * 1000) / 1000;
}
push @EXPORT, qw(testCheck);
1;

190
lib/BackRest/Common/String.pm Normal file
View File

@ -0,0 +1,190 @@
####################################################################################################################################
# COMMON STRING MODULE
####################################################################################################################################
package BackRest::Common::String;
use threads;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess longmess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
####################################################################################################################################
# dataHashBuild
#
# Hash a delimited multi-line string with a header.
####################################################################################################################################
sub dataHashBuild
{
my $oHashRef = shift;
my $strData = shift;
my $strDelimiter = shift;
my $strUndefinedKey = shift;
my @stryFile = split("\n", $strData);
my @stryHeader = split($strDelimiter, $stryFile[0]);
for (my $iLineIdx = 1; $iLineIdx < scalar @stryFile; $iLineIdx++)
{
my @stryLine = split($strDelimiter, $stryFile[$iLineIdx]);
if (!defined($stryLine[0]) || $stryLine[0] eq '')
{
$stryLine[0] = $strUndefinedKey;
}
for (my $iColumnIdx = 1; $iColumnIdx < scalar @stryHeader; $iColumnIdx++)
{
if (defined(${$oHashRef}{"$stryHeader[0]"}{"$stryLine[0]"}{"$stryHeader[$iColumnIdx]"}))
{
confess 'the first column must be unique to build the hash';
}
if (defined($stryLine[$iColumnIdx]) && $stryLine[$iColumnIdx] ne '')
{
${$oHashRef}{"$stryHeader[0]"}{"$stryLine[0]"}{"$stryHeader[$iColumnIdx]"} = $stryLine[$iColumnIdx];
}
}
}
}
push @EXPORT, qw(dataHashBuild);
####################################################################################################################################
# trim
#
# Trim whitespace.
####################################################################################################################################
sub trim
{
my $strBuffer = shift;
if (!defined($strBuffer))
{
return undef;
}
$strBuffer =~ s/^\s+|\s+$//g;
return $strBuffer;
}
push @EXPORT, qw(trim);
####################################################################################################################################
# commonPrefix
#
# Determine how much of two strings is the same from the beginning.
####################################################################################################################################
sub commonPrefix
{
my $strString1 = shift;
my $strString2 = shift;
my $iCommonLen = 0;
my $iCompareLen = length($strString1) < length($strString2) ? length($strString1) : length($strString2);
for (my $iIndex = 0; $iIndex < $iCompareLen; $iIndex++)
{
if (substr($strString1, $iIndex, 1) ne substr($strString2, $iIndex, 1))
{
last;
}
$iCommonLen++;
}
return $iCommonLen;
}
push @EXPORT, qw(commonPrefix);
####################################################################################################################################
# boolFormat
#
# Outut boolean as true or false.
####################################################################################################################################
sub boolFormat
{
my $bValue;
if ($bValue)
{
return 'true';
}
return 'false';
}
push @EXPORT, qw(boolFormat);
####################################################################################################################################
# fileSizeFormat
#
# Format file sizes in human-readable form.
####################################################################################################################################
sub fileSizeFormat
{
my $lFileSize = shift;
if ($lFileSize < 1024)
{
return $lFileSize . 'B';
}
if ($lFileSize < (1024 * 1024))
{
return (int($lFileSize / 102.4) / 10) . 'KB';
}
if ($lFileSize < (1024 * 1024 * 1024))
{
return (int($lFileSize / 1024 / 102.4) / 10) . 'MB';
}
return (int($lFileSize / 1024 / 1024 / 102.4) / 10) . 'GB';
}
push @EXPORT, qw(fileSizeFormat);
####################################################################################################################################
# timestampFormat
#
# Get standard timestamp format (or formatted as specified).
####################################################################################################################################
sub timestampFormat
{
my $strFormat = shift;
my $lTime = shift;
if (!defined($strFormat))
{
$strFormat = '%4d-%02d-%02d %02d:%02d:%02d';
}
if (!defined($lTime))
{
$lTime = time();
}
my ($iSecond, $iMinute, $iHour, $iMonthDay, $iMonth, $iYear, $iWeekDay, $iYearDay, $bIsDst) = localtime($lTime);
return sprintf($strFormat, $iYear + 1900, $iMonth + 1, $iMonthDay, $iHour, $iMinute, $iSecond);
}
push @EXPORT, qw(timestampFormat);
####################################################################################################################################
# timestampFileFormat
####################################################################################################################################
sub timestampFileFormat
{
return timestampFormat('%4d%02d%02d-%02d%02d%02d');
}
push @EXPORT, qw(timestampFileFormat);
1;

163
lib/BackRest/Common/Wait.pm Normal file
View File

@ -0,0 +1,163 @@
####################################################################################################################################
# COMMON WAIT MODULE
####################################################################################################################################
package BackRest::Common::Wait;
use threads;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
use POSIX qw(ceil);
use Time::HiRes qw(gettimeofday usleep);
use lib dirname($0) . '/../lib';
use BackRest::Common::Log;
####################################################################################################################################
# waitRemainder
####################################################################################################################################
sub waitRemainder
{
my $lTimeBegin = gettimeofday();
my $lSleepMs = ceil(((int($lTimeBegin) + 1.05) - $lTimeBegin) * 1000);
usleep($lSleepMs * 1000);
&log(TRACE, "WAIT_REMAINDER: slept ${lSleepMs}ms: begin ${lTimeBegin}, end " . gettimeofday());
return int($lTimeBegin);
}
push @EXPORT, qw(waitRemainder);
####################################################################################################################################
# waitHiRes
####################################################################################################################################
sub waitHiRes
{
my $fSecond = shift;
return usleep($fSecond * 1000000);
}
push @EXPORT, qw(waitHiRes);
####################################################################################################################################
# waitInit
####################################################################################################################################
sub waitInit
{
my $fWaitTime = shift;
my $fSleep = shift;
# Declare oWait hash
my $oWait = {};
# If wait seconds is not defined or 0 then return undef
if (!defined($fWaitTime) || $fWaitTime == 0)
{
return undef;
}
# Wait seconds can be a minimum of .1
if ($fWaitTime < .1)
{
confess &log(ASSERT, 'fWaitTime cannot be < .1');
}
# If fSleep is not defined set it
if (!defined($fSleep))
{
if ($fWaitTime >= 1)
{
$$oWait{sleep} = .1;
}
else
{
$$oWait{sleep} = $fWaitTime / 10;
}
}
# Else make sure it's not greater than fWaitTime
else
{
# Make sure fsleep is less than fWaitTime
if ($fSleep >= $fWaitTime)
{
confess &log(ASSERT, 'fSleep > fWaitTime - this is useless');
}
}
# Set variables
$$oWait{wait_time} = $fWaitTime;
$$oWait{time_begin} = gettimeofday();
$$oWait{time_end} = $$oWait{time_begin};
return $oWait;
}
push @EXPORT, qw(waitInit);
####################################################################################################################################
# waitMore
####################################################################################################################################
sub waitMore
{
my $oWait = shift;
# Return if oWait is not defined
if (!defined($oWait))
{
return false;
}
# Sleep for fSleep time
waitHiRes($$oWait{sleep});
# Capture the end time
$$oWait{time_end} = gettimeofday();
# Exit if wait time has expired
if ((gettimeofday() - $$oWait{time_begin}) < $$oWait{wait_time})
{
return true;
}
# Else calculate the new sleep time
my $fSleepNext = $$oWait{sleep} + (defined($$oWait{sleep_prev}) ? $$oWait{sleep_prev} : 0);
if ($fSleepNext > $$oWait{wait_time} - ($$oWait{time_end} - $$oWait{time_begin}))
{
$fSleepNext = ($$oWait{wait_time} - ($$oWait{time_end} - $$oWait{time_begin})) + .001
}
$$oWait{sleep_prev} = $$oWait{sleep};
$$oWait{sleep} = $fSleepNext;
return false;
}
push @EXPORT, qw(waitMore);
####################################################################################################################################
# waitInterval
####################################################################################################################################
sub waitInterval
{
my $oWait = shift;
# Error if oWait is not defined
if (!defined($oWait))
{
confess &log(ERROR, "oWait is not defined");
}
return int(($$oWait{time_end} - $$oWait{time_begin}) * 1000) / 1000;
}
push @EXPORT, qw(waitInterval);
1;

1558
lib/BackRest/Config.pm
View File

File diff suppressed because it is too large Load Diff

291
lib/BackRest/Db.pm
View File

@ -15,10 +15,12 @@ use Fcntl qw(O_RDONLY);
use File::Basename qw(dirname);
use lib dirname($0);
use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Common::String;
use BackRest::Common::Wait;
use BackRest::Config;
use BackRest::Exception;
use BackRest::File;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
@ -28,12 +30,16 @@ use constant OP_DB => 'Db';
use constant OP_DB_NEW => OP_DB . "->new";
use constant OP_DB_BACKUP_START => OP_DB . "->backupStart";
use constant OP_DB_BACKUP_STOP => OP_DB . "->backupStop";
use constant OP_DB_DESTROY => OP_DB . "->DESTROY";
use constant OP_DB_EXECUTE_SQL => OP_DB . "->executeSql";
push @EXPORT, qw(OP_DB_EXECUTE_SQL);
use constant OP_DB_EXECUTE_SQL_ONE => OP_DB . "->executeSqlOne";
use constant OP_DB_EXECUTE_SQL_ROW => OP_DB . "->executeSqlRow";
use constant OP_DB_INFO => OP_DB . "->info";
push @EXPORT, qw(OP_DB_INFO);
use constant OP_DB_TABLESPACE_MAP_GET => OP_DB . "->tablespaceMapGet";
use constant OP_DB_VERSION_GET => OP_DB . "->versionGet";
use constant OP_DB_VERSION_SUPPORT => OP_DB . "->versionSupport";
####################################################################################################################################
# Postmaster process Id file
@ -58,7 +64,21 @@ sub new
my $self = {};
bless $self, $class;
return $self;
# Assign function parameters, defaults, and log debug info
(
my $strOperation
) =
logDebugParam
(
OP_DB_NEW
);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
@ -68,11 +88,27 @@ sub DESTROY
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_DB_DESTROY
);
if (defined($self->{hDb}))
{
$self->{hDb}->disconnect();
undef($self->{hDb});
}
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
####################################################################################################################################
@ -82,9 +118,24 @@ sub DESTROY
####################################################################################################################################
sub versionSupport
{
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_DB_VERSION_SUPPORT
);
my @strySupportVersion = ('8.3', '8.4', '9.0', '9.1', '9.2', '9.3', '9.4', '9.5');
return \@strySupportVersion;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strySupportVersion', value => \@strySupportVersion}
);
}
push @EXPORT, qw(versionSupport);
@ -95,10 +146,20 @@ push @EXPORT, qw(versionSupport);
sub executeSql
{
my $self = shift;
my $strSql = shift;
my $bIgnoreError = shift;
logDebug(OP_DB_EXECUTE_SQL, DEBUG_CALL, undef, {isRemote => optionRemoteTypeTest(DB), script => \$strSql});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strSql,
$bIgnoreError
) =
logDebugParam
(
OP_DB_EXECUTE_SQL, \@_,
{name => 'strSql'},
{name => 'bIgnoreError', default => false}
);
# Get the user-defined command for psql
my $strResult;
@ -110,11 +171,7 @@ sub executeSql
my %oParamHash;
$oParamHash{'script'} = $strSql;
if (defined($bIgnoreError) && $bIgnoreError)
{
$oParamHash{'ignore-error'} = true;
}
$oParamHash{'ignore-error'} = $bIgnoreError;
# Execute the command
$strResult = protocolGet()->cmdExecute(OP_DB_EXECUTE_SQL, \%oParamHash, true);
@ -138,7 +195,12 @@ sub executeSql
my $strDbUri = "dbi:Pg:dbname=${strDbName};port=" . optionGet(OPTION_DB_PORT) .
(optionTest(OPTION_DB_SOCKET_PATH) ? ';host=' . optionGet(OPTION_DB_SOCKET_PATH) : '');
logDebug(OP_DB_EXECUTE_SQL, DEBUG_MISC, 'db connect', {strDbUri => $strDbUri, strDbUser => $strDbUser});
logDebugMisc
(
$strOperation, 'db connect',
{name => 'strDbUri', value => $strDbUri},
{name => 'strDbUser', value => $strDbUser}
);
$self->{hDb} = DBI->connect($strDbUri, $strDbUser, undef, {AutoCommit => 1, RaiseError => 0, PrintError => 0});
@ -156,8 +218,7 @@ sub executeSql
$hStatement->execute();
# Wait for the query to return
my $iWaitSeconds = optionGet(OPTION_DB_TIMEOUT);
my $oExecuteWait = waitInit($iWaitSeconds);
my $oWait = waitInit(optionGet(OPTION_DB_TIMEOUT));
my $bTimeout = true;
do
@ -168,7 +229,7 @@ sub executeSql
if (!$hStatement->pg_result())
{
# Return if the error should be ignored
if (defined($bIgnoreError) && $bIgnoreError)
if ($bIgnoreError)
{
return '';
}
@ -195,19 +256,23 @@ sub executeSql
$bTimeout = false;
}
} while ($bTimeout && waitMore($oExecuteWait));
} while ($bTimeout && waitMore($oWait));
# If timeout then cancel the query and confess
if ($bTimeout)
{
$hStatement->pg_cancel();
confess &log(ERROR, "statement timed out after ${iWaitSeconds} second(s):\n${strSql}", ERROR_DB_TIMEOUT);
confess &log(ERROR, 'statement timed out after ' . waitInterval($oWait) .
" second(s):\n${strSql}", ERROR_DB_TIMEOUT);
}
}
logDebug(OP_DB_EXECUTE_SQL, DEBUG_RESULT, undef, {strResult => $strResult});
return $strResult;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strResult', value => $strResult}
);
}
####################################################################################################################################
@ -216,9 +281,28 @@ sub executeSql
sub executeSqlRow
{
my $self = shift;
my $strSql = shift;
return split("\t", trim($self->executeSql($strSql)));
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strSql
) =
logDebugParam
(
OP_DB_EXECUTE_SQL_ROW, \@_,
{name => 'strSql', trace => true}
);
# Return from function and log return values if any
my @stryResult = split("\t", trim($self->executeSql($strSql)));
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strResult', value => \@stryResult}
);
}
####################################################################################################################################
@ -227,9 +311,25 @@ sub executeSqlRow
sub executeSqlOne
{
my $self = shift;
my $strSql = shift;
return ($self->executeSqlRow($strSql))[0];
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strSql
) =
logDebugParam
(
OP_DB_EXECUTE_SQL_ONE, \@_,
{name => 'strSql', trace => true}
);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strResult', value => ($self->executeSqlRow($strSql))[0], trace => true}
);
}
####################################################################################################################################
@ -241,14 +341,25 @@ sub tablespaceMapGet
{
my $self = shift;
logTrace(OP_DB_TABLESPACE_MAP_GET, DEBUG_CALL);
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_DB_TABLESPACE_MAP_GET
);
my $oHashRef = {};
data_hash_build($oHashRef, "oid\tname\n" . $self->executeSql(
dataHashBuild(my $oTablespaceMapRef = {}, "oid\tname\n" . $self->executeSql(
'select oid, spcname from pg_tablespace'), "\t");
return $oHashRef;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'oTablespaceMapRef', value => $oTablespaceMapRef}
);
}
####################################################################################################################################
@ -257,10 +368,20 @@ sub tablespaceMapGet
sub info
{
my $self = shift;
my $oFile = shift;
my $strDbPath = shift;
logDebug(OP_DB_INFO, DEBUG_CALL, undef, {isRemote => $oFile->is_remote(PATH_DB_ABSOLUTE), dbPath => \$strDbPath});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile,
$strDbPath
) =
logDebugParam
(
OP_DB_INFO, \@_,
{name => 'oFile'},
{name => 'strDbPath'}
);
# Return data from the cache if it exists
if (defined($self->{info}{$strDbPath}))
@ -277,7 +398,7 @@ sub info
my $ullDbSysId;
my $fDbVersion;
if ($oFile->is_remote(PATH_DB_ABSOLUTE))
if ($oFile->isRemote(PATH_DB_ABSOLUTE))
{
# Build param hash
my %oParamHash;
@ -389,10 +510,15 @@ sub info
$self->{info}{$strDbPath}{iCatalogVersion} = $iCatalogVersion;
$self->{info}{$strDbPath}{ullDbSysId} = $ullDbSysId;
&log(DEBUG, OP_DB_INFO . "=>: dbVersion = ${fDbVersion}, controlVersion = ${iControlVersion}" .
", catalogVersion = ${iCatalogVersion}, dbSysId = ${ullDbSysId}");
return $fDbVersion, $iControlVersion, $iCatalogVersion, $ullDbSysId;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'fDbVersion', value => $fDbVersion},
{name => 'iControlVersion', value => $iControlVersion},
{name => 'iCatalogVersion', value => $iCatalogVersion},
{name => 'ullDbSysId', value => $ullDbSysId}
);
}
####################################################################################################################################
@ -402,27 +528,41 @@ sub versionGet
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_DB_VERSION_GET
);
# Get data from the cache if possible
if (defined($self->{fVersion}) && defined($self->{strDbPath}))
if (defined($self->{fDbVersion}) && defined($self->{strDbPath}))
{
return $self->{fVersion}, $self->{strDbPath};
return $self->{fDbVersion}, $self->{strDbPath};
}
# Get version and db-path from
($self->{fVersion}, $self->{strDbPath}) =
($self->{fDbVersion}, $self->{strDbPath}) =
$self->executeSqlRow("select (regexp_matches(split_part(version(), ' ', 2), '^[0-9]+\.[0-9]+'))[1], setting" .
" from pg_settings where name = 'data_directory'");
my $strVersionSupport = versionSupport();
my @stryVersionSupport = versionSupport();
if ($self->{fVersion} < ${$strVersionSupport}[0])
if ($self->{fDbVersion} < $stryVersionSupport[0])
{
confess &log(ERROR, "unsupported Postgres version ${$strVersionSupport}[0]", ERROR_VERSION_NOT_SUPPORTED);
confess &log(ERROR, 'unsupported Postgres version' . $self->{fDbVersion}, ERROR_VERSION_NOT_SUPPORTED);
}
logDebug(OP_DB_VERSION_GET, DEBUG_RESULT, {dbVersion => $self->{fVersion}});
return $self->{fVersion}, $self->{strDbPath};
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'fDbVersion', value => $self->{fDbVersion}},
{name => 'strDbPath', value => $self->{strDbPath}}
);
}
####################################################################################################################################
@ -431,12 +571,24 @@ sub versionGet
sub backupStart
{
my $self = shift;
my $oFile = shift;
my $strDbPath = shift;
my $strLabel = shift;
my $bStartFast = shift;
logDebug(OP_DB_BACKUP_START, DEBUG_CALL, undef, {dbPath => \$strDbPath, strLabel => \$strLabel, isStartFast => $bStartFast});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile,
$strDbPath,
$strLabel,
$bStartFast
) =
logDebugParam
(
OP_DB_BACKUP_START, \@_,
{name => 'oFile'},
{name => 'strDbPath'},
{name => 'strLabel'},
{name => 'bStartFast'}
);
# Get the version from the control file
my ($fDbVersion) = $self->info($oFile, $strDbPath);
@ -453,7 +605,7 @@ sub backupStart
}
# Only allow start-fast option for version >= 8.4
if ($self->{fVersion} < 8.4 && $bStartFast)
if ($self->{fDbVersion} < 8.4 && $bStartFast)
{
&log(WARN, OPTION_START_FAST . ' option is only available in PostgreSQL >= 8.4');
$bStartFast = false;
@ -469,7 +621,7 @@ sub backupStart
# Test if a backup is already running when version >= 9.3
if (optionGet(OPTION_STOP_AUTO))
{
if ($self->{fVersion} >= 9.3)
if ($self->{fDbVersion} >= 9.3)
{
if ($self->executeSqlOne('select pg_is_in_backup()'))
{
@ -484,7 +636,7 @@ sub backupStart
}
}
&log(INFO, "executing pg_start_backup() with label \"${strLabel}\": backup will begin after " .
&log(INFO, "execute pg_start_backup() with label \"${strLabel}\": backup begins after " .
($bStartFast ? "the requested immediate checkpoint" : "the next regular checkpoint") . " completes");
my ($strTimestampDbStart, $strArchiveStart) =
@ -492,7 +644,13 @@ sub backupStart
"pg_xlogfile_name(xlog) from pg_start_backup('${strLabel}'" .
($bStartFast ? ', true' : '') . ') as xlog');
return $strArchiveStart, $strTimestampDbStart;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strArchiveStart', value => $strArchiveStart},
{name => 'strTimestampDbStart', value => $strTimestampDbStart}
);
}
####################################################################################################################################
@ -502,14 +660,29 @@ sub backupStop
{
my $self = shift;
logDebug(OP_DB_BACKUP_STOP, DEBUG_CALL);
&log(INFO, 'executing pg_stop_backup() and waiting for all WAL segments to be archived');
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_DB_BACKUP_STOP
);
&log(INFO, 'execute pg_stop_backup() and wait for all WAL segments to archive');
my ($strTimestampDbStop, $strArchiveStop) =
$self->executeSqlRow("select to_char(clock_timestamp(), 'YYYY-MM-DD HH24:MI:SS.US TZ')," .
" pg_xlogfile_name(xlog) from pg_stop_backup() as xlog");
return $strArchiveStop, $strTimestampDbStop;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strArchiveStop', value => $strArchiveStop},
{name => 'strTimestampDbStop', value => $strTimestampDbStop}
);
}
1;

116
lib/BackRest/Exception.pm
View File

@ -1,116 +0,0 @@
####################################################################################################################################
# EXCEPTION MODULE
####################################################################################################################################
package BackRest::Exception;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess longmess);
use Exporter qw(import);
####################################################################################################################################
# Exception Codes
####################################################################################################################################
use constant
{
ERROR_ASSERT => 100,
ERROR_CHECKSUM => 101,
ERROR_CONFIG => 102,
ERROR_FILE_INVALID => 103,
ERROR_FORMAT => 104,
ERROR_COMMAND_REQUIRED => 105,
ERROR_OPTION_INVALID => 106,
ERROR_OPTION_INVALID_VALUE => 107,
ERROR_OPTION_INVALID_RANGE => 108,
ERROR_OPTION_INVALID_PAIR => 109,
ERROR_OPTION_DUPLICATE_KEY => 110,
ERROR_OPTION_NEGATE => 111,
ERROR_OPTION_REQUIRED => 112,
ERROR_POSTMASTER_RUNNING => 113,
ERROR_PROTOCOL => 114,
ERROR_RESTORE_PATH_NOT_EMPTY => 115,
ERROR_FILE_OPEN => 116,
ERROR_FILE_READ => 117,
ERROR_PARAM_REQUIRED => 118,
ERROR_ARCHIVE_MISMATCH => 119,
ERROR_ARCHIVE_DUPLICATE => 120,
ERROR_VERSION_NOT_SUPPORTED => 121,
ERROR_PATH_CREATE => 122,
ERROR_COMMAND_INVALID => 123,
ERROR_HOST_CONNECT => 124,
ERROR_LOCK_ACQUIRE => 125,
ERROR_BACKUP_MISMATCH => 126,
ERROR_FILE_SYNC => 127,
ERROR_PATH_OPEN => 128,
ERROR_PATH_SYNC => 129,
ERROR_FILE_MISSING => 130,
ERROR_DB_CONNECT => 131,
ERROR_DB_QUERY => 132,
ERROR_DB_MISMATCH => 133,
ERROR_DB_TIMEOUT => 134,
ERROR_UNKNOWN => 199
};
our @EXPORT = qw(ERROR_ASSERT ERROR_CHECKSUM ERROR_CONFIG ERROR_FILE_INVALID ERROR_FORMAT ERROR_COMMAND_REQUIRED
ERROR_OPTION_INVALID ERROR_OPTION_INVALID_VALUE ERROR_OPTION_INVALID_RANGE ERROR_OPTION_INVALID_PAIR
ERROR_OPTION_DUPLICATE_KEY ERROR_OPTION_NEGATE ERROR_OPTION_REQUIRED ERROR_POSTMASTER_RUNNING ERROR_PROTOCOL
ERROR_RESTORE_PATH_NOT_EMPTY ERROR_FILE_OPEN ERROR_FILE_READ ERROR_PARAM_REQUIRED ERROR_ARCHIVE_MISMATCH
ERROR_ARCHIVE_DUPLICATE ERROR_VERSION_NOT_SUPPORTED ERROR_PATH_CREATE ERROR_COMMAND_INVALID ERROR_HOST_CONNECT
ERROR_UNKNOWN ERROR_LOCK_ACQUIRE ERROR_BACKUP_MISMATCH ERROR_FILE_SYNC ERROR_PATH_OPEN ERROR_PATH_SYNC
ERROR_FILE_MISSING ERROR_DB_CONNECT ERROR_DB_QUERY ERROR_DB_MISMATCH ERROR_DB_TIMEOUT);
####################################################################################################################################
# CONSTRUCTOR
####################################################################################################################################
sub new
{
my $class = shift; # Class name
my $iCode = shift; # Error code
my $strMessage = shift; # ErrorMessage
my $strTrace = shift; # Stack trace
# Create the class hash
my $self = {};
bless $self, $class;
# Initialize exception
$self->{iCode} = $iCode;
$self->{strMessage} = $strMessage;
$self->{strTrace} = $strTrace;
return $self;
}
####################################################################################################################################
# CODE
####################################################################################################################################
sub code
{
my $self = shift;
return $self->{iCode};
}
####################################################################################################################################
# MESSAGE
####################################################################################################################################
sub message
{
my $self = shift;
return $self->{strMessage};
}
####################################################################################################################################
# TRACE
####################################################################################################################################
sub trace
{
my $self = shift;
return $self->{strTrace};
}
1;

286
lib/BackRest/Expire.pm Normal file
View File

@ -0,0 +1,286 @@
####################################################################################################################################
# EXPIRE MODULE
####################################################################################################################################
package BackRest::Expire;
use threads;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
use File::Basename qw(dirname);
use File::Path qw(remove_tree);
use Scalar::Util qw(looks_like_number);
use lib dirname($0);
use BackRest::Common::Log;
use BackRest::BackupCommon;
use BackRest::Config;
use BackRest::File;
use BackRest::Manifest;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_EXPIRE => 'Expire';
use constant OP_EXPIRE_NEW => OP_EXPIRE . '->new';
use constant OP_EXPIRE_PROCESS => OP_EXPIRE . '->process';
####################################################################################################################################
# new
####################################################################################################################################
sub new
{
my $class = shift;
# Create the class hash
my $self = {};
bless $self, $class;
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{oFile}
) =
logDebugParam
(
OP_EXPIRE_NEW, \@_,
{name => 'oFile'}
);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
# process
#
# Removes expired backups and archive logs from the backup directory. Partial backups are not counted for expiration, so if full
# or differential retention is set to 2, there must be three complete backups before the oldest one can be deleted.
####################################################################################################################################
sub process
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_EXPIRE_PROCESS
);
my $strPath;
my @stryPath;
my $oFile = $self->{oFile};
my $strBackupClusterPath = $oFile->pathGet(PATH_BACKUP_CLUSTER);
my $iFullRetention = optionGet(OPTION_RETENTION_FULL, false);
my $iDifferentialRetention = optionGet(OPTION_RETENTION_DIFF, false);
my $strArchiveRetentionType = optionGet(OPTION_RETENTION_ARCHIVE_TYPE, false);
my $iArchiveRetention = optionGet(OPTION_RETENTION_ARCHIVE, false);
# Load or build backup.info
my $oBackupInfo = new BackRest::BackupInfo($oFile->pathGet(PATH_BACKUP_CLUSTER));
# Find all the expired full backups
if (defined($iFullRetention))
{
# Make sure iFullRetention is valid
if (!looks_like_number($iFullRetention) || $iFullRetention < 1)
{
confess &log(ERROR, 'full_retention must be a number >= 1');
}
my $iIndex = $iFullRetention;
@stryPath = $oFile->list(PATH_BACKUP_CLUSTER, undef, backupRegExpGet(true), 'reverse');
while (defined($stryPath[$iIndex]))
{
# Delete all backups that depend on the full backup. Done in reverse order so that remaining backups will still
# be consistent if the process dies
foreach $strPath ($oFile->list(PATH_BACKUP_CLUSTER, undef, '^' . $stryPath[$iIndex] . '.*', 'reverse'))
{
system("rm -rf ${strBackupClusterPath}/${strPath}") == 0
or confess &log(ERROR, "unable to delete backup ${strPath}");
$oBackupInfo->delete($strPath);
}
&log(INFO, 'remove expired full backup: ' . $stryPath[$iIndex]);
$iIndex++;
}
}
# Find all the expired differential backups
if (defined($iDifferentialRetention))
{
# Make sure iDifferentialRetention is valid
if (!looks_like_number($iDifferentialRetention) || $iDifferentialRetention < 1)
{
confess &log(ERROR, 'differential_retention must be a number >= 1');
}
@stryPath = $oFile->list(PATH_BACKUP_CLUSTER, undef, backupRegExpGet(false, true), 'reverse');
if (defined($stryPath[$iDifferentialRetention - 1]))
{
logDebugMisc($strOperation, 'differential expiration based on ' . $stryPath[$iDifferentialRetention - 1]);
# Get a list of all differential and incremental backups
foreach $strPath ($oFile->list(PATH_BACKUP_CLUSTER, undef, backupRegExpGet(false, true, true), 'reverse'))
{
logDebugMisc($strOperation, "checking ${strPath} for differential expiration");
# Remove all differential and incremental backups before the oldest valid differential
if ($strPath lt $stryPath[$iDifferentialRetention - 1])
{
system("rm -rf ${strBackupClusterPath}/${strPath}") == 0
or confess &log(ERROR, "unable to delete backup ${strPath}");
$oBackupInfo->delete($strPath);
&log(INFO, "remove expired diff/incr backup ${strPath}");
}
}
}
}
# If no archive retention type is set then exit
if (!defined($strArchiveRetentionType))
{
&log(INFO, 'archive retention type not set - archive logs will not be expired');
}
else
{
# Determine which backup type to use for archive retention (full, differential, incremental)
if ($strArchiveRetentionType eq BACKUP_TYPE_FULL)
{
if (!defined($iArchiveRetention))
{
$iArchiveRetention = $iFullRetention;
}
@stryPath = $oFile->list(PATH_BACKUP_CLUSTER, undef, backupRegExpGet(true), 'reverse');
}
elsif ($strArchiveRetentionType eq BACKUP_TYPE_DIFF)
{
if (!defined($iArchiveRetention))
{
$iArchiveRetention = $iDifferentialRetention;
}
@stryPath = $oFile->list(PATH_BACKUP_CLUSTER, undef, backupRegExpGet(true, true), 'reverse');
}
elsif ($strArchiveRetentionType eq BACKUP_TYPE_INCR)
{
@stryPath = $oFile->list(PATH_BACKUP_CLUSTER, undef, backupRegExpGet(true, true, true), 'reverse');
}
else
{
confess &log(ERROR, "unknown archive_retention_type '$strArchiveRetentionType'");
}
# Make sure that iArchiveRetention is set and valid
if (!defined($iArchiveRetention))
{
confess &log(ERROR, 'archive_retention must be set if archive_retention_type is set');
}
if (!looks_like_number($iArchiveRetention) || $iArchiveRetention < 1)
{
confess &log(ERROR, 'archive_retention must be a number >= 1');
}
# if no backups were found then preserve current archive logs - too scary to delete them!
my $iBackupTotal = scalar @stryPath;
if ($iBackupTotal > 0)
{
# See if enough backups exist for expiration to start
my $strArchiveRetentionBackup = $stryPath[$iArchiveRetention - 1];
if (!defined($strArchiveRetentionBackup))
{
if ($strArchiveRetentionType eq BACKUP_TYPE_FULL && scalar @stryPath > 0)
{
&log(INFO, 'fewer than required backups for retention, ' .
'but since archive_retention_type = full using oldest full backup');
$strArchiveRetentionBackup = $stryPath[scalar @stryPath - 1];
}
}
if (defined($strArchiveRetentionBackup))
{
# Get the archive logs that need to be kept. To be cautious we will keep all the archive logs starting from this
# backup even though they are also in the pg_xlog directory (since they have been copied more than once).
&log(INFO, 'archive retention based on backup ' . $strArchiveRetentionBackup);
my $oManifest = new BackRest::Manifest($oFile->pathGet(PATH_BACKUP_CLUSTER) .
"/${strArchiveRetentionBackup}/backup.manifest");
my $strArchiveLast = $oManifest->get(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_ARCHIVE_START);
if (!defined($strArchiveLast))
{
confess &log(ERROR, "invalid archive location retrieved ${strArchiveRetentionBackup}");
}
&log(INFO, 'archive retention starts at ' . $strArchiveLast);
# Get archive info
my $oArchive = new BackRest::Archive();
my $strArchiveId = $oArchive->getCheck($oFile);
# Remove any archive directories or files that are out of date
foreach $strPath ($oFile->list(PATH_BACKUP_ARCHIVE, $strArchiveId, "^[0-F]{16}\$"))
{
logDebugMisc($strOperation, "found major archive path: ${strPath}");
# If less than first 16 characters of current archive file, then remove the directory
if ($strPath lt substr($strArchiveLast, 0, 16))
{
my $strFullPath = $oFile->pathGet(PATH_BACKUP_ARCHIVE, $strArchiveId) . "/${strPath}";
remove_tree($strFullPath) > 0 or confess &log(ERROR, "unable to remove ${strFullPath}");
logDebugMisc($strOperation, "remove major archive path: ${strFullPath}");
}
# If equals the first 16 characters of the current archive file, then delete individual files instead
elsif ($strPath eq substr($strArchiveLast, 0, 16))
{
my $strSubPath;
# Look for archive files in the archive directory
foreach $strSubPath ($oFile->list(PATH_BACKUP_ARCHIVE, "${strArchiveId}/${strPath}", "^[0-F]{24}.*\$"))
{
# Delete if the first 24 characters less than the current archive file
if ($strSubPath lt substr($strArchiveLast, 0, 24))
{
unlink($oFile->pathGet(PATH_BACKUP_ARCHIVE, "${strArchiveId}/${strSubPath}"))
or confess &log(ERROR, 'unable to remove ' . $strSubPath);
logDebugMisc($strOperation, "remove expired archive file: ${strSubPath}");
}
}
}
}
}
}
}
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
1;

1154
lib/BackRest/File.pm
View File

File diff suppressed because it is too large Load Diff

27
lib/BackRest/FileCommon.pm
View File

@ -8,12 +8,13 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
use IO::Handle;
use lib dirname($0) . '/../lib';
use BackRest::Exception;
use BackRest::Utility;
use BackRest::Common::Exception;
use BackRest::Common::Log;
####################################################################################################################################
# Operation constants
@ -29,9 +30,17 @@ use constant OP_FILE_COMMON_PATH_SYNC => OP_FILE_COM
####################################################################################################################################
sub filePathSync
{
my $strPath = shift;
logTrace(OP_FILE_COMMON_PATH_SYNC, DEBUG_CALL, undef, {path => \$strPath});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strPath
) =
logDebugParam
(
OP_FILE_COMMON_PATH_SYNC, \@_,
{name => 'strPath', trace => true}
);
open(my $hPath, "<", $strPath)
or confess &log(ERROR, "unable to open ${strPath}", ERROR_PATH_OPEN);
@ -40,8 +49,14 @@ sub filePathSync
$hPathDup->sync
or confess &log(ERROR, "unable to sync ${strPath}", ERROR_PATH_SYNC);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
our @EXPORT = qw(filePathSync);
push @EXPORT, qw(filePathSync);
1;

149
lib/BackRest/Info.pm
View File

@ -8,22 +8,27 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
use lib dirname($0);
use BackRest::Common::Log;
use BackRest::Common::Ini;
use BackRest::Common::String;
use BackRest::BackupCommon;
use BackRest::BackupInfo;
use BackRest::Config;
use BackRest::File;
use BackRest::Ini;
use BackRest::Manifest;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_INFO_LIST_STANZA => 'Info->listStanza';
our @EXPORT = qw(OP_INFO_LIST_STANZA);
use constant OP_INFO_BACKUP_LIST => 'Info->backupList';
use constant OP_INFO_NEW => 'Info->new';
use constant OP_INFO_PROCESS => 'Info->process';
use constant OP_INFO_STANZA_LIST => 'Info->stanzaList';
push @EXPORT, qw(OP_INFO_STANZA_LIST);
####################################################################################################################################
# Info constants
@ -75,19 +80,42 @@ sub new
my $self = {};
bless $self, $class;
# Set variables
$self->{oFile} = $oFile;
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{oFile}
) =
logDebugParam
(
OP_INFO_NEW, \@_,
{name => 'oFile', required => false, trace => true}
);
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
# info
# process
####################################################################################################################################
sub info
sub process
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_INFO_PROCESS
);
# Get stanza if specified
my $strStanza = optionTest(OPTION_STANZA) ? optionGet(OPTION_STANZA) : undef;
@ -101,13 +129,13 @@ sub info
);
# Get the stanza list with all info
my $oStanzaList = $self->listStanza($oFile, $strStanza);
my $oyStanzaList = $self->stanzaList($oFile, $strStanza);
if (optionTest(OPTION_OUTPUT, INFO_OUTPUT_TEXT))
{
my $strOutput;
foreach my $oStanzaInfo (@{$oStanzaList})
foreach my $oStanzaInfo (@{$oyStanzaList})
{
$strOutput = defined($strOutput) ? $strOutput .= "\n" : '';
@ -121,13 +149,13 @@ sub info
$strOutput .= ' oldest backup label: ' . $$oOldestBackup{&INFO_KEY_LABEL} . "\n";
$strOutput .= ' oldest backup timestamp: ' .
timestamp_string_get(undef, $$oOldestBackup{&INFO_SECTION_TIMESTAMP}{&INFO_KEY_START}) . "\n";
timestampFormat(undef, $$oOldestBackup{&INFO_SECTION_TIMESTAMP}{&INFO_KEY_START}) . "\n";
my $oLatestBackup = $$oStanzaInfo{&INFO_BACKUP_SECTION_BACKUP}[@{$$oStanzaInfo{&INFO_BACKUP_SECTION_BACKUP}} - 1];
$strOutput .= ' latest backup label: ' . $$oLatestBackup{&INFO_KEY_LABEL} . "\n";
$strOutput .= ' latest backup timestamp: ' .
timestamp_string_get(undef, $$oLatestBackup{&INFO_SECTION_TIMESTAMP}{&INFO_KEY_START}) . "\n";
timestampFormat(undef, $$oLatestBackup{&INFO_SECTION_TIMESTAMP}{&INFO_KEY_START}) . "\n";
}
}
@ -136,7 +164,7 @@ sub info
elsif (optionTest(OPTION_OUTPUT, INFO_OUTPUT_JSON))
{
my $oJSON = JSON::PP->new()->canonical()->pretty()->indent_length(4);
my $strJSON = $oJSON->encode($oStanzaList);
my $strJSON = $oJSON->encode($oyStanzaList);
syswrite(*STDOUT, $strJSON);
@ -152,24 +180,38 @@ sub info
confess &log(ASSERT, "invalid info output option '" . optionGet(OPTION_OUTPUT) . "'");
}
return 0;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'iResult', value => 0, trace => true}
);
}
####################################################################################################################################
# listStanza
# stanzaList
####################################################################################################################################
sub listStanza
sub stanzaList
{
my $self = shift;
my $oFile = shift;
my $strStanza = shift;
# Set operation and debug strings
my $strOperation = OP_INFO_LIST_STANZA;
&log(DEBUG, "${strOperation}". (defined($strStanza) ? ": stanza = ${strStanza}" : ''));
my @oStanzaList;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile,
$strStanza
) =
logDebugParam
(
OP_INFO_STANZA_LIST, \@_,
{name => 'oFile'},
{name => 'strStanza', required => false}
);
if ($oFile->is_remote(PATH_BACKUP))
my @oyStanzaList;
if ($oFile->isRemote(PATH_BACKUP))
{
# Build param hash
my $oParamHash = undef;
@ -180,13 +222,13 @@ sub listStanza
}
# Trace the remote parameters
&log(TRACE, "${strOperation}: remote (" . $oFile->{oProtocol}->commandParamString($oParamHash) . ')');
&log(TRACE, OP_INFO_STANZA_LIST . ": remote (" . $oFile->{oProtocol}->commandParamString($oParamHash) . ')');
# Execute the command
my $strStanzaList = $oFile->{oProtocol}->cmdExecute($strOperation, $oParamHash, true);
my $strStanzaList = $oFile->{oProtocol}->cmdExecute(OP_INFO_STANZA_LIST, $oParamHash, true);
# Trace the remote response
&log(TRACE, "${strOperation}: remote json response (${strStanzaList})");
&log(TRACE, OP_INFO_STANZA_LIST . ": remote json response (${strStanzaList})");
my $oJSON = JSON::PP->new();
return $oJSON->decode($strStanzaList);
@ -205,7 +247,7 @@ sub listStanza
my $oStanzaInfo = {};
$$oStanzaInfo{&INFO_STANZA_NAME} = $strStanzaFound;
($$oStanzaInfo{&INFO_BACKUP_SECTION_BACKUP}, $$oStanzaInfo{&INFO_BACKUP_SECTION_DB}) =
$self->listBackup($oFile, $strStanzaFound);
$self->backupList($oFile, $strStanzaFound);
if (@{$$oStanzaInfo{&INFO_BACKUP_SECTION_BACKUP}} == 0)
{
@ -224,10 +266,10 @@ sub listStanza
};
}
push @oStanzaList, $oStanzaInfo;
push @oyStanzaList, $oStanzaInfo;
}
if (defined($strStanza) && @oStanzaList == 0)
if (defined($strStanza) && @oyStanzaList == 0)
{
my $oStanzaInfo = {};
@ -242,24 +284,41 @@ sub listStanza
$$oStanzaInfo{&INFO_BACKUP_SECTION_BACKUP} = [];
$$oStanzaInfo{&INFO_BACKUP_SECTION_DB} = [];
push @oStanzaList, $oStanzaInfo;
push @oyStanzaList, $oStanzaInfo;
}
}
return \@oStanzaList;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'oyStanzaList', value => \@oyStanzaList, log => false, ref => true}
);
}
####################################################################################################################################
# listBackup
# backupList
###################################################################################################################################
sub listBackup
sub backupList
{
my $self = shift;
my $oFile = shift;
my $strStanza = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile,
$strStanza
) =
logDebugParam
(
OP_INFO_BACKUP_LIST, \@_,
{name => 'oFile'},
{name => 'strStanza'}
);
# Load or build backup.info
my $oBackupInfo = new BackRest::BackupInfo($oFile->path_get(PATH_BACKUP, CMD_BACKUP . "/${strStanza}"));
my $oBackupInfo = new BackRest::BackupInfo($oFile->pathGet(PATH_BACKUP, CMD_BACKUP . "/${strStanza}"));
# Build the db list
my @oyDbList;
@ -295,14 +354,14 @@ sub listBackup
&INFO_SECTION_BACKREST =>
{
&INFO_KEY_FORMAT =>
$oBackupInfo->getNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INI_KEY_FORMAT),
$oBackupInfo->numericGet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INI_KEY_FORMAT),
&INFO_KEY_VERSION =>
$oBackupInfo->get(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INI_KEY_VERSION)
},
&INFO_SECTION_DB =>
{
&INFO_KEY_ID =>
$oBackupInfo->getNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INFO_BACKUP_KEY_HISTORY_ID)
$oBackupInfo->numericGet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INFO_BACKUP_KEY_HISTORY_ID)
},
&INFO_SECTION_INFO =>
{
@ -321,9 +380,9 @@ sub listBackup
&INFO_SECTION_TIMESTAMP =>
{
&INFO_KEY_START =>
$oBackupInfo->getNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INFO_BACKUP_KEY_TIMESTAMP_START),
$oBackupInfo->numericGet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INFO_BACKUP_KEY_TIMESTAMP_START),
&INFO_KEY_STOP =>
$oBackupInfo->getNumeric(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INFO_BACKUP_KEY_TIMESTAMP_STOP),
$oBackupInfo->numericGet(INFO_BACKUP_SECTION_BACKUP_CURRENT, $strBackup, INFO_BACKUP_KEY_TIMESTAMP_STOP),
},
&INFO_KEY_LABEL => $strBackup,
&INFO_KEY_PRIOR =>
@ -337,7 +396,13 @@ sub listBackup
push(@oyBackupList, $oBackupHash);
}
return \@oyBackupList, \@oyDbList;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'oyBackupList', value => \@oyBackupList, log => false, ref => true},
{name => 'oyDbList', value => \@oyDbList, log => false, ref => true}
);
}
1;

109
lib/BackRest/Manifest.pm
View File

@ -2,30 +2,32 @@
# MANIFEST MODULE
####################################################################################################################################
package BackRest::Manifest;
use parent 'BackRest::Ini';
use parent 'BackRest::Common::Ini';
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname basename);
use Digest::SHA;
use Time::Local qw(timelocal);
use lib dirname($0);
use BackRest::Exception qw(ERROR_CHECKSUM ERROR_FORMAT);
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::File;
use BackRest::Ini;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_MANIFEST => 'Manifest';
our @EXPORT = qw(OP_MANIFEST);
use constant OP_MANIFEST_BUILD => OP_MANIFEST . '->build';
use constant OP_MANIFEST_NEW => OP_MANIFEST . '->new';
use constant OP_MANIFEST_SAVE => OP_MANIFEST . '->save';
push @EXPORT, qw(OP_MANIFEST_SAVE);
####################################################################################################################################
# File/path constants
@ -133,9 +135,21 @@ use constant MANIFEST_SUBKEY_USER => 'user';
####################################################################################################################################
sub new
{
my $class = shift; # Class name
my $strFileName = shift; # Manifest filename
my $bLoad = shift; # Load the manifest?
my $class = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strFileName, # Manifest filename
$bLoad # Load the manifest?
) =
logDebugParam
(
OP_MANIFEST_NEW, \@_,
{name => 'strFileName', trace => true},
{name => 'bLoad', required => false, trace => true}
);
# Set defaults
$bLoad = defined($bLoad) ? $bLoad : true;
@ -143,7 +157,12 @@ sub new
# Init object and store variables
my $self = $class->SUPER::new($strFileName, $bLoad);
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
@ -155,8 +174,18 @@ sub save
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
) =
logDebugParam
(
OP_MANIFEST_SAVE
);
# !!! Add section comments here
# $self->setComment(MANIFEST_SECTION_BACKUP_INFO,
# $self->commentSet(MANIFEST_SECTION_BACKUP_INFO,
# #################################################################################
# "Information about the backup:\n" .
# " backup-size = total size of original files.\n" .
@ -166,14 +195,20 @@ sub save
# " unless option-start-stop = true.\n" .
# "\n" .
# "Human-readable output:\n" .
# " backup-repo-size = " . file_size_format($lBackupRepoSize) . "\n" .
# " backup-repo-size-delta = " . file_size_format($lBackupRepoSizeDelta) . "\n" .
# " backup-size = " . file_size_format($lBackupSize) . "\n" .
# " backup-size-delta = " . file_size_format($lBackupSizeDelta)
# " backup-repo-size = " . fileSizeFormat($lBackupRepoSize) . "\n" .
# " backup-repo-size-delta = " . fileSizeFormat($lBackupRepoSizeDelta) . "\n" .
# " backup-size = " . fileSizeFormat($lBackupSize) . "\n" .
# " backup-size-delta = " . fileSizeFormat($lBackupSizeDelta)
# );
# Call inherited save
$self->SUPER::save();
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
####################################################################################################################################
@ -349,14 +384,28 @@ sub valid
sub build
{
my $self = shift;
my $oFile = shift;
my $strDbClusterPath = shift;
my $oLastManifest = shift;
my $bNoStartStop = shift;
my $oTablespaceMapRef = shift;
my $strLevel = shift;
&log(DEBUG, 'Manifest->build');
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oFile,
$strDbClusterPath,
$oLastManifest,
$bNoStartStop,
$oTablespaceMapRef,
$strLevel
) =
logDebugParam
(
OP_MANIFEST_BUILD, \@_,
{name => 'oFile'},
{name => 'strDbClusterPath'},
{name => 'oLastManifest', required => false},
{name => 'bNoStartStop'},
{name => 'oTablespaceMapRef', required => false},
{name => 'strLevel', required => false}
);
# If no level is defined then it must be base
if (!defined($strLevel))
@ -389,7 +438,7 @@ sub build
confess &log(ERROR, PATH_PG_TBLSPC . "/${strName} is not a link");
}
&log(DEBUG, "Found tablespace ${strName}");
logDebugMisc($strOperation, "found tablespace ${strName}");
${$oTablespaceMapRef}{oid}{$strName}{name} = $strName;
}
@ -491,22 +540,22 @@ sub build
{
# If modification time is in the future (in this backup OR the last backup) set warning flag and do not
# allow a reference
if ($self->getNumeric($strSection, $strName, MANIFEST_SUBKEY_TIMESTAMP) > $lTimeBegin ||
if ($self->numericGet($strSection, $strName, MANIFEST_SUBKEY_TIMESTAMP) > $lTimeBegin ||
(defined($oLastManifest) && $oLastManifest->test($strSection, $strName, MANIFEST_SUBKEY_FUTURE, 'y')))
{
$bTimeInFuture = true;
# Only mark as future if still in the future in the current backup
if ($self->getNumeric($strSection, $strName, MANIFEST_SUBKEY_TIMESTAMP) > $lTimeBegin)
if ($self->numericGet($strSection, $strName, MANIFEST_SUBKEY_TIMESTAMP) > $lTimeBegin)
{
$self->set($strSection, $strName, MANIFEST_SUBKEY_FUTURE, 'y');
}
}
# Else check if modification time and size are unchanged since last backup
elsif (defined($oLastManifest) && $oLastManifest->test($strSection, $strName) &&
$self->getNumeric($strSection, $strName, MANIFEST_SUBKEY_SIZE) ==
$self->numericGet($strSection, $strName, MANIFEST_SUBKEY_SIZE) ==
$oLastManifest->get($strSection, $strName, MANIFEST_SUBKEY_SIZE) &&
$self->getNumeric($strSection, $strName, MANIFEST_SUBKEY_TIMESTAMP) ==
$self->numericGet($strSection, $strName, MANIFEST_SUBKEY_TIMESTAMP) ==
$oLastManifest->get($strSection, $strName, MANIFEST_SUBKEY_TIMESTAMP))
{
# Copy reference from previous backup if possible
@ -542,6 +591,12 @@ sub build
# Record the time when copying will start
$self->set(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_TIMESTAMP_COPY_START, undef, $lTimeBegin + 1);
}
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
1;

64
lib/BackRest/Protocol/Common.pm
View File

@ -12,11 +12,11 @@ use File::Basename qw(dirname);
use IO::String qw();
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::Exception;
use BackRest::Ini;
use BackRest::Protocol::IO;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
@ -31,50 +31,40 @@ use constant OP_PROTOCOL_COMMON_NEW => OP_PROTOC
sub new
{
my $class = shift; # Class name
my $iBlockSize = shift; # Buffer size
my $iCompressLevel = shift; # Set compression level
my $iCompressLevelNetwork = shift; # Set compression level for network only compression
my $strName = shift; # Name to be used for gretting
# Debug
logTrace(OP_PROTOCOL_COMMON_NEW, DEBUG_CALL, undef,
{iBlockSize => $iBlockSize, iCompressLevel => $iCompressLevel, iCompressNetworkLevel => $iCompressLevelNetwork});
# Create the class hash
my $self = {};
bless $self, $class;
# Set default block size
$self->{iBlockSize} = $iBlockSize;
if (!defined($self->{iBlockSize}))
{
confess &log(ASSERT, 'iBlockSize must be set');
}
# Set compress levels
$self->{iCompressLevel} = $iCompressLevel;
if (!defined($self->{iCompressLevel}))
{
confess &log(ASSERT, 'iCompressLevel must be set');
}
$self->{iCompressLevelNetwork} = $iCompressLevelNetwork;
if (!defined($self->{iCompressLevelNetwork}))
{
confess &log(ASSERT, 'iCompressLevelNetwork must be set');
}
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{iBlockSize},
$self->{iCompressLevel},
$self->{iCompressLevelNetwork},
$self->{strName}
) =
logDebugParam
(
OP_PROTOCOL_COMMON_NEW, \@_,
{name => 'iBlockSize', trace => true},
{name => 'iCompressLevel', trace => true},
{name => 'iCompressNetworkLevel', trace => true},
{name => 'strName', required => false, trace => true}
);
# Create the greeting that will be used to check versions with the remote
if (defined($strName))
if (defined($self->{strName}))
{
$self->{strName} = $strName;
$self->{strGreeting} = 'PG_BACKREST_' . uc($strName) . ' ' . BACKREST_VERSION;
$self->{strGreeting} = 'PG_BACKREST_' . uc($self->{strName}) . ' ' . BACKREST_VERSION;
}
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################

95
lib/BackRest/Protocol/CommonMaster.pm
View File

@ -11,12 +11,12 @@ use Carp qw(confess);
use File::Basename qw(dirname);
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::Exception;
use BackRest::Ini;
use BackRest::Protocol::Common;
use BackRest::Protocol::IO;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
@ -33,16 +33,26 @@ use constant OP_PROTOCOL_COMMON_MASTER_OUTPUT_READ => OP_PROTOC
sub new
{
my $class = shift; # Class name
my $strName = shift; # Name of the protocol
my $strCommand = shift; # Command to execute on local/remote
my $iBlockSize = shift; # Buffer size
my $iCompressLevel = shift; # Set compression level
my $iCompressLevelNetwork = shift; # Set compression level for network only compression
# Debug
logDebug(OP_PROTOCOL_COMMON_MASTER_NEW, DEBUG_CALL, undef,
{name => \$strName, command => \$strCommand, blockSize => $iBlockSize,
compressLevel => $iCompressLevel, compressLevelNetwork => $iCompressLevelNetwork});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strName, # Name of the protocol
$strCommand, # Command to execute on local/remote
$iBlockSize, # Buffer size
$iCompressLevel, # Set compression level
$iCompressLevelNetwork # Set compression level for network only compression
) =
logDebugParam
(
OP_PROTOCOL_COMMON_MASTER_NEW, \@_,
{name => 'strName'},
{name => 'strCommand'},
{name => 'iBlockSize'},
{name => 'iCompressLevel'},
{name => 'iCompressLevelNetwork'}
);
# Create the class hash
my $self = $class->SUPER::new($iBlockSize, $iCompressLevel, $iCompressLevelNetwork, $strName);
@ -60,7 +70,12 @@ sub new
# Check greeting to be sure the protocol matches
$self->greetingRead();
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
@ -115,12 +130,22 @@ sub greetingRead
sub outputRead
{
my $self = shift;
my $bOutputRequired = shift;
my $strErrorPrefix = shift;
my $bSuppressLog = shift;
logTrace(OP_PROTOCOL_COMMON_MASTER_OUTPUT_READ, DEBUG_CALL, undef,
{isOutputRequired => $bOutputRequired, strErrorPrefix => \$strErrorPrefix, isSuppressLog => $bSuppressLog});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$bOutputRequired,
$strErrorPrefix,
$bSuppressLog
) =
logDebugParam
(
OP_PROTOCOL_COMMON_MASTER_OUTPUT_READ, \@_,
{name => 'bOutputRequired', default => false, trace => true},
{name => 'strErrorPrefix', required => false, trace => true},
{name => 'bSuppressLog', required => false, trace => true}
);
my $strLine;
my $strOutput;
@ -165,10 +190,12 @@ sub outputRead
confess &log(ERROR, (defined($strErrorPrefix) ? "${strErrorPrefix}: " : '') . 'output is not defined');
}
logTrace(OP_PROTOCOL_COMMON_MASTER_OUTPUT_READ, DEBUG_RESULT, undef, {strOutput => \$strOutput});
# Return output
return $strOutput;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'strOutput', value => $strOutput, trace => true}
);
}
####################################################################################################################################
@ -203,10 +230,20 @@ sub commandParamString
sub cmdWrite
{
my $self = shift;
my $strCommand = shift;
my $oParamRef = shift;
logTrace(OP_PROTOCOL_COMMON_MASTER_COMMAND_WRITE, DEBUG_CALL, \$strCommand, $oParamRef);
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strCommand,
$oParamRef,
) =
logDebugParam
(
OP_PROTOCOL_COMMON_MASTER_COMMAND_WRITE, \@_,
{name => 'strCommand', trace => true},
{name => 'oParamRef', required => false, trace => true}
);
if (defined($oParamRef))
{
@ -235,9 +272,13 @@ sub cmdWrite
$strCommand .= 'end';
}
$self->{io}->lineWrite($strCommand);
logDebugMisc
(
$strOperation, undef,
{name => 'strCommand', value => $strCommand, trace => true}
);
logTrace(OP_PROTOCOL_COMMON_MASTER_COMMAND_WRITE, DEBUG_RESULT, undef, {strCommand => \$strCommand});
$self->{io}->lineWrite($strCommand);
}
####################################################################################################################################

41
lib/BackRest/Protocol/CommonMinion.pm
View File

@ -12,12 +12,13 @@ use File::Basename qw(dirname);
use Scalar::Util qw(blessed);
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Common::String;
use BackRest::Config;
use BackRest::Exception;
use BackRest::Ini;
use BackRest::Protocol::Common;
use BackRest::Protocol::IO;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
@ -32,27 +33,29 @@ use constant OP_PROTOCOL_COMMON_MINION_NEW => OP_PROTOC
sub new
{
my $class = shift; # Class name
my $strName = shift; # Name of the protocol
my $iBlockSize = shift; # Buffer size
my $iCompressLevel = shift; # Set compression level
my $iCompressLevelNetwork = shift; # Set compression level for network only compression
# Debug
logTrace(OP_PROTOCOL_COMMON_MINION_NEW, DEBUG_CALL, undef,
{name => \$strName, blockSize => $iBlockSize, compressLevel => $iCompressLevel,
compressLevelNetwork => $iCompressLevelNetwork});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strName, # Name of the protocol
$iBlockSize, # Buffer size
$iCompressLevel, # Set compression level
$iCompressLevelNetwork # Set compression level for network only compression
) =
logDebugParam
(
OP_PROTOCOL_COMMON_MINION_NEW, \@_,
{name => 'strName'},
{name => 'iBlockSize'},
{name => 'iCompressLevel'},
{name => 'iCompressLevelNetwork'}
);
# Create the class hash
my $self = $class->SUPER::new($iBlockSize, $iCompressLevel, $iCompressLevelNetwork, $strName);
bless $self, $class;
# Create the greeting that will be used to check versions with the remote
if (defined($strName))
{
$self->{strName} = $strName;
$self->{strGreeting} = 'PG_BACKREST_' . uc($strName) . ' ' . BACKREST_VERSION;
}
# Create the IO object with std io
$self->{io} = new BackRest::Protocol::IO(*STDIN, *STDOUT, *STDERR);
@ -119,7 +122,7 @@ sub errorWrite
if (blessed($oMessage))
{
# Check if it is a standard exception
if ($oMessage->isa('BackRest::Exception'))
if ($oMessage->isa('BackRest::Common::Exception'))
{
$iCode = $oMessage->code();
$strMessage = $oMessage->message();

66
lib/BackRest/Protocol/IO.pm
View File

@ -8,12 +8,14 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use File::Basename qw(dirname);
use IPC::Open3;
use IPC::Open3 qw(open3);
use POSIX qw(:sys_wait_h);
use lib dirname($0) . '/../lib';
use BackRest::Exception;
use BackRest::Utility;
use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Common::String;
use BackRest::Common::Wait;
####################################################################################################################################
# Operation constants
@ -28,25 +30,35 @@ use constant OP_IO_PROTOCOL_NEW3 =>
####################################################################################################################################
sub new
{
my $class = shift; # Class name
my $hIn = shift; # Input stream
my $hOut = shift; # Output stream
my $hErr = shift; # Error stream
my $pId = shift; # Process ID
# Debug
logTrace(OP_IO_PROTOCOL_NEW3, DEBUG_CALL);
my $class = shift;
# Create the class hash
my $self = {};
bless $self, $class;
$self->{hIn} = $hIn;
$self->{hOut} = $hOut;
$self->{hErr} = $hErr;
$self->{pId} = $pId;
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{hIn}, # Input stream
$self->{hOut}, # Output stream
$self->{hErr}, # Error stream
$self->{pId} # Process ID
) =
logDebugParam
(
OP_IO_PROTOCOL_NEW, \@_,
{name => 'hIn', required => false, trace => true},
{name => 'hOut', required => false, trace => true},
{name => 'hErr', required => false, trace => true},
{name => 'pId', required => false, trace => true}
);
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
@ -57,18 +69,30 @@ sub new
sub new3
{
my $class = shift;
my $strCommand = shift;
# Debug
logTrace(OP_IO_PROTOCOL_NEW3, DEBUG_CALL, undef, {command => \$strCommand});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strCommand
) =
logDebugParam
(
OP_IO_PROTOCOL_NEW3, \@_,
{name => 'strCommand', trace => true}
);
# Use open3 to run the command
my ($pId, $hIn, $hOut, $hErr);
$pId = IPC::Open3::open3($hIn, $hOut, $hErr, $strCommand);
# Return the IO class
return $class->new($hOut, $hIn, $hErr, $pId);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $class->new($hOut, $hIn, $hErr, $pId)}
);
}
####################################################################################################################################

60
lib/BackRest/Protocol/RemoteMaster.pm
View File

@ -11,9 +11,9 @@ use Carp qw(confess);
use File::Basename qw(dirname);
use lib dirname($0) . '/../lib';
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::Protocol::CommonMaster;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
@ -27,36 +27,29 @@ use constant OP_PROTOCOL_REMOTE_MASTER_NEW => OP_PROTOC
####################################################################################################################################
sub new
{
my $class = shift; # Class name
my $strCommand = shift; # Command to execute on local/remote
my $iBlockSize = shift; # Buffer size
my $iCompressLevel = shift; # Set compression level
my $iCompressLevelNetwork = shift; # Set compression level for network only compression
my $strHost = shift; # Host to connect to for remote (optional as this can also be used for local)
my $strUser = shift; # User to connect to for remote (must be set if strHost is set)
my $class = shift;
# Debug
logDebug(OP_PROTOCOL_REMOTE_MASTER_NEW, DEBUG_CALL, undef,
{command => \$strCommand, host => \$strHost, user => \$strUser, blockSize => $iBlockSize,
compressLevel => $iCompressLevel, compressLevelNetwork => $iCompressLevelNetwork});
# Host must be defined
if (!defined($strHost))
{
confess &log(ASSERT, 'strHost must be defined');
}
# User must be defined
if (!defined($strUser))
{
confess &log(ASSERT, 'strUser must be defined');
}
# Command must be defined
if (!defined($strCommand))
{
confess &log(ASSERT, 'strCommand must be defined');
}
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strCommand, # Command to execute on local/remote
$iBlockSize, # Buffer size
$iCompressLevel, # Set compression level
$iCompressLevelNetwork, # Set compression level for network only compression
$strHost, # Host to connect to for remote (optional as this can also be used for local)
$strUser # User to connect to for remote (must be set if strHost is set)
) =
logDebugParam
(
OP_PROTOCOL_REMOTE_MASTER_NEW, \@_,
{name => 'strCommand'},
{name => 'iBlockSize'},
{name => 'iCompressLevel'},
{name => 'iCompressLevelNetwork'},
{name => 'strHost'},
{name => 'strUser'}
);
# Create SSH command
$strCommand = "ssh -o Compression=no -o PasswordAuthentication=no ${strUser}\@${strHost} '${strCommand}'";
@ -65,7 +58,12 @@ sub new
my $self = $class->SUPER::new('remote', $strCommand, $iBlockSize, $iCompressLevel, $iCompressLevelNetwork);
bless $self, $class;
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################

42
lib/BackRest/Protocol/RemoteMinion.pm
View File

@ -11,21 +11,21 @@ use Carp qw(confess);
use File::Basename qw(dirname);
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Archive;
use BackRest::Config;
use BackRest::Db;
use BackRest::Exception;
use BackRest::File;
use BackRest::Info;
use BackRest::Protocol::CommonMinion;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_PROTOCOL_REMOVE_MINION => 'Protocol::RemoteMinion';
use constant OP_PROTOCOL_REMOTE_MINION => 'Protocol::RemoteMinion';
use constant OP_PROTOCOL_REMOVE_MINION_NEW => OP_PROTOCOL_REMOVE_MINION . "->new";
use constant OP_PROTOCOL_REMOTE_MINION_NEW => OP_PROTOCOL_REMOTE_MINION . "->new";
####################################################################################################################################
# Operation constants
@ -42,19 +42,33 @@ use constant
sub new
{
my $class = shift; # Class name
my $iBlockSize = shift; # Buffer size
my $iCompressLevel = shift; # Set compression level
my $iCompressLevelNetwork = shift; # Set compression level for network only compression
# Debug
logTrace(OP_PROTOCOL_REMOVE_MINION_NEW, DEBUG_CALL, undef,
{iBlockSize => $iBlockSize, iCompressLevel => $iCompressLevel, iCompressNetworkLevel => $iCompressLevelNetwork});
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$iBlockSize, # Buffer size
$iCompressLevel, # Set compression level
$iCompressLevelNetwork # Set compression level for network only compression
) =
logDebugParam
(
OP_PROTOCOL_REMOTE_MINION_NEW, \@_,
{name => 'iBlockSize', trace => true},
{name => 'iCompressLevel', trace => true},
{name => 'iCompressNetworkLevel', trace => true}
);
# Init object and store variables
my $self = $class->SUPER::new(CMD_REMOTE, $iBlockSize, $iCompressLevel, $iCompressLevelNetwork);
bless $self, $class;
return $self;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
@ -188,7 +202,7 @@ sub process
# Create a path
elsif ($strCommand eq OP_FILE_PATH_CREATE)
{
$oFile->path_create(PATH_ABSOLUTE, paramGet(\%oParamHash, 'path'), paramGet(\%oParamHash, 'mode', false));
$oFile->pathCreate(PATH_ABSOLUTE, paramGet(\%oParamHash, 'path'), paramGet(\%oParamHash, 'mode', false));
$self->outputWrite();
}
# Check if a file/path exists
@ -243,11 +257,11 @@ sub process
$self->outputWrite($oArchive->getCheck($oFile));
}
# Info list stanza
elsif ($strCommand eq OP_INFO_LIST_STANZA)
elsif ($strCommand eq OP_INFO_STANZA_LIST)
{
$self->outputWrite(
$oJSON->encode(
$oInfo->listStanza($oFile,
$oInfo->stanzaList($oFile,
paramGet(\%oParamHash, 'stanza', false))));
}
elsif ($strCommand eq OP_DB_INFO)

26
lib/BackRest/ThreadGroup.pm → lib/BackRest/Protocol/ThreadGroup.pm
View File

@ -1,7 +1,7 @@
####################################################################################################################################
# THREADGROUP MODULE
# COMMON THREADGROUP MODULE
####################################################################################################################################
package BackRest::ThreadGroup;
package BackRest::Protocol::ThreadGroup;
use threads;
use strict;
@ -9,19 +9,19 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename;
use lib dirname($0) . '/../lib';
use BackRest::Common::Log;
use BackRest::Common::Wait;
use BackRest::Config;
use BackRest::BackupFile;
use BackRest::RestoreFile;
use BackRest::Utility;
####################################################################################################################################
# MODULE EXPORTS
# Module globals
####################################################################################################################################
our @EXPORT = qw(threadGroupCreate threadGroupRun threadGroupComplete threadGroupDestroy);
my @oyThread;
my @oyMessageQueue;
my @oyCommandQueue;
@ -56,6 +56,8 @@ sub threadGroupCreate
}
}
push @EXPORT, qw(threadGroupCreate);
####################################################################################################################################
# threadGroupThread
####################################################################################################################################
@ -251,6 +253,8 @@ sub threadGroupRun
$byThreadRunning[$iThreadIdx] = true;
}
push @EXPORT, qw(threadGroupRun);
####################################################################################################################################
# threadGroupComplete
#
@ -276,7 +280,7 @@ sub threadGroupComplete
# Rejoin the threads
# while ($iThreadComplete < @oyThread)
# {
hsleep(.1);
waitHiRes(.1);
# If a timeout has been defined, make sure we have not been running longer than that
if (defined($iTimeout))
@ -297,7 +301,7 @@ sub threadGroupComplete
{
my $strError;
if ($oError->isa('BackRest::Exception'))
if ($oError->isa('BackRest::Common::Exception'))
{
$strError = $oError->message();
}
@ -347,6 +351,8 @@ sub threadGroupComplete
return false;
}
push @EXPORT, qw(threadGroupComplete);
####################################################################################################################################
# threadGroupDestroy
####################################################################################################################################
@ -362,7 +368,7 @@ sub threadGroupDestroy
$oCommand{function} = 'exit';
$oyCommandQueue[$iThreadIdx]->enqueue(\%oCommand);
hsleep(.1);
waitHiRes(.1);
if ($oyThread[$iThreadIdx]->is_running())
{
@ -383,4 +389,6 @@ sub threadGroupDestroy
return(@oyThread);
}
push @EXPORT, qw(threadGroupDestroy);
1;

316
lib/BackRest/Restore.pm
View File

@ -14,20 +14,36 @@ use File::Basename qw(dirname);
use File::stat qw(lstat);
use lib dirname($0);
use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::Db;
use BackRest::Exception;
use BackRest::File;
use BackRest::Manifest;
use BackRest::Protocol::ThreadGroup;
use BackRest::RestoreFile;
use BackRest::ThreadGroup;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_RESTORE => 'Restore';
use constant OP_RESTORE_BUILD => OP_RESTORE . '->build';
use constant OP_RESTORE_CLEAN => OP_RESTORE . '->clean';
use constant OP_RESTORE_MANIFEST_LOAD => OP_RESTORE . '->manifestLoad';
use constant OP_RESTORE_MANIFEST_OWNERSHIP_CHECK => OP_RESTORE . '->manifestOwnershipCheck';
use constant OP_RESTORE_NEW => OP_RESTORE . '->new';
use constant OP_RESTORE_PROCESS => OP_RESTORE . '->process';
use constant OP_RESTORE_RECOVERY => OP_RESTORE . '->recovery';
####################################################################################################################################
# File constants
####################################################################################################################################
use constant FILE_RECOVERY_CONF => 'recovery.conf'; # Conf file with settings for recovery after restore
use constant FILE_TABLESPACE_MAP => 'tablespace_map'; # Tablespace map introduced in 9.5
# Conf file with settings for recovery after restore
use constant FILE_RECOVERY_CONF => 'recovery.conf';
# Tablespace map introduced in 9.5
use constant FILE_TABLESPACE_MAP => 'tablespace_map';
####################################################################################################################################
# CONSTRUCTOR
@ -35,58 +51,55 @@ use constant FILE_TABLESPACE_MAP => 'tablespace_map'; # Tablespace map introdu
sub new
{
my $class = shift; # Class name
my $strDbClusterPath = shift; # Database cluster path
my $strBackupPath = shift; # Backup to restore
my $oRemapRef = shift; # Tablespace remaps
my $oFile = shift; # Default file object
my $iThreadTotal = shift; # Total threads to run for restore
my $bDelta = shift; # perform delta restore
my $bForce = shift; # force a restore
my $strType = shift; # Recovery type
my $strTarget = shift; # Recovery target
my $bTargetExclusive = shift; # Target exlusive option
my $bTargetResume = shift; # Target resume option
my $strTargetTimeline = shift; # Target timeline option
my $oRecoveryRef = shift; # Other recovery options
my $strStanza = shift; # Restore stanza
my $strBackRestBin = shift; # Absolute backrest filename
my $strConfigFile = shift; # Absolute config filename (optional)
# Create the class hash
my $self = {};
bless $self, $class;
# Initialize variables
$self->{strDbClusterPath} = $strDbClusterPath;
$self->{strBackupPath} = $strBackupPath;
$self->{oRemapRef} = $oRemapRef;
$self->{oFile} = $oFile;
$self->{iThreadTotal} = defined($iThreadTotal) ? $iThreadTotal : 1;
$self->{bDelta} = $bDelta;
$self->{bForce} = $bForce;
$self->{strType} = $strType;
$self->{strTarget} = $strTarget;
$self->{bTargetExclusive} = $bTargetExclusive;
$self->{bTargetResume} = $bTargetResume;
$self->{strTargetTimeline} = $strTargetTimeline;
$self->{oRecoveryRef} = $oRecoveryRef;
$self->{strStanza} = $strStanza;
$self->{strBackRestBin} = $strBackRestBin;
$self->{strConfigFile} = $strConfigFile;
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{oFile}
) =
logDebugParam
(
OP_RESTORE_NEW, \@_,
{name => 'oFile', trace => true}
);
return $self;
# Initialize variables
$self->{strDbClusterPath} = optionGet(OPTION_DB_PATH);
$self->{strBackupSet} = optionGet(OPTION_SET);
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
# MANIFEST_OWNERSHIP_CHECK
# manifestOwnershipCheck
#
# Checks the users and groups that exist in the manifest and emits warnings for ownership that cannot be set properly, either
# because the current user does not have permissions or because the user/group does not exist.
####################################################################################################################################
sub manifest_ownership_check
sub manifestOwnershipCheck
{
my $self = shift; # Class hash
my $oManifest = shift; # Backup manifest
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oManifest # Backup manifest
) =
logDebugParam
(
OP_RESTORE_MANIFEST_OWNERSHIP_CHECK, \@_,
{name => 'oManifest', trace => true}
);
# Create hashes to track valid/invalid users/groups
my %oOwnerHash = ();
@ -168,25 +181,35 @@ sub manifest_ownership_check
}
}
}
# Return from function and log return values if any
return logDebugReturn($strOperation);
}
####################################################################################################################################
# MANIFEST_LOAD
# manifestLoad
#
# Loads the backup manifest and performs requested tablespace remaps.
####################################################################################################################################
sub manifest_load
sub manifestLoad
{
my $self = shift; # Class hash
if ($self->{oFile}->exists(PATH_BACKUP_CLUSTER, $self->{strBackupPath}))
# Assign function parameters, defaults, and log debug info
my ($strOperation) = logDebugParam (OP_RESTORE_MANIFEST_LOAD);
# Error if the backup set does not exist
if (!$self->{oFile}->exists(PATH_BACKUP_CLUSTER, $self->{strBackupSet}))
{
confess &log(ERROR, 'backup ' . $self->{strBackupSet} . ' does not exist');
}
# Copy the backup manifest to the db cluster path
$self->{oFile}->copy(PATH_BACKUP_CLUSTER, $self->{strBackupPath} . '/' . FILE_MANIFEST,
$self->{oFile}->copy(PATH_BACKUP_CLUSTER, $self->{strBackupSet} . '/' . FILE_MANIFEST,
PATH_DB_ABSOLUTE, $self->{strDbClusterPath} . '/' . FILE_MANIFEST);
# Load the manifest into a hash
my $oManifest = new BackRest::Manifest($self->{oFile}->path_get(PATH_DB_ABSOLUTE,
my $oManifest = new BackRest::Manifest($self->{oFile}->pathGet(PATH_DB_ABSOLUTE,
$self->{strDbClusterPath} . '/' . FILE_MANIFEST));
# Remove the manifest now that it is in memory
@ -195,13 +218,13 @@ sub manifest_load
# If backup is latest then set it equal to backup label, else verify that requested backup and label match
my $strBackupLabel = $oManifest->get(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_LABEL);
if ($self->{strBackupPath} eq OPTION_DEFAULT_RESTORE_SET)
if ($self->{strBackupSet} eq OPTION_DEFAULT_RESTORE_SET)
{
$self->{strBackupPath} = $strBackupLabel;
$self->{strBackupSet} = $strBackupLabel;
}
elsif ($self->{strBackupPath} ne $strBackupLabel)
elsif ($self->{strBackupSet} ne $strBackupLabel)
{
confess &log(ASSERT, "request backup $self->{strBackupPath} and label ${strBackupLabel} do not match " .
confess &log(ASSERT, "request backup $self->{strBackupSet} and label ${strBackupLabel} do not match " .
' - this indicates some sort of corruption (at the very least paths have been renamed)');
}
@ -235,16 +258,18 @@ sub manifest_load
$oManifest->set('base:path', $strTablespaceLink, MANIFEST_SUBKEY_MODE,
$oManifest->get('base:path', '.', MANIFEST_SUBKEY_MODE));
&log(INFO, "remapping tablespace ${strTablespaceKey} to ${strTablespacePath}");
&log(INFO, "remap tablespace ${strTablespaceKey} to ${strTablespacePath}");
}
}
}
# If tablespaces have been remapped, update the manifest
elsif (defined($self->{oRemapRef}))
elsif (optionTest(OPTION_RESTORE_TABLESPACE_MAP))
{
foreach my $strTablespaceKey (sort(keys(%{$self->{oRemapRef}})))
my $oRemapRef = optionGet(OPTION_RESTORE_TABLESPACE_MAP);
foreach my $strTablespaceKey (sort(keys(%$oRemapRef)))
{
my $strRemapPath = ${$self->{oRemapRef}}{$strTablespaceKey};
my $strRemapPath = $$oRemapRef{$strTablespaceKey};
my $strPathKey = "tablespace/${strTablespaceKey}";
# Make sure that the tablespace exists in the manifest
@ -263,16 +288,18 @@ sub manifest_load
}
}
$self->manifest_ownership_check($oManifest);
$self->manifestOwnershipCheck($oManifest);
return $oManifest;
}
confess &log(ERROR, 'backup ' . $self->{strBackupPath} . ' does not exist');
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'oManifest', value => $oManifest, trace => true}
);
}
####################################################################################################################################
# CLEAN
# clean
#
# Checks that the restore paths are empty, or if --force was used then it cleans files/paths/links from the restore directories that
# are not present in the manifest.
@ -280,7 +307,19 @@ sub manifest_load
sub clean
{
my $self = shift; # Class hash
my $oManifest = shift; # Backup manifest
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oManifest # Backup manifest
) =
logDebugParam
(
OP_RESTORE_CLEAN, \@_,
{name => 'oManifest', trace => true}
);
# Track if files/links/paths where removed
my %oRemoveHash = (&MANIFEST_FILE => 0, &MANIFEST_PATH => 0, &MANIFEST_LINK => 0);
@ -291,7 +330,7 @@ sub clean
{
my $strPath = $oManifest->get(MANIFEST_SECTION_BACKUP_PATH, $strPathKey, MANIFEST_SUBKEY_PATH);
&log(INFO, "checking/cleaning db path ${strPath}");
&log(INFO, "check/clean db path ${strPath}");
if (!$self->{oFile}->exists(PATH_DB_ABSOLUTE, $strPath))
{
@ -311,7 +350,7 @@ sub clean
}
# If force was not specified then error if any file is found
if (!$self->{bForce} && !$self->{bDelta})
if (!optionGet(OPTION_FORCE) && !optionGet(OPTION_DELTA))
{
confess &log(ERROR, "cannot restore to path '${strPath}' that contains files - " .
'try using --delta if this is what you intended', ERROR_RESTORE_PATH_NOT_EMPTY);
@ -344,7 +383,7 @@ sub clean
if ($strUser ne $oPathManifest{name}{$strName}{user} ||
$strGroup ne $oPathManifest{name}{$strName}{group})
{
&log(INFO, "setting ${strFile} ownership to ${strUser}:${strGroup}");
&log(INFO, "set ownership ${strUser}:${strGroup} on ${strFile}");
$self->{oFile}->owner(PATH_DB_ABSOLUTE, $strFile, $strUser, $strGroup);
}
@ -355,8 +394,10 @@ sub clean
if ($strType eq MANIFEST_LINK && $oManifest->get($strSection, $strName, MANIFEST_SUBKEY_DESTINATION) ne
$oPathManifest{name}{$strName}{link_destination})
{
&log(INFO, "removing link ${strFile} - destination changed");
unlink($strFile) or confess &log(ERROR, "unable to delete file ${strFile}");
&log(INFO, "remove link ${strFile} - destination changed");
unlink($strFile)
or confess &log(ERROR, "unable to remove link ${strFile}");
}
}
# Else if file/path mode does not match, fix it
@ -366,10 +407,10 @@ sub clean
if ($strType ne MANIFEST_LINK && $strMode ne $oPathManifest{name}{$strName}{mode})
{
&log(INFO, "setting ${strFile} mode to ${strMode}");
&log(INFO, "set mode ${strMode} on ${strFile}");
chmod(oct($strMode), $strFile)
or confess 'unable to set mode ${strMode} for ${strFile}';
or confess 'unable to set mode ${strMode} on ${strFile}';
}
}
}
@ -379,7 +420,7 @@ sub clean
# If a path then remove it, all the files should have already been deleted since we are going in reverse order
if ($strType eq MANIFEST_PATH)
{
&log(INFO, "removing path ${strFile}");
&log(INFO, "remove path ${strFile}");
rmdir($strFile) or confess &log(ERROR, "unable to delete path ${strFile}, is it empty?");
}
# Else delete a file/link
@ -389,7 +430,7 @@ sub clean
# preserved. It will be written/deleted/preserved as needed in recovery().
if (!($strName eq FILE_RECOVERY_CONF && $strType eq MANIFEST_FILE))
{
&log(INFO, "removing file/link ${strFile}");
&log(INFO, "remove file/link ${strFile}");
unlink($strFile) or confess &log(ERROR, "unable to delete file/link ${strFile}");
}
}
@ -400,24 +441,46 @@ sub clean
}
# Loop through types (path, link, file) and emit info if any were removed
my @stryMessage;
foreach my $strFileType (sort (keys %oRemoveHash))
{
if ($oRemoveHash{$strFileType} > 0)
{
&log(INFO, "$oRemoveHash{$strFileType} ${strFileType}(s) removed during cleanup");
}
push(@stryMessage, "$oRemoveHash{$strFileType} ${strFileType}" . ($oRemoveHash{$strFileType} > 1 ? 's' : ''));
}
}
if (@stryMessage)
{
&log(INFO, 'cleanup removed ' . join(', ', @stryMessage));
}
# Return from function and log return values if any
return logDebugReturn($strOperation);
}
####################################################################################################################################
# BUILD
# build
#
# Creates missing paths and links and corrects ownership/mode on existing paths and links.
####################################################################################################################################
sub build
{
my $self = shift; # Class hash
my $oManifest = shift; # Backup manifest
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$oManifest # Backup manifest
) =
logDebugParam
(
OP_RESTORE_BUILD, \@_,
{name => 'oManifest', trace => true}
);
# Build paths/links in each restore path
foreach my $strSectionPathKey ($oManifest->keys(MANIFEST_SECTION_BACKUP_PATH))
@ -440,7 +503,7 @@ sub build
if (!$self->{oFile}->exists(PATH_DB_ABSOLUTE, $strPath))
{
$self->{oFile}->path_create(PATH_DB_ABSOLUTE, $strPath,
$self->{oFile}->pathCreate(PATH_DB_ABSOLUTE, $strPath,
$oManifest->get($strSection, $strName, MANIFEST_SUBKEY_MODE));
}
}
@ -456,7 +519,7 @@ sub build
if (!$self->{oFile}->exists(PATH_DB_ABSOLUTE, $strLink))
{
$self->{oFile}->link_create(PATH_DB_ABSOLUTE,
$self->{oFile}->linkCreate(PATH_DB_ABSOLUTE,
$oManifest->get($strSection, $strName, MANIFEST_SUBKEY_DESTINATION),
PATH_DB_ABSOLUTE, $strLink);
}
@ -474,10 +537,13 @@ sub build
confess &log(ERROR, "required db path '${strPath}' does not exist");
}
}
# Return from function and log return values if any
return logDebugReturn($strOperation);
}
####################################################################################################################################
# RECOVERY
# recovery
#
# Creates the recovery.conf file.
####################################################################################################################################
@ -485,6 +551,9 @@ sub recovery
{
my $self = shift; # Class hash
# Assign function parameters, defaults, and log debug info
my ($strOperation) = logDebugParam (OP_RESTORE_RECOVERY);
# Create recovery.conf path/file
my $strRecoveryConf = $self->{strDbClusterPath} . '/' . FILE_RECOVERY_CONF;
@ -492,16 +561,15 @@ sub recovery
my $bRecoveryConfExists = $self->{oFile}->exists(PATH_DB_ABSOLUTE, $strRecoveryConf);
# If RECOVERY_TYPE_PRESERVE then warn if recovery.conf does not exist and return
if ($self->{strType} eq RECOVERY_TYPE_PRESERVE)
if (optionTest(OPTION_TYPE, RECOVERY_TYPE_PRESERVE))
{
if (!$bRecoveryConfExists)
{
&log(WARN, "recovery type is $self->{strType} but recovery file does not exist at ${strRecoveryConf}");
&log(WARN, "recovery type is " . optionGet(OPTION_TYPE) . " but recovery file does not exist at ${strRecoveryConf}");
}
return;
}
else
{
# In all other cases the old recovery.conf should be removed if it exists
if ($bRecoveryConfExists)
{
@ -509,18 +577,17 @@ sub recovery
}
# If RECOVERY_TYPE_NONE then return
if ($self->{strType} eq RECOVERY_TYPE_NONE)
if (!optionTest(OPTION_TYPE, RECOVERY_TYPE_NONE))
{
return;
}
# Write recovery options read from the configuration file
my $strRecovery = '';
my $bRestoreCommandOverride = false;
if (defined($self->{oRecoveryRef}))
if (optionTest(OPTION_RESTORE_RECOVERY_SETTING))
{
foreach my $strKey (sort(keys(%{$self->{oRecoveryRef}})))
my $oRecoveryRef = optionGet(OPTION_RESTORE_RECOVERY_SETTING);
foreach my $strKey (sort(keys(%$oRecoveryRef)))
{
my $strPgKey = $strKey;
$strPgKey =~ s/\-/\_/g;
@ -530,7 +597,7 @@ sub recovery
$bRestoreCommandOverride = true;
}
$strRecovery .= "$strPgKey = '${$self->{oRecoveryRef}}{$strKey}'\n";
$strRecovery .= "${strPgKey} = '$$oRecoveryRef{$strKey}'\n";
}
}
@ -541,28 +608,28 @@ sub recovery
}
# If RECOVERY_TYPE_DEFAULT do not write target options
if ($self->{strType} ne RECOVERY_TYPE_DEFAULT)
if (!optionTest(OPTION_TYPE, RECOVERY_TYPE_DEFAULT))
{
# Write the recovery target
$strRecovery .= "recovery_target_$self->{strType} = '$self->{strTarget}'\n";
$strRecovery .= "recovery_target_" . optionGet(OPTION_TYPE) . " = '" . optionGet(OPTION_TARGET) . "'\n";
# Write recovery_target_inclusive
if ($self->{bTargetExclusive})
if (optionGet(OPTION_TARGET_EXCLUSIVE, false))
{
$strRecovery .= "recovery_target_inclusive = 'false'\n";
}
}
# Write pause_at_recovery_target
if ($self->{bTargetResume})
if (optionGet(OPTION_TARGET_RESUME, false))
{
$strRecovery .= "pause_at_recovery_target = 'false'\n";
}
# Write recovery_target_timeline
if (defined($self->{strTargetTimeline}))
if (optionTest(OPTION_TARGET_TIMELINE))
{
$strRecovery .= "recovery_target_timeline = '$self->{strTargetTimeline}'\n";
$strRecovery .= "recovery_target_timeline = '" . optionGet(OPTION_TARGET_TIMELINE) . "'\n";
}
# Write recovery.conf
@ -579,16 +646,24 @@ sub recovery
&log(INFO, "wrote $strRecoveryConf");
}
}
# Return from function and log return values if any
return logDebugReturn($strOperation);
}
####################################################################################################################################
# RESTORE
# process
#
# Takes a backup and restores it back to the original or a remapped location.
####################################################################################################################################
sub restore
sub process
{
my $self = shift; # Class hash
# Assign function parameters, defaults, and log debug info
my ($strOperation) = logDebugParam (OP_RESTORE_PROCESS);
# Make sure that Postgres is not running
if ($self->{oFile}->exists(PATH_DB_ABSOLUTE, $self->{strDbClusterPath} . '/' . FILE_POSTMASTER_PID))
{
@ -596,10 +671,10 @@ sub restore
}
# Log the backup set to restore
&log(INFO, "restore backup set " . $self->{strBackupPath});
&log(INFO, "restore backup set " . $self->{strBackupSet});
# Make sure the backup path is valid and load the manifest
my $oManifest = $self->manifest_load();
my $oManifest = $self->manifestLoad();
# Delete pg_control file. This will be copied from the backup at the very end to prevent a partially restored database
# from being started by PostgreSQL.
@ -614,8 +689,8 @@ sub restore
$self->build($oManifest);
# Get variables required for restore
my $lCopyTimeBegin = $oManifest->getNumeric(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_TIMESTAMP_COPY_START);
my $bSourceCompression = $oManifest->getBool(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_COMPRESS);
my $lCopyTimeBegin = $oManifest->numericGet(MANIFEST_SECTION_BACKUP, MANIFEST_KEY_TIMESTAMP_COPY_START);
my $bSourceCompression = $oManifest->boolGet(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_COMPRESS);
my $strCurrentUser = getpwuid($<);
my $strCurrentGroup = getgrgid($();
@ -640,7 +715,7 @@ sub restore
next;
}
my $lSize = $oManifest->getNumeric($strSection, $strFile, MANIFEST_SUBKEY_SIZE);
my $lSize = $oManifest->numericGet($strSection, $strFile, MANIFEST_SUBKEY_SIZE);
$lSizeTotal += $lSize;
# Preface the file key with the size. This allows for sorting the files to restore by size.
@ -667,10 +742,10 @@ sub restore
$oRestoreHash{$strPathKey}{$strFileKey}{destination_path} =
$oManifest->get(MANIFEST_SECTION_BACKUP_PATH, $strPathKey, MANIFEST_SUBKEY_PATH);
$oRestoreHash{$strPathKey}{$strFileKey}{reference} =
$oManifest->testBool(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_HARDLINK, undef, true) ? undef :
$oManifest->boolTest(MANIFEST_SECTION_BACKUP_OPTION, MANIFEST_KEY_HARDLINK, undef, true) ? undef :
$oManifest->get($strSection, $strFile, MANIFEST_SUBKEY_REFERENCE, false);
$oRestoreHash{$strPathKey}{$strFileKey}{modification_time} =
$oManifest->getNumeric($strSection, $strFile, MANIFEST_SUBKEY_TIMESTAMP);
$oManifest->numericGet($strSection, $strFile, MANIFEST_SUBKEY_TIMESTAMP);
$oRestoreHash{$strPathKey}{$strFileKey}{mode} =
$oManifest->get($strSection, $strFile, MANIFEST_SUBKEY_MODE);
$oRestoreHash{$strPathKey}{$strFileKey}{user} =
@ -689,9 +764,13 @@ sub restore
}
# If multi-threaded then create threads to copy files
if ($self->{iThreadTotal} > 1)
if (optionGet(OPTION_THREAD_MAX) > 1)
{
&log(DEBUG, "starting restore with $self->{iThreadTotal} threads");
logDebugMisc
(
$strOperation, 'restore with threads',
{name => 'iThreadTotal', value => optionGet(OPTION_THREAD_MAX)}
);
# Initialize the thread queues
my @oyRestoreQueue;
@ -714,16 +793,16 @@ sub restore
$oParam{copy_time_begin} = $lCopyTimeBegin;
$oParam{size_total} = $lSizeTotal;
$oParam{delta} = $self->{bDelta};
$oParam{force} = $self->{bForce};
$oParam{backup_path} = $self->{strBackupPath};
$oParam{delta} = optionGet(OPTION_DELTA);
$oParam{force} = optionGet(OPTION_FORCE);
$oParam{backup_path} = $self->{strBackupSet};
$oParam{source_compression} = $bSourceCompression;
$oParam{current_user} = $strCurrentUser;
$oParam{current_group} = $strCurrentGroup;
$oParam{queue} = \@oyRestoreQueue;
# Run the threads
for (my $iThreadIdx = 0; $iThreadIdx < $self->{iThreadTotal}; $iThreadIdx++)
for (my $iThreadIdx = 0; $iThreadIdx < optionGet(OPTION_THREAD_MAX); $iThreadIdx++)
{
threadGroupRun($iThreadIdx, 'restore', \%oParam);
}
@ -733,7 +812,7 @@ sub restore
}
else
{
&log(DEBUG, "starting restore in main process");
logDebugMisc($strOperation, 'restore in main process');
# Restore file in main process
foreach my $strPathKey (sort (keys %oRestoreHash))
@ -743,8 +822,8 @@ sub restore
# Skip files marked to be copied later
next if ($oRestoreHash{$strPathKey}{$strFileKey}{skip});
$lSizeCurrent = restoreFile($oRestoreHash{$strPathKey}{$strFileKey}, $lCopyTimeBegin, $self->{bDelta},
$self->{bForce}, $self->{strBackupPath}, $bSourceCompression, $strCurrentUser,
$lSizeCurrent = restoreFile($oRestoreHash{$strPathKey}{$strFileKey}, $lCopyTimeBegin, optionGet(OPTION_DELTA),
optionGet(OPTION_FORCE), $self->{strBackupSet}, $bSourceCompression, $strCurrentUser,
$strCurrentGroup, $self->{oFile}, $lSizeTotal, $lSizeCurrent);
}
}
@ -756,11 +835,12 @@ sub restore
# Copy pg_control last
&log(INFO, 'restore ' . FILE_PG_CONTROL . ' (copied last to ensure aborted restores cannot be started)');
restoreFile($oRestoreHash{&MANIFEST_KEY_BASE}{&FILE_PG_CONTROL}, $lCopyTimeBegin, $self->{bDelta}, $self->{bForce},
$self->{strBackupPath}, $bSourceCompression, $strCurrentUser, $strCurrentGroup, $self->{oFile}, $lSizeTotal,
$lSizeCurrent);
restoreFile($oRestoreHash{&MANIFEST_KEY_BASE}{&FILE_PG_CONTROL}, $lCopyTimeBegin, optionGet(OPTION_DELTA),
optionGet(OPTION_FORCE), $self->{strBackupSet}, $bSourceCompression, $strCurrentUser, $strCurrentGroup,
$self->{oFile}, $lSizeTotal, $lSizeCurrent);
&log(INFO, 'restore complete');
# Return from function and log return values if any
return logDebugReturn($strOperation);
}
1;

76
lib/BackRest/RestoreFile.pm
View File

@ -11,15 +11,24 @@ use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
use File::stat qw(lstat);
use lib dirname($0);
use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Common::String;
use BackRest::Config;
use BackRest::Exception;
use BackRest::File;
use BackRest::Manifest;
use BackRest::Utility;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_RESTORE_FILE => 'RestoreFile';
use constant OP_RESTORE_FILE_RESTORE_FILE => OP_RESTORE_FILE . '::restoreFile';
####################################################################################################################################
# restoreFile
@ -29,19 +38,39 @@ use BackRest::Utility;
sub restoreFile
{
my $oFileHash = shift; # File to restore
my $lCopyTimeBegin = shift; # Time that the backup begain - used for size/timestamp deltas
my $bDelta = shift; # Is restore a delta?
my $bForce = shift; # Force flag
my $strBackupPath = shift; # Backup path
my $bSourceCompression = shift; # Is the source compressed?
my $strCurrentUser = shift; # Current OS user
my $strCurrentGroup = shift; # Current OS group
my $oFile = shift; # File object
my $lSizeTotal = shift; # Total size of files to be restored
my $lSizeCurrent = shift; # Current size of files restored
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$lCopyTimeBegin, # Time that the backup begain - used for size/timestamp deltas
$bDelta, # Is restore a delta?
$bForce, # Force flag
$strBackupPath, # Backup path
$bSourceCompression, # Is the source compressed?
$strCurrentUser, # Current OS user
$strCurrentGroup, # Current OS group
$oFile, # File object
$lSizeTotal, # Total size of files to be restored
$lSizeCurrent # Current size of files restored
) =
logDebugParam
(
OP_RESTORE_FILE_RESTORE_FILE, \@_,
{name => 'lCopyTimeBegin', trace => true},
{name => 'bDelta', trace => true},
{name => 'bForce', trace => true},
{name => 'strBackupPath', trace => true},
{name => 'bSourceCompression', trace => true},
{name => 'strCurrentUser', trace => true},
{name => 'strCurrentGroup', trace => true},
{name => 'oFile', trace => true},
{name => 'lSizeTotal', trace => true},
{name => 'lSizeCurrent', trace => true}
);
# Generate destination file name
my $strDestinationFile = $oFile->path_get(PATH_DB_ABSOLUTE, "$$oFileHash{destination_path}/$$oFileHash{file}");
my $strDestinationFile = $oFile->pathGet(PATH_DB_ABSOLUTE, "$$oFileHash{destination_path}/$$oFileHash{file}");
# Copy flag and log message
my $bCopy = true;
@ -62,18 +91,17 @@ sub restoreFile
if (defined($oStat) && $oStat->size == $$oFileHash{size} &&
$oStat->mtime == $$oFileHash{modification_time} && $oStat->mtime < $lCopyTimeBegin)
{
$strLog = "${strDestinationFile} exists and matches size " . $oStat->size .
" and modification time " . $oStat->mtime;
$strLog = 'exists and matches size ' . $oStat->size . ' and modification time ' . $oStat->mtime;
$bCopy = false;
}
}
else
{
my ($strChecksum, $lSize) = $oFile->hash_size(PATH_DB_ABSOLUTE, $strDestinationFile);
my ($strChecksum, $lSize) = $oFile->hashSize(PATH_DB_ABSOLUTE, $strDestinationFile);
if ($lSize == $$oFileHash{size} && ($lSize == 0 || $strChecksum eq $$oFileHash{checksum}))
{
$strLog = "exists and " . ($lSize == 0 ? 'is zero size' : "matches backup");
$strLog = 'exists and ' . ($lSize == 0 ? 'is zero size' : "matches backup");
# Even if hash is the same set the time back to backup time. This helps with unit testing, but also
# presents a pristine version of the database after restore.
@ -107,17 +135,21 @@ sub restoreFile
confess &log(ERROR, "error restoring ${strDestinationFile}: actual checksum ${strCopyChecksum} " .
"does not match expected checksum $$oFileHash{checksum}", ERROR_CHECKSUM);
}
$strLog = "restore";
}
&log(INFO, "${strDestinationFile} ${strLog} (" . file_size_format($$oFileHash{size}) .
&log(INFO, "restore file ${strDestinationFile}" . (defined($strLog) ? " - ${strLog}" : '') .
' (' . fileSizeFormat($$oFileHash{size}) .
($lSizeTotal > 0 ? ', ' . int($lSizeCurrent * 100 / $lSizeTotal) . '%' : '') . ')' .
($$oFileHash{size} != 0 ? " checksum $$oFileHash{checksum}" : ''));
return $lSizeCurrent;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'lSizeCurrent', value => $lSizeCurrent, trace => true}
);
}
our @EXPORT = qw(restoreFile);
push @EXPORT, qw(restoreFile);
1;

3
lib/BackRest/Version.pm
View File

@ -9,6 +9,7 @@ use strict;
use warnings FATAL => qw(all);
use Exporter qw(import);
our @EXPORT = qw();
# BackRest Version Number
#
@ -18,7 +19,7 @@ use Exporter qw(import);
our # 'our' keyword is on a separate line to make the ExtUtils::MakeMaker parser happy.
$VERSION = '0.85';
our @EXPORT = qw($VERSION);
push @EXPORT, qw($VERSION);
# Format Format Number
#

23
test/lib/BackRestTest/BackupCommonTest.pm
View File

@ -22,12 +22,13 @@ use Time::HiRes qw(gettimeofday);
use lib dirname($0) . '/../lib';
use BackRest::Archive;
use BackRest::ArchiveInfo;
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Common::Wait;
use BackRest::Config;
use BackRest::Exception;
use BackRest::File;
use BackRest::Ini;
use BackRest::Manifest;
use BackRest::Utility;
use BackRestTest::CommonTest;
@ -1092,7 +1093,7 @@ sub BackRestTestBackup_BackupCompare
}
my %oActualManifest;
iniLoad($oFile->path_get(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, \%oActualManifest);
iniLoad($oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, \%oActualManifest);
${$oExpectedManifestRef}{&MANIFEST_SECTION_BACKUP}{&MANIFEST_KEY_TIMESTAMP_START} =
$oActualManifest{&MANIFEST_SECTION_BACKUP}{&MANIFEST_KEY_TIMESTAMP_START};
@ -1149,12 +1150,12 @@ sub BackRestTestBackup_ManifestMunge
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 750 ' . BackRestTestCommon_RepoPathGet(), true);
BackRestTestCommon_Execute('chmod 770 ' . $oFile->path_get(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, true);
BackRestTestCommon_Execute('chmod 770 ' . $oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, true);
}
# Read the manifest
my %oManifest;
iniLoad($oFile->path_get(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, \%oManifest);
iniLoad($oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, \%oManifest);
# Write in the munged value
if (defined($strSubKey))
@ -1191,12 +1192,12 @@ sub BackRestTestBackup_ManifestMunge
$oManifest{&INI_SECTION_BACKREST}{&INI_KEY_CHECKSUM} = $oSHA->hexdigest();
# Resave the manifest
iniSave($oFile->path_get(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, \%oManifest);
iniSave($oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, \%oManifest);
# Change mode on the backup path back before unit tests continue
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 750 ' . $oFile->path_get(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, true);
BackRestTestCommon_Execute('chmod 750 ' . $oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, true);
BackRestTestCommon_Execute('chmod 700 ' . BackRestTestCommon_RepoPathGet(), true);
}
}
@ -1418,11 +1419,11 @@ sub BackRestTestBackup_RestoreCompare
$oActualManifest->set(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_DB_VERSION, undef,
${$oExpectedManifestRef}{&MANIFEST_SECTION_BACKUP_DB}{&MANIFEST_KEY_DB_VERSION});
$oActualManifest->setNumeric(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_CONTROL, undef,
$oActualManifest->numericSet(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_CONTROL, undef,
${$oExpectedManifestRef}{&MANIFEST_SECTION_BACKUP_DB}{&MANIFEST_KEY_CONTROL});
$oActualManifest->setNumeric(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_CATALOG, undef,
$oActualManifest->numericSet(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_CATALOG, undef,
${$oExpectedManifestRef}{&MANIFEST_SECTION_BACKUP_DB}{&MANIFEST_KEY_CATALOG});
$oActualManifest->setNumeric(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_SYSTEM_ID, undef,
$oActualManifest->numericSet(MANIFEST_SECTION_BACKUP_DB, MANIFEST_KEY_SYSTEM_ID, undef,
${$oExpectedManifestRef}{&MANIFEST_SECTION_BACKUP_DB}{&MANIFEST_KEY_SYSTEM_ID});
$oActualManifest->set(INI_SECTION_BACKREST, INI_KEY_VERSION, undef,

27
test/lib/BackRestTest/BackupTest.pm
View File

@ -22,15 +22,16 @@ use Time::HiRes qw(gettimeofday);
use lib dirname($0) . '/../lib';
use BackRest::Archive;
use BackRest::ArchiveInfo;
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Common::Wait;
use BackRest::Db;
use BackRest::Config;
use BackRest::Exception;
use BackRest::File;
use BackRest::Ini;
use BackRest::Manifest;
use BackRest::Protocol::Common;
use BackRest::Protocol::RemoteMaster;
use BackRest::Utility;
use BackRestTest::BackupCommonTest;
use BackRestTest::CommonTest;
@ -188,7 +189,7 @@ sub BackRestTestBackup_Test
if ($iArchive == $iBackup)
{
# load the archive info file so it can be munged for testing
my $strInfoFile = $oFile->path_get(PATH_BACKUP_ARCHIVE, ARCHIVE_INFO_FILE);
my $strInfoFile = $oFile->pathGet(PATH_BACKUP_ARCHIVE, ARCHIVE_INFO_FILE);
my %oInfo;
BackRestTestCommon_iniLoad($strInfoFile, \%oInfo, $bRemote);
my $strDbVersion = $oInfo{&INFO_ARCHIVE_SECTION_DB}{&INFO_ARCHIVE_KEY_DB_VERSION};
@ -272,7 +273,7 @@ sub BackRestTestBackup_Test
# !!! Need to put in tests for .backup files here
}
BackRestTestCommon_TestLogAppendFile($oFile->path_get(PATH_BACKUP_ARCHIVE) . '/archive.info', $bRemote);
BackRestTestCommon_TestLogAppendFile($oFile->pathGet(PATH_BACKUP_ARCHIVE) . '/archive.info', $bRemote);
}
}
@ -370,7 +371,7 @@ sub BackRestTestBackup_Test
archivePush($oFile, $strXlogPath, $strArchiveTestFile, 1);
# load the archive info file so it can be munged for testing
my $strInfoFile = $oFile->path_get(PATH_BACKUP_ARCHIVE, ARCHIVE_INFO_FILE);
my $strInfoFile = $oFile->pathGet(PATH_BACKUP_ARCHIVE, ARCHIVE_INFO_FILE);
my %oInfo;
BackRestTestCommon_iniLoad($strInfoFile, \%oInfo, $bRemote);
my $strDbVersion = $oInfo{&INFO_ARCHIVE_SECTION_DB}{&INFO_ARCHIVE_KEY_DB_VERSION};
@ -490,9 +491,9 @@ sub BackRestTestBackup_Test
BackRestTestCommon_Execute("chmod g+r,g+x " . BackRestTestCommon_RepoPathGet(), $bRemote);
}
BackRestTestCommon_Execute('mkdir -p -m 770 ' . $oFile->path_get(PATH_BACKUP_ARCHIVE), $bRemote);
(new BackRest::ArchiveInfo($oFile->path_get(PATH_BACKUP_ARCHIVE)))->check('9.3', 1234567890123456789);
BackRestTestCommon_TestLogAppendFile($oFile->path_get(PATH_BACKUP_ARCHIVE) . '/archive.info', $bRemote);
BackRestTestCommon_Execute('mkdir -p -m 770 ' . $oFile->pathGet(PATH_BACKUP_ARCHIVE), $bRemote);
(new BackRest::ArchiveInfo($oFile->pathGet(PATH_BACKUP_ARCHIVE)))->check('9.3', 1234567890123456789);
BackRestTestCommon_TestLogAppendFile($oFile->pathGet(PATH_BACKUP_ARCHIVE) . '/archive.info', $bRemote);
if ($bRemote)
{
@ -646,7 +647,7 @@ sub BackRestTestBackup_Test
"/backup/${strStanza}/backup.info", false);
# Create an archive log path that will be removed as old on the first archive expire call
$oFile->path_create(PATH_BACKUP_ARCHIVE, BackRestTestCommon_DbVersion() . '-1/0000000000000000');
$oFile->pathCreate(PATH_BACKUP_ARCHIVE, BackRestTestCommon_DbVersion() . '-1/0000000000000000');
# Get the expected archive list
my @stryArchiveExpected = $oFile->list(PATH_BACKUP_ARCHIVE, BackRestTestCommon_DbVersion() . '-1/0000000100000000');
@ -922,6 +923,8 @@ sub BackRestTestBackup_Test
'add tablespace 1');
# Resume Incr Backup
#
# Links are removed in the resume because it's easy to recreate them.
#-----------------------------------------------------------------------------------------------------------------------
$strType = 'incr';
@ -1626,7 +1629,7 @@ sub BackRestTestBackup_Test
# Sleep .5 seconds to give a reasonable amount of time for the file to be copied after the manifest was generated
# Sleep for a while to show there is a large window where this can happen
&log(INFO, 'time ' . gettimeofday());
hsleep(.5);
waitHiRes(.5);
&log(INFO, 'time ' . gettimeofday());
# Insert another row
@ -1718,7 +1721,7 @@ sub BackRestTestBackup_Test
# Sleep for a while to show there is a large window where this can happen
&log(INFO, 'time ' . gettimeofday());
hsleep(.5);
waitHiRes(.5);
&log(INFO, 'time ' . gettimeofday());
# Modify the test file within the same second

26
test/lib/BackRestTest/CommonTest.pm
View File

@ -21,12 +21,14 @@ use IPC::Open3;
use POSIX ':sys_wait_h';
use lib dirname($0) . '/../lib';
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Common::String;
use BackRest::Common::Wait;
use BackRest::Config;
use BackRest::Db;
use BackRest::File;
use BackRest::Ini;
use BackRest::Manifest;
use BackRest::Utility;
our @EXPORT = qw(BackRestTestCommon_Create BackRestTestCommon_Drop BackRestTestCommon_Setup BackRestTestCommon_ExecuteBegin
BackRestTestCommon_ExecuteEnd BackRestTestCommon_Execute BackRestTestCommon_ExecuteBackRest
@ -119,7 +121,7 @@ sub BackRestTestCommon_DropRepo
{
BackRestTestCommon_PathRemove(BackRestTestCommon_RepoPathGet(), true, true);
BackRestTestCommon_PathRemove(BackRestTestCommon_RepoPathGet(), false, true);
hsleep(.1);
waitHiRes(.1);
}
}
@ -322,7 +324,8 @@ sub BackRestTestCommon_ExecuteBegin
$bFullLog = false;
if (defined($strModule) && $strCommandParam =~ /^$strCommonCommandMain/)
if (defined($strModule) &&
($strCommandParam =~ /$strCommonCommandMain/ || $strCommandParam =~ /$strCommonCommandRemote/))
{
$strCommandParam = BackRestTestCommon_ExecuteRegExpAll($strCommandParam);
@ -423,6 +426,7 @@ sub BackRestTestCommon_ExecuteRegExpAll
my $strBinPath = dirname(dirname(abs_path($0))) . '/bin';
$strLine =~ s/$strCommonCommandMain/[BACKREST_BIN]/g;
$strLine =~ s/$strCommonCommandRemote/[BACKREST_BIN]/g;
$strLine =~ s/$strPgSqlBin/[PGSQL_BIN_PATH]/g;
my $strTestPath = BackRestTestCommon_TestPathGet();
@ -432,16 +436,16 @@ sub BackRestTestCommon_ExecuteRegExpAll
$strLine =~ s/$strTestPath/[TEST_PATH]/g;
}
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'MODIFICATION-TIME', 'modification_time = [0-9]+', '[0-9]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'MODIFICATION-TIME', 'lModificationTime = [0-9]+', '[0-9]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'TIMESTAMP', 'timestamp"[ ]{0,1}:[ ]{0,1}[0-9]+','[0-9]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'BACKUP-INCR', '[0-9]{8}\-[0-9]{6}F\_[0-9]{8}\-[0-9]{6}I');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'BACKUP-DIFF', '[0-9]{8}\-[0-9]{6}F\_[0-9]{8}\-[0-9]{6}D');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'BACKUP-FULL', '[0-9]{8}\-[0-9]{6}F');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'GROUP', 'group = [^ \n,\[\]]+', '[^ \n,\[\]]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'GROUP', 'strGroup = [^ \n,\[\]]+', '[^ \n,\[\]]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'GROUP', 'group"[ ]{0,1}:[ ]{0,1}"[^"]+', '[^"]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'USER', 'user = [^ \n,\[\]]+', '[^ \n,\[\]]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'USER', 'strUser = [^ \n,\[\]]+', '[^ \n,\[\]]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'USER', 'user"[ ]{0,1}:[ ]{0,1}"[^"]+', '[^"]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'USER', '^db-user=.+$', '[^=]+$');
@ -516,7 +520,7 @@ sub BackRestTestCommon_ExecuteEnd
{
$strOutLog .= $strLine;
if (defined($strTest) && test_check($strLine, $strTest))
if (defined($strTest) && testCheck($strLine, $strTest))
{
&log(DEBUG, "Found test ${strTest}");
return true;
@ -807,11 +811,11 @@ sub BackRestTestCommon_Setup
}
# Don't run unit tests for unsupported versions
my $strVersionSupport = versionSupport();
my @stryVersionSupport = versionSupport();
if ($strCommonDbVersion < ${$strVersionSupport}[0])
if ($strCommonDbVersion < $stryVersionSupport[0])
{
confess "currently only version ${$strVersionSupport}[0] and up are supported";
confess "currently only version $stryVersionSupport[0] and up are supported";
}
return true;

4
test/lib/BackRestTest/CompareTest.pm
View File

@ -17,7 +17,7 @@ use File::stat;
use Time::HiRes qw(gettimeofday);
use lib dirname($0) . '/../lib';
use BackRest::Utility;
use BackRest::Common::Log;
use BackRestTest::BackupTest;
use BackRestTest::CommonTest;
@ -35,7 +35,7 @@ sub BackRestTestCompare_BuildDb
my $iTableTotal = shift;
my $iTableSize = shift;
&log(INFO, "build database: " . file_size_format($iTableTotal * $iTableSize * 1024 * 1024));
&log(INFO, "build database: " . fileSizeFormat($iTableTotal * $iTableSize * 1024 * 1024));
for (my $iTableIdx = 0; $iTableIdx < $iTableTotal; $iTableIdx++)
{

30
test/lib/BackRestTest/ConfigTest.pm
View File

@ -17,10 +17,10 @@ use File::Basename qw(dirname);
use Scalar::Util qw(blessed);
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::Exception;
use BackRest::Ini;
use BackRest::Utility;
use BackRestTest::CommonTest;
@ -33,7 +33,7 @@ sub optionSetTest
$$oOption{option}{$strKey} = $strValue;
}
sub optionSetBoolTest
sub optionboolSetTest
{
my $oOption = shift;
my $strKey = shift;
@ -123,7 +123,7 @@ sub configLoadExpect
my $oMessage = $@;
if (blessed($oMessage) && $oMessage->isa('BackRest::Exception'))
if (blessed($oMessage) && $oMessage->isa('BackRest::Common::Exception'))
{
if ($oMessage->code() != $iExpectedError)
{
@ -184,7 +184,7 @@ sub configLoadExpect
}
else
{
confess "configLoad should throw BackRest::Exception:\n$oMessage";
confess "configLoad should throw BackRest::Common::Exception:\n$oMessage";
}
}
else
@ -273,7 +273,7 @@ sub BackRestTestConfig_Test
if (BackRestTestCommon_Run(++$iRun, 'backup with boolean stanza'))
{
optionSetBoolTest($oOption, OPTION_STANZA);
optionboolSetTest($oOption, OPTION_STANZA);
configLoadExpect($oOption, CMD_BACKUP, ERROR_COMMAND_REQUIRED);
}
@ -310,7 +310,7 @@ sub BackRestTestConfig_Test
{
optionSetTest($oOption, OPTION_STANZA, $strStanza);
optionSetTest($oOption, OPTION_DB_PATH, '/db');
optionSetBoolTest($oOption, OPTION_FORCE);
optionboolSetTest($oOption, OPTION_FORCE);
configLoadExpect($oOption, CMD_BACKUP, ERROR_OPTION_INVALID, OPTION_FORCE, OPTION_NO_START_STOP);
}
@ -320,8 +320,8 @@ sub BackRestTestConfig_Test
# $oOption = {};
optionSetTest($oOption, OPTION_STANZA, $strStanza);
optionSetTest($oOption, OPTION_DB_PATH, '/db');
optionSetBoolTest($oOption, OPTION_NO_START_STOP);
optionSetBoolTest($oOption, OPTION_FORCE);
optionboolSetTest($oOption, OPTION_NO_START_STOP);
optionboolSetTest($oOption, OPTION_FORCE);
configLoadExpect($oOption, CMD_BACKUP);
optionTestExpect(OPTION_NO_START_STOP, true);
@ -332,7 +332,7 @@ sub BackRestTestConfig_Test
{
optionSetTest($oOption, OPTION_STANZA, $strStanza);
optionSetTest($oOption, OPTION_DB_PATH, '/db');
optionSetBoolTest($oOption, OPTION_TEST);
optionboolSetTest($oOption, OPTION_TEST);
optionSetTest($oOption, OPTION_TEST_DELAY, BOGUS);
configLoadExpect($oOption, CMD_BACKUP, ERROR_OPTION_INVALID_VALUE, BOGUS, OPTION_TEST_DELAY);
@ -409,7 +409,7 @@ sub BackRestTestConfig_Test
{
optionSetTest($oOption, OPTION_STANZA, $strStanza);
optionSetTest($oOption, OPTION_DB_PATH, '/db');
optionSetBoolTest($oOption, OPTION_TEST);
optionboolSetTest($oOption, OPTION_TEST);
optionSetTest($oOption, OPTION_TEST_DELAY, '0.25');
configLoadExpect($oOption, CMD_BACKUP);
@ -419,7 +419,7 @@ sub BackRestTestConfig_Test
{
optionSetTest($oOption, OPTION_STANZA, $strStanza);
optionSetTest($oOption, OPTION_DB_PATH, '/db');
optionSetBoolTest($oOption, OPTION_TEST);
optionboolSetTest($oOption, OPTION_TEST);
optionSetTest($oOption, OPTION_TEST_DELAY, 3);
configLoadExpect($oOption, CMD_BACKUP);
@ -556,7 +556,7 @@ sub BackRestTestConfig_Test
optionSetTest($oOption, OPTION_STANZA, $strStanza);
optionSetTest($oOption, OPTION_DB_PATH, '/db');
optionSetTest($oOption, OPTION_CONFIG, '/dude/dude.conf');
optionSetBoolTest($oOption, OPTION_CONFIG, false);
optionboolSetTest($oOption, OPTION_CONFIG, false);
configLoadExpect($oOption, CMD_BACKUP, ERROR_OPTION_NEGATE, OPTION_CONFIG);
}
@ -565,7 +565,7 @@ sub BackRestTestConfig_Test
{
optionSetTest($oOption, OPTION_STANZA, $strStanza);
optionSetTest($oOption, OPTION_DB_PATH, '/db');
optionSetBoolTest($oOption, OPTION_CONFIG, false);
optionboolSetTest($oOption, OPTION_CONFIG, false);
configLoadExpect($oOption, CMD_BACKUP);
optionTestExpect(OPTION_CONFIG);

20
test/lib/BackRestTest/FileTest.pm
View File

@ -21,11 +21,11 @@ use Scalar::Util qw(blessed);
use Time::HiRes qw(gettimeofday usleep);
use lib dirname($0) . '/../lib';
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::File;
use BackRest::Protocol::Common;
use BackRest::Protocol::RemoteMaster;
use BackRest::Utility;
use BackRestTest::CommonTest;
@ -121,7 +121,7 @@ sub BackRestTestFile_Test
{
$iRun = 0;
&log(INFO, "Test File->path_create()\n");
&log(INFO, "Test File->pathCreate()\n");
# Loop through local/remote
for (my $bRemote = 0; $bRemote <= 1; $bRemote++)
@ -175,7 +175,7 @@ sub BackRestTestFile_Test
eval
{
$oFile->path_create($strPathType, $strPath, $strMode);
$oFile->pathCreate($strPathType, $strPath, $strMode);
};
# Check for errors
@ -196,7 +196,7 @@ sub BackRestTestFile_Test
}
# Make sure the path was actually created
my $strPathCheck = $oFile->path_get($strPathType, $strPath);
my $strPathCheck = $oFile->pathGet($strPathType, $strPath);
unless (-e $strPathCheck)
{
@ -365,7 +365,7 @@ sub BackRestTestFile_Test
elsif ($bExists)
{
system("echo 'TESTDATA' > ${strFile}");
($strSourceHash, $iSourceSize) = $oFile->hash_size(PATH_BACKUP_ABSOLUTE, $strFile);
($strSourceHash, $iSourceSize) = $oFile->hashSize(PATH_BACKUP_ABSOLUTE, $strFile);
}
# Execute in eval in case of error
@ -403,7 +403,7 @@ sub BackRestTestFile_Test
system("gzip -d ${strDestinationFile}") == 0 or die "could not decompress ${strDestinationFile}";
my ($strDestinationHash, $iDestinationSize) = $oFile->hash_size(PATH_BACKUP_ABSOLUTE, $strFile);
my ($strDestinationHash, $iDestinationSize) = $oFile->hashSize(PATH_BACKUP_ABSOLUTE, $strFile);
if ($strSourceHash ne $strDestinationHash)
{
@ -918,7 +918,7 @@ sub BackRestTestFile_Test
eval
{
($strHash, $iSize) = $oFile->hash_size(PATH_BACKUP_ABSOLUTE, $strFile, $bCompressed)
($strHash, $iSize) = $oFile->hashSize(PATH_BACKUP_ABSOLUTE, $strFile, $bCompressed)
};
if ($@)
@ -1006,7 +1006,7 @@ sub BackRestTestFile_Test
if (blessed($oMessage))
{
if ($oMessage->isa('BackRest::Exception'))
if ($oMessage->isa('BackRest::Common::Exception'))
{
$iCode = $oMessage->code();
$strMessage = $oMessage->message();
@ -1203,7 +1203,7 @@ sub BackRestTestFile_Test
if (blessed($oMessage))
{
if ($oMessage->isa('BackRest::Exception'))
if ($oMessage->isa('BackRest::Common::Exception'))
{
if ($bSourceMissing && !$bSourceIgnoreMissing)
{
@ -1269,7 +1269,7 @@ sub BackRestTestFile_Test
or die "could not decompress ${strDestinationFile}";
}
my ($strDestinationHash, $iDestinationSize) = $oFile->hash_size(PATH_ABSOLUTE, $strDestinationTest);
my ($strDestinationHash, $iDestinationSize) = $oFile->hashSize(PATH_ABSOLUTE, $strDestinationTest);
if ($strSourceHash ne $strDestinationHash || $strSourceHash ne $strCopyHash)
{

16
test/lib/BackRestTest/UtilityTest.pm → test/lib/BackRestTest/IniTest.pm
View File

@ -1,8 +1,8 @@
#!/usr/bin/perl
####################################################################################################################################
# UtilityTest.pl - Unit Tests for BackRest::Utility
# IniTest.pm - Unit Tests for ini load and save
####################################################################################################################################
package BackRestTest::UtilityTest;
package BackRestTest::IniTest;
####################################################################################################################################
# Perl includes
@ -15,19 +15,19 @@ use Exporter qw(import);
use File::Basename qw(dirname);
use lib dirname($0) . '/../lib';
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Config;
use BackRest::File;
use BackRest::Ini;
use BackRest::Utility;
use BackRestTest::CommonTest;
####################################################################################################################################
# BackRestTestUtility_Test
# BackRestTestIni_Test
####################################################################################################################################
our @EXPORT = qw(BackRestTestUtility_Test);
our @EXPORT = qw(BackRestTestIni_Test);
sub BackRestTestUtility_Test
sub BackRestTestIni_Test
{
my $strTest = shift;
@ -37,7 +37,7 @@ sub BackRestTestUtility_Test
my $strTestPath = BackRestTestCommon_TestPathGet();
# Print test banner
&log(INFO, 'UTILITY MODULE ******************************************************************');
&log(INFO, 'INI MODULE ******************************************************************');
#-------------------------------------------------------------------------------------------------------------------------------
# Create remote

32
test/log/backup-archive-get-001.log
View File

@ -3,12 +3,16 @@ run 001 - rmt 0, cmp 0, exists 0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-get start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
ERROR: [130]: archive.info does not exist but is required to get WAL segments
HINT: Is archive_command configured in postgresql.conf?
HINT: Use --no-archive-check to disable archive checks during backup if you have an alternate archiving scheme.
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 130
INFO: archive-get stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@ -27,10 +31,18 @@ db-version="9.3"
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000090000000900000009
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, expression ^000000090000000900000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->exists: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009
INFO: 000000090000000900000009 was not found in the archive repository
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000090000000900000009
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG, strSourceArchive = 000000090000000900000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000090000000900000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000090000000900000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, strPathType = backup:absolute
DEBUG: File->exists=>: bExists = false
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
INFO: unable to find 000000090000000900000009 in the archive
DEBUG: Archive->get=>: iResult = 1
DEBUG: Main::safeExit(): iExitCode = 1
INFO: archive-get stop

79
test/log/backup-archive-get-002.log
View File

@ -3,12 +3,16 @@ run 002 - rmt 0, cmp 0, exists 1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-get start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
ERROR: [130]: archive.info does not exist but is required to get WAL segments
HINT: Is archive_command configured in postgresql.conf?
HINT: Use --no-archive-check to disable archive checks during backup if you have an alternate archiving scheme.
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 130
INFO: archive-get stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@ -27,33 +31,54 @@ db-version="9.3"
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->copy: local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000002 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000002
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->copy: local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000002
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourceArchive = 000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000002
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000003 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000003
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->copy: local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000003
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourceArchive = 000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000003
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop

32
test/log/backup-archive-get-003.log
View File

@ -3,12 +3,16 @@ run 003 - rmt 0, cmp 1, exists 0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-get start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
ERROR: [130]: archive.info does not exist but is required to get WAL segments
HINT: Is archive_command configured in postgresql.conf?
HINT: Use --no-archive-check to disable archive checks during backup if you have an alternate archiving scheme.
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 130
INFO: archive-get stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@ -27,10 +31,18 @@ db-version="9.3"
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000090000000900000009
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, expression ^000000090000000900000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->exists: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009
INFO: 000000090000000900000009 was not found in the archive repository
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000090000000900000009
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG, strSourceArchive = 000000090000000900000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000090000000900000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000090000000900000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, strPathType = backup:absolute
DEBUG: File->exists=>: bExists = false
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
INFO: unable to find 000000090000000900000009 in the archive
DEBUG: Archive->get=>: iResult = 1
DEBUG: Main::safeExit(): iExitCode = 1
INFO: archive-get stop

79
test/log/backup-archive-get-004.log
View File

@ -3,12 +3,16 @@ run 004 - rmt 0, cmp 1, exists 1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-get start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
ERROR: [130]: archive.info does not exist but is required to get WAL segments
HINT: Is archive_command configured in postgresql.conf?
HINT: Use --no-archive-check to disable archive checks during backup if you have an alternate archiving scheme.
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 130
INFO: archive-get stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@ -27,33 +31,54 @@ db-version="9.3"
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->copy: local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, source_compressed = true, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = true, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000002 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000002
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->copy: local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002, source_compressed = true, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000002
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourceArchive = 000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000002
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = true, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000003 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000003
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->copy: local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003, source_compressed = true, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000003
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourceArchive = 000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: ArchiveInfo->new(): bRequired = true, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000003
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = true, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop

33
test/log/backup-archive-get-005.log
View File

@ -3,13 +3,17 @@ run 005 - rmt 1, cmp 0, exists 0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
ERROR: [130]: archive.info does not exist but is required to get WAL segments
HINT: Is archive_command configured in postgresql.conf?
HINT: Use --no-archive-check to disable archive checks during backup if you have an alternate archiving scheme.
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 130
INFO: archive-get stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@ -28,10 +32,17 @@ db-version="9.3"
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000090000000900000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, expression ^000000090000000900000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
INFO: 000000090000000900000009 was not found in the archive repository
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000090000000900000009
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG, strSourceArchive = 000000090000000900000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000090000000900000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000090000000900000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
INFO: unable to find 000000090000000900000009 in the archive
DEBUG: Archive->get=>: iResult = 1
DEBUG: Main::safeExit(): iExitCode = 1
INFO: archive-get stop

84
test/log/backup-archive-get-006.log
View File

@ -3,13 +3,17 @@ run 006 - rmt 1, cmp 0, exists 1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
ERROR: [130]: archive.info does not exist but is required to get WAL segments
HINT: Is archive_command configured in postgresql.conf?
HINT: Use --no-archive-check to disable archive checks during backup if you have an alternate archiving scheme.
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 130
INFO: archive-get stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@ -28,36 +32,54 @@ db-version="9.3"
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->copy: remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000002 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000002
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->copy: remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000002
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourceArchive = 000000010000000100000002
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000002
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000003 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000003
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->copy: remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000003
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourceArchive = 000000010000000100000003
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000003
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop

33
test/log/backup-archive-get-007.log
View File

@ -3,13 +3,17 @@ run 007 - rmt 1, cmp 1, exists 0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
ERROR: [130]: archive.info does not exist but is required to get WAL segments
HINT: Is archive_command configured in postgresql.conf?
HINT: Use --no-archive-check to disable archive checks during backup if you have an alternate archiving scheme.
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 130
INFO: archive-get stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@ -28,10 +32,17 @@ db-version="9.3"
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000090000000900000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, expression ^000000090000000900000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
INFO: 000000090000000900000009 was not found in the archive repository
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000090000000900000009
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG, strSourceArchive = 000000090000000900000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000090000000900000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000090000000900000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000900000009, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
INFO: unable to find 000000090000000900000009 in the archive
DEBUG: Archive->get=>: iResult = 1
DEBUG: Main::safeExit(): iExitCode = 1
INFO: archive-get stop

84
test/log/backup-archive-get-008.log
View File

@ -3,13 +3,17 @@ run 008 - rmt 1, cmp 1, exists 1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
ERROR: [130]: archive.info does not exist but is required to get WAL segments
HINT: Is archive_command configured in postgresql.conf?
HINT: Use --no-archive-check to disable archive checks during backup if you have an alternate archiving scheme.
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 130
INFO: archive-get stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@ -28,36 +32,54 @@ db-version="9.3"
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000001 [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->copy: remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, source_compressed = true, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000001
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourceArchive = 000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = true, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000002 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000002
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->copy: remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002, source_compressed = true, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000002
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourceArchive = 000000010000000100000002
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000002
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = true, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000003 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: getting WAL segment 000000010000000100000003
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->getCheck=>: archiveId = 9.3-1
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: archive_get: cp 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->copy: remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz to local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003, source_compressed = true, destination_compress = false, ignore_missing_source = false, destination_path_create = false, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003.backrest.tmp to absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003, destination_path_create = false
DEBUG: safe exit called, terminating threads
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: get WAL segment 000000010000000100000003
DEBUG: Archive->get(): strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourceArchive = 000000010000000100000003
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000003
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = true, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strSourcePathType = backup:archive, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003.backrest.tmp, strSourcePathType = absolute
DEBUG: Archive->get=>: iResult = 0
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-get stop

564
test/log/backup-archive-push-001.log
View File

@ -3,235 +3,503 @@ run 001 - rmt 0, cmp 0, arc_async 0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->path_create: backup:archive:[TEST_PATH]/backrest/archive/db, mode 0750
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->exists: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = false
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [undef], strPathType = backup:archive
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute
DEBUG: File->exists=>: bExists = false
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000002
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000003
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000004
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000004(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000004 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004, strWalSegment = 000000010000000100000004, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000004
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000004(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000004, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000005
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000005
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000005
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000006(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000006
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000006(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000007
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000007(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000007 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007, strWalSegment = 000000010000000100000007, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000007
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000007(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000007, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000008
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000008(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000008 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008, strWalSegment = 000000010000000100000008, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000008
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000008(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000008, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000009, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
INFO: archive-push start: --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

1068
test/log/backup-archive-push-002.log
View File

File diff suppressed because it is too large Load Diff

564
test/log/backup-archive-push-003.log
View File

@ -3,235 +3,503 @@ run 003 - rmt 0, cmp 1, arc_async 0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->path_create: backup:archive:[TEST_PATH]/backrest/archive/db, mode 0750
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->exists: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = false
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [undef], strPathType = backup:archive
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute
DEBUG: File->exists=>: bExists = false
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000002
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000003
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000004
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000004(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000004 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004, strWalSegment = 000000010000000100000004, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000004
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000004(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000004.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000005
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000005
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000005
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000006(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000006
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000006(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000007
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000007(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000007 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007, strWalSegment = 000000010000000100000007, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000007
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000007(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000007.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000008
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000008(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000008 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008, strWalSegment = 000000010000000100000008, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000008
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000008(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000008.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000009.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009.gz.tmp, strSourcePathType = absolute
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
INFO: archive-push start: --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000009
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz)
DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

1068
test/log/backup-archive-push-004.log
View File

File diff suppressed because it is too large Load Diff

390
test/log/backup-archive-push-005.log
View File

@ -3,207 +3,357 @@ run 005 - rmt 1, cmp 0, arc_async 0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000004
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000004 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004, strWalSegment = 000000010000000100000004, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000004, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000007
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000007 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007, strWalSegment = 000000010000000100000007, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000007, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000008
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000008 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008, strWalSegment = 000000010000000100000008, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000008, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000009, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

917
test/log/backup-archive-push-006.log
View File

File diff suppressed because it is too large Load Diff

390
test/log/backup-archive-push-007.log
View File

@ -3,207 +3,357 @@ run 007 - rmt 1, cmp 1, arc_async 0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000004
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000004 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000004.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004, strWalSegment = 000000010000000100000004, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000004.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000007
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000007 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000007.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007, strWalSegment = 000000010000000100000007, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000007.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000008
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000008 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000008.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008, strWalSegment = 000000010000000100000008, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000008.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000009.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000009.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment system-id 5947969990501855219 does not match archive system-id 5000900090001855000
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum
HINT: this is valid in some recovery scenarios but may also indicate a problem
DEBUG: safe exit called, terminating threads
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushProcess(): bAsync = false, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strWalSegment = 000000010000000100000009, ullDbSysId = 5947969990501855219
DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = [undef], strPathType = db:absolute
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 120
INFO: archive-push stop
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

917
test/log/backup-archive-push-008.log
View File

File diff suppressed because it is too large Load Diff

313
test/log/backup-archive-stop-001.log
View File

@ -3,125 +3,234 @@ run 001 - rmt 0, cmp 0, error version
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/backrest/archive/db/out, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->exists: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000001, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute
DEBUG: File->exists=>: bExists = false
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000002.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --archive-async --archive-max-mb=24 --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000002, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000003.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 2, size 32MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --archive-async --archive-max-mb=24 --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000003, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 2, size = 32MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
ERROR: local archive store max size has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/backrest/lock/db-archive.stop) is removed
DEBUG: safe exit called, terminating threads
ERROR: local archive queue has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/backrest/lock/db-archive.stop) is removed
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --archive-max-mb=24 --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
ERROR: discarding 000000010000000100000004 due to the archive store max size exceeded - remove the archive stop file ([TEST_PATH]/backrest/lock/db-archive.stop) to resume archiving and be sure to take a new backup as soon as possible
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 3, size 48MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: archive 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: transferred 3 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000005, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000002
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000003
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000005
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer=>: lFileTotal = 3
DEBUG: Archive->pushProcess: transferred 3 WAL segments, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000006, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000006.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000006(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000006, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000006
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000006(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop

313
test/log/backup-archive-stop-002.log
View File

@ -3,125 +3,234 @@ run 002 - rmt 0, cmp 1, error version
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/backrest/archive/db/out, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->exists: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000001, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000001
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute
DEBUG: File->exists=>: bExists = false
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000002.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --archive-async --archive-max-mb=24 --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000002, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000003.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 2, size 32MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
INFO: archive-push start: --archive-async --archive-max-mb=24 --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000003, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 2, size = 32MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
ERROR: local archive store max size has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/backrest/lock/db-archive.stop) is removed
DEBUG: safe exit called, terminating threads
ERROR: local archive queue has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/backrest/lock/db-archive.stop) is removed
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --archive-max-mb=24 --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
ERROR: discarding 000000010000000100000004 due to the archive store max size exceeded - remove the archive stop file ([TEST_PATH]/backrest/lock/db-archive.stop) to resume archiving and be sure to take a new backup as soon as possible
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 3, size 48MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: archive 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: transferred 3 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000005, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000002
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000002(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000003
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000003(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000005
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer=>: lFileTotal = 3
DEBUG: Archive->pushProcess: transferred 3 WAL segments, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000006, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000006.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->new(): archiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, expression ^000000010000000100000006(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000006, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: File->exists(): strPath = [undef], strPathType = backup:archive
DEBUG: File->exists=>: bExists = true
DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TEST_PATH]/backrest/archive/db
DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: ArchiveInfo->archiveId=>: strArchiveId = 9.3-1
DEBUG: ArchiveInfo->check=>: strArchiveId = 9.3-1
DEBUG: Archive->walFileName(): iWaitSeconds = [undef], oFile = [object], strArchiveId = 9.3-1, strWalSegment = 000000010000000100000006
DEBUG: File->list(): bIgnoreMissing = true, strExpression = ^000000010000000100000006(-[0-f]+){0,1}(\.gz){0,1}$, strPath = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001, strPathType = backup:absolute, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
DEBUG: Archive->walFileName=>: strWalFileName = [undef]
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp, strSourcePathType = absolute
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/backrest/archive/db/out, strStopFile = [TEST_PATH]/backrest/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/backrest/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop

244
test/log/backup-archive-stop-003.log
View File

@ -3,108 +3,182 @@ run 003 - rmt 1, cmp 0, error version
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/local/archive/db/out, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/local/archive/db/out
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000001, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/local/archive/db/out, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/local/archive/db/out, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000002, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 2, size 32MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000003, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 2, size = 32MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
ERROR: local archive store max size has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/local/lock/db-archive.stop) is removed
DEBUG: safe exit called, terminating threads
ERROR: local archive queue has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/local/lock/db-archive.stop) is removed
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
ERROR: discarding 000000010000000100000004 due to the archive store max size exceeded - remove the archive stop file ([TEST_PATH]/local/lock/db-archive.stop) to resume archiving and be sure to take a new backup as soon as possible
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 3, size 48MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: archive 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 3 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000005, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 3
DEBUG: Archive->pushProcess: transferred 3 WAL segments, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000006, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000006, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop

226
test/log/backup-archive-stop-004.log
View File

@ -3,100 +3,168 @@ run 004 - rmt 1, cmp 0, error connect
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/local/archive/db/out, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/local/archive/db/out
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000001, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/local/archive/db/out, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/local/archive/db/out, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push --backup-host=bogus [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = bogus, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=bogus --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000002, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = bogus, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
ERROR: [124]: protocol version mismatch: ssh: Could not resolve hostname bogus: Name or service not known
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 124
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push --backup-host=bogus [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = bogus, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=bogus --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000003, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = bogus, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
ERROR: [124]: protocol version mismatch: ssh: Could not resolve hostname bogus: Name or service not known
ERROR: local archive store max size has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/local/lock/db-archive.stop) is removed
DEBUG: safe exit called, terminating threads
ERROR: local archive queue has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/local/lock/db-archive.stop) is removed
DEBUG: Main::safeExit(): iExitCode = 124
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
ERROR: discarding 000000010000000100000004 due to the archive store max size exceeded - remove the archive stop file ([TEST_PATH]/local/lock/db-archive.stop) to resume archiving and be sure to take a new backup as soon as possible
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 3, size 48MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: archive 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 3 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000005, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 3
DEBUG: Archive->pushProcess: transferred 3 WAL segments, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000006, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000006, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop

244
test/log/backup-archive-stop-005.log
View File

@ -3,108 +3,182 @@ run 005 - rmt 1, cmp 1, error version
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/local/archive/db/out, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/local/archive/db/out
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000001, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/local/archive/db/out, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/local/archive/db/out, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000002, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 2, size 32MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000003, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 2, size = 32MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
ERROR: [119]: WAL segment version 9.3 does not match archive version 8.0
HINT: are you archiving to the correct stanza?
ERROR: local archive store max size has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/local/lock/db-archive.stop) is removed
DEBUG: safe exit called, terminating threads
ERROR: local archive queue has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/local/lock/db-archive.stop) is removed
DEBUG: Main::safeExit(): iExitCode = 119
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
ERROR: discarding 000000010000000100000004 due to the archive store max size exceeded - remove the archive stop file ([TEST_PATH]/local/lock/db-archive.stop) to resume archiving and be sure to take a new backup as soon as possible
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 3, size 48MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: archive 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 3 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000005, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 3
DEBUG: Archive->pushProcess: transferred 3 WAL segments, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000006, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000006, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop

226
test/log/backup-archive-stop-006.log
View File

@ -3,100 +3,168 @@ run 006 - rmt 1, cmp 1, error connect
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->path_create: absolute:[TEST_PATH]/local/archive/db/out, mode 0750
DEBUG: File->exists: absolute:[TEST_PATH]/local/archive/db/out
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000001, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000001, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [TEST_PATH]/local/archive/db/out, strPathType = absolute
DEBUG: File->exists(): strPath = [TEST_PATH]/local/archive/db/out, strPathType = absolute
DEBUG: File->exists=>: bExists = false
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000001, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push --backup-host=bogus [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000002 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000002, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = bogus, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=bogus --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000002 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000002, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000002, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = bogus, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
ERROR: [124]: protocol version mismatch: ssh: Could not resolve hostname bogus: Name or service not known
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 124
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push --backup-host=bogus [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000003 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000003, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = bogus, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=bogus --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000003 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000003, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000003, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = bogus, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
ERROR: [124]: protocol version mismatch: ssh: Could not resolve hostname bogus: Name or service not known
ERROR: local archive store max size has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/local/lock/db-archive.stop) is removed
DEBUG: safe exit called, terminating threads
ERROR: local archive queue has exceeded limit of 24MB - WAL segments will be discarded until the stop file ([TEST_PATH]/local/lock/db-archive.stop) is removed
DEBUG: Main::safeExit(): iExitCode = 124
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
ERROR: discarding 000000010000000100000004 due to the archive store max size exceeded - remove the archive stop file ([TEST_PATH]/local/lock/db-archive.stop) to resume archiving and be sure to take a new backup as soon as possible
DEBUG: safe exit called, terminating threads
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 3, size 48MB
DEBUG: archive 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000002
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: archive 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000003
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 3 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000005, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000005, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000002, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000003, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000005, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 3
DEBUG: Archive->pushProcess: transferred 3 WAL segments, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --archive-max-mb=24 --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000006 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000006, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: No fork on archive local for TESTING
DEBUG: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: Protocol::RemoteMaster->new(): blockSize = 4194304, command = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, compressLevel = 6, compressLevelNetwork = 3, host = 127.0.0.1, user = [USER-1]
DEBUG: Protocol::CommonMaster->new(): blockSize = 4194304, command = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', compressLevel = 6, compressLevelNetwork = 3, name = remote
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000006
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/9.3-1/0000000100000001/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = 0640, user = [undef], group = [undef]
DEBUG: transferred 1 WAL segment(s), calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: transfer found 0 WAL segments - exiting
DEBUG: safe exit called, terminating threads
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --db-path=[TEST_PATH]/db/common --log-level-console=debug --log-level-file=trace --no-fork --repo-path=[TEST_PATH]/local --repo-remote-path=[TEST_PATH]/backrest --stanza=db
INFO: push WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000006 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000006, strDestinationPathType = backup:archive:out, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000006, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Protocol::RemoteMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = [BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = 127.0.0.1, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBlockSize = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --no-config --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --no-fork --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = backup, strStanza = db
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo(): strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strWalSegment = 000000010000000100000006, ullDbSysId = 5947969990501855219
DEBUG: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = [undef]
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = true, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 9.3-1/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, strDestinationPathType = backup:archive, strGroup = [undef], strMode = <0640>, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strSourcePathType = db:absolute, strUser = [undef]
DEBUG: Archive->xfer=>: lFileTotal = 1
DEBUG: Archive->pushProcess: transferred 1 WAL segment, calling Archive->xfer() again
DEBUG: Archive->xfer(): strArchivePath = [TEST_PATH]/local/archive/db/out, strStopFile = [TEST_PATH]/local/lock/db-archive.stop
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/local/archive/db/out, strPathType = db:absolute
DEBUG: Archive->xfer: no WAL segments to archive
DEBUG: Archive->pushProcess: transfer found 0 WAL segments - exiting
DEBUG: Main::safeExit(): iExitCode = 0
INFO: archive-push stop

2035
test/log/backup-synthetic-001.log
View File

File diff suppressed because it is too large Load Diff

2308
test/log/backup-synthetic-002.log
View File

File diff suppressed because it is too large Load Diff

2048
test/log/backup-synthetic-003.log
View File

File diff suppressed because it is too large Load Diff

2321
test/log/backup-synthetic-004.log
View File

File diff suppressed because it is too large Load Diff

2023
test/log/backup-synthetic-005.log
View File

File diff suppressed because it is too large Load Diff

2296
test/log/backup-synthetic-006.log
View File

File diff suppressed because it is too large Load Diff

2036
test/log/backup-synthetic-007.log
View File

File diff suppressed because it is too large Load Diff

2309
test/log/backup-synthetic-008.log
View File

File diff suppressed because it is too large Load Diff

56
test/test.pl
View File

@ -1,6 +1,6 @@
#!/usr/bin/perl
####################################################################################################################################
# test.pl - BackRest Unit Tests
# test.pl - pgBackRest Unit Tests
####################################################################################################################################
####################################################################################################################################
@ -10,27 +10,27 @@ use strict;
use warnings FATAL => qw(all);
use Carp qw(confess longmess);
# Convert die to confess to capture the stack trace
$SIG{__DIE__} = sub { Carp::confess @_ };
use File::Basename;
use Getopt::Long;
use Cwd 'abs_path';
use Pod::Usage;
use File::Basename qw(dirname);
use Getopt::Long qw(GetOptions);
use Cwd qw(abs_path);
use Pod::Usage qw(pod2usage);
use Scalar::Util qw(blessed);
#use Test::More;
use lib dirname($0) . '/../lib';
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Db;
use BackRest::Ini;
use BackRest::Utility;
use lib dirname($0) . '/lib';
use BackRestTest::BackupTest;
use BackRestTest::CommonTest;
use BackRestTest::UtilityTest;
use BackRestTest::CompareTest;
use BackRestTest::ConfigTest;
use BackRestTest::FileTest;
use BackRestTest::BackupTest;
use BackRestTest::CompareTest;
# use BackRestTest::IniTest;
####################################################################################################################################
# Usage
@ -38,7 +38,7 @@ use BackRestTest::CompareTest;
=head1 NAME
test.pl - Simple Postgres Backup and Restore Unit Tests
test.pl - pgBackRest Unit Tests
=head1 SYNOPSIS
@ -108,11 +108,11 @@ GetOptions ('q|quiet' => \$bQuiet,
# Display version and exit if requested
if ($bVersion || $bHelp)
{
print 'pg_backrest ' . version_get() . " unit test\n";
syswrite(*STDOUT, 'pgBackRest ' . BACKREST_VERSION . " Unit Tests\n");
if ($bHelp)
{
print "\n";
syswrite(*STDOUT, "\n");
pod2usage();
}
@ -121,16 +121,10 @@ if ($bVersion || $bHelp)
if (@ARGV > 0)
{
print "invalid parameter\n\n";
syswrite(*STDOUT, "invalid parameter\n\n");
pod2usage();
}
# Must be run from the test path so relative paths to bin can be tested
# if ($0 ne './test.pl')
# {
# confess 'test.pl must be run from the test path';
# }
####################################################################################################################################
# Setup
####################################################################################################################################
@ -148,7 +142,7 @@ if ($bQuiet)
$strLogLevel = 'off';
}
log_level_set(undef, uc($strLogLevel));
logLevelSet(undef, uc($strLogLevel));
if ($strModuleTest ne 'all' && $strModule eq 'all')
{
@ -162,7 +156,7 @@ if (defined($iModuleTestRun) && $strModuleTest eq 'all')
# Search for psql bin
my @stryTestVersion;
my $strVersionSupport = versionSupport();
my @stryVersionSupport = versionSupport();
if (!defined($strPgSqlBin))
{
@ -177,13 +171,13 @@ if (!defined($strPgSqlBin))
foreach my $strSearchPath (@strySearchPath)
{
for (my $iVersionIdx = @{$strVersionSupport} - 1; $iVersionIdx >= 0; $iVersionIdx--)
for (my $iVersionIdx = @stryVersionSupport - 1; $iVersionIdx >= 0; $iVersionIdx--)
{
if ($strDbVersion eq 'all' || $strDbVersion eq 'max' && @stryTestVersion == 0 ||
$strDbVersion eq ${$strVersionSupport}[$iVersionIdx])
$strDbVersion eq $stryVersionSupport[$iVersionIdx])
{
my $strVersionPath = $strSearchPath;
$strVersionPath =~ s/VERSION/${$strVersionSupport}[$iVersionIdx]/g;
$strVersionPath =~ s/VERSION/$stryVersionSupport[$iVersionIdx]/g;
if (-e "${strVersionPath}/initdb")
{
@ -271,10 +265,10 @@ eval
&log(INFO, "INFINITE - RUN ${iRun}\n");
}
if ($strModule eq 'all' || $strModule eq 'utility')
{
BackRestTestUtility_Test($strModuleTest);
}
# if ($strModule eq 'all' || $strModule eq 'ini')
# {
# BackRestTestIni_Test($strModuleTest);
# }
if ($strModule eq 'all' || $strModule eq 'config')
{
@ -316,7 +310,7 @@ if ($@)
my $oMessage = $@;
# If a backrest exception then return the code - don't confess
if (blessed($oMessage) && $oMessage->isa('BackRest::Exception'))
if (blessed($oMessage) && $oMessage->isa('BackRest::Common::Exception'))
{
syswrite(*STDOUT, $oMessage->trace());
exit $oMessage->code();