#!/usr/bin/env python3
"""Back up RouterOS devices using the system OpenSSH client."""

__author__ = 'Sergei S., https://www.makeitwork.cz/'
__license__ = 'MIT'
__version__ = '0.1.0'

import argparse
from datetime import datetime
import math
from pathlib import Path
import re
import subprocess
import sys
import tempfile
import time

import yaml


class BackupError(Exception):
    """An unsuccessful backup; remote files are retained on copy failure."""


def parser():
    ap = argparse.ArgumentParser(description=f'RouterOS backup tool version {__version__}')
    ap.add_argument('--version', action='version', version=__version__)
    ap.add_argument('-f', '--config', default='/usr/local/etc/rosbak.yml', metavar='FILE')
    ap.add_argument('-p', '--port', type=int, metavar='PORT')
    ap.add_argument('-i', '--ssh-key', metavar='FILE')
    ap.add_argument('-u', '--username', metavar='USER')
    ap.add_argument('-d', '--dir', metavar='PATH')
    ap.add_argument('-z', '--delay', type=float, metavar='SEC')
    ap.add_argument('-o', '--fname', metavar='NAME')
    ap.add_argument('-k', '--keep', action='store_true', default=None,
                    help='Keep backup on host')
    ap.add_argument('-x', '--export', action='store_true', default=None,
                    help='Export config to file as well')
    ap.add_argument('host', metavar='HOST')
    return ap


def load_config(args):
    try:
        with Path(args.config).expanduser().open(encoding='utf-8') as fh:
            config = yaml.safe_load(fh)
    except FileNotFoundError:
        config = {}
    if config is None:
        config = {}
    if not isinstance(config, dict):
        raise ValueError('Configuration must be a YAML mapping')
    host_config = config.get(args.host, {})
    if not isinstance(host_config, dict):
        raise ValueError('Host configuration must be a YAML mapping')
    defaults = dict(dir='.', port=22, username='admin', delay=2,
                    fname=args.host + datetime.now().strftime('-%Y%m%d-%H%M%S'),
                    keep=False, export=False, ssh_key=None, addr=args.host)
    cfg = defaults.copy()
    for key in defaults:
        for source in (config, host_config, vars(args)):
            if key in source and source[key] is not None:
                cfg[key] = source[key]
    for key in ('addr', 'username', 'dir', 'fname'):
        if not isinstance(cfg[key], str) or not cfg[key]:
            raise ValueError(f'{key} must be a nonempty string')
    if not re.fullmatch(r'[A-Za-z0-9_.:\[\]-]+', cfg['addr']) or cfg['addr'].startswith('-'):
        raise ValueError('Invalid host address')
    if not re.fullmatch(r'[A-Za-z0-9_.-]+', cfg['username']) or cfg['username'].startswith('-'):
        raise ValueError('Invalid SSH username')
    if not re.fullmatch(r'[A-Za-z0-9_.-]+', cfg['fname']) or cfg['fname'] in ('.', '..'):
        raise ValueError('Backup name must contain only letters, digits, dots, underscores or hyphens')
    if type(cfg['port']) is not int or not 1 <= cfg['port'] <= 65535:
        raise ValueError('port must be an integer between 1 and 65535')
    if (type(cfg['delay']) not in (int, float) or not math.isfinite(cfg['delay'])
            or cfg['delay'] < 0):
        raise ValueError('delay must be a finite nonnegative number')
    for key in ('keep', 'export'):
        if type(cfg[key]) is not bool:
            raise ValueError(f'{key} must be a YAML boolean')
    if cfg['ssh_key'] is not None:
        if not isinstance(cfg['ssh_key'], str) or not cfg['ssh_key']:
            raise ValueError('ssh_key must be a nonempty path')
        cfg['ssh_key'] = str(Path(cfg['ssh_key']).expanduser())
    cfg['dir'] = str(Path(cfg['dir'].replace('{host}', args.host)).expanduser())
    return cfg


def ssh_options(cfg):
    options = ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=15',
               '-o', 'ServerAliveInterval=15', '-o', 'ServerAliveCountMax=3']
    if cfg['ssh_key']:
        options += ['-i', cfg['ssh_key']]
    return options


def run(argv, description):
    result = subprocess.run(argv, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
                            text=True, umask=0o077)
    if result.returncode:
        detail = result.stderr.strip()
        raise BackupError(f'{description}' + (f': {detail}' if detail else ''))


def ros_cmd(cfg, command):
    run(['ssh', *ssh_options(cfg), '-p', str(cfg['port']),
         f"{cfg['username']}@{cfg['addr']}", command], 'RouterOS command failed')


def copy_file(cfg, suffix, destination):
    name = cfg['fname'] + suffix
    # OpenSSH 9 defaults to SFTP, which RouterOS does not support. Force SCP.
    address = cfg['addr']
    if ':' in address and not address.startswith('['):
        address = f'[{address}]'
    remote = f"{cfg['username']}@{address}:/{name}"
    with tempfile.NamedTemporaryFile(prefix='.rosbak-', dir=destination, delete=False) as fh:
        temporary = Path(fh.name)
    try:
        run(['scp', '-O', *ssh_options(cfg), '-P', str(cfg['port']),
             remote, str(temporary)], f'Unable to copy {name}; remote files retained')
        if temporary.stat().st_size == 0:
            raise BackupError(f'Empty {name}; remote files retained')
        temporary.chmod(0o600)
        temporary.replace(destination / name)
    finally:
        temporary.unlink(missing_ok=True)


def backup(cfg):
    destination = Path(cfg['dir'])
    destination.mkdir(parents=True, exist_ok=True, mode=0o700)
    name = cfg['fname']
    ros_cmd(cfg, f'/system backup save name="{name}"')
    if cfg['export']:
        ros_cmd(cfg, f'/export file="{name}"')
    time.sleep(cfg['delay'])
    suffixes = ['.backup', '.rsc'] if cfg['export'] else ['.backup']
    for suffix in suffixes:
        copy_file(cfg, suffix, destination)
    # Do not delete either remote file until every requested download succeeded.
    if not cfg['keep']:
        for suffix in suffixes:
            ros_cmd(cfg, f'/file remove "{name}{suffix}"')
    for suffix in suffixes:
        print(destination / (name + suffix))


def main(argv=None):
    args = parser().parse_args(argv)
    try:
        backup(load_config(args))
    except (OSError, ValueError, yaml.YAMLError, BackupError) as exc:
        print(f'rosbak: {exc}', file=sys.stderr)
        return 1
    return 0


if __name__ == '__main__':
    sys.exit(main())
