db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-02-11 13:53:03 +02:00
Code Issues Releases Activity

Implement issue #68: Allow duplicate WAL to be pushed if the checksum matches.

Browse Source
This commit is contained in:
David Steele 2015-05-29 08:12:39 -04:00
parent 6d2f2d3f91
commit 7ace66e544
13 changed files with 484 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
bin/pg_backrest_remote.pl
View File

@ -205,12 +205,13 @@ while ($strCommand ne OP_EXIT)
# Archive push checks
elsif ($strCommand eq OP_ARCHIVE_PUSH_CHECK)
{
$oArchive->pushCheck($oFile,
param_get(\%oParamHash, 'wal-segment'),
param_get(\%oParamHash, 'db-version'),
param_get(\%oParamHash, 'db-sys-id'));
my $strChecksum = $oArchive->pushCheck($oFile,
param_get(\%oParamHash, 'wal-segment'),
undef,
param_get(\%oParamHash, 'db-version'),
param_get(\%oParamHash, 'db-sys-id'));
$oRemote->output_write('Y');
$oRemote->output_write(defined($strChecksum) ? $strChecksum : 'Y');
}
# Continue if noop or exit
elsif ($strCommand ne OP_NOOP && $strCommand ne OP_EXIT)

34
lib/BackRest/Archive.pm
View File

@ -464,7 +464,7 @@ sub push
if ($bArchiveFile && !$bAsync)
{
my ($strDbVersion, $ullDbSysId) = $self->walInfo($strSourceFile);
$self->pushCheck($oFile, substr(basename($strSourceFile), 0, 24), $strDbVersion, $ullDbSysId);
$self->pushCheck($oFile, substr(basename($strSourceFile), 0, 24), $strSourceFile, $strDbVersion, $ullDbSysId);
}
# Append compression extension
@ -493,12 +493,14 @@ sub pushCheck
my $self = shift;
my $oFile = shift;
my $strWalSegment = shift;
my $strWalFile = shift;
my $strDbVersion = shift;
my $ullDbSysId = shift;
# Set operation and debug strings
my $strOperation = OP_ARCHIVE_PUSH_CHECK;
&log(DEBUG, "${strOperation}: " . PATH_BACKUP_ARCHIVE . ":${strWalSegment}");
my $strChecksum;
if ($oFile->is_remote(PATH_BACKUP_ARCHIVE))
{
@ -513,7 +515,12 @@ sub pushCheck
&log(TRACE, "${strOperation}: remote (" . $oFile->{oRemote}->command_param_string(\%oParamHash) . ')');
# Execute the command
$oFile->{oRemote}->command_execute($strOperation, \%oParamHash);
$strChecksum = $oFile->{oRemote}->command_execute($strOperation, \%oParamHash, true);
if ($strChecksum eq 'Y')
{
undef($strChecksum);
}
}
else
{
@ -551,11 +558,30 @@ sub pushCheck
}
# Check if the WAL segment already exists in the archive
if (defined($self->walFileName($oFile, $strWalSegment)))
$strChecksum = $self->walFileName($oFile, $strWalSegment);
if (defined($strChecksum))
{
$strChecksum = substr($strChecksum, 25, 40);
}
}
if (defined($strChecksum) && defined($strWalFile))
{
my $strChecksumNew = $oFile->hash(PATH_DB_ABSOLUTE, $strWalFile);
if ($strChecksumNew ne $strChecksum)
{
confess &log(ERROR, "WAL segment ${strWalSegment} already exists in the archive", ERROR_ARCHIVE_DUPLICATE);
}
&log(WARN, "WAL segment ${strWalSegment} already exists in the archive with the same checksum" .
" - this is valid in some recovery scenarios but may also indicate a problem");
return undef;
}
return $strChecksum;
}
####################################################################################################################################
@ -670,7 +696,7 @@ sub xfer
if ($bArchiveFile)
{
my ($strDbVersion, $ullDbSysId) = $self->walInfo($strArchiveFile);
$self->pushCheck($oFile, substr(basename($strArchiveFile), 0, 24), $strDbVersion, $ullDbSysId);
$self->pushCheck($oFile, substr(basename($strArchiveFile), 0, 24), $strArchiveFile, $strDbVersion, $ullDbSysId);
}
# Copy the archive file

BIN
test/data/test.archive1.bin
View File

Binary file not shown.

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

@ -1489,6 +1489,7 @@ sub BackRestTestBackup_Test
my $iArchiveMax = 3;
my $strXlogPath = BackRestTestCommon_DbCommonPathGet() . '/pg_xlog';
my $strArchiveTestFile = BackRestTestCommon_DataPathGet() . '/test.archive2.bin';
my $strArchiveTestFile2 = BackRestTestCommon_DataPathGet() . '/test.archive1.bin';
# Print test banner
&log(INFO, 'BACKUP MODULE ******************************************************************');
@ -1640,9 +1641,21 @@ sub BackRestTestBackup_Test
$oInfo{database}{'system-id'} = $ullDbSysId;
BackRestTestCommon_iniSave($strInfoFile, \%oInfo, $bRemote);
# Now it should break on archive duplication
# Should succeed because checksum is the same
&log(INFO, ' test archive duplicate ok');
BackRestTestCommon_Execute($strCommand . " ${strSourceFile}");
# Now it should break on archive duplication (because checksum is different
&log(INFO, ' test archive duplicate error');
$oFile->copy(PATH_DB_ABSOLUTE, $strArchiveTestFile2, # Source file
PATH_DB_ABSOLUTE, $strSourceFile, # Destination file
false, # Source is not compressed
false, # Destination is not compressed
undef, undef, undef, # Unused params
true); # Create path if it does not exist
BackRestTestCommon_Execute($strCommand . " ${strSourceFile}", undef, undef, undef,
ERROR_ARCHIVE_DUPLICATE);
@ -1650,7 +1663,7 @@ sub BackRestTestBackup_Test
{
my $strDuplicateWal =
($bRemote ? BackRestTestCommon_LocalPathGet() : BackRestTestCommon_RepoPathGet()) .
"/archive/${strStanza}/out/${strArchiveFile}-1c7e00fd09b9dd11fc2966590b3e3274645dd031";
"/archive/${strStanza}/out/${strArchiveFile}-4518a0fdf41d796760b384a358270d4682589820";
unlink ($strDuplicateWal)
or confess "unable to remove duplicate WAL segment created for testing: ${strDuplicateWal}";

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

@ -1153,7 +1153,7 @@ sub BackRestTestFile_Test
if ($iLarge == 1)
{
$strSourceHash = 'c2e63b6a49d53a53d6df1aa6b70c7c16747ca099';
$strSourceHash = '4518a0fdf41d796760b384a358270d4682589820';
$iSourceSize = 16777216;
}
elsif ($iLarge == 2)

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

@ -41,6 +41,20 @@ run 001 - rmt 0, cmp 0, arc_async 0
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
@ -113,6 +127,20 @@ run 001 - rmt 0, cmp 0, arc_async 0
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
@ -185,5 +213,19 @@ run 001 - rmt 0, cmp 0, arc_async 0
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads

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

@ -74,6 +74,31 @@ run 002 - rmt 0, cmp 0, arc_async 1
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
@ -211,6 +236,31 @@ run 002 - rmt 0, cmp 0, arc_async 1
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
@ -348,5 +398,30 @@ run 002 - rmt 0, cmp 0, arc_async 1
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads

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

@ -41,6 +41,20 @@ run 003 - rmt 0, cmp 1, arc_async 0
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
@ -113,6 +127,20 @@ run 003 - rmt 0, cmp 1, arc_async 0
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
@ -185,5 +213,19 @@ run 003 - rmt 0, cmp 1, arc_async 0
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads

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

@ -74,6 +74,31 @@ run 004 - rmt 0, cmp 1, arc_async 1
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
@ -211,6 +236,31 @@ run 004 - rmt 0, cmp 1, arc_async 1
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
@ -348,5 +398,30 @@ run 004 - rmt 0, cmp 1, arc_async 1
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
DEBUG: File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
DEBUG: File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
DEBUG: File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads

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

@ -26,7 +26,17 @@ run 005 - rmt 1, cmp 0, arc_async 0
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
ERROR: [120]: : WAL segment 000000010000000100000001 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
@ -75,7 +85,17 @@ run 005 - rmt 1, cmp 0, arc_async 0
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
ERROR: [120]: : WAL segment 000000010000000100000005 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
@ -124,5 +144,15 @@ run 005 - rmt 1, cmp 0, arc_async 0
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
ERROR: [120]: : WAL segment 000000010000000100000009 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads

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

@ -60,7 +60,28 @@ run 006 - rmt 1, cmp 0, arc_async 1
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
ERROR: [120]: : WAL segment 000000010000000100000001 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
@ -174,7 +195,28 @@ run 006 - rmt 1, cmp 0, arc_async 1
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
ERROR: [120]: : WAL segment 000000010000000100000005 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
@ -288,5 +330,26 @@ run 006 - rmt 1, cmp 0, arc_async 1
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
ERROR: [120]: : WAL segment 000000010000000100000009 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads

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

@ -26,7 +26,17 @@ run 007 - rmt 1, cmp 1, arc_async 0
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
ERROR: [120]: : WAL segment 000000010000000100000001 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
@ -75,7 +85,17 @@ run 007 - rmt 1, cmp 1, arc_async 0
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
ERROR: [120]: : WAL segment 000000010000000100000005 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
@ -124,5 +144,15 @@ run 007 - rmt 1, cmp 1, arc_async 0
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
ERROR: [120]: : WAL segment 000000010000000100000009 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads

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

@ -60,7 +60,28 @@ run 008 - rmt 1, cmp 1, arc_async 1
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
ERROR: [120]: : WAL segment 000000010000000100000001 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000001
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
@ -174,7 +195,28 @@ run 008 - rmt 1, cmp 1, arc_async 1
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
ERROR: [120]: : WAL segment 000000010000000100000005 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000005
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
@ -288,5 +330,26 @@ run 008 - rmt 1, cmp 1, arc_async 1
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
ERROR: [120]: : WAL segment 000000010000000100000009 already exists in the archive
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
DEBUG: File->copy: local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: 1 WAL segments were transferred, calling Archive->xfer() again
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
DEBUG: no archive logs to be copied to backup
DEBUG: no more WAL segments to transfer - exiting
DEBUG: safe exit called, terminating threads
> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
------------------------------------------------------------------------------------------------------------------------------------
INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009 asynchronously
DEBUG: File->copy: local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
DEBUG: File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
INFO: No fork on archive local for TESTING
INFO: starting async archive-push
DEBUG: File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
INFO: archive to be copied to backup total 1, size 16MB
DEBUG: archive 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
DEBUG: Archive->pushCheck: backup:archive:000000010000000100000009
DEBUG: File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
DEBUG: safe exit called, terminating threads