Merge branch 'development'

Remove forgotten test code -.-

.gitignore

@@ -1,2 +1,3 @@
 .idea/
+__pycache__/
 test/

PKGBUILD

@@ -1,47 +0,0 @@
-# PKGBUILD
-
-# Maintainer: Daniele Fucini <dfucini@gmail.com>
-
-pkgname=simple_backup
-pkgver=3.1.2.r1.ga4c4b88
-pkgrel=1
-pkgdesc='Simple backup script that uses rsync to copy files'
-arch=('any')
-url="https://github.com/Fuxino/simple_backup.git"
-license=('GPL3')
-makedepends=('git'
-             'python-setuptools'
-             'python-build'
-             'python-installer'
-             'python-wheel')
-depends=('python'
-         'rsync'
-         'python-dotenv')
-optdepends=('python-systemd: use systemd log')
-install=${pkgname}.install
-source=(git+https://github.com/Fuxino/${pkgname}.git)
-sha256sums=('SKIP')
-
-pkgver() 
-{  
-   cd ${pkgname}
-   git describe --long --tags | sed 's/\([^-]*-g\)/r\1/;s/-/./g'
-}
-
-prepare()
-{
-   git -C ${srcdir}/${pkgname} clean -dfx
-}
-
-build()
-{
-   cd ${srcdir}/${pkgname}
-   python -m build --wheel --no-isolation
-}
-
-package()
-{
-   cd ${srcdir}/${pkgname}
-   python -m installer --destdir=${pkgdir} dist/*.whl
-   install -Dm644 ${srcdir}/${pkgname}/${pkgname}.conf ${pkgdir}/etc/${pkgname}/${pkgname}.conf
-}

README.md

@@ -20,6 +20,10 @@ The script uses rsync to actually run the backup, so you will have to install it
 sudo pacman -Syu rsync
 ```
 
+It's also required to have python-dotenv
+
+Optional dependencies are systemd-python to enable using systemd journal for logging, and dbus-python for desktop notifications.
+
 ## Install
 To install the program, first clone the repository:
 
@@ -27,14 +31,41 @@ To install the program, first clone the repository:
 git clone https://github.com/Fuxino/simple_backup.git
 ```
 
-Then run:
+Then install the tools required to build the package:
+
+```bash
+pip install --upgrade build wheel
+```
+
+Finally, run:
 
 ```bash
 cd simple_backup
 python -m build --wheel
-python -m installer dist/*.whl
+python -m pip install dist/*.whl
+```
 
-For Arch Linux, a PKGBUILD that automates this process is provided.
+For Arch Linux and Arch-based distros, two packages are available in the AUR (aur.archlinux.org):
+- **simple_backup** for the release version
+- **simple_backup-git** for the git version
 
-After installing, copy simple_backup.conf (if you used the PKGBUILD on Arch, it will be in /etc/simple_backup/) to $HOME/.config/simple_backup and edit is as needed.
+## Remote backup
+> **Warning**
+> This feature is experimental
+
+It's possible to use a remote server as destination for the backup. Just use the --username (or -u) and --host arguments (or set them in the configuration file).
+For this to work, rsync must be installed on the server too.
+
+### Server authentication
+The best way to handle the authentication is to have an ssh agent running on your system, otherwise if a passphrase is necessary to unlock the ssh key, it will be necessary to enter it more than once.
+If needed, it's possible to specify the ssh key location with the --keyfile argument or in the configuration file.
+
+To be able to connect to the user's ssh agent when running simple_backup with sudo, make sure to preserve the SSH_AUTH_SOCK environment variable. For example:
+
+```bash
+sudo --preserve-env=SSH_AUTH_SOCK -s simple_backup [options]
+```
+
+or by editing the sudoers file.
+If SSH key authentication is not available, password authentication will be used instead.
 

man/simple_backup.1

@@ -0,0 +1,186 @@
+.TH SIMPLE_BACKUP 1 2023-06-15 SIMPLE_BACKUP 3.2.6
+.SH NAME
+simple_backup \- Backup files and folders using rsync
+.SH SYNOPSIS
+.B simple_backup
+\-h, \-\-help
+.PD 0
+.P
+.PD
+.B simple_backup
+[\-c, \-\-config FILE]
+[\-i, \-\-input INPUT [INPUT...]]
+[\-o, \-\-output DIR]
+.PD 0
+.P
+.PD
+.RS 14 [\-e, \-\-exclude FILE|DIR|PATTERN [FILE|...]]
+[\-k, \-\-keep N]
+[\-\-ssh\-host HOSTNAME]
+[\-\-ssh\-user USERNAME]
+[\-\-keyfile FILE]
+.PD 0
+.P
+.PD
+[\-s, \-\-checksum]
+[\-z, \-\-compress]
+[\-\-remove\-before\-backup]
+.RE
+.SH DESCRIPTION
+.B simple_backup
+is a python script for performing backup of files and folders.
+.P
+It uses rsync to copy the files to the specified location. Parameters for the backup such as
+input files/directories, output location and files or folders to exclude can be specified
+in a configuration file (default location $HOME/.config/simple_backup/simple_backup.conf)
+or directly on the command line.
+.P
+Parameters specified on the command line will override those in the configuration file.
+.SH OPTIONS
+.TP
+.B \-h, \-\-help
+Print a short help message and exit
+.TP
+.B \-c, \-\-config FILE
+Specify the configuration file, useful to specify a different one from the default.
+.TP
+.B \-i, \-\-input INPUT [INPUT...]
+Specify the files and directories to backup. Multiple inputs can be specified, just separate
+them with a space. If filenames or paths contain spaces, don't forget to escape them,
+or to use single or double quotes around them.
+.TP
+.B \-o, \-\-output DIR
+Specify the directory where the files will be copied. The program will automatically
+create a subdirectory called \(aqsimple_backup\(aq (if it does not already exist) and
+inside this directory the actual backup directory (using the current date and time)
+.TP
+.B \-e, \-\-exclude FILE|DIR|PATTERN [FILE|...]]
+Specify files, directories or patterns to exclude from the backup. Matching files and directories
+will not be copied. Multiple elements can be specified, in the same way as for the \-\-input option
+.TP
+.B \-k, \-\-keep N
+Specify how many old backups (so excluding the current one) will be kept. The default behavior
+is to keep them all (same as N=\-1)
+.TP
+.B \-\-ssh\-host HOSTNAME
+Hostname of the server where to copy the files in case of remote backup through SSH
+.TP
+.B \-\-ssh\-user USERNAME
+Username for connecting to the server in case of remote backup
+.TP
+.B \-\-keyfile FILE
+Location of the SSH key for server authentication. 
+.TP
+.B \-s, \-\-checksums
+Same as rsync option \(aq\-\-checksum\(aq, use checksums instead of mod\-time and size
+to skip files.
+.TP
+.B \-z, \-\-compress
+Compress data during transfer (rsync \(aq\-\-compress\(aq option). Useful for remote backup
+if saving bandwith is needed.
+.TP
+.B \-\-remove\-before\-backup
+Remove old backups (if necessary) before creating the new backup. Useful to free some space
+before performing the backup.
+Default behavior is to remove old backups after successfully completing the backup.
+.TP
+.B \-\-no\-syslog
+Don't use systemd journal for logging
+.TP
+.B \-\-rsync\-options OPTIONS [OPTION...]
+By default, the following rsync options are used:
+.RS
+.PP
+    \-a \-r \-v \-h \-s \-H \-X
+.PP
+Using \-\-rsync\-options it is possible to manually select which options to use. Supported values are the following:
+.PP
+    \-a, \-l, \-p, \-t, \-g, \-o, \-c, \-h, \-D, \-H, \-X, \-s
+.PP
+Options \-r and \-v are used in any case. Not that options must be specified without dash (\-), for example:
+.PP
+.EX
+    simple_backup \-\-rsync\-options a l p
+.EE
+.TP
+Check
+.BR rsync (1)
+for details about the options.
+.RE
+.TP
+.B \-\-remote\-sudo
+Run rsync on the remote server with sudo. This is needed if you want to preserve the owner of the files/folders to be copied (rsync \-\-owner option). For this to work the user used to login to the server obviously need to be allowed to use sudo. In addition, the user need to be able to run rsync with sudo without a password. To do this, /etc/sudoers on the server need to be edited adding a line like this one:
+.RS
+.PP
+    <username> ALL=NOPASSWD:<path/to/rsync>
+.RE
+.TP
+.B \-\-numeric\-ids
+Use rsync \-\-numeric\-ids option. This causes rsync to use numeric uid/gid instead of trying to map uid/gid names from the local machine to the server
+.SH CONFIGURATION
+An example configuration file is provided at \(aq/usr/share/doc/simple_backup/simple_backup.conf\(aq.
+Copy it to the default location ($HOME/.config/simple_backup) and edit it as needed.
+.SH REMOTE BACKUP
+It is possible to choose a directory on a remote server as destination for the backup. The files
+are copied by rsync through SSH. Server hostname and username must be specified, either in the
+configuration file, or on the command line (\(aq\-\-ssh\-host\(aq and \(aq\-\-ssh\-user\(aq options).
+.SS AUTHENTICATION
+For authentication, it is possible to use SSH key or password.
+.P
+When using SSH key, the best way to connect to the server is to have an SSH agent running.
+Otherwise, if the SSH key is encrypted, it will be necessary to enter the passphrase more
+than once. It is possible to specify the SSH key to use with the option \(aq\-\-keyfile\(aq,
+if necessary.
+.P
+When running
+.B simple_backup
+with
+.B sudo,
+in order to connect to the user\(aq s SSH agent it is necessary to preserve the \(aq SSH_AUTH_SOCK\(aq environment variable, for example:
+.P
+.EX
+    sudo --preserve-env=SSH_AUTH_SOCK -s simple_backup [options]
+.EE
+.P
+It is also possible to make this permanent by editing the
+.B sudoers
+file (see
+.BR sudoers (5)
+)
+.P
+If SSH key authentication is not available, password authentication will be used instead.
+Note that in this case
+.B sshpass
+(if available) will be used to send the password to rsync, to avoid prompting the user for
+the password multiple
+times. This can pose some security risks, see
+.BR sshpass (1)
+for details. For this reason, use SSH key authentication if possible.
+.SH EXIT STATUS
+.TP
+.B 0
+The backup was completed without errors
+.TP
+.B 1
+No valid inputs selected for backup
+.TP
+.B 2
+Backup failed because output directory for storing the backup does not exist
+.TP
+.B 3
+Permission denied to access the output directory
+.TP
+.B 4
+rsync error (rsync returned a non-zero value)
+.TP
+.B 5
+SSH connection failed
+.TP
+.B 6
+Bad configuration file
+.SH SEE ALSO
+.BR rsync (1)
+.SH AUTHORS
+.MT https://github.com/Fuxino
+Daniele Fucini
+.ME

setup.cfg

@@ -8,7 +8,7 @@ author_email = dfucini@gmail.com
 license = GPL3
 url = https://github.com/Fuxino/simple_backup
 classifiers =
-   Development Status :: 5 - Production/Stable
+   Development Status :: 4 - Beta
    Environment :: Console
    License :: OSI Approved :: GNU General Public License v3 (GPLv3)
    Natural Language :: English
@@ -25,9 +25,16 @@ packages = simple_backup
 python_requires = >=3.7
 install_requires =
    python-dotenv
-   systemd-python
+
+[options.extras_require]
+JOURNAL =
+    systemd-python
+NOTIFICATIONS =
+    dbus-python
+REMOTE =
+    paramiko
 
 [options.entry_points]
 console_scripts =
-   simple_backup = simple_backup:simple_backup
+   simple_backup = simple_backup.simple_backup:simple_backup
 

simple_backup.conf

@@ -1,14 +0,0 @@
-#Example config file for simple_backup
-
-[default]
-#Input directories. Use a comma to separate items
-inputs=/home/my_home,/etc
-
-#Output directory
-backup_dir=/media/Backup
-
-#Exclude patterns. Use a comma to separate items
-exclude=.gvfs,.local/share/gvfs-metadata,.cache,.dbus,.Trash,.local/share/Trash,.macromedia,.adobe,.recently-used,.recently-used.xbel,.thumbnails
-
-#Number of snapshots to keep (use -1 to keep all)
-keep=-1

simple_backup.install

@@ -1,8 +0,0 @@
-post_install() {
-   echo "An example configuration file is found in /etc/simple_backup/simple_backup.conf."
-   echo "Copy it to ~/config/simple_backup/simple_backup.conf and modify it as needed"
-}
-
-post_upgrade() {
-   post_install
-}

simple_backup/__init__.py

@@ -1,3 +1,3 @@
 """Init."""
 
-__version__ = '3.1.2'
+__version__ = '4.0.0'

simple_backup/simple_backup.conf

@@ -1,14 +1,22 @@
-#Example config file for simple_backup
+# Example config file for simple_backup
 
-[default]
+[backup]
-#Input directories. Use a comma to separate items
+# Files and directories to backup. Multiple items can be separated using a comma (','). It is possible to use wildcards (i.e. '*' to match multiple characters and '~' for the user's home directory).
 inputs=/home/my_home,/etc
 
-#Output directory
+# Output directory.
 backup_dir=/media/Backup
 
-#Exclude patterns. Use a comma to separate items
+# Files, directories and patterns to exclude from the backup. Multiple items can be separated using a comma.
-exclude=.gvfs,.local/share/gvfs-metadata,.cache,.dbus,.Trash,.local/share/Trash,.macromedia,.adobe,.recently-used,.recently-used.xbel,.thumbnails
+exclude=*.bak
 
-#Number of snapshots to keep (use -1 to keep all)
+# Number of old backups (i.e. excluding the one that's being created) to keep (use -1 to keep all)
-keep=-1
+keep=-1
+
+# Uncomment the following section to enable backup to remote server through ssh
+# [server]
+# ssh_host=
+# ssh_user=
+# ssh_keyfile=
+# remote_sudo=
+# numeric_ids=

simple_backup/simple_backup.py

@@ -1,9 +1,23 @@
-#!/usr/bin/python3
+#!/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
+"""
 
 # Import libraries
+import sys
 import os
+import warnings
 from functools import wraps
-from shutil import rmtree
+from shutil import rmtree, which
+import shlex
 import argparse
 import configparser
 import logging
@@ -12,10 +26,26 @@ from timeit import default_timer
 from subprocess import Popen, PIPE, STDOUT
 from datetime import datetime
 from tempfile import mkstemp
+from getpass import getpass
+from glob import glob
+
 from dotenv import load_dotenv
 
+warnings.filterwarnings('error')
+
+try:
+    import paramiko
+    from paramiko import RSAKey, Ed25519Key, ECDSAKey, DSSKey
+except ImportError:
+    pass
+
 try:
     from systemd import journal
+except ImportError:
+    journal = None
+
+try:
+    import dbus
 except ImportError:
     pass
 
@@ -24,9 +54,10 @@ load_dotenv()
 euid = os.geteuid()
 
 if euid == 0:
-    user = os.getenv("SUDO_USER")
+    user = os.getenv('SUDO_USER')
     homedir = os.path.expanduser(f'~{user}')
 else:
+    user = os.getenv('USER')
     homedir = os.getenv('HOME')
 
 logging.getLogger().setLevel(logging.DEBUG)
@@ -38,17 +69,20 @@ c_format = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
 c_handler.setFormatter(c_format)
 logger.addHandler(c_handler)
 
-try:
+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)
-except NameError:
-    pass
 
 
 def timing(_logger):
+    """Decorator to measure execution time of a function
+
+        Parameters:
+            _logger: Logger object
+    """
     def decorator_timing(func):
         @wraps(func)
         def wrapper_timing(*args, **kwargs):
@@ -68,242 +102,669 @@ def timing(_logger):
 
 
 class MyFormatter(argparse.RawTextHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
-    pass
+    """Custom format for argparse help text"""
 
 
 class Backup:
+    """Main class defining parameters and functions for performing backup
 
-    def __init__(self, inputs, output, exclude, keep, options):
+    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, output, exclude, keep, options, ssh_host=None, ssh_user=None,
+                 ssh_keyfile=None, remote_sudo=False, remove_before=False):
         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._last_backup = ''
+        self._server = ''
         self._output_dir = ''
         self._inputs_path = ''
         self._exclude_path = ''
+        self._remote = None
         self._err_flag = False
+        self._ssh = None
+        self._password_auth = False
+        self._password = None
 
     def check_params(self):
+        """Check if parameters for the backup are valid"""
+
         if self.inputs is None or len(self.inputs) == 0:
-            logger.info('No files or directory specified for backup.')
+            logger.info('No existing files or directories specified for backup. Nothing to do')
 
-            return False
+            return 1
-
-        for i in self.inputs:
-            if os.path.islink(i):
-                try:
-                    i_new = os.readlink(i)
-                    logger.info(f'Input {i} is a symbolic link referencing {i_new}. Copying {i_new} instead')
-                    self.inputs.remove(i)
-                    self.inputs.append(i_new)
-                except Exception:
-                    logger.warning(f'Input {i} is a link and cannot be read. Skipping')
-                    self.inputs.remove(i)
 
         if self.output is None:
             logger.critical('No output path specified. Use -o argument or specify output path in configuration file')
 
-            return False
+            return 2
 
-        if not os.path.isdir(self.output):
+        if self.ssh_host is not None and self.ssh_user is not None:
-            logger.critical('Output path for backup does not exist')
+            self._remote = True
 
-            return False
+        if self._remote:
+            self._ssh = self._ssh_connect()
+
+            if self._ssh is None:
+                sys.exit(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 True
+        return 0
 
     # Function to create the actual backup directory
-    def create_backup_dir(self):
+    def define_backup_dir(self):
+        """Define the actual backup dir"""
         now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
         self._output_dir = f'{self.output}/simple_backup/{now}'
 
-        os.makedirs(self._output_dir, exist_ok=True)
+        if self._remote:
+            self._server = f'{self.ssh_user}@{self.ssh_host}:'
 
     def remove_old_backups(self):
-        try:
+        """Remove old backups if there are more than indicated by 'keep'"""
-            dirs = os.listdir(f'{self.output}/simple_backup')
-        except Exception:
-            logger.info('No older backups to remove')
 
-            return
+        if self._remote:
+            _, stdout, _ = self._ssh.exec_command(f'ls {self.output}/simple_backup')
 
-        if dirs.count('last_backup') > 0:
+            dirs = stdout.read().decode('utf-8').strip().split('\n')
-            dirs.remove('last_backup')
 
-        n_backup = len(dirs) - 1
+            n_backup = len(dirs)
-        count = 0
 
-        if n_backup > self.keep:
+            if not self._remove_before:
-            logger.info('Removing old backups...')
+                n_backup -= 1
-            dirs.sort()
 
-            for i in range(n_backup - self.keep):
+            count = 0
-                try:
-                    rmtree(f'{self.output}/simple_backup/{dirs[i]}')
-                    count += 1
-                except Exception:
-                    logger.error(f'Error while removing backup {dirs[i]}')
 
-            if count == 1:
+            if n_backup > self.keep:
-                logger.info(f'Removed {count} backup')
+                logger.info('Removing old backups...')
-            else:
+                dirs.sort()
-                logger.info(f'Removed {count} backups')
+
+                for i in range(n_backup - self.keep):
+                    _, _, 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])
+
+        if count == 1:
+            logger.info('Removed %d backup', count)
+        elif count > 1:
+            logger.info('Removed %d backups', count)
 
     def find_last_backup(self):
-        if os.path.islink(f'{self.output}/simple_backup/last_backup'):
+        """Get path of last backup (from last_backup symlink) for rsync --link-dest"""
-            try:
-                self._last_backup = os.readlink(f'{self.output}/simple_backup/last_backup')
-            except Exception:
-                logger.warning('Previous backup could not be read')
-        else:
-            logger.info('No previous backups available')
 
-        if not os.path.isdir(self._last_backup):
+        if self._remote:
-            logger.warning('Previous backup could not be read')
+            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')
+
+                try:
+                    notify('Backup failed (check log for details)')
+                except NameError:
+                    pass
+
+                sys.exit(3)
+
+            try:
+                self._last_backup = dirs[-1]
+            except IndexError:
+                logger.info('No previous backups available')
+
+    def _ssh_connect(self):
+        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(f'Cannot find file {homedir}/.ssh/known_hosts')
+
+        ssh.set_missing_host_key_policy(paramiko.WarningPolicy())
+
+        try:
+            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:
+                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 paramiko.SSHException as e:
+                logger.critical('Can\'t connect to the server.')
+                logger.critical(e)
+
+                return None
+
+        pkey = None
+
+        try:
+            pkey = RSAKey.from_private_key_file(self.ssh_keyfile)
+        except paramiko.PasswordRequiredException:
+            password = getpass(f'Enter passwphrase for key \'{self.ssh_keyfile}\': ')
+
+            try:
+                pkey = RSAKey.from_private_key_file(self.ssh_keyfile, password)
+            except paramiko.SSHException:
+                pass
+
+        if pkey is None:
+            try:
+                pkey = Ed25519Key.from_private_key_file(self.ssh_keyfile)
+            except paramiko.PasswordRequiredException:
+                try:
+                    pkey = Ed25519Key.from_private_key_file(self.ssh_keyfile, password)
+                except paramiko.SSHException:
+                    pass
+
+        if pkey is None:
+            try:
+                pkey = ECDSAKey.from_private_key_file(self.ssh_keyfile)
+            except paramiko.PasswordRequiredException:
+                try:
+                    pkey = ECDSAKey.from_private_key_file(self.ssh_keyfile, password)
+                except paramiko.SSHException:
+                    pass
+
+        if pkey is None:
+            try:
+                pkey = DSSKey.from_private_key_file(self.ssh_keyfile)
+            except paramiko.PasswordRequiredException:
+                try:
+                    pkey = DSSKey.from_private_key_file(self.ssh_keyfile, password)
+                except paramiko.SSHException:
+                    pass
+
+        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
 
     # Function to read configuration file
     @timing(logger)
     def run(self):
+        """Perform the backup"""
+
         logger.info('Starting backup...')
 
-        self.create_backup_dir()
+        try:
+            _notify('Starting backup...')
+        except NameError:
+            pass
+
+        self.define_backup_dir()
         self.find_last_backup()
 
-        if os.path.islink(f'{self.output}/simple_backup/last_backup'):
-            try:
-                os.remove(f'{self.output}/simple_backup/last_backup')
-            except Exception:
-                logger.error('Failed to remove last_backup link')
-                self._err_flag = True
-
         _, self._inputs_path = mkstemp(prefix='tmp_inputs', text=True)
-        _, self._exclude_path = mkstemp(prefix='tmp_exclude', text=True)
+        count = 0
 
-        with open(self._inputs_path, 'w') as fp:
+        with open(self._inputs_path, 'w', encoding='utf-8') as fp:
             for i in self.inputs:
                 if not os.path.exists(i):
-                    logger.warning(f'Input {i} not found. Skipping')
+                    logger.warning('Input %s not found. Skipping', i)
                 else:
                     fp.write(i)
                     fp.write('\n')
+                    count += 1
 
-        with open(self._exclude_path, 'w') as fp:
+        if count == 0:
-            for e in self.exclude:
+            logger.info('No existing files or directories specified for backup. Nothing to do')
-                fp.write(e)
+
-                fp.write('\n')
+            try:
+                notify('Backup finished. No files copied')
+            except NameError:
+                pass
+
+            return 1
+
+        _, self._exclude_path = mkstemp(prefix='tmp_exclude', text=True)
+
+        with open(self._exclude_path, '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()
 
         logger.info('Copying files. This may take a long time...')
 
         if self._last_backup == '':
-            rsync = f'rsync {self.options} --exclude-from={self._exclude_path} ' +\
+            rsync = f'/usr/bin/rsync {self.options} --exclude-from={self._exclude_path} ' +\
-                    f'--files-from={self._inputs_path} / "{self._output_dir}" ' +\
+                    f'--files-from={self._inputs_path} / "{self._server}{self._output_dir}"'
-                    '--ignore-missing-args'
         else:
-            rsync = f'rsync {self.options} --link-dest="{self._last_backup}" --exclude-from=' +\
+            rsync = f'/usr/bin/rsync {self.options} --link-dest="{self._last_backup}" --exclude-from=' +\
-                    f'{self._exclude_path} --files-from={self._inputs_path} / "{self._output_dir}" ' +\
+                    f'{self._exclude_path} --files-from={self._inputs_path} / "{self._server}{self._output_dir}"'
-                    '--ignore-missing-args'
 
-        p = Popen(rsync, stdout=PIPE, stderr=STDOUT, shell=True)
+        if euid == 0 and self.ssh_keyfile is not None:
-        output, _ = p.communicate()
+            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, _ = p.communicate()
+
+            try:
+                del os.environ['SSHPASS']
+            except KeyError:
+                pass
+
+            if p.returncode != 0:
+                self._err_flag = True
 
         output = output.decode("utf-8").split('\n')
 
-        logger.info(f'rsync: {output[-3]}')
+        if self._err_flag:
-        logger.info(f'rsync: {output[-2]}')
+            logger.error('rsync: %s', output)
+        else:
+            logger.info('rsync: %s', output[-3])
+            logger.info('rsync: %s', output[-2])
 
-        try:
+        if self.keep != -1 and not self._remove_before:
-            os.symlink(self._output_dir, f'{self.output}/simple_backup/last_backup')
-        except Exception:
-            logger.error('Failed to create last_backup link')
-            self._err_flag = True
-
-        if self.keep != -1:
             self.remove_old_backups()
 
         os.remove(self._inputs_path)
         os.remove(self._exclude_path)
 
-        logger.info('Backup completed')
+        if self._remote:
+            _, stdout, _ = self._ssh.exec_command(f'if [ -d "{self._output_dir}" ]; then echo "ok"; fi')
 
-        if self._err_flag:
+            output = stdout.read().decode('utf-8').strip()
-            logger.warning('Some errors occurred (check log for details)')
+
+            if output == 'ok':
+                logger.info('Backup completed')
+
+                try:
+                    _notify('Backup completed')
+                except NameError:
+                    pass
+            else:
+                logger.error('Backup failed')
+
+                try:
+                    _notify('Backup failed (check log for details)')
+                except NameError:
+                    pass
+
+            if self._ssh:
+                self._ssh.close()
+        else:
+            if self._err_flag:
+                logger.error('Some errors occurred while performing the backup')
+
+                try:
+                    _notify('Some errors occurred while performing the backup. Check log for details')
+                except NameError:
+                    pass
+
+                return 4
+            else:
+                logger.info('Backup completed')
+
+                try:
+                    _notify('Backup completed')
+                except NameError:
+                    pass
+
+            return 0
 
 
 def _parse_arguments():
     parser = argparse.ArgumentParser(prog='simple_backup',
                                      description='Simple backup script written in Python that uses rsync to copy files',
-                                     epilog='Report bugs to dfucini<at>gmail<dot>com',
+                                     epilog='See simple_backup(1) manpage for full documentation',
                                      formatter_class=MyFormatter)
 
     parser.add_argument('-c', '--config', default=f'{homedir}/.config/simple_backup/simple_backup.conf',
                         help='Specify location of configuration file')
-    parser.add_argument('-i', '--input', nargs='+', help='Paths/files to backup')
+    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('--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('-s', '--checksum', action='store_true',
-                        help='Use checksum rsync option to compare files (MUCH SLOWER)')
+                        help='Use checksum rsync option to compare files')
+    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 _read_config(config_file):
+def _expand_inputs(inputs):
-    if not os.path.isfile(config_file):
+    expanded_inputs = []
-        logger.warning(f'Config file {config_file} does not exist')
 
-        return None, None, None, None
+    for i in inputs:
+        if i == '':
+            continue
+
+        i_ex = glob(os.path.expanduser(i.replace('~', f'~{user}')))
+
+        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):
+    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):
+        logger.warning('Config file %s does not exist', config_file)
+
+        return config_args
 
     config = configparser.ConfigParser()
     config.read(config_file)
 
-    inputs = config.get('default', 'inputs')
+    section = 'backup'
-    inputs = inputs.split(',')
-    output = config.get('default', 'backup_dir')
-    exclude = config.get('default', 'exclude')
-    exclude = exclude.split(',')
-    keep = config.getint('default', 'keep')
 
-    return inputs, output, exclude, keep
+    # 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 = inputs.split(',')
+    inputs = _expand_inputs(inputs)
+    inputs = list(set(inputs))
+
+    config_args['inputs'] = inputs
+
+    output = config.get(section, 'backup_dir')
+    output = os.path.expanduser(output.replace('~', f'~{user}'))
+
+    config_args['output'] = output
+
+    try:
+        exclude = config.get(section, 'exclude')
+        exclude = exclude.split(',')
+    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 _notify(text):
+    _euid = os.geteuid()
+
+    if _euid == 0:
+        uid = os.getenv('SUDO_UID')
+    else:
+        uid = os.geteuid()
+
+    os.seteuid(int(uid))
+    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('', 0, '', 'simple_backup', text, [], {'urgency': 1}, 10000)
+
+    os.seteuid(int(_euid))
 
 
 def simple_backup():
+    """Main"""
+
     args = _parse_arguments()
-    inputs, output, exclude, keep = _read_config(args.config)
 
-    if args.input is not None:
+    if args.no_syslog:
-        inputs = args.input
+        try:
+            logger.removeHandler(j_handler)
+        except NameError:
+            pass
 
-    if args.output is not None:
+    try:
-        output = args.output
+        config_args = _read_config(args.config)
+    except (configparser.NoSectionError, configparser.NoOptionError):
+        logger.critical('Bad configuration file')
+        sys.exit(6)
 
-    if args.exclude is not None:
+    inputs = args.inputs if args.inputs is not None else config_args['inputs']
-        exclude = args.exclude
+    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 if args.remote_sudo is not None else config_args['remote_sudo']
 
-    if args.keep is not None:
+    if args.rsync_options is None:
-        keep = args.keep
+        rsync_options = ['-a', '-r', '-v', '-h', '-H', '-X', '-s', '--ignore-missing-args', '--mkpath']
+    else:
+        rsync_options = ['-r', '-v']
+
+        for ro in args.rsync_options:
+            rsync_options.append(f'-{ro}')
 
     if args.checksum:
-        backup_options = '-arcvh -H -X'
+        rsync_options.append('-c')
-    else:
-        backup_options = '-arvh -H -X'
 
-    backup = Backup(inputs, output, exclude, keep, backup_options)
+    if args.compress:
+        rsync_options.append('-z')
 
-    if backup.check_params():
+    if args.numeric_ids or config_args['numeric_ids']:
-        backup.run()
+        rsync_options.append('--numeric-ids')
 
-        return 0
+    rsync_options = ' '.join(rsync_options)
 
-    return 1
+    backup = Backup(inputs, output, exclude, keep, rsync_options, ssh_host, ssh_user, ssh_keyfile,
+                    remote_sudo, remove_before=args.remove_before_backup)
+
+    return_code = backup.check_params()
+
+    if return_code == 0:
+        return backup.run()
+
+    return return_code
 
 
 if __name__ == '__main__':