def show_server(args):
"""
Show all configuration parameters for the specified servers
"""
servers = get_server_list(args)
for name in sorted(servers):
server = servers[name]
# Skip the server (apply general rule)
if not manage_server_command(server,
name,
skip_inactive=False,
skip_disabled=False,
disabled_is_error=False):
continue
# If the server has been manually disabled
if not server.config.active:
name += " (inactive)"
# If server has configuration errors
elif server.config.disabled:
name += " (WARNING: disabled)"
output.init('show_server', name)
with closing(server):
server.show()
output.close_and_exit()
def cron(keep_descriptors=False):
"""
Run maintenance tasks (global command)
"""
# Skip inactive and temporarily disabled servers
servers = get_server_list(skip_inactive=True, skip_disabled=True)
for name in sorted(servers):
server = servers[name]
# Exception: manage_server_command is not invoked here
# Normally you would call manage_server_command to check if the
# server is None and to report inactive and disabled servers,
# but here we have only active and well configured servers.
try:
server.cron(keep_descriptors=keep_descriptors)
except Exception:
# A cron should never raise an exception, so this code
# should never be executed. However, it is here to protect
# unrelated servers in case of unexpected failures.
output.exception(
"Unable to run cron on server '{}',please look in the frabit log file for more details."
.format(name))
output.close_and_exit()
def list_server(minimal=False):
"""
List available servers, with useful information
"""
# Get every server, both inactive and temporarily disabled
servers = get_server_list()
for name in sorted(servers):
server = servers[name]
# Exception: manage_server_command is not invoked here
# Normally you would call manage_server_command to check if the
# server is None and to report inactive and disabled servers, but here
# we want all servers and the server cannot be None
output.init('list_server', name, minimal=minimal)
description = server.config.description or ''
# If the server has been manually disabled
if not server.config.active:
description += " (inactive)"
# If server has configuration errors
elif server.config.disabled:
description += " (WARNING: disabled)"
# If server is a passive node
if server.replica_node:
description += ' (Passive)'
output.result('list_server', name, description)
output.close_and_exit()
def backup(args):
"""
Perform a full backup for the given server (supports 'all')
"""
servers = get_server_list(args, skip_inactive=True, skip_passive=True)
for name in sorted(servers):
server = servers[name]
# Skip the server (apply general rule)
if not manage_server_command(server, name):
continue
if args.reuse_backup is not None:
server.config.reuse_backup = args.reuse_backup
if args.retry_sleep is not None:
server.config.basebackup_retry_sleep = args.retry_sleep
if args.retry_times is not None:
server.config.basebackup_retry_times = args.retry_times
if hasattr(args, 'immediate_checkpoint'):
server.config.immediate_checkpoint = args.immediate_checkpoint
if args.jobs is not None:
server.config.parallel_jobs = args.jobs
if hasattr(args, 'bwlimit'):
server.config.bandwidth_limit = args.bwlimit
with closing(server):
server.backup(wait=args.wait, wait_timeout=args.wait_timeout)
output.close_and_exit()
def get_wal(args):
"""
Retrieve WAL_NAME file from SERVER_NAME archive.
The content will be streamed on standard output unless
the --output-directory option is specified.
"""
server = get_server(args, inactive_is_error=True)
if getattr(args, 'test', None):
output.info("Ready to retrieve WAL files from the server %s",
server.config.name)
return
# Retrieve optional arguments. If an argument is not specified,
# the namespace doesn't contain it due to SUPPRESS default.
# In that case we pick 'None' using getattr third argument.
compression = getattr(args, 'compression', None)
output_directory = getattr(args, 'output_directory', None)
peek = getattr(args, 'peek', None)
with closing(server):
server.get_wal(args.wal_name,
compression=compression,
output_directory=output_directory,
peek=peek,
partial=args.partial)
output.close_and_exit()
def check(args):
"""
Check if the server configuration is working.
This command returns success if every checks pass,
or failure if any of these fails
"""
if args.nagios:
output.set_output_writer(output.NagiosOutputWriter())
servers = get_server_list(args)
for name in sorted(servers):
server = servers[name]
# Validate the returned server
if not manage_server_command(server,
name,
skip_inactive=False,
skip_disabled=False,
disabled_is_error=False):
continue
output.init('check', name, server.config.active,
server.config.disabled)
with closing(server):
server.check()
output.close_and_exit()
def diagnose():
"""
Diagnostic command (for support and problems detection purpose)
"""
# Get every server (both inactive and temporarily disabled)
servers = get_server_list(on_error_stop=False, suppress_error=True)
# errors list with duplicate paths between servers
errors_list = frabit.__config__.servers_msg_list
frabit.diagnose.exec_diagnose(servers, errors_list)
output.close_and_exit()
def show_backup(args):
"""
This method shows a single backup information
"""
server = get_server(args)
# Retrieves the backup
backup_info = parse_backup_id(server, args)
with closing(server):
server.show_backup(backup_info)
output.close_and_exit()
def archive_wal(args):
"""
Execute maintenance operations on WAL files for a given server.
This command processes any incoming WAL files for the server
and archives them along the catalogue.
"""
server = get_server(args)
with closing(server):
server.archive_wal()
output.close_and_exit()
def sync_wals(args):
"""
Command that synchronises WAL files from a master to a passive node
"""
server = get_server(args)
try:
server.sync_wals()
except SyncError as e:
# Catch SyncError exceptions and output only the error message,
# preventing from logging the stack trace
output.error(e)
output.close_and_exit()
def delete(args):
"""
Delete a backup
"""
server = get_server(args)
# Retrieves the backup
backup_id = parse_backup_id(server, args)
with closing(server):
if not server.delete_backup(backup_id):
output.error("Cannot delete backup (%s %s)" %
(server.config.name, backup_id))
output.close_and_exit()
def switch_wal(args):
"""
Execute the switch-wal command on the target server
"""
servers = get_server_list(args, skip_inactive=True)
for name in sorted(servers):
server = servers[name]
# Skip the server (apply general rule)
if not manage_server_command(server, name):
continue
with closing(server):
server.switch_wal(args.force, args.archive, args.archive_timeout)
output.close_and_exit()
def rebuild_xlogdb(args):
"""
Rebuild the WAL file database guessing it from the disk content.
"""
servers = get_server_list(args, skip_inactive=True)
for name in sorted(servers):
server = servers[name]
# Skip the server (apply general rule)
if not manage_server_command(server, name):
continue
with closing(server):
server.rebuild_xlogdb()
output.close_and_exit()
def replication_status(args):
"""
Shows live information and status of any streaming client
"""
servers = get_server_list(args, skip_inactive=True)
for name in sorted(servers):
server = servers[name]
# Skip the server (apply general rule)
if not manage_server_command(server, name):
continue
with closing(server):
output.init('replication_status', name, minimal=args.minimal)
server.replication_status(args.target)
output.close_and_exit()
def status(args):
"""
Shows live information and status of the MySQL server
"""
servers = get_server_list(args, skip_inactive=True)
for name in sorted(servers):
server = servers[name]
# Skip the server (apply general rule)
if not manage_server_command(server, name):
continue
output.init('status', name)
with closing(server):
server.status()
output.close_and_exit()
def list_backup(args):
"""
List available backups for the given server (supports 'all')
"""
servers = get_server_list(args, skip_inactive=True)
for name in sorted(servers):
server = servers[name]
# Skip the server (apply general rule)
if not manage_server_command(server, name):
continue
output.init('list_backup', name, minimal=args.minimal)
with closing(server):
server.list_backups()
output.close_and_exit()
def check_backup(args):
"""
Make sure that all the required WAL files to check
the consistency of a physical backup (that is, from the
beginning to the end of the full backup) are correctly
archived. This command is automatically invoked by the
cron command and at the end of every backup operation.
"""
server = get_server(args)
# Retrieves the backup
backup_info = parse_backup_id(server, args)
with closing(server):
server.check_backup(backup_info)
output.close_and_exit()
def list_files(args):
"""
List all the files for a single backup
"""
server = get_server(args)
# Retrieves the backup
backup_info = parse_backup_id(server, args)
try:
for line in backup_info.get_list_of_files(args.target):
output.info(line, log=False)
except BinlogHasPurged as e:
output.error(
"invalid xlog segment name %r\n"
"HINT: Please run \"barman rebuild-xlogdb %s\" "
"to solve this issue", force_str(e), server.config.name)
output.close_and_exit()
def put_wal(args):
"""
Receive a WAL file from SERVER_NAME and securely store it in the incoming
directory. The file will be read from standard input in tar format.
"""
server = get_server(args, inactive_is_error=True)
if getattr(args, 'test', None):
output.info("Ready to accept WAL files for the server %s",
server.config.name)
return
try:
# Python 3.x
stream = sys.stdin.buffer
except AttributeError:
# Python 2.x
stream = sys.stdin
with closing(server):
server.put_wal(stream)
output.close_and_exit()
def sync_info(args):
"""
Output the internal synchronisation status.
Used to sync_backup with a passive node
"""
server = get_server(args)
try:
# if called with --primary option
if getattr(args, 'primary', False):
primary_info = server.primary_node_info(args.last_wal,
args.last_position)
output.info(json.dumps(primary_info, cls=FrabitEncoder, indent=4),
log=False)
else:
server.sync_status(args.last_wal, args.last_position)
except SyncError as e:
# Catch SyncError exceptions and output only the error message,
# preventing from logging the stack trace
output.error(e)
output.close_and_exit()
def parse_backup_id(server, args):
"""
Parses backup IDs including special words such as latest, oldest, etc.
Exit with error if the backup id doesn't exist.
:param Server server: server object to search for the required backup
:param args: command lien arguments namespace
:rtype: barman.infofile.LocalBackupInfo
"""
if args.backup_id in ('latest', 'last'):
backup_id = server.get_last_backup_id()
elif args.backup_id in ('oldest', 'first'):
backup_id = server.get_first_backup_id()
else:
backup_id = args.backup_id
backup_info = server.get_backup(backup_id)
if backup_info is None:
output.error("Unknown backup '%s' for server '%s'", args.backup_id,
server.config.name)
output.close_and_exit()
return backup_info
def receive_wal(args):
"""
Start a receive-wal process.
The process uses the streaming protocol to receive WAL files
from the PostgreSQL server.
"""
server = get_server(args)
if args.stop and args.reset:
output.error("--stop and --reset options are not compatible")
# If the caller requested to shutdown the receive-wal process deliver the
# termination signal, otherwise attempt to start it
elif args.stop:
server.kill('receive-wal')
elif args.create_slot:
with closing(server):
server.create_physical_repslot()
elif args.drop_slot:
with closing(server):
server.drop_repslot()
else:
with closing(server):
server.receive_wal(reset=args.reset)
output.close_and_exit()
def get_server(args,
skip_inactive=True,
skip_disabled=False,
skip_passive=False,
inactive_is_error=False,
on_error_stop=True,
suppress_error=False):
"""
Get a single server retrieving its configuration (wraps get_server_list())
Returns a Server object or None if the required server is unknown and
on_error_stop is False.
WARNING: this function modifies the 'args' parameter
:param args: an argparse namespace containing a single
server_name parameter
WARNING: the function modifies the content of this parameter
:param bool skip_inactive: do nothing if the server is inactive
:param bool skip_disabled: do nothing if the server is disabled
:param bool skip_passive: do nothing if the server is passive
:param bool inactive_is_error: treat inactive server as error
:param bool on_error_stop: stop if an error is found
:param bool suppress_error: suppress display of errors (e.g. diagnose)
:rtype: Server|None
"""
# This function must to be called with in a single-server context
name = args.server_name
assert isinstance(name, str)
# The 'all' special name is forbidden in this context
if name == 'all':
output.error("You cannot use 'all' in a single server context")
output.close_and_exit()
# The following return statement will never be reached
# but it is here for clarity
return None
# Builds a list from a single given name
args.server_name = [name]
# Skip_inactive is reset if inactive_is_error is set, because
# it needs to retrieve the inactive server to emit the error.
skip_inactive &= not inactive_is_error
# Retrieve the requested server
servers = get_server_list(args, skip_inactive, skip_disabled, skip_passive,
on_error_stop, suppress_error)
# The requested server has been excluded from get_server_list result
if len(servers) == 0:
output.close_and_exit()
# The following return statement will never be reached
# but it is here for clarity
return None
# retrieve the server object
server = servers[name]
# Apply standard validation control and skips
# the server if inactive or disabled, displaying standard
# error messages. If on_error_stop (default) exits
if not manage_server_command(server, name,
inactive_is_error) and \
on_error_stop:
output.close_and_exit()
# The following return statement will never be reached
# but it is here for clarity
return None
# Returns the filtered server
return server
def main():
"""
The main method of Frabit
"""
p = ArghParser(epilog='Frabit by Frabit (www.frabit.com)')
p.add_argument(
'-v',
'--version',
action='version',
version='{version}\n\nFrabit by Frabit (www.frabit.com)'.format(
version=frabit.__version__))
p.add_argument('-c',
'--config',
help='uses a configuration file (defaults: %s)' %
', '.join(frabit.config.Config.CONFIG_FILES),
default=SUPPRESS)
p.add_argument('--color',
'--colour',
help='Whether to use colors in the output',
choices=['never', 'always', 'auto'],
default='auto')
p.add_argument('--log-level',
help='Override the default log level',
choices=list(get_log_levels()),
default=SUPPRESS)
p.add_argument('-q', '--quiet', help='be quiet', action='store_true')
p.add_argument('-d', '--debug', help='debug output', action='store_true')
p.add_argument('-f',
'--format',
help='output format',
choices=output.AVAILABLE_WRITERS.keys(),
default=output.DEFAULT_WRITER)
p.add_commands([
archive_wal,
backup,
check,
check_backup,
cron,
delete,
diagnose,
get_wal,
list_backup,
list_files,
list_server,
put_wal,
rebuild_xlogdb,
receive_wal,
recover,
show_backup,
show_server,
replication_status,
status,
switch_wal,
switch_xlog,
sync_info,
sync_backup,
sync_wals,
])
# noinspection PyBroadException
try:
p.dispatch(pre_call=global_config)
except KeyboardInterrupt:
msg = "Process interrupted by user (KeyboardInterrupt)"
output.error(msg)
except Exception as e:
msg = "%s\nSee log file for more details." % e
output.exception(msg)
# cleanup output API and exit honoring output.error_occurred and
# output.error_exit_code
output.close_and_exit()
def recover(args):
"""
Recover a server at a given time, name, LSN or xid
"""
server = get_server(args)
# Retrieves the backup
backup_id = parse_backup_id(server, args)
if backup_id.status not in BackupInfo.STATUS_COPY_DONE:
output.error("Cannot recover from backup '{id}' of server '{name}': "
"backup status is not DONE".format(
id=args.backup_id, name=server.config.name))
output.close_and_exit()
# decode the tablespace relocation rules
tablespaces = {}
if args.tablespace:
for rule in args.tablespace:
try:
tablespaces.update([rule.split(':', 1)])
except ValueError:
output.error(
"Invalid tablespace relocation rule '%s'\n"
"HINT: The valid syntax for a relocation rule is "
"NAME:LOCATION", rule)
output.close_and_exit()
# validate the rules against the tablespace list
valid_tablespaces = []
if backup_id.tablespaces:
valid_tablespaces = [
tablespace_data.name for tablespace_data in backup_id.tablespaces
]
for item in tablespaces:
if item not in valid_tablespaces:
output.error(
"Invalid tablespace name '%s'\n"
"HINT: Please use any of the following "
"tablespaces: %s", item, ', '.join(valid_tablespaces))
output.close_and_exit()
# explicitly disallow the rsync remote syntax (common mistake)
if ':' in args.destination_directory:
output.error(
"The destination directory parameter "
"cannot contain the ':' character\n"
"HINT: If you want to do a remote recovery you have to use "
"the --remote-ssh-command option")
output.close_and_exit()
if args.retry_sleep is not None:
server.config.basebackup_retry_sleep = args.retry_sleep
if args.retry_times is not None:
server.config.basebackup_retry_times = args.retry_times
if hasattr(args, 'get_wal'):
if args.get_wal:
server.config.recovery_options.add(RecoveryOptions.GET_WAL)
else:
server.config.recovery_options.remove(RecoveryOptions.GET_WAL)
if args.jobs is not None:
server.config.parallel_jobs = args.jobs
if hasattr(args, 'bwlimit'):
server.config.bandwidth_limit = args.bwlimit
target_options = [
'target_tli', 'target_time', 'target_xid', 'target_lsn', 'target_name',
'target_immediate'
]
specified_target_options = len(
[option for option in target_options if getattr(args, option)])
if specified_target_options > 1:
output.error(
"You cannot specify multiple targets for the recovery operation")
output.close_and_exit()
if hasattr(args, 'network_compression'):
if args.network_compression and args.remote_ssh_command is None:
output.error("Network compression can only be used with "
"remote recovery.\n"
"HINT: If you want to do a remote recovery "
"you have to use the --remote-ssh-command option")
output.close_and_exit()
server.config.network_compression = args.network_compression
with closing(server):
try:
server.recover(backup_id,
args.destination_directory,
tablespaces=tablespaces,
target_tli=args.target_tli,
target_time=args.target_time,
target_xid=args.target_xid,
target_lsn=args.target_lsn,
target_name=args.target_name,
target_immediate=args.target_immediate,
exclusive=args.exclusive,
remote_command=args.remote_ssh_command,
target_action=getattr(args, 'target_action', None),
standby_mode=getattr(args, 'standby_mode', None))
except RecoveryException as exc:
output.error(force_str(exc))
output.close_and_exit()
def get_server_list(args=None,
skip_inactive=False,
skip_disabled=False,
skip_passive=False,
on_error_stop=True,
suppress_error=False):
"""
Get the server list from the configuration
If args the parameter is None or arg.server_name is ['all']
returns all defined servers
:param args: an argparse namespace containing a list server_name parameter
:param bool skip_inactive: skip inactive servers when 'all' is required
:param bool skip_disabled: skip disabled servers when 'all' is required
:param bool skip_passive: skip passive servers when 'all' is required
:param bool on_error_stop: stop if an error is found
:param bool suppress_error: suppress display of errors (e.g. diagnose)
:rtype: dict[str,Server]
"""
server_dict = {}
# This function must to be called with in a multiple-server context
assert not args or isinstance(args.server_name, list)
# Generate the list of servers (required for global errors)
available_servers = frabit.__config__.server_names()
# Get a list of configuration errors from all the servers
global_error_list = frabit.__config__.servers_msg_list
# Global errors have higher priority
if global_error_list:
# Output the list of global errors
if not suppress_error:
for error in global_error_list:
output.error(error)
# If requested, exit on first error
if on_error_stop:
output.close_and_exit()
# The following return statement will never be reached
# but it is here for clarity
return {}
# Handle special 'all' server cases
# - args is None
# - 'all' special name
if not args or 'all' in args.server_name:
# When 'all' is used, it must be the only specified argument
if args and len(args.server_name) != 1:
output.error("You cannot use 'all' with other server names")
servers = available_servers
else:
# Put servers in a set, so multiple occurrences are counted only once
servers = set(args.server_name)
# Loop through all the requested servers
for server in servers:
conf = frabit.__config__.get_server(server)
if conf is None:
# Unknown server
server_dict[server] = None
else:
server_object = Server(conf)
# Skip inactive servers, if requested
if skip_inactive and not server_object.config.active:
output.info("Skipping inactive server '%s'" % conf.name)
continue
# Skip disabled servers, if requested
if skip_disabled and server_object.config.disabled:
output.info("Skipping temporarily disabled server '%s'" %
conf.name)
continue
# Skip passive nodes, if requested
if skip_passive and server_object.replica_node:
output.info("Skipping passive server '%s'", conf.name)
continue
server_dict[server] = server_object
return server_dict
