#!/usr/bin/python3
import json
import os
import platform
import queue
import re
import shutil
import socket
import ssl
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.request

VERSION = '1.0.0'
CONF_DIR = '/etc/htc-vnc'
STATE_FILE = CONF_DIR + '/agent.json'
PERM_FILE = CONF_DIR + '/permissions.json'
KEY_FILE = CONF_DIR + '/wg.key'
WG_NAME = 'htcvnc'
WG_CONF = '/etc/wireguard/' + WG_NAME + '.conf'
DEFAULT_SERVER = 'https://vnc.ht-c.ru'
SAFE = ['services', 'service_status', 'journal', 'processes', 'disk', 'ports', 'updates_check', 'docker_ps']
DANGEROUS = ['service_control', 'apt_update', 'apt_upgrade', 'reboot', 'ufw_rule', 'docker_control']
ALL_ACTIONS = SAFE + DANGEROUS
UNIT_RE = re.compile(r'^[A-Za-z0-9@._:-]{1,80}\.(service|socket|timer)$')
CONTAINER_RE = re.compile(r'^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$')
CIDR_RE = re.compile(r'^\d{1,3}(\.\d{1,3}){3}(/\d{1,2})?$')
MAX_OUT = 50000


def die(msg, code=1):
    sys.stderr.write(msg + '\n')
    sys.exit(code)


def need_root():
    if os.geteuid() != 0:
        die('Запустите от root: sudo htc-vnc ...')


def read_json(path, default):
    try:
        with open(path) as f:
            return json.load(f)
    except (OSError, ValueError):
        return default


def write_secret(path, data):
    tmp = path + '.tmp'
    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
    with os.fdopen(fd, 'w') as f:
        f.write(data)
    os.replace(tmp, path)


def run(cmd, timeout=60, stdin=None, env=None):
    e = dict(os.environ)
    e['LC_ALL'] = 'C.UTF-8'
    e['LANG'] = 'C.UTF-8'
    if env:
        e.update(env)
    try:
        p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, input=stdin, timeout=timeout, env=e)
        return p.returncode, p.stdout.decode('utf-8', 'replace')
    except subprocess.TimeoutExpired:
        return 124, 'Превышено время ожидания'
    except OSError as ex:
        return 127, 'Не удалось запустить команду: %s' % ex


def clip(text):
    if len(text) > MAX_OUT:
        return text[:MAX_OUT] + '\n… вывод обрезан'
    return text


def post(server, path, payload, token=None):
    if not server.startswith('https://'):
        die('Сервер должен использовать https')
    req = urllib.request.Request(server + path, data=json.dumps(payload).encode(), method='POST')
    req.add_header('Content-Type', 'application/json')
    req.add_header('User-Agent', 'htc-vnc-agent/' + VERSION)
    if token:
        req.add_header('Authorization', 'Bearer ' + token)
    ctx = ssl.create_default_context()
    try:
        with urllib.request.urlopen(req, timeout=25, context=ctx) as r:
            return r.status, json.loads(r.read(2000000).decode())
    except urllib.error.HTTPError as ex:
        try:
            return ex.code, json.loads(ex.read(200000).decode())
        except ValueError:
            return ex.code, {'ok': False, 'error': 'HTTP %d' % ex.code}


def os_name():
    try:
        with open('/etc/os-release') as f:
            for line in f:
                if line.startswith('PRETTY_NAME='):
                    return line.split('=', 1)[1].strip().strip('"')
    except OSError:
        pass
    return platform.system() + ' ' + platform.release()


def load_perms():
    allow = read_json(PERM_FILE, {}).get('allow')
    if not isinstance(allow, list):
        allow = list(SAFE)
    return [a for a in allow if a in ALL_ACTIONS]


def save_perms(allow):
    write_secret(PERM_FILE, json.dumps({'allow': sorted(set(allow))}))


def wg_text(priv, st):
    return ('[Interface]\nPrivateKey = %s\nAddress = %s/24\nMTU = 1380\nTable = off\n\n[Peer]\nPublicKey = %s\nEndpoint = %s\nAllowedIPs = %s\nPersistentKeepalive = 25\n'
            % (priv, st['ip'], st['hub_pub'], st['endpoint'], st['cidr']))


def wg_up():
    return run(['ip', 'link', 'show', WG_NAME])[0] == 0


def apply_wg(st, enabled=True):
    try:
        priv = open(KEY_FILE).read().strip()
    except OSError:
        return 'нет ключа WireGuard'
    if not enabled:
        if wg_up():
            run(['wg-quick', 'down', WG_NAME])
        return None
    text = wg_text(priv, st)
    cur = None
    try:
        cur = open(WG_CONF).read()
    except OSError:
        pass
    if cur == text and wg_up():
        return None
    os.makedirs('/etc/wireguard', mode=0o700, exist_ok=True)
    write_secret(WG_CONF, text)
    if wg_up():
        run(['wg-quick', 'down', WG_NAME])
    code, out = run(['wg-quick', 'up', WG_NAME])
    return None if code == 0 else out.strip()


def cmd_enroll(args):
    need_root()
    server = DEFAULT_SERVER
    key = None
    i = 0
    while i < len(args):
        if args[i] == '--server' and i + 1 < len(args):
            server = args[i + 1].rstrip('/')
            i += 2
            continue
        key = args[i]
        i += 1
    if not key:
        die('Использование: htc-vnc enroll КЛЮЧ [--server https://vnc.ht-c.ru]')
    if shutil.which('wg') is None or shutil.which('wg-quick') is None:
        die('Не установлен wireguard-tools')
    os.makedirs(CONF_DIR, mode=0o755, exist_ok=True)
    if read_json(STATE_FILE, {}).get('token'):
        die('Устройство уже подключено. Сначала выполните: htc-vnc leave')
    code, priv = run(['wg', 'genkey'])
    if code != 0:
        die('Не удалось создать ключ WireGuard')
    priv = priv.strip()
    code, pub = run(['wg', 'pubkey'], stdin=priv.encode())
    pub = pub.strip()
    status, r = post(server, '/agent/enroll', {'key': key, 'pubkey': pub, 'hostname': socket.gethostname(), 'os': os_name(), 'version': VERSION})
    if status != 200 or not r.get('ok'):
        die('Ошибка подключения: %s' % r.get('error', status))
    write_secret(KEY_FILE, priv + '\n')
    st = {'server': server, 'device_id': r['device_id'], 'token': r['token'], 'ip': r['ip'], 'cidr': r['cidr'], 'hub_pub': r['hub_pub'], 'endpoint': r['endpoint'], 'network': r.get('network', '')}
    write_secret(STATE_FILE, json.dumps(st))
    if not os.path.exists(PERM_FILE):
        save_perms(SAFE)
    err = apply_wg(st)
    if err:
        sys.stderr.write('Предупреждение: туннель не поднялся: %s\n' % err)
    run(['systemctl', 'daemon-reload'])
    run(['systemctl', 'enable', '--now', 'htc-vnc-agent'])
    print('Готово. Сеть: %s, внутренний IP: %s' % (st['network'], st['ip']))
    print('Сейчас разрешены действия: %s' % ', '.join(load_perms()))
    print('Разрешить управление службами, обновления, перезагрузку и файрвол: sudo htc-vnc allow <действие> (см. htc-vnc permissions)')


def cmd_status(args):
    st = read_json(STATE_FILE, {})
    if not st.get('token'):
        print('Не подключено. Выполните: sudo htc-vnc enroll КЛЮЧ')
        return
    print('Версия агента: %s' % VERSION)
    print('Сервер: %s' % st['server'])
    print('Сеть: %s, внутренний IP: %s (%s)' % (st.get('network', ''), st['ip'], st['cidr']))
    print('Туннель: %s' % ('поднят' if wg_up() else 'не поднят'))
    print('Служба агента: %s' % run(['systemctl', 'is-active', 'htc-vnc-agent'])[1].strip())
    print('Разрешённые действия: %s' % ', '.join(load_perms()))


def cmd_permissions(args):
    allow = load_perms()
    for a in ALL_ACTIONS:
        print('%-16s %-4s %s' % (a, 'ДА' if a in allow else 'нет', '(изменяет систему)' if a in DANGEROUS else ''))


def cmd_allow(args, grant):
    need_root()
    if not args:
        die('Укажите действия: %s или all' % ', '.join(ALL_ACTIONS))
    allow = load_perms()
    for a in args:
        if a == 'all':
            allow = list(ALL_ACTIONS) if grant else []
        elif a not in ALL_ACTIONS:
            die('Неизвестное действие: %s' % a)
        elif grant and a not in allow:
            allow.append(a)
        elif not grant and a in allow:
            allow.remove(a)
    save_perms(allow)
    print('Разрешено: %s' % (', '.join(allow) or 'ничего'))


def cmd_leave(args):
    need_root()
    st = read_json(STATE_FILE, {})
    if st.get('token'):
        try:
            post(st['server'], '/agent/leave', {}, st['token'])
        except Exception:
            pass
    run(['systemctl', 'disable', '--now', 'htc-vnc-agent'])
    if wg_up():
        run(['wg-quick', 'down', WG_NAME])
    for p in (STATE_FILE, KEY_FILE, WG_CONF):
        try:
            os.remove(p)
        except OSError:
            pass
    print('Устройство отключено от сети.')


UPDATES_CACHE = {'n': None}


def cpu_count():
    try:
        return os.cpu_count() or 1
    except Exception:
        return 1


def collect_metrics(extra):
    m = {'cpus': cpu_count(), 'kernel': platform.release()}
    try:
        l = open('/proc/loadavg').read().split()
        m['load1'], m['load5'], m['load15'] = float(l[0]), float(l[1]), float(l[2])
    except (OSError, ValueError, IndexError):
        pass
    try:
        info = {}
        for line in open('/proc/meminfo'):
            k, v = line.split(':', 1)
            info[k] = int(v.split()[0]) * 1024
        m['mem_total'] = info.get('MemTotal', 0)
        m['mem_avail'] = info.get('MemAvailable', 0)
        m['swap_total'] = info.get('SwapTotal', 0)
        m['swap_free'] = info.get('SwapFree', 0)
    except (OSError, ValueError):
        pass
    try:
        du = shutil.disk_usage('/')
        m['disk_total'], m['disk_used'] = du.total, du.used
    except OSError:
        pass
    try:
        m['uptime'] = int(float(open('/proc/uptime').read().split()[0]))
    except (OSError, ValueError, IndexError):
        pass
    m['reboot_required'] = os.path.exists('/var/run/reboot-required')
    if UPDATES_CACHE['n'] is not None:
        m['updates'] = UPDATES_CACHE['n']
    m.update(extra)
    return m


def failed_units():
    code, out = run(['systemctl', '--failed', '--no-legend', '--plain'], timeout=10)
    if code != 0:
        return None
    return len([x for x in out.splitlines() if x.strip()])


def need_unit(p):
    u = p.get('unit')
    if not isinstance(u, str) or not UNIT_RE.match(u):
        raise ValueError('Некорректное имя службы')
    return u


def do_action(action, p):
    if action == 'services':
        code, out = run(['systemctl', 'list-units', '--type=service', '--all', '--no-pager', '--no-legend', '--plain'])
        return code, '\n'.join(out.splitlines()[:400])
    if action == 'service_status':
        return run(['systemctl', 'status', need_unit(p), '--no-pager', '-l'])
    if action == 'journal':
        n = p.get('lines', 50)
        n = n if isinstance(n, int) and 1 <= n <= 200 else 50
        return run(['journalctl', '-u', need_unit(p), '-n', str(n), '--no-pager', '-o', 'short-iso'])
    if action == 'processes':
        code, out = run(['ps', '-eo', 'pid,user,pcpu,pmem,etime,comm', '--sort=-pcpu'])
        return code, '\n'.join(out.splitlines()[:41])
    if action == 'disk':
        return run(['df', '-hT', '-x', 'tmpfs', '-x', 'devtmpfs', '-x', 'overlay'])
    if action == 'ports':
        return run(['ss', '-tulpn'])
    if action == 'updates_check':
        if shutil.which('apt-get'):
            code, out = run(['apt-get', '-s', 'upgrade'], timeout=120)
            lines = [x for x in out.splitlines() if x.startswith('Inst ')]
            UPDATES_CACHE['n'] = len(lines)
            return code, ('Доступно обновлений: %d (по данным последнего apt update)\n' % len(lines)) + '\n'.join(lines[:200])
        if shutil.which('dnf'):
            code, out = run(['dnf', '-q', 'check-update'], timeout=180)
            UPDATES_CACHE['n'] = len([x for x in out.splitlines() if x.strip() and not x.startswith(' ')])
            return 0, out
        return 1, 'Менеджер пакетов не поддерживается'
    if action == 'service_control':
        op = p.get('op')
        if op not in ('start', 'stop', 'restart', 'reload'):
            raise ValueError('Некорректная операция')
        unit = need_unit(p)
        code, out = run(['systemctl', op, unit], timeout=90)
        c2, st = run(['systemctl', 'status', unit, '--no-pager', '-l', '-n', '5'])
        return code, out + st
    if action == 'apt_update':
        return run(['apt-get', 'update'], timeout=600, env={'DEBIAN_FRONTEND': 'noninteractive'})
    if action == 'apt_upgrade':
        return run(['apt-get', '-y', '-o', 'Dpkg::Options::=--force-confold', 'upgrade'], timeout=3000, env={'DEBIAN_FRONTEND': 'noninteractive'})
    if action == 'reboot':
        if p.get('confirm') is not True:
            raise ValueError('Не подтверждено')
        code, out = run(['shutdown', '-r', '+1', 'HORiZONT VNC: перезагрузка по запросу'])
        return code, out + '\nПерезагрузка через 1 минуту. Отмена: shutdown -c'
    if action == 'ufw_rule':
        if shutil.which('ufw') is None:
            return 1, 'ufw не установлен'
        op, port, proto, src = p.get('op'), p.get('port'), p.get('proto'), p.get('from') or ''
        if op not in ('allow', 'deny', 'delete') or not isinstance(port, int) or not 1 <= port <= 65535 or proto not in ('tcp', 'udp') or (src and not CIDR_RE.match(src)):
            raise ValueError('Некорректное правило')
        if op == 'deny' and port == 22:
            return 1, 'Блокировка порта 22 запрещена агентом, чтобы не потерять доступ'
        if src:
            rule = ['proto', proto, 'from', src, 'to', 'any', 'port', str(port)]
        else:
            rule = ['%d/%s' % (port, proto)]
        cmd = ['ufw', '--force', 'delete', 'allow'] + rule if op == 'delete' else ['ufw', op] + rule
        return run(cmd)
    if action == 'docker_ps':
        if shutil.which('docker') is None:
            return 1, 'Docker не установлен'
        return run(['docker', 'ps', '-a', '--format', 'table {{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'])
    if action == 'docker_control':
        c, op = p.get('container'), p.get('op')
        if not isinstance(c, str) or not CONTAINER_RE.match(c) or op not in ('start', 'stop', 'restart'):
            raise ValueError('Некорректные параметры')
        return run(['docker', op, c], timeout=120)
    raise ValueError('Неизвестное действие')


def worker(q, st):
    while True:
        c = q.get()
        action = c.get('action')
        params = c.get('params') if isinstance(c.get('params'), dict) else {}
        if action not in load_perms():
            status, out = 'error', 'Действие %s не разрешено на этом сервере. Выполните: sudo htc-vnc allow %s' % (action, action)
        else:
            try:
                code, out = do_action(action, params)
                status = 'done' if code == 0 else 'error'
            except ValueError as ex:
                status, out = 'error', str(ex)
            except Exception as ex:
                status, out = 'error', 'Ошибка агента: %s' % ex
        for _ in range(5):
            try:
                post(st['server'], '/agent/result', {'id': c['id'], 'status': status, 'output': clip(out)}, st['token'])
                break
            except Exception:
                time.sleep(5)


def cmd_run(args):
    need_root()
    st = read_json(STATE_FILE, {})
    if not st.get('token'):
        die('Устройство не подключено')
    q = queue.Queue()
    t = threading.Thread(target=worker, args=(q, st), daemon=True)
    t.start()
    err = apply_wg(st)
    if err:
        sys.stderr.write('wg: %s\n' % err)
    extra = {}
    last_units = 0
    delay = 15
    backoff = 0
    while True:
        if time.time() - last_units > 60:
            fu = failed_units()
            if fu is not None:
                extra['failed_units'] = fu
            last_units = time.time()
        payload = {'metrics': collect_metrics(extra), 'perms': load_perms(), 'version': VERSION, 'os': os_name(), 'hostname': socket.gethostname()}
        try:
            status, r = post(st['server'], '/agent/poll', payload, st['token'])
            if status == 401:
                sys.stderr.write('Сервер отклонил ключ устройства. Возможно, устройство удалено из сети.\n')
                apply_wg(st, False)
                time.sleep(120)
                continue
            if status == 200 and r.get('ok'):
                backoff = 0
                changed = False
                for k in ('ip', 'cidr', 'hub_pub', 'endpoint'):
                    if r.get(k) and r[k] != st.get(k):
                        st[k] = r[k]
                        changed = True
                if changed:
                    write_secret(STATE_FILE, json.dumps(st))
                e = apply_wg(st, bool(r.get('enabled', True)))
                if e:
                    sys.stderr.write('wg: %s\n' % e)
                for c in r.get('commands', []):
                    if isinstance(c, dict) and isinstance(c.get('id'), int):
                        q.put(c)
                delay = max(5, min(120, int(r.get('poll', 15))))
            else:
                backoff = min(60, backoff + 10)
        except Exception as ex:
            sys.stderr.write('poll: %s\n' % ex)
            backoff = min(60, backoff + 10)
        time.sleep(delay + backoff)


def main():
    a = sys.argv[1:]
    if not a or a[0] in ('-h', '--help', 'help'):
        print('HORiZONT VNC agent %s\n\nКоманды:\n  enroll КЛЮЧ     подключить сервер к сети\n  status          состояние\n  permissions     список разрешённых действий\n  allow ДЕЙСТВИЕ  разрешить действие (или all)\n  deny ДЕЙСТВИЕ   запретить действие\n  leave           отключить сервер от сети\n  run             запуск агента (используется службой)\n' % VERSION)
        return
    c, rest = a[0], a[1:]
    if c == 'enroll':
        cmd_enroll(rest)
    elif c == 'status':
        cmd_status(rest)
    elif c == 'permissions':
        cmd_permissions(rest)
    elif c == 'allow':
        cmd_allow(rest, True)
    elif c == 'deny':
        cmd_allow(rest, False)
    elif c == 'leave':
        cmd_leave(rest)
    elif c == 'run':
        cmd_run(rest)
    elif c in ('version', '--version'):
        print(VERSION)
    else:
        die('Неизвестная команда: %s (см. htc-vnc help)' % c)


if __name__ == '__main__':
    main()
