database/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2026-01-06 08:01:21 +03:00
Code Activity

v0.85: Start/Stop Commands and Minor Bug Fixes

Browse Source 
* Added new feature to allow all pgBackRest operations to be stopped or started using the stop and start commands.  This prevents any pgBackRest processes from running on a system where PostgreSQL is shutdown or the system needs to be quiesced for some reason.

* Removed dependency on IO::String module.

* Fixed an issue where an error could be returned after a backup or restore completely successfully.

* Fixed an issue where a resume would fail if temp files were left in the root backup directory when the backup failed.  This scenario was likely if the backup process got terminated during the copy phase.

* Experimental support for PostgreSQL 9.5 beta1.  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.
This commit is contained in:
David Steele
2015-10-08 12:34:50 -04:00
parent 9be15d00f8
commit 097eb7ca41
69 changed files with 7025 additions and 3038 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
CHANGELOG.md
View File

@@ -1,5 +1,18 @@
# pgBackRest - Change Log
## v0.85: Start/Stop Commands and Minor Bug Fixes
__Released October 8, 2015__
* Added new feature to allow all pgBackRest operations to be stopped or started using the `stop` and `start` commands. This prevents any pgBackRest processes from running on a system where PostgreSQL is shutdown or the system needs to be quiesced for some reason.
* Removed dependency on `IO::String` module.
* Fixed an issue where an error could be returned after a backup or restore completely successfully.
* Fixed an issue where a resume would fail if temp files were left in the root backup directory when the backup failed. This scenario was likely if the backup process got terminated during the copy phase.
* Experimental support for PostgreSQL 9.5 beta1. 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.82: Refactoring, Command-line Help, and Minor Bug Fixes
__Released September 14, 2015__

49
USERGUIDE.md
View File

@@ -257,6 +257,16 @@ allow: 0-9
example: compress-level-network=1
```
##### `config-remote` key
pgBackRest remote configuration file.
Sets the location of the remote configuration file. This is only required if the remote configuration file is in a different location than the local configuration file.
```
default: /etc/doc.pl.conf
example: config-remote=/etc/pg_backrest_remote.conf
```
##### `db-timeout` key
Database query timeout.
@@ -877,6 +887,45 @@ pg_backrest help backup force
Get help for the force option of the backup command.
#### `start` command
Allow pgBackRest processes to run.
If the pgBackRest processes were previously stopped using the `stop` command then they can be started again using the `start` command. Note that this will not immediately start up any pgBackRest processes but they are allowed to run.
##### Example: Start processes for stanza main
```
pg_backrest --stanza=main start
```
Allows pgBackRest processes to run for the `main` stanza.
#### `stop` command
Stop pgBackRest processes from running.
Does not allow any new pgBackRest processes to run. By default running processes will be allowed to complete successfully. Use the `--force` option to terminate running processes.
pgBackRest processes will return an error if they are run after the stop command completes.
##### `force` option
Force all pgBackRest processes to stop.
This option will send TERM signals to all running pgBackRest processes to effect a graceful but immediate shutdown. Note that this will also shutdown processes that were initiated on another system but have remotes running on the current system. For instance, if a backup was started on the backup server then running `stop --force` on the database server will shutdown the backup process on the backup server.
```
default: n
```
##### Example: Stop processes for all stanzas
```
pg_backrest stop
```
Stop new pgBackRest processes for all stanzas but allow any current process to complete.
#### `version` command
Get version.

225
bin/pg_backrest
View File

@@ -19,84 +19,12 @@ use Scalar::Util qw(blessed);
use lib dirname($0) . '/../lib';
use BackRest::Archive;
use BackRest::Common::Exception;
use BackRest::Common::Exit;
use BackRest::Common::Lock;
use BackRest::Common::Log;
use BackRest::Config::Config;
use BackRest::File;
####################################################################################################################################
# Operation constants
####################################################################################################################################
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.
####################################################################################################################################
my $iThreadMax = 1;
sub safeExit
{
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$iExitCode
) =
logDebugParam
(
OP_MAIN_SAFE_EXIT, \@_,
{name => 'iExitCode', required => false}
);
commandStop();
# Stop threads if threading is enabled
my $iThreadsStopped = 0;
if ($iThreadMax > 1)
{
&log(DEBUG, "stop ${iThreadMax} threads");
# Don't fail if the threads cannot be stopped
eval
{
$iThreadsStopped = threadGroupDestroy();
};
if ($@ && defined($iExitCode))
{
&log(WARN, "unable to stop threads: $@");
}
}
# Don't fail if protocol cannot be destroyed
eval
{
protocolDestroy();
};
if ($@ && defined($iExitCode))
{
&log(WARN, "unable to shutdown protocol: $@");
}
# Exit with code when defined
if (defined($iExitCode))
{
exit $iExitCode;
}
# Else the process was terminated on a signal or exception
&log(ERROR, 'process terminated on signal or exception' . ($iThreadsStopped > 0 ? "${iThreadsStopped} threads stopped" : ''));
}
$SIG{TERM} = \&safeExit;
$SIG{HUP} = \&safeExit;
$SIG{INT} = \&safeExit;
####################################################################################################################################
# START EVAL BLOCK TO CATCH ERRORS AND STOP THREADS
####################################################################################################################################
@@ -116,16 +44,20 @@ eval
# Generate help and exit
configHelp($ARGV[1], $ARGV[2], commandTest(CMD_VERSION), $bConfigResult);
safeExit(0);
exitSafe(0);
}
# Set test options
!optionGet(OPTION_TEST, false) or
testSet(optionGet(OPTION_TEST), optionGet(OPTION_TEST_DELAY), optionGet(OPTION_TEST_POINT, false));
################################################################################################################################
# Process remote commands
################################################################################################################################
if (commandTest(CMD_REMOTE))
{
# Turn all logging off
logLevelSet(OFF, OFF);
# Set log levels
logLevelSet(OFF, REMOTE);
# Load module dynamically
require BackRest::Protocol::RemoteMinion;
@@ -134,21 +66,26 @@ eval
# Create the remote object
my $oRemote = new BackRest::Protocol::RemoteMinion
(
optionGet(OPTION_COMMAND),
optionGet(OPTION_BUFFER_SIZE),
optionGet(OPTION_COMPRESS_LEVEL),
optionGet(OPTION_COMPRESS_LEVEL_NETWORK)
optionGet(OPTION_COMPRESS_LEVEL_NETWORK),
protocolTimeoutGet()
);
# !!! Would like to remove this check and allow a test lock
if (optionGet(OPTION_COMMAND) ne 'test' && !optionTest(OPTION_PROCESS))
{
lockAcquire(optionGet(OPTION_COMMAND), undef, true, optionGet(OPTION_PROCESS, false));
}
# Process remote requests
safeExit($oRemote->process());
exitSafe($oRemote->process());
}
# Set the log levels
logLevelSet(optionGet(OPTION_LOG_LEVEL_FILE), optionGet(OPTION_LOG_LEVEL_CONSOLE));
# Set test options
!optionGet(OPTION_TEST) or testSet(optionGet(OPTION_TEST), optionGet(OPTION_TEST_DELAY));
# Log the command start
commandStart();
@@ -157,7 +94,21 @@ eval
################################################################################################################################
if (commandTest(CMD_ARCHIVE_PUSH) || commandTest(CMD_ARCHIVE_GET))
{
safeExit(new BackRest::Archive()->process());
exitSafe(new BackRest::Archive()->process());
}
################################################################################################################################
# Process start/stop commands
################################################################################################################################
if (commandTest(CMD_START))
{
lockStart();
exitSafe(0);
}
elsif (commandTest(CMD_STOP))
{
lockStop();
exitSafe(0);
}
################################################################################################################################
@@ -169,16 +120,12 @@ eval
require BackRest::Info;
BackRest::Info->import();
safeExit(new BackRest::Info()->process());
exitSafe(new BackRest::Info()->process());
}
################################################################################################################################
# Acquire the command lock
################################################################################################################################
# Load module dynamically
require BackRest::Common::Lock;
BackRest::Common::Lock->import();
lockAcquire(commandGet());
################################################################################################################################
@@ -191,8 +138,8 @@ eval
################################################################################################################################
if (optionTest(OPTION_THREAD_MAX) && optionGet(OPTION_THREAD_MAX) > 1)
{
# Set local thread-max so safeExit knows to stop them on exit
$iThreadMax = optionGet(OPTION_THREAD_MAX);
# Set local thread-max so exitSafe knows to stop them on exit
exitInit(optionGet(OPTION_THREAD_MAX));
# Load module dynamically
require BackRest::Protocol::ThreadGroup;
@@ -201,17 +148,6 @@ eval
threadGroupCreate();
}
################################################################################################################################
# Initialize the default file object
################################################################################################################################
my $oFile = new BackRest::File
(
optionGet(OPTION_STANZA),
optionRemoteTypeTest(BACKUP) ? optionGet(OPTION_REPO_REMOTE_PATH) : optionGet(OPTION_REPO_PATH),
optionRemoteType(),
protocolGet()
);
################################################################################################################################
# RESTORE
################################################################################################################################
@@ -227,58 +163,49 @@ eval
BackRest::Restore->import();
# Do the restore
new BackRest::Restore
(
$oFile
)->process;
new BackRest::Restore()->process();
safeExit(0);
exitSafe(0);
}
################################################################################################################################
# Make sure backup and expire command happen on the backup side
################################################################################################################################
if (optionRemoteTypeTest(BACKUP))
else
{
confess &log(ERROR, 'backup and expire commands must run on the backup host');
############################################################################################################################
# Make sure backup and expire commands happen on the backup side
############################################################################################################################
if (optionRemoteTypeTest(BACKUP))
{
confess &log(ERROR, 'backup and expire commands must run on the backup host');
}
############################################################################################################################
# BACKUP
############################################################################################################################
if (commandTest(CMD_BACKUP))
{
# Load module dynamically
require BackRest::Backup;
BackRest::Backup->import();
new BackRest::Backup()->process();
commandSet(CMD_EXPIRE);
}
############################################################################################################################
# EXPIRE
############################################################################################################################
if (commandTest(CMD_EXPIRE))
{
# Load module dynamically
require BackRest::Expire;
BackRest::Expire->import();
new BackRest::Expire()->process();
}
}
################################################################################################################################
# BACKUP
################################################################################################################################
if (commandTest(CMD_BACKUP))
{
# Load module dynamically
require BackRest::Backup;
BackRest::Backup->import();
new BackRest::Backup
(
$oFile
)->process();
commandSet(CMD_EXPIRE);
}
################################################################################################################################
# EXPIRE
################################################################################################################################
if (commandTest(CMD_EXPIRE))
{
# Load module dynamically
require BackRest::Expire;
BackRest::Expire->import();
new BackRest::Expire
(
$oFile
)->process();
}
# Release the command lock
lockRelease();
safeExit(0);
exitSafe(0);
};
####################################################################################################################################
@@ -291,9 +218,9 @@ if ($@)
# If a backrest exception then return the code - don't confess
if (blessed($oMessage) && $oMessage->isa('BackRest::Common::Exception'))
{
safeExit($oMessage->code());
exitSafe($oMessage->code());
}
safeExit();
exitSafe(-1);
confess $oMessage;
}

4
doc/html/default.css
View File

@@ -108,13 +108,13 @@ Menu
/*******************************************************************************
Section
*******************************************************************************/
doc-install, doc-configure, doc-intro
.section1
{
display:block;
margin-top: 8px;
}
doc-install-header, doc-configure-header
section1-header
{
display:block;
background-color: #dddddd;

2
doc/lib/BackRestDoc/Doc.pm
View File

@@ -310,7 +310,7 @@ sub nodeGetById
if (!defined($oNode) && $bRequired)
{
confess "unable to find child ${strName} in node $$oDoc{name}";
confess "unable to find child ${strName} (${strId}) in node $$oDoc{name}";
}
# Return from function and log return values if any

20
doc/xml/changelog.xml
View File

@@ -6,6 +6,26 @@
</intro>
<changelog>
<changelog-release date="2015-10-08" version="0.85" title="Start/Stop Commands and Minor Bug Fixes">
<release-feature-bullet-list>
<release-feature>
<text>Added new feature to allow all <backrest/> operations to be stopped or started using the <cmd>stop</cmd> and <cmd>start</cmd> commands. This prevents any <backrest/> processes from running on a system where <postgres/> is shutdown or the system needs to be quiesced for some reason.</text>
</release-feature>
<release-feature>
<text>Removed dependency on <code>IO::String</code> module.</text>
</release-feature>
<release-feature>
<text>Fixed an issue where an error could be returned after a backup or restore completely successfully.</text>
</release-feature>
<release-feature>
<text>Fixed an issue where a resume would fail if temp files were left in the root backup directory when the backup failed. This scenario was likely if the backup process got terminated during the copy phase.</text>
</release-feature>
<release-feature>
<text>Experimental support for <postgres/> 9.5 beta1. 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>
<changelog-release date="2015-09-14" version="0.82" title="Refactoring, Command-line Help, and Minor Bug Fixes">
<release-feature-bullet-list>
<release-feature>

54
doc/xml/userguide.xml
View File

@@ -263,6 +263,15 @@
<example>1</example>
</config-key>
<!-- CONFIG - GENERAL SECTION - CONFIG_REMOTE KEY -->
<config-key id="config-remote">
<summary><text><backrest/> remote configuration file.</text></summary>
<text>Sets the location of the remote configuration file. This is only required if the remote configuration file is in a different location than the local configuration file.</text>
<example>/etc/pg_backrest_remote.conf</example>
</config-key>
<!-- CONFIG - GENERAL SECTION - DB-TIMEOUT KEY -->
<config-key id="db-timeout">
<summary><text>Database query timeout.</text></summary>
@@ -884,6 +893,51 @@
</command-example-list>
</command>
<!-- OPERATION - START COMMAND -->
<command id="start">
<summary><text>Allow <backrest/> processes to run.</text></summary>
<text>If the <backrest/> processes were previously stopped using the <cmd>stop</cmd> command then they can be started again using the <cmd>start</cmd> command. Note that this will not immediately start up any <backrest/> processes but they are allowed to run.</text>
<command-example-list>
<command-example title="Start processes for stanza main">
<text><code-block>
<exe/> --stanza=main start
</code-block>
Allows <backrest/> processes to run for the <id>main</id> stanza.</text>
</command-example>
</command-example-list>
</command>
<!-- OPERATION - STOP COMMAND -->
<command id="stop">
<summary><text>Stop <backrest/> processes from running.</text></summary>
<text>Does not allow any new <backrest/> processes to run. By default running processes will be allowed to complete successfully. Use the <setting>--force</setting> option to terminate running processes.
<backrest/> processes will return an error if they are run after the stop command completes.</text>
<option-list>
<!-- OPERATION - STOP COMMAND - FORCE OPTION -->
<option id="force">
<summary><text>Force all <backrest/> processes to stop.</text></summary>
<text>This option will send TERM signals to all running <backrest/> processes to effect a graceful but immediate shutdown. Note that this will also shutdown processes that were initiated on another system but have remotes running on the current system. For instance, if a backup was started on the backup server then running <cmd>stop --force</cmd> on the database server will shutdown the backup process on the backup server.</text>
</option>
</option-list>
<command-example-list>
<command-example title="Stop processes for all stanzas">
<text><code-block>
<exe/> stop
</code-block>
Stop new <backrest/> processes for all stanzas but allow any current process to complete.</text>
</command-example>
</command-example-list>
</command>
<!-- OPERATION - VERSION COMMAND -->
<command id="version">
<summary><text>Get version.</text></summary>

14
lib/BackRest/Archive.pm
View File

@@ -14,6 +14,7 @@ use File::Basename qw(dirname basename);
use lib dirname($0);
use BackRest::Common::Exception;
use BackRest::Common::Lock;
use BackRest::Common::Log;
use BackRest::ArchiveInfo;
use BackRest::Common::String;
@@ -256,7 +257,7 @@ sub walInfo
my $strDbVersion;
my $iSysIdOffset;
if ($iMagic == hex('0xD085'))
if ($iMagic == hex('0xD087'))
{
$strDbVersion = '9.5';
$iSysIdOffset = 20;
@@ -366,6 +367,8 @@ sub get
{name => 'strDestinationFile'}
);
lockStopTest();
# Create the file object
my $oFile = new BackRest::File
(
@@ -541,10 +544,6 @@ sub pushProcess
# Start the async archive push
logDebugMisc($strOperation, 'start async archive-push');
# Load module dynamically
require BackRest::Common::Lock;
BackRest::Common::Lock->import();
# Create a lock file to make sure async archive-push does not run more than once
if (!lockAcquire(commandGet(), false))
{
@@ -615,6 +614,8 @@ sub push
protocolGet($bAsync)
);
lockStopTest();
# If the source file path is not absolute then it is relative to the data path
if (index($strSourceFile, '/',) != 0)
{
@@ -836,6 +837,9 @@ sub xfer
{
eval
{
# Start backup test point
&log(TEST, TEST_ARCHIVE_PUSH_ASYNC_START);
# If the archive repo is remote create a new file object to do the copies
if (!optionRemoteTypeTest(NONE))
{

47
lib/BackRest/Backup.pm
View File

@@ -16,6 +16,7 @@ use Thread::Queue;
use lib dirname($0);
use BackRest::Common::Exception;
use BackRest::Common::Exit;
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Archive;
@@ -53,16 +54,18 @@ sub new
bless $self, $class;
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{oFile}
) =
logDebugParam
(
OP_BACKUP_NEW, \@_,
{name => 'oFile', trace => true}
);
my ($strOperation) = logDebugParam(OP_BACKUP_NEW);
# Initialize default file object
$self->{oFile} = new BackRest::File
(
optionGet(OPTION_STANZA),
optionRemoteTypeTest(BACKUP) ? optionGet(OPTION_REPO_REMOTE_PATH) : optionGet(OPTION_REPO_PATH),
optionRemoteType(),
protocolGet()
);
# Initialize variables
$self->{oDb} = new BackRest::Db();
# Return from function and log return values if any
@@ -93,7 +96,6 @@ sub DESTROY
undef($self->{oFile});
undef($self->{oDb});
# Return from function and log return values if any
return logDebugReturn
(
@@ -187,13 +189,12 @@ sub fileNotInManifest
next;
}
# We'll always keep the base path
if ($strName eq MANIFEST_KEY_BASE)
{
if ($oManifest->test(MANIFEST_SECTION_BACKUP_PATH, $strName))
{
next;
}
next;
}
# Keep the tablespace path if some tablespaces exist in the new manfest
elsif ($strName eq MANIFEST_TABLESPACE)
{
my $bFound = false;
@@ -209,7 +210,8 @@ sub fileNotInManifest
next if $bFound;
}
else
# If there is a / in the name then check further, otherwise it's a temp file or some other garbage and should be deleted
elsif (index($strName, '/') != -1)
{
my $strBasePath = (split('/', $strName))[0];
my $strPath = substr($strName, length($strBasePath) + 1);
@@ -217,6 +219,7 @@ sub fileNotInManifest
# Create the section from the base path
my $strSection = $strBasePath;
# Test to see if a tablespace exists in the new manifest
if ($strSection eq 'tablespace')
{
my $strTablespace = (split('/', $strPath))[0];
@@ -234,8 +237,10 @@ sub fileNotInManifest
$strPath = substr($strPath, length($strTablespace) + 1);
}
# Get the file type (all links will be deleted since they are easy to recreate)
my $cType = $oFileHash{name}{"${strName}"}{type};
# If a directory check if it exists in the new manifest
if ($cType eq 'd')
{
if ($oManifest->test("${strSection}:path", "${strPath}"))
@@ -274,6 +279,7 @@ sub fileNotInManifest
}
}
# Push the file/path/link to be deleted into the result array
push @stryFile, $strName;
}
@@ -531,8 +537,14 @@ sub processManifest
$lManifestSaveSize = optionGet(OPTION_MANIFEST_SAVE_THRESHOLD);
}
if (optionGet(OPTION_THREAD_MAX) == 1)
{
# Start backup test point
&log(TEST, TEST_BACKUP_START);
}
# Iterate all backup files
foreach my $strPathKey (sort (keys %oFileCopyMap))
foreach my $strPathKey (sort(keys(%oFileCopyMap)))
{
if (optionGet(OPTION_THREAD_MAX) > 1)
{
@@ -581,6 +593,9 @@ sub processManifest
threadGroupRun($iThreadIdx, 'backup', \%oParam);
}
# Start backup test point
&log(TEST, TEST_BACKUP_START);
# Complete thread queues
my $bDone = false;

170
lib/BackRest/Common/Exception.pm
View File

@@ -13,82 +13,97 @@ use Exporter qw(import);
####################################################################################################################################
# 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_MINIMUM => 100;
push @EXPORT, qw(ERROR_MINIMUM);
use constant ERROR_MAXIMUM => 199;
push @EXPORT, qw(ERROR_MAXIMUM);
use constant ERROR_UNKNOWN => 199;
use constant ERROR_ASSERT => ERROR_MINIMUM;
push @EXPORT, qw(ERROR_ASSERT);
use constant ERROR_CHECKSUM => ERROR_MINIMUM + 1;
push @EXPORT, qw(ERROR_CHECKSUM);
use constant ERROR_CONFIG => ERROR_MINIMUM + 2;
push @EXPORT, qw(ERROR_CONFIG);
use constant ERROR_FILE_INVALID => ERROR_MINIMUM + 3;
push @EXPORT, qw(ERROR_FILE_INVALID);
use constant ERROR_FORMAT => ERROR_MINIMUM + 4;
push @EXPORT, qw(ERROR_FORMAT);
use constant ERROR_COMMAND_REQUIRED => ERROR_MINIMUM + 5;
push @EXPORT, qw(ERROR_COMMAND_REQUIRED);
use constant ERROR_OPTION_INVALID => ERROR_MINIMUM + 6;
push @EXPORT, qw(ERROR_OPTION_INVALID);
use constant ERROR_OPTION_INVALID_VALUE => ERROR_MINIMUM + 7;
push @EXPORT, qw(ERROR_OPTION_INVALID_VALUE);
use constant ERROR_OPTION_INVALID_RANGE => ERROR_MINIMUM + 8;
push @EXPORT, qw(ERROR_OPTION_INVALID_RANGE);
use constant ERROR_OPTION_INVALID_PAIR => ERROR_MINIMUM + 9;
push @EXPORT, qw(ERROR_OPTION_INVALID_PAIR);
use constant ERROR_OPTION_DUPLICATE_KEY => ERROR_MINIMUM + 10;
push @EXPORT, qw(ERROR_OPTION_DUPLICATE_KEY);
use constant ERROR_OPTION_NEGATE => ERROR_MINIMUM + 11;
push @EXPORT, qw(ERROR_OPTION_NEGATE);
use constant ERROR_OPTION_REQUIRED => ERROR_MINIMUM + 12;
push @EXPORT, qw(ERROR_OPTION_REQUIRED);
use constant ERROR_POSTMASTER_RUNNING => ERROR_MINIMUM + 13;
push @EXPORT, qw(ERROR_POSTMASTER_RUNNING);
use constant ERROR_PROTOCOL => ERROR_MINIMUM + 14;
push @EXPORT, qw(ERROR_PROTOCOL);
use constant ERROR_RESTORE_PATH_NOT_EMPTY => ERROR_MINIMUM + 15;
push @EXPORT, qw(ERROR_RESTORE_PATH_NOT_EMPTY);
use constant ERROR_FILE_OPEN => ERROR_MINIMUM + 16;
push @EXPORT, qw(ERROR_FILE_OPEN);
use constant ERROR_FILE_READ => ERROR_MINIMUM + 17;
push @EXPORT, qw(ERROR_FILE_READ);
use constant ERROR_PARAM_REQUIRED => ERROR_MINIMUM + 18;
push @EXPORT, qw(ERROR_PARAM_REQUIRED);
use constant ERROR_ARCHIVE_MISMATCH => ERROR_MINIMUM + 19;
push @EXPORT, qw(ERROR_ARCHIVE_MISMATCH);
use constant ERROR_ARCHIVE_DUPLICATE => ERROR_MINIMUM + 20;
push @EXPORT, qw(ERROR_ARCHIVE_DUPLICATE);
use constant ERROR_VERSION_NOT_SUPPORTED => ERROR_MINIMUM + 21;
push @EXPORT, qw(ERROR_VERSION_NOT_SUPPORTED);
use constant ERROR_PATH_CREATE => ERROR_MINIMUM + 22;
push @EXPORT, qw(ERROR_PATH_CREATE);
use constant ERROR_COMMAND_INVALID => ERROR_MINIMUM + 23;
push @EXPORT, qw(ERROR_COMMAND_INVALID);
use constant ERROR_HOST_CONNECT => ERROR_MINIMUM + 24;
push @EXPORT, qw(ERROR_HOST_CONNECT);
use constant ERROR_LOCK_ACQUIRE => ERROR_MINIMUM + 25;
push @EXPORT, qw(ERROR_LOCK_ACQUIRE);
use constant ERROR_BACKUP_MISMATCH => ERROR_MINIMUM + 26;
push @EXPORT, qw(ERROR_BACKUP_MISMATCH);
use constant ERROR_FILE_SYNC => ERROR_MINIMUM + 27;
push @EXPORT, qw(ERROR_FILE_SYNC);
use constant ERROR_PATH_OPEN => ERROR_MINIMUM + 28;
push @EXPORT, qw(ERROR_PATH_OPEN);
use constant ERROR_PATH_SYNC => ERROR_MINIMUM + 29;
push @EXPORT, qw(ERROR_PATH_SYNC);
use constant ERROR_FILE_MISSING => ERROR_MINIMUM + 30;
push @EXPORT, qw(ERROR_FILE_MISSING);
use constant ERROR_DB_CONNECT => ERROR_MINIMUM + 31;
push @EXPORT, qw(ERROR_DB_CONNECT);
use constant ERROR_DB_QUERY => ERROR_MINIMUM + 32;
push @EXPORT, qw(ERROR_DB_QUERY);
use constant ERROR_DB_MISMATCH => ERROR_MINIMUM + 33;
push @EXPORT, qw(ERROR_DB_MISMATCH);
use constant ERROR_DB_TIMEOUT => ERROR_MINIMUM + 34;
push @EXPORT, qw(ERROR_DB_TIMEOUT);
use constant ERROR_FILE_REMOVE => ERROR_MINIMUM + 35;
push @EXPORT, qw(ERROR_FILE_REMOVE);
use constant ERROR_PATH_REMOVE => ERROR_MINIMUM + 36;
push @EXPORT, qw(ERROR_PATH_REMOVE);
use constant ERROR_STOP => ERROR_MINIMUM + 37;
push @EXPORT, qw(ERROR_STOP);
use constant ERROR_TERM => ERROR_MINIMUM + 38;
push @EXPORT, qw(ERROR_TERM);
use constant ERROR_FILE_WRITE => ERROR_MINIMUM + 39;
push @EXPORT, qw(ERROR_FILE_WRITE);
use constant ERROR_UNHANDLED_EXCEPTION => ERROR_MINIMUM + 40;
push @EXPORT, qw(ERROR_UNHANDLED_EXCEPTION);
use constant ERROR_INVALID_VALUE => ERROR_MAXIMUM - 1;
push @EXPORT, qw(ERROR_INVALID_VALUE);
use constant ERROR_UNKNOWN => ERROR_MAXIMUM;
push @EXPORT, qw(ERROR_UNKNOWN);
####################################################################################################################################
@@ -101,6 +116,11 @@ sub new
my $strMessage = shift; # ErrorMessage
my $strTrace = shift; # Stack trace
# if ($iCode < ERROR_MINIMUM || $iCode > ERROR_MAXIMUM)
# {
# $iCode = ERROR_INVALID_VALUE;
# }
# Create the class hash
my $self = {};
bless $self, $class;

164
lib/BackRest/Common/Exit.pm Normal file
View File

@@ -0,0 +1,164 @@
####################################################################################################################################
# COMMON EXIT MODULE
####################################################################################################################################
package BackRest::Common::Exit;
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
use Scalar::Util qw(blessed);
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
use BackRest::Common::Lock;
use BackRest::Common::Log;
use BackRest::Config::Config;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_EXIT => 'Exit';
use constant OP_EXIT_SAFE => OP_EXIT . '::exitSafe';
####################################################################################################################################
# Signal constants
####################################################################################################################################
use constant SIGNAL_HUP => 'HUP';
use constant SIGNAL_INT => 'INT';
use constant SIGNAL_TERM => 'TERM';
####################################################################################################################################
# Hook important signals into exitSafe function
####################################################################################################################################
$SIG{&SIGNAL_HUP} = sub {exitSafe(-1, SIGNAL_HUP)};
$SIG{&SIGNAL_INT} = sub {exitSafe(-1, SIGNAL_INT)};
$SIG{&SIGNAL_TERM} = sub {exitSafe(-1, SIGNAL_TERM)};
####################################################################################################################################
# Module variables
####################################################################################################################################
my $iThreadMax = 1; # Total threads that were started for processing
my $bRemote = false; # Is the process a remote?
####################################################################################################################################
# exitInit
#
# Initialize exit so it knows if threads need to be terminated.
####################################################################################################################################
sub exitInit
{
my $iThreadMaxParam = shift;
my $bRemoteParam = shift;
if (defined($iThreadMaxParam) && $iThreadMaxParam > 1)
{
# Load module dynamically
require BackRest::Protocol::ThreadGroup;
BackRest::Protocol::ThreadGroup->import();
$iThreadMax = $iThreadMaxParam;
}
if (defined($bRemoteParam))
{
$bRemote = $bRemoteParam;
}
}
push @EXPORT, qw(exitInit);
####################################################################################################################################
# exitSafe
#
# Terminate all threads and SSH connections when the script is terminated.
####################################################################################################################################
sub exitSafe
{
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$iExitCode,
$strSignal
) =
logDebugParam
(
OP_EXIT_SAFE, \@_,
{name => 'iExitCode'},
{name => 'strSignal', required => false}
);
commandStop();
# Stop threads if threading is enabled
my $iThreadsStopped = 0;
if ($iThreadMax > 1)
{
&log(DEBUG, "stop ${iThreadMax} threads");
# Don't fail if the threads cannot be stopped
eval
{
$iThreadsStopped = threadGroupDestroy();
};
if ($@ && defined($iExitCode))
{
&log(WARN, "unable to stop threads: $@");
}
}
# Don't fail if protocol cannot be destroyed
eval
{
protocolDestroy();
};
if ($@ && defined($iExitCode))
{
my $oMessage = $@;
if (blessed($oMessage) && $oMessage->isa('BackRest::Common::Exception'))
{
&log(WARN, 'unable to shutdown protocol (' . $oMessage->code() . '): ' . $oMessage->message());
exit $oMessage->code();
}
&log(WARN, "unable to shutdown protocol: $oMessage");
}
# Don't fail if the lock can't be released
eval
{
lockRelease(false);
};
# Exit with code when defined
if ($iExitCode != -1)
{
exit $iExitCode;
}
# Log error based on where the signal came from
&log(ERROR, 'process terminated ' .
(defined($strSignal) ? "on a ${strSignal} signal" : 'due to an unhandled exception') .
($iThreadsStopped > 0 ? ", ${iThreadsStopped} threads stopped" : ''),
defined($strSignal) ? ERROR_TERM : ERROR_UNHANDLED_EXCEPTION);
# If terminated by a signal exit with 0 code
exit ERROR_TERM if defined($strSignal);
# Return from function and log return values if any
return logDebugReturn($strOperation);
}
push @EXPORT, qw(exitSafe);
1;

316
lib/BackRest/Common/Lock.pm
View File

@@ -17,6 +17,15 @@ use BackRest::Common::Exception;
use BackRest::Common::Log;
use BackRest::Config::Config;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_LOCK => 'Common:::Lock';
use constant OP_LOCK_ACQUIRE => OP_LOCK . "::lockAquire";
use constant OP_LOCK_RELEASE => OP_LOCK . "::lockRelease";
use constant OP_LOCK_STOP_TEST => OP_LOCK . "::lockStopTest";
####################################################################################################################################
# Global lock type and handle
####################################################################################################################################
@@ -46,8 +55,29 @@ sub lockFileName
my $strLockType = shift;
my $strStanza = shift;
my $strRepoPath = shift;
my $bRemote = shift;
my $iProcessIdx = shift;
return lockPathName($strRepoPath) . "/${strStanza}-${strLockType}.lock";
return lockPathName($strRepoPath) . '/' . (defined($strStanza) ? $strStanza : 'global') . "_${strLockType}" .
(defined($bRemote) && $bRemote ? '_remote' : '') .
(defined($iProcessIdx) ? "-${iProcessIdx}" : '') . '.lock';
}
####################################################################################################################################
# lockPathCreate
#
# Create the lock path if it does not exist.
####################################################################################################################################
sub lockPathCreate
{
my $strRepoPath = shift;
# Create the lock path if it does not exist. Use 770 so that members of the group can run read-only processes.
if (! -e lockPathName($strRepoPath))
{
mkdir (lockPathName($strRepoPath), 0770)
or confess &log(ERROR, 'unable to create lock path ' . lockPathName($strRepoPath), ERROR_PATH_CREATE);
}
}
####################################################################################################################################
@@ -57,8 +87,25 @@ sub lockFileName
####################################################################################################################################
sub lockAcquire
{
my $strLockType = shift;
my $bFailOnNoLock = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strLockType,
$bFailOnNoLock,
$bRemote,
$iProcessIdx
) =
logDebugParam
(
OP_LOCK_ACQUIRE, \@_,
{name => 'strLockType'},
{name => 'bFailOnNoLock', default => true},
{name => 'bRemote', default => false},
{name => 'iProcessIdx', required => false}
);
my $strRepoPath = optionGet(OPTION_REPO_PATH);
# Cannot proceed if a lock is currently held
if (defined($strCurrentLockType))
@@ -66,20 +113,21 @@ sub lockAcquire
confess &lock(ASSERT, "${strCurrentLockType} lock is already held");
}
# Create the lock path if it does not exist. Use 770 so that members of the group can run read-only processes.
if (! -e lockPathName(optionGet(OPTION_REPO_PATH)))
{
mkdir (lockPathName(optionGet(OPTION_REPO_PATH)), 0770)
or confess &log(ERROR, 'unable to create lock path ' . lockPathName(optionGet(OPTION_REPO_PATH)), ERROR_PATH_CREATE);
}
# Check if processes are currently stopped
lockStopTest($strRepoPath);
# Create the lock path
lockPathCreate($strRepoPath);
# Attempt to open the lock file
$strCurrentLockFile = lockFileName($strLockType, optionGet(OPTION_STANZA), optionGet(OPTION_REPO_PATH));
$strCurrentLockFile = lockFileName($strLockType, optionGet(OPTION_STANZA, false), $strRepoPath, $bRemote, $iProcessIdx);
sysopen($hCurrentLockHandle, $strCurrentLockFile, O_WRONLY | O_CREAT, 0660)
sysopen($hCurrentLockHandle, $strCurrentLockFile, O_WRONLY | O_CREAT, 0640)
or confess &log(ERROR, "unable to open lock file ${strCurrentLockFile}", ERROR_FILE_OPEN);
# Attempt to lock the lock file
my $bResult = false;
if (!flock($hCurrentLockHandle, LOCK_EX | LOCK_NB))
{
close($hCurrentLockHandle);
@@ -88,15 +136,26 @@ sub lockAcquire
{
confess &log(ERROR, "unable to acquire ${strLockType} lock", ERROR_LOCK_ACQUIRE);
}
}
else
{
# Write pid into the lock file. This is used stop terminate processes on a stop --force.
syswrite($hCurrentLockHandle, "$$\n")
or confess(ERROR, "unable to write process id into lock file ${strCurrentLockFile}", ERROR_FILE_WRITE);
return false;
# Set current lock type so we know we have a lock
$strCurrentLockType = $strLockType;
# Lock was successful
$bResult = true;
}
# Set current lock type so we know we have a lock
$strCurrentLockType = $strLockType;
# Lock was successful
return true;
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'bResult', value => $bResult}
);
}
push @EXPORT, qw(lockAcquire);
@@ -106,29 +165,222 @@ push @EXPORT, qw(lockAcquire);
####################################################################################################################################
sub lockRelease
{
my $strLockType = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$bFailOnNoLock
) =
logDebugParam
(
OP_LOCK_RELEASE, \@_,
{name => 'bFailOnNoLock', default => true}
);
# Fail if there is no lock
if (!defined($strCurrentLockType))
{
confess &log(ASSERT, 'no lock is currently held');
if ($bFailOnNoLock)
{
confess &log(ASSERT, 'no lock is currently held');
}
}
else
{
# # Fail if the lock being released is not the one held
# if ($strLockType ne $strCurrentLockType)
# {
# confess &log(ASSERT, "cannot remove lock ${strLockType} since ${strCurrentLockType} is currently held");
# }
# Remove the file
unlink($strCurrentLockFile);
close($hCurrentLockHandle);
# Undef lock variables
undef($strCurrentLockType);
undef($hCurrentLockHandle);
}
# # Fail if the lock being released is not the one held
# if ($strLockType ne $strCurrentLockType)
# {
# confess &log(ASSERT, "cannot remove lock ${strLockType} since ${strCurrentLockType} is currently held");
# }
# Remove the file
unlink($strCurrentLockFile);
close($hCurrentLockHandle);
# Undef lock variables
undef($strCurrentLockType);
undef($hCurrentLockHandle);
# Return from function and log return values if any
logDebugReturn($strOperation);
}
push @EXPORT, qw(lockRelease);
####################################################################################################################################
# lockStopFileName
#
# Get the stop file name.
####################################################################################################################################
sub lockStopFileName
{
my $strRepoPath = shift;
my $strStanza = shift;
return lockPathName($strRepoPath) . (defined($strStanza) ? "/${strStanza}" : '/all') . '.stop';
}
####################################################################################################################################
# lockStop
#
# Write a stop file that will prevent backrest processes from running. Optionally attempt to kill any processes that are currently
# running.
####################################################################################################################################
sub lockStop
{
# Create the lock path
lockPathCreate(optionGet(OPTION_REPO_PATH));
# Generate the stop file name
my $strStopFile = lockStopFileName(optionGet(OPTION_REPO_PATH), optionGet(OPTION_STANZA, false));
# If the stop file already exists then warn
if (-e $strStopFile)
{
&log(WARN, 'stop file already exists' . (optionTest(OPTION_STANZA) ? ' for stanza ' . optionGet(OPTION_STANZA) : ''));
return false;
}
# Create the stop file
sysopen(my $hStopHandle, $strStopFile, O_WRONLY | O_CREAT, 0640)
or confess &log(ERROR, "unable to open stop file ${strStopFile}", ERROR_FILE_OPEN);
close($hStopHandle);
# If --force was specified then send term signals to running processes
if (optionGet(OPTION_FORCE))
{
my $strLockPath = lockPathName(optionGet(OPTION_REPO_PATH));
opendir(my $hPath, $strLockPath)
or confess &log(ERROR, "unable to open lock path ${strLockPath}", ERROR_PATH_OPEN);
my @stryFileList = grep(!/^(\.)|(\.\.)$/i, readdir($hPath));
# Find each lock file and send term signals to the processes
foreach my $strFile (sort(@stryFileList))
{
my $hLockHandle;
my $strLockFile = "${strLockPath}/${strFile}";
# Skip if this is a stop file
next if ($strFile =~ /\.stop$/);
#
# # Skip if this is a thread lock file (we only send TERMs to the main process)
# next if ($strFile =~ /\-[0-9]+\.lock$/);
# Open the lock file for read
if (!sysopen($hLockHandle, $strLockFile, O_RDONLY))
{
&log(WARN, "unable to open lock file ${strLockFile}");
next;
}
# Attempt a lock on the file - if a lock can be acquired that means the original process died without removing the
# lock file so we'll remove it now.
if (flock($hLockHandle, LOCK_EX | LOCK_NB))
{
unlink($strLockFile);
close($hLockHandle);
next;
}
# The file is locked so that means there is a running process - read the process id and send it a term signal
my $iProcessId = readline($hLockHandle);
# If the process id is defined then this is a valid lock file
if (defined($iProcessId))
{
if (!kill('TERM', $iProcessId))
{
&log(WARN, "unable to send term signal to process ${iProcessId}");
}
&log(INFO, "sent term signal to process ${iProcessId}");
}
# Else not a valid lock file so delete it
{
unlink($strLockFile);
close($hLockHandle);
next;
}
}
}
return true;
}
push @EXPORT, qw(lockStop);
####################################################################################################################################
# lockStopTest
#
# Test if a stop file exists for the current stanza or all stanza.
####################################################################################################################################
sub lockStopTest
{
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strRepoPath
) =
logDebugParam
(
OP_LOCK_STOP_TEST, \@_,
{name => 'strRepoPath', default => optionGet(OPTION_REPO_PATH, false), required => true}
);
# Check the stanza first if it is specified
if (optionTest(OPTION_STANZA))
{
# Generate the stop file name
my $strStopFile = lockStopFileName($strRepoPath, optionGet(OPTION_STANZA));
if (-e $strStopFile)
{
confess &log(ERROR, 'stop file exists for stanza ' . optionGet(OPTION_STANZA), ERROR_STOP);
}
}
# Now check all stanzas
my $strStopFile = lockStopFileName($strRepoPath);
if (-e $strStopFile)
{
confess &log(ERROR, 'stop file exists for all stanzas', ERROR_STOP);
}
# Return from function and log return values if any
logDebugReturn($strOperation);
}
push @EXPORT, qw(lockStopTest);
####################################################################################################################################
# lockStart
#
# Remove the stop file so processes can run
####################################################################################################################################
sub lockStart
{
# Generate the stop file name
my $strStopFile = lockStopFileName(optionGet(OPTION_REPO_PATH), optionGet(OPTION_STANZA, false));
# If the stop file doesn't exist then warn
if (!-e $strStopFile)
{
&log(WARN, 'stop file does not exist' . (optionTest(OPTION_STANZA) ? ' for stanza ' . optionGet(OPTION_STANZA) : ''));
return false;
}
# Remove the stop file
unlink($strStopFile)
or confess &log(ERROR, "unable to remove ${strStopFile}: $!");
return true;
}
push @EXPORT, qw(lockStart);
1;

41
lib/BackRest/Common/Log.pm
View File

@@ -42,6 +42,8 @@ use constant ERROR => 'ERROR';
push @EXPORT, qw(ERROR);
use constant ASSERT => 'ASSERT';
push @EXPORT, qw(ASSERT);
use constant REMOTE => 'REMOTE';
push @EXPORT, qw(REMOTE);
use constant OFF => 'OFF';
push @EXPORT, qw(OFF);
@@ -50,12 +52,13 @@ use constant OFF => 'OFF';
####################################################################################################################################
my %oLogLevelRank;
$oLogLevelRank{TRACE}{rank} = 6;
$oLogLevelRank{DEBUG}{rank} = 5;
$oLogLevelRank{INFO}{rank} = 4;
$oLogLevelRank{WARN}{rank} = 3;
$oLogLevelRank{ERROR}{rank} = 2;
$oLogLevelRank{ASSERT}{rank} = 1;
$oLogLevelRank{TRACE}{rank} = 7;
$oLogLevelRank{DEBUG}{rank} = 6;
$oLogLevelRank{INFO}{rank} = 5;
$oLogLevelRank{WARN}{rank} = 4;
$oLogLevelRank{ERROR}{rank} = 3;
$oLogLevelRank{ASSERT}{rank} = 2;
$oLogLevelRank{REMOTE}{rank} = 1;
$oLogLevelRank{OFF}{rank} = 0;
####################################################################################################################################
@@ -63,11 +66,12 @@ $oLogLevelRank{OFF}{rank} = 0;
####################################################################################################################################
my $hLogFile;
my $strLogLevelFile = ERROR;
my $strLogLevelConsole = ERROR;
my $strLogLevelConsole = REMOTE;
# Test globals
my $bTest = false;
my $fTestDelay;
my $oTestPoint;
####################################################################################################################################
# Test constants
@@ -77,12 +81,16 @@ use constant TEST => 'TEST';
use constant TEST_ENCLOSE => 'PgBaCkReStTeSt';
push @EXPORT, qw(TEST_ENCLOSE);
use constant TEST_MANIFEST_BUILD => 'MANIFEST_BUILD';
use constant TEST_MANIFEST_BUILD => 'MANIFEST-BUILD';
push @EXPORT, qw(TEST_MANIFEST_BUILD);
use constant TEST_BACKUP_RESUME => 'BACKUP_RESUME';
use constant TEST_BACKUP_RESUME => 'BACKUP-RESUME';
push @EXPORT, qw(TEST_BACKUP_RESUME);
use constant TEST_BACKUP_NORESUME => 'BACKUP_NORESUME';
use constant TEST_BACKUP_NORESUME => 'BACKUP-NORESUME';
push @EXPORT, qw(TEST_BACKUP_NORESUME);
use constant TEST_BACKUP_START => 'BACKUP-START';
push @EXPORT, qw(TEST_BACKUP_START);
use constant TEST_ARCHIVE_PUSH_ASYNC_START => 'ARCHIVE-PUSH-ASYNC-START';
push @EXPORT, qw(TEST_ARCHIVE_PUSH_ASYNC_START);
####################################################################################################################################
# logFileSet - set the file messages will be logged to
@@ -94,7 +102,7 @@ sub logFileSet
unless (-e dirname($strFile))
{
mkdir(dirname($strFile), oct('0770'))
or die "unable to create directory for log file ${strFile}";
or die "unable to create directory " . dirname($strFile) . " for log file ${strFile}";
}
$strFile .= '-' . timestampFormat('%4d%02d%02d') . '.log';
@@ -422,6 +430,11 @@ sub log
# If test message
if ($strLevel eq TEST)
{
if (!defined($oTestPoint) || !defined($$oTestPoint{lc($strMessage)}))
{
return;
}
$iLogLevelRank = $oLogLevelRank{TRACE}{rank} + 1;
$strMessageFormat = TEST_ENCLOSE . '-' . $strMessageFormat . '-' . TEST_ENCLOSE;
}
@@ -484,6 +497,10 @@ sub log
usleep($fTestDelay * 1000000);
}
}
elsif ($strLogLevelConsole eq REMOTE && ($strLevel eq ASSERT || $strLevel eq ERROR))
{
syswrite(*STDERR, $strLevel . (defined($iCode) ? " [${iCode}]" : '') . ": $strMessage\n");
}
# Output to file depending on log level and test flag
if ($iLogLevelRank <= $oLogLevelRank{$strLogLevelFile}{rank})
@@ -527,10 +544,12 @@ sub testSet
{
my $bTestParam = shift;
my $fTestDelayParam = shift;
my $oTestPointParam = shift;
# Set defaults
$bTest = defined($bTestParam) ? $bTestParam : false;
$fTestDelay = defined($bTestParam) ? $fTestDelayParam : $fTestDelay;
$oTestPoint = $oTestPointParam;
# Make sure that a delay is specified in test mode
if ($bTest && !defined($fTestDelay))

249
lib/BackRest/Config/Config.pm
View File

@@ -67,6 +67,12 @@ use constant CMD_REMOTE => 'remote';
use constant CMD_RESTORE => 'restore';
push @EXPORT, qw(CMD_RESTORE);
$oCommandHash{&CMD_RESTORE} = true;
use constant CMD_START => 'start';
push @EXPORT, qw(CMD_START);
$oCommandHash{&CMD_START} = true;
use constant CMD_STOP => 'stop';
push @EXPORT, qw(CMD_STOP);
$oCommandHash{&CMD_STOP} = true;
use constant CMD_VERSION => 'version';
push @EXPORT, qw(CMD_VERSION);
$oCommandHash{&CMD_VERSION} = true;
@@ -220,6 +226,13 @@ use constant OPTION_HELP => 'help';
use constant OPTION_VERSION => 'version';
push @EXPORT, qw(OPTION_VERSION);
# Command-line only remote
#-----------------------------------------------------------------------------------------------------------------------------------
use constant OPTION_COMMAND => 'command';
push @EXPORT, qw(OPTION_COMMAND);
use constant OPTION_PROCESS => 'process';
push @EXPORT, qw(OPTION_PROCESS);
# Command-line only test
#-----------------------------------------------------------------------------------------------------------------------------------
use constant OPTION_TEST => 'test';
@@ -228,11 +241,15 @@ use constant OPTION_TEST_DELAY => 'test-del
push @EXPORT, qw(OPTION_TEST_DELAY);
use constant OPTION_TEST_NO_FORK => 'no-fork';
push @EXPORT, qw(OPTION_TEST_NO_FORK);
use constant OPTION_TEST_POINT => 'test-point';
push @EXPORT, qw(OPTION_TEST_POINT);
# GENERAL Section
#-----------------------------------------------------------------------------------------------------------------------------------
use constant OPTION_BUFFER_SIZE => 'buffer-size';
push @EXPORT, qw(OPTION_BUFFER_SIZE);
use constant OPTION_CONFIG_REMOTE => 'config-remote';
push @EXPORT, qw(OPTION_CONFIG_REMOTE);
use constant OPTION_DB_TIMEOUT => 'db-timeout';
push @EXPORT, qw(OPTION_DB_TIMEOUT);
use constant OPTION_COMPRESS => 'compress';
@@ -392,6 +409,10 @@ use constant OPTION_DEFAULT_REPO_PATH => '/var/lib
push @EXPORT, qw(OPTION_DEFAULT_REPO_PATH);
use constant OPTION_DEFAULT_THREAD_MAX => 1;
push @EXPORT, qw(OPTION_DEFAULT_THREAD_MAX);
use constant OPTION_DEFAULT_THREAD_MAX_MIN => 1;
push @EXPORT, qw(OPTION_DEFAULT_THREAD_MAX_MIN);
use constant OPTION_DEFAULT_THREAD_MAX_MAX => 256;
push @EXPORT, qw(OPTION_DEFAULT_THREAD_MAX_MAX);
# COMMAND Section
#-----------------------------------------------------------------------------------------------------------------------------------
@@ -441,6 +462,11 @@ use constant OPTION_DEFAULT_BACKUP_START_FAST => false;
use constant OPTION_DEFAULT_RESTORE_TABLESPACE => true;
push @EXPORT, qw(OPTION_DEFAULT_RESTORE_TABLESPACE);
# START/STOP SECTION
#-----------------------------------------------------------------------------------------------------------------------------------
use constant OPTION_DEFAULT_STOP_FORCE => false;
push @EXPORT, qw(OPTION_DEFAULT_STOP_FORCE);
# EXPIRE Section
#-----------------------------------------------------------------------------------------------------------------------------------
use constant OPTION_DEFAULT_RETENTION_ARCHIVE_TYPE => BACKUP_TYPE_FULL;
@@ -497,11 +523,6 @@ my %oOptionRule =
&OPTION_RULE_TYPE => OPTION_TYPE_BOOLEAN,
&OPTION_RULE_COMMAND =>
{
&CMD_RESTORE =>
{
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_RESTORE_FORCE,
},
&CMD_BACKUP =>
{
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_BACKUP_FORCE,
@@ -510,6 +531,16 @@ my %oOptionRule =
&OPTION_RULE_DEPEND_OPTION => OPTION_NO_START_STOP,
&OPTION_RULE_DEPEND_VALUE => true
}
},
&CMD_RESTORE =>
{
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_RESTORE_FORCE,
},
&CMD_STOP =>
{
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_STOP_FORCE
}
}
},
@@ -570,6 +601,14 @@ my %oOptionRule =
&CMD_RESTORE =>
{
&OPTION_RULE_REQUIRED => true
},
&CMD_START =>
{
&OPTION_RULE_REQUIRED => false
},
&CMD_STOP =>
{
&OPTION_RULE_REQUIRED => false
}
}
},
@@ -710,12 +749,39 @@ my %oOptionRule =
}
},
# Command-line only test
#-------------------------------------------------------------------------------------------------------------------------------
&OPTION_COMMAND =>
{
&OPTION_RULE_TYPE => OPTION_TYPE_STRING,
&OPTION_RULE_COMMAND =>
{
&CMD_REMOTE => true
}
},
&OPTION_PROCESS =>
{
&OPTION_RULE_TYPE => OPTION_TYPE_INTEGER,
&OPTION_RULE_REQUIRED => false,
&OPTION_RULE_ALLOW_RANGE => [OPTION_DEFAULT_THREAD_MAX_MIN, OPTION_DEFAULT_THREAD_MAX_MAX],
&OPTION_RULE_COMMAND =>
{
&CMD_REMOTE => true
}
},
# Command-line only test
#-------------------------------------------------------------------------------------------------------------------------------
&OPTION_TEST =>
{
&OPTION_RULE_TYPE => OPTION_TYPE_BOOLEAN,
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_TEST
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_TEST,
&OPTION_RULE_COMMAND =>
{
&CMD_ARCHIVE_PUSH => true,
&CMD_BACKUP => true
}
},
&OPTION_TEST_DELAY =>
@@ -726,6 +792,27 @@ my %oOptionRule =
{
&OPTION_RULE_DEPEND_OPTION => OPTION_TEST,
&OPTION_RULE_DEPEND_VALUE => true
},
&OPTION_RULE_COMMAND =>
{
&CMD_ARCHIVE_PUSH => true,
&CMD_BACKUP => true
}
},
&OPTION_TEST_POINT =>
{
&OPTION_RULE_TYPE => OPTION_TYPE_HASH,
&OPTION_RULE_REQUIRED => false,
&OPTION_RULE_DEPEND =>
{
&OPTION_RULE_DEPEND_OPTION => OPTION_TEST,
&OPTION_RULE_DEPEND_VALUE => true
},
&OPTION_RULE_COMMAND =>
{
&CMD_ARCHIVE_PUSH => true,
&CMD_BACKUP => true
}
},
@@ -733,9 +820,9 @@ my %oOptionRule =
{
&OPTION_RULE_TYPE => OPTION_TYPE_BOOLEAN,
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_TEST_NO_FORK,
&OPTION_RULE_DEPEND =>
&OPTION_RULE_COMMAND =>
{
&OPTION_RULE_DEPEND_OPTION => OPTION_TEST
&CMD_ARCHIVE_PUSH => true
}
},
@@ -768,8 +855,13 @@ my %oOptionRule =
&OPTION_RULE_SECTION_INHERIT => CONFIG_SECTION_GENERAL,
&OPTION_RULE_COMMAND =>
{
&CMD_ARCHIVE_GET => true,
&CMD_ARCHIVE_PUSH => true,
&CMD_BACKUP => true,
&CMD_REMOTE => true
&CMD_EXPIRE => false,
&CMD_INFO => true,
&CMD_REMOTE => true,
&CMD_RESTORE => true
}
},
@@ -827,6 +919,22 @@ my %oOptionRule =
}
},
&OPTION_CONFIG_REMOTE =>
{
&OPTION_RULE_TYPE => OPTION_TYPE_STRING,
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_CONFIG,
&OPTION_RULE_SECTION => CONFIG_SECTION_GENERAL,
&OPTION_RULE_COMMAND =>
{
&CMD_ARCHIVE_GET => true,
&CMD_ARCHIVE_PUSH => true,
&CMD_BACKUP => true,
&CMD_INFO => true,
&CMD_RESTORE => true,
&CMD_EXPIRE => true
},
},
&OPTION_NEUTRAL_UMASK =>
{
&OPTION_RULE_TYPE => OPTION_TYPE_BOOLEAN,
@@ -840,7 +948,9 @@ my %oOptionRule =
&CMD_INFO => false,
&CMD_EXPIRE => false,
&CMD_REMOTE => true,
&CMD_RESTORE => true
&CMD_RESTORE => true,
&CMD_START => false,
&CMD_STOP => false
}
},
@@ -855,7 +965,10 @@ my %oOptionRule =
&CMD_ARCHIVE_PUSH => true,
&CMD_BACKUP => true,
&CMD_INFO => true,
&CMD_REMOTE => true,
&CMD_RESTORE => true,
&CMD_START => true,
&CMD_STOP => true,
&CMD_EXPIRE => true
},
},
@@ -880,6 +993,7 @@ my %oOptionRule =
{
&OPTION_RULE_TYPE => OPTION_TYPE_INTEGER,
&OPTION_RULE_DEFAULT => OPTION_DEFAULT_THREAD_MAX,
&OPTION_RULE_ALLOW_RANGE => [OPTION_DEFAULT_THREAD_MAX_MIN, OPTION_DEFAULT_THREAD_MAX_MAX],
&OPTION_RULE_SECTION => true,
&OPTION_RULE_SECTION_INHERIT => CONFIG_SECTION_GENERAL,
&OPTION_RULE_COMMAND =>
@@ -1186,7 +1300,6 @@ my %oOptionRule =
# RESTORE Section
#-------------------------------------------------------------------------------------------------------------------------------
&OPTION_TABLESPACE =>
{
&OPTION_RULE_TYPE => OPTION_TYPE_BOOLEAN,
@@ -2018,6 +2131,7 @@ sub protocolGet
{
my $bForceLocal = shift;
my $bStore = shift;
my $iProcessIdx = shift;
# If force local or remote = NONE then create a local remote and return it
if ((defined($bForceLocal) && $bForceLocal) || optionRemoteTypeTest(NONE))
@@ -2026,7 +2140,8 @@ sub protocolGet
(
optionGet(OPTION_BUFFER_SIZE),
commandTest(CMD_EXPIRE) ? OPTION_DEFAULT_COMPRESS_LEVEL : optionGet(OPTION_COMPRESS_LEVEL),
commandTest(CMD_EXPIRE) ? OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK : optionGet(OPTION_COMPRESS_LEVEL_NETWORK)
commandTest(CMD_EXPIRE) ? OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK : optionGet(OPTION_COMPRESS_LEVEL_NETWORK),
protocolTimeoutGet()
);
}
@@ -2039,12 +2154,16 @@ sub protocolGet
# Return the remote when required
my $oProtocolTemp = new BackRest::Protocol::RemoteMaster
(
commandWrite(CMD_REMOTE, true, optionGet(OPTION_COMMAND_REMOTE)),
commandWrite(CMD_REMOTE, true, optionGet(OPTION_COMMAND_REMOTE), undef,
{&OPTION_COMMAND => {value => commandGet()}, &OPTION_PROCESS => {value => $iProcessIdx}, &OPTION_CONFIG =>
{value => optionSource(OPTION_CONFIG_REMOTE) eq SOURCE_DEFAULT ? undef : optionGet(OPTION_CONFIG_REMOTE)},
&OPTION_REPO_PATH => {}}),
optionGet(OPTION_BUFFER_SIZE),
commandTest(CMD_EXPIRE) ? OPTION_DEFAULT_COMPRESS_LEVEL : optionGet(OPTION_COMPRESS_LEVEL),
commandTest(CMD_EXPIRE) ? OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK : optionGet(OPTION_COMPRESS_LEVEL_NETWORK),
optionRemoteTypeTest(DB) ? optionGet(OPTION_DB_HOST) : optionGet(OPTION_BACKUP_HOST),
optionRemoteTypeTest(DB) ? optionGet(OPTION_DB_USER) : optionGet(OPTION_BACKUP_USER)
optionRemoteTypeTest(DB) ? optionGet(OPTION_DB_USER) : optionGet(OPTION_BACKUP_USER),
protocolTimeoutGet()
);
if (!defined($bStore) || $bStore)
@@ -2057,6 +2176,18 @@ sub protocolGet
push @EXPORT, qw(protocolGet);
####################################################################################################################################
# protocolTimeoutGet
#
# Get the protocol time - for the moment this is based on the db timeout + 30 seconds.
####################################################################################################################################
sub protocolTimeoutGet
{
return optionGet(OPTION_DB_TIMEOUT) + 30;
}
push @EXPORT, qw(protocolTimeoutGet);
####################################################################################################################################
# protocolDestroy
#
@@ -2066,6 +2197,7 @@ sub protocolDestroy
{
if (defined($oProtocol))
{
$oProtocol->close();
undef($oProtocol);
}
}
@@ -2155,38 +2287,79 @@ sub commandWrite
my $bIncludeConfig = shift;
my $strExeString = shift;
my $bIncludeCommand = shift;
my $oOptionOverride = shift;
# Set defaults
$strExeString = defined($strExeString) ? $strExeString : abs_path($0);
$bIncludeConfig = defined($bIncludeConfig) ? $bIncludeConfig : false;
$bIncludeCommand = defined($bIncludeCommand) ? $bIncludeCommand : true;
if ($bIncludeConfig && $strExeString ne '')
# if ($bIncludeConfig && $strExeString ne '')
# {
# $strExeString .= ' --no-config';
# }
# Function to correctly format options for command-line usage
sub optionFormat
{
$strExeString .= ' --no-config';
my $strOption = shift;
my $bMulti = shift;
my $oValue = shift;
# Loops though all keys in the hash
my $strOptionFormat = '';
my $strParam;
foreach my $strKey (sort(keys(%$oValue)))
{
# Get the value - if the original value was a hash then the key must be prefixed
my $strValue = ($bMulti ? "${strKey}=" : '') . $$oValue{$strKey};
# Handle the no- prefix for boolean values
if ($oOptionRule{$strOption}{&OPTION_RULE_TYPE} eq OPTION_TYPE_BOOLEAN)
{
$strParam = '--' . ($strValue ? '' : 'no-') . $strOption;
}
else
{
$strParam = "--${strOption}=${strValue}";
}
# Add quotes if the value has spaces in it
$strOptionFormat .= ' ' . (index($strValue, " ") != -1 ? "\"${strParam}\"" : $strParam);
}
return $strOptionFormat;
}
foreach my $strOption (sort(keys(%oOption)))
# Iterate the options to figure out which ones are not default and need to be written out to the new command string
foreach my $strOption (sort(keys(%oOptionRule)))
{
next if ($bIncludeConfig && $strOption eq OPTION_CONFIG);
# Skip the config option if it's already included
# next if ($bIncludeConfig && $strOption eq OPTION_CONFIG);
# &log(WARN, "option ${strOption} = " . (defined($oOption{$strOption}{source}) ? $oOption{$strOption}{source} : 'undef') .
# ", " . (defined($oOption{$strOption}{value}) ? $oOption{$strOption}{value} : 'undef'));
if ((!defined($oOptionRule{$strOption}{&OPTION_RULE_COMMAND}) ||
defined($oOptionRule{$strOption}{&OPTION_RULE_COMMAND}{$strNewCommand})) &&
defined($oOption{$strOption}{value}) &&
($bIncludeConfig ? $oOption{$strOption}{source} ne SOURCE_DEFAULT : $oOption{$strOption}{source} eq SOURCE_PARAM))
# Process any option overrides first
if (defined($$oOptionOverride{$strOption}))
{
if (defined($$oOptionOverride{$strOption}{value}))
{
$strExeString .= optionFormat($strOption, false, {value => $$oOptionOverride{$strOption}{value}});
}
}
# else look for non-default options in the current configuration
elsif ((!defined($oOptionRule{$strOption}{&OPTION_RULE_COMMAND}) ||
defined($oOptionRule{$strOption}{&OPTION_RULE_COMMAND}{$strNewCommand})) &&
defined($oOption{$strOption}{value}) &&
($bIncludeConfig ? $oOption{$strOption}{source} ne SOURCE_DEFAULT : $oOption{$strOption}{source} eq SOURCE_PARAM))
{
my $strParam;
my $oValue;
my $bHash = false;
my $bMulti = false;
# If this is a hash then it will break up into multple command-line options
if (ref($oOption{$strOption}{value}) eq 'HASH')
{
$oValue = $oOption{$strOption}{value};
$bHash = true;
$bMulti = true;
}
# Else a single value but store it in a hash anyway to make processing below simpler
else
@@ -2194,25 +2367,7 @@ sub commandWrite
$oValue = {value => $oOption{$strOption}{value}};
}
# Loops though all keys in the hash
foreach my $strKey (sort(keys(%$oValue)))
{
# Get the value - if the original value was a hash then the key must be prefixed
my $strValue = ($bHash ? "${strKey}=" : '') . $$oValue{$strKey};
# Handle the no- prefix for boolean values
if ($oOptionRule{$strOption}{&OPTION_RULE_TYPE} eq OPTION_TYPE_BOOLEAN)
{
$strParam = '--' . ($strValue ? '' : 'no-') . $strOption;
}
else
{
$strParam = "--${strOption}=${strValue}";
}
# Add quotes if the value has spaces in it
$strExeString .= ' ' . (index($strValue, " ") != -1 ? "\"${strParam}\"" : $strParam);
}
$strExeString .= optionFormat($strOption, $bMulti, $oValue);
}
}

73
lib/BackRest/Config/ConfigHelpData.pm
View File

@@ -188,6 +188,18 @@ my $oConfigHelpData =
"Use this option to specify a different configuration file than the default."
},
# CONFIG-REMOTE Option Help
#---------------------------------------------------------------------------------------------------------------------------
'config-remote' =>
{
section => 'general',
summary =>
"pgBackRest remote configuration file.",
description =>
"Sets the location of the remote configuration file. This is only required if the remote configuration file is " .
"in a different location than the local configuration file."
},
# DB-HOST Option Help
#---------------------------------------------------------------------------------------------------------------------------
'db-host' =>
@@ -567,7 +579,9 @@ my $oConfigHelpData =
'compress-level' => 'section',
'compress-level-network' => 'section',
'config' => 'default',
'config-remote' => 'section',
'db-path' => 'section',
'db-timeout' => 'section',
'log-level-console' => 'section',
'log-level-file' => 'section',
'neutral-umask' => 'section',
@@ -599,7 +613,9 @@ my $oConfigHelpData =
'compress-level' => 'section',
'compress-level-network' => 'section',
'config' => 'default',
'config-remote' => 'section',
'db-path' => 'section',
'db-timeout' => 'section',
'log-level-console' => 'section',
'log-level-file' => 'section',
'neutral-umask' => 'section',
@@ -629,6 +645,7 @@ my $oConfigHelpData =
'compress-level' => 'section',
'compress-level-network' => 'section',
'config' => 'default',
'config-remote' => 'section',
'db-host' => 'section',
'db-path' => 'section',
'db-port' => 'section',
@@ -717,6 +734,7 @@ my $oConfigHelpData =
option =>
{
'config-remote' => 'section',
'log-level-console' => 'section',
'log-level-file' => 'section',
'repo-path' => 'section',
@@ -765,6 +783,8 @@ my $oConfigHelpData =
'compress-level' => 'section',
'compress-level-network' => 'section',
'config' => 'default',
'config-remote' => 'section',
'db-timeout' => 'section',
'log-level-console' => 'section',
'log-level-file' => 'section',
@@ -806,6 +826,8 @@ my $oConfigHelpData =
'compress-level' => 'section',
'compress-level-network' => 'section',
'config' => 'default',
'config-remote' => 'section',
'db-timeout' => 'section',
# DELTA Option Help
#-------------------------------------------------------------------------------------------------------------------
@@ -960,6 +982,57 @@ my $oConfigHelpData =
}
},
# START Command Help
#---------------------------------------------------------------------------------------------------------------------------
'start' =>
{
summary =>
"Allow pgBackRest processes to run.",
description =>
"If the pgBackRest processes were previously stopped using the stop command then they can be started again " .
"using the start command. Note that this will not immediately start up any pgBackRest processes but they " .
"are allowed to run.",
option =>
{
'repo-path' => 'section',
'stanza' => 'default'
}
},
# STOP Command Help
#---------------------------------------------------------------------------------------------------------------------------
'stop' =>
{
summary =>
"Stop pgBackRest processes from running.",
description =>
"Does not allow any new pgBackRest processes to run. By default running processes will be allowed to complete " .
"successfully. Use the --force option to terminate running processes.\n" .
"\n" .
"pgBackRest processes will return an error if they are run after the stop command completes.",
option =>
{
# FORCE Option Help
#-------------------------------------------------------------------------------------------------------------------
'force' =>
{
summary =>
"Force all pgBackRest processes to stop.",
description =>
"This option will send TERM signals to all running pgBackRest processes to effect a graceful but " .
"immediate shutdown. Note that this will also shutdown processes that were initiated on another " .
"system but have remotes running on the current system. For instance, if a backup was started on " .
"the backup server then running stop --force on the database server will shutdown the backup " .
"process on the backup server."
},
'repo-path' => 'section',
'stanza' => 'default'
}
},
# VERSION Command Help
#---------------------------------------------------------------------------------------------------------------------------
'version' =>

13
lib/BackRest/Db.pm
View File

@@ -597,7 +597,7 @@ sub backupStart
# Get version and db path from the database
my ($fCompareDbVersion, $strCompareDbPath) = $self->versionGet();
# Error if they are not identical
# Error if the version from the control file and the configured db-path do not match the values obtained from the database
if (!($fDbVersion == $fCompareDbVersion && $strDbPath eq $strCompareDbPath))
{
confess &log(ERROR, "version '${fCompareDbVersion}' and db-path '${strCompareDbPath}' queried from cluster does not match" .
@@ -612,18 +612,21 @@ sub backupStart
$bStartFast = false;
}
# Acquire the backup advisory lock
# Acquire the backup advisory lock to make sure that backups are not running from multiple backup servers against the same
# database cluster. This lock helps make the stop-auto option safe.
if (!$self->executeSqlOne('select pg_try_advisory_lock(' . DB_BACKUP_ADVISORY_LOCK . ')'))
{
confess &log(ERROR, "unable to acquire backup lock\n" .
'HINT: is another backup already running on this cluster?', ERROR_LOCK_ACQUIRE);
}
# Test if a backup is already running when version >= 9.3
# If stop-auto is enabled check for a running backup
if (optionGet(OPTION_STOP_AUTO))
{
# Running backups can only be detected in PostgreSQL >= 9.3
if ($self->{fDbVersion} >= 9.3)
{
# If a backup is currently in progress emit a warning and then stop it
if ($self->executeSqlOne('select pg_is_in_backup()'))
{
&log(WARN, 'the cluster is already in backup mode but no backup process is running. pg_stop_backup() will be called' .
@@ -631,12 +634,15 @@ sub backupStart
$self->backupStop();
}
}
# Else emit a warning that the feature is not supported and continue. If a backup is running then an error will be
# generated later on.
else
{
&log(WARN, OPTION_STOP_AUTO . 'option is only available in PostgreSQL >= 9.3');
}
}
# Start the backup
&log(INFO, "execute pg_start_backup() with label \"${strLabel}\": backup begins after " .
($bStartFast ? "the requested immediate checkpoint" : "the next regular checkpoint") . " completes");
@@ -671,6 +677,7 @@ sub backupStop
OP_DB_BACKUP_STOP
);
# Stop the backup
&log(INFO, 'execute pg_stop_backup() and wait for all WAL segments to archive');
my ($strTimestampDbStop, $strArchiveStop) =

44
lib/BackRest/Expire.pm
View File

@@ -25,6 +25,7 @@ use BackRest::Manifest;
####################################################################################################################################
use constant OP_EXPIRE => 'Expire';
use constant OP_EXPIRE_DESTROY => OP_EXPIRE . '->DESTROY';
use constant OP_EXPIRE_NEW => OP_EXPIRE . '->new';
use constant OP_EXPIRE_PROCESS => OP_EXPIRE . '->process';
@@ -40,15 +41,16 @@ sub new
bless $self, $class;
# Assign function parameters, defaults, and log debug info
my ($strOperation) = logDebugParam(OP_EXPIRE_NEW);
# Initialize file object
$self->{oFile} = new BackRest::File
(
my $strOperation,
$self->{oFile}
) =
logDebugParam
(
OP_EXPIRE_NEW, \@_,
{name => 'oFile'}
);
optionGet(OPTION_STANZA),
optionRemoteTypeTest(BACKUP) ? optionGet(OPTION_REPO_REMOTE_PATH) : optionGet(OPTION_REPO_PATH),
optionRemoteType(),
protocolGet()
);
# Return from function and log return values if any
return logDebugReturn
@@ -58,6 +60,32 @@ sub new
);
}
####################################################################################################################################
# DESTROY
####################################################################################################################################
sub DESTROY
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_EXPIRE_DESTROY
);
undef($self->{oFile});
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
####################################################################################################################################
# process
#

12
lib/BackRest/File.pm
View File

@@ -1758,11 +1758,7 @@ sub copy
$strOperation = OP_FILE_COPY_OUT;
$strRemote = 'in';
if ($strSourcePathType eq PIPE_STDIN)
{
$hIn = *STDIN;
}
else
if ($strSourcePathType ne PIPE_STDIN)
{
$oParamHash{source_file} = $strSourceOp;
$oParamHash{source_compressed} = $bSourceCompressed;
@@ -1776,11 +1772,7 @@ sub copy
$strOperation = OP_FILE_COPY_IN;
$strRemote = 'out';
if ($strDestinationPathType eq PIPE_STDOUT)
{
$hOut = *STDOUT;
}
else
if ($strDestinationPathType ne PIPE_STDOUT)
{
$oParamHash{destination_file} = $strDestinationOp;
$oParamHash{source_compressed} = $bSourceCompressed;

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

@@ -9,7 +9,6 @@ use Carp qw(confess);
use Compress::Raw::Zlib qw(WANT_GZIP Z_OK Z_BUF_ERROR Z_STREAM_END);
use File::Basename qw(dirname);
use IO::String qw();
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
@@ -39,17 +38,19 @@ sub new
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{iBlockSize},
$self->{iBufferMax},
$self->{iCompressLevel},
$self->{iCompressLevelNetwork},
$self->{iProtocolTimeout},
$self->{strName}
) =
logDebugParam
(
OP_PROTOCOL_COMMON_NEW, \@_,
{name => 'iBlockSize', trace => true},
{name => 'iBufferMax', trace => true},
{name => 'iCompressLevel', trace => true},
{name => 'iCompressNetworkLevel', trace => true},
{name => 'iProtocolTimeout', trace => true},
{name => 'strName', required => false, trace => true}
);
@@ -67,23 +68,6 @@ sub new
);
}
####################################################################################################################################
# pipeToString
#
# Copies data from a file handle into a string.
####################################################################################################################################
sub pipeToString
{
my $self = shift;
my $hOut = shift;
my $strBuffer;
my $hString = IO::String->new($strBuffer);
$self->binaryXfer($hOut, $hString);
return $strBuffer;
}
####################################################################################################################################
# blockRead
#
@@ -92,7 +76,7 @@ sub pipeToString
sub blockRead
{
my $self = shift;
my $io = shift;
my $oIn = shift;
my $strBlockRef = shift;
my $bProtocol = shift;
@@ -102,12 +86,11 @@ sub blockRead
if ($bProtocol)
{
# Read the block header and make sure it's valid
my $strBlockHeader = $self->{io}->lineRead();
my $strBlockHeader = $oIn->lineRead();
if ($strBlockHeader !~ /^block -{0,1}[0-9]+( .*){0,1}$/)
{
$self->{io}->waitPid();
confess "unable to read block header ${strBlockHeader}";
confess &log(ERROR, "invalid block header ${strBlockHeader}", ERROR_FILE_READ);
}
# Get block size from the header
@@ -123,24 +106,12 @@ sub blockRead
# Else read the block
else
{
my $iBlockRead = 0;
my $iBlockIn = 0;
my $iOffset = defined($$strBlockRef) ? length($$strBlockRef) : 0;
# !!! Would be nice to modify this with a non-blocking read
# http://docstore.mik.ua/orelly/perl/cookbook/ch07_15.htm
# Read as many chunks as it takes to get the full block
while ($iBlockRead != $iBlockSize)
{
$iBlockIn = $io->bufferRead($strBlockRef, $iBlockSize - $iBlockRead, $iBlockRead + $iOffset);
$iBlockRead += $iBlockIn;
}
$oIn->bufferRead($strBlockRef, $iBlockSize, undef, true);
}
}
else
{
$iBlockSize = $io->bufferRead($strBlockRef, $self->{iBlockSize}, defined($$strBlockRef) ? length($$strBlockRef) : undef);
$iBlockSize = $oIn->bufferRead($strBlockRef, $self->{iBufferMax}, defined($$strBlockRef) ? length($$strBlockRef) : undef);
}
# Return the block size
@@ -155,7 +126,7 @@ sub blockRead
sub blockWrite
{
my $self = shift;
my $io = shift;
my $oOut = shift;
my $tBlockRef = shift;
my $iBlockSize = shift;
my $bProtocol = shift;
@@ -167,13 +138,13 @@ sub blockWrite
# Write block header to the protocol stream
if ($bProtocol)
{
$io->lineWrite("block ${iBlockSize}" . (defined($strMessage) ? " ${strMessage}" : ''));
$oOut->lineWrite("block ${iBlockSize}" . (defined($strMessage) ? " ${strMessage}" : ''));
}
# Write block if size > 0
if ($iBlockSize > 0)
{
$io->bufferWrite($tBlockRef, $iBlockSize);
$oOut->bufferWrite($tBlockRef, $iBlockSize);
}
}
@@ -194,33 +165,29 @@ sub binaryXfer
my $bProtocol = shift;
# The input stream must be defined
my $oIn;
if (!defined($hIn))
{
if (defined($self->{io}))
{
$hIn = $self->{io}->hInGet();
}
else
{
confess &log(ASSERT, 'hIn is not defined');
}
$oIn = $self->{io};
}
else
{
$oIn = new BackRest::Protocol::IO($hIn, undef, $self->{io}->{hErr}, $self->{io}->{pid},
$self->{iProtocolTimeout}, $self->{iBufferMax});
}
# The output stream must be defined unless 'none' is passed
my $oOut;
if (!defined($hOut))
{
if (defined($self->{io}))
{
$hOut = $self->{io}->hOutGet();
}
else
{
confess &log(ASSERT, 'hOut is not defined');
}
$oOut = $self->{io};
}
elsif ($hOut eq 'none')
elsif ($hOut ne 'none')
{
undef($hOut);
$oOut = new BackRest::Protocol::IO(undef, $hOut, $self->{io}->{hErr}, $self->{io}->{pid},
$self->{iProtocolTimeout}, $self->{iBufferMax});
}
# If no remote is defined then set to none
@@ -239,9 +206,6 @@ sub binaryXfer
$bProtocol = defined($bProtocol) ? $bProtocol : true;
my $strMessage = undef;
# Create IO object for this transfer
my $io = new BackRest::Protocol::IO($hIn, $hOut, $self->{io}->{hErr}, $self->{io}->{pid});
# Checksum and size
my $strChecksum = undef;
my $iFileSize = undef;
@@ -268,7 +232,7 @@ sub binaryXfer
# Initialize inflate object and check for errors
my ($oZLib, $iZLibStatus) =
new Compress::Raw::Zlib::Inflate(WindowBits => 15 & $bSourceCompressed ? WANT_GZIP : 0,
Bufsize => $self->{iBlockSize}, LimitOutput => 1);
Bufsize => $self->{iBufferMax}, LimitOutput => 1);
if ($iZLibStatus != Z_OK)
{
@@ -279,7 +243,7 @@ sub binaryXfer
do
{
# Read a block from the input stream
($iBlockSize, $strMessage) = $self->blockRead($io, \$tCompressedBuffer, $bProtocol);
($iBlockSize, $strMessage) = $self->blockRead($oIn, \$tCompressedBuffer, $bProtocol);
# Process protocol messages
if (defined($strMessage) && $strMessage eq 'nochecksum')
@@ -310,9 +274,9 @@ sub binaryXfer
}
# Write data if hOut is defined
if (defined($hOut))
if (defined($oOut))
{
$io->bufferWrite(\$tUncompressedBuffer, $iUncompressedBufferSize);
$oOut->bufferWrite(\$tUncompressedBuffer, $iUncompressedBufferSize);
}
}
}
@@ -359,7 +323,7 @@ sub binaryXfer
do
{
# Read a block from the protocol stream
($iBlockSize, $strMessage) = $self->blockRead($io, \$tBuffer, $bProtocol);
($iBlockSize, $strMessage) = $self->blockRead($oIn, \$tBuffer, $bProtocol);
# If the block contains data, write it
if ($iBlockSize > 0)
@@ -371,7 +335,7 @@ sub binaryXfer
$iFileSize += $iBlockSize;
}
$io->bufferWrite(\$tBuffer, $iBlockSize);
$oOut->bufferWrite(\$tBuffer, $iBlockSize);
undef($tBuffer);
}
}
@@ -396,7 +360,7 @@ sub binaryXfer
my $tUncompressedBuffer;
# Initialize message to indicate that a checksum will be sent
if ($bProtocol && defined($hOut))
if ($bProtocol && defined($oOut))
{
$strMessage = 'checksum';
}
@@ -409,7 +373,7 @@ sub binaryXfer
new Compress::Raw::Zlib::Deflate(WindowBits => 15 & $bDestinationCompress ? WANT_GZIP : 0,
Level => $bDestinationCompress ? $self->{iCompressLevel} :
$self->{iCompressLevelNetwork},
Bufsize => $self->{iBlockSize}, AppendOutput => 1);
Bufsize => $self->{iBufferMax}, AppendOutput => 1);
if ($iZLibStatus != Z_OK)
{
@@ -419,7 +383,7 @@ sub binaryXfer
do
{
# Read a block from the stream
$iBlockSize = $io->bufferRead(\$tUncompressedBuffer, $self->{iBlockSize});
$iBlockSize = $oIn->bufferRead(\$tUncompressedBuffer, $self->{iBufferMax});
# If block size > 0 then compress
if ($iBlockSize > 0)
@@ -435,9 +399,9 @@ sub binaryXfer
if ($iZLibStatus == Z_OK)
{
# The compressed data is larger than block size, then write
if ($iCompressedBufferSize > $self->{iBlockSize})
if ($iCompressedBufferSize > $self->{iBufferMax})
{
$self->blockWrite($io, \$tCompressedBuffer, $iCompressedBufferSize, $bProtocol, $strMessage);
$self->blockWrite($oOut, \$tCompressedBuffer, $iCompressedBufferSize, $bProtocol, $strMessage);
undef($tCompressedBuffer);
undef($strMessage);
}
@@ -468,17 +432,17 @@ sub binaryXfer
$iFileSize = $oZLib->total_in();
# Write out the last block
if (defined($hOut))
if (defined($oOut))
{
$iCompressedBufferSize = length($tCompressedBuffer);
if ($iCompressedBufferSize > 0)
{
$self->blockWrite($io, \$tCompressedBuffer, $iCompressedBufferSize, $bProtocol, $strMessage);
$self->blockWrite($oOut, \$tCompressedBuffer, $iCompressedBufferSize, $bProtocol, $strMessage);
undef($strMessage);
}
$self->blockWrite($io, undef, 0, $bProtocol, "${strChecksum}-${iFileSize}");
$self->blockWrite($oOut, undef, 0, $bProtocol, "${strChecksum}-${iFileSize}");
}
}
# If source is already compressed or transfer is not compressed then just read the stream
@@ -507,7 +471,7 @@ sub binaryXfer
# Initialize inflate object and check for errors
($oZLib, $iZLibStatus) =
new Compress::Raw::Zlib::Inflate(WindowBits => WANT_GZIP, Bufsize => $self->{iBlockSize}, LimitOutput => 1);
new Compress::Raw::Zlib::Inflate(WindowBits => WANT_GZIP, Bufsize => $self->{iBufferMax}, LimitOutput => 1);
if ($iZLibStatus != Z_OK)
{
@@ -523,12 +487,12 @@ sub binaryXfer
# Read input
do
{
$iBlockSize = $io->bufferRead(\$tBuffer, $self->{iBlockSize});
$iBlockSize = $oIn->bufferRead(\$tBuffer, $self->{iBufferMax});
# Write a block if size > 0
if ($iBlockSize > 0)
{
$self->blockWrite($io, \$tBuffer, $iBlockSize, $bProtocol, $strMessage);
$self->blockWrite($oOut, \$tBuffer, $iBlockSize, $bProtocol, $strMessage);
undef($strMessage);
}
@@ -599,7 +563,7 @@ sub binaryXfer
if ($bProtocol)
{
# Write 0 block to indicate end of stream
$self->blockWrite($io, undef, 0, $bProtocol, $strMessage);
$self->blockWrite($oOut, undef, 0, $bProtocol, $strMessage);
}
}
}

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

@@ -40,22 +40,24 @@ sub new
$strOperation,
$strName, # Name of the protocol
$strCommand, # Command to execute on local/remote
$iBlockSize, # Buffer size
$iBufferMax, # Maximum buffer size
$iCompressLevel, # Set compression level
$iCompressLevelNetwork # Set compression level for network only compression
$iCompressLevelNetwork, # Set compression level for network only compression
$iProtocolTimeout # Protocol timeout
) =
logDebugParam
(
OP_PROTOCOL_COMMON_MASTER_NEW, \@_,
{name => 'strName'},
{name => 'strCommand'},
{name => 'iBlockSize'},
{name => 'iBufferMax'},
{name => 'iCompressLevel'},
{name => 'iCompressLevelNetwork'}
{name => 'iCompressLevelNetwork'},
{name => 'iProtocolTimeout'}
);
# Create the class hash
my $self = $class->SUPER::new($iBlockSize, $iCompressLevel, $iCompressLevelNetwork, $strName);
my $self = $class->SUPER::new($iBufferMax, $iCompressLevel, $iCompressLevelNetwork, $iProtocolTimeout, $strName);
bless $self, $class;
# Set command
@@ -65,7 +67,7 @@ sub new
}
# Execute the command
$self->{io} = BackRest::Protocol::IO->new3($strCommand);
$self->{io} = BackRest::Protocol::IO->new3($strCommand, $iProtocolTimeout, $iBufferMax);
# Check greeting to be sure the protocol matches
$self->greetingRead();
@@ -79,9 +81,9 @@ sub new
}
####################################################################################################################################
# DESTROY
# close
####################################################################################################################################
sub DESTROY
sub close
{
my $self = shift;
@@ -92,6 +94,8 @@ sub DESTROY
$self->cmdWrite('exit');
undef($self->{io});
# &log(TRACE, "waiting for remote process");
# if (!$self->waitPid(5, false))
# {
@@ -101,6 +105,16 @@ sub DESTROY
}
}
####################################################################################################################################
# DESTROY
####################################################################################################################################
sub DESTROY
{
my $self = shift;
$self->close();
}
####################################################################################################################################
# greetingRead
#
@@ -154,7 +168,7 @@ sub outputRead
my $strError;
# Read output lines
while ($strLine = $self->{io}->lineRead(false))
while ($strLine = $self->{io}->lineRead())
{
# Exit if an error is found
if ($strLine =~ /^ERROR.*/)
@@ -278,7 +292,11 @@ sub cmdWrite
{name => 'strCommand', value => $strCommand, trace => true}
);
# Write out the command
$self->{io}->lineWrite($strCommand);
# Return from function and log return values if any
logDebugReturn($strOperation);
}
####################################################################################################################################

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

@@ -39,25 +39,31 @@ sub new
(
$strOperation,
$strName, # Name of the protocol
$iBlockSize, # Buffer size
$strCommand, # Command the master process is running
$iBufferMax, # Maximum buffer size
$iCompressLevel, # Set compression level
$iCompressLevelNetwork # Set compression level for network only compression
$iCompressLevelNetwork, # Set compression level for network only compression
$iProtocolTimeout # Protocol timeout
) =
logDebugParam
(
OP_PROTOCOL_COMMON_MINION_NEW, \@_,
{name => 'strName'},
{name => 'iBlockSize'},
{name => 'strCommand'},
{name => 'iBufferMax'},
{name => 'iCompressLevel'},
{name => 'iCompressLevelNetwork'}
{name => 'iCompressLevelNetwork'},
{name => 'iProtocolTimeout'}
);
# Create the class hash
my $self = $class->SUPER::new($iBlockSize, $iCompressLevel, $iCompressLevelNetwork, $strName);
my $self = $class->SUPER::new($iBufferMax, $iCompressLevel, $iCompressLevelNetwork, $iProtocolTimeout, $strName);
bless $self, $class;
$self->{strCommand} = $strCommand;
# Create the IO object with std io
$self->{io} = new BackRest::Protocol::IO(*STDIN, *STDOUT, *STDERR);
$self->{io} = new BackRest::Protocol::IO(*STDIN, *STDOUT, *STDERR, undef, $iProtocolTimeout, $iBufferMax);
# Write the greeting so master process knows who we are
$self->greetingWrite();
@@ -130,15 +136,13 @@ sub errorWrite
# Else terminate the process with an error
else
{
$self->{io}->errorWrite('unknown error object');
exit ERROR_UNKNOWN;
confess &log(ERROR, 'unknown error object', ERROR_UNKNOWN);
}
}
# Else terminate the process with an error
else
{
$self->{io}->errorWrite('unknown error: ' . $oMessage);
exit ERROR_UNKNOWN;
confess &log(ERROR, 'unknown error: ' . $oMessage, ERROR_UNKNOWN);
}
# Write the message text into protocol

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

@@ -9,7 +9,10 @@ use Carp qw(confess);
use File::Basename qw(dirname);
use IPC::Open3 qw(open3);
use IO::Select;
use POSIX qw(:sys_wait_h);
use Symbol 'gensym';
use Time::HiRes qw(gettimeofday);
use lib dirname($0) . '/../lib';
use BackRest::Common::Exception;
@@ -42,7 +45,9 @@ sub new
$self->{hIn}, # Input stream
$self->{hOut}, # Output stream
$self->{hErr}, # Error stream
$self->{pId} # Process ID
$self->{pId}, # Process ID
$self->{iProtocolTimeout}, # Protocol timeout
$self->{iBufferMax} # Maximum buffer size
) =
logDebugParam
(
@@ -50,9 +55,17 @@ sub 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}
{name => 'pId', required => false, trace => true},
{name => 'iProtocolTimeout', trace => true},
{name => 'iBufferMax', trace => true}
);
if (defined($self->{hIn}))
{
$self->{oInSelect} = IO::Select->new();
$self->{oInSelect}->add($self->{hIn});
}
# Return from function and log return values if any
return logDebugReturn
(
@@ -74,16 +87,21 @@ sub new3
my
(
$strOperation,
$strCommand
$strCommand,
$iProtocolTimeout, # Protocol timeout
$iBufferMax # Maximum buffer Size
) =
logDebugParam
(
OP_IO_PROTOCOL_NEW3, \@_,
{name => 'strCommand', trace => true}
{name => 'strCommand', trace => true},
{name => 'iProtocolTimeout', trace => true},
{name => 'iBufferMax', trace => true}
);
# Use open3 to run the command
my ($pId, $hIn, $hOut, $hErr);
$hErr = gensym;
$pId = IPC::Open3::open3($hIn, $hOut, $hErr, $strCommand);
@@ -91,7 +109,7 @@ sub new3
return logDebugReturn
(
$strOperation,
{name => 'self', value => $class->new($hOut, $hIn, $hErr, $pId)}
{name => 'self', value => $class->new($hOut, $hIn, $hErr, $pId, $iProtocolTimeout, $iBufferMax)}
);
}
@@ -140,50 +158,142 @@ sub kill
####################################################################################################################################
# lineRead
#
# Read a line.
# Read an lf-terminated line from the input or error stream.
####################################################################################################################################
sub lineRead
{
my $self = shift;
my $bError = shift;
my $iTimeout = shift;
my $bInRead = shift;
my $strLine;
my $strChar;
my $iByteIn;
# If there's already data in the buffer try to find the next linefeed
my $iLineFeedPos = defined($self->{strBuffer}) ? index($self->{strBuffer}, "\n", $self->{iBufferPos}) : -1;
# my $oOutSelect = IO::Select->new();
# $oOutSelect->add($self->{hOut});
#
# if ($oOutSelect->can_read(2))
# {
# $strLine = readline($self->{hOut});
# $strLine = trim($strLine);
# }
while (1)
# Store the current time if a timeout is required
if ($iLineFeedPos == -1)
{
$iByteIn = sysread($self->{hIn}, $strChar, 1);
my $fTimeout = defined($iTimeout) ? $iTimeout : $self->{iProtocolTimeout};
my $fRemaining = $fTimeout;
my $fTimeStart = gettimeofday();
if (!defined($iByteIn) || $iByteIn != 1)
# If no linefeed was found then load more data
do
{
$self->waitPid();
if (defined($bError) and !$bError)
# If the buffer already has data
if (defined($self->{strBuffer}) && $self->{iBufferPos} < $self->{iBufferSize})
{
return undef;
# And the buffer position is not 0 then trim it so there's room for more data
if ($self->{iBufferPos} != 0)
{
$self->{strBuffer} = substr($self->{strBuffer}, $self->{iBufferPos});
$self->{iBufferSize} = $self->{iBufferSize} - $self->{iBufferPos};
$self->{iBufferPos} = 0;
}
}
# Else the buffer is empty and data will need to be loaded
else
{
undef($self->{strBuffer}); # !!! Do we need this?
$self->{iBufferSize} = 0;
$self->{iBufferPos} = 0;
}
confess &log(ERROR, 'unable to read 1 byte' . (defined($!) ? ': ' . $! : ''));
}
# Get stream handle and select object
my $hIn;
my $oSelect;
if ($strChar eq "\n")
# If this is a normal input read
if (!defined($bInRead) || $bInRead)
{
$hIn = $self->{hIn};
$oSelect = $self->{oInSelect};
}
# Else this is an error read
else
{
# The select object will need to be created the first time an error is read
if (!defined($self->{oErrSelect}))
{
$self->{oErrSelect} = IO::Select->new();
$self->{oErrSelect}->add($self->{hErr});
}
$oSelect = $self->{oErrSelect};
$hIn = $self->{hErr};
}
# Load data into the buffer
my $iBufferRead = 0;
if ($oSelect->can_read($fRemaining))
{
$iBufferRead = sysread($hIn, $self->{strBuffer}, $self->{iBufferSize} >= $self->{iBufferMax} ?
$self->{iBufferMax} : $self->{iBufferMax} - $self->{iBufferSize}, $self->{iBufferSize});
# An error occurred if undef is returned
if (!defined($iBufferRead))
{
# Store the error message
my $strError = defined($!) && $! ne '' ? $! : undef;
# Check if the remote process exited unexpectedly
$self->waitPid();
# Raise the error
confess &log(ERROR, 'unable to read line' . (defined($strError) ? ": ${strError}" : ''));
}
# Error on EOF (unless reading from error stream)
if ($iBufferRead == 0)
{
# Check if the remote process exited unexpectedly
$self->waitPid();
# Only error if reading from the input stream
if (!defined($bInRead) || $bInRead)
{
confess &log(ERROR, "unexpected EOF", ERROR_FILE_READ);
}
# If reading from error stream then just return undef
else
{
return undef;
}
}
}
# If data was read then check for a linefeed
if ($iBufferRead > 0)
{
$self->{iBufferSize} += $iBufferRead;
$iLineFeedPos = index($self->{strBuffer}, "\n");
}
else
{
# Check if the remote process exited unexpectedly
$self->waitPid();
}
# Calculate time remaining before timeout
if ($iLineFeedPos == -1)
{
$fRemaining = $fTimeout - (gettimeofday() - $fTimeStart);
}
}
while ($iLineFeedPos == -1 && $fRemaining > 0);
# If not linefeed was found within the time return undef
if ($iLineFeedPos == -1)
{
last;
return undef;
}
$strLine .= $strChar;
}
# Return the line that was found and adjust the buffer position
my $strLine = substr($self->{strBuffer}, $self->{iBufferPos}, $iLineFeedPos - $self->{iBufferPos});
$self->{iBufferPos} = $iLineFeedPos + 1;
return $strLine;
}
@@ -199,7 +309,7 @@ sub errorWrite
if (defined($self->{pId}))
{
confess &log(ASSERT, 'errorWrite() not valid got master process.');
confess &log(ASSERT, 'errorWrite() not valid in master process');
}
$self->lineWrite($strBuffer, $self->{hError});
@@ -216,10 +326,18 @@ sub lineWrite
my $strBuffer = shift;
my $hOut = shift;
# Check if the process has exited abnormally (doesn't seem like we should need this, but the next syswrite does a hard
# abort if the remote process has already closed)
$self->waitPid();
# Write the data
my $iLineOut = syswrite(defined($hOut) ? $hOut : $self->{hOut}, (defined($strBuffer) ? $strBuffer : '') . "\n");
if (!defined($iLineOut) || $iLineOut != (defined($strBuffer) ? length($strBuffer) : 0) + 1)
{
# Check if the process has exited abnormally
$self->waitPid();
confess &log(ERROR, "unable to write ${strBuffer}: $!", ERROR_PROTOCOL);
}
}
@@ -232,20 +350,108 @@ sub lineWrite
sub bufferRead
{
my $self = shift;
my $tBlockRef = shift;
my $iBlockSize = shift;
my $tBufferRef = shift;
my $iRequestSize = shift;
my $iOffset = shift;
my $bBlock = shift;
# Read a block from the stream
my $iBlockIn = sysread($self->{hIn}, $$tBlockRef, $iBlockSize, defined($iOffset) ? $iOffset : 0);
# Set working variables
my $iRemainingSize = $iRequestSize;
$iOffset = defined($iOffset) ? $iOffset : 0;
$bBlock = defined($bBlock) ? $bBlock : false;
if (!defined($iBlockIn))
# If there is data left over in the buffer from lineRead then use it
if (defined($self->{strBuffer}) && $self->{iBufferPos} < $self->{iBufferSize})
{
$self->waitPid();
confess &log(ERROR, 'unable to read');
# There is enough data in the buffer to satisfy the entire request and have data left over
if ($iRemainingSize < $self->{iBufferSize} - $self->{iBufferPos})
{
$$tBufferRef = substr($self->{strBuffer}, $self->{iBufferPos}, $iRequestSize);
$self->{iBufferPos} += $iRequestSize;
return $iRequestSize;
}
# Else the entire buffer will be used (and more may be needed if blocking)
else
{
$$tBufferRef = substr($self->{strBuffer}, $self->{iBufferPos});
my $iReadSize = $self->{iBufferSize} - $self->{iBufferPos};
$iRemainingSize -= $iReadSize;
undef($self->{strBuffer});
return $iReadSize if !$bBlock || $iRemainingSize == 0;
$iOffset += $iReadSize;
}
}
return $iBlockIn;
# If this is a blocking read then loop until all bytes have been read - else error.
#
# This link (http://docstore.mik.ua/orelly/perl/cookbook/ch07_15.htm) demonstrates a way to implement this same loop without
# using select. Not sure if it would be better but the link has been left here so it can be found in the future if the
# implementation needs to be changed.
if ($bBlock)
{
my $fTimeStart = gettimeofday();
my $fRemaining = $self->{iProtocolTimeout};
do
{
# Check if the sysread call will block
if ($self->{oInSelect}->can_read($fRemaining))
{
# Read a data into the buffer
my $iReadSize = sysread($self->{hIn}, $$tBufferRef, $iRemainingSize, $iOffset);
# Process errors from the sysread
if (!defined($iReadSize))
{
my $strError = $!;
$self->waitPid();
confess &log(ERROR, 'unable to read' . (defined($strError) ? ": ${strError}" : ''));
}
# Check for EOF
if ($iReadSize == 0)
{
confess &log(ERROR, 'unexpected EOF', ERROR_FILE_READ);
}
# Update remaining size and return when it reaches 0
$iRemainingSize -= $iReadSize;
if ($iRemainingSize == 0)
{
return $iRequestSize;
}
# Update the offset to advance the next read further into the buffer
$iOffset += $iReadSize;
}
# Calculate time remaining before timeout
$fRemaining = $self->{iProtocolTimeout} - (gettimeofday() - $fTimeStart);
}
while ($fRemaining > 0);
# Throw an error if timeout happened before required bytes were read
confess &log(ERROR, "unable to read ${iRequestSize} bytes after $self->{iProtocolTimeout} seconds");
}
# Otherwise do a non-blocking read and return whatever bytes are ready
my $iReadSize = sysread($self->{hIn}, $$tBufferRef, $iRemainingSize, $iOffset);
# Process errors from sysread
if (!defined($iReadSize))
{
my $strError = $!;
$self->waitPid();
confess &log(ERROR, 'unable to read' . (defined($strError) ? ": ${strError}" : ''));
}
# Return the number of bytes read
return $iReadSize;
}
####################################################################################################################################
@@ -256,22 +462,22 @@ sub bufferRead
sub bufferWrite
{
my $self = shift;
my $tBlockRef = shift;
my $iBlockSize = shift;
my $tBufferRef = shift;
my $iWriteSize = shift;
# If block size is not defined, get it from buffer length
$iBlockSize = defined($iBlockSize) ? $iBlockSize : length($$tBlockRef);
$iWriteSize = defined($iWriteSize) ? $iWriteSize : length($$tBufferRef);
# Write the block
my $iBlockOut = syswrite($self->{hOut}, $$tBlockRef, $iBlockSize);
my $iWriteOut = syswrite($self->{hOut}, $$tBufferRef, $iWriteSize);
# Report any errors
if (!defined($iBlockOut) || $iBlockOut != $iBlockSize)
if (!defined($iWriteOut) || $iWriteOut != $iWriteSize)
{
my $strError = $!;
$self->waitPid();
confess "unable to write ${iBlockSize} bytes" . (defined($strError) ? ': ' . $strError : '');
confess "unable to write ${iWriteSize} bytes" . (defined($strError) ? ': ' . $strError : '');
}
}
@@ -295,30 +501,51 @@ sub waitPid
{
my $iResult = waitpid($self->{pId}, WNOHANG);
if (defined($fWaitTime))
{
confess &log(TRACE, "waitpid result = $iResult");
}
# If there is no such process
# If there is no such process we'll assume it terminated previously
if ($iResult == -1)
{
return true;
}
# If the process exited then this is unexpected
if ($iResult > 0)
{
# Get the exit status so we can report it later
my $iExitStatus = ${^CHILD_ERROR_NATIVE} >> 8;
# Sometimes we'll expect an error so it won't always be reported
if (!defined($bReportError) || $bReportError)
{
# Default error
my $strError = 'no error on stderr';
# If the error stream is already closed then we can't fetch the real error
if (!defined($self->{hErr}))
{
$strError = 'no error captured because stderr is already closed';
}
# Get whatever text we can from the error stream
else
{
$strError = $self->pipeToString($self->{hErr});
eval
{
$strError = undef;
while (my $strLine = $self->lineRead(0, false))
{
if (defined($strError))
{
$strError .= "\n";
}
$strError .= $strLine;
}
};
if ($@ || !defined($strError))
{
$strError = 'no output from terminated process' . (defined($@) && $@ ne '' ? ": $@" : '');
}
}
$self->{pId} = undef;
@@ -326,13 +553,16 @@ sub waitPid
$self->{hOut} = undef;
$self->{hErr} = undef;
confess &log(ERROR, "remote process terminated: ${strError}", ERROR_HOST_CONNECT);
# Finally, confess the error
confess &log(ERROR, 'remote process terminated' .
($iExitStatus < ERROR_MINIMUM && $iExitStatus > ERROR_MAXIMUM ?
" (exit status ${iExitStatus}" : '') .
" : ${strError}",
$iExitStatus >= ERROR_MINIMUM && $iExitStatus <= ERROR_MAXIMUM ? $iExitStatus : ERROR_HOST_CONNECT);
}
return true;
}
&log(TRACE, "waiting for pid");
}
while (waitMore($oWait));
}

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

@@ -34,28 +34,30 @@ sub new
(
$strOperation,
$strCommand, # Command to execute on local/remote
$iBlockSize, # Buffer size
$iBufferMax, # Maximum 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)
$strUser, # User to connect to for remote (must be set if strHost is set)
$iProtocolTimeout # Protocol timeout
) =
logDebugParam
(
OP_PROTOCOL_REMOTE_MASTER_NEW, \@_,
{name => 'strCommand'},
{name => 'iBlockSize'},
{name => 'iBufferMax'},
{name => 'iCompressLevel'},
{name => 'iCompressLevelNetwork'},
{name => 'strHost'},
{name => 'strUser'}
{name => 'strUser'},
{name => 'iProtocolTimeout'}
);
# Create SSH command
$strCommand = "ssh -o Compression=no -o PasswordAuthentication=no ${strUser}\@${strHost} '${strCommand}'";
# Init object and store variables
my $self = $class->SUPER::new('remote', $strCommand, $iBlockSize, $iCompressLevel, $iCompressLevelNetwork);
my $self = $class->SUPER::new('remote', $strCommand, $iBufferMax, $iCompressLevel, $iCompressLevelNetwork, $iProtocolTimeout);
bless $self, $class;
# Return from function and log return values if any
@@ -66,22 +68,4 @@ sub new
);
}
####################################################################################################################################
# CLONE
####################################################################################################################################
sub clone
{
my $self = shift;
return BackRest::Protocol::RemoteMaster->new
(
$self->{strCommand},
$self->{iBlockSize},
$self->{iCompressLevel},
$self->{iCompressLevelNetwork},
$self->{strHost},
$self->{strUser}
);
}
1;

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

@@ -47,20 +47,25 @@ sub new
my
(
$strOperation,
$iBlockSize, # Buffer size
$strCommand, # Command the master process is running
$iBufferMax, # Maximum buffer size
$iCompressLevel, # Set compression level
$iCompressLevelNetwork # Set compression level for network only compression
$iCompressLevelNetwork, # Set compression level for network only compression,
$iProtocolTimeout # Protocol timeout
) =
logDebugParam
(
OP_PROTOCOL_REMOTE_MINION_NEW, \@_,
{name => 'iBlockSize', trace => true},
{name => 'iCompressLevel', trace => true},
{name => 'iCompressNetworkLevel', trace => true}
{name => 'strCommand'},
{name => 'iBufferMax'},
{name => 'iCompressLevel'},
{name => 'iCompressNetworkLevel'},
{name => 'iProtocolTimeout'}
);
# Init object and store variables
my $self = $class->SUPER::new(CMD_REMOTE, $iBlockSize, $iCompressLevel, $iCompressLevelNetwork);
my $self = $class->SUPER::new(CMD_REMOTE, $strCommand, $iBufferMax, $iCompressLevel,
$iCompressLevelNetwork, $iProtocolTimeout);
bless $self, $class;
# Return from function and log return values if any

63
lib/BackRest/Protocol/ThreadGroup.pm
View File

@@ -85,7 +85,7 @@ sub threadGroupThread
optionGet(OPTION_STANZA),
optionRemoteTypeTest(BACKUP) ? optionGet(OPTION_REPO_REMOTE_PATH) : optionGet(OPTION_REPO_PATH),
optionRemoteType(),
protocolGet(undef, false),
protocolGet(undef, false, $iThreadIdx + 1),
undef, undef,
$iThreadIdx + 1
);
@@ -275,7 +275,7 @@ sub threadGroupComplete
my $strFirstError;
my $iFirstErrorThreadIdx;
&log(DEBUG, "waiting for " . @oyThread . " threads to complete");
&log(TRACE, "waiting for " . @oyThread . " threads to complete");
# Rejoin the threads
# while ($iThreadComplete < @oyThread)
@@ -295,6 +295,16 @@ sub threadGroupComplete
{
if ($byThreadRunning[$iThreadIdx])
{
if (threadMessageExpect($oyResultQueue[$iThreadIdx], 'shutdown', $iThreadIdx, true))
{
threadMessage($oyMessageQueue[$iThreadIdx], 'continue', $iThreadIdx);
threadMessageExpect($oyResultQueue[$iThreadIdx], 'complete', $iThreadIdx);
$byThreadRunning[$iThreadIdx] = false;
$iThreadComplete++;
}
# Check for errors
my $oError = $oyThread[$iThreadIdx]->error();
if (defined($oError))
@@ -317,15 +327,11 @@ sub threadGroupComplete
$iFirstErrorThreadIdx = $iThreadIdx;
}
$byThreadRunning[$iThreadIdx] = false;
$iThreadComplete++;
}
elsif (threadMessageExpect($oyResultQueue[$iThreadIdx], 'shutdown', $iThreadIdx, true))
{
threadMessage($oyMessageQueue[$iThreadIdx], 'continue', $iThreadIdx);
threadMessageExpect($oyResultQueue[$iThreadIdx], 'complete', $iThreadIdx);
$byThreadRunning[$iThreadIdx] = false;
$iThreadComplete++;
if ($byThreadRunning[$iThreadIdx])
{
$byThreadRunning[$iThreadIdx] = false;
$iThreadComplete++;
}
}
}
else
@@ -364,24 +370,27 @@ sub threadGroupDestroy
for (my $iThreadIdx = 0; $iThreadIdx < @oyThread; $iThreadIdx++)
{
my %oCommand;
$oCommand{function} = 'exit';
$oyCommandQueue[$iThreadIdx]->enqueue(\%oCommand);
waitHiRes(.1);
if ($oyThread[$iThreadIdx]->is_running())
if (defined($oyThread[$iThreadIdx]))
{
$oyThread[$iThreadIdx]->kill('KILL')->join();
&log(TRACE, "thread ${iThreadIdx} killed");
}
elsif ($oyThread[$iThreadIdx]->is_joinable())
{
$oyThread[$iThreadIdx]->join();
&log(TRACE, "thread ${iThreadIdx} joined");
}
my %oCommand;
$oCommand{function} = 'exit';
undef($oyThread[$iThreadIdx]);
$oyCommandQueue[$iThreadIdx]->enqueue(\%oCommand);
waitHiRes(.1);
if ($oyThread[$iThreadIdx]->is_running())
{
$oyThread[$iThreadIdx]->kill('KILL')->join();
&log(TRACE, "thread ${iThreadIdx} killed");
}
elsif ($oyThread[$iThreadIdx]->is_joinable())
{
$oyThread[$iThreadIdx]->join();
&log(TRACE, "thread ${iThreadIdx} joined");
}
undef($oyThread[$iThreadIdx]);
}
}
&log(TRACE, @oyThread . " threads destroyed");

44
lib/BackRest/Restore.pm
View File

@@ -29,6 +29,7 @@ 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_DESTROY => OP_RESTORE . '->destroy';
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';
@@ -56,15 +57,16 @@ sub new
bless $self, $class;
# Assign function parameters, defaults, and log debug info
my ($strOperation) = logDebugParam(OP_RESTORE_NEW);
# Initialize default file object
$self->{oFile} = new BackRest::File
(
my $strOperation,
$self->{oFile}
) =
logDebugParam
(
OP_RESTORE_NEW, \@_,
{name => 'oFile', trace => true}
);
optionGet(OPTION_STANZA),
optionRemoteTypeTest(BACKUP) ? optionGet(OPTION_REPO_REMOTE_PATH) : optionGet(OPTION_REPO_PATH),
optionRemoteType(),
protocolGet()
);
# Initialize variables
$self->{strDbClusterPath} = optionGet(OPTION_DB_PATH);
@@ -78,6 +80,32 @@ sub new
);
}
####################################################################################################################################
# DESTROY
####################################################################################################################################
sub DESTROY
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation
) =
logDebugParam
(
OP_RESTORE_DESTROY
);
undef($self->{oFile});
# Return from function and log return values if any
return logDebugReturn
(
$strOperation
);
}
####################################################################################################################################
# manifestOwnershipCheck
#

2
lib/BackRest/Version.pm
View File

@@ -17,7 +17,7 @@ use Exporter qw(import);
# repositories or manifests can be read - that's the job of the format number.
#-----------------------------------------------------------------------------------------------------------------------------------
our # 'our' keyword is on a separate line to make the ExtUtils::MakeMaker parser happy.
$VERSION = '0.82';
$VERSION = '0.85';
push @EXPORT, qw($VERSION);

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

@@ -30,6 +30,7 @@ use BackRest::Config::Config;
use BackRest::File;
use BackRest::Manifest;
use BackRestTest::Common::ExecuteTest;
use BackRestTest::CommonTest;
my $hDb;
@@ -270,8 +271,8 @@ sub BackRestTestBackup_ClusterStop
if ((!defined($bNoError) || !$bNoError) &&
-e BackRestTestCommon_DbCommonPathGet() . '/postgresql.log')
{
BackRestTestCommon_Execute('grep ERROR ' . BackRestTestCommon_DbCommonPathGet() . '/postgresql.log',
undef, undef, undef, 1);
executeTest('grep ERROR ' . BackRestTestCommon_DbCommonPathGet() . '/postgresql.log',
{iExpectedExitStatus => 1});
}
}
@@ -336,7 +337,7 @@ sub BackRestTestBackup_ClusterStart
BackRestTestCommon_DbPathGet() . "'\" " .
"-D ${strPath} -l ${strPath}/postgresql.log -s";
BackRestTestCommon_Execute($strCommand);
executeTest($strCommand);
# Connect user session
BackRestTestBackup_PgConnect();
@@ -357,7 +358,7 @@ sub BackRestTestBackup_ClusterRestart
# If postmaster process is running them stop the cluster
if (-e $strPath . '/postmaster.pid')
{
BackRestTestCommon_Execute(BackRestTestCommon_PgSqlBinPathGet() . "/pg_ctl restart -D ${strPath} -w -s");
executeTest(BackRestTestCommon_PgSqlBinPathGet() . "/pg_ctl restart -D ${strPath} -w -s");
}
# Connect user session
@@ -378,7 +379,7 @@ sub BackRestTestBackup_ClusterCreate
# Defaults
$strPath = defined($strPath) ? $strPath : BackRestTestCommon_DbCommonPathGet();
BackRestTestCommon_Execute(BackRestTestCommon_PgSqlBinPathGet() . "/initdb -D ${strPath} -A trust");
executeTest(BackRestTestCommon_PgSqlBinPathGet() . "/initdb -D ${strPath} -A trust");
BackRestTestBackup_ClusterStart($strPath, $iPort, undef, $bArchive);
@@ -913,36 +914,77 @@ sub BackRestTestBackup_LastBackup
####################################################################################################################################
# BackRestTestBackup_BackupBegin
####################################################################################################################################
push @EXPORT, qw(BackRestTestBackup_BackupBegin);
my $oExecuteBackup;
my $bBackupRemote;
my $oBackupFile;
my $bBackupSynthetic;
my $strBackupType;
my $strBackupStanza;
my $oBackupLogTest;
my $iBackupThreadMax;
sub BackRestTestBackup_Init
{
my $bRemote = shift;
my $oFile = shift;
my $bSynthetic = shift;
my $oLogTest = shift;
my $iThreadMax = shift;
$bBackupRemote = $bRemote;
$oBackupFile = $oFile;
$bBackupSynthetic = $bSynthetic;
$oBackupLogTest = $oLogTest;
$iBackupThreadMax = defined($iThreadMax) ? $iThreadMax : 1;
}
push @EXPORT, qw(BackRestTestBackup_Init);
sub BackRestTestBackup_BackupBegin
{
my $strType = shift;
my $strStanza = shift;
my $bRemote = shift;
my $strComment = shift;
my $bSynthetic = shift;
my $bTestPoint = shift;
my $fTestDelay = shift;
my $strOptionalParam = shift;
my $oParam = shift;
$strBackupType = $strType;
$strBackupStanza = $strStanza;
# Set defaults
$bTestPoint = defined($bTestPoint) ? $bTestPoint : false;
$fTestDelay = defined($fTestDelay) ? $fTestDelay : 0;
my $strTest = defined($$oParam{strTest}) ? $$oParam{strTest} : undef;
my $fTestDelay = defined($$oParam{fTestDelay}) ? $$oParam{fTestDelay} : 0;
$strComment = "${strType} backup" . (defined($strComment) ? " (${strComment})" : '');
if (!defined($$oParam{iExpectedExitStatus}) && $iBackupThreadMax > 1)
{
$$oParam{iExpectedExitStatus} = -1;
}
$strComment = "${strBackupType} backup" . (defined($strComment) ? " (${strComment})" : '');
&log(INFO, " $strComment");
BackRestTestCommon_ExecuteBegin(($bRemote ? BackRestTestCommon_CommandMainAbsGet() : BackRestTestCommon_CommandMainGet()) .
' --config=' .
($bRemote ? BackRestTestCommon_RepoPathGet() : BackRestTestCommon_DbPathGet()) .
"/pg_backrest.conf" . ($bSynthetic ? " --no-start-stop" : '') .
(defined($strOptionalParam) ? " ${strOptionalParam}" : '') .
($strType ne 'incr' ? " --type=${strType}" : '') .
" --stanza=${strStanza} backup" . ($bTestPoint ? " --test --test-delay=${fTestDelay}": ''),
$bRemote, $strComment);
# Execute the backup command
$oExecuteBackup = new BackRestTest::Common::ExecuteTest(
($bBackupRemote ? BackRestTestCommon_CommandMainAbsGet() : BackRestTestCommon_CommandMainGet()) .
' --config=' . ($bBackupRemote ? BackRestTestCommon_RepoPathGet() : BackRestTestCommon_DbPathGet()) . '/pg_backrest.conf' .
($bBackupSynthetic ? " --no-start-stop" : '') .
(defined($$oParam{strOptionalParam}) ? " $$oParam{strOptionalParam}" : '') .
($strBackupType ne 'incr' ? " --type=${strBackupType}" : '') .
" --stanza=${strBackupStanza} backup" .
(defined($strTest) ? " --test --test-delay=${fTestDelay} --test-point=" . lc($strTest) . '=y' : ''),
{bRemote => $bBackupRemote, strComment => $strComment, iExpectedExitStatus => $$oParam{iExpectedExitStatus},
oLogTest => $oBackupLogTest});
$oExecuteBackup->begin();
# Return at the test point if one was defined
if (defined($strTest))
{
$oExecuteBackup->end($strTest);
}
}
push @EXPORT, qw(BackRestTestBackup_BackupBegin);
####################################################################################################################################
# BackRestTestBackup_BackupEnd
####################################################################################################################################
@@ -950,46 +992,44 @@ push @EXPORT, qw(BackRestTestBackup_BackupEnd);
sub BackRestTestBackup_BackupEnd
{
my $strType = shift;
my $strStanza = shift;
my $oFile = shift;
my $bRemote = shift;
my $strBackup = shift;
my $oExpectedManifestRef = shift;
my $bSynthetic = shift;
my $iExpectedExitStatus = shift;
my $iExitStatus = BackRestTestCommon_ExecuteEnd(undef, undef, undef, $iExpectedExitStatus);
my $iExitStatus = $oExecuteBackup->end();
if (defined($iExpectedExitStatus))
if ($oExecuteBackup->{iExpectedExitStatus} != 0 && $oExecuteBackup->{iExpectedExitStatus} != -1)
{
return undef;
}
${$oExpectedManifestRef}{&MANIFEST_SECTION_BACKUP}{&MANIFEST_KEY_TYPE} = $strType;
${$oExpectedManifestRef}{&MANIFEST_SECTION_BACKUP}{&MANIFEST_KEY_TYPE} = $strBackupType;
if (!defined($strBackup))
my $strBackup = BackRestTestBackup_LastBackup($oBackupFile);
if ($bBackupSynthetic)
{
$strBackup = BackRestTestBackup_LastBackup($oFile);
if (!defined($oExpectedManifestRef))
{
confess 'must pass oExpectedManifestRef to BackupEnd for synthetic backups when no error is expected';
}
BackRestTestBackup_BackupCompare($oBackupFile, $bBackupRemote, $strBackup, $oExpectedManifestRef);
}
if ($bSynthetic)
if (defined($oBackupLogTest))
{
BackRestTestBackup_BackupCompare($oFile, $bRemote, $strBackup, $oExpectedManifestRef);
$oBackupLogTest->supplementalAdd(BackRestTestCommon_DbPathGet() . "/pg_backrest.conf", $bBackupRemote);
if ($bBackupRemote)
{
$oBackupLogTest->supplementalAdd(BackRestTestCommon_RepoPathGet() . "/pg_backrest.conf", true);
}
$oBackupLogTest->supplementalAdd(BackRestTestCommon_RepoPathGet() .
"/backup/${strBackupStanza}/${strBackup}/backup.manifest", $bBackupRemote);
$oBackupLogTest->supplementalAdd(BackRestTestCommon_RepoPathGet() .
"/backup/${strBackupStanza}/backup.info", $bBackupRemote);
}
BackRestTestCommon_TestLogAppendFile(BackRestTestCommon_DbPathGet() . "/pg_backrest.conf", $bRemote);
if ($bRemote)
{
BackRestTestCommon_TestLogAppendFile(BackRestTestCommon_RepoPathGet() . "/pg_backrest.conf", $bRemote);
}
BackRestTestCommon_TestLogAppendFile(BackRestTestCommon_RepoPathGet() .
"/backup/${strStanza}/${strBackup}/backup.manifest", $bRemote);
BackRestTestCommon_TestLogAppendFile(BackRestTestCommon_RepoPathGet() .
"/backup/${strStanza}/backup.info", $bRemote);
return $strBackup;
}
@@ -1002,25 +1042,12 @@ sub BackRestTestBackup_BackupSynthetic
{
my $strType = shift;
my $strStanza = shift;
my $bRemote = shift;
my $oFile = shift;
my $oExpectedManifestRef = shift;
my $strComment = shift;
my $strTestPoint = shift;
my $fTestDelay = shift;
my $iExpectedExitStatus = shift;
my $strOptionalParam = shift;
my $oParam = shift;
BackRestTestBackup_BackupBegin($strType, $strStanza, $bRemote, $strComment, true, defined($strTestPoint), $fTestDelay,
$strOptionalParam);
if (defined($strTestPoint))
{
BackRestTestCommon_ExecuteEnd($strTestPoint);
}
return BackRestTestBackup_BackupEnd($strType, $strStanza, $oFile, $bRemote, undef, $oExpectedManifestRef, true,
$iExpectedExitStatus);
BackRestTestBackup_BackupBegin($strType, $strStanza, $strComment, $oParam);
return BackRestTestBackup_BackupEnd($oExpectedManifestRef);
}
####################################################################################################################################
@@ -1032,21 +1059,11 @@ sub BackRestTestBackup_Backup
{
my $strType = shift;
my $strStanza = shift;
my $bRemote = shift;
my $oFile = shift;
my $strComment = shift;
my $strTestPoint = shift;
my $fTestDelay = shift;
my $iExpectedExitStatus = shift;
my $oParam = shift;
BackRestTestBackup_BackupBegin($strType, $strStanza, $bRemote, $strComment, false, defined($strTestPoint), $fTestDelay);
if (defined($strTestPoint))
{
BackRestTestCommon_ExecuteEnd($strTestPoint);
}
return BackRestTestBackup_BackupEnd($strType, $strStanza, $oFile, $bRemote, undef, undef, false, $iExpectedExitStatus);
BackRestTestBackup_BackupBegin($strType, $strStanza, $strComment, $oParam);
return BackRestTestBackup_BackupEnd();
}
####################################################################################################################################
@@ -1064,12 +1081,56 @@ sub BackRestTestBackup_Info
$strComment = "info" . (defined($strStanza) ? " ${strStanza}" : '');
&log(INFO, " $strComment");
BackRestTestCommon_Execute(($bRemote ? BackRestTestCommon_CommandMainAbsGet() : BackRestTestCommon_CommandMainGet()) .
' --config=' .
($bRemote ? BackRestTestCommon_RepoPathGet() : BackRestTestCommon_DbPathGet()) .
'/pg_backrest.conf' . (defined($strStanza) ? " --stanza=${strStanza}" : '') . ' info' .
(defined($strOutput) ? " --output=${strOutput}" : ''),
$bRemote, undef, undef, undef, $strComment);
executeTest(($bRemote ? BackRestTestCommon_CommandMainAbsGet() : BackRestTestCommon_CommandMainGet()) .
' --config=' .
($bRemote ? BackRestTestCommon_RepoPathGet() : BackRestTestCommon_DbPathGet()) .
'/pg_backrest.conf' . (defined($strStanza) ? " --stanza=${strStanza}" : '') . ' info' .
(defined($strOutput) ? " --output=${strOutput}" : ''),
{bRemote => $bRemote, strComment => $strComment, oLogTest => $oBackupLogTest});
}
####################################################################################################################################
# BackRestTestBackup_Stop
####################################################################################################################################
push @EXPORT, qw(BackRestTestBackup_Stop);
sub BackRestTestBackup_Stop
{
my $strStanza = shift;
my $bRemote = shift;
my $bForce = shift;
my $strComment = "stop" . (defined($strStanza) ? " ${strStanza}" : '') .
(defined($bRemote) && $bRemote ? ' (remote)' : ' (local)');
&log(INFO, " $strComment");
executeTest(($bRemote ? BackRestTestCommon_CommandMainAbsGet() : BackRestTestCommon_CommandMainGet()) .
' --config=' . ($bRemote ? BackRestTestCommon_RepoPathGet() : BackRestTestCommon_DbPathGet()) .
'/pg_backrest.conf' .
(defined($strStanza) ? " --stanza=${strStanza}" : '') .
(defined($bForce) && $bForce ? ' --force' : '') . ' stop',
{bRemote => $bRemote, oLogTest => $oBackupLogTest});
}
####################################################################################################################################
# BackRestTestBackup_Start
####################################################################################################################################
push @EXPORT, qw(BackRestTestBackup_Start);
sub BackRestTestBackup_Start
{
my $strStanza = shift;
my $bRemote = shift;
my $strComment = "start" . (defined($strStanza) ? " ${strStanza}" : '') .
(defined($bRemote) && $bRemote ? ' (remote)' : ' (local)');
&log(INFO, " $strComment");
executeTest(($bRemote ? BackRestTestCommon_CommandMainAbsGet() : BackRestTestCommon_CommandMainGet()) .
' --config=' .
($bRemote ? BackRestTestCommon_RepoPathGet() : BackRestTestCommon_DbPathGet()) .
'/pg_backrest.conf' . (defined($strStanza) ? " --stanza=${strStanza}" : '') . ' start',
{bRemote => $bRemote, strComment => $strComment, oLogTest => $oBackupLogTest});
}
####################################################################################################################################
@@ -1089,7 +1150,8 @@ sub BackRestTestBackup_BackupCompare
# Change mode on the backup path so it can be read
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 750 ' . BackRestTestCommon_RepoPathGet(), true);
executeTest('chmod 750 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
my %oActualManifest;
@@ -1110,12 +1172,13 @@ sub BackRestTestBackup_BackupCompare
iniSave("${strTestPath}/actual.manifest", \%oActualManifest);
iniSave("${strTestPath}/expected.manifest", $oExpectedManifestRef);
BackRestTestCommon_Execute("diff ${strTestPath}/expected.manifest ${strTestPath}/actual.manifest");
executeTest("diff ${strTestPath}/expected.manifest ${strTestPath}/actual.manifest");
# Change mode on the backup path back before unit tests continue
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 700 ' . BackRestTestCommon_RepoPathGet(), true);
executeTest('chmod 700 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
$oFile->remove(PATH_ABSOLUTE, "${strTestPath}/expected.manifest");
@@ -1125,8 +1188,8 @@ sub BackRestTestBackup_BackupCompare
####################################################################################################################################
# BackRestTestBackup_ManifestMunge
#
# Allows for munging of the manifest while make it appear to be valid. This is used to create various error conditions that should
# be caught by the unit tests.
# Allows for munging of the manifest while making it appear to be valid. This is used to create various error conditions that
# should be caught by the unit tests.
####################################################################################################################################
push @EXPORT, qw(BackRestTestBackup_ManifestMunge);
@@ -1149,8 +1212,10 @@ sub BackRestTestBackup_ManifestMunge
# Change mode on the backup path so it can be read/written
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 750 ' . BackRestTestCommon_RepoPathGet(), true);
BackRestTestCommon_Execute('chmod 770 ' . $oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, true);
executeTest('chmod 750 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
executeTest('chmod 770 ' . $oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST,
{bRemote => true});
}
# Read the manifest
@@ -1197,8 +1262,10 @@ sub BackRestTestBackup_ManifestMunge
# Change mode on the backup path back before unit tests continue
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 750 ' . $oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST, true);
BackRestTestCommon_Execute('chmod 700 ' . BackRestTestCommon_RepoPathGet(), true);
executeTest('chmod 750 ' . $oFile->pathGet(PATH_BACKUP_CLUSTER, $strBackup) . '/' . FILE_MANIFEST,
{bRemote => true});
executeTest('chmod 700 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
}
@@ -1254,7 +1321,8 @@ sub BackRestTestBackup_Restore
# Change mode on the backup path so it can be read
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 750 ' . BackRestTestCommon_RepoPathGet(), true);
executeTest('chmod 750 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
my $oExpectedManifest = new BackRest::Manifest(BackRestTestCommon_RepoPathGet() .
@@ -1265,7 +1333,8 @@ sub BackRestTestBackup_Restore
# Change mode on the backup path back before unit tests continue
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 700 ' . BackRestTestCommon_RepoPathGet(), true);
executeTest('chmod 700 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
}
@@ -1280,26 +1349,30 @@ sub BackRestTestBackup_Restore
}
# Create the backup command
BackRestTestCommon_Execute(($bRemote ? BackRestTestCommon_CommandMainAbsGet() : BackRestTestCommon_CommandMainGet()) .
' --config=' . BackRestTestCommon_DbPathGet() .
'/pg_backrest.conf' . (defined($bDelta) && $bDelta ? ' --delta' : '') .
(defined($bForce) && $bForce ? ' --force' : '') .
($strBackup ne 'latest' ? " --set=${strBackup}" : '') .
(defined($strOptionalParam) ? " ${strOptionalParam} " : '') .
(defined($strType) && $strType ne RECOVERY_TYPE_DEFAULT ? " --type=${strType}" : '') .
(defined($strTarget) ? " --target=\"${strTarget}\"" : '') .
(defined($strTargetTimeline) ? " --target-timeline=\"${strTargetTimeline}\"" : '') .
(defined($bTargetExclusive) && $bTargetExclusive ? " --target-exclusive" : '') .
(defined($bTargetResume) && $bTargetResume ? " --target-resume" : '') .
" --stanza=${strStanza} restore",
undef, undef, undef, $iExpectedExitStatus, $strComment);
executeTest(($bRemote ? BackRestTestCommon_CommandMainAbsGet() : BackRestTestCommon_CommandMainGet()) .
' --config=' . BackRestTestCommon_DbPathGet() .
'/pg_backrest.conf' . (defined($bDelta) && $bDelta ? ' --delta' : '') .
(defined($bForce) && $bForce ? ' --force' : '') .
($strBackup ne 'latest' ? " --set=${strBackup}" : '') .
(defined($strOptionalParam) ? " ${strOptionalParam} " : '') .
(defined($strType) && $strType ne RECOVERY_TYPE_DEFAULT ? " --type=${strType}" : '') .
(defined($strTarget) ? " --target=\"${strTarget}\"" : '') .
(defined($strTargetTimeline) ? " --target-timeline=\"${strTargetTimeline}\"" : '') .
(defined($bTargetExclusive) && $bTargetExclusive ? " --target-exclusive" : '') .
(defined($bTargetResume) && $bTargetResume ? " --target-resume" : '') .
" --stanza=${strStanza} restore",
{iExpectedExitStatus => $iExpectedExitStatus, strComment => $strComment, oLogTest => $oBackupLogTest});
if (!defined($iExpectedExitStatus) && (!defined($bCompare) || $bCompare))
{
BackRestTestBackup_RestoreCompare($oFile, $strStanza, $bRemote, $strBackup, $bSynthetic, $oExpectedManifestRef);
BackRestTestCommon_TestLogAppendFile(
$$oExpectedManifestRef{&MANIFEST_SECTION_BACKUP_PATH}{&MANIFEST_KEY_BASE}{&MANIFEST_SUBKEY_PATH} .
"/recovery.conf");
if (defined($oBackupLogTest))
{
$oBackupLogTest->supplementalAdd(
$$oExpectedManifestRef{&MANIFEST_SECTION_BACKUP_PATH}{&MANIFEST_KEY_BASE}{&MANIFEST_SUBKEY_PATH} .
"/recovery.conf");
}
}
}
@@ -1327,7 +1400,8 @@ sub BackRestTestBackup_RestoreCompare
# Change mode on the backup path so it can be read
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 750 ' . BackRestTestCommon_RepoPathGet(), true);
executeTest('chmod 750 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
my $oExpectedManifest = new BackRest::Manifest(BackRestTestCommon_RepoPathGet() .
@@ -1341,7 +1415,8 @@ sub BackRestTestBackup_RestoreCompare
# Change mode on the backup path back before unit tests continue
if ($bRemote)
{
BackRestTestCommon_Execute('chmod 700 ' . BackRestTestCommon_RepoPathGet(), true);
executeTest('chmod 700 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
}
@@ -1452,7 +1527,7 @@ sub BackRestTestBackup_RestoreCompare
iniSave("${strTestPath}/actual.manifest", $oActualManifest->{oContent});
iniSave("${strTestPath}/expected.manifest", $oExpectedManifestRef);
BackRestTestCommon_Execute("diff ${strTestPath}/expected.manifest ${strTestPath}/actual.manifest");
executeTest("diff ${strTestPath}/expected.manifest ${strTestPath}/actual.manifest");
$oFile->remove(PATH_ABSOLUTE, "${strTestPath}/expected.manifest");
$oFile->remove(PATH_ABSOLUTE, "${strTestPath}/actual.manifest");
@@ -1493,7 +1568,7 @@ sub BackRestTestBackup_Expire
' --retention-archive=' . $iExpireArchive;
}
BackRestTestCommon_Execute($strCommand);
executeTest($strCommand);
# Check that the correct backups were expired
my @stryBackupActual = $oFile->list(PATH_BACKUP_CLUSTER);
@@ -1513,8 +1588,11 @@ sub BackRestTestBackup_Expire
"\n\nbut actual was:\n " . join("\n ", @stryArchiveActual) . "\n";
}
BackRestTestCommon_TestLogAppendFile(BackRestTestCommon_RepoPathGet() .
"/backup/${strStanza}/backup.info", false);
if (defined($oBackupLogTest))
{
$oBackupLogTest->supplementalAdd(BackRestTestCommon_RepoPathGet() .
"/backup/${strStanza}/backup.info");
}
}
1;

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

@@ -34,8 +34,9 @@ use BackRest::Protocol::Common;
use BackRest::Protocol::RemoteMaster;
use BackRestTest::BackupCommonTest;
use BackRestTest::ExpireCommonTest;
use BackRestTest::Common::ExecuteTest;
use BackRestTest::CommonTest;
use BackRestTest::ExpireCommonTest;
####################################################################################################################################
# BackRestTestBackup_Test
@@ -66,6 +67,7 @@ sub BackRestTestBackup_Test
my $strThisTest;
my $bCreate;
my $strStanza = BackRestTestCommon_StanzaGet();
my $oLogTest;
my $strArchiveChecksum = '1c7e00fd09b9dd11fc2966590b3e3274645dd031';
my $iArchiveMax = 3;
@@ -85,19 +87,21 @@ sub BackRestTestBackup_Test
#-------------------------------------------------------------------------------------------------------------------------------
my $oRemote = new BackRest::Protocol::RemoteMaster
(
BackRestTestCommon_CommandRemoteFullGet(), # Command
BackRestTestCommon_CommandRemoteFullGet(), # Remote command
OPTION_DEFAULT_BUFFER_SIZE, # Buffer size
OPTION_DEFAULT_COMPRESS_LEVEL, # Compress level
OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK, # Compress network level
$strHost, # Host
$strUserBackRest # User
$strUserBackRest, # User
PROTOCOL_TIMEOUT_TEST # Protocol timeout
);
my $oLocal = new BackRest::Protocol::Common
(
OPTION_DEFAULT_BUFFER_SIZE, # Buffer size
OPTION_DEFAULT_COMPRESS_LEVEL, # Compress level
OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK # Compress network level
OPTION_DEFAULT_BUFFER_SIZE, # Buffer size
OPTION_DEFAULT_COMPRESS_LEVEL, # Compress level
OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK, # Compress network level
PROTOCOL_TIMEOUT_TEST # Protocol timeout
);
#-------------------------------------------------------------------------------------------------------------------------------
@@ -124,7 +128,8 @@ sub BackRestTestBackup_Test
"rmt ${bRemote}, cmp ${bCompress}, " .
"arc_async ${bArchiveAsync}",
$iThreadMax == 1 ? $strModule : undef,
$iThreadMax == 1 ? $strThisTest: undef)) {next}
$iThreadMax == 1 ? $strThisTest: undef,
\$oLogTest)) {next}
# Create the file object
if ($bCreate)
@@ -142,8 +147,9 @@ sub BackRestTestBackup_Test
# Create the test directory
BackRestTestBackup_Create($bRemote, false);
BackRestTestBackup_Init($bRemote, $oFile, true, $oLogTest);
BackRestTestCommon_ConfigCreate('db',
BackRestTestCommon_ConfigCreate(DB,
($bRemote ? BACKUP : undef),
$bCompress,
undef, # checksum
@@ -152,6 +158,9 @@ sub BackRestTestBackup_Test
$bArchiveAsync,
undef);
BackRestTestCommon_ConfigCreate(BACKUP,
($bRemote ? DB : undef));
my $strCommand = BackRestTestCommon_CommandMainGet() . ' --config=' . BackRestTestCommon_DbPathGet() .
'/pg_backrest.conf --no-fork --stanza=db archive-push';
@@ -186,7 +195,7 @@ sub BackRestTestBackup_Test
undef, undef, undef, # Unused params
true); # Create path if it does not exist
BackRestTestCommon_Execute($strCommand . " ${strSourceFile}");
executeTest($strCommand . " ${strSourceFile}", {oLogTest => $oLogTest});
if ($iArchive == $iBackup)
{
@@ -203,8 +212,8 @@ sub BackRestTestBackup_Test
&log(INFO, ' test db version mismatch error');
BackRestTestCommon_Execute($strCommand . " ${strSourceFile}", undef, undef, undef,
ERROR_ARCHIVE_MISMATCH);
executeTest($strCommand . " ${strSourceFile}",
{iExpectedExitStatus => ERROR_ARCHIVE_MISMATCH, oLogTest => $oLogTest});
# Break the system id
$oInfo{&INFO_ARCHIVE_SECTION_DB}{&INFO_ARCHIVE_KEY_DB_VERSION} = $strDbVersion;
@@ -213,17 +222,48 @@ sub BackRestTestBackup_Test
&log(INFO, ' test db system-id mismatch error');
BackRestTestCommon_Execute($strCommand . " ${strSourceFile}", undef, undef, undef,
ERROR_ARCHIVE_MISMATCH);
executeTest($strCommand . " ${strSourceFile}",
{iExpectedExitStatus => ERROR_ARCHIVE_MISMATCH, oLogTest => $oLogTest});
# Move settings back to original
$oInfo{&INFO_ARCHIVE_SECTION_DB}{&INFO_ARCHIVE_KEY_DB_SYSTEM_ID} = $ullDbSysId;
BackRestTestCommon_iniSave($strInfoFile, \%oInfo, $bRemote, true);
# Fail because the process was killed
if ($iBackup == 1 && !$bCompress)
{
&log(INFO, ' test stop');
if ($bArchiveAsync)
{
my $oExecArchive = new BackRestTest::Common::ExecuteTest(
$strCommand . ' --test --test-delay=5 --test-point=' . lc(TEST_ARCHIVE_PUSH_ASYNC_START) .
"=y ${strSourceFile}",
{oLogTest => $oLogTest, iExpectedExitStatus => ERROR_TERM});
$oExecArchive->begin();
$oExecArchive->end(TEST_ARCHIVE_PUSH_ASYNC_START);
BackRestTestBackup_Stop(undef, undef, true);
$oExecArchive->end();
}
else
{
BackRestTestBackup_Stop($strStanza);
}
executeTest($strCommand . " ${strSourceFile}",
{oLogTest => $oLogTest, iExpectedExitStatus => ERROR_STOP});
BackRestTestBackup_Start($bArchiveAsync ? undef : $strStanza);
}
# Should succeed because checksum is the same
&log(INFO, ' test archive duplicate ok');
BackRestTestCommon_Execute($strCommand . " ${strSourceFile}");
executeTest($strCommand . " ${strSourceFile}", {oLogTest => $oLogTest});
# Now it should break on archive duplication (because checksum is different
&log(INFO, ' test archive duplicate error');
@@ -235,8 +275,8 @@ sub BackRestTestBackup_Test
undef, undef, undef, # Unused params
true); # Create path if it does not exist
BackRestTestCommon_Execute($strCommand . " ${strSourceFile}", undef, undef, undef,
ERROR_ARCHIVE_DUPLICATE);
executeTest($strCommand . " ${strSourceFile}",
{iExpectedExitStatus => ERROR_ARCHIVE_DUPLICATE, oLogTest => $oLogTest});
if ($bArchiveAsync)
{
@@ -272,10 +312,13 @@ sub BackRestTestBackup_Test
}
}
# !!! Need to put in tests for .backup files here
# Might be nice to add tests for .backup files here (but this is already tested in full backup)
}
BackRestTestCommon_TestLogAppendFile($oFile->pathGet(PATH_BACKUP_ARCHIVE) . '/archive.info', $bRemote);
if (defined($oLogTest))
{
$oLogTest->supplementalAdd($oFile->pathGet(PATH_BACKUP_ARCHIVE) . '/archive.info', $bRemote);
}
}
}
@@ -283,7 +326,7 @@ sub BackRestTestBackup_Test
$bCreate = true;
}
if (BackRestTestCommon_Cleanup())
if (BackRestTestCommon_Cleanup(\$oLogTest))
{
&log(INFO, 'cleanup');
BackRestTestBackup_Drop(true);
@@ -314,7 +357,8 @@ sub BackRestTestBackup_Test
"rmt ${bRemote}, cmp ${bCompress}" .
', error ' . ($iError ? 'connect' : 'version'),
$iThreadMax == 1 ? $strModule : undef,
$iThreadMax == 1 ? $strThisTest: undef)) {next}
$iThreadMax == 1 ? $strThisTest: undef,
\$oLogTest)) {next}
# Create the file object
if ($bCreate)
@@ -333,7 +377,7 @@ sub BackRestTestBackup_Test
# Create the test directory
BackRestTestBackup_Create($bRemote, false);
BackRestTestCommon_ConfigCreate('db',
BackRestTestCommon_ConfigCreate(DB,
($bRemote ? BACKUP : undef),
$bCompress,
undef, # checksum
@@ -342,9 +386,13 @@ sub BackRestTestBackup_Test
true, # archive-async
undef);
BackRestTestCommon_ConfigCreate(BACKUP,
($bRemote ? DB : undef));
# Helper function to push archive logs
sub archivePush
{
my $oLogTest = shift;
my $oFile = shift;
my $strXlogPath = shift;
my $strArchiveTestFile = shift;
@@ -365,12 +413,12 @@ sub BackRestTestBackup_Test
(defined($iExpectedError) && $iExpectedError == ERROR_HOST_CONNECT ?
" --backup-host=bogus" : '');
BackRestTestCommon_Execute($strCommand . " ${strSourceFile}", undef, undef, undef,
$iExpectedError);
executeTest($strCommand . " ${strSourceFile}",
{iExpectedExitStatus => $iExpectedError, oLogTest => $oLogTest});
}
# Push a WAL segment
archivePush($oFile, $strXlogPath, $strArchiveTestFile, 1);
archivePush($oLogTest, $oFile, $strXlogPath, $strArchiveTestFile, 1);
# load the archive info file so it can be munged for testing
my $strInfoFile = $oFile->pathGet(PATH_BACKUP_ARCHIVE, ARCHIVE_INFO_FILE);
@@ -387,14 +435,14 @@ sub BackRestTestBackup_Test
}
# Push two more segments with errors to exceed archive-max-mb
archivePush($oFile, $strXlogPath, $strArchiveTestFile, 2,
archivePush($oLogTest, $oFile, $strXlogPath, $strArchiveTestFile, 2,
$iError ? ERROR_HOST_CONNECT : ERROR_ARCHIVE_MISMATCH);
archivePush($oFile, $strXlogPath, $strArchiveTestFile, 3,
archivePush($oLogTest, $oFile, $strXlogPath, $strArchiveTestFile, 3,
$iError ? ERROR_HOST_CONNECT : ERROR_ARCHIVE_MISMATCH);
# Now this segment will get dropped
archivePush($oFile, $strXlogPath, $strArchiveTestFile, 4);
archivePush($oLogTest, $oFile, $strXlogPath, $strArchiveTestFile, 4);
# Fix the database version
if ($iError == 0)
@@ -411,15 +459,15 @@ sub BackRestTestBackup_Test
or die "unable to remove stop file ${strStopFile}";
# Push two more segments - only #4 should be missing from the archive at the end
archivePush($oFile, $strXlogPath, $strArchiveTestFile, 5);
archivePush($oFile, $strXlogPath, $strArchiveTestFile, 6);
archivePush($oLogTest, $oFile, $strXlogPath, $strArchiveTestFile, 5);
archivePush($oLogTest, $oFile, $strXlogPath, $strArchiveTestFile, 6);
}
}
$bCreate = true;
}
if (BackRestTestCommon_Cleanup())
if (BackRestTestCommon_Cleanup(\$oLogTest))
{
&log(INFO, 'cleanup');
BackRestTestBackup_Drop(true);
@@ -449,7 +497,8 @@ sub BackRestTestBackup_Test
if (!BackRestTestCommon_Run(++$iRun,
"rmt ${bRemote}, cmp ${bCompress}, exists ${bExists}",
$iThreadMax == 1 ? $strModule : undef,
$iThreadMax == 1 ? $strThisTest: undef)) {next}
$iThreadMax == 1 ? $strThisTest: undef,
\$oLogTest)) {next}
# Create the test directory
if ($bCreate)
@@ -464,6 +513,13 @@ sub BackRestTestBackup_Test
))->clone();
BackRestTestBackup_Create($bRemote, false);
BackRestTestBackup_Init($bRemote, $oFile, true, $oLogTest);
BackRestTestCommon_ConfigCreate(DB,
($bRemote ? BACKUP : undef));
BackRestTestCommon_ConfigCreate(BACKUP,
($bRemote ? DB : undef));
# Create the db/common/pg_xlog directory
BackRestTestCommon_PathCreate($strXlogPath);
@@ -484,22 +540,29 @@ sub BackRestTestBackup_Test
'/pg_backrest.conf --stanza=db archive-get';
BackRestTestCommon_Execute($strCommand . " 000000010000000100000001 ${strXlogPath}/000000010000000100000001",
undef, undef, undef, ERROR_FILE_MISSING);
executeTest($strCommand . " 000000010000000100000001 ${strXlogPath}/000000010000000100000001",
{iExpectedExitStatus => ERROR_FILE_MISSING, oLogTest => $oLogTest});
# Create the archive info file
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g+r,g+x " . BackRestTestCommon_RepoPathGet(), $bRemote);
executeTest("chmod g+r,g+x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
BackRestTestCommon_Execute('mkdir -p -m 770 ' . $oFile->pathGet(PATH_BACKUP_ARCHIVE), $bRemote);
executeTest('mkdir -p -m 770 ' . $oFile->pathGet(PATH_BACKUP_ARCHIVE),
{bRemote => $bRemote});
(new BackRest::ArchiveInfo($oFile->pathGet(PATH_BACKUP_ARCHIVE)))->check('9.3', 1234567890123456789);
BackRestTestCommon_TestLogAppendFile($oFile->pathGet(PATH_BACKUP_ARCHIVE) . '/archive.info', $bRemote);
if (defined($oLogTest))
{
$oLogTest->supplementalAdd($oFile->pathGet(PATH_BACKUP_ARCHIVE) . '/archive.info');
}
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g-r,g-x " . BackRestTestCommon_RepoPathGet(), $bRemote);
executeTest("chmod g-r,g-x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
if ($bExists)
@@ -536,7 +599,7 @@ sub BackRestTestBackup_Test
my $strDestinationFile = "${strXlogPath}/${strArchiveFile}";
BackRestTestCommon_Execute($strCommand . " ${strArchiveFile} ${strDestinationFile}");
executeTest($strCommand . " ${strArchiveFile} ${strDestinationFile}", {oLogTest => $oLogTest});
# Check that the destination file exists
if ($oFile->exists(PATH_DB_ABSOLUTE, $strDestinationFile))
@@ -554,8 +617,15 @@ sub BackRestTestBackup_Test
}
else
{
BackRestTestCommon_Execute($strCommand . " 000000090000000900000009 ${strXlogPath}/RECOVERYXLOG",
undef, undef, undef, 1);
BackRestTestBackup_Stop();
executeTest($strCommand . " 000000090000000900000009 ${strXlogPath}/RECOVERYXLOG",
{iExpectedExitStatus => ERROR_STOP, oLogTest => $oLogTest});
BackRestTestBackup_Start();
executeTest($strCommand . " 000000090000000900000009 ${strXlogPath}/RECOVERYXLOG",
{iExpectedExitStatus => 1, oLogTest => $oLogTest});
}
$bCreate = true;
@@ -563,7 +633,7 @@ sub BackRestTestBackup_Test
}
}
if (BackRestTestCommon_Cleanup())
if (BackRestTestCommon_Cleanup(\$oLogTest))
{
&log(INFO, 'cleanup');
BackRestTestBackup_Drop(true);
@@ -585,7 +655,8 @@ sub BackRestTestBackup_Test
if (BackRestTestCommon_Run(++$iRun,
"local",
$iThreadMax == 1 ? $strModule : undef,
$iThreadMax == 1 ? $strThisTest: undef))
$iThreadMax == 1 ? $strThisTest: undef,
\$oLogTest))
{
# Create the file object
$oFile = (BackRest::File->new
@@ -611,7 +682,7 @@ sub BackRestTestBackup_Test
undef); # compress-async
# Create the test object
my $oExpireTest = new BackRestTest::ExpireCommonTest($oFile);
my $oExpireTest = new BackRestTest::ExpireCommonTest($oFile, $oLogTest);
$oExpireTest->stanzaCreate($strStanza, '9.2');
use constant SECONDS_PER_DAY => 86400;
@@ -659,7 +730,7 @@ sub BackRestTestBackup_Test
$oExpireTest->process($strStanza, 1, 1, BACKUP_TYPE_INCR, 1, $strDescription);
# Cleanup
if (BackRestTestCommon_Cleanup())
if (BackRestTestCommon_Cleanup(\$oLogTest))
{
&log(INFO, 'cleanup');
BackRestTestBackup_Drop(true);
@@ -690,7 +761,12 @@ sub BackRestTestBackup_Test
if (!BackRestTestCommon_Run(++$iRun,
"rmt ${bRemote}, cmp ${bCompress}, hardlink ${bHardlink}",
$iThreadMax == 1 ? $strModule : undef,
$iThreadMax == 1 ? $strThisTest: undef)) {next}
$iThreadMax == 1 ? $strThisTest: undef,
\$oLogTest)) {next}
# Determine if this is a neutral test, i.e. we only want to do it once for local and once for remote. Neutral means
# that options such as compression and hardlinks are disabled
my $bNeutralTest = !$bCompress && !$bHardlink;
# Get base time
my $lTime = time() - 100000;
@@ -726,6 +802,8 @@ sub BackRestTestBackup_Test
$bRemote ? $oRemote : $oLocal
);
BackRestTestBackup_Init($bRemote, $oFile, true, $oLogTest, $iThreadMax);
BackRestTestBackup_ManifestFileCreate(\%oManifest, 'base', 'PG_VERSION', '9.3',
'e1f7a3a299f62225cba076fc6d3d6e677f303482', $lTime);
@@ -740,8 +818,8 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestFileCreate(\%oManifest, 'base', 'global/pg_control', '[replaceme]',
'56fe5780b8dca9705e0c22032a83828860a21235', $lTime - 100);
BackRestTestCommon_Execute('cp ' . BackRestTestCommon_DataPathGet() . '/pg_control ' .
BackRestTestCommon_DbCommonPathGet() . '/global/pg_control');
executeTest('cp ' . BackRestTestCommon_DataPathGet() . '/pg_control ' .
BackRestTestCommon_DbCommonPathGet() . '/global/pg_control');
utime($lTime - 100, $lTime - 100, BackRestTestCommon_DbCommonPathGet() . '/global/pg_control')
or confess &log(ERROR, "unable to set time");
$oManifest{'base:file'}{'global/pg_control'}{'size'} = 8192;
@@ -775,8 +853,60 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestLinkCreate(\%oManifest, 'base', 'link-test', '/test');
BackRestTestBackup_ManifestPathCreate(\%oManifest, 'base', 'path-test');
my $strFullBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
undef, undef, undef, undef, '--manifest-save-threshold=3');
my $strFullBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, undef,
{strOptionalParam => '--manifest-save-threshold=3'});
# Stop operations and make sure the correct error occurs
#-----------------------------------------------------------------------------------------------------------------------
if ($bNeutralTest)
{
# Test a backup abort
BackRestTestBackup_BackupBegin($strType, $strStanza, 'abort backup - local',
{strTest => TEST_BACKUP_START, fTestDelay => 5, iExpectedExitStatus => ERROR_TERM});
BackRestTestBackup_Stop(undef, undef, true);
BackRestTestBackup_BackupEnd();
# Test global stop
BackRestTestBackup_BackupSynthetic($strType, $strStanza, undef, 'global stop',
{iExpectedExitStatus => ERROR_STOP});
# Test stanza stop
BackRestTestBackup_Stop($strStanza);
# This time a warning should be generated
BackRestTestBackup_Stop($strStanza);
BackRestTestBackup_BackupSynthetic($strType, $strStanza, undef, 'stanza stop',
{iExpectedExitStatus => ERROR_STOP});
BackRestTestBackup_Start($strStanza);
BackRestTestBackup_Start();
# This time a warning should be generated
BackRestTestBackup_Start();
# If the backup is remote then test remote stops
if ($bRemote)
{
BackRestTestBackup_BackupBegin($strType, $strStanza, 'abort backup - remote',
{strTest => TEST_BACKUP_START, fTestDelay => 5,
iExpectedExitStatus => ERROR_TERM});
BackRestTestBackup_Stop(undef, $bRemote, true);
BackRestTestBackup_BackupEnd();
BackRestTestBackup_BackupSynthetic($strType, $strStanza, undef, 'global stop',
{iExpectedExitStatus => ERROR_STOP});
BackRestTestBackup_Start(undef, $bRemote, true);
}
}
# Cleanup any garbage left in the temp backup path
executeTest('rm -rf ' . BackRestTestCommon_RepoPathGet() . "/temp/${strStanza}.tmp", {bRemote => $bRemote});
# Backup Info
#-----------------------------------------------------------------------------------------------------------------------
@@ -796,8 +926,12 @@ sub BackRestTestBackup_Test
$oMungeManifest->remove('base:file', 'PG_VERSION', 'checksum');
BackRestTestCommon_manifestSave("$strTmpPath/backup.manifest", $oMungeManifest, $bRemote);
$strFullBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'resume', TEST_BACKUP_RESUME);
# Create a temp file in backup temp root to be sure it's deleted correctly
executeTest("touch ${strTmpPath}/file.tmp" . ($bCompress ? '.gz' : ''),
{bRemote => $bRemote});
$strFullBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'resume',
{strTest => TEST_BACKUP_RESUME});
# Restore - tests various mode, extra files/paths, missing files/paths
#-----------------------------------------------------------------------------------------------------------------------
@@ -839,8 +973,8 @@ sub BackRestTestBackup_Test
$oInfo{db}{&MANIFEST_KEY_DB_VERSION} = '8.0';
BackRestTestCommon_iniSave($strInfoFile, \%oInfo, $bRemote, true);
my $strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'invalid database version', undef, undef, ERROR_BACKUP_MISMATCH);
BackRestTestBackup_BackupSynthetic($strType, $strStanza, undef, 'invalid database version',
{iExpectedExitStatus => ERROR_BACKUP_MISMATCH});
$oInfo{db}{&MANIFEST_KEY_DB_VERSION} = $strDbVersion;
# Break the database system id
@@ -848,8 +982,8 @@ sub BackRestTestBackup_Test
$oInfo{db}{&MANIFEST_KEY_SYSTEM_ID} = 6999999999999999999;
BackRestTestCommon_iniSave($strInfoFile, \%oInfo, $bRemote, true);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'invalid system id', undef, undef, ERROR_BACKUP_MISMATCH);
BackRestTestBackup_BackupSynthetic($strType, $strStanza, undef, 'invalid system id',
{iExpectedExitStatus => ERROR_BACKUP_MISMATCH});
$oInfo{db}{&MANIFEST_KEY_SYSTEM_ID} = $ullDbSysId;
# Break the control version
@@ -857,8 +991,8 @@ sub BackRestTestBackup_Test
$oInfo{db}{&MANIFEST_KEY_CONTROL} = 842;
BackRestTestCommon_iniSave($strInfoFile, \%oInfo, $bRemote, true);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'invalid control version', undef, undef, ERROR_BACKUP_MISMATCH);
BackRestTestBackup_BackupSynthetic($strType, $strStanza, undef, 'invalid control version',
{iExpectedExitStatus => ERROR_BACKUP_MISMATCH});
$oInfo{db}{&MANIFEST_KEY_CONTROL} = $iControlVersion;
# Break the catalog version
@@ -866,8 +1000,8 @@ sub BackRestTestBackup_Test
$oInfo{db}{&MANIFEST_KEY_CATALOG} = 197208141;
BackRestTestCommon_iniSave($strInfoFile, \%oInfo, $bRemote, true);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'invalid catalog version', undef, undef, ERROR_BACKUP_MISMATCH);
BackRestTestBackup_BackupSynthetic($strType, $strStanza, undef, 'invalid catalog version',
{iExpectedExitStatus => ERROR_BACKUP_MISMATCH});
# Fix up info file for next test
$oInfo{db}{&MANIFEST_KEY_CATALOG} = $iCatalogVersion;
@@ -885,8 +1019,7 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestFileCreate(\%oManifest, "base", 'badchecksum.txt', 'BADCHECKSUM',
'f927212cd08d11a42a666b2f04235398e9ceeb51', $lTime);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'add tablespace 1');
my $strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'add tablespace 1');
# Resume Incr Backup
#
@@ -910,8 +1043,8 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestFileCreate(\%oManifest, "tablespace/2", 'tablespace2.txt', 'TBLSPC2',
'dc7f76e43c46101b47acc55ae4d593a9e6983578', $lTime);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'resume and add tablespace 2', TEST_BACKUP_RESUME);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'resume and add tablespace 2',
{strTest => TEST_BACKUP_RESUME});
# Resume Diff Backup
#-----------------------------------------------------------------------------------------------------------------------
@@ -922,8 +1055,8 @@ sub BackRestTestBackup_Test
BackRestTestCommon_PathMove(BackRestTestCommon_RepoPathGet() . "/backup/${strStanza}/${strBackup}",
$strTmpPath, $bRemote);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'cannot resume - new diff', TEST_BACKUP_NORESUME);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'cannot resume - new diff',
{strTest => TEST_BACKUP_NORESUME});
# Resume Diff Backup
#-----------------------------------------------------------------------------------------------------------------------
@@ -934,9 +1067,8 @@ sub BackRestTestBackup_Test
BackRestTestCommon_PathMove(BackRestTestCommon_RepoPathGet() . "/backup/${strStanza}/${strBackup}",
$strTmpPath, $bRemote);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'cannot resume - disabled', TEST_BACKUP_NORESUME, undef, undef,
'--no-resume');
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'cannot resume - disabled',
{strTest => TEST_BACKUP_NORESUME, strOptionalParam => '--no-resume'});
# Restore
#-----------------------------------------------------------------------------------------------------------------------
@@ -990,8 +1122,7 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestMunge($oFile, $bRemote, $strBackup, INI_SECTION_BACKREST, INI_KEY_VERSION, undef,
'0.00');
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest,
'add files and remove tablespace 2');
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'add files and remove tablespace 2');
# Incr Backup
#-----------------------------------------------------------------------------------------------------------------------
@@ -1001,27 +1132,26 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestFileCreate(\%oManifest, 'base', 'base/base1.txt', 'BASEUPDT',
'9a53d532e27785e681766c98516a5e93f096a501', $lTime);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest, 'update files');
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'update files');
# Diff Backup
#-----------------------------------------------------------------------------------------------------------------------
$strType = 'diff';
BackRestTestBackup_ManifestReference(\%oManifest, $strFullBackup, true);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest, 'no updates');
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'no updates');
# Incr Backup
#-----------------------------------------------------------------------------------------------------------------------
$strType = 'incr';
BackRestTestBackup_ManifestReference(\%oManifest, $strBackup);
BackRestTestBackup_BackupBegin($strType, $strStanza, $bRemote, "remove files - but won't affect manifest",
true, true, 1);
BackRestTestCommon_ExecuteEnd(TEST_MANIFEST_BUILD);
BackRestTestBackup_BackupBegin($strType, $strStanza, "remove files - but won't affect manifest",
{strTest => TEST_MANIFEST_BUILD, fTestDelay => 1});
BackRestTestBackup_FileRemove(\%oManifest, 'base', 'base/base1.txt');
$strBackup = BackRestTestBackup_BackupEnd($strType, $strStanza, $oFile, $bRemote, undef, \%oManifest, true);
$strBackup = BackRestTestBackup_BackupEnd(\%oManifest);
# Diff Backup
#-----------------------------------------------------------------------------------------------------------------------
@@ -1035,15 +1165,15 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestFileCreate(\%oManifest, "tablespace/2", 'tablespace2c.txt', 'TBLSPC2C',
'ad7df329ab97a1e7d35f1ff0351c079319121836', $lTime);
BackRestTestBackup_BackupBegin($strType, $strStanza, $bRemote, "remove files during backup", true, true, 1);
BackRestTestCommon_ExecuteEnd(TEST_MANIFEST_BUILD);
BackRestTestBackup_BackupBegin($strType, $strStanza, 'remove files during backup',
{strTest => TEST_MANIFEST_BUILD, fTestDelay => 1});
BackRestTestBackup_ManifestFileCreate(\%oManifest, "tablespace/2", 'tablespace2c.txt', 'TBLSPCBIGGER',
'dfcb8679956b734706cf87259d50c88f83e80e66', $lTime);
BackRestTestBackup_ManifestFileRemove(\%oManifest, 'base', 'base/base2.txt', true);
$strBackup = BackRestTestBackup_BackupEnd($strType, $strStanza, $oFile, $bRemote, undef, \%oManifest, true);
$strBackup = BackRestTestBackup_BackupEnd(\%oManifest);
# Full Backup
#-----------------------------------------------------------------------------------------------------------------------
@@ -1053,7 +1183,7 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestFileCreate(\%oManifest, 'base', 'base/base1.txt', 'BASEUPDT2',
'7579ada0808d7f98087a0a586d0df9de009cdc33', $lTime);
$strFullBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest);
$strFullBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest);
# Diff Backup
#-----------------------------------------------------------------------------------------------------------------------
@@ -1063,7 +1193,7 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ManifestFileCreate(\%oManifest, 'base', 'base/base2.txt', 'BASE2UPDT',
'cafac3c59553f2cfde41ce2e62e7662295f108c0', $lTime);
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, $bRemote, $oFile, \%oManifest, 'add files');
$strBackup = BackRestTestBackup_BackupSynthetic($strType, $strStanza, \%oManifest, 'add files');
# Restore
#-----------------------------------------------------------------------------------------------------------------------
@@ -1075,7 +1205,8 @@ sub BackRestTestBackup_Test
# Backup Info (with an empty stanza)
#-----------------------------------------------------------------------------------------------------------------------
BackRestTestCommon_Execute('mkdir ' . BackRestTestCommon_RepoPathGet . '/backup/db_empty', $bRemote);
executeTest('mkdir ' . BackRestTestCommon_RepoPathGet . '/backup/db_empty',
{bRemote => $bRemote});
BackRestTestBackup_Info(undef, undef, false);
BackRestTestBackup_Info(undef, INFO_OUTPUT_JSON, false);
@@ -1084,7 +1215,8 @@ sub BackRestTestBackup_Test
# Backup Info (with no stanzas)
#-----------------------------------------------------------------------------------------------------------------------
BackRestTestCommon_Execute('rm -rf ' . BackRestTestCommon_RepoPathGet . '/backup/*', $bRemote);
executeTest('rm -rf ' . BackRestTestCommon_RepoPathGet . '/backup/*',
{bRemote => $bRemote});
BackRestTestBackup_Info(undef, undef, false);
BackRestTestBackup_Info(undef, INFO_OUTPUT_JSON, false);
@@ -1092,7 +1224,7 @@ sub BackRestTestBackup_Test
}
}
if (BackRestTestCommon_Cleanup())
if (BackRestTestCommon_Cleanup(\$oLogTest))
{
&log(INFO, 'cleanup');
BackRestTestBackup_Drop(true);
@@ -1167,9 +1299,11 @@ sub BackRestTestBackup_Test
$bCreate = false;
}
BackRestTestBackup_Init($bRemote, $oFile, false, undef, $iThreadMax);
# Static backup parameters
my $bSynthetic = false;
my $fTestDelay = .1;
# my $bSynthetic = false;
my $fTestDelay = 1;
# Variable backup parameters
my $bDelta = true;
@@ -1180,7 +1314,7 @@ sub BackRestTestBackup_Test
my $bTargetResume = false;
my $strTargetTimeline = undef;
my $oRecoveryHashRef = undef;
my $strTestPoint = undef;
# my $strTestPoint = undef;
my $strComment = undef;
my $iExpectedExitStatus = undef;
@@ -1196,7 +1330,6 @@ sub BackRestTestBackup_Test
# Full backup
#-----------------------------------------------------------------------------------------------------------------------
$strType = BACKUP_TYPE_FULL;
$strTestPoint = TEST_MANIFEST_BUILD;
# Create the table where test messages will be stored
BackRestTestBackup_PgExecute("create table test (message text not null)");
@@ -1210,7 +1343,8 @@ sub BackRestTestBackup_Test
}
$strComment = 'fail on backup lock exists';
BackRestTestBackup_Backup($strType, $strStanza, $bRemote, $oFile, $strComment, undef, undef, ERROR_LOCK_ACQUIRE);
BackRestTestBackup_Backup($strType, $strStanza, $strComment,
{iExpectedExitStatus => ERROR_LOCK_ACQUIRE});
# Release the backup advisory lock so the next backup will succeed
if (!BackRestTestBackup_PgSelectOne('select pg_advisory_unlock(' . DB_BACKUP_ADVISORY_LOCK . ')'))
@@ -1219,14 +1353,28 @@ sub BackRestTestBackup_Test
}
$strComment = 'update during backup';
BackRestTestBackup_BackupBegin($strType, $strStanza, $bRemote, $strComment, $bSynthetic,
defined($strTestPoint), $fTestDelay);
BackRestTestCommon_ExecuteEnd($strTestPoint);
BackRestTestBackup_BackupBegin($strType, $strStanza, $strComment,
{strTest => TEST_MANIFEST_BUILD, fTestDelay => $fTestDelay});
BackRestTestBackup_PgExecute("update test set message = '$strFullMessage'", false);
my $strFullBackup = BackRestTestBackup_BackupEnd($strType, $strStanza, $oFile, $bRemote, undef, undef, $bSynthetic);
my $strFullBackup = BackRestTestBackup_BackupEnd();
# Execute stop and make sure the backup fails
#-----------------------------------------------------------------------------------------------------------------------
$strComment = 'attempt backup when stopped';
# Stop the cluster to check for any errors before continuing since the stop tests will definitely create errors and
# the logs will to be deleted to avoid causing issues further down the line.
BackRestTestBackup_ClusterStop();
BackRestTestBackup_ClusterStart();
BackRestTestBackup_Stop();
BackRestTestBackup_Backup($strType, $strStanza, $strComment,
{iExpectedExitStatus => ERROR_STOP});
BackRestTestBackup_Start();
# Setup the time target
#-----------------------------------------------------------------------------------------------------------------------
@@ -1238,7 +1386,6 @@ sub BackRestTestBackup_Test
# Incr backup
#-----------------------------------------------------------------------------------------------------------------------
$strType = BACKUP_TYPE_INCR;
$strTestPoint = TEST_MANIFEST_BUILD;
BackRestTestBackup_PgExecuteNoTrans("create tablespace ts1 location '" .
BackRestTestCommon_DbTablespacePathGet(1) . "'");
@@ -1260,15 +1407,15 @@ sub BackRestTestBackup_Test
# BackRestTestBackup_Backup($strType, $strStanza, $bRemote, $oFile, $strComment, undef, undef, ERROR_DB_QUERY);
$strComment = 'update during backup';
BackRestTestBackup_BackupBegin($strType, $strStanza, $bRemote, $strComment, $bSynthetic,
defined($strTestPoint), $fTestDelay, '--' . OPTION_STOP_AUTO);
BackRestTestCommon_ExecuteEnd($strTestPoint);
BackRestTestBackup_BackupBegin($strType, $strStanza, $strComment,
{strTest => TEST_MANIFEST_BUILD, fTestDelay => $fTestDelay,
strOptionalParam => '--' . OPTION_STOP_AUTO});
BackRestTestBackup_PgExecute("drop table test_remove", false);
BackRestTestBackup_PgSwitchXlog();
BackRestTestBackup_PgExecute("update test set message = '$strIncrMessage'", false);
my $strIncrBackup = BackRestTestBackup_BackupEnd($strType, $strStanza, $oFile, $bRemote, undef, undef, $bSynthetic);
my $strIncrBackup = BackRestTestBackup_BackupEnd();
# Setup the xid target
#-----------------------------------------------------------------------------------------------------------------------
@@ -1389,7 +1536,7 @@ sub BackRestTestBackup_Test
BackRestTestBackup_ClusterStop();
# Restore recovery file that was save in last test
# Restore recovery file that was saved in last test
$oFile->move(PATH_ABSOLUTE, BackRestTestCommon_TestPathGet() . '/recovery.conf',
PATH_ABSOLUTE, BackRestTestCommon_DbCommonPathGet() . '/recovery.conf');
@@ -1508,22 +1655,19 @@ sub BackRestTestBackup_Test
# Incr backup - make sure a --no-stop-start backup fails
#-----------------------------------------------------------------------------------------------------------------------
$strType = BACKUP_TYPE_INCR;
$strTestPoint = TEST_MANIFEST_BUILD;
$strComment = 'fail on --' . OPTION_NO_START_STOP;
BackRestTestBackup_BackupBegin($strType, $strStanza, $bRemote, $strComment, $bSynthetic,
defined($strTestPoint), $fTestDelay, '--' . OPTION_NO_START_STOP);
BackRestTestCommon_ExecuteEnd(undef, undef, undef, ERROR_POSTMASTER_RUNNING);
BackRestTestBackup_Backup($strType, $strStanza, $strComment,
{iExpectedExitStatus => ERROR_POSTMASTER_RUNNING,
strOptionalParam => '--' . OPTION_NO_START_STOP});
# Incr backup - allow --no-start-stop backup to succeed with --force
#-----------------------------------------------------------------------------------------------------------------------
$strType = BACKUP_TYPE_INCR;
$strTestPoint = TEST_MANIFEST_BUILD;
$strComment = 'succeed on --' . OPTION_NO_START_STOP . ' with --' . OPTION_FORCE;
BackRestTestBackup_BackupBegin($strType, $strStanza, $bRemote, $strComment, $bSynthetic,
defined($strTestPoint), $fTestDelay, '--' . OPTION_NO_START_STOP . ' --' . OPTION_FORCE);
BackRestTestCommon_ExecuteEnd();
BackRestTestBackup_Backup($strType, $strStanza, $strComment,
{strOptionalParam => '--' . OPTION_NO_START_STOP . ' --' . OPTION_FORCE});
$bCreate = true;
}
@@ -1714,7 +1858,7 @@ sub BackRestTestBackup_Test
# Rsync
&log(INFO, "rsync 1st time");
BackRestTestCommon_Execute($strCommand, false, false, true);
executeTest($strCommand, {bShowOutput => true});
# Sleep for a while to show there is a large window where this can happen
&log(INFO, 'time ' . gettimeofday());
@@ -1729,7 +1873,7 @@ sub BackRestTestBackup_Test
# Rsync again
&log(INFO, "rsync 2nd time");
BackRestTestCommon_Execute($strCommand, false, false, true);
excuteTest($strCommand, {bShowOutput => true});
my $strTestChecksum = $oFile->hash(PATH_DB_ABSOLUTE, "${strPathRsync2}/test.txt");

278
test/lib/BackRestTest/Common/ExecuteTest.pm Normal file
View File

@@ -0,0 +1,278 @@
#!/usr/bin/perl
####################################################################################################################################
# ExecuteTest.pl - Module to execute external commands
####################################################################################################################################
package BackRestTest::Common::ExecuteTest;
####################################################################################################################################
# Perl includes
####################################################################################################################################
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
use IO::Select;
use IPC::Open3;
use POSIX ':sys_wait_h';
use Symbol 'gensym';
use lib dirname($0) . '/../lib';
use BackRest::Common::Log;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_EXECUTE_TEST => 'ExecuteTest';
use constant OP_EXECUTE_TEST_BEGIN => OP_EXECUTE_TEST . "->begin";
use constant OP_EXECUTE_TEST_END => OP_EXECUTE_TEST . "->end";
use constant OP_EXECUTE_TEST_NEW => OP_EXECUTE_TEST . "->new";
####################################################################################################################################
# new
####################################################################################################################################
sub new
{
my $class = shift; # Class name
# Create the class hash
my $self = {};
bless $self, $class;
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{strCommandOriginal},
my $oParam
) =
logDebugParam
(
OP_EXECUTE_TEST_NEW, \@_,
{name => 'strCommandOriginal'},
{name => 'oParam', required => false}
);
# Load params
foreach my $strParam (sort(keys(%$oParam)))
{
$self->{$strParam} = $$oParam{$strParam};
}
# Set defaults
$self->{bRemote} = defined($self->{bRemote}) ? $self->{bRemote} : false;
$self->{bSuppressError} = defined($self->{bSuppressError}) ? $self->{bSuppressError} : false;
$self->{bShowOutput} = defined($self->{bShowOutput}) ? $self->{bShowOutput} : false;
$self->{iExpectedExitStatus} = defined($self->{iExpectedExitStatus}) ? $self->{iExpectedExitStatus} : 0;
$self->{strUserBackRest} = 'backrest'; #BackRestTestCommon_UserBackRestGet();
$self->{strHost} = '127.0.0.1'; #BackRestTestCommon_HostGet();
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self}
);
}
####################################################################################################################################
# begin
####################################################################################################################################
sub begin
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
logDebugParam(OP_EXECUTE_TEST_BEGIN);
if ($self->{bRemote})
{
# $self->{strCommand} = "sudo -u $self->{strUserBackRest} $self->{strCommandOriginal}";
$self->{strCommand} = "ssh $self->{strUserBackRest}\@$self->{strHost} '$self->{strCommandOriginal}'";
}
else
{
$self->{strCommand} = $self->{strCommandOriginal};
}
$self->{strErrorLog} = '';
$self->{strOutLog} = '';
if (defined($self->{oTestLog}))
{
if (defined($self->{strComment}))
{
$self->{strFullLog} = $self->{oTestLog}->regExpAll($self->{strComment}) . "\n";
}
$self->{strFullLog} .= '> ' . $self->{oTestLog}->regExpAll($self->{strCommand}) . "\n" . ('-' x '132') . "\n";
}
logDebugMisc("executing command: $self->{strCommand}");
# Execute the command
$self->{hError} = gensym;
$self->{pId} = open3(undef, $self->{hOut}, $self->{hError}, $self->{strCommand});
if (!defined($self->{hError}))
{
confess 'STDERR handle is undefined';
}
}
####################################################################################################################################
# end
####################################################################################################################################
sub end
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strTest
) =
logDebugParam
(
OP_EXECUTE_TEST_END, \@_,
{name => 'strTest', required => false}
);
# Create select objects
my $oErrorSelect = IO::Select->new();
$oErrorSelect->add($self->{hError});
my $oOutSelect = IO::Select->new();
$oOutSelect->add($self->{hOut});
# Drain the output and error streams and look for test points
while(waitpid($self->{pId}, WNOHANG) == 0)
{
# Drain the stderr stream
if ($oErrorSelect->can_read(0))
{
while (my $strLine = readline($self->{hError}))
{
$self->{strErrorLog} .= $strLine;
}
}
# Drain the stdout stream and look for test points
if ($oOutSelect->can_read(.05))
{
while (my $strLine = readline($self->{hOut}))
{
$self->{strOutLog} .= $strLine;
if (defined($strTest) && testCheck($strLine, $strTest))
{
&log(DEBUG, "Found test ${strTest}");
return true;
}
}
}
}
# Check the exit status
my $iExitStatus = ${^CHILD_ERROR_NATIVE} >> 8;
# Drain the stderr stream
if ($oErrorSelect->can_read(0))
{
while (my $strLine = readline($self->{hError}))
{
$self->{strErrorLog} .= $strLine;
}
}
# Drain the stdout stream
if ($oOutSelect->can_read(0))
{
while (my $strLine = readline($self->{hOut}))
{
$self->{strOutLog} .= $strLine;
}
}
# Pass the log to the LogTest object
if (defined($self->{oLogTest}))
{
$self->{oLogTest}->logAdd($self->{strCommandOriginal}, $self->{strComment}, $self->{strOutLog});
}
# If an error was expected then return success if that error occurred
if ($self->{iExpectedExitStatus} != 0 && $iExitStatus == $self->{iExpectedExitStatus})
{
return $iExitStatus;
}
# This is a hack to make regression tests pass even when threaded backup/restore sometimes return 255
if ($self->{iExpectedExitStatus} == -1 && ($iExitStatus == 0 || $iExitStatus == 255))
{
return 0;
}
if ($iExitStatus != 0 || ($self->{iExpectedExitStatus} != 0 && $iExitStatus != $self->{iExpectedExitStatus}))
{
if ($self->{bSuppressError})
{
&log(DEBUG, "suppressed error was ${iExitStatus}");
$self->{strErrorLog} = '';
}
else
{
confess &log(ERROR, "command '$self->{strCommand}' returned " . $iExitStatus .
($self->{iExpectedExitStatus} != 0 ? ", but $self->{iExpectedExitStatus} was expected" : '') . "\n" .
($self->{strOutLog} ne '' ? "STDOUT (last 10,000 characters):\n" . substr($self->{strOutLog},
length($self->{strOutLog}) - 10000) : '') .
($self->{strErrorLog} ne '' ? "STDERR:\n$self->{strErrorLog}" : ''));
}
}
if ($self->{strErrorLog} ne '')
{
confess &log(ERROR, "output found on STDERR:\n$self->{strErrorLog}");
}
if ($self->{bShowOutput})
{
print "output:\n$self->{strOutLog}\n";
}
if (defined($strTest))
{
confess &log(ASSERT, "test point ${strTest} was not found");
}
return $iExitStatus;
}
####################################################################################################################################
# executeTest
####################################################################################################################################
sub executeTest
{
my $strCommand = shift;
my $oParam = shift;
my $strTest = shift;
my $oExec = new BackRestTest::Common::ExecuteTest($strCommand, $oParam);
$oExec->begin();
if (defined($strTest))
{
$oExec->end($strTest);
}
$oExec->end();
return $oExec->{strOutLog};
}
push @EXPORT, qw(executeTest);
1;

371
test/lib/BackRestTest/Common/LogTest.pm Normal file
View File

@@ -0,0 +1,371 @@
#!/usr/bin/perl
####################################################################################################################################
# LogTest.pl - Capture the output of commands to compare them with an expected version
####################################################################################################################################
package BackRestTest::Common::LogTest;
####################################################################################################################################
# Perl includes
####################################################################################################################################
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Cwd qw(abs_path);
use Exporter qw(import);
our @EXPORT = qw();
use File::Basename qw(dirname);
use lib dirname($0) . '/../lib';
use BackRest::Common::Ini;
use BackRest::Common::Log;
use BackRest::Config::Config;
use BackRestTest::Common::ExecuteTest;
####################################################################################################################################
# Operation constants
####################################################################################################################################
use constant OP_LOG_TEST => 'LogTest';
use constant OP_LOG_TEST_LOG_ADD => OP_LOG_TEST . "->logAdd";
use constant OP_LOG_TEST_LOG_WRITE => OP_LOG_TEST . "->logWrite";
use constant OP_LOG_TEST_NEW => OP_LOG_TEST . "->new";
####################################################################################################################################
# new
####################################################################################################################################
sub new
{
my $class = shift; # Class name
# Create the class hash
my $self = {};
bless $self, $class;
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{strModule},
$self->{strTest},
$self->{iRun},
$self->{bForce},
$self->{strComment},
$self->{strCommandMain},
$self->{strCommandRemote},
$self->{strPgSqlBin},
$self->{strTestPath},
$self->{strRepoPath}
) =
logDebugParam
(
OP_LOG_TEST_NEW, \@_,
{name => 'strModule', trace => true},
{name => 'strTest', trace => true},
{name => 'iRun', trace => true},
{name => 'bForce', trace => true},
{name => 'strComment', trace => true},
{name => 'strCommandMain', trace => true},
{name => 'strCommandRemote', trace => true},
{name => 'strPgSqlBin', trace => true},
{name => 'strTestPath', trace => true},
{name => 'strRepoPath', trace => true}
);
# Initialize the test log
$self->{strLog} = 'run ' . sprintf('%03d', $self->{iRun}) . ' - ' . $self->{strComment};
$self->{strLog} .= "\n" . ('=' x length($self->{strLog})) . "\n";
# Initialize the replacement hash
$self->{oReplaceHash} = {};
# Return from function and log return values if any
return logDebugReturn
(
$strOperation,
{name => 'self', value => $self, trace => true}
);
}
####################################################################################################################################
# logAdd
####################################################################################################################################
sub logAdd
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strCommand,
$strComment,
$strLog
) =
logDebugParam
(
OP_LOG_TEST_LOG_ADD, \@_,
{name => 'strCommand', trace => true},
{name => 'strComment', required => false, trace => true},
{name => 'strLog', required => false, trace => true}
);
$self->{strLog} .= "\n";
if (defined($strComment))
{
$self->{strLog} .= $self->regExpReplaceAll($strComment) . "\n";
}
$self->{strLog} .= '> ' . $self->regExpReplaceAll($strCommand) . "\n" . ('-' x '132') . "\n";
# Make sure there is a log before trying to output it
if (defined($strLog))
{
# Do replacements on each line of the log
foreach my $strLine (split("\n", $strLog))
{
$strLine =~ s/^[0-9]{4}-[0-1][0-9]-[0-3][0-9] [0-2][0-9]:[0-6][0-9]:[0-6][0-9]\.[0-9]{3} T[0-9]{2} //;
if ($strLine !~ /^ TEST/)
{
$strLine =~ s/^ //;
$strLine =~ s/^ //;
$strLine =~ s/\r$//;
$strLine = $self->regExpReplaceAll($strLine);
$self->{strLog} .= "${strLine}\n";
}
}
}
# Return from function and log return values if any
logDebugReturn($strOperation);
}
####################################################################################################################################
# supplementalAdd
####################################################################################################################################
sub supplementalAdd
{
my $self = shift;
my $strFileName = shift;
my $bRemote = shift;
my $strComment = shift;
if ($bRemote)
{
executeTest("chmod g+x " . $self->{strRepoPath},
{bRemote => true});
}
open(my $hFile, '<', $strFileName)
or confess &log(ERROR, "unable to open ${strFileName} for appending to test log");
my $strHeader .= "+ supplemental file: " . $self->regExpReplaceAll($strFileName);
if (defined($strComment))
{
$self->{strLog} .= "\n" . $self->regExpReplaceAll($strComment) . "\n" . ('=' x '132') . "\n";
}
$self->{strLog} .= "\n${strHeader}\n" . ('-' x length($strHeader)) . "\n";
while (my $strLine = readline($hFile))
{
$self->{strLog} .= $self->regExpReplaceAll($strLine);
}
close($hFile);
if ($bRemote)
{
executeTest("chmod g-x " . $self->{strRepoPath},
{bRemote => true});
}
}
####################################################################################################################################
# logWrite
####################################################################################################################################
sub logWrite
{
my $self = shift;
# Assign function parameters, defaults, and log debug info
my
(
$strOperation,
$strBasePath,
$strTestPath,
$strFileName
) =
logDebugParam
(
OP_LOG_TEST_LOG_WRITE, \@_,
{name => 'strBasePath', trace => true},
{name => 'strTestPath', trace => true},
{name => 'strFileName',
default => sprintf("log/$self->{strModule}-$self->{strTest}-%03d.log", $self->{iRun}), trace => true}
);
if ($self->{bForce})
{
$strFileName = "${strBasePath}/test/${strFileName}";
}
else
{
my $strTestLogPath = "${strTestPath}/log";
if (!-e $strTestLogPath)
{
mkdir($strTestLogPath) or
confess "unable to create test log path ${strTestLogPath}";
}
$strFileName = "${strTestPath}/${strFileName}";
}
open(my $hFile, '>', $strFileName)
or confess "could not open test log file '${strFileName}': $!";
syswrite($hFile, $self->{strLog})
or confess "could not write to test log file '${strFileName}': $!";
close($hFile);
# Return from function and log return values if any
logDebugReturn($strOperation);
}
####################################################################################################################################
# regExpReplace
####################################################################################################################################
sub regExpReplace
{
my $self = shift;
my $strLine = shift;
my $strType = shift;
my $strExpression = shift;
my $strToken = shift;
my $bIndex = shift;
my @stryReplace = ($strLine =~ /$strExpression/g);
foreach my $strReplace (@stryReplace)
{
my $iIndex;
my $strTypeReplacement;
my $strReplacement;
if (!defined($bIndex) || $bIndex)
{
if (defined($strToken))
{
my @stryReplacement = ($strReplace =~ /$strToken/g);
if (@stryReplacement != 1)
{
confess &log(ASSERT, "'${strToken}' is not a sub-regexp of '${strExpression}' or" .
" matches multiple times on '${strReplace}'");
}
$strReplacement = $stryReplacement[0];
}
else
{
$strReplacement = $strReplace;
}
if (defined(${$self->{oReplaceHash}}{$strType}{$strReplacement}))
{
$iIndex = ${$self->{oReplaceHash}}{$strType}{$strReplacement}{index};
}
else
{
if (!defined(${$self->{oReplaceHash}}{$strType}{index}))
{
${$self->{oReplaceHash}}{$strType}{index} = 1;
}
$iIndex = ${$self->{oReplaceHash}}{$strType}{index}++;
${$self->{oReplaceHash}}{$strType}{$strReplacement}{index} = $iIndex;
}
}
$strTypeReplacement = "[${strType}" . (defined($iIndex) ? "-${iIndex}" : '') . ']';
if (defined($strToken))
{
$strReplacement = $strReplace;
$strReplacement =~ s/$strToken/$strTypeReplacement/;
}
else
{
$strReplacement = $strTypeReplacement;
}
$strLine =~ s/$strReplace/$strReplacement/g;
}
return $strLine;
}
####################################################################################################################################
# regExpReplaceAll
####################################################################################################################################
sub regExpReplaceAll
{
my $self = shift;
my $strLine = shift;
my $strBinPath = dirname(dirname(abs_path($0))) . '/bin';
$strLine =~ s/$self->{strCommandMain}/[BACKREST_BIN]/g;
$strLine =~ s/$self->{strCommandRemote}/[BACKREST_BIN]/g;
$strLine =~ s/$self->{strPgSqlBin}/[PGSQL_BIN_PATH]/g;
$strLine =~ s/$self->{strTestPath}/[TEST_PATH]/g;
$strLine = $self->regExpReplace($strLine, 'BACKREST_NAME_VERSION', '^' . BACKREST_NAME . ' ' . BACKREST_VERSION,
undef, false);
$strLine = $self->regExpReplace($strLine, 'PROCESS-ID', 'process [0-9]+', '[0-9]+$', false);
$strLine = $self->regExpReplace($strLine, 'MODIFICATION-TIME', 'lModificationTime = [0-9]+', '[0-9]+$');
$strLine = $self->regExpReplace($strLine, 'TIMESTAMP', 'timestamp"[ ]{0,1}:[ ]{0,1}[0-9]+','[0-9]+$');
$strLine = $self->regExpReplace($strLine, 'BACKUP-INCR', '[0-9]{8}\-[0-9]{6}F\_[0-9]{8}\-[0-9]{6}I');
$strLine = $self->regExpReplace($strLine, 'BACKUP-DIFF', '[0-9]{8}\-[0-9]{6}F\_[0-9]{8}\-[0-9]{6}D');
$strLine = $self->regExpReplace($strLine, 'BACKUP-FULL', '[0-9]{8}\-[0-9]{6}F');
$strLine = $self->regExpReplace($strLine, 'GROUP', 'strGroup = [^ \n,\[\]]+', '[^ \n,\[\]]+$');
$strLine = $self->regExpReplace($strLine, 'GROUP', 'group"[ ]{0,1}:[ ]{0,1}"[^"]+', '[^"]+$');
$strLine = $self->regExpReplace($strLine, 'USER', 'strUser = [^ \n,\[\]]+', '[^ \n,\[\]]+$');
$strLine = $self->regExpReplace($strLine, 'USER', 'user"[ ]{0,1}:[ ]{0,1}"[^"]+', '[^"]+$');
$strLine = $self->regExpReplace($strLine, 'USER', '^db-user=.+$', '[^=]+$');
$strLine = $self->regExpReplace($strLine, 'PORT', 'db-port=[0-9]+', '[0-9]+$');
my $strTimestampRegExp = "[0-9]{4}-[0-1][0-9]-[0-3][0-9] [0-2][0-9]:[0-6][0-9]:[0-6][0-9]";
$strLine = $self->regExpReplace($strLine, 'VERSION',
"version[\"]{0,1}[ ]{0,1}[\:\=)]{1}[ ]{0,1}[\"]{0,1}" . BACKREST_VERSION, BACKREST_VERSION . '$');
$strLine = $self->regExpReplace($strLine, 'TIMESTAMP',
"timestamp-[a-z-]+[\"]{0,1}[ ]{0,1}[\:\=)]{1}[ ]{0,1}[\"]{0,1}[0-9]+", '[0-9]+$', false);
$strLine = $self->regExpReplace($strLine, 'TIMESTAMP',
"start\" : [0-9]{10}", '[0-9]{10}$', false);
$strLine = $self->regExpReplace($strLine, 'TIMESTAMP',
"stop\" : [0-9]{10}", '[0-9]{10}$', false);
$strLine = $self->regExpReplace($strLine, 'SIZE',
"size\"[ ]{0,1}:[ ]{0,1}[0-9]+", '[0-9]+$', false);
$strLine = $self->regExpReplace($strLine, 'DELTA',
"delta\"[ ]{0,1}:[ ]{0,1}[0-9]+", '[0-9]+$', false);
$strLine = $self->regExpReplace($strLine, 'TIMESTAMP-STR', "est backup timestamp: $strTimestampRegExp",
"${strTimestampRegExp}\$", false);
$strLine = $self->regExpReplace($strLine, 'CHECKSUM', 'checksum=[\"]{0,1}[0-f]{40}', '[0-f]{40}$', false);
return $strLine;
}
1;

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

@@ -31,8 +31,10 @@ use BackRest::Db;
use BackRest::File;
use BackRest::Manifest;
our @EXPORT = qw(BackRestTestCommon_Create BackRestTestCommon_Drop BackRestTestCommon_Setup BackRestTestCommon_ExecuteBegin
BackRestTestCommon_ExecuteEnd BackRestTestCommon_Execute BackRestTestCommon_ExecuteBackRest
use BackRestTest::Common::ExecuteTest;
use BackRestTest::Common::LogTest;
our @EXPORT = qw(BackRestTestCommon_Create BackRestTestCommon_Drop BackRestTestCommon_Setup
BackRestTestCommon_PathCreate BackRestTestCommon_PathMode BackRestTestCommon_PathRemove
BackRestTestCommon_FileCreate BackRestTestCommon_FileRemove BackRestTestCommon_PathCopy BackRestTestCommon_PathMove
BackRestTestCommon_ConfigCreate BackRestTestCommon_ConfigRemap BackRestTestCommon_ConfigRecovery
@@ -45,7 +47,7 @@ our @EXPORT = qw(BackRestTestCommon_Create BackRestTestCommon_Drop BackRestTestC
BackRestTestCommon_DbPortGet BackRestTestCommon_iniLoad BackRestTestCommon_iniSave BackRestTestCommon_DbVersion
BackRestTestCommon_CommandPsqlGet BackRestTestCommon_DropRepo BackRestTestCommon_CreateRepo
BackRestTestCommon_manifestLoad BackRestTestCommon_manifestSave BackRestTestCommon_CommandMainAbsGet
BackRestTestCommon_TestLogAppendFile BackRestTestCommon_CommandRemoteFullGet);
BackRestTestCommon_CommandRemoteFullGet BackRestTestCommon_BasePathGet);
my $strPgSqlBin;
my $strCommonStanza;
@@ -73,25 +75,8 @@ my $bDryRun;
my $bNoCleanup;
my $bLogForce;
# Execution globals
my $bExecuteRemote;
my $strErrorLog;
my $hError;
my $strOutLog;
my $strFullLog;
my $bFullLog = false;
my $hOut;
my $pId;
my $strCommand;
my $oReplaceHash = {};
# Test globals
my $strTestLog;
my $strModule;
my $strModuleTest;
my $iModuleTestRun;
my $bValidWalChecksum;
my $bNormalLog;
use constant PROTOCOL_TIMEOUT_TEST => 30;
push @EXPORT, qw(PROTOCOL_TIMEOUT_TEST);
####################################################################################################################################
# BackRestTestCommon_ClusterStop
@@ -108,8 +93,8 @@ sub BackRestTestCommon_ClusterStop
# If postmaster process is running then stop the cluster
if (-e $strPath . '/postmaster.pid')
{
BackRestTestCommon_Execute(BackRestTestCommon_PgSqlBinPathGet() . "/pg_ctl stop -D ${strPath} -w -s -m " .
($bImmediate ? 'immediate' : 'fast'));
executeTest(BackRestTestCommon_PgSqlBinPathGet() . "/pg_ctl stop -D ${strPath} -w -s -m " .
($bImmediate ? 'immediate' : 'fast'));
}
}
@@ -139,7 +124,8 @@ sub BackRestTestCommon_CreateRepo
# Create the backup directory
if ($bRemote)
{
BackRestTestCommon_Execute('mkdir -m 700 ' . BackRestTestCommon_RepoPathGet(), true);
executeTest('mkdir -m 700 ' . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
else
{
@@ -180,35 +166,35 @@ sub BackRestTestCommon_Run
my $strLog = shift;
my $strModuleParam = shift;
my $strModuleTestParam = shift;
my $bValidWalChecksumParam = shift;
my $bNormalLogParam = shift;
my $oLogTestRef = shift;
# &log(INFO, "module " . (defined($strModule) ? $strModule : ''));
BackRestTestCommon_TestLog();
# Save the previous test log
if (defined($$oLogTestRef))
{
$$oLogTestRef->logWrite(BackRestTestCommon_BasePathGet(), BackRestTestCommon_TestPathGet());
$$oLogTestRef = undef;
}
if (defined($iModuleTestRunOnly) && $iModuleTestRunOnly != $iRun)
# Return if this test should not be run
if ((defined($iModuleTestRunOnly) && $iModuleTestRunOnly != $iRun) || $bDryRun)
{
return false;
}
$strTestLog = 'run ' . sprintf('%03d', $iRun) . ' - ' . $strLog;
# Output information about test to run
&log(INFO, 'run ' . sprintf('%03d', $iRun) . ' - ' . $strLog);
&log(INFO, $strTestLog);
if ($bDryRun)
# If the module is defined then create a LogTest object
if (defined($strModuleParam))
{
return false;
$$oLogTestRef = new BackRestTest::Common::LogTest($strModuleParam, $strModuleTestParam, $iRun, $bLogForce, $strLog,
BackRestTestCommon_CommandMainGet(),
BackRestTestCommon_CommandMainAbsGet(),
BackRestTestCommon_PgSqlBinPathGet(),
BackRestTestCommon_TestPathGet(),
BackRestTestCommon_RepoPathGet());
}
$strFullLog = "${strTestLog}\n" . ('=' x length($strTestLog)) . "\n";
$oReplaceHash = {};
$strModule = $strModuleParam;
$strModuleTest = $strModuleTestParam;
$iModuleTestRun = $iRun;
$bValidWalChecksum = defined($bValidWalChecksumParam) ? $bValidWalChecksumParam : true;
$bNormalLog = defined($bNormalLogParam) ? $bNormalLogParam : true;
return true;
}
@@ -217,421 +203,19 @@ sub BackRestTestCommon_Run
####################################################################################################################################
sub BackRestTestCommon_Cleanup
{
BackRestTestCommon_TestLog();
my $oLogTestRef = shift;
# Save the previous test log
if (defined($$oLogTestRef))
{
$$oLogTestRef->logWrite(BackRestTestCommon_BasePathGet(), BackRestTestCommon_TestPathGet());
$$oLogTestRef = undef;
}
# Return false if there is no cleanup or if this was a test run (this prevents cleanup from being run)
return !$bNoCleanup && !$bDryRun;
}
####################################################################################################################################
# BackRestTestCommon_TestLogAppendFile
####################################################################################################################################
sub BackRestTestCommon_TestLogAppendFile
{
my $strFileName = shift;
my $bRemote = shift;
my $strDescription = shift;
if (defined($strModule))
{
my $hFile;
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g+x " . BackRestTestCommon_RepoPathGet(), $bRemote);
}
open($hFile, '<', $strFileName)
or confess &log(ERROR, "unable to open ${strFileName} for appending to test log");
my $strHeader .= "+ supplemental file: " . BackRestTestCommon_ExecuteRegExpAll($strFileName);
if (defined($strDescription))
{
$strFullLog .= "\n" . BackRestTestCommon_ExecuteRegExpAll($strDescription) . "\n" . ('=' x '132') . "\n";
}
$strFullLog .= "\n${strHeader}\n" . ('-' x length($strHeader)) . "\n";
while (my $strLine = readline($hFile))
{
$strLine = BackRestTestCommon_ExecuteRegExpAll($strLine);
$strFullLog .= $strLine;
}
close($hFile);
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g-x " . BackRestTestCommon_RepoPathGet(), $bRemote);
}
}
}
####################################################################################################################################
# BackRestTestCommon_TestLog
####################################################################################################################################
sub BackRestTestCommon_TestLog
{
if (defined($strModule))
{
my $hFile;
my $strLogFile = BackRestTestCommon_BasePathGet() .
sprintf("/test/log/${strModule}-${strModuleTest}-%03d.log", $iModuleTestRun);
if (!$bLogForce && -e $strLogFile)
{
mkdir(BackRestTestCommon_TestPathGet() . '/log');
my $strTestLogFile = BackRestTestCommon_TestPathGet() .
sprintf("/log/${strModule}-${strModuleTest}-%03d.log", $iModuleTestRun);
open($hFile, '>', $strTestLogFile)
or die "Could not open file '${strTestLogFile}': $!";
print $hFile $strFullLog;
close $hFile;
BackRestTestCommon_Execute("diff ${strLogFile} ${strTestLogFile}");
}
else
{
open($hFile, '>', $strLogFile)
or die "Could not open file '${strLogFile}': $!";
print $hFile $strFullLog;
close $hFile;
}
undef($strModule);
}
}
####################################################################################################################################
# BackRestTestCommon_ExecuteBegin
####################################################################################################################################
sub BackRestTestCommon_ExecuteBegin
{
my $strCommandParam = shift;
my $bRemote = shift;
my $strComment = shift;
# Set defaults
$bExecuteRemote = defined($bRemote) ? $bRemote : false;
if ($bExecuteRemote)
{
$strCommand = "ssh ${strCommonUserBackRest}\@${strCommonHost} '${strCommandParam}'";
}
else
{
$strCommand = $strCommandParam;
}
$strErrorLog = '';
$hError = undef;
$strOutLog = '';
$hOut = undef;
$bFullLog = false;
if (defined($strModule) &&
($strCommandParam =~ /$strCommonCommandMain/ || $strCommandParam =~ /$strCommonCommandRemote/))
{
$strCommandParam = BackRestTestCommon_ExecuteRegExpAll($strCommandParam);
if (defined($strComment))
{
$strComment = BackRestTestCommon_ExecuteRegExpAll($strComment);
$strFullLog .= "\n${strComment}";
}
$strFullLog .= "\n> ${strCommandParam}\n" . ('-' x '132') . "\n";
$bFullLog = true;
}
&log(DEBUG, "executing command: ${strCommand}");
# Execute the command
$hError = gensym;
$pId = open3(undef, $hOut, $hError, $strCommand);
if (!defined($hError))
{
confess 'STDERR handle is undefined';
}
}
####################################################################################################################################
# BackRestTestCommon_ExecuteRegExp
####################################################################################################################################
sub BackRestTestCommon_ExecuteRegExp
{
my $strLine = shift;
my $strType = shift;
my $strExpression = shift;
my $strToken = shift;
my $bIndex = shift;
my @stryReplace = ($strLine =~ /$strExpression/g);
foreach my $strReplace (@stryReplace)
{
my $iIndex;
my $strTypeReplacement;
my $strReplacement;
if (!defined($bIndex) || $bIndex)
{
if (defined($strToken))
{
my @stryReplacement = ($strReplace =~ /$strToken/g);
if (@stryReplacement != 1)
{
confess &log(ASSERT, "'${strToken}' is not a sub-regexp of '${strExpression}' or matches multiple times on '${strReplace}'");
}
$strReplacement = $stryReplacement[0];
}
else
{
$strReplacement = $strReplace;
}
if (defined($$oReplaceHash{$strType}{$strReplacement}))
{
$iIndex = $$oReplaceHash{$strType}{$strReplacement}{index};
}
else
{
if (!defined($$oReplaceHash{$strType}{index}))
{
$$oReplaceHash{$strType}{index} = 1;
}
$iIndex = $$oReplaceHash{$strType}{index}++;
$$oReplaceHash{$strType}{$strReplacement}{index} = $iIndex;
}
}
$strTypeReplacement = "[${strType}" . (defined($iIndex) ? "-${iIndex}" : '') . ']';
if (defined($strToken))
{
$strReplacement = $strReplace;
$strReplacement =~ s/$strToken/$strTypeReplacement/;
}
else
{
$strReplacement = $strTypeReplacement;
}
$strLine =~ s/$strReplace/$strReplacement/g;
}
return $strLine;
}
####################################################################################################################################
# BackRestTestCommon_ExecuteRegExpAll
####################################################################################################################################
sub BackRestTestCommon_ExecuteRegExpAll
{
my $strLine = shift;
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();
if (defined($strTestPath))
{
$strLine =~ s/$strTestPath/[TEST_PATH]/g;
}
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'BACKREST_NAME_VERSION', '^' . BACKREST_NAME . ' ' . BACKREST_VERSION,
undef, false);
$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', 'strGroup = [^ \n,\[\]]+', '[^ \n,\[\]]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'GROUP', 'group"[ ]{0,1}:[ ]{0,1}"[^"]+', '[^"]+$');
$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=.+$', '[^=]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'PORT', 'db-port=[0-9]+', '[0-9]+$');
my $strTimestampRegExp = "[0-9]{4}-[0-1][0-9]-[0-3][0-9] [0-2][0-9]:[0-6][0-9]:[0-6][0-9]";
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'VERSION',
"version[\"]{0,1}[ ]{0,1}[\:\=)]{1}[ ]{0,1}[\"]{0,1}" . BACKREST_VERSION, BACKREST_VERSION . '$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'TIMESTAMP',
"timestamp-[a-z-]+[\"]{0,1}[ ]{0,1}[\:\=)]{1}[ ]{0,1}[\"]{0,1}[0-9]+", '[0-9]+$', false);
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'TIMESTAMP',
"start\" : [0-9]{10}", '[0-9]{10}$', false);
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'TIMESTAMP',
"stop\" : [0-9]{10}", '[0-9]{10}$', false);
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'SIZE',
"size\"[ ]{0,1}:[ ]{0,1}[0-9]+", '[0-9]+$', false);
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'DELTA',
"delta\"[ ]{0,1}:[ ]{0,1}[0-9]+", '[0-9]+$', false);
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'TIMESTAMP-STR', "est backup timestamp: $strTimestampRegExp",
"${strTimestampRegExp}\$", false);
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'CHECKSUM', 'checksum=[\"]{0,1}[0-f]{40}', '[0-f]{40}$', false);
if (!$bValidWalChecksum)
{
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'CHECKSUM', '[0-F]{24}-[0-f]{40}', '[0-f]{40}$', false);
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'DB-SYSTEM-ID',
"db-system-id[\"]{0,1}[ ]{0,1}[\:\=)]{1}[ ]{0,1}[0-9]+", '[0-9]+$');
$strLine = BackRestTestCommon_ExecuteRegExp($strLine, 'BACKUP-INFO',
"backup-info-[a-z-]+[\"]{0,1}[ ]{0,1}[\:\=)]{1}[ ]{0,1}[0-9]+", '[0-9]+$', false);
}
return $strLine;
}
####################################################################################################################################
# BackRestTestCommon_ExecuteEnd
####################################################################################################################################
sub BackRestTestCommon_ExecuteEnd
{
my $strTest = shift;
my $bSuppressError = shift;
my $bShowOutput = shift;
my $iExpectedExitStatus = shift;
# Set defaults
$bSuppressError = defined($bSuppressError) ? $bSuppressError : false;
$bShowOutput = defined($bShowOutput) ? $bShowOutput : false;
# Create select objects
my $oErrorSelect = IO::Select->new();
$oErrorSelect->add($hError);
my $oOutSelect = IO::Select->new();
$oOutSelect->add($hOut);
# While the process is running drain the stdout and stderr streams
while(waitpid($pId, WNOHANG) == 0)
{
# Drain the stderr stream
if ($oErrorSelect->can_read(.1))
{
while (my $strLine = readline($hError))
{
$strErrorLog .= $strLine;
}
}
# Drain the stdout stream
if ($oOutSelect->can_read(.1))
{
while (my $strLine = readline($hOut))
{
$strOutLog .= $strLine;
if (defined($strTest) && testCheck($strLine, $strTest))
{
&log(DEBUG, "Found test ${strTest}");
return true;
}
if ($bFullLog)
{
if ($bNormalLog)
{
$strLine =~ s/^[0-9]{4}-[0-1][0-9]-[0-3][0-9] [0-2][0-9]:[0-6][0-9]:[0-6][0-9]\.[0-9]{3} T[0-9]{2} //;
}
if ($strLine !~ /^ TEST/ || !$bNormalLog)
{
if ($bNormalLog)
{
$strLine =~ s/^ //;
$strLine =~ s/^ //;
$strLine =~ s/\r$//;
}
$strLine = BackRestTestCommon_ExecuteRegExpAll($strLine);
$strFullLog .= $strLine;
}
}
}
}
}
# Check the exit status and output an error if needed
my $iExitStatus = ${^CHILD_ERROR_NATIVE} >> 8;
if (defined($iExpectedExitStatus) && ($iExitStatus == $iExpectedExitStatus || $bExecuteRemote && $iExitStatus != 0))
{
return $iExitStatus;
}
if ($iExitStatus != 0 || (defined($iExpectedExitStatus) && $iExitStatus != $iExpectedExitStatus))
{
if ($bSuppressError)
{
&log(DEBUG, "suppressed error was ${iExitStatus}");
$strErrorLog = '';
}
else
{
confess &log(ERROR, "command '${strCommand}' returned " . $iExitStatus .
(defined($iExpectedExitStatus) ? ", but ${iExpectedExitStatus} was expected" : '') . "\n" .
($strOutLog ne '' ? "STDOUT (last 10,000 characters):\n" . substr($strOutLog, length($strOutLog) - 10000) : '') .
($strErrorLog ne '' ? "STDERR:\n${strErrorLog}" : ''));
}
}
if ($strErrorLog ne '')
{
confess &log(ERROR, "output found on STDERR:\n${strErrorLog}");
}
if ($bShowOutput)
{
print "output:\n${strOutLog}\n";
}
if (defined($strTest))
{
confess &log(ASSERT, "test point ${strTest} was not found");
}
$hError = undef;
$hOut = undef;
return $iExitStatus;
}
####################################################################################################################################
# BackRestTestCommon_Execute
####################################################################################################################################
sub BackRestTestCommon_Execute
{
my $strCommand = shift;
my $bRemote = shift;
my $bSuppressError = shift;
my $bShowOutput = shift;
my $iExpectedExitStatus = shift;
my $strComment = shift;
BackRestTestCommon_ExecuteBegin($strCommand, $bRemote, $strComment);
return BackRestTestCommon_ExecuteEnd(undef, $bSuppressError, $bShowOutput, $iExpectedExitStatus);
}
####################################################################################################################################
# BackRestTestCommon_PathCreate
#
@@ -683,7 +267,8 @@ sub BackRestTestCommon_PathRemove
my $bRemote = shift;
my $bSuppressError = shift;
BackRestTestCommon_Execute('rm -rf ' . $strPath, $bRemote, $bSuppressError);
executeTest('rm -rf ' . $strPath,
{bRemote => $bRemote, bSuppressError => $bSuppressError});
# remove_tree($strPath, {result => \my $oError});
#
@@ -712,7 +297,8 @@ sub BackRestTestCommon_PathCopy
my $bRemote = shift;
my $bSuppressError = shift;
BackRestTestCommon_Execute("cp -RpP ${strSourcePath} ${strDestinationPath}", $bRemote, $bSuppressError);
executeTest("cp -RpP ${strSourcePath} ${strDestinationPath}",
{bRemote => $bRemote, bSuppressError => $bSuppressError});
}
####################################################################################################################################
@@ -822,7 +408,7 @@ sub BackRestTestCommon_Setup
$bCommandMainSet = defined($strExe) ? true : false;
$strCommonCommandRemote = defined($strExe) ? $strExe : "${strCommonBasePath}/bin/pg_backrest";
$strCommonCommandRemoteFull = "${strCommonCommandRemote} --stanza=${strCommonStanza}" .
" --repo-remote-path=${strCommonRepoPath} --no-config remote";
" --repo-remote-path=${strCommonRepoPath} --no-config --command=test remote";
$strCommonCommandPsql = "${strPgSqlBin}/psql -X %option% -h ${strCommonDbPath}";
$iCommonDbPort = 6543;
@@ -831,7 +417,7 @@ sub BackRestTestCommon_Setup
$bNoCleanup = $bNoCleanupParam;
$bLogForce = $bLogForceParam;
BackRestTestCommon_Execute($strPgSqlBin . '/postgres --version');
my $strOutLog = executeTest($strPgSqlBin . '/postgres --version');
# Get the Postgres version
my $strVersionRegExp = '(devel|((alpha|beta)[0-9]+))$';
@@ -873,14 +459,17 @@ sub BackRestTestCommon_manifestLoad
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g+x " . BackRestTestCommon_RepoPathGet(), $bRemote);
executeTest("chmod g+x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
my $oManifest = new BackRest::Manifest($strFileName);
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g-x " . BackRestTestCommon_RepoPathGet(), $bRemote);
executeTest("chmod g-x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
return $oManifest;
@@ -900,16 +489,20 @@ sub BackRestTestCommon_manifestSave
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g+x " . BackRestTestCommon_RepoPathGet(), $bRemote);
BackRestTestCommon_Execute("chmod g+w " . $strFileName, $bRemote);
executeTest("chmod g+x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
executeTest("chmod g+w " . $strFileName,
{bRemote => true});
}
$oManifest->save();
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g-w " . $strFileName, $bRemote);
BackRestTestCommon_Execute("chmod g-x " . BackRestTestCommon_RepoPathGet(), $bRemote);
executeTest("chmod g-w " . $strFileName,
{bRemote => true});
executeTest("chmod g-x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
}
@@ -927,14 +520,16 @@ sub BackRestTestCommon_iniLoad
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g+x " . BackRestTestCommon_RepoPathGet(), $bRemote);
executeTest("chmod g+x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
iniLoad($strFileName, $oIniRef);
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g-x " . BackRestTestCommon_RepoPathGet(), $bRemote);
executeTest("chmod g-x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
}
@@ -953,8 +548,10 @@ sub BackRestTestCommon_iniSave
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g+x " . BackRestTestCommon_RepoPathGet(), $bRemote);
BackRestTestCommon_Execute("chmod g+w " . $strFileName, $bRemote);
executeTest("chmod g+x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
executeTest("chmod g+w " . $strFileName,
{bRemote => true});
}
# Calculate a new checksum if requested
@@ -973,8 +570,10 @@ sub BackRestTestCommon_iniSave
if ($bRemote)
{
BackRestTestCommon_Execute("chmod g-w " . $strFileName, $bRemote);
BackRestTestCommon_Execute("chmod g-x " . BackRestTestCommon_RepoPathGet(), $bRemote);
executeTest("chmod g-w " . $strFileName,
{bRemote => true});
executeTest("chmod g-x " . BackRestTestCommon_RepoPathGet(),
{bRemote => true});
}
}
@@ -1001,7 +600,8 @@ sub BackRestTestCommon_ConfigRemap
if ($bRemote)
{
BackRestTestCommon_Execute("mv " . BackRestTestCommon_RepoPathGet() . "/pg_backrest.conf ${strRemoteConfigFile}", true);
executeTest("mv " . BackRestTestCommon_RepoPathGet() . "/pg_backrest.conf ${strRemoteConfigFile}",
{bRemote => true});
iniLoad($strRemoteConfigFile, \%oRemoteConfig, true);
}
@@ -1038,7 +638,8 @@ sub BackRestTestCommon_ConfigRemap
if ($bRemote)
{
iniSave($strRemoteConfigFile, \%oRemoteConfig, true);
BackRestTestCommon_Execute("mv ${strRemoteConfigFile} " . BackRestTestCommon_RepoPathGet() . '/pg_backrest.conf', true);
executeTest("mv ${strRemoteConfigFile} " . BackRestTestCommon_RepoPathGet() . '/pg_backrest.conf',
{bRemote => true});
}
}
@@ -1064,7 +665,8 @@ sub BackRestTestCommon_ConfigRecovery
if ($bRemote)
{
BackRestTestCommon_Execute("mv " . BackRestTestCommon_RepoPathGet() . "/pg_backrest.conf ${strRemoteConfigFile}", true);
executeTest("mv " . BackRestTestCommon_RepoPathGet() . "/pg_backrest.conf ${strRemoteConfigFile}",
{bRemote => true});
iniLoad($strRemoteConfigFile, \%oRemoteConfig, true);
}
@@ -1083,7 +685,8 @@ sub BackRestTestCommon_ConfigRecovery
if ($bRemote)
{
iniSave($strRemoteConfigFile, \%oRemoteConfig, true);
BackRestTestCommon_Execute("mv ${strRemoteConfigFile} " . BackRestTestCommon_RepoPathGet() . '/pg_backrest.conf', true);
executeTest("mv ${strRemoteConfigFile} " . BackRestTestCommon_RepoPathGet() . '/pg_backrest.conf',
{bRemote => true});
}
}
@@ -1129,10 +732,12 @@ sub BackRestTestCommon_ConfigCreate
if ($strLocal eq BACKUP)
{
$oParamHash{'global:general'}{'repo-path'} = $strCommonRepoPath;
$oParamHash{'global:general'}{'config-remote'} = "${strCommonDbPath}/pg_backrest.conf";
}
elsif ($strLocal eq DB)
{
$oParamHash{'global:general'}{'repo-path'} = $strCommonLocalPath;
$oParamHash{'global:general'}{'config-remote'} = "${strCommonRepoPath}/pg_backrest.conf";
if (defined($strRemote))
{
@@ -1207,7 +812,8 @@ sub BackRestTestCommon_ConfigCreate
}
else
{
BackRestTestCommon_Execute("mv ${strFile} " . BackRestTestCommon_RepoPathGet() . '/pg_backrest.conf', true);
executeTest("mv ${strFile} " . BackRestTestCommon_RepoPathGet() . '/pg_backrest.conf',
{bRemote => true});
}
}

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

@@ -44,7 +44,7 @@ sub BackRestTestCompare_BuildDb
for (my $iTableSizeIdx = 0; $iTableSizeIdx < $iTableSize; $iTableSizeIdx++)
{
BackRestTestCommon_Execute("cat ${strSourceFile} >> ${strTableFile}");
executeTest("cat ${strSourceFile} >> ${strTableFile}");
}
}
}
@@ -75,7 +75,7 @@ sub BackRestTestCompare_Test
BackRestTestCommon_PathCreate(BackRestTestCommon_DbCommonPathGet() . '/pg_tblspc');
BackRestTestCompare_BuildDb(48, 10);
BackRestTestCommon_Execute('sync');
executeTest('sync');
for (my $bRemote = true; $bRemote <= true; $bRemote++)
{
@@ -109,8 +109,8 @@ sub BackRestTestCompare_Test
}
my $fTimeBegin = gettimeofday();
BackRestTestCommon_Execute($strCommand, $bRemote);
BackRestTestCommon_Execute('sync');
executeTest($strCommand, $bRemote);
executeTest('sync');
my $fTimeEnd = gettimeofday();
&log(INFO, " time = " . (int(($fTimeEnd - $fTimeBegin) * 100) / 100));

42
test/lib/BackRestTest/ExpireCommonTest.pm
View File

@@ -22,6 +22,7 @@ use BackRest::Config::Config;
use BackRest::File;
use BackRest::Manifest;
use BackRestTest::Common::ExecuteTest;
use BackRestTest::CommonTest;
####################################################################################################################################
@@ -50,12 +51,14 @@ sub new
# Assign function parameters, defaults, and log debug info
(
my $strOperation,
$self->{oFile}
$self->{oFile},
$self->{oLogTest}
) =
logDebugParam
(
OP_EXPIRE_COMMON_TEST_NEW, \@_,
{name => 'oFile'}
{name => 'oFile', trace => true},
{name => 'oLogTest', required => false, trace => true}
);
# Return from function and log return values if any
@@ -373,8 +376,12 @@ sub process
my $oStanza = $self->{oStanzaHash}{$strStanza};
BackRestTestCommon_TestLogAppendFile(BackRestTestCommon_RepoPathGet() .
"/backup/${strStanza}/backup.info", false, $$oStanza{strBackupDescription});
if (defined($self->{oLogTest}))
{
$self->{oLogTest}->supplementalAdd(BackRestTestCommon_RepoPathGet() .
"/backup/${strStanza}/backup.info", undef, $$oStanza{strBackupDescription});
}
undef($$oStanza{strBackupDescription});
my $strCommand = BackRestTestCommon_CommandMainGet() .
@@ -400,28 +407,13 @@ sub process
$strCommand .= ' expire';
BackRestTestCommon_Execute($strCommand, undef, undef, undef, undef, $strDescription);
executeTest($strCommand, {strComment => $strDescription, oLogTest => $self->{oLogTest}});
# # Check that the correct backups were expired
# my @stryBackupActual = $oFile->list(PATH_BACKUP_CLUSTER);
#
# if (join(",", @stryBackupActual) ne join(",", @{$stryBackupExpectedRef}))
# {
# confess "expected backup list:\n " . join("\n ", @{$stryBackupExpectedRef}) .
# "\n\nbut actual was:\n " . join("\n ", @stryBackupActual) . "\n";
# }
#
# # Check that the correct archive logs were expired
# my @stryArchiveActual = $oFile->list(PATH_BACKUP_ARCHIVE, BackRestTestCommon_DbVersion() . '-1/0000000100000000');
#
# if (join(",", @stryArchiveActual) ne join(",", @{$stryArchiveExpectedRef}))
# {
# confess "expected archive list:\n " . join("\n ", @{$stryArchiveExpectedRef}) .
# "\n\nbut actual was:\n " . join("\n ", @stryArchiveActual) . "\n";
# }
BackRestTestCommon_TestLogAppendFile(BackRestTestCommon_RepoPathGet() .
"/backup/${strStanza}/backup.info", false);
if (defined($self->{oLogTest}))
{
$self->{oLogTest}->supplementalAdd(BackRestTestCommon_RepoPathGet() .
"/backup/${strStanza}/backup.info");
}
# Return from function and log return values if any
return logDebugReturn

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

@@ -11,7 +11,7 @@ use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
use Cwd qw(abs_path);
use Cwd qw(abs_path cwd);
use Exporter qw(import);
use Fcntl qw(:mode);
use File::Basename;
@@ -27,6 +27,7 @@ use BackRest::File;
use BackRest::Protocol::Common;
use BackRest::Protocol::RemoteMaster;
use BackRestTest::Common::ExecuteTest;
use BackRestTest::CommonTest;
my $strTestPath;
@@ -97,21 +98,26 @@ sub BackRestTestFile_Test
#-------------------------------------------------------------------------------------------------------------------------------
# Create remotes
#-------------------------------------------------------------------------------------------------------------------------------
executeTest('rm -rf ' . cwd() . '/log_remote');
mkdir(cwd() . '/log_remote', oct('0770')) or confess 'Unable to create test log directory';
my $oRemote = new BackRest::Protocol::RemoteMaster
(
BackRestTestCommon_CommandRemoteFullGet(), # Command
BackRestTestCommon_CommandRemoteFullGet() . ' --repo-path=' . cwd() . '/log_remote', # Remote command
OPTION_DEFAULT_BUFFER_SIZE, # Buffer size
OPTION_DEFAULT_COMPRESS_LEVEL, # Compress level
OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK, # Compress network level
$strHost, # Host
$strUserBackRest # User
$strUserBackRest, # User
PROTOCOL_TIMEOUT_TEST # Protocol timeout
);
my $oLocal = new BackRest::Protocol::Common
(
OPTION_DEFAULT_BUFFER_SIZE, # Buffer size
OPTION_DEFAULT_COMPRESS_LEVEL, # Compress level
OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK # Compress network level
OPTION_DEFAULT_BUFFER_SIZE, # Buffer size
OPTION_DEFAULT_COMPRESS_LEVEL, # Compress level
OPTION_DEFAULT_COMPRESS_LEVEL_NETWORK, # Compress network level
PROTOCOL_TIMEOUT_TEST # Protocol timeout
);
#-------------------------------------------------------------------------------------------------------------------------------
@@ -1130,15 +1136,13 @@ sub BackRestTestFile_Test
if ($iLarge < 3)
{
BackRestTestCommon_Execute('cp ' . BackRestTestCommon_DataPathGet() .
"/test.archive${iLarge}.bin ${strSourceFile}");
executeTest('cp ' . BackRestTestCommon_DataPathGet() . "/test.archive${iLarge}.bin ${strSourceFile}");
}
else
{
for (my $iTableSizeIdx = 0; $iTableSizeIdx < 100; $iTableSizeIdx++)
{
BackRestTestCommon_Execute('cat ' . BackRestTestCommon_DataPathGet() .
"/test.table.bin >> ${strSourceFile}");
executeTest('cat ' . BackRestTestCommon_DataPathGet() . "/test.table.bin >> ${strSourceFile}");
}
}
}
@@ -1185,6 +1189,8 @@ sub BackRestTestFile_Test
# Run file copy in an eval block because some errors are expected
my $bReturn;
#
# exit;
eval
{
@@ -1210,7 +1216,7 @@ sub BackRestTestFile_Test
next;
}
confess $oMessage->message();
confess $oMessage->message() . "\n" . $oMessage->trace();
}
else
{

3
test/lib/BackRestTest/HelpTest.pm
View File

@@ -18,6 +18,7 @@ use lib dirname($0) . '/../lib';
use BackRest::Common::Log;
use BackRest::Config::Config;
use BackRestTest::Common::ExecuteTest;
use BackRestTest::CommonTest;
####################################################################################################################################
@@ -27,7 +28,7 @@ sub BackRestTestHelp_ExecuteHelp
{
my $strCommand = shift;
BackRestTestCommon_Execute(BackRestTestCommon_CommandMainAbsGet() . ' --no-config ' . $strCommand);
executeTest(BackRestTestCommon_CommandMainAbsGet() . ' --no-config ' . $strCommand);
}
####################################################################################################################################

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

@@ -3,16 +3,18 @@ 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: 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: archive-get start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Main::safeExit(): iExitCode = 130
DEBUG: Exit::exitSafe(): iExitCode = 130, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@@ -29,11 +31,38 @@ db-version="9.3"
[db:history]
1={"db-id":1234567890123456789,"db-version":"9.3"}
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --repo-path=[TEST_PATH]/backrest
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
ERROR: [137]: stop file exists for all stanzas
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/backrest
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-get start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -44,5 +73,6 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 1, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,16 +3,18 @@ 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: 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: archive-get start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Main::safeExit(): iExitCode = 130
DEBUG: Exit::exitSafe(): iExitCode = 130, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@@ -31,9 +33,10 @@ 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: 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: archive-get start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -44,14 +47,16 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000002 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -62,14 +67,16 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000002-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000003 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -80,5 +87,6 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000003-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,16 +3,18 @@ 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: 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: archive-get start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Main::safeExit(): iExitCode = 130
DEBUG: Exit::exitSafe(): iExitCode = 130, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@@ -29,11 +31,38 @@ db-version="9.3"
[db:history]
1={"db-id":1234567890123456789,"db-version":"9.3"}
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --repo-path=[TEST_PATH]/backrest
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
ERROR: [137]: stop file exists for all stanzas
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/backrest
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-get start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -44,5 +73,6 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 1, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,16 +3,18 @@ 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: 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: archive-get start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Main::safeExit(): iExitCode = 130
DEBUG: Exit::exitSafe(): iExitCode = 130, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@@ -31,9 +33,10 @@ 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: 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: archive-get start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -44,14 +47,16 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000002 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -62,14 +67,16 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000002-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000003 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -80,5 +87,6 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000003-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,17 +3,19 @@ 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: 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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 130
DEBUG: Exit::exitSafe(): iExitCode = 130, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@@ -30,13 +32,40 @@ db-version="9.3"
[db:history]
1={"db-id":1234567890123456789,"db-version":"9.3"}
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --repo-path=[TEST_PATH]/local
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
ERROR: [137]: stop file exists for all stanzas
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/local
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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>
@@ -44,5 +73,6 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 1, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,17 +3,19 @@ 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: 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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 130
DEBUG: Exit::exitSafe(): iExitCode = 130, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@@ -32,11 +34,12 @@ 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: 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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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>
@@ -45,16 +48,18 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000002 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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>
@@ -63,16 +68,18 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000002-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000003 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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>
@@ -81,5 +88,6 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000003-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,17 +3,19 @@ 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: 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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 130
DEBUG: Exit::exitSafe(): iExitCode = 130, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@@ -30,13 +32,40 @@ db-version="9.3"
[db:history]
1={"db-id":1234567890123456789,"db-version":"9.3"}
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --repo-path=[TEST_PATH]/local
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
ERROR: [137]: stop file exists for all stanzas
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/local
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000090000000900000009 [TEST_PATH]/db/common/pg_xlog/RECOVERYXLOG
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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>
@@ -44,5 +73,6 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 1, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,17 +3,19 @@ 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: 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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 130
DEBUG: Exit::exitSafe(): iExitCode = 130, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------
@@ -32,11 +34,12 @@ 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: 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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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>
@@ -45,16 +48,18 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000001-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000002 [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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>
@@ -63,16 +68,18 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000002-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db archive-get 000000010000000100000003 [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
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: archive-get start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-get --config=[TEST_PATH]/backrest/pg_backrest.conf --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>
@@ -81,5 +88,6 @@ DEBUG: Archive->walFileName=>: strWalFileName = 000000010000000100000003-1c7
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-get stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,10 +3,11 @@ 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: 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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -28,15 +29,17 @@ DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath =
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -46,15 +49,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -64,15 +69,44 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
ERROR: [137]: stop file exists for stanza db
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start db (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -92,15 +126,17 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -118,15 +154,17 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -143,15 +181,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -168,15 +208,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -193,15 +235,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -218,15 +262,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -236,15 +282,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -254,15 +302,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -282,15 +332,17 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -308,15 +360,17 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -333,15 +387,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -358,15 +414,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -383,15 +441,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -408,15 +468,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -426,15 +488,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -444,15 +508,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -472,15 +538,17 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -498,8 +566,9 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

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

@@ -3,10 +3,11 @@ run 002 - rmt 0, cmp 0, arc_async 1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -14,6 +15,9 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -48,19 +52,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -76,19 +86,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -104,19 +119,76 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --force stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: stop start: --force --repo-path=[TEST_PATH]/backrest
INFO: sent term signal to process [PROCESS-ID]
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push --test --test-delay=1 --test-point=archive-push-async-start=y [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 --test --test-delay=1 --test-point=archive-push-async-start=y
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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Exit::exitSafe(): iExitCode = -1, strSignal = TERM
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
ERROR: [138]: process terminated on a TERM signal
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
ERROR: [137]: stop file exists for all stanzas
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/backrest
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -150,19 +222,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -186,19 +264,24 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/backrest/a
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -229,19 +312,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -272,19 +361,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000004, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000004.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -315,19 +410,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -358,19 +459,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -386,19 +493,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -414,19 +526,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -460,19 +577,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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-4518a0fdf41d796760b384a358270d4682589820, 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -496,19 +619,24 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/backrest/a
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -539,19 +667,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000007, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000007.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -582,19 +716,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000008, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000008.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -625,19 +765,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -668,19 +814,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -696,19 +848,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -724,19 +881,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -770,19 +932,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -806,8 +974,9 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/backrest/a
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

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

@@ -3,10 +3,11 @@ 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: 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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -28,15 +29,17 @@ DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath =
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -46,15 +49,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -64,15 +69,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -92,15 +99,17 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -118,15 +127,17 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -143,15 +154,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -168,15 +181,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -193,15 +208,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -218,15 +235,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -236,15 +255,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -254,15 +275,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -282,15 +305,17 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -308,15 +333,17 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -333,15 +360,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -358,15 +387,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -383,15 +414,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -408,15 +441,17 @@ 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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -426,15 +461,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -444,15 +481,17 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -472,15 +511,17 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -498,8 +539,9 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

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

@@ -3,10 +3,11 @@ run 004 - rmt 0, cmp 1, arc_async 1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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
@@ -14,6 +15,9 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -48,19 +52,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -76,19 +86,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -104,19 +119,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -150,19 +170,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -186,19 +212,24 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/backrest/a
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -229,19 +260,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -272,19 +309,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000004, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000004.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -315,19 +358,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -358,19 +407,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -386,19 +441,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -414,19 +474,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -460,19 +525,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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-4518a0fdf41d796760b384a358270d4682589820, 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -496,19 +567,24 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/backrest/a
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -539,19 +615,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000007, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000007.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -582,19 +664,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000008, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000008.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -625,19 +713,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -668,19 +762,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -696,19 +796,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -724,19 +829,24 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -770,19 +880,25 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, 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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/backrest>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -806,8 +922,9 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/backrest/a
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

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

@@ -3,60 +3,96 @@ 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: 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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --repo-path=[TEST_PATH]/local --stanza=db
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
ERROR: [137]: stop file exists for stanza db
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start db (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/local --stanza=db
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -66,17 +102,19 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -84,113 +122,127 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -200,17 +252,19 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -218,113 +272,127 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -334,17 +402,19 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -352,8 +422,9 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

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

@@ -3,10 +3,11 @@ run 006 - rmt 1, cmp 0, arc_async 1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -14,12 +15,15 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -36,25 +40,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -63,25 +73,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -90,25 +105,82 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --force stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: stop start: --force --repo-path=[TEST_PATH]/local
INFO: sent term signal to process [PROCESS-ID]
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push --test --test-delay=1 --test-point=archive-push-async-start=y [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 --test --test-delay=1 --test-point=archive-push-async-start=y
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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Exit::exitSafe(): iExitCode = -1, strSignal = TERM
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
ERROR: [138]: process terminated on a TERM signal
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
ERROR: [137]: stop file exists for all stanzas
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/local
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -129,25 +201,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820
@@ -158,25 +236,30 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/local/arch
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -193,25 +276,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -228,25 +317,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000004, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000004.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -263,25 +358,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -298,25 +399,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -325,25 +432,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -352,25 +464,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -391,25 +508,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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-4518a0fdf41d796760b384a358270d4682589820, 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820
@@ -420,25 +543,30 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/local/arch
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -455,25 +583,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000007, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000007.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -490,25 +624,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000008, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000008.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -525,25 +665,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -560,25 +706,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -587,25 +739,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -614,25 +771,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -653,25 +815,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820
@@ -682,8 +850,9 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/local/arch
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

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

@@ -3,60 +3,67 @@ 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: 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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -66,17 +73,19 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -84,113 +93,127 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -200,17 +223,19 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -218,113 +243,127 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -334,17 +373,19 @@ DEBUG: File->hashSize=>: iSize = 16777216, strHash = 1c7e00fd09b9dd11fc29665
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: Archive->pushCheck=>: strArchiveId = 9.3-1, strChecksum = 1c7e00fd09b9dd11fc2966590b3e3274645dd031
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/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: archive-push start: --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -352,8 +393,9 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/db/common/
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: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

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

@@ -3,10 +3,11 @@ run 008 - rmt 1, cmp 1, arc_async 1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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
@@ -14,12 +15,15 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -36,25 +40,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -63,25 +73,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -90,25 +105,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -129,25 +149,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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->move(): bDestinationPathCreate = true, strDestinationFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820
@@ -158,25 +184,30 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/local/arch
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -193,25 +224,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000003
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000003-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -228,25 +265,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000004
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000004, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000004.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000004-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -263,25 +306,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -298,25 +347,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -325,25 +380,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -352,25 +412,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -391,25 +456,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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-4518a0fdf41d796760b384a358270d4682589820, 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820
@@ -420,25 +491,30 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/local/arch
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -455,25 +531,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000007
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000007, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000007.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000007-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -490,25 +572,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000008
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000008, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000008.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000008-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -525,25 +613,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -560,25 +654,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -587,25 +687,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -614,25 +719,30 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, 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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -653,25 +763,31 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: archive-push start: --archive-async --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: archive-push start: --archive-async --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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 asynchronously
DEBUG: Archive->pushProcess(): bAsync = true, strSourceFile = [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/local, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = <[TEST_PATH]/local>
DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, bDestinationPathCreate = true, bIgnoreMissingSource = <false>, bSourceCompressed = false, lModificationTime = [undef], strDestinationFile = 000000010000000100000009, strDestinationPathType = backup:archive:out, 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]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp, strSourcePathType = absolute
DEBUG: Archive->pushProcess: no fork on archive local for TESTING
DEBUG: Archive->pushProcess: start async archive-push
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820
@@ -682,8 +798,9 @@ DEBUG: File->hash(): bCompressed = [undef], strFile = [TEST_PATH]/local/arch
DEBUG: File->hashSize(): bCompressed = <false>, strFile = [TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, strHashType = <sha1>, strPathType = db:absolute
DEBUG: File->hashSize=>: iSize = 16777216, strHash = 4518a0fdf41d796760b384a358270d4682589820
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: Main::safeExit(): iExitCode = 120
DEBUG: Exit::exitSafe(): iExitCode = 120, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/backrest/archive/db/archive.info
-----------------------------------------------------------------

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

@@ -3,7 +3,7 @@ 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: 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: archive-push start: --archive-async --archive-max-mb=24 --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -14,6 +14,9 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -48,12 +51,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -61,6 +66,9 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -76,12 +84,13 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -89,6 +98,9 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -105,19 +117,21 @@ DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 59479699905018
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 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
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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
INFO: archive-push start: --archive-async --archive-max-mb=24 --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -125,6 +139,9 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -189,12 +206,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -202,6 +221,9 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -232,5 +254,7 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,7 +3,7 @@ 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: 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: archive-push start: --archive-async --archive-max-mb=24 --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -14,6 +14,9 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -48,12 +51,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -61,6 +66,9 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -76,12 +84,13 @@ DEBUG: ArchiveInfo->new(): bRequired = <false>, strArchiveClusterPath = [TES
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -89,6 +98,9 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -105,19 +117,21 @@ DEBUG: ArchiveInfo->check(): strDbVersion = 9.3, ullDbSysId = 59479699905018
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 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
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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
INFO: archive-push start: --archive-async --archive-max-mb=24 --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -125,6 +139,9 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -189,12 +206,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -202,6 +221,9 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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
@@ -232,5 +254,7 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/ba
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,7 +3,7 @@ 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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -14,12 +14,15 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -36,12 +39,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -49,12 +54,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -63,12 +71,13 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -76,12 +85,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 2, size = 32MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -91,19 +103,21 @@ DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFil
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 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
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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
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 --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -111,12 +125,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -145,12 +162,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -158,12 +177,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -180,5 +202,7 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,7 +3,7 @@ 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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -14,12 +14,15 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -36,12 +39,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=bogus --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -49,19 +54,23 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Main::safeExit(): iExitCode = 124
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = bogus, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
ERROR: [124]: remote process terminated : ssh: Could not resolve hostname bogus: Name or service not known
DEBUG: Exit::exitSafe(): iExitCode = 124, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=bogus --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -69,27 +78,32 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = bogus, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
ERROR: [124]: remote process terminated : ssh: Could not resolve hostname bogus: Name or service not known
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
DEBUG: Exit::exitSafe(): iExitCode = 124, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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
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 --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -97,12 +111,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -131,12 +148,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -144,12 +163,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = false, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -166,5 +188,7 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,7 +3,7 @@ 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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -14,12 +14,15 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -36,12 +39,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -49,12 +54,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -63,12 +71,13 @@ DEBUG: Archive->walInfo=>: strDbVersion = 9.3, ullDbSysId = 5947969990501855
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: Main::safeExit(): iExitCode = 119
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -76,12 +85,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 2, size = 32MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -91,19 +103,21 @@ DEBUG: Archive->pushCheck(): oFile = [object], strDbVersion = 9.3, strWalFil
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 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
DEBUG: Exit::exitSafe(): iExitCode = 119, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -111,12 +125,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -145,12 +162,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -158,12 +177,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -180,5 +202,7 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -3,7 +3,7 @@ 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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -14,12 +14,15 @@ 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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -36,12 +39,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=bogus --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -49,19 +54,23 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Main::safeExit(): iExitCode = 124
DEBUG: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = bogus, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
ERROR: [124]: remote process terminated : ssh: Could not resolve hostname bogus: Name or service not known
DEBUG: Exit::exitSafe(): iExitCode = 124, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=bogus --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -69,27 +78,32 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote, strHost = bogus, strUser = [USER-1]
DEBUG: Protocol::CommonMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@bogus '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --repo-remote-path=[TEST_PATH]/backrest --stanza=db remote', strName = remote
ERROR: [124]: remote process terminated : ssh: Could not resolve hostname bogus: Name or service not known
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
DEBUG: Exit::exitSafe(): iExitCode = 124, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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
INFO: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -97,12 +111,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 3, size = 48MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000002-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -131,12 +148,14 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [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: 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: archive-push start: --archive-async --archive-max-mb=24 --backup-host=127.0.0.1 --backup-user=backrest --cmd-remote=[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --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
@@ -144,12 +163,15 @@ DEBUG: File->copy(): bAppendChecksum = true, bDestinationCompress = false, b
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: Common:::Lock::lockAquire(): bFailOnNoLock = false, bRemote = <false>, iProcessIdx = [undef], strLockType = archive-push
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/local
DEBUG: Common:::Lock::lockAquire=>: bResult = true
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: Protocol::RemoteMaster->new(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = [BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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(): iBufferMax = 4194304, iCompressLevel = 6, iCompressLevelNetwork = 3, iProtocolTimeout = 1830, strCommand = ssh -o Compression=no -o PasswordAuthentication=no backrest@127.0.0.1 '[BACKREST_BIN] --command=archive-push --config=[TEST_PATH]/backrest/pg_backrest.conf --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
INFO: WAL segments to archive: total = 1, size = 16MB
DEBUG: Archive->xfer: bArchiveFile = true, bDestinationCompress = true, bSourceCompressed = false, strFile = 000000010000000100000006-1c7e00fd09b9dd11fc2966590b3e3274645dd031
@@ -166,5 +188,7 @@ DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/lo
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
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: archive-push stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

12
test/log/backup-expire-001.log
View File

@@ -33,7 +33,7 @@ db-version="9.2"
Nothing to expire
> [BACKREST_BIN] "--config=[TEST_PATH]/backrest/pg_backrest.conf" --stanza=db --log-level-console=info --retention-full=1 --retention-diff=1 --retention-archive-type=full --retention-archive=1 expire
------------------------------------------------------------------------------------------------------------------------------------
INFO: expire start: --no-compress --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=full --retention-diff=1 --retention-full=1 --stanza=db
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/db/pg_backrest.conf --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=full --retention-diff=1 --retention-full=1 --stanza=db
INFO: archive retention based on backup [BACKUP-FULL-1]
INFO: archive retention starts at 000000010000000000000000
INFO: no WAL segments to expire
@@ -97,7 +97,7 @@ db-version="9.2"
Expire oldest full backup, archive expire falls on segment major boundary
> [BACKREST_BIN] "--config=[TEST_PATH]/backrest/pg_backrest.conf" --stanza=db --log-level-console=info --retention-full=1 --retention-diff=1 --retention-archive-type=full --retention-archive=1 expire
------------------------------------------------------------------------------------------------------------------------------------
INFO: expire start: --no-compress --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=full --retention-diff=1 --retention-full=1 --stanza=db
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/db/pg_backrest.conf --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=full --retention-diff=1 --retention-full=1 --stanza=db
INFO: remove expired full backup: [BACKUP-FULL-1]
INFO: archive retention based on backup [BACKUP-FULL-2]
INFO: archive retention starts at 000000010000000100000000
@@ -165,7 +165,7 @@ db-version="9.2"
Expire oldest diff backup
> [BACKREST_BIN] "--config=[TEST_PATH]/backrest/pg_backrest.conf" --stanza=db --log-level-console=info --retention-full=1 --retention-diff=1 --retention-archive-type=full --retention-archive=1 expire
------------------------------------------------------------------------------------------------------------------------------------
INFO: expire start: --no-compress --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=full --retention-diff=1 --retention-full=1 --stanza=db
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/db/pg_backrest.conf --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=full --retention-diff=1 --retention-full=1 --stanza=db
INFO: remove expired diff/incr backup [BACKUP-DIFF-1]
INFO: archive retention based on backup [BACKUP-FULL-2]
INFO: archive retention starts at 000000010000000100000000
@@ -242,7 +242,7 @@ db-version="9.2"
Expire oldest full backup, archive expire does not fall on major segment boundary
> [BACKREST_BIN] "--config=[TEST_PATH]/backrest/pg_backrest.conf" --stanza=db --log-level-console=info --retention-full=1 --retention-diff=1 --retention-archive-type=diff --retention-archive=1 expire
------------------------------------------------------------------------------------------------------------------------------------
INFO: expire start: --no-compress --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=diff --retention-diff=1 --retention-full=1 --stanza=db
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/db/pg_backrest.conf --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=diff --retention-diff=1 --retention-full=1 --stanza=db
INFO: remove expired full backup: [BACKUP-FULL-2]
INFO: archive retention based on backup [BACKUP-DIFF-3]
INFO: archive retention starts at 000000010000000200000016
@@ -321,7 +321,7 @@ db-version="9.2"
Expire oldest diff backup (cascade to incr)
> [BACKREST_BIN] "--config=[TEST_PATH]/backrest/pg_backrest.conf" --stanza=db --log-level-console=info --retention-full=1 --retention-diff=1 --retention-archive-type=diff --retention-archive=1 expire
------------------------------------------------------------------------------------------------------------------------------------
INFO: expire start: --no-compress --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=diff --retention-diff=1 --retention-full=1 --stanza=db
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/db/pg_backrest.conf --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=diff --retention-diff=1 --retention-full=1 --stanza=db
INFO: remove expired diff/incr backup [BACKUP-INCR-2]
INFO: remove expired diff/incr backup [BACKUP-DIFF-3]
INFO: archive retention based on backup [BACKUP-DIFF-4]
@@ -401,7 +401,7 @@ db-version="9.2"
Expire archive based on newest incr backup
> [BACKREST_BIN] "--config=[TEST_PATH]/backrest/pg_backrest.conf" --stanza=db --log-level-console=info --retention-full=1 --retention-diff=1 --retention-archive-type=incr --retention-archive=1 expire
------------------------------------------------------------------------------------------------------------------------------------
INFO: expire start: --no-compress --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=incr --retention-diff=1 --retention-full=1 --stanza=db
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/db/pg_backrest.conf --log-level-console=info --log-level-file=trace --repo-path=[TEST_PATH]/backrest --retention-archive=1 --retention-archive-type=incr --retention-diff=1 --retention-full=1 --stanza=db
INFO: archive retention based on backup [BACKUP-INCR-3]
INFO: archive retention starts at 000000010000000200000024
INFO: expired WAL segments: start = 00000001000000020000001E-0000000000000000000000000000000000000000.gz, stop = 000000010000000200000023-0000000000000000000000000000000000000000.gz

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

@@ -4,7 +4,10 @@ run 001 - rmt 0, cmp 0, hardlink 0
full backup
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --manifest-save-threshold=3 --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --manifest-save-threshold=3 --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --manifest-save-threshold=3 --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -56,12 +59,14 @@ DEBUG: File->remove=>: bRemoved = false
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -79,6 +84,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -154,10 +160,122 @@ db-version="9.3"
[db:history]
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --force stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --force --repo-path=[TEST_PATH]/backrest
INFO: sent term signal to process [PROCESS-ID]
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
full backup (abort backup - local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=5 --test-point=backup-start=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=5 --test-point=backup-start=y --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists=>: bExists = true
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
DEBUG: Backup->typeFind(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db, strType = full
DEBUG: Backup->typeFind=>: strLabel = [undef]
DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
DEBUG: Manifest->build(): bNoStartStop = true, oFile = [object], oLastManifest = [undef], oTablespaceMapRef = [undef], strDbClusterPath = [TEST_PATH]/db/common, strLevel = [undef]
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/db/common/pg_tblspc, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/db/common/pg_tblspc, strPathType = db:absolute
DEBUG: File->manifest(): oManifestHashRef = [hash], strPath = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 0, oManifestHashRef = [hash], strPathFileOp = [undef], strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = base, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = global, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = path-test, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = pg_tblspc, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->wait(): strPathType = db:absolute
DEBUG: Backup->process: create temp backup path [TEST_PATH]/backrest/temp/db.tmp
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [undef], strPathType = backup:tmp
DEBUG: Backup->processManifest(): bCompress = false, bHardLink = false, oBackupManifest = [object], strType = full
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = base/base, strPathType = backup:tmp
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = base/global, strPathType = backup:tmp
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = base/path-test, strPathType = backup:tmp
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = base/pg_tblspc, strPathType = backup:tmp
DEBUG: File->linkCreate(): bHard = false, bPathCreate = false, bRelative = false, strDestinationFile = base/link-test, strDestinationPathType = backup:tmp, strSourceFile = /test, strSourcePathType = backup:absolute
DEBUG: Exit::exitSafe(): iExitCode = -1, strSignal = TERM
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
ERROR: [138]: process terminated on a TERM signal
full backup (global stop)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
ERROR: [137]: stop file exists for all stanzas
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db stop
------------------------------------------------------------------------------------------------------------------------------------
INFO: stop start: --repo-path=[TEST_PATH]/backrest --stanza=db
WARN: stop file already exists for stanza db
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: stop stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
full backup (stanza stop)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
ERROR: [137]: stop file exists for stanza db
DEBUG: Exit::exitSafe(): iExitCode = 137, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start db (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/backrest
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
start (local)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf start
------------------------------------------------------------------------------------------------------------------------------------
INFO: start start: --repo-path=[TEST_PATH]/backrest
WARN: stop file does not exist
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: start stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info db
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Info->stanzaList(): oFile = [object], strStanza = db
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -170,13 +288,14 @@ stanza db
oldest backup timestamp: [TIMESTAMP-STR]
latest backup label: [BACKUP-FULL-1]
latest backup timestamp: [TIMESTAMP-STR]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info db
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Info->stanzaList(): oFile = [object], strStanza = db
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -230,13 +349,17 @@ DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
full backup (resume)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=0 --test-point=backup-resume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --type=full
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-resume=y --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -268,7 +391,8 @@ DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPa
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/base, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/global, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/path-test, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: Backup->fileNotInManifest=>: stryFile = (base/PG_VERSION, base/link-test)
DEBUG: Backup->fileNotInManifest=>: stryFile = (base/PG_VERSION, base/link-test, file.tmp)
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/file.tmp
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/base/link-test
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/base/PG_VERSION
DEBUG: Backup->processManifest(): bCompress = false, bHardLink = false, oBackupManifest = [object], strType = full
@@ -296,12 +420,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -319,6 +445,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -398,7 +525,10 @@ db-version="9.3"
restore delta, backup '[BACKUP-FULL-2]' (add and delete files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --delta --set=[BACKUP-FULL-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-FULL-2] --stanza=db
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-FULL-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -461,8 +591,9 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/common/recovery.conf
--------------------------------------------------------
@@ -471,7 +602,10 @@ restore_command = '[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --sta
incr backup (invalid database version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -488,13 +622,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database version = 9.3, system-id 6156904820763115222 does not match backup version = 8.0, system-id = 6156904820763115222
HINT: are you backing up to the correct stanza?
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid system id)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -511,13 +649,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database version = 9.3, system-id 6156904820763115222 does not match backup version = 9.3, system-id = 6999999999999999999
HINT: are you backing up to the correct stanza?
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid control version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -534,13 +676,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database control-version = 937, catalog-version 201306121 does not match backup control-version = 842, catalog-version = 201306121
HINT: this may be a symptom of database or repository corruption!
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid catalog version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -557,13 +703,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database control-version = 937, catalog-version 201306121 does not match backup control-version = 937, catalog-version = 197208141
HINT: this may be a symptom of database or repository corruption!
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (add tablespace 1)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -622,12 +772,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -645,6 +797,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -734,9 +887,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
incr backup (resume and add tablespace 2)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=0 --test-point=backup-resume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-resume=y
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -810,12 +966,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -833,6 +991,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -931,9 +1090,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (cannot resume - new diff)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=0 --test-point=backup-noresume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-noresume=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1004,12 +1166,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1027,6 +1191,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -1126,9 +1291,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (cannot resume - disabled)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --no-resume --type=diff --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --no-resume --type=diff --stanza=db backup --test --test-delay=0 --test-point=backup-noresume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --no-resume --stanza=db --start-fast --test --test-delay=0 --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --no-resume --stanza=db --start-fast --test --test-delay=0 --test-point=backup-noresume=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1199,12 +1367,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1222,6 +1392,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -1324,7 +1495,10 @@ db-version="9.3"
restore, backup '[BACKUP-DIFF-2]', expect exit 115 (fail on used path)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1347,13 +1521,17 @@ DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPa
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = path-test, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = pg_tblspc, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
ERROR: [115]: cannot restore to path '[TEST_PATH]/db/common' that contains files - try using --delta if this is what you intended
DEBUG: Main::safeExit(): iExitCode = 115
DEBUG: Exit::exitSafe(): iExitCode = 115, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', expect exit 104 (fail on undef format)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1363,13 +1541,17 @@ DEBUG: File->exists=>: bExists = true
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <false>, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = <false>, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = [BACKUP-DIFF-2]/backup.manifest, strSourcePathType = backup:cluster, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/backup.manifest.backrest.tmp, strSourcePathType = absolute
ERROR: [104]: format of [TEST_PATH]/db/common/backup.manifest is 0 but 4 is required
DEBUG: Main::safeExit(): iExitCode = 104
DEBUG: Exit::exitSafe(): iExitCode = 104, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', expect exit 104 (fail on mismatch format)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1379,13 +1561,17 @@ DEBUG: File->exists=>: bExists = true
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <false>, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = <false>, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = [BACKUP-DIFF-2]/backup.manifest, strSourcePathType = backup:cluster, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/backup.manifest.backrest.tmp, strSourcePathType = absolute
ERROR: [104]: format of [TEST_PATH]/db/common/backup.manifest is 0 but 4 is required
DEBUG: Main::safeExit(): iExitCode = 104
DEBUG: Exit::exitSafe(): iExitCode = 104, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', remap (remap all paths)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common-2/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1486,8 +1672,9 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common-2/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common-2/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/common-2/recovery.conf
----------------------------------------------------------
@@ -1496,7 +1683,10 @@ restore_command = '[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --sta
incr backup (add files and remove tablespace 2)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1557,12 +1747,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1581,6 +1773,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -1678,7 +1871,10 @@ db-version="9.3"
incr backup (update files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1734,12 +1930,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-4], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1758,6 +1956,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -1857,7 +2056,10 @@ db-version="9.3"
diff backup (no updates)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1927,12 +2129,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1951,6 +2155,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2050,9 +2255,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
incr backup (remove files - but won't affect manifest)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=1 --test-point=manifest-build=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --test-point=manifest-build=y
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2103,12 +2311,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-5], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=1
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2127,6 +2337,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2228,9 +2439,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (remove files during backup)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=1 --test-point=manifest-build=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --test-point=manifest-build=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2293,12 +2507,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-4], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=1
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2317,6 +2533,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2420,7 +2637,10 @@ db-version="9.3"
full backup
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2487,12 +2707,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2511,6 +2733,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2616,7 +2839,10 @@ db-version="9.3"
diff backup (add files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2672,12 +2898,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-5], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2696,6 +2924,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2805,7 +3034,10 @@ db-version="9.3"
restore delta, backup '[BACKUP-DIFF-5]' (no tablespace remap)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --delta --set=[BACKUP-DIFF-5] --no-tablespace --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-5] --stanza=db --no-tablespace --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-5] --stanza=db --no-tablespace --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common-2/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -2895,13 +3127,14 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common-2/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common-2/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -2919,13 +3152,14 @@ stanza db
stanza db_empty
status: error (no valid backups)
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3240,26 +3474,28 @@ DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info bogus
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=bogus info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = bogus
DEBUG: Info->stanzaList(): oFile = [object], strStanza = bogus
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (db, db_empty)
stanza bogus
status: error (missing stanza path)
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info bogus
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=bogus info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = bogus
DEBUG: Info->stanzaList(): oFile = [object], strStanza = bogus
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3275,29 +3511,32 @@ DEBUG: File->list=>: stryFileList = (db, db_empty)
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
No stanzas exist in [TEST_PATH]/backrest.
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
[]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -4,7 +4,10 @@ run 002 - rmt 0, cmp 0, hardlink 1
full backup
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --manifest-save-threshold=3 --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --manifest-save-threshold=3 --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --manifest-save-threshold=3 --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -56,12 +59,14 @@ DEBUG: File->remove=>: bRemoved = false
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -80,6 +85,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -158,7 +164,7 @@ db-version="9.3"
info db
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Info->stanzaList(): oFile = [object], strStanza = db
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -171,13 +177,14 @@ stanza db
oldest backup timestamp: [TIMESTAMP-STR]
latest backup label: [BACKUP-FULL-1]
latest backup timestamp: [TIMESTAMP-STR]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info db
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Info->stanzaList(): oFile = [object], strStanza = db
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -231,13 +238,17 @@ DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
full backup (resume)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=0 --test-point=backup-resume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --type=full
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-resume=y --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -269,7 +280,8 @@ DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPa
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/base, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/global, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/path-test, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: Backup->fileNotInManifest=>: stryFile = (base/PG_VERSION, base/link-test)
DEBUG: Backup->fileNotInManifest=>: stryFile = (base/PG_VERSION, base/link-test, file.tmp)
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/file.tmp
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/base/link-test
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/base/PG_VERSION
DEBUG: Backup->processManifest(): bCompress = false, bHardLink = true, oBackupManifest = [object], strType = full
@@ -297,12 +309,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -321,6 +335,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -400,7 +415,10 @@ db-version="9.3"
restore delta, backup '[BACKUP-FULL-2]' (add and delete files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --delta --set=[BACKUP-FULL-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-FULL-2] --stanza=db
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-FULL-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -463,8 +481,9 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/common/recovery.conf
--------------------------------------------------------
@@ -473,7 +492,10 @@ restore_command = '[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --sta
incr backup (invalid database version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -490,13 +512,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database version = 9.3, system-id 6156904820763115222 does not match backup version = 8.0, system-id = 6156904820763115222
HINT: are you backing up to the correct stanza?
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid system id)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -513,13 +539,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database version = 9.3, system-id 6156904820763115222 does not match backup version = 9.3, system-id = 6999999999999999999
HINT: are you backing up to the correct stanza?
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid control version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -536,13 +566,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database control-version = 937, catalog-version 201306121 does not match backup control-version = 842, catalog-version = 201306121
HINT: this may be a symptom of database or repository corruption!
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid catalog version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -559,13 +593,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database control-version = 937, catalog-version 201306121 does not match backup control-version = 937, catalog-version = 197208141
HINT: this may be a symptom of database or repository corruption!
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (add tablespace 1)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -634,12 +672,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -658,6 +698,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -747,9 +788,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
incr backup (resume and add tablespace 2)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=0 --test-point=backup-resume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-resume=y
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -845,12 +889,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -869,6 +915,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -967,9 +1014,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (cannot resume - new diff)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=0 --test-point=backup-noresume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-noresume=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1052,12 +1102,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1076,6 +1128,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -1175,9 +1228,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (cannot resume - disabled)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --no-resume --type=diff --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --no-resume --type=diff --stanza=db backup --test --test-delay=0 --test-point=backup-noresume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --no-resume --stanza=db --start-fast --test --test-delay=0 --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --no-resume --stanza=db --start-fast --test --test-delay=0 --test-point=backup-noresume=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1260,12 +1316,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1284,6 +1342,7 @@ start-fast=y
# general settings for all operations
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -1386,7 +1445,10 @@ db-version="9.3"
restore, backup '[BACKUP-DIFF-2]', expect exit 115 (fail on used path)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1409,13 +1471,17 @@ DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPa
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = path-test, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = pg_tblspc, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
ERROR: [115]: cannot restore to path '[TEST_PATH]/db/common' that contains files - try using --delta if this is what you intended
DEBUG: Main::safeExit(): iExitCode = 115
DEBUG: Exit::exitSafe(): iExitCode = 115, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', expect exit 104 (fail on undef format)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1425,13 +1491,17 @@ DEBUG: File->exists=>: bExists = true
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <false>, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = <false>, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = [BACKUP-DIFF-2]/backup.manifest, strSourcePathType = backup:cluster, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/backup.manifest.backrest.tmp, strSourcePathType = absolute
ERROR: [104]: format of [TEST_PATH]/db/common/backup.manifest is 0 but 4 is required
DEBUG: Main::safeExit(): iExitCode = 104
DEBUG: Exit::exitSafe(): iExitCode = 104, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', expect exit 104 (fail on mismatch format)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1441,13 +1511,17 @@ DEBUG: File->exists=>: bExists = true
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <false>, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = <false>, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = [BACKUP-DIFF-2]/backup.manifest, strSourcePathType = backup:cluster, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/backup.manifest.backrest.tmp, strSourcePathType = absolute
ERROR: [104]: format of [TEST_PATH]/db/common/backup.manifest is 0 but 4 is required
DEBUG: Main::safeExit(): iExitCode = 104
DEBUG: Exit::exitSafe(): iExitCode = 104, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', remap (remap all paths)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common-2/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1548,8 +1622,9 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common-2/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common-2/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/common-2/recovery.conf
----------------------------------------------------------
@@ -1558,7 +1633,10 @@ restore_command = '[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --sta
incr backup (add files and remove tablespace 2)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1630,12 +1708,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1655,6 +1735,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -1752,7 +1833,10 @@ db-version="9.3"
incr backup (update files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1824,12 +1908,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-4], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1849,6 +1935,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -1948,7 +2035,10 @@ db-version="9.3"
diff backup (no updates)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2023,12 +2113,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2048,6 +2140,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2147,9 +2240,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
incr backup (remove files - but won't affect manifest)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=1 --test-point=manifest-build=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --test-point=manifest-build=y
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2221,12 +2317,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-5], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=1
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2246,6 +2344,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2347,9 +2446,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (remove files during backup)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=1 --test-point=manifest-build=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --test-point=manifest-build=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2420,12 +2522,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-4], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=1
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2445,6 +2549,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2548,7 +2653,10 @@ db-version="9.3"
full backup
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2615,12 +2723,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2640,6 +2750,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2745,7 +2856,10 @@ db-version="9.3"
diff backup (add files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --no-compress --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
INFO: backup start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2817,12 +2931,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-5], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --no-compress --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --no-compress --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2842,6 +2958,7 @@ start-fast=y
[global:general]
compress=n
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2951,7 +3068,10 @@ db-version="9.3"
restore delta, backup '[BACKUP-DIFF-5]' (no tablespace remap)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --delta --set=[BACKUP-DIFF-5] --no-tablespace --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --no-compress --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-5] --stanza=db --no-tablespace --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
INFO: restore start: --no-compress --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-5] --stanza=db --no-tablespace --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common-2/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -3041,13 +3161,14 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common-2/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common-2/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3065,13 +3186,14 @@ stanza db
stanza db_empty
status: error (no valid backups)
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3386,26 +3508,28 @@ DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info bogus
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=bogus info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = bogus
DEBUG: Info->stanzaList(): oFile = [object], strStanza = bogus
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (db, db_empty)
stanza bogus
status: error (missing stanza path)
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info bogus
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=bogus info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = bogus
DEBUG: Info->stanzaList(): oFile = [object], strStanza = bogus
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3421,29 +3545,32 @@ DEBUG: File->list=>: stryFileList = (db, db_empty)
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
No stanzas exist in [TEST_PATH]/backrest.
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
[]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -4,7 +4,10 @@ run 003 - rmt 0, cmp 1, hardlink 0
full backup
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --manifest-save-threshold=3 --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --manifest-save-threshold=3 --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --manifest-save-threshold=3 --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -56,12 +59,14 @@ DEBUG: File->remove=>: bRemoved = false
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -78,6 +83,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -156,7 +162,7 @@ db-version="9.3"
info db
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Info->stanzaList(): oFile = [object], strStanza = db
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -169,13 +175,14 @@ stanza db
oldest backup timestamp: [TIMESTAMP-STR]
latest backup label: [BACKUP-FULL-1]
latest backup timestamp: [TIMESTAMP-STR]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info db
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Info->stanzaList(): oFile = [object], strStanza = db
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -229,13 +236,17 @@ DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
full backup (resume)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=0 --test-point=backup-resume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --type=full
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-resume=y --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -267,7 +278,8 @@ DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPa
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/base, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/global, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/path-test, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: Backup->fileNotInManifest=>: stryFile = (base/PG_VERSION.gz, base/link-test)
DEBUG: Backup->fileNotInManifest=>: stryFile = (base/PG_VERSION.gz, base/link-test, file.tmp.gz)
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/file.tmp.gz
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/base/link-test
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/base/PG_VERSION.gz
DEBUG: Backup->processManifest(): bCompress = true, bHardLink = false, oBackupManifest = [object], strType = full
@@ -295,12 +307,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -317,6 +331,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -396,7 +411,10 @@ db-version="9.3"
restore delta, backup '[BACKUP-FULL-2]' (add and delete files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --delta --set=[BACKUP-FULL-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-FULL-2] --stanza=db
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-FULL-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -459,8 +477,9 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/common/recovery.conf
--------------------------------------------------------
@@ -469,7 +488,10 @@ restore_command = '[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --sta
incr backup (invalid database version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -486,13 +508,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database version = 9.3, system-id 6156904820763115222 does not match backup version = 8.0, system-id = 6156904820763115222
HINT: are you backing up to the correct stanza?
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid system id)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -509,13 +535,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database version = 9.3, system-id 6156904820763115222 does not match backup version = 9.3, system-id = 6999999999999999999
HINT: are you backing up to the correct stanza?
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid control version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -532,13 +562,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database control-version = 937, catalog-version 201306121 does not match backup control-version = 842, catalog-version = 201306121
HINT: this may be a symptom of database or repository corruption!
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid catalog version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -555,13 +589,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database control-version = 937, catalog-version 201306121 does not match backup control-version = 937, catalog-version = 197208141
HINT: this may be a symptom of database or repository corruption!
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (add tablespace 1)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -620,12 +658,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -642,6 +682,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -731,9 +772,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
incr backup (resume and add tablespace 2)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=0 --test-point=backup-resume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-resume=y
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -807,12 +851,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -829,6 +875,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -927,9 +974,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (cannot resume - new diff)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=0 --test-point=backup-noresume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-noresume=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1000,12 +1050,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1022,6 +1074,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -1121,9 +1174,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (cannot resume - disabled)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --no-resume --type=diff --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --no-resume --type=diff --stanza=db backup --test --test-delay=0 --test-point=backup-noresume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --no-resume --stanza=db --start-fast --test --test-delay=0 --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --no-resume --stanza=db --start-fast --test --test-delay=0 --test-point=backup-noresume=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1194,12 +1250,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1216,6 +1274,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -1318,7 +1377,10 @@ db-version="9.3"
restore, backup '[BACKUP-DIFF-2]', expect exit 115 (fail on used path)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1341,13 +1403,17 @@ DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPa
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = path-test, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = pg_tblspc, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
ERROR: [115]: cannot restore to path '[TEST_PATH]/db/common' that contains files - try using --delta if this is what you intended
DEBUG: Main::safeExit(): iExitCode = 115
DEBUG: Exit::exitSafe(): iExitCode = 115, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', expect exit 104 (fail on undef format)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1357,13 +1423,17 @@ DEBUG: File->exists=>: bExists = true
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <false>, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = <false>, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = [BACKUP-DIFF-2]/backup.manifest, strSourcePathType = backup:cluster, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/backup.manifest.backrest.tmp, strSourcePathType = absolute
ERROR: [104]: format of [TEST_PATH]/db/common/backup.manifest is 0 but 4 is required
DEBUG: Main::safeExit(): iExitCode = 104
DEBUG: Exit::exitSafe(): iExitCode = 104, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', expect exit 104 (fail on mismatch format)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1373,13 +1443,17 @@ DEBUG: File->exists=>: bExists = true
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <false>, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = <false>, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = [BACKUP-DIFF-2]/backup.manifest, strSourcePathType = backup:cluster, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/backup.manifest.backrest.tmp, strSourcePathType = absolute
ERROR: [104]: format of [TEST_PATH]/db/common/backup.manifest is 0 but 4 is required
DEBUG: Main::safeExit(): iExitCode = 104
DEBUG: Exit::exitSafe(): iExitCode = 104, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', remap (remap all paths)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common-2/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1480,8 +1554,9 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common-2/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common-2/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/common-2/recovery.conf
----------------------------------------------------------
@@ -1490,7 +1565,10 @@ restore_command = '[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --sta
incr backup (add files and remove tablespace 2)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1551,12 +1629,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1574,6 +1654,7 @@ archive-copy=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -1671,7 +1752,10 @@ db-version="9.3"
incr backup (update files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1727,12 +1811,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-4], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1750,6 +1836,7 @@ archive-copy=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -1849,7 +1936,10 @@ db-version="9.3"
diff backup (no updates)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1919,12 +2009,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1942,6 +2034,7 @@ archive-copy=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2041,9 +2134,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
incr backup (remove files - but won't affect manifest)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=1 --test-point=manifest-build=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --test-point=manifest-build=y
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2094,12 +2190,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-5], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=1
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2117,6 +2215,7 @@ archive-copy=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2218,9 +2317,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (remove files during backup)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=1 --test-point=manifest-build=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --test-point=manifest-build=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2283,12 +2385,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-4], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=1
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2306,6 +2410,7 @@ archive-copy=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2409,7 +2514,10 @@ db-version="9.3"
full backup
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2476,12 +2584,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2499,6 +2609,7 @@ archive-copy=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2604,7 +2715,10 @@ db-version="9.3"
diff backup (add files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2660,12 +2774,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-5], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2683,6 +2799,7 @@ archive-copy=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2792,7 +2909,10 @@ db-version="9.3"
restore delta, backup '[BACKUP-DIFF-5]' (no tablespace remap)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --delta --set=[BACKUP-DIFF-5] --no-tablespace --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-5] --stanza=db --no-tablespace --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-5] --stanza=db --no-tablespace --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common-2/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -2882,13 +3002,14 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common-2/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common-2/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -2906,13 +3027,14 @@ stanza db
stanza db_empty
status: error (no valid backups)
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3227,26 +3349,28 @@ DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info bogus
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=bogus info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = bogus
DEBUG: Info->stanzaList(): oFile = [object], strStanza = bogus
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (db, db_empty)
stanza bogus
status: error (missing stanza path)
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info bogus
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=bogus info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = bogus
DEBUG: Info->stanzaList(): oFile = [object], strStanza = bogus
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3262,29 +3386,32 @@ DEBUG: File->list=>: stryFileList = (db, db_empty)
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
No stanzas exist in [TEST_PATH]/backrest.
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
[]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

@@ -4,7 +4,10 @@ run 004 - rmt 0, cmp 1, hardlink 1
full backup
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --manifest-save-threshold=3 --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --manifest-save-threshold=3 --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --manifest-save-threshold=3 --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -56,12 +59,14 @@ DEBUG: File->remove=>: bRemoved = false
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -79,6 +84,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -157,7 +163,7 @@ db-version="9.3"
info db
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Info->stanzaList(): oFile = [object], strStanza = db
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -170,13 +176,14 @@ stanza db
oldest backup timestamp: [TIMESTAMP-STR]
latest backup label: [BACKUP-FULL-1]
latest backup timestamp: [TIMESTAMP-STR]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info db
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=db info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: Info->stanzaList(): oFile = [object], strStanza = db
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -230,13 +237,17 @@ DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
full backup (resume)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup --test --test-delay=0 --test-point=backup-resume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --type=full
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-resume=y --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -268,7 +279,8 @@ DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPa
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/base, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/global, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: File->manifestRecurse(): iDepth = 2, oManifestHashRef = [hash], strPathFileOp = base/path-test, strPathOp = [TEST_PATH]/backrest/temp/db.tmp, strPathType = backup:tmp
DEBUG: Backup->fileNotInManifest=>: stryFile = (base/PG_VERSION.gz, base/link-test)
DEBUG: Backup->fileNotInManifest=>: stryFile = (base/PG_VERSION.gz, base/link-test, file.tmp.gz)
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/file.tmp.gz
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/base/link-test
DEBUG: Backup->tmpClean: remove file [TEST_PATH]/backrest/temp/db.tmp/base/PG_VERSION.gz
DEBUG: Backup->processManifest(): bCompress = true, bHardLink = true, oBackupManifest = [object], strType = full
@@ -296,12 +308,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -319,6 +333,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -398,7 +413,10 @@ db-version="9.3"
restore delta, backup '[BACKUP-FULL-2]' (add and delete files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --delta --set=[BACKUP-FULL-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-FULL-2] --stanza=db
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-FULL-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -461,8 +479,9 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/common/recovery.conf
--------------------------------------------------------
@@ -471,7 +490,10 @@ restore_command = '[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --sta
incr backup (invalid database version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -488,13 +510,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database version = 9.3, system-id 6156904820763115222 does not match backup version = 8.0, system-id = 6156904820763115222
HINT: are you backing up to the correct stanza?
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid system id)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -511,13 +537,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database version = 9.3, system-id 6156904820763115222 does not match backup version = 9.3, system-id = 6999999999999999999
HINT: are you backing up to the correct stanza?
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid control version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -534,13 +564,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database control-version = 937, catalog-version 201306121 does not match backup control-version = 842, catalog-version = 201306121
HINT: this may be a symptom of database or repository corruption!
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (invalid catalog version)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -557,13 +591,17 @@ DEBUG: Db->info(): oFile = [object], strDbPath = [TEST_PATH]/db/common
DEBUG: Db->info=>: fDbVersion = 9.3, iCatalogVersion = 201306121, iControlVersion = 937, ullDbSysId = 6156904820763115222
ERROR: [126]: database control-version = 937, catalog-version 201306121 does not match backup control-version = 937, catalog-version = 197208141
HINT: this may be a symptom of database or repository corruption!
DEBUG: Main::safeExit(): iExitCode = 126
DEBUG: Exit::exitSafe(): iExitCode = 126, strSignal = [undef]
INFO: backup stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
incr backup (add tablespace 1)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -632,12 +670,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -655,6 +695,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -744,9 +785,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
incr backup (resume and add tablespace 2)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=0 --test-point=backup-resume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-resume=y
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -842,12 +886,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -865,6 +911,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -963,9 +1010,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (cannot resume - new diff)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=0 --test-point=backup-noresume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=0 --test-point=backup-noresume=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1048,12 +1098,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-1], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1071,6 +1123,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -1170,9 +1223,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (cannot resume - disabled)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --no-resume --type=diff --stanza=db backup --test --test-delay=0
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --no-resume --type=diff --stanza=db backup --test --test-delay=0 --test-point=backup-noresume=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --no-resume --stanza=db --start-fast --test --test-delay=0 --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --no-resume --stanza=db --start-fast --test --test-delay=0 --test-point=backup-noresume=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1255,12 +1311,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-2], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=0
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1278,6 +1336,7 @@ start-fast=y
# general settings for all operations
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
# file and console log settings
@@ -1380,7 +1439,10 @@ db-version="9.3"
restore, backup '[BACKUP-DIFF-2]', expect exit 115 (fail on used path)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1403,13 +1465,17 @@ DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPa
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = path-test, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
DEBUG: File->manifestRecurse(): iDepth = 1, oManifestHashRef = [hash], strPathFileOp = pg_tblspc, strPathOp = [TEST_PATH]/db/common, strPathType = db:absolute
ERROR: [115]: cannot restore to path '[TEST_PATH]/db/common' that contains files - try using --delta if this is what you intended
DEBUG: Main::safeExit(): iExitCode = 115
DEBUG: Exit::exitSafe(): iExitCode = 115, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', expect exit 104 (fail on undef format)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1419,13 +1485,17 @@ DEBUG: File->exists=>: bExists = true
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <false>, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = <false>, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = [BACKUP-DIFF-2]/backup.manifest, strSourcePathType = backup:cluster, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/backup.manifest.backrest.tmp, strSourcePathType = absolute
ERROR: [104]: format of [TEST_PATH]/db/common/backup.manifest is 0 but 4 is required
DEBUG: Main::safeExit(): iExitCode = 104
DEBUG: Exit::exitSafe(): iExitCode = 104, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', expect exit 104 (fail on mismatch format)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1435,13 +1505,17 @@ DEBUG: File->exists=>: bExists = true
DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <false>, bDestinationPathCreate = <false>, bIgnoreMissingSource = <false>, bSourceCompressed = <false>, lModificationTime = [undef], strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = db:absolute, strGroup = [undef], strMode = <0640>, strSourceFile = [BACKUP-DIFF-2]/backup.manifest, strSourcePathType = backup:cluster, strUser = [undef]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common/backup.manifest, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common/backup.manifest.backrest.tmp, strSourcePathType = absolute
ERROR: [104]: format of [TEST_PATH]/db/common/backup.manifest is 0 but 4 is required
DEBUG: Main::safeExit(): iExitCode = 104
DEBUG: Exit::exitSafe(): iExitCode = 104, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
restore, backup '[BACKUP-DIFF-2]', remap (remap all paths)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --set=[BACKUP-DIFF-2] --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-2] --stanza=db --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common-2/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -1542,8 +1616,9 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common-2/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common-2/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/common-2/recovery.conf
----------------------------------------------------------
@@ -1552,7 +1627,10 @@ restore_command = '[BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --sta
incr backup (add files and remove tablespace 2)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1624,12 +1702,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1648,6 +1728,7 @@ hardlink=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -1745,7 +1826,10 @@ db-version="9.3"
incr backup (update files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -1817,12 +1901,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-4], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -1841,6 +1927,7 @@ hardlink=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -1940,7 +2027,10 @@ db-version="9.3"
diff backup (no updates)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2015,12 +2105,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2039,6 +2131,7 @@ hardlink=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2138,9 +2231,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
incr backup (remove files - but won't affect manifest)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --stanza=db backup --test --test-delay=1 --test-point=manifest-build=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --test-point=manifest-build=y
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2212,12 +2308,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-INCR-5], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=1
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2236,6 +2334,7 @@ hardlink=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2337,9 +2436,12 @@ db-version="9.3"
1={"db-catalog-version":201306121,"db-control-version":937,"db-system-id":6156904820763115222,"db-version":"9.3"}
diff backup (remove files during backup)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=1
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup --test --test-delay=1 --test-point=manifest-build=y
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --test --test-delay=1 --test-point=manifest-build=y --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2410,12 +2512,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-4], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db --test --test-delay=1
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2434,6 +2538,7 @@ hardlink=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2537,7 +2642,10 @@ db-version="9.3"
full backup
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=full --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=full
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2604,12 +2712,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-FULL-3], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2628,6 +2738,7 @@ hardlink=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2733,7 +2844,10 @@ db-version="9.3"
diff backup (add files)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --no-start-stop --type=diff --stanza=db backup
------------------------------------------------------------------------------------------------------------------------------------
INFO: backup start: --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
INFO: backup start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --db-path=[TEST_PATH]/db/common-2 --db-port=[PORT-1] --db-socket-path=[TEST_PATH]/db --hardlink --log-level-console=debug --log-level-file=trace --no-start-stop --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=db --start-fast --type=diff
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = backup
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->pathCreate(): bIgnoreExists = true, strMode = <0750>, strPath = [undef], strPathType = backup:cluster
DEBUG: File->exists(): strPath = [undef], strPathType = backup:cluster
@@ -2805,12 +2919,14 @@ DEBUG: File->remove=>: bRemoved = true
DEBUG: File->linkCreate(): bHard = <false>, bPathCreate = <true>, bRelative = true, strDestinationFile = latest, strDestinationPathType = backup:cluster, strSourceFile = [BACKUP-DIFF-5], strSourcePathType = backup:cluster
DEBUG: File->pathCreate(): bIgnoreExists = <false>, strMode = <0750>, strPath = [TEST_PATH]/backrest/backup/db, strPathType = backup:absolute
INFO: backup stop
INFO: expire start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: Expire->new(): oFile = [object]
INFO: expire start: --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --stanza=db
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup/db
INFO: archive retention type not set - archive logs will not be expired
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = <true>
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: expire stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
+ supplemental file: [TEST_PATH]/db/pg_backrest.conf
----------------------------------------------------
@@ -2829,6 +2945,7 @@ hardlink=y
start-fast=y
[global:general]
config-remote=[TEST_PATH]/backrest/pg_backrest.conf
repo-path=[TEST_PATH]/backrest
[global:log]
@@ -2938,7 +3055,10 @@ db-version="9.3"
restore delta, backup '[BACKUP-DIFF-5]' (no tablespace remap)
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --delta --set=[BACKUP-DIFF-5] --no-tablespace --stanza=db restore
------------------------------------------------------------------------------------------------------------------------------------
INFO: restore start: --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-5] --stanza=db --no-tablespace --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
INFO: restore start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --delta --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --set=[BACKUP-DIFF-5] --stanza=db --no-tablespace --tablespace-map=1=[TEST_PATH]/db/tablespace/ts1-2 --tablespace-map=2=[TEST_PATH]/db/tablespace/ts2-2
DEBUG: Common:::Lock::lockAquire(): bFailOnNoLock = <true>, bRemote = <false>, iProcessIdx = [undef], strLockType = restore
DEBUG: Common:::Lock::lockStopTest(): strRepoPath = [TEST_PATH]/backrest
DEBUG: Common:::Lock::lockAquire=>: bResult = true
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = db
DEBUG: File->exists(): strPath = [TEST_PATH]/db/common-2/postmaster.pid, strPathType = db:absolute
DEBUG: File->exists=>: bExists = false
@@ -3028,13 +3148,14 @@ DEBUG: File->copy(): bAppendChecksum = <false>, bDestinationCompress = <fals
DEBUG: File->owner(): strFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strGroup = [GROUP-1], strPathType = absolute, strUser = [USER-1]
DEBUG: File->move(): bDestinationPathCreate = false, strDestinationFile = [TEST_PATH]/db/common-2/global/pg_control, strDestinationPathType = absolute, strSourceFile = [TEST_PATH]/db/common-2/global/pg_control.backrest.tmp, strSourcePathType = absolute
INFO: restore file [TEST_PATH]/db/common-2/global/pg_control (8KB, 100%) checksum 56fe5780b8dca9705e0c22032a83828860a21235
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
INFO: restore stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3052,13 +3173,14 @@ stanza db
stanza db_empty
status: error (no valid backups)
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3373,26 +3495,28 @@ DEBUG: BackupInfo->new(): strBackupClusterPath = [TEST_PATH]/backrest/backup
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info bogus
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=bogus info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = bogus
DEBUG: Info->stanzaList(): oFile = [object], strStanza = bogus
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = (db, db_empty)
stanza bogus
status: error (missing stanza path)
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info bogus
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf --stanza=bogus info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest --stanza=bogus
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = bogus
DEBUG: Info->stanzaList(): oFile = [object], strStanza = bogus
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
@@ -3408,29 +3532,32 @@ DEBUG: File->list=>: stryFileList = (db, db_empty)
}
}
]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
No stanzas exist in [TEST_PATH]/backrest.
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false
info
> [BACKREST_BIN] --config=[TEST_PATH]/db/pg_backrest.conf info --output=json
------------------------------------------------------------------------------------------------------------------------------------
DEBUG: info start: --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: info start: --config=[TEST_PATH]/db/pg_backrest.conf --config-remote=[TEST_PATH]/backrest/pg_backrest.conf --log-level-console=debug --log-level-file=trace --output=json --repo-path=[TEST_PATH]/backrest --repo-remote-path=[TEST_PATH]/backrest
DEBUG: File->new(): iThreadIdx = [undef], oProtocol = [object], strBackupPath = [TEST_PATH]/backrest, strDefaultFileMode = <0640>, strDefaultPathMode = <0750>, strRemote = none, strStanza = [undef]
DEBUG: Info->stanzaList(): oFile = [object], strStanza = [undef]
DEBUG: File->list(): bIgnoreMissing = true, strExpression = [undef], strPath = backup, strPathType = backup, strSortOrder = <forward>
DEBUG: File->list=>: stryFileList = ()
[]
DEBUG: Main::safeExit(): iExitCode = 0
DEBUG: Exit::exitSafe(): iExitCode = 0, strSignal = [undef]
DEBUG: info stop
DEBUG: Common:::Lock::lockRelease(): bFailOnNoLock = false

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

4
test/test.pl
View File

@@ -147,12 +147,12 @@ logLevelSet(undef, uc($strLogLevel));
if ($strModuleTest ne 'all' && $strModule eq 'all')
{
confess "--module must be provided for test \"${strModuleTest}\"";
confess "--module must be provided for --test=\"${strModuleTest}\"";
}
if (defined($iModuleTestRun) && $strModuleTest eq 'all')
{
confess "--module-test must be provided for run \"${iModuleTestRun}\"";
confess "--test must be provided for --run=\"${iModuleTestRun}\"";
}
# Search for psql bin

10
test/vm/Vagrantfile vendored
View File

@@ -83,10 +83,10 @@ Vagrant.configure(2) do |config|
end
config.vm.define "co6" do |co6|
co6.vm.box = "chef/centos-6.6"
co6.vm.box = "boxcutter/centos67"
co6.vm.provider :virtualbox do |vb|
vb.name = "backrest-test-centos-6.6"
vb.name = "backrest-test-centos-6.7"
end
# Provision the VM
@@ -104,7 +104,7 @@ Vagrant.configure(2) do |config|
yum -y install postgresql94-server
# Install Perl and required modules
yum -y install perl perl-Time-HiRes perl-IO-String perl-parent perl-JSON perl-Digest-SHA perl-DBD-Pg
yum -y install perl perl-Time-HiRes perl-parent perl-JSON perl-Digest-SHA perl-DBD-Pg
# Setup SSH
adduser -gvagrant -n backrest
@@ -113,7 +113,7 @@ Vagrant.configure(2) do |config|
end
config.vm.define "co7" do |co7|
co7.vm.box = "chef/centos-7.1"
co7.vm.box = "boxcutter/centos71"
co7.vm.provider :virtualbox do |vb|
vb.name = "backrest-test-centos-7.1"
@@ -130,7 +130,7 @@ Vagrant.configure(2) do |config|
yum -y install postgresql95-server
# Install Perl and required modules
yum -y install perl perl-IO-String perl-Thread-Queue perl-JSON-PP perl-Digest-SHA perl-DBD-Pg
yum -y install perl perl-Thread-Queue perl-JSON-PP perl-Digest-SHA perl-DBD-Pg
# Setup SSH
adduser -gvagrant -n backrest