path: root/MassPnfSim.py

#!/usr/bin/env python3
import logging
import base64
from subprocess import run, CalledProcessError
import argparse
import ipaddress
from sys import exit
from os import chdir, getcwd, path, popen, kill, getuid, stat, mkdir, chmod
from shutil import copytree, rmtree, move
from json import loads, dumps
from yaml import load, SafeLoader, dump
from glob import glob
from time import strftime, tzname, daylight
from docker import from_env
from requests import get, codes, post
from requests.exceptions import MissingSchema, InvalidSchema, InvalidURL, ConnectionError, ConnectTimeout

def validate_url(url):
    '''Helper function to perform --urlves input param validation'''
    logger = logging.getLogger("urllib3")
    logger.setLevel(logging.WARNING)
    try:
        get(url, timeout=0.001)
    except (MissingSchema, InvalidSchema, InvalidURL):
        raise argparse.ArgumentTypeError(f'{url} is not a valid URL')
    except (ConnectionError, ConnectTimeout):
        pass
    return url

def merge_dictionaries(origin, custom):
    '''Combine 2 dictionaries based on common keys.'''
    return {
            key: dict(
                origin.get(key, {}),
                **custom.get(key, {}))
            for key in origin.keys() | custom.keys()
        }

def validate_ip(ip):
    '''Helper function to validate input param is a vaild IP address'''
    try:
        ip_valid = ipaddress.ip_address(ip)
    except ValueError:
        raise argparse.ArgumentTypeError(f'{ip} is not a valid IP address')
    else:
        return ip_valid

def get_auth_token_base64(plain):
    '''Converts user:password to Base64.'''
    basic_auth_plain = plain
    basic_auth_bytes = basic_auth_plain.encode('ascii')
    basic_auth_base64_bytes = base64.b64encode(basic_auth_bytes)
    basic_auth_base64 = basic_auth_base64_bytes.decode('ascii')
    return basic_auth_base64

def get_parser():
    '''Process input arguments'''

    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(title='Subcommands', dest='subcommand')
    # Build command parser
    subparsers.add_parser('build', help='Build simulator image')
    # Bootstrap command parser
    parser_bootstrap = subparsers.add_parser('bootstrap', help='Bootstrap the system')
    parser_bootstrap.add_argument('--count', help='Instance count to bootstrap', type=int, metavar='INT', default=1)
    parser_bootstrap.add_argument('--urlves', help='URL of the VES collector', type=validate_url, metavar='URL', required=True)
    parser_bootstrap.add_argument('--ipfileserver', help='Visible IP of the file server (SFTP/FTPS) to be included in the VES event',
                                  type=validate_ip, metavar='IP', required=True)
    parser_bootstrap.add_argument('--typefileserver', help='Type of the file server (SFTP/FTPS) to be included in the VES event',
                                  type=str, choices=['sftp', 'ftps'], required=True)
    parser_bootstrap.add_argument('--user', help='File server username', type=str, metavar='USERNAME', required=True)
    parser_bootstrap.add_argument('--password', help='File server password', type=str, metavar='PASSWORD', required=True)
    parser_bootstrap.add_argument('--ipstart', help='IP address range beginning', type=validate_ip, metavar='IP', required=True)
    # Start command parser
    parser_start = subparsers.add_parser('start', help='Start instances')
    parser_start.add_argument('--count', help='Instance count to start', type=int, metavar='INT', default=0)
    # Stop command parser
    parser_stop = subparsers.add_parser('stop', help='Stop instances')
    parser_stop.add_argument('--count', help='Instance count to stop', type=int, metavar='INT', default=0)
    # Trigger command parser
    parser_trigger = subparsers.add_parser('trigger', help='Trigger one single VES event from each simulator')
    parser_trigger.add_argument('--count', help='Instance count to trigger', type=int, metavar='INT', default=0)
    parser_trigger.add_argument('--user', help='VES auth username', type=str, metavar='USERNAME')
    parser_trigger.add_argument('--password', help='VES auth password', type=str, metavar='PASSWORD')
    # Stop-simulator command parser
    parser_stopsimulator = subparsers.add_parser('stop_simulator', help='Stop sending PNF registration messages')
    parser_stopsimulator.add_argument('--count', help='Instance count to stop', type=int, metavar='INT', default=0)
    # Trigger-custom command parser
    parser_triggerstart = subparsers.add_parser('trigger_custom', help='Trigger one single VES event from specific simulators')
    parser_triggerstart.add_argument('--triggerstart', help='First simulator id to trigger', type=int,
                                     metavar='INT', required=True)
    parser_triggerstart.add_argument('--triggerend', help='Last simulator id to trigger', type=int,
                                     metavar='INT', required=True)
    parser_triggerstart.add_argument('--user', help='VES auth username', type=str, metavar='USERNAME')
    parser_triggerstart.add_argument('--password', help='VES auth password', type=str, metavar='PASSWORD')
    parser_triggerstart.add_argument('--data', help='Custom data to override default values', type=dict, metavar='DATA')
    # Status command parser
    parser_status = subparsers.add_parser('status', help='Status')
    parser_status.add_argument('--count', help='Instance count to show status for', type=int, metavar='INT', default=0)
    # Clean command parser
    subparsers.add_parser('clean', help='Clean work-dirs')
    # General options parser
    parser.add_argument('--verbose', help='Verbosity level', choices=['info', 'debug'],
                        type=str, default='info')
    return parser

class MassPnfSim:

    # MassPnfSim class actions decorator
    class _MassPnfSim_Decorators:
        @staticmethod
        def validate_subcommand(method):
            def wrapper(self, args): # pylint: disable=W0613
                # Validate 'trigger_custom' subcommand options
                if self.args.subcommand == 'trigger_custom':
                    if (self.args.triggerend + 1) > self._enum_sim_instances():
                        self.logger.error('--triggerend value greater than existing instance count.')
                        exit(1)

                # Validate --count option for subcommands that support it
                if self.args.subcommand in ['start', 'stop', 'trigger', 'status', 'stop_simulator']:
                    if self.args.count > self._enum_sim_instances():
                        self.logger.error('--count value greater that existing instance count')
                        exit(1)
                    if not self._enum_sim_instances():
                        self.logger.error('No bootstrapped instance found')
                        exit(1)

                # Validate 'bootstrap' subcommand
                if (self.args.subcommand == 'bootstrap') and self._enum_sim_instances():
                    self.logger.error('Bootstrapped instances detected, not overwiriting, clean first')
                    exit(1)
                method(self, args)
            return wrapper

        @staticmethod
        def substitute_instance_args(method):
            def wrapper(self, args):
                self.args = args
                method(self, args)
            return wrapper

    log_lvl = logging.INFO
    sim_compose_template = 'docker-compose-template.yml'
    sim_vsftpd_template = 'config/vsftpd_ssl-TEMPLATE.conf'
    sim_vsftpd_config = 'config/vsftpd_ssl.conf'
    sim_sftp_script = 'fix-sftp-perms.sh'
    sim_sftp_script_template = 'fix-sftp-perms-template.sh'
    sim_config = 'config/config.yml'
    sim_msg_config = 'config/config.json'
    sim_port = 5000
    sim_base_url = 'http://{}:' + str(sim_port) + '/simulator'
    sim_start_url = sim_base_url + '/start'
    sim_status_url = sim_base_url + '/status'
    sim_stop_url = sim_base_url + '/stop'
    sim_container_name = 'pnf-simulator'
    rop_script_name = 'ROP_file_creator.sh'

    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.logger.setLevel(self.log_lvl)
        self.sim_dirname_pattern = "pnf-sim-lw-"
        self.mvn_build_cmd = 'mvn clean package docker:build -Dcheckstyle.skip'
        self.docker_compose_status_cmd = 'docker-compose ps'

    def _run_cmd(self, cmd, dir_context='.'):
        old_pwd = getcwd()
        try:
            chdir(dir_context)
            self.logger.debug(f'_run_cmd: Current direcotry: {getcwd()}')
            self.logger.debug(f'_run_cmd: Command string: {cmd}')
            run(cmd, check=True, shell=True)
            chdir(old_pwd)
        except FileNotFoundError:
            self.logger.error(f"Directory {dir_context} not found")
        except CalledProcessError as e:
            exit(e.returncode)

    def _enum_sim_instances(self):
        '''Helper method that returns bootstraped simulator instances count'''
        return len(glob(f"{self.sim_dirname_pattern}[0-9]*"))

    def _get_sim_instance_data(self, instance_id):
        '''Helper method that returns specific instance data'''
        oldpwd = getcwd()
        chdir(f"{self.sim_dirname_pattern}{instance_id}")
        with open(self.sim_config) as cfg:
            yml = load(cfg, Loader=SafeLoader)
        chdir(oldpwd)
        return yml['ippnfsim']

    def _get_docker_containers(self):
        '''Returns a list containing 'name' attribute of running docker containers'''
        dc = from_env()
        containers = []
        for container in dc.containers.list():
            containers.append(container.attrs['Name'][1:])
        return containers

    def _get_iter_range(self):
        '''Helper routine to get the iteration range
        for the lifecycle commands'''
        if hasattr(self.args, 'count'):
            if not self.args.count:
                return [self._enum_sim_instances()]
            else:
                return [self.args.count]
        elif hasattr(self.args, 'triggerstart'):
            return [self.args.triggerstart, self.args.triggerend + 1]
        else:
            return [self._enum_sim_instances()]

    def _archive_logs(self, sim_dir):
        '''Helper function to archive simulator logs or create the log dir'''
        old_pwd = getcwd()
        try:
            chdir(sim_dir)
            if path.isdir('logs'):
                arch_dir = f"logs/archive_{strftime('%Y-%m-%d_%T')}"
                mkdir(arch_dir)
                self.logger.debug(f'Created {arch_dir}')
                # Collect file list to move
                self.logger.debug('Archiving log files')
                for fpattern in ['*.log', '*.xml']:
                    for f in glob('logs/' + fpattern):
                        # Move files from list to arch dir
                        move(f, arch_dir)
                        self.logger.debug(f'Moving {f} to {arch_dir}')
            else:
                mkdir('logs')
                self.logger.debug("Logs dir didn't exist, created")
            chdir(old_pwd)
        except FileNotFoundError:
            self.logger.error(f"Directory {sim_dir} not found")

    def _generate_pnf_sim_config(self, i, port_sftp, port_ftps, pnf_sim_ip):
        '''Writes a yaml formatted configuration file for Java simulator app'''
        yml = {}
        yml['urlves'] = self.args.urlves
        yml['urlsftp'] = f'sftp://{self.args.user}:{self.args.password}@{self.args.ipfileserver}:{port_sftp}'
        yml['urlftps'] = f'ftps://{self.args.user}:{self.args.password}@{self.args.ipfileserver}:{port_ftps}'
        yml['ippnfsim'] = pnf_sim_ip
        yml['typefileserver'] = self.args.typefileserver
        self.logger.debug(f'Generated simulator config:\n{dump(yml)}')
        with open(f'{self.sim_dirname_pattern}{i}/{self.sim_config}', 'w') as fout:
            fout.write(dump(yml))

    def _generate_config_file(self, source, dest, **kwargs):
        '''Helper private method to generate a file based on a template'''
        old_pwd = getcwd()
        chdir(self.sim_dirname_pattern + str(kwargs['I']))
        # Read the template file
        with open(source, 'r') as f:
            template = f.read()
        # Replace all occurences of env like variable with it's
        # relevant value from a corresponding key form kwargs
        for (k,v) in kwargs.items():
            template = template.replace('${' + k + '}', str(v))
        with open(dest, 'w') as f:
            f.write(template)
        chdir(old_pwd)

    @_MassPnfSim_Decorators.substitute_instance_args
    @_MassPnfSim_Decorators.validate_subcommand
    def bootstrap(self, args): # pylint: disable=W0613
        self.logger.info("Bootstrapping PNF instances")

        start_port = 2000
        ftps_pasv_port_start = 8000
        ftps_pasv_port_num_of_ports = 10

        ftps_pasv_port_end = ftps_pasv_port_start + ftps_pasv_port_num_of_ports

        for i in range(self.args.count):
            self.logger.info(f"PNF simulator instance: {i}")

            # The IP ranges are in distance of 16 compared to each other.
            # This is matching the /28 subnet mask used in the dockerfile inside.
            instance_ip_offset = i * 16
            ip_properties = [
                      'subnet',
                      'gw',
                      'PnfSim',
                      'ftps',
                      'sftp'
                    ]

            ip_offset = 0
            ip = {}
            for prop in ip_properties:
                ip.update({prop: str(self.args.ipstart + ip_offset + instance_ip_offset)})
                ip_offset += 1

            self.logger.debug(f'Instance #{i} properties:\n {dumps(ip, indent=4)}')

            PortSftp = start_port + 1
            PortFtps = start_port + 2
            start_port += 2

            self.logger.info(f'\tCreating {self.sim_dirname_pattern}{i}')
            copytree('pnf-sim-lightweight', f'{self.sim_dirname_pattern}{i}')
            self.logger.info(f"\tCreating instance #{i} configuration ")
            self._generate_pnf_sim_config(i, PortSftp, PortFtps, ip['PnfSim'])
            # generate docker-compose for the simulator instance
            self._generate_config_file(self.sim_compose_template, 'docker-compose.yml',
                                       IPGW = ip['gw'], IPSUBNET = ip['subnet'],
                                       I = i, IPPNFSIM = ip['PnfSim'],
                                       PORTSFTP = str(PortSftp),
                                       PORTFTPS = str(PortFtps),
                                       IPFTPS = ip['ftps'], IPSFTP = ip['sftp'],
                                       FTPS_PASV_MIN = str(ftps_pasv_port_start),
                                       FTPS_PASV_MAX = str(ftps_pasv_port_end),
                                       TIMEZONE = tzname[daylight],
                                       FILESERV_USER = self.args.user,
                                       FILESERV_PASS = self.args.password)
            # generate vsftpd config file for the simulator instance
            self._generate_config_file(self.sim_vsftpd_template, self.sim_vsftpd_config,
                                       I = i,
                                       FTPS_PASV_MIN = str(ftps_pasv_port_start),
                                       FTPS_PASV_MAX = str(ftps_pasv_port_end),
                                       IPFILESERVER = str(self.args.ipfileserver))
            # generate sftp permission fix script
            self._generate_config_file(self.sim_sftp_script_template, self.sim_sftp_script,
                                       I = i, FILESERV_USER = self.args.user)
            chmod(f'{self.sim_dirname_pattern}{i}/{self.sim_sftp_script}', 0o755)

            ftps_pasv_port_start += ftps_pasv_port_num_of_ports + 1
            ftps_pasv_port_end += ftps_pasv_port_num_of_ports + 1

            # ugly hack to chown vsftpd config file to root
            if getuid():
                self._run_cmd(f'sudo chown root {self.sim_vsftpd_config}', f'{self.sim_dirname_pattern}{i}')
                self.logger.debug(f"vsftpd config file owner UID: {stat(self.sim_dirname_pattern + str(i) + '/' + self.sim_vsftpd_config).st_uid}")

            self.logger.info(f'Done setting up instance #{i}')

    @_MassPnfSim_Decorators.substitute_instance_args
    def build(self, args): # pylint: disable=W0613
        self.logger.info("Building simulator image")
        if path.isfile('pnf-sim-lightweight/pom.xml'):
            self._run_cmd(self.mvn_build_cmd, 'pnf-sim-lightweight')
        else:
            self.logger.error('POM file was not found, Maven cannot run')
            exit(1)

    @_MassPnfSim_Decorators.substitute_instance_args
    def clean(self, args): # pylint: disable=W0613
        self.logger.info('Cleaning simulators workdirs')
        for sim_id in range(self._enum_sim_instances()):
            rmtree(f"{self.sim_dirname_pattern}{sim_id}")

    @_MassPnfSim_Decorators.substitute_instance_args
    @_MassPnfSim_Decorators.validate_subcommand
    def start(self, args): # pylint: disable=W0613
        for i in range(*self._get_iter_range()):
            # Start measurements file generator if not running
            rop_running = False
            for ps_line in iter(popen(f'ps --no-headers -C {self.rop_script_name} -o pid,cmd').readline, ''):
                # try getting ROP script pid
                try:
                    ps_line_arr = ps_line.split()
                    assert self.rop_script_name in ps_line_arr[2]
                    assert ps_line_arr[3] == str(i)
                except AssertionError:
                    pass
                else:
                    self.logger.warning(f'3GPP measurements file generator for instance {i} is already running')
                    rop_running = True
            if not rop_running:
                self._run_cmd(f'./ROP_file_creator.sh {i} &', f"{self.sim_dirname_pattern}{i}")
                self.logger.info(f'ROP_file_creator.sh {i} successfully started')
            # If container is not running
            if f"{self.sim_container_name}-{i}" not in self._get_docker_containers():
                self.logger.info(f'Starting {self.sim_dirname_pattern}{i} instance:')
                self.logger.info(f' PNF-Sim IP: {self._get_sim_instance_data(i)}')
                #Move logs to archive
                self._archive_logs(self.sim_dirname_pattern + str(i))
                self.logger.info(' Starting simulator containers using netconf model specified in config/netconf.env')
                self._run_cmd('docker-compose up -d', self.sim_dirname_pattern + str(i))
            else:
                self.logger.warning(f'Instance {self.sim_dirname_pattern}{i} containers are already up')

    @_MassPnfSim_Decorators.substitute_instance_args
    @_MassPnfSim_Decorators.validate_subcommand
    def status(self, args): # pylint: disable=W0613
        for i in range(*self._get_iter_range()):
            self.logger.info(f'Getting {self.sim_dirname_pattern}{i} instance status:')
            if f"{self.sim_container_name}-{i}" in self._get_docker_containers():
                try:
                    sim_ip = self._get_sim_instance_data(i)
                    self.logger.info(f' PNF-Sim IP: {sim_ip}')
                    self._run_cmd(self.docker_compose_status_cmd, f"{self.sim_dirname_pattern}{i}")
                    sim_response = get('{}'.format(self.sim_status_url).format(sim_ip))
                    if sim_response.status_code == codes.ok:
                        self.logger.info(sim_response.text)
                    else:
                        self.logger.error(f'Simulator request returned http code {sim_response.status_code}')
                except KeyError:
                    self.logger.error(f'Unable to get sim instance IP from {self.sim_config}')
            else:
                self.logger.info(' Simulator containers are down')

    @_MassPnfSim_Decorators.substitute_instance_args
    @_MassPnfSim_Decorators.validate_subcommand
    def stop(self, args): # pylint: disable=W0613
        for i in range(*self._get_iter_range()):
            self.logger.info(f'Stopping {self.sim_dirname_pattern}{i} instance:')
            self.logger.info(f' PNF-Sim IP: {self._get_sim_instance_data(i)}')
            # attempt killing ROP script
            rop_pid = []
            for ps_line in iter(popen(f'ps --no-headers -C {self.rop_script_name} -o pid,cmd').readline, ''):
                # try getting ROP script pid
                try:
                    ps_line_arr = ps_line.split()
                    assert self.rop_script_name in ps_line_arr[2]
                    assert ps_line_arr[3] == str(i)
                    rop_pid = ps_line_arr[0]
                except AssertionError:
                    pass
                else:
                    # get rop script childs, kill ROP script and all childs
                    childs = popen(f'pgrep -P {rop_pid}').read().split()
                    for pid in [rop_pid] + childs:
                        kill(int(pid), 15)
                    self.logger.info(f' ROP_file_creator.sh {i} successfully killed')
            if not rop_pid:
                # no process found
                self.logger.warning(f' ROP_file_creator.sh {i} already not running')
            # try tearing down docker-compose application
            if f"{self.sim_container_name}-{i}" in self._get_docker_containers():
                self._run_cmd('docker-compose down', self.sim_dirname_pattern + str(i))
                self._run_cmd('docker-compose rm', self.sim_dirname_pattern + str(i))
            else:
                self.logger.warning(" Simulator containers are already down")

    @_MassPnfSim_Decorators.substitute_instance_args
    @_MassPnfSim_Decorators.validate_subcommand
    def trigger(self, args): # pylint: disable=W0613
        self.logger.info("Triggering VES sending:")

        for i in range(*self._get_iter_range()):

            sim_ip = self._get_sim_instance_data(i)
            self.logger.info(f'Triggering {self.sim_dirname_pattern}{i} instance:')
            self.logger.info(f' PNF-Sim IP: {sim_ip}')

            # create a Basic auth token
            plaintext_auth = f"{args.user}:{args.password}"
            basic_auth_base64 = get_auth_token_base64(plaintext_auth)
            basic_auth_token = f"Basic {basic_auth_base64}"
            self.logger.info((basic_auth_base64))

            # setup req headers
            req_headers = {
                    "Content-Type": "application/json",
                    "X-ONAP-RequestID": "123",
                    "X-InvocationID": "456",
                    "Authorization": basic_auth_token
                }
            self.logger.debug(f' Request headers: {req_headers}')

            try:

                # get payload for the request
                with open(f'{self.sim_dirname_pattern}{i}/{self.sim_msg_config}') as data:

                    json_data = loads(data.read())
                    try:
                        json_data = merge_dictionaries(json_data, args.data)
                    except AttributeError:
                        self.logger.debug('The request will be sent without customization.')

                    self.logger.debug(f' JSON payload for the simulator:\n{json_data}')

                    # make a http request to the simulator
                    sim_response = post('{}'.format(self.sim_start_url).format(sim_ip), headers=req_headers, json=json_data)

                    if sim_response.status_code == codes.ok:
                        self.logger.info(' Simulator response: ' + sim_response.text)
                    else:
                        self.logger.warning(' Simulator response ' + sim_response.text)

            except TypeError:
                self.logger.error(f' Could not load JSON data from {self.sim_dirname_pattern}{i}/{self.sim_msg_config}')

    # Make the 'trigger_custom' an alias to the 'trigger' method
    trigger_custom = trigger

    @_MassPnfSim_Decorators.substitute_instance_args
    @_MassPnfSim_Decorators.validate_subcommand
    def stop_simulator(self, args): # pylint: disable=W0613
        self.logger.info("Stopping sending PNF registration messages:")
        for i in range(*self._get_iter_range()):
            sim_ip = self._get_sim_instance_data(i)
            self.logger.info(f'Stopping {self.sim_dirname_pattern}{i} instance:')
            self.logger.info(f' PNF-Sim IP: {sim_ip}')
            sim_response = post('{}'.format(self.sim_stop_url).format(sim_ip))
            if sim_response.status_code == codes.ok:
                self.logger.info(' Simulator response: ' + sim_response.text)
            else:
                self.logger.warning(' Simulator response ' + sim_response.text)