Add no-syslog option

Correctly handle exception when trying to display notification if
dbus-python is not available

.gitignore

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

PKGBUILD

@@ -1,31 +0,0 @@
-#Arch Linux PKGBUILD
-#
-#Maintainer: Daniele Fucini <dfucini@gmail.com>
-#
-
-pkgname=simple_backup
-pkgver=2.0.0.r3.gc61c704
-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')
-depends=('python3'
-         'rsync'
-         'python-dotenv')
-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'
-}
-
-package()
-{
-   install -Dm755 "${srcdir}/${pkgname}/${pkgname}.py" "${pkgdir}/usr/bin/${pkgname}"
-   install -Dm644 "${srcdir}/${pkgname}/config" "${pkgdir}/etc/${pkgname}/config"
-}

README.md

@@ -1,10 +1,51 @@
-# simple_backup
+simple_backup
+============
 A simple backup script
 
 ## Description
 simple_backup is a Python script that allows you to backup your files.
-It reads from a configuration file the files/directories that must be copied,
-the destination directory for the backup and a few other options.
+Parameters like input files/directories, output directory etc. can be specified in a configuration file, or on the command line.
+Run:
+
+```bash
+simple_backup -h
+```
+
+to print all possible command line options.
 
 ## Dependencies
-rsync is used to perform the backup.  
+The script uses rsync to actually run the backup, so you will have to install it on your system. For example on Arch Linux:
+
+```bash
+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:
+
+```bash
+git clone https://github.com/Fuxino/simple_backup.git
+```
+
+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 pip install dist/*.whl
+```
+
+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
+

man/simple_backup.1

@@ -0,0 +1,70 @@
+.TH SIMPLE_BACKUP 1 2023-06-01 SIMPLE_BACKUP 3.2.6
+.SH NAME
+simple_backup \- Backup files and folders using rsync
+.SH SYNOPSIS
+.BR simple_backup
+\-h, \-\-help
+.PD 0
+.P
+.PD
+.BR 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]
+[\-s, \-\-checksum]
+[\-\-remove\-before\-backup]
+.RE
+.SH DESCRIPTION
+.BR simple_backup
+is a python script for performing backup of files and folders. 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.
+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 \-s, \-\-checksums
+Same as rsync option \(aq\-\-checksum\(aq, use checksums instead of mod\-time and size to skip files.
+.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
+.SH CONFIGURATION
+An example configuration file is provided at \(aq/etc/simple_backup/simple_backup.conf\(aq. Copy it to the default location
+($HOME/.config/simple_backup) and edit it as needed.
+.SH SEE ALSO
+.BR rsync (1)
+.SH AUTHORS
+.MT https://github.com/Fuxino
+Daniele Fucini
+.ME

pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ['setuptools']
+build-backend = 'setuptools.build_meta'

requirements.txt

@@ -1 +0,0 @@
-python-dotenv>=1.0.0

setup.cfg

@@ -0,0 +1,38 @@
+[metadata]
+name = simple_backup
+version = attr: simple_backup.__version__
+description = Simple backup script using rsync
+long_description = file: README.md
+author = Daniele Fucini
+author_email = dfucini@gmail.com
+license = GPL3
+url = https://github.com/Fuxino/simple_backup
+classifiers =
+   Development Status :: 5 - Production/Stable
+   Environment :: Console
+   License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+   Natural Language :: English
+   Operating System :: POSIX :: Linux
+   Programming Language :: Python :: 3.7
+   Programming Language :: Python :: 3.8
+   Programming Language :: Python :: 3.9
+   Programming Language :: Python :: 3.10
+   Programming Language :: Python :: 3.11
+   Topic :: System :: Archiving :: Backup
+
+[options]
+packages = simple_backup
+python_requires = >=3.7
+install_requires =
+   python-dotenv
+
+[options.extras_require]
+JOURNAL =
+    systemd-python
+NOTIFICATIONS =
+    dbus-python
+
+[options.entry_points]
+console_scripts =
+   simple_backup = simple_backup.simple_backup:simple_backup
+

simple_backup.install

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

simple_backup/__init__.py

@@ -0,0 +1,3 @@
+"""Init."""
+
+__version__ = '3.3.0'

simple_backup/simple_backup.py

@@ -1,17 +1,73 @@
 #!/usr/bin/python3
 
 # Import libraries
-from dotenv import load_dotenv
 import os
+from functools import wraps
 from shutil import rmtree
 import argparse
 import configparser
 import logging
 from logging import StreamHandler
-from logging.handlers import RotatingFileHandler
+from timeit import default_timer
 from subprocess import Popen, PIPE, STDOUT
 from datetime import datetime
 from tempfile import mkstemp
+from dotenv import load_dotenv
+
+try:
+    from systemd import journal
+except ImportError:
+    journal = None
+
+try:
+    import dbus
+except ImportError:
+    pass
+
+
+load_dotenv()
+euid = os.geteuid()
+
+if euid == 0:
+    user = os.getenv('SUDO_USER')
+    homedir = os.path.expanduser(f'~{user}')
+else:
+    homedir = os.getenv('HOME')
+
+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)
+
+
+def timing(_logger):
+    def decorator_timing(func):
+        @wraps(func)
+        def wrapper_timing(*args, **kwargs):
+            start = default_timer()
+
+            value = func(*args, **kwargs)
+
+            end = default_timer()
+
+            _logger.info(f'Elapsed time: {end - start:.3f} seconds')
+
+            return value
+
+        return wrapper_timing
+
+    return decorator_timing
 
 
 class MyFormatter(argparse.RawTextHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
@@ -20,12 +76,13 @@ class MyFormatter(argparse.RawTextHelpFormatter, argparse.ArgumentDefaultsHelpFo
 
 class Backup:
 
-    def __init__(self, inputs, output, exclude, keep, options):
+    def __init__(self, inputs, output, exclude, keep, options, remove_before=False):
         self.inputs = inputs
         self.output = output
         self.exclude = exclude
         self.options = options
         self.keep = keep
+        self.remove_before = remove_before
         self._last_backup = ''
         self._output_dir = ''
         self._inputs_path = ''
@@ -38,22 +95,18 @@ class Backup:
 
             return False
 
-        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.inpts.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
 
         if not os.path.isdir(self.output):
             logger.critical('Output path for backup does not exist')
 
             return False
 
+        self.output = os.path.abspath(self.output)
+
         if self.keep is None:
             self.keep = -1
 
@@ -69,15 +122,11 @@ class Backup:
     def remove_old_backups(self):
         try:
             dirs = os.listdir(f'{self.output}/simple_backup')
-        except Exception:
-            logger.info('No older backups to remove')
-
+        except FileNotFoundError:
             return
 
-        if dirs.count('last_backup') > 0:
-            dirs.remove('last_backup')
-
         n_backup = len(dirs) - 1
+        count = 0
 
         if n_backup > self.keep:
             logger.info('Removing old backups...')
@@ -86,32 +135,45 @@ class Backup:
             for i in range(n_backup - self.keep):
                 try:
                     rmtree(f'{self.output}/simple_backup/{dirs[i]}')
-                except Exception:
-                    logger.error(f'Error while removing backup {dirs[i]}')
+                    count += 1
+                except FileNotFoundError:
+                    logger.error(f'Error while removing backup {dirs[i]}. Directory not found')
+                except PermissionError:
+                    logger.error(f'Error while removing backup {dirs[i]}. Permission denied')
+
+            if count == 1:
+                logger.info(f'Removed {count} backup')
+            else:
+                logger.info(f'Removed {count} backups')
 
     def find_last_backup(self):
-        if os.path.islink(f'{self.output}/simple_backup/last_backup'):
         try:
-                self._last_backup = os.readlink(f'{self.output}/simple_backup/last_backup')
-            except Exception:
-                logger.error('Previous backup could not be read')
+            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
+
+        try:
+            self._last_backup = dirs[-1]
+        except IndexError:
+            logger.info('No previous backups available')
 
     # Function to read configuration file
+    @timing(logger)
     def run(self):
         logger.info('Starting backup...')
 
-        self.create_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
+            notify('Starting backup...')
+        except NameError:
+            pass
 
-        inputs_handle, self._inputs_path = mkstemp(prefix='tmp_inputs', text=True)
-        exclude_handle, self._exclude_path = mkstemp(prefix='tmp_exclude', text=True)
+        self.find_last_backup()
+        self.create_backup_dir()
+
+        _, self._inputs_path = mkstemp(prefix='tmp_inputs', text=True)
+        _, self._exclude_path = mkstemp(prefix='tmp_exclude', text=True)
 
         with open(self._inputs_path, 'w') as fp:
             for i in self.inputs:
@@ -122,10 +184,14 @@ class Backup:
                     fp.write('\n')
 
         with open(self._exclude_path, 'w') 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 == '':
@@ -140,15 +206,15 @@ class Backup:
         p = Popen(rsync, stdout=PIPE, stderr=STDOUT, shell=True)
         output, _ = p.communicate()
 
-        logger.info(f'Output of rsync command: {output.decode("utf-8")}')
-
-        try:
-            os.symlink(self._output_dir, f'{self.output}/simple_backup/last_backup')
-        except Exception:
-            logger.error('Failed to create last_backup link')
+        if p.returncode != 0:
             self._err_flag = True
 
-        if self.keep != -1:
+        output = output.decode("utf-8").split('\n')
+
+        logger.info(f'rsync: {output[-3]}')
+        logger.info(f'rsync: {output[-2]}')
+
+        if self.keep != -1 and not self.remove_before:
             self.remove_old_backups()
 
         os.remove(self._inputs_path)
@@ -159,44 +225,24 @@ class Backup:
         if self._err_flag:
             logger.warning('Some errors occurred (check log for details)')
 
-
-load_dotenv()
-euid = os.geteuid()
-
-if euid == 0:
-    user = os.getenv("SUDO_USER")
-    homedir = os.path.expanduser(f'~{user}')
-else:
-    homedir = os.getenv('HOME')
-
-logging.getLogger().setLevel(logging.DEBUG)
-logger = logging.getLogger(os.path.basename(__file__))
-c_handler = StreamHandler()
-
             try:
-    f_handler = RotatingFileHandler(f'{homedir}/.simple_backup/simple_backup.log', maxBytes=1024000, backupCount=5)
-except Exception:
-    f_handler = None
-
-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 f_handler:
-    f_handler.setLevel(logging.INFO)
-    f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    f_handler.setFormatter(f_format)
-    logger.addHandler(f_handler)
+                notify('Backup finished with errors (check log for details)')
+            except NameError:
+                pass
+        else:
+            try:
+                notify('Backup finished')
+            except NameError:
+                pass
 
 
 def _parse_arguments():
     parser = argparse.ArgumentParser(prog='simple_backup',
-                                     description='A simple backup script written in Python that uses rsync to copy files',
+                                     description='Simple backup script written in Python that uses rsync to copy files',
                                      epilog='Report bugs to dfucini<at>gmail<dot>com',
                                      formatter_class=MyFormatter)
 
-    parser.add_argument('-c', '--config', default=f'{homedir}/.simple_backup/simple_backup.config',
+    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('-o', '--output', help='Output directory for the backup')
@@ -204,6 +250,9 @@ def _parse_arguments():
     parser.add_argument('-k', '--keep', type=int, help='Number of old backups to keep')
     parser.add_argument('-s', '--checksum', action='store_true',
                         help='Use checksum rsync option to compare files (MUCH SLOWER)')
+    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')
 
     args = parser.parse_args()
 
@@ -229,8 +278,33 @@ def _read_config(config_file):
     return inputs, output, exclude, keep
 
 
+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():
     args = _parse_arguments()
+
+    if args.no_syslog:
+        try:
+            logger.removeHandler(j_handler)
+        except NameError:
+            pass
+
     inputs, output, exclude, keep = _read_config(args.config)
 
     if args.input is not None:
@@ -250,11 +324,15 @@ def simple_backup():
     else:
         backup_options = '-arvh -H -X'
 
-    backup = Backup(inputs, output, exclude, keep, backup_options)
+    backup = Backup(inputs, output, exclude, keep, backup_options, remove_before=args.remove_before_backup)
 
     if backup.check_params():
         backup.run()
 
+        return 0
+
+    return 1
+
 
 if __name__ == '__main__':
     simple_backup()