path: root/src/live/ogOperations.py

#
# Copyright (C) 2020-2021 Soleta Networks <info@soleta.eu>
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU Affero General Public License as published by the
# Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

import datetime
import hashlib
import logging
import os
import subprocess
import shlex
import shutil

from subprocess import Popen, PIPE

import fdisk

from src.ogRest import ThreadState
from src.live.partcodes import GUID_MAP
from src.live.parttypes import get_parttype

from src.utils.image import *
from src.utils.postinstall import configure_os
from src.utils.net import ethtool
from src.utils.menu import generate_menu
from src.utils.fs import *
from src.utils.probe import os_probe, get_cache_dev_path
from src.utils.disk import *
from src.utils.cache import *
from src.utils.tiptorrent import *
from src.utils.uefi import *
from src.utils.boot import *
from src.utils.sw_inventory import get_package_set
from src.utils.hw_inventory import get_hardware_inventory, legacy_list_hardware_inventory
from src.log import OgError


OG_SHELL = '/bin/bash'

class OgLiveOperations:
    def __init__(self, config):
        self._url = config['opengnsys']['url']
        self._url_log = config['opengnsys']['url_log']
        self._smb_user = config['samba']['user']
        self._smb_pass = config['samba']['pass']

    def _restartBrowser(self, url):
        try:
            proc = subprocess.call(["pkill", "-9", "browser"])
            proc = subprocess.Popen(["browser", "-qws", url])
        except OSError as e:
            raise OgError('Cannot restart browser') from e

    def _refresh_payload_disk(self, cxt, part_setup, num_disk):
        part_setup['disk'] = str(num_disk)
        part_setup['disk_type'] = 'DISK'
        part_setup['partition'] = '0'
        part_setup['filesystem'] = ''
        part_setup['os'] = ''
        part_setup['size'] = str(cxt.nsectors * cxt.sector_size // 1024)
        part_setup['used_size'] = '0'
        if not cxt.label:
            part_setup['code'] = '0'
        else:
            part_setup['code'] = '2' if cxt.label.name == 'gpt' else '1'

    def _refresh_payload_partition(self, cxt, pa, part_setup, disk):
        parttype = cxt.partition_to_string(pa, fdisk.FDISK_FIELD_TYPEID)
        fstype = cxt.partition_to_string(pa, fdisk.FDISK_FIELD_FSTYPE)
        padev = cxt.partition_to_string(pa, fdisk.FDISK_FIELD_DEVICE)
        size = cxt.partition_to_string(pa, fdisk.FDISK_FIELD_SIZE)
        partnum = pa.partno + 1
        source = padev
        target = padev.replace('dev', 'mnt')

        if cxt.label.name == 'gpt':
            code = GUID_MAP.get(parttype, 0x0)
        else:
            code = int(parttype, base=16)

        if mount_mkdir(source, target):
            probe_result = os_probe(target)
            part_setup['os'] = probe_result
            part_setup['used_size'] = get_usedperc(target)
            umount(target)
        else:
            part_setup['os'] = ''
            part_setup['used_size'] = '0'


        part_setup['disk_type'] = ''
        part_setup['partition'] = str(partnum)
        part_setup['filesystem'] = fstype.upper() if fstype else 'EMPTY'
        # part_setup['code'] = hex(code).removeprefix('0x')
        part_setup['code'] = hex(code)[2:]
        part_setup['size'] = str(int(size) // 1024)

        if (part_setup['filesystem'] == 'VFAT'):
            part_setup['filesystem'] = 'FAT32'

        if (part_setup['filesystem'] == 'SWAP'):
            part_setup['filesystem'] = 'LINUX-SWAP'

    def _refresh_part_setup_cache(self, cxt, pa, part_setup, cache):
        padev = cxt.partition_to_string(pa, fdisk.FDISK_FIELD_DEVICE)
        if padev == cache:
            part_setup['filesystem'] = 'CACHE'
            part_setup['code'] = 'ca'

    def _get_cache_contents(self):
        cache_contents = []

        if not mount_cache():
            return cache_contents

        img_dir = OG_CACHE_IMAGE_PATH

        if not os.path.isdir(img_dir):
            return cache_contents

        for file_name in os.listdir(img_dir):
            file_path = os.path.join(img_dir, file_name)

            if not os.path.isfile(file_path):
                continue
            if not file_name.endswith('.img'):
                continue

            checksum_file_path = file_path + '.full.sum'
            image_checksum = ''

            try:
                with open(checksum_file_path, 'r') as f:
                    image_checksum = f.read()
            except (FileNotFoundError, PermissionError, OSError) as e:
                logging.error(f'Cannot read checksum file {checksum_file_path}: {e}')

            if not image_checksum:
                logging.error(f'Empty checksum for image {file_name}')

            image_size = os.stat(file_path).st_size
            cache_contents.append({
                'name': file_name,
                'size': image_size,
                'checksum': image_checksum})
        return cache_contents

    def _compute_md5(self, path, bs=2**20):
        m = hashlib.md5()
        with open(path, 'rb') as f:
            while True:
                buf = f.read(bs)
                if not buf:
                    break
                m.update(buf)
        return m.hexdigest()

    def _md5_file(self, path):
        if not os.path.exists(path):
            raise OgError(f'Failed to calculate checksum, image file {path} does not exist')

        return self._compute_md5(path)

    def _write_md5_file(self, path, checksum):
        if not os.path.exists(path):
            raise OgError(f'Failed to calculate checksum, image file {path} does not exist')

        filename = path + ".full.sum"
        try:
            with open(filename, 'w') as f:
                f.write(checksum)
        except:
            logging.error(f'Cannot write checksum {filename}')
            return -1

        return 0

    def _fetch_image_unicast(self, repo, image_name):
        """
        Copies /opt/opengnsys/image/{image_name} into
        /opt/opengnsys/cache/opt/opengnsys/images/

        Implies a unicast transfer. Does not use tiptorrent.
        """
        if not get_cache_dev_path():
                raise OgError('No cache partition is mounted')

        dst = f'{OG_CACHE_IMAGE_PATH}{image_name}.img'

        if (os.path.exists(dst) and tip_check_csum(repo, image_name)):
            return

        try:
            if os.path.exists(dst):
                os.unlink(dst)
            if os.path.exists(f"{dst}.full.sum"):
                os.unlink(f"{dst}.full.sum")
        except OSError as e:
            raise OgError(f"Error deleting file {e.filename}: {e.strerror}") from e

        src = f'/opt/opengnsys/images/{image_name}.img'
        try:
            logging.info(f'Fetching image {image_name} from {src}')
            logging.info('*DO NOT REBOOT OR POWEROFF* the client during this time')
            r = shutil.copy(src, dst)
            tip_write_csum(image_name)
        except (OSError, OgError) as e:
            try:
                if os.path.exists(dst):
                    os.unlink(dst)
                if os.path.exists(f"{dst}.full.sum"):
                    os.unlink(f"{dst}.full.sum")
            except OSError as e:
                pass
            raise OgError(f'Error copying image {image_name} to cache. Reported: {e}') from e

        if (not os.path.exists(dst)):
            raise OgError(f'could not find {dst} in cache')
        if (not tip_check_csum(repo, image_name)):
            raise OgError(f'Failed to validate checksum for {image_name}.img')

    def _restore_image_unicast(self, repo, name, devpath, cache=False):
        if ogChangeRepo(repo, smb_user=self._smb_user, smb_pass=self._smb_pass) != 0:
            self._restartBrowser(self._url)
            raise OgError(f'Cannot change repository to {repo}')

        if cache:
            self._fetch_image_unicast(repo, name)
            image_path = f'{OG_CACHE_IMAGE_PATH}{image_name}.img'
        else:
            if os.access(f'/opt/opengnsys/images', os.R_OK) == False:
                raise OgError('Cannot access /opt/opengnsys/images in read mode, check permissions')

            logging.warn(f'Checksum validation is *NOT* available with UNICAST-DIRECT!')
            image_path = f'/opt/opengnsys/images/{name}.img'

        self._restore_image(image_path, devpath)

    def _fetch_image_tiptorrent(self, repo, name):
        if not get_cache_dev_path():
            raise OgError('No cache partition is mounted')

        fetch = False
        image_path = f'{OG_CACHE_IMAGE_PATH}{name}.img'
        try:
            if (not os.path.exists(image_path) or not tip_check_csum(repo, name)):
                tip_client_get(repo, name)
                fetch = True
        except:
            self._restartBrowser(self._url)
            raise

        if fetch:
            if (not os.path.exists(image_path)):
                raise OgError(f'could not find {image_path} in cache')
            if (not tip_check_csum(repo, name)):
                raise OgError(f'Failed to validate checksum for {name}.img')
        return image_path

    def _restore_image_tiptorrent(self, repo, name, devpath):
        image_path = self._fetch_image_tiptorrent(repo, name)
        self._restore_image(image_path, devpath)

    def _restore_image(self, image_path, devpath):
        logging.info(f'Restoring image at {image_path} into {devpath}')
        logging.info('*DO NOT REBOOT OR POWEROFF* the client during this time')

        cmd_lzop = shlex.split(f'lzop -dc {image_path}')
        cmd_pc = shlex.split(f'partclone.restore -d0 -C -I -o {devpath}')

        if not os.path.exists(image_path):
            raise OgError(f'Image not found at {image_path} during image restore')

        with open('/tmp/command.log', 'wb', 0) as logfile:
            proc_lzop = subprocess.Popen(cmd_lzop,
                                         stdout=subprocess.PIPE)
            proc_pc = subprocess.Popen(cmd_pc,
                                       stdin=proc_lzop.stdout,
                                       stderr=logfile)
            proc_lzop.stdout.close()
            proc_pc.communicate()

    def _ogbrowser_clear_logs(self):
        logfiles = ['/tmp/command.log', '/tmp/session.log']
        for logfile in logfiles:
            with open(logfile, 'wb', 0) as f:
                f.truncate(0)

    def _poweroff_oglive(self, operation='poweroff'):
        interface = os.getenv('DEVICE')
        cmd_ethtool = shlex.split(f'ethtool -s {interface} wol g')
        cmd_browser = shlex.split('pkill -9 browser')
        if not shutil.which('busyboxOLD'):
            busybox = 'busybox'
        else:
            busybox = shutil.which('busyboxOLD')
        cmd_busybox = shlex.split(f'{busybox} {operation}')

        umount_all()
        umount_cache()
        if subprocess.run(cmd_ethtool).returncode != 0:
            logging.error('Error running ethtool subprocess')
        if subprocess.run(cmd_browser).returncode != 0:
            logging.error('Error terminating ogBrowser process')
        if subprocess.run(cmd_busybox) != 0:
            logging.error('Error running "busybox poweroff" subprocess')

    def poweroff(self):
        logging.info('Powering off client')
        self._poweroff_oglive()

    def reboot(self):
        logging.info('Rebooting client')
        self._poweroff_oglive(operation='reboot')

    def shellrun(self, request, ogRest):
        cmd = request.getrun()
        cmds = cmd.split(";|\n\r")

        self._restartBrowser(self._url_log)

        shell_path = '/opt/opengnsys/shell/'

        restricted_mode = False

        for file_name in os.listdir(shell_path):
            file_path = os.path.join(shell_path, file_name)

            if cmds[0] == file_name:
                cmds[0] = file_path
                restricted_mode = True
                break

        try:
            if restricted_mode:
                ogRest.proc = subprocess.Popen(cmds, stdout=subprocess.PIPE)
            else:
                ogRest.proc = subprocess.Popen(cmds,
                                stdout=subprocess.PIPE,
                                shell=True,
                                executable=OG_SHELL)
            (output, error) = ogRest.proc.communicate()
        except OSError as e:
            raise OgError(f'Error when running "shell run" subprocess: {e}') from e

        if ogRest.proc.returncode != 0:
            logging.warn('Non zero exit code when running: %s', ' '.join(cmds))
        else:
            logging.info('Shell run command OK')

        self.refresh(ogRest)

        return (ogRest.proc.returncode, " ".join(cmds), output.decode('utf-8'))

    def session(self, request, ogRest):
        disk = request.getDisk()
        partition = request.getPartition()

        boot_os_at(int(disk), int(partition))
        self.reboot()

    def software(self, request, ogRest):
        disk = request.getDisk()
        partition = request.getPartition()
        partdev = get_partition_device(int(disk), int(partition))
        mountpoint = partdev.replace('dev', 'mnt')
        if not mount_mkdir(partdev, mountpoint):
            raise OgError(f'Error mounting {partdev} at {mountpoint}')
        if not os.path.ismount(mountpoint):
            raise OgError(f'Invalid mountpoint {mountpoint} for software inventory')

        self._restartBrowser(self._url_log)
        pkgset = get_package_set(mountpoint)
        self._restartBrowser(self._url)

        umount(mountpoint)
        logging.info('Software inventory command OK')

        # Software inventory result is still processed by legacy server code
        # (ogAdmServer.c).  Legacy response format is string where each
        # software package is separated by a newline '\n'.
        # Each package/software line follows this format:
        # "{package_name} {package_version}"
        return '\n'.join(map(str,pkgset))

    def hardware(self, ogRest):
        self._restartBrowser(self._url_log)
        logging.info('Running hardware inventory command')

        try:
            inventory = get_hardware_inventory()
        except Exception as e:
            raise OgError(f'Error while running hardware inventory. {e}') from e
        finally:
            self._restartBrowser(self._url)

        result = legacy_list_hardware_inventory(inventory)
        logging.info('Successful hardware inventory command execution')
        return result

    def setup(self, request, ogRest):
        table_type = request.getType()
        disk = request.getDisk()
        cache = request.getCache()
        cache_size = request.getCacheSize()
        partlist = request.getPartitionSetup()

        self._ogbrowser_clear_logs()
        self._restartBrowser(self._url_log)

        umount_all()
        umount_cache()

        diskname = get_disks()[int(disk)-1]
        cxt = fdisk.Context(f'/dev/{diskname}',
                            details=True)

        if table_type == 'MSDOS':
            cxt.create_disklabel('dos')
        elif table_type == 'GPT':
            cxt.create_disklabel('gpt')
        else:
            raise OgError(f'Unsupported partition scheme {table_type}, only MSDOS and GPT are supported')

        logging.info(f'Setting up partition layout to {table_type}')

        for part in partlist:
            logging.info(f'Creating partition {part["partition"]} with {part["code"]} of {int(part["size"])//1024} Mbytes')
            if part["code"] == 'EMPTY':
                continue
            if ogRest.terminated:
                break

            pa = fdisk.Partition(start_follow_default=True,
                                 end_follow_default=False,
                                 partno_follow_default=False)
            parttype = get_parttype(cxt, part["code"])
            size = int(part["size"])
            pa.size = (size * (1 << 10)) // cxt.sector_size
            pa.partno = int(part["partition"]) - 1
            pa.type = parttype
            cxt.add_partition(pa)

        cxt.write_disklabel()
        os.sync()

        ret = subprocess.run(['partprobe', f'/dev/{diskname}'])
        logging.info(f'first partprobe /dev/{diskname} reports {ret.returncode}')

        for part in partlist:
            if part["filesystem"] == 'EMPTY':
                continue

            fs = part["filesystem"].lower()
            logging.info(f'Formatting partition {part["partition"]} with filesystem {part["filesystem"]}')

            partition = int(part["partition"])
            if fs == 'cache':
                err = mkfs('ext4', int(disk), partition, label='CACHE')
            else:
                err = mkfs(fs, int(disk), partition)

            if err == -1:
                raise OgError(f'Failed to format {part["partition"]} with filesystem {part["filesystem"]}')

        ret = subprocess.run(['partprobe', f'/dev/{diskname}'])
        logging.info(f'second partprobe /dev/{diskname} reports {ret.returncode}')

        for part in partlist:
            if part["filesystem"] == 'EMPTY':
                continue

            fs = part["filesystem"].lower()
            if fs == 'cache':
                init_cache()

        logging.info('Partition setup command OK')
        result = self.refresh(ogRest)

        self._restartBrowser(self._url)

        return result

    def image_restore(self, request, ogRest):
        disk = int(request.getDisk())
        partition = int(request.getPartition())
        name = request.getName()
        repo = request.getRepo()
        ctype = request.getType()
        profile = request.getProfile()
        cid = request.getId()
        partdev = get_partition_device(disk, partition)

        self._ogbrowser_clear_logs()
        self._restartBrowser(self._url_log)

        logging.info(f'Request to restore image {name}.img via {ctype} from {repo}')

        if shutil.which('restoreImageCustom'):
            restoreImageCustom(repo, name, disk, partition, ctype)
        elif 'UNICAST' in ctype:
            cache = 'DIRECT' not in ctype
            self._restore_image_unicast(repo, name, partdev, cache)
        elif ctype == 'TIPTORRENT':
            self._restore_image_tiptorrent(repo, name, partdev)

        extend_filesystem(disk, partition)

        configure_os(disk, partition)

        self.refresh(ogRest)

        logging.info('Image restore command OK')

        json_dict = {
            'disk': request.getDisk(),
            'partition': request.getPartition(),
            'image_id': request.getId(),
            'cache': self._get_cache_contents(),
        }
        return json_dict

    def image_create(self, request, ogRest):
        disk = int(request.getDisk())
        partition = int(request.getPartition())
        name = request.getName()
        repo = request.getRepo()
        backup = request.getBackup()
        image_path = f'/opt/opengnsys/images/{name}.img'

        self._ogbrowser_clear_logs()
        self._restartBrowser(self._url_log)

        logging.info(f'Request to create image {name}.img at repository {repo}')

        if ogChangeRepo(repo, smb_user=self._smb_user, smb_pass=self._smb_pass) != 0:
            self._restartBrowser(self._url)
            raise OgError(f'Cannot change image repository to {repo}')

        if ogRest.terminated:
            return

        diskname = get_disks()[disk-1]
        cxt = fdisk.Context(f'/dev/{diskname}', details=True)
        pa = None

        for i, p in enumerate(cxt.partitions):
            if (p.partno + 1) == partition:
                pa = cxt.partitions[i]

        if pa is None:
            self._restartBrowser(self._url)
            raise OgError(f'Target partition /dev/{diskname} not found')

        padev = cxt.partition_to_string(pa, fdisk.FDISK_FIELD_DEVICE)
        fstype = cxt.partition_to_string(pa, fdisk.FDISK_FIELD_FSTYPE)
        if not fstype:
            raise OgError(f'No filesystem detected in {padev}. Aborting image creation')

        if change_access(user=self._smb_user, pwd=self._smb_pass) == -1:
            raise OgError('remount of /opt/opengnsys/images has failed')

        if os.access(f'/opt/opengnsys/images', os.R_OK | os.W_OK) == False:
            raise OgError('Cannot access /opt/opengnsys/images in read and write mode, check permissions')

        if os.access(f'{image_path}', os.R_OK) == True:
            logging.info(f'image file {image_path} already exists, updating.')

        copy_windows_efi_bootloader(disk, partition)
        if ogReduceFs(disk, partition) == -1:
            raise OgError(f'Failed to shrink {fstype} filesystem in {padev}')

        cmd1 = shlex.split(f'partclone.{fstype} -I -C --clone -s {padev} -O -')
        cmd2 = shlex.split(f'lzop -1 -fo {image_path}')

        logfile = open('/tmp/command.log', 'wb', 0)

        try:
            if os.path.exists(image_path) and backup:
                shutil.move(image_path, f'{image_path}.ant')
        except OSError as e:
            raise OgError(f'Cannot create backup for {image_path}: {e}') from e

        try:
            p1 = Popen(cmd1, stdout=PIPE, stderr=logfile)
            p2 = Popen(cmd2, stdin=p1.stdout)
            p1.stdout.close()

            logging.info(f'Creating image at {image_path} from {padev} using {fstype}')
            logging.info('*DO NOT REBOOT OR POWEROFF* the client during this time')

            try:
                retdata = p2.communicate()
            except OSError as e:
                raise OgError(f'Unexpected error when running partclone and lzop commands: {e}') from e
            finally:
                logfile.close()
                p2.terminate()
                p1.poll()

            logging.info(f'partclone process exited with code {p1.returncode}')
            logging.info(f'lzop process exited with code {p2.returncode}')

            extend_filesystem(disk, partition)

            if os.access(f'{image_path}', os.R_OK) == False:
                raise OgError(f'Cannot access partclone image file {image_path}')

            image_info = get_image_info(image_path)
        except Exception as e:
            if os.path.exists(image_path):
                os.unlink(image_path)

            if os.path.exists(f'{image_path}.ant'):
                shutil.move(f'{image_path}.ant', image_path)

            self._restartBrowser(self._url)

            if isinstance(e, OgError):
                raise OgError(f'Failed to create image for {fstype} filesystem in device {padev}: {e}') from e
            else:
                raise

        logging.info(f'Writing checksum file {name}.img.full.sum...')
        logging.info('*DO NOT REBOOT OR POWEROFF* the client during this time')

        checksum = self._md5_file(f'/opt/opengnsys/images/{name}.img')
        if checksum == -1:
            raise OgError(f'Cannot access {name}.full.sum file')

        if self._write_md5_file(f'/opt/opengnsys/images/{name}.img', checksum) == -1:
            raise OgError(f'Cannot write {name}.full.sum file')

        image_info.checksum = checksum

        self._restartBrowser(self._url)

        logging.info('Image creation command OK')
        return image_info

    def cache_delete(self, request, ogRest):
        images = request.getImages()
        deleted_images = []

        logging.info(f'Request to remove files from cache')

        if not mount_cache():
            logging.error(f'Cache is not mounted')
            return

        img_dir = OG_CACHE_IMAGE_PATH

        if not os.path.isdir(img_dir):
            logging.error(f'{img_dir} is not a directory')
            return cache_contents

        for file_name in os.listdir(img_dir):
            file_path = os.path.join(img_dir, file_name)

            if not os.path.isfile(file_path):
                continue
            if not file_name.endswith('.img'):
                continue
            if os.sep in file_name:
                logging.info(f'Detected cache deletion request of filename with a path, ignoring {file_name}')
                continue

            if file_name in images:
                logging.info(f'Removing file {file_path} from cache')
                os.remove(file_path)

                csum_path = file_path + '.full.sum'
                if not os.path.isfile(csum_path):
                    logging.info(f'Missing checksum file {csum_path}')
                    continue

                logging.info(f'Removing checksum file {csum_path} from cache')
                os.remove(csum_path)

        result = {'cache': self._get_cache_contents()}

        self._restartBrowser(self._url)

        logging.info('Delete file from cache request OK')
        return result

    def cache_fetch(self, request, ogRest):
        image = request.getImages()
        repo = request.getRepo()
        ctype = request.getType()

        logging.info(f'Request to cache image {image}.img via {ctype} from {repo}')

        if ctype == 'UNICAST':
            self._fetch_image_unicast(repo, image)
        elif ctype == 'TIPTORRENT':
            self._fetch_image_tiptorrent(repo, image)
        else:
            raise OgError(f'Invalid image fetch type {ctype}')

        logging.info('Cache fetch command OK')

        result = {'cache': self._get_cache_contents()}

        return result

    def refresh(self, ogRest):
        self._restartBrowser(self._url_log)

        cache = get_cache_dev_path()
        disks = get_disks()
        interface = os.getenv('DEVICE')
        link = ethtool(interface)
        json_body = { 'serial_number': '',
                'disk_setup': [],
                'partition_setup': [],
                'link': link
        }

        for num_disk, disk in enumerate(get_disks(), start=1):
            logging.debug('refresh: processing %s', disk)
            part_setup = {}
            try:
                cxt = fdisk.Context(device=f'/dev/{disk}', details=True)
            except:
                continue

            self._refresh_payload_disk(cxt, part_setup, num_disk)
            json_body['disk_setup'].append(part_setup)

            for pa in cxt.partitions:
                part_setup = part_setup.copy()
                self._refresh_payload_partition(cxt, pa, part_setup, disk)
                self._refresh_part_setup_cache(cxt, pa, part_setup, cache)
                json_body['partition_setup'].append(part_setup)

        json_body['cache'] = self._get_cache_contents()

        generate_menu(json_body['partition_setup'])
        generate_cache_txt()
        self._restartBrowser(self._url)

        logging.info('Sending response to refresh request')
        return json_body

    def probe(self, ogRest):

        interface = os.getenv('DEVICE')
        speed = ethtool(interface)

        return {'status': 'OPG' if ogRest.state != ThreadState.BUSY else 'BSY',
                'speed': speed}