1
0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2024-12-14 10:13:05 +02:00
pgbackrest/bin/pg_backrest

227 lines
9.1 KiB
Perl
Executable File

#!/usr/bin/perl
####################################################################################################################################
# pgBackRest - Simple PostgreSQL Backup and Restore
####################################################################################################################################
####################################################################################################################################
# Perl includes
####################################################################################################################################
use strict;
use warnings FATAL => qw(all);
use Carp qw(confess);
# Convert die to confess to capture the stack trace
$SIG{__DIE__} = sub { Carp::confess @_ };
use File::Basename qw(dirname);
use Scalar::Util qw(blessed);
use lib dirname($0) . '/../lib';
use BackRest::Archive;
use BackRest::Common::Exception;
use BackRest::Common::Exit;
use BackRest::Common::Lock;
use BackRest::Common::Log;
use BackRest::Config::Config;
use BackRest::File;
####################################################################################################################################
# START EVAL BLOCK TO CATCH ERRORS AND STOP THREADS
####################################################################################################################################
eval
{
################################################################################################################################
# Load command line parameters and config
################################################################################################################################
my $bConfigResult = configLoad();
# Display help and version
if (commandTest(CMD_HELP) || commandTest(CMD_VERSION))
{
# Load module dynamically
require BackRest::Config::ConfigHelp;
BackRest::Config::ConfigHelp->import();
# Generate help and exit
configHelp($ARGV[1], $ARGV[2], commandTest(CMD_VERSION), $bConfigResult);
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))
{
# Set log levels
logLevelSet(OFF, REMOTE);
# Load module dynamically
require BackRest::Protocol::RemoteMinion;
BackRest::Protocol::RemoteMinion->import();
# 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),
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
exitSafe($oRemote->process());
}
# Set the log levels
logLevelSet(optionGet(OPTION_LOG_LEVEL_FILE), optionGet(OPTION_LOG_LEVEL_CONSOLE));
# Log the command start
commandStart();
################################################################################################################################
# Process archive commands
################################################################################################################################
if (commandTest(CMD_ARCHIVE_PUSH) || commandTest(CMD_ARCHIVE_GET))
{
exitSafe(new BackRest::Archive()->process());
}
################################################################################################################################
# Process start/stop commands
################################################################################################################################
if (commandTest(CMD_START))
{
lockStart();
exitSafe(0);
}
elsif (commandTest(CMD_STOP))
{
lockStop();
exitSafe(0);
}
################################################################################################################################
# Process info command
################################################################################################################################
if (commandTest(CMD_INFO))
{
# Load module dynamically
require BackRest::Info;
BackRest::Info->import();
exitSafe(new BackRest::Info()->process());
}
################################################################################################################################
# Acquire the command lock
################################################################################################################################
lockAcquire(commandGet());
################################################################################################################################
# Open the log file
################################################################################################################################
logFileSet(optionGet(OPTION_REPO_PATH) . '/log/' . optionGet(OPTION_STANZA) . '-' . lc(commandGet()));
################################################################################################################################
# Create the thread group that will be used for parallel processing
################################################################################################################################
if (optionTest(OPTION_THREAD_MAX) && optionGet(OPTION_THREAD_MAX) > 1)
{
# Set local thread-max so exitSafe knows to stop them on exit
exitInit(optionGet(OPTION_THREAD_MAX));
# Load module dynamically
require BackRest::Protocol::ThreadGroup;
BackRest::Protocol::ThreadGroup->import();
threadGroupCreate();
}
################################################################################################################################
# RESTORE
################################################################################################################################
if (commandTest(CMD_RESTORE))
{
if (optionRemoteTypeTest(DB))
{
confess &log(ASSERT, 'restore command must be performed locally on the db server');
}
# Load module dynamically
require BackRest::Restore;
BackRest::Restore->import();
# Do the restore
new BackRest::Restore()->process();
exitSafe(0);
}
else
{
############################################################################################################################
# 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', ERROR_HOST_INVALID);
}
############################################################################################################################
# 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();
}
}
lockRelease();
exitSafe(0);
};
####################################################################################################################################
# CHECK FOR ERRORS AND STOP THREADS
####################################################################################################################################
if ($@)
{
my $oMessage = $@;
# If a backrest exception then return the code - don't confess
if (blessed($oMessage) && $oMessage->isa('BackRest::Common::Exception'))
{
exitSafe($oMessage->code());
}
exitSafe(-1);
confess $oMessage;
}