# Remote only: Create a new ssh key
ssh-keygen -q -N '' -a 4096 -f ~/backup_scripts/remote/SSHKey.pem
# Remote only: Prepare the ssh-env-vars for repository creation
export BORG_RSH='ssh -i ~/backup_scripts/remote/SSHKey.pem'
# Remote only: View the public key and MAKE SURE TO INSTALL IT NOW on the target server!
cat ~/backup_scripts/remote/SSHKey.pem.pub

# Create a new encryption key
openssl rand -base64 4096 > ~/backup_scripts/remote/BORGKeyPassword.file
# Prepare the env-vars for repository creation
export BORG_PASSPHRASE=`cat ~/backup_scripts/remote/BORGKeyPassword.file`
# Create the repo!
borg init -e keyfile ssh://server/./subdir
# And make sure to have a key backup!!!
borg key export ssh://server/./subdir ~/backup_scripts/remote/BORGKey.bak

backup:
  - $HOME/backup_scripts/
target: 'ssh://server/./subdir'
options:
  backup: '-C lzma,9'
  cleanup: '--lock-wait 60'
  check: ''
cleanup:
  daily: 7
  weekly: 4
  monthly: 6
  yearly: 2
tries:
  backup: 3
  cleanup: 3
  check: 3

#!/usr/bin/python3
import os, sys, yaml, time, logging, argparse, subprocess
logger = logging.getLogger(__name__)

# Base variables
configDirPath = os.path.join(os.path.expanduser('~'), 'backup_scripts')

# Parse args
parser = argparse.ArgumentParser()
parser.add_argument('--config', help='Set the configuration directory name (located at ' + configDirPath + ').', type=str, required=True)
parser.add_argument('--shell', help='Execute a shell with all environment variables set.', action='store_true')
parser.add_argument('--debug', help='Debug mode! Also add "-v" o the borg-command.', action='store_true')
parser.add_argument('--output', help='Do not capture the borg-command outputs.', action='store_true')
parser.add_argument('--nocreate', help='Skip archive creation.', action='store_true')
parser.add_argument('--nocleanup', help='Skip repository cleanup.', action='store_true')
parser.add_argument('--nocheck', help='Skip repository checks.', action='store_true')
parser.add_argument('--progress', help='Show progress by adding "-p" o the borg-command.', action='store_true')
args = parser.parse_args()

if args.debug:
    logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.DEBUG)
else:
    logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)

if args.debug and args.progress and not args.shell and not args.output:
    logging.warning('Please note, that you won\'t see any progress (even in "--debug" mode) as the output is still captured. Use "--output" instead.')

# Make sure config dir is available
configDirPath = os.path.join(configDirPath, args.config)
if not os.path.isdir(configDirPath):
    logger.critical('Config dir (' + configDirPath + ') not available!')
    sys.exit(1)

# Read config vars
configFilePath = os.path.join(configDirPath, 'config.yaml')
if not os.path.isfile(configFilePath):
    logger.critical('Config file (' + configFilePath + ') not available!')
    sys.exit(2)
with open(configFilePath, 'r') as configFile:
    configDict = yaml.safe_load(configFile)
configBackupThis = [os.path.expandvars(x) for x in configDict['backup']]
configBackupOptions = configDict['options']['backup'].split(' ') if configDict['options']['backup'] != '' else []
configCleanupOptions = configDict['options']['cleanup'].split(' ') if configDict['options']['cleanup'] != '' else []
configCheckOptions = configDict['options']['check'].split(' ') if configDict['options']['check'] != '' else []
if args.progress:
    configBackupOptions.append('-p')
    configCleanupOptions.append('-p')
    configCheckOptions.append('-p')
if args.debug:
    configBackupOptions.append('-v')
    configCleanupOptions.append('-v')
    configCheckOptions.append('-v')

# Make sure every backup target exists
if not args.nocreate:
    for p in configBackupThis:
        if not os.path.exists(p):
            if not not args.shell:
                logger.warning('Backup path (' + p + ') not available!')
            else:
                logger.critical('Backup path (' + p + ') not available!')
                sys.exit(3)

# Prepare environment variables
os.environ['THIS_TARGET'] = configDict['target']
targetIsRemote = configDict['target'].startswith('ssh://')
if targetIsRemote:
    sshKeyPath = os.path.join(configDirPath, 'SSHKey.pem')
    os.environ['BORG_RSH'] = 'ssh -i ' + sshKeyPath
    if not os.path.isfile(sshKeyPath):
        logger.critical('SSH key (' + sshKeyPath + ') not available!')
        sys.exit(4)
os.environ['BORG_KEY_FILE'] = os.path.join(configDirPath, 'BORGKey.bak')
# I tried to load the file in the BORG_PASSPHRASE variable, but Python does not seem to handle new lines consistently (sometimes they are just becoming spaces)
os.environ['BORG_PASSCOMMAND'] = 'cat "' + os.path.join(configDirPath, 'BORGKeyPassword.file') + '"'
os.environ['BACKUP_THIS'] = ' '.join(configBackupThis)

# Should we fire of a shell?
if args.shell:
    logger.info('Following environment variables are set for you:')
    vars = ['THIS_TARGET', 'BORG_PASSCOMMAND', 'BACKUP_THIS', 'BORG_KEY_FILE']
    if targetIsRemote:
        vars.append('BORG_RSH')
    for v in sorted(vars):
        logger.info('\t' + v)
    logger.info('Try to execute "borg info $THIS_TARGET" to test the connection.')
    logger.info('Starting shell...')
    os.system(os.environ['SHELL'])
    logger.info('Bye!')
else:
    # Run other stuff - add your own backup commands here!

    # Note this: https://borgbackup.readthedocs.io/en/stable/internals/frontends.html
    # Therefore we are not importing borg here, but instead use the command line interface!
    def runBorgCommand(cmnd, tries):
        for tryNum in range(1, tries+1):
            logger.debug(cmnd)
            if args.output:
                proc = subprocess.Popen(cmnd)
            else:
                proc = subprocess.Popen(cmnd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
            stdout, _ = proc.communicate()
            if proc.returncode != 0:
                # Whoops!
                logger.error('Something went wrong (try {} out of {}):'.format(tryNum, tries))
                logger.error(stdout)
                time.sleep(10)
            else:
                logger.debug(proc.returncode)
                if not args.output:
                    logger.info(stdout)
                break
        if tryNum == tries:
            logger.error('Cleanup failed.')
        return tryNum != tries

    # Create new archive
    createOK = args.nocreate
    if not args.nocreate:
        cmnd = ['borg', 'create', '-s']
        cmnd += configBackupOptions
        cmnd += [configDict['target'] + '::' + str(time.time())]
        cmnd += configBackupThis
        logger.info('Backup started...')
        createOK = runBorgCommand(cmnd, configDict['tries']['backup'])

    # Cleanup
    cleanOK = args.nocleanup
    if not args.nocleanup:
        cmnd = ['borg', 'prune', '-s']
        cmnd += configCleanupOptions
        cmnd += [configDict['target'], '--keep-daily=' + str(configDict['cleanup']['daily']), '--keep-weekly=' + str(configDict['cleanup']['weekly']), '--keep-monthly=' + str(configDict['cleanup']['monthly']), '--keep-yearly=' + str(configDict['cleanup']['yearly'])]
        logger.info('Cleanup started...')
        cleanOK = runBorgCommand(cmnd, configDict['tries']['cleanup'])

    # Check (max-duration requires borgbackup version >= 1.2.0)
    checkOK = args.nocheck
    if not args.nocheck:
        cmnd = ['borg', 'check', '--max-duration=' + str(60 * 60)] # Run archive checks for up to one hour
        cmnd += configCheckOptions
        cmnd += [configDict['target']]
        logger.info('Cleanup started...')
        checkOK = runBorgCommand(cmnd, configDict['tries']['check'])

    if createOK and cleanOK and checkOK:
        logger.info('Jobs successful finished.')
    else:
        logger.warning('At least one job failed.')
        sys.exit(5)