Fuxino
7091118663
An unknown hostname, a refused connection or an unreachable server raise OSError (socket.gaierror, NoValidConnectionsError), which paramiko.SSHException doesn't cover, so the program crashed with a traceback. Log the error and exit with code 5 instead.
971 lines
32 KiB
Python
Executable File
971 lines
32 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
"""
|
|
A simple python script that calls rsync to perform a backup
|
|
|
|
Parameters can be specified on the command line or using a configuration file
|
|
Backup to a remote server is also supported (experimental)
|
|
|
|
Classes:
|
|
MyFormatter
|
|
Backup
|
|
"""
|
|
|
|
# Avoid evaluating annotations at definition time, as they reference optional modules (paramiko)
|
|
from __future__ import annotations
|
|
|
|
# Import libraries
|
|
import sys
|
|
import os
|
|
import pwd
|
|
from typing import Callable, List, Optional, ParamSpec, TypeVar, Union
|
|
import warnings
|
|
from functools import wraps
|
|
from shutil import rmtree, which
|
|
import shlex
|
|
import argparse
|
|
import configparser
|
|
import logging
|
|
from logging import StreamHandler
|
|
from timeit import default_timer
|
|
from subprocess import Popen, PIPE, STDOUT
|
|
from datetime import datetime
|
|
from tempfile import mkstemp
|
|
from getpass import GetPassWarning, getpass
|
|
from glob import glob
|
|
|
|
try:
|
|
import paramiko
|
|
except ImportError:
|
|
pass
|
|
|
|
try:
|
|
from systemd import journal
|
|
except ImportError:
|
|
journal = None
|
|
|
|
try:
|
|
import dbus
|
|
except ImportError:
|
|
dbus = None
|
|
|
|
|
|
logging.getLogger().setLevel(logging.DEBUG)
|
|
logger = logging.getLogger(os.path.basename(__file__))
|
|
c_handler = StreamHandler()
|
|
|
|
c_handler.setLevel(logging.INFO)
|
|
c_format = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
|
|
c_handler.setFormatter(c_format)
|
|
logger.addHandler(c_handler)
|
|
|
|
if journal:
|
|
j_handler = journal.JournalHandler()
|
|
j_handler.setLevel(logging.INFO)
|
|
j_format = logging.Formatter('%(levelname)s - %(message)s')
|
|
j_handler.setFormatter(j_format)
|
|
logger.addHandler(j_handler)
|
|
|
|
P = ParamSpec('P')
|
|
R = TypeVar('R')
|
|
|
|
|
|
def timing(func: Callable[P, R]) -> Callable[P, R]:
|
|
"""Decorator to measure execution time of a function
|
|
|
|
Parameters:
|
|
func: Function to decorate
|
|
"""
|
|
@wraps(func)
|
|
def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
|
|
start = default_timer()
|
|
|
|
value = func(*args, **kwargs)
|
|
|
|
end = default_timer()
|
|
|
|
logger.info('Elapsed time: %.3f seconds', end - start)
|
|
|
|
return value
|
|
|
|
return wrapper
|
|
|
|
|
|
class MyFormatter(argparse.RawTextHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
|
|
"""Custom format for argparse help text"""
|
|
|
|
|
|
class Backup:
|
|
"""Main class defining parameters and functions for performing backup
|
|
|
|
Attributes:
|
|
inputs: list
|
|
Files and folders that will be backup up
|
|
output: str
|
|
Path where the backup will be saved
|
|
exclude: list
|
|
List of files/folders/patterns to exclude from backup
|
|
options: str
|
|
String representing main backup options for rsync
|
|
keep: int
|
|
Number of old backup to preserve
|
|
ssh_host: str
|
|
Hostname of server (for remote backup)
|
|
ssh_user: str
|
|
Username for server login (for remote backup)
|
|
ssh_keyfile: str
|
|
Location of ssh key
|
|
remote_sudo: bool
|
|
Run remote rsync with sudo
|
|
remove_before: bool
|
|
Indicate if removing old backups will be performed before copying files
|
|
|
|
Methods:
|
|
check_params():
|
|
Check if parameters for the backup are valid
|
|
define_backup_dir():
|
|
Define the actual backup dir
|
|
remove_old_backups():
|
|
Remove old backups if there are more than indicated by 'keep'
|
|
find_last_backup():
|
|
Get path of last backup (from last_backup symlink) for rsync --link-dest
|
|
run():
|
|
Perform the backup
|
|
"""
|
|
|
|
def __init__(self, inputs: List[str], output: str, exclude: List[str], keep: int, options: str,
|
|
ssh_host: Optional[str] = None, ssh_user: Optional[str] = None, ssh_keyfile: Optional[str] = None,
|
|
remote_sudo: bool = False, remove_before: bool = False, verbose: bool = False) -> None:
|
|
self.inputs = inputs
|
|
self.output = output
|
|
self.exclude = exclude
|
|
self.options = options
|
|
self.keep = keep
|
|
self.ssh_host = ssh_host
|
|
self.ssh_user = ssh_user
|
|
self.ssh_keyfile = ssh_keyfile
|
|
self.remote_sudo = remote_sudo
|
|
self._remove_before = remove_before
|
|
self._verbose = verbose
|
|
self._last_backup = ''
|
|
self._server = ''
|
|
self._output_dir = ''
|
|
self._inputs_path = ''
|
|
self._exclude_path = ''
|
|
self._remote = False
|
|
self._ssh = None
|
|
self._password_auth = False
|
|
self._password = None
|
|
self._removed_count = 0
|
|
|
|
def check_params(self, homedir: str = '') -> int:
|
|
"""Check if parameters for the backup are valid"""
|
|
|
|
if self.inputs is None or len(self.inputs) == 0:
|
|
logger.info(
|
|
'No existing files or directories specified for backup. Nothing to do')
|
|
|
|
return 1
|
|
|
|
if self.output is None:
|
|
logger.critical(
|
|
'No output path specified. Use -o argument or specify output path in configuration file')
|
|
|
|
return 2
|
|
|
|
if self.ssh_host is not None and self.ssh_user is not None:
|
|
self._remote = True
|
|
|
|
if self._remote:
|
|
try:
|
|
self._ssh = self._ssh_connect(homedir)
|
|
except OSError as e:
|
|
# Unknown hostname, connection refused, unreachable host or timeout
|
|
logger.critical('Can\'t connect to the server %s', self.ssh_host)
|
|
logger.critical(e)
|
|
|
|
return 5
|
|
|
|
if self._ssh is None:
|
|
return 5
|
|
|
|
_, stdout, _ = self._ssh.exec_command(
|
|
f'if [ -d "{self.output}" ]; then echo "ok"; fi')
|
|
|
|
output = stdout.read().decode('utf-8').strip()
|
|
|
|
if output != 'ok':
|
|
logger.critical('Output path for backup does not exist')
|
|
|
|
return 2
|
|
else:
|
|
if not os.path.isdir(self.output):
|
|
logger.critical('Output path for backup does not exist')
|
|
|
|
return 2
|
|
|
|
self.output = os.path.abspath(self.output)
|
|
|
|
if self.keep is None:
|
|
self.keep = -1
|
|
|
|
return 0
|
|
|
|
# Function to create the actual backup directory
|
|
def define_backup_dir(self) -> None:
|
|
"""Define the actual backup dir"""
|
|
# Avoid ':', which is not allowed on FAT/exFAT filesystems.
|
|
# Backups created with the old format ('%Y-%m-%d %H:%M:%S') still sort correctly
|
|
now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
|
|
self._output_dir = f'{self.output}/simple_backup/{now}'
|
|
|
|
if self._remote:
|
|
self._server = f'{self.ssh_user}@{self.ssh_host}:'
|
|
|
|
def remove_old_backups(self) -> None:
|
|
"""Remove old backups if there are more than indicated by 'keep'"""
|
|
|
|
if self._remote:
|
|
assert self._ssh is not None
|
|
|
|
_, stdout, _ = self._ssh.exec_command(
|
|
f'ls {self.output}/simple_backup')
|
|
|
|
dirs = stdout.read().decode('utf-8').strip().split('\n')
|
|
|
|
n_backup = len(dirs)
|
|
|
|
if not self._remove_before:
|
|
n_backup -= 1
|
|
|
|
count = 0
|
|
|
|
if n_backup > self.keep:
|
|
logger.info('Removing old backups...')
|
|
dirs.sort()
|
|
|
|
for i in range(n_backup - self.keep):
|
|
if self.remote_sudo:
|
|
_, _, stderr = self._ssh.exec_command(
|
|
f'sudo rm -r "{self.output}/simple_backup/{dirs[i]}"')
|
|
else:
|
|
_, _, stderr = self._ssh.exec_command(
|
|
f'rm -r "{self.output}/simple_backup/{dirs[i]}"')
|
|
|
|
err = stderr.read().decode('utf-8').strip().split('\n')[0]
|
|
|
|
if err != '':
|
|
logger.error(
|
|
'Error while removing backup %s.', {dirs[i]})
|
|
logger.error(err)
|
|
else:
|
|
count += 1
|
|
else:
|
|
try:
|
|
dirs = os.listdir(f'{self.output}/simple_backup')
|
|
except FileNotFoundError:
|
|
return
|
|
|
|
n_backup = len(dirs)
|
|
|
|
if not self._remove_before:
|
|
n_backup -= 1
|
|
|
|
count = 0
|
|
|
|
if n_backup > self.keep:
|
|
logger.info('Removing old backups...')
|
|
dirs.sort()
|
|
|
|
for i in range(n_backup - self.keep):
|
|
try:
|
|
rmtree(f'{self.output}/simple_backup/{dirs[i]}')
|
|
count += 1
|
|
except FileNotFoundError:
|
|
logger.error(
|
|
'Error while removing backup %s. Directory not found', dirs[i])
|
|
except PermissionError:
|
|
logger.error(
|
|
'Error while removing backup %s. Permission denied', dirs[i])
|
|
|
|
self._removed_count = count
|
|
|
|
if count == 1:
|
|
logger.info('Removed %d backup', count)
|
|
elif count > 1:
|
|
logger.info('Removed %d backups', count)
|
|
|
|
def find_last_backup(self) -> None:
|
|
"""Get path of last backup (from last_backup symlink) for rsync --link-dest"""
|
|
|
|
if self._remote:
|
|
if self._ssh is None:
|
|
logger.critical('SSH connection to server failed')
|
|
sys.exit(5)
|
|
|
|
_, stdout, _ = self._ssh.exec_command(
|
|
f'find {self.output}/simple_backup/ -mindepth 1 -maxdepth 1 -type d | sort')
|
|
output = stdout.read().decode('utf-8').strip().split('\n')
|
|
|
|
if output[-1] != '':
|
|
self._last_backup = output[-1]
|
|
else:
|
|
logger.info('No previous backups available')
|
|
else:
|
|
try:
|
|
dirs = sorted([f.path for f in os.scandir(
|
|
f'{self.output}/simple_backup') if f.is_dir(follow_symlinks=False)])
|
|
except FileNotFoundError:
|
|
logger.info('No previous backups available')
|
|
|
|
return
|
|
except PermissionError:
|
|
logger.critical(
|
|
'Cannot access the backup directory. Permission denied')
|
|
|
|
_notify('Backup failed (check log for details)')
|
|
|
|
sys.exit(3)
|
|
|
|
try:
|
|
self._last_backup = dirs[-1]
|
|
except IndexError:
|
|
logger.info('No previous backups available')
|
|
|
|
def _ssh_connect(self, homedir: str = '') -> Optional[paramiko.client.SSHClient]:
|
|
try:
|
|
ssh = paramiko.SSHClient()
|
|
except NameError:
|
|
logger.error('Install paramiko for ssh support')
|
|
|
|
return None
|
|
|
|
try:
|
|
ssh.load_host_keys(filename=f'{homedir}/.ssh/known_hosts')
|
|
except FileNotFoundError:
|
|
logger.warning('Cannot find file %s/.ssh/known_hosts', homedir)
|
|
|
|
ssh.set_missing_host_key_policy(paramiko.WarningPolicy())
|
|
|
|
try:
|
|
# WarningPolicy emits a UserWarning for unknown host keys
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('error', UserWarning)
|
|
ssh.connect(self.ssh_host, username=self.ssh_user)
|
|
|
|
return ssh
|
|
except UserWarning:
|
|
k = input(
|
|
f'Unknown key for host {self.ssh_host}. Continue anyway? (Y/N) ')
|
|
|
|
if k[0].upper() == 'Y':
|
|
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
|
|
else:
|
|
return None
|
|
except paramiko.BadHostKeyException as e:
|
|
logger.critical('Can\'t connect to the server.')
|
|
logger.critical(e)
|
|
|
|
return None
|
|
except paramiko.SSHException:
|
|
pass
|
|
|
|
try:
|
|
ssh.connect(self.ssh_host, username=self.ssh_user)
|
|
|
|
return ssh
|
|
except paramiko.SSHException:
|
|
pass
|
|
|
|
if self.ssh_keyfile is None:
|
|
try:
|
|
# Fail instead of reading the password with echo if no terminal is available
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('error', GetPassWarning)
|
|
password = getpass(
|
|
f'{self.ssh_user}@{self.ssh_host}\'s password: ')
|
|
|
|
ssh.connect(self.ssh_host, username=self.ssh_user,
|
|
password=password)
|
|
|
|
self._password_auth = True
|
|
os.environ['SSHPASS'] = password
|
|
|
|
return ssh
|
|
except GetPassWarning as e:
|
|
logger.critical('Unable to get password')
|
|
logger.critical(e)
|
|
|
|
return None
|
|
except paramiko.SSHException as e:
|
|
logger.critical('Can\'t connect to the server.')
|
|
logger.critical(e)
|
|
|
|
return None
|
|
|
|
pkey = self._load_ssh_key()
|
|
|
|
if pkey is None:
|
|
return None
|
|
|
|
try:
|
|
ssh.connect(self.ssh_host, username=self.ssh_user, pkey=pkey)
|
|
except paramiko.SSHException:
|
|
logger.critical('SSH connection to server failed')
|
|
|
|
return None
|
|
|
|
return ssh
|
|
|
|
def _load_ssh_key(self) -> Optional[paramiko.PKey]:
|
|
try:
|
|
return paramiko.PKey.from_path(self.ssh_keyfile)
|
|
except TypeError:
|
|
# Raised when the key is encrypted and no passphrase was given
|
|
pass
|
|
except (OSError, ValueError, paramiko.UnknownKeyType) as e:
|
|
logger.critical('Unable to load SSH key %s', self.ssh_keyfile)
|
|
logger.critical(e)
|
|
|
|
return None
|
|
|
|
try:
|
|
# Fail instead of reading the passphrase with echo if no terminal is available
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter('error', GetPassWarning)
|
|
passphrase = getpass(
|
|
f'Enter passphrase for key \'{self.ssh_keyfile}\': ')
|
|
except GetPassWarning as e:
|
|
logger.critical('Unable to get passphrase')
|
|
logger.critical(e)
|
|
|
|
return None
|
|
|
|
try:
|
|
return paramiko.PKey.from_path(self.ssh_keyfile, passphrase.encode())
|
|
except (ValueError, paramiko.SSHException):
|
|
logger.critical('Unable to load SSH key %s, wrong passphrase?', self.ssh_keyfile)
|
|
|
|
return None
|
|
|
|
def _returncode_log(self, returncode: int) -> None:
|
|
match returncode:
|
|
case 2:
|
|
logger.error(
|
|
'Rsync error (return code 2) - Protocol incompatibility')
|
|
case 3:
|
|
logger.error(
|
|
'Rsync error (return code 3) - Errors selecting input/output files, dirs')
|
|
case 4:
|
|
logger.error(
|
|
'Rsync error (return code 4) - Requested action not supported')
|
|
case 5:
|
|
logger.error(
|
|
'Rsync error (return code 5) - Error starting client-server protocol')
|
|
case 10:
|
|
logger.error(
|
|
'Rsync error (return code 10) - Error in socket I/O')
|
|
case 11:
|
|
logger.error(
|
|
'Rsync error (return code 11) - Error in file I/O')
|
|
case 12:
|
|
logger.error(
|
|
'Rsync error (return code 12) - Error in rsync protocol data stream')
|
|
case 22:
|
|
logger.error(
|
|
'Rsync error (return code 22) - Error allocating core memory buffers')
|
|
case 23:
|
|
logger.warning(
|
|
'Rsync error (return code 23) - Partial transfer due to error')
|
|
case 24:
|
|
logger.warning(
|
|
'Rsync warning (return code 24) - Some source files vanished during the transfer')
|
|
case 30:
|
|
logger.error(
|
|
'Rsync error (return code 30) - Timeout in data send/receive')
|
|
case 35:
|
|
logger.error(
|
|
'Rsync error (return code 35) - Timeout waiting for daemon connection')
|
|
case _:
|
|
logger.error(
|
|
'Rsync error (return code %d) - Check rsync(1) for details', returncode)
|
|
|
|
# Function to read configuration file
|
|
@timing
|
|
def run(self) -> int:
|
|
"""Perform the backup"""
|
|
|
|
try:
|
|
return self._run()
|
|
finally:
|
|
self._remove_temp_files()
|
|
|
|
def _remove_temp_files(self) -> None:
|
|
for path in [self._inputs_path, self._exclude_path]:
|
|
if path != '':
|
|
try:
|
|
os.remove(path)
|
|
except FileNotFoundError:
|
|
pass
|
|
|
|
def _run(self) -> int:
|
|
logger.info('Starting backup...')
|
|
|
|
_notify('Starting backup...')
|
|
|
|
self.define_backup_dir()
|
|
|
|
fd, self._inputs_path = mkstemp(prefix='tmp_inputs', text=True)
|
|
count = 0
|
|
|
|
with os.fdopen(fd, 'w', encoding='utf-8') as fp:
|
|
for i in self.inputs:
|
|
if not os.path.exists(i):
|
|
logger.warning('Input %s not found. Skipping', i)
|
|
else:
|
|
# rsync reads --files-from paths relative to the source ('/')
|
|
fp.write(os.path.abspath(i))
|
|
fp.write('\n')
|
|
count += 1
|
|
|
|
if count == 0:
|
|
logger.info(
|
|
'No existing files or directories specified for backup. Nothing to do')
|
|
|
|
_notify('Backup finished. No files copied')
|
|
|
|
return 1
|
|
|
|
fd, self._exclude_path = mkstemp(prefix='tmp_exclude', text=True)
|
|
|
|
with os.fdopen(fd, 'w', encoding='utf-8') as fp:
|
|
if self.exclude is not None:
|
|
for e in self.exclude:
|
|
fp.write(e)
|
|
fp.write('\n')
|
|
|
|
if self.keep != -1 and self._remove_before:
|
|
self.remove_old_backups()
|
|
|
|
# Only look for the last backup now, as it may have been removed above
|
|
self.find_last_backup()
|
|
|
|
logger.info('Copying files. This may take a long time...')
|
|
|
|
if self._last_backup == '':
|
|
rsync = f'/usr/bin/rsync {self.options} --exclude-from={self._exclude_path} ' +\
|
|
f'--files-from={self._inputs_path} / "{self._server}{self._output_dir}"'
|
|
else:
|
|
rsync = f'/usr/bin/rsync {self.options} --link-dest="{self._last_backup}" --exclude-from=' +\
|
|
f'{self._exclude_path} --files-from={self._inputs_path} / "{self._server}{self._output_dir}"'
|
|
|
|
euid = os.geteuid()
|
|
|
|
if euid == 0 and self.ssh_keyfile is not None:
|
|
rsync = f'{rsync} -e \'ssh -i {self.ssh_keyfile} -o StrictHostKeyChecking=no\''
|
|
elif self._password_auth and which('sshpass'):
|
|
rsync = f'{rsync} -e \'sshpass -e ssh -l {self.ssh_user} -o StrictHostKeyChecking=no\''
|
|
else:
|
|
rsync = f'{rsync} -e \'ssh -o StrictHostKeyChecking=no\''
|
|
|
|
if self._remote and self.remote_sudo:
|
|
rsync = f'{rsync} --rsync-path="sudo rsync"'
|
|
|
|
args = shlex.split(rsync)
|
|
|
|
with Popen(args, stdin=PIPE, stdout=PIPE, stderr=STDOUT, shell=False) as p:
|
|
output: Union[bytes, List[str]]
|
|
output, _ = p.communicate()
|
|
|
|
try:
|
|
del os.environ['SSHPASS']
|
|
except KeyError:
|
|
pass
|
|
|
|
returncode = p.returncode
|
|
|
|
output = output.decode("utf-8").split('\n')
|
|
|
|
if returncode == 0:
|
|
if self._verbose:
|
|
logger.info('rsync: %s', output)
|
|
else:
|
|
logger.info('rsync: %s', output[-3])
|
|
logger.info('rsync: %s', output[-2])
|
|
else:
|
|
self._returncode_log(returncode)
|
|
|
|
if self._verbose:
|
|
if returncode in [23, 24]:
|
|
logger.warning(output)
|
|
else:
|
|
logger.error(output)
|
|
|
|
if self._removed_count > 0 and returncode not in [0, 24]:
|
|
# With --remove-before-backup, old backups are already gone if the new one failed
|
|
if self.keep == 0:
|
|
message = 'All old backups were removed before the backup, and the new backup may be ' +\
|
|
'incomplete. No complete backup is available'
|
|
else:
|
|
message = 'Old backups were removed before the backup, and the new backup may be incomplete'
|
|
|
|
logger.error(message)
|
|
_notify(message)
|
|
|
|
if self.keep != -1 and not self._remove_before:
|
|
# Don't delete old backups if the new one may be incomplete
|
|
if returncode in [0, 24]:
|
|
self.remove_old_backups()
|
|
else:
|
|
logger.warning('Backup not completed successfully. Old backups will not be removed')
|
|
|
|
if self._remote:
|
|
assert self._ssh is not None
|
|
|
|
self._ssh.close()
|
|
|
|
# Files vanishing during the transfer is normal for a live system (return code 24)
|
|
if returncode not in [0, 24]:
|
|
logger.error(
|
|
'Some errors occurred while performing the backup')
|
|
|
|
_notify(
|
|
'Some errors occurred while performing the backup. Check log for details')
|
|
|
|
return 4
|
|
|
|
logger.info('Backup completed')
|
|
|
|
_notify('Backup completed')
|
|
|
|
return 0
|
|
|
|
|
|
def _detect_user() -> Optional[str]:
|
|
if os.geteuid() == 0:
|
|
return os.getenv('SUDO_USER') or os.getenv('DOAS_USER')
|
|
|
|
return os.getenv('USER')
|
|
|
|
|
|
def _parse_arguments() -> argparse.Namespace:
|
|
parser = argparse.ArgumentParser(prog='simple_backup',
|
|
description='Simple backup script written in Python that uses rsync to copy files',
|
|
epilog='See simple_backup(1) manpage for full documentation',
|
|
formatter_class=MyFormatter)
|
|
|
|
parser.add_argument('-v', '--verbose', action='store_true',
|
|
help='More verbose output')
|
|
parser.add_argument('-c', '--config', default='~/.config/simple_backup/simple_backup.conf',
|
|
help='Specify location of configuration file')
|
|
parser.add_argument('-i', '--inputs', nargs='+',
|
|
help='Paths/files to backup')
|
|
parser.add_argument(
|
|
'-o', '--output', help='Output directory for the backup')
|
|
parser.add_argument('-e', '--exclude', nargs='+',
|
|
help='Files/directories/patterns to exclude from the backup')
|
|
parser.add_argument('-k', '--keep', type=int,
|
|
help='Number of old backups to keep')
|
|
parser.add_argument(
|
|
'-u', '--user', help='Explicitly specify the user running the backup')
|
|
parser.add_argument('-s', '--checksum', action='store_true',
|
|
help='Use checksum rsync option to compare files')
|
|
parser.add_argument(
|
|
'--ssh-host', help='Server hostname (for remote backup)')
|
|
parser.add_argument(
|
|
'--ssh-user', help='Username to connect to server (for remote backup)')
|
|
parser.add_argument('--keyfile', help='SSH key location')
|
|
parser.add_argument('-z', '--compress', action='store_true',
|
|
help='Compress data during the transfer')
|
|
parser.add_argument('--remove-before-backup', action='store_true',
|
|
help='Remove old backups before executing the backup, instead of after')
|
|
parser.add_argument('--no-syslog', action='store_true',
|
|
help='Disable systemd journal logging')
|
|
parser.add_argument('--rsync-options', nargs='+',
|
|
choices=['a', 'l', 'p', 't', 'g', 'o',
|
|
'c', 'h', 's', 'D', 'H', 'X'],
|
|
help='Specify options for rsync')
|
|
parser.add_argument('--remote-sudo', action='store_true',
|
|
help='Run rsync on remote server with sudo if allowed')
|
|
parser.add_argument('--numeric-ids', action='store_true',
|
|
help='Use rsync \'--numeric-ids\' option (don\'t map uid/gid values by name)')
|
|
|
|
args = parser.parse_args()
|
|
|
|
return args
|
|
|
|
|
|
def _expand_home(path: str, user: str) -> str:
|
|
"""Expand a leading '~' to the home directory of user (other '~' are left as they are)"""
|
|
|
|
if path == '~' or path.startswith('~/'):
|
|
path = f'~{user}{path[1:]}'
|
|
|
|
return os.path.expanduser(path)
|
|
|
|
|
|
def _expand_inputs(inputs, user: Optional[str] = None):
|
|
expanded_inputs = []
|
|
|
|
for i in inputs:
|
|
if i == '':
|
|
continue
|
|
|
|
if user is not None:
|
|
i_ex = glob(_expand_home(i, user))
|
|
else:
|
|
i_ex = glob(i)
|
|
|
|
if i.startswith('~'):
|
|
logger.warning('Cannot expand \'~\'. No user specified')
|
|
|
|
if len(i_ex) == 0:
|
|
logger.warning(
|
|
'No file or directory matching input %s. Skipping...', i)
|
|
else:
|
|
expanded_inputs.extend(i_ex)
|
|
|
|
return expanded_inputs
|
|
|
|
|
|
def _read_config(config_file, user: Optional[str] = None):
|
|
config_args = {'inputs': None,
|
|
'output': None,
|
|
'exclude': None,
|
|
'keep': -1,
|
|
'ssh_host': None,
|
|
'ssh_user': None,
|
|
'ssh_keyfile': None,
|
|
'remote_sudo': False,
|
|
'numeric_ids': False}
|
|
|
|
if not os.path.isfile(config_file):
|
|
if user is not None:
|
|
logger.warning('Config file %s does not exist', config_file)
|
|
else:
|
|
logger.warning(
|
|
'User not specified. Can\'t read configuration file')
|
|
|
|
return config_args
|
|
|
|
# Disable interpolation, so that '%' can be used in paths and patterns
|
|
config = configparser.ConfigParser(interpolation=None)
|
|
config.read(config_file)
|
|
|
|
section = 'backup'
|
|
|
|
# Allow compatibility with previous version of config file
|
|
try:
|
|
inputs = config.get(section, 'inputs')
|
|
except configparser.NoSectionError:
|
|
section = 'default'
|
|
inputs = config.get(section, 'inputs')
|
|
|
|
inputs = [i.strip() for i in inputs.split(',')]
|
|
inputs = _expand_inputs(inputs, user)
|
|
inputs = list(set(inputs))
|
|
|
|
config_args['inputs'] = inputs
|
|
|
|
output = config.get(section, 'backup_dir')
|
|
|
|
if user is not None:
|
|
output = _expand_home(output, user)
|
|
elif user is None and output.startswith('~'):
|
|
logger.warning('Cannot expand \'~\', no user specified')
|
|
|
|
config_args['output'] = output
|
|
|
|
try:
|
|
exclude = config.get(section, 'exclude')
|
|
exclude = [e.strip() for e in exclude.split(',') if e.strip() != '']
|
|
except configparser.NoOptionError:
|
|
exclude = []
|
|
|
|
config_args['exclude'] = exclude
|
|
|
|
try:
|
|
keep = config.getint(section, 'keep')
|
|
except configparser.NoOptionError:
|
|
keep = -1
|
|
|
|
config_args['keep'] = keep
|
|
|
|
try:
|
|
ssh_host = config.get('server', 'ssh_host')
|
|
ssh_user = config.get('server', 'ssh_user')
|
|
except (configparser.NoSectionError, configparser.NoOptionError):
|
|
ssh_host = None
|
|
ssh_user = None
|
|
|
|
config_args['ssh_host'] = ssh_host
|
|
config_args['ssh_user'] = ssh_user
|
|
|
|
try:
|
|
ssh_keyfile = config.get('server', 'ssh_keyfile')
|
|
except (configparser.NoSectionError, configparser.NoOptionError):
|
|
ssh_keyfile = None
|
|
|
|
config_args['ssh_keyfile'] = ssh_keyfile
|
|
|
|
try:
|
|
remote_sudo = config.getboolean('server', 'remote_sudo')
|
|
except (configparser.NoSectionError, configparser.NoOptionError):
|
|
remote_sudo = False
|
|
|
|
config_args['remote_sudo'] = remote_sudo
|
|
|
|
try:
|
|
numeric_ids = config.getboolean('server', 'numeric_ids')
|
|
except (configparser.NoSectionError, configparser.NoOptionError):
|
|
numeric_ids = False
|
|
|
|
config_args['numeric_ids'] = numeric_ids
|
|
|
|
return config_args
|
|
|
|
|
|
def _target_uid() -> int | None:
|
|
euid = os.geteuid()
|
|
|
|
if euid != 0:
|
|
return euid
|
|
|
|
if (val := os.getenv('SUDO_UID')) is not None:
|
|
return int(val)
|
|
|
|
if (name := os.getenv('DOAS_USER')) is not None:
|
|
try:
|
|
return pwd.getpwnam(name).pw_uid
|
|
except KeyError:
|
|
return None
|
|
|
|
return None
|
|
|
|
|
|
_notify_failed = False
|
|
|
|
|
|
def _notify(text: str) -> None:
|
|
global _notify_failed
|
|
|
|
if dbus is None or _notify_failed:
|
|
return
|
|
|
|
euid = os.geteuid()
|
|
uid = _target_uid()
|
|
|
|
if uid is None:
|
|
logger.debug('Cannot send desktop notification: user not found')
|
|
|
|
return
|
|
|
|
os.seteuid(uid)
|
|
|
|
try:
|
|
os.environ['DBUS_SESSION_BUS_ADDRESS'] = f'unix:path=/run/user/{uid}/bus'
|
|
|
|
obj = dbus.SessionBus().get_object('org.freedesktop.Notifications',
|
|
'/org/freedesktop/Notifications')
|
|
obj = dbus.Interface(obj, 'org.freedesktop.Notifications')
|
|
obj.Notify('simple_backup', 0, '', 'simple_backup', text, [], {'urgency': dbus.Byte(1)}, 10000)
|
|
except Exception as e:
|
|
# Report the failure only once (e.g. no session bus available), then stop trying
|
|
_notify_failed = True
|
|
logger.warning('Cannot send desktop notification: %s', e)
|
|
finally:
|
|
os.seteuid(euid)
|
|
|
|
|
|
def simple_backup() -> int:
|
|
"""Main"""
|
|
|
|
args = _parse_arguments()
|
|
|
|
if args.user:
|
|
user = args.user
|
|
homedir = os.path.expanduser(f'~{user}')
|
|
else:
|
|
euid = os.geteuid()
|
|
|
|
if euid == 0:
|
|
user = _detect_user()
|
|
|
|
if user is not None:
|
|
homedir = os.path.expanduser(f'~{user}')
|
|
else:
|
|
logger.warning(
|
|
'Failed to detect user. You can use -u/--user parameter to manually specify it')
|
|
homedir = None
|
|
else:
|
|
user = os.getenv('USER')
|
|
homedir = os.getenv('HOME')
|
|
|
|
if homedir is None:
|
|
homedir = ''
|
|
|
|
if args.no_syslog:
|
|
try:
|
|
logger.removeHandler(j_handler)
|
|
except NameError:
|
|
pass
|
|
|
|
config_file = args.config
|
|
|
|
# Expand '~' to the home of the user running the backup, not root's
|
|
if config_file.startswith('~/') and user is not None:
|
|
config_file = f'~{user}{config_file[1:]}'
|
|
|
|
config_file = os.path.expanduser(config_file)
|
|
|
|
try:
|
|
config_args = _read_config(config_file, user)
|
|
except (configparser.Error, ValueError) as e:
|
|
# configparser.Error: missing sections/options or bad syntax, ValueError: invalid values (e.g. keep=abc)
|
|
logger.critical('Bad configuration file: %s', e)
|
|
|
|
return 6
|
|
|
|
inputs = args.inputs if args.inputs is not None else config_args['inputs']
|
|
output = args.output if args.output is not None else config_args['output']
|
|
exclude = args.exclude if args.exclude is not None else config_args['exclude']
|
|
keep = args.keep if args.keep is not None else config_args['keep']
|
|
ssh_host = args.ssh_host if args.ssh_host is not None else config_args['ssh_host']
|
|
ssh_user = args.ssh_user if args.ssh_user is not None else config_args['ssh_user']
|
|
ssh_keyfile = args.keyfile if args.keyfile is not None else config_args['ssh_keyfile']
|
|
remote_sudo = args.remote_sudo or config_args['remote_sudo']
|
|
|
|
# Options needed in any case (--mkpath creates the backup directory on the first run)
|
|
rsync_options = ['-r', '-v', '--ignore-missing-args', '--mkpath']
|
|
|
|
if args.rsync_options is None:
|
|
rsync_options.extend(['-a', '-h', '-H', '-X', '-s'])
|
|
else:
|
|
for ro in args.rsync_options:
|
|
rsync_options.append(f'-{ro}')
|
|
|
|
if args.checksum:
|
|
rsync_options.append('-c')
|
|
|
|
if args.compress:
|
|
rsync_options.append('-z')
|
|
|
|
if args.numeric_ids or config_args['numeric_ids']:
|
|
rsync_options.append('--numeric-ids')
|
|
|
|
rsync_options = ' '.join(rsync_options)
|
|
|
|
backup = Backup(inputs, output, exclude, keep, rsync_options, ssh_host, ssh_user, ssh_keyfile,
|
|
remote_sudo, remove_before=args.remove_before_backup, verbose=args.verbose)
|
|
|
|
return_code = backup.check_params(homedir)
|
|
|
|
if return_code == 0:
|
|
return backup.run()
|
|
|
|
return return_code
|
|
|
|
|
|
if __name__ == '__main__':
|
|
simple_backup()
|