config_parser.py

import os
import sys
import tempfile
from datetime import datetime

from pathlib import Path

import yaml
# from yamlinclude import YamlIncludeConstructor
from yaml_include import Constructor
from schema import Schema, Or, And, Use, Optional, SchemaError, Regex

from dhalsim.parser.input_parser import InputParser


class Error(Exception):
    """Base class for exceptions in this module."""


class EmptyConfigError(Error):
    """Raised when the configuration file is empty"""


class MissingValueError(Error):
    """Raised when there is a value missing in a configuration file"""


class InvalidValueError(Error):
    """Raised when there is a invalid value in a configuration file"""


class DuplicateValueError(Error):
    """Raised when there is a duplicate plc value in the plcs section"""


class NoSuchPlc(Error):
    """Raised when an attack targets a PLC that does not exist"""


class NoSuchNode(Error):
    """Raised when an attack targets a node that does not exist"""


class NoSuchTag(Error):
    """Raised when an attack targets a tag the target PLC does not have"""


class NetworkAttackError(Error):
    """Used to raise errors about network attack"""


class TooManyNodes(Error):
    """Raised when there will be too many nodes in the network"""


class SchemaParser:
    """
    Class which handles all schema logic.
    """
    string_pattern = Regex(r'^[a-zA-Z0-9_]+$',
                           error="Error in string: '{}', Can only have a-z, A-Z, 0-9, and _")

    attack_pattern = Regex(r'^[a-zA-Z0-9_<>+-.]+$',
                           error="Error in attack name: '{}', "
                                 "Can only have a-z, A-Z, 0-9, and symbols: _ < > + - . (no whitespaces)")

    event_pattern = Regex(r'^[a-zA-Z0-9_<>+-.]+$',
                          error="Error in event name: '{}', "
                                "Can only have a-z, A-Z, 0-9, and symbols: _ < > + - . (no whitespaces)")

    concealment_path = Schema(
        str,
        Use(Path),
        Use(lambda p: p.absolute().parent / p),
        Schema(lambda l: Path.is_file, error="'inp_file' could not be found."),
        Schema(lambda f: f.suffix == '.csv',
               error="Suffix of 'inp_file' should be .inp.")
    )

    concealment_data = Schema(
        Or(
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'path'
                ),
                'path': concealment_path
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'value'
                ),
                'concealment_value': [{
                    'tag': And(
                        str,
                        string_pattern,
                    ),
                    Or('value', 'offset', only_one=True,
                       error="'tags' should have either a 'value' or 'offset' attribute."): Or(float, And(int, Use(float))),
                }],
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'payload_replay'
                ),
                'capture_start': And(
                    int,
                    Schema(lambda i: i >= 0, error="'capture_start' must be positive."),
                ),
                'capture_end': And(
                    int,
                    Schema(lambda i: i >= 0, error="'capture_end' must be positive."),
                ),
                'replay_start': And(
                    int,
                    Schema(lambda i: i >= 0, error="'replay_start' must be positive."),
                ),
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'network_replay'
                ),
                'capture_start': And(
                    int,
                    Schema(lambda i: i >= 0, error="'capture_start' must be positive."),
                ),
                'capture_end': And(
                    int,
                    Schema(lambda i: i >= 0, error="'capture_end' must be positive."),
                ),
                'replay_start': And(
                    int,
                    Schema(lambda i: i >= 0, error="'replay_start' must be positive."),
                ),
            },
        )
    )

    trigger = Schema(
        Or(
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'time'
                ),
                'start': And(
                    int,
                    Schema(lambda i: i >= 0, error="'start' must be positive."),
                ),
                'end': And(
                    int,
                    Schema(lambda i: i >= 0, error="'end' must be positive."),
                ),
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    Or('below', 'above')
                ),
                'sensor': And(
                    str,
                    string_pattern,
                ),
                'value': And(
                    Or(float, And(int, Use(float))),
                ),
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'between'
                ),
                'sensor': And(
                    str,
                    string_pattern,
                ),
                'lower_value': And(
                    Or(float, And(int, Use(float))),
                ),
                'upper_value': And(
                    Or(float, And(int, Use(float))),
                ),
            },
        )
    )

    device_attacks = Schema({
        'name': And(
            str,
            attack_pattern,
        ),
        'trigger': trigger,
        'actuator': And(
            str,
            string_pattern,
        ),
        'command':
        Or(
            And(
                str,
                Use(str.lower),
                Or('open', 'closed')),
            And(
                Or(float, And(int, Use(float))))
        )
    })

    network_attacks = Schema(
        Or(
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'naive_mitm',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                Or('value', 'offset', only_one=True,
                   error="'tags' should have either a 'value' or 'offset' attribute."): Or(float, And(int, Use(float))),
                'target': And(
                    str,
                    string_pattern
                ),

                Optional('direction', default='source'): And(
                    str,
                    Use(str.lower),
                    Or('source', 'destination'), error="'direction' should be one of the following:"
                                                       " 'source' or 'destination'."
                )
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'mitm',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                'target': And(
                    str,
                    string_pattern
                ),
                'tag': And(
                    str,
                    string_pattern,
                ),
                Or('value', 'offset', only_one=True,
                   error="'tags' should have either a 'value' or 'offset' attribute."): Or(float,
                                                                                           And(int, Use(float))),
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'server_mitm',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                'target': And(
                    str,
                    string_pattern
                ),
                'tags': [{
                    'tag': And(
                        str,
                        string_pattern,
                    ),
                    Or('value', 'offset', only_one=True,
                       error="'tags' should have either a 'value' or 'offset' attribute."): Or(float, And(int, Use(float))),
                }]
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'concealment_mitm',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                'target': And(
                    str,
                    string_pattern
                ),
                'tags': [{
                    'tag': And(
                        str,
                        string_pattern,
                    ),
                    Or('value', 'offset', only_one=True,
                       error="'tags' should have either a 'value' or 'offset' attribute."): Or(float, And(int, Use(float))),
                }],
                'concealment_data': concealment_data
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'unconstrained_blackbox_concealment_mitm',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                Optional('persistent', default='True'): And(
                    str,
                    Use(str.lower),
                    Or(True, False), error="'Persistent' should be one of the following: 'True' or 'False'."
                ),
                'trigger': trigger,
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'replay_mitm',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                'target': And(
                    str,
                    string_pattern
                ),
                'capture_start': And(
                    int,
                    Schema(lambda i: i >= 0, error="'capture_start' must be positive."),
                ),
                'capture_end': And(
                    int,
                    Schema(lambda i: i >= 0, error="'capture_start' must be positive."),
                ),
                'replay_start': And(
                    int,
                    Schema(lambda i: i >= 0, error="'capture_start' must be positive."),
                ),
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'simple_dos',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                'target': And(
                    str,
                    string_pattern
                ),
                Optional('direction', default='source'): And(
                    str,
                    Use(str.lower),
                    Or('source', 'destination'), error="'direction' should be one of the following:"
                                                       " 'source' or 'destination'."
                )
            }

        )
    )

    network_events = Schema(
        Or(
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'packet_loss',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                'target': And(
                    str,
                    string_pattern
                ),
                'value': And(
                    Or(float, And(int, Use(float)))
                )
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'network_delay',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                'target': And(
                    str,
                    string_pattern
                ),
                'value': And(
                    Or(float, And(int, Use(float)))
                )
            },
            {
                'type': And(
                    str,
                    Use(str.lower),
                    'network_delay_loss',
                ),
                'name': And(
                    str,
                    string_pattern,
                    Schema(lambda name: 1 <= len(name) <= 20,
                           error="Length of name must be between 1 and 20, '{}' has invalid length")
                ),
                'trigger': trigger,
                'target': And(
                    str,
                    string_pattern
                ),
                'loss_value': And(
                    Or(float, And(int, Use(float)))
                ),
                'delay_value': And(
                    Or(float, And(int, Use(float)))
                )
            }
        )
    )

    @staticmethod
    def path_schema(data: dict, config_path: Path) -> dict:
        """
        For all the values that need to be a path, this function converts them to absolute paths,
        checks if they exists, and checks the suffix if applicable.

        :param data: data from the config file
        :type data: dict
        :param config_path: That to the config file
        :type config_path:

        :return: the config data, but with existing absolute path objects
        :rtype: dict
        """
        return Schema(
            And(
                {
                    'inp_file': And(
                        Use(Path),
                        Use(lambda p: config_path.absolute().parent / p),
                        Schema(lambda l: Path.is_file, error="'inp_file' could not be found."),
                        Schema(lambda f: f.suffix == '.inp',
                               error="Suffix of 'inp_file' should be .inp.")),
                    Optional('output_path', default=config_path.absolute().parent / 'output'): And(
                        Use(str, error="'output_path' should be a string."),
                        Use(Path),
                        Use(lambda p: config_path.absolute().parent / p),
                    ),
                    Optional('initial_tank_data'): And(
                        Use(Path),
                        Use(lambda p: config_path.absolute().parent / p),
                        Schema(lambda l: Path.is_file, error="'initial_tank_data' could not be found."),
                        Schema(lambda f: f.suffix == '.csv',
                               error="Suffix of initial_tank_data should be .csv")),
                    Optional('demand_patterns'): And(
                        Use(Path),
                        Use(lambda p: config_path.absolute().parent / p),
                        Schema(lambda l: Path.exists, error="'demand_patterns' path does not exist."),
                        Or(
                            Path.is_dir,
                            Schema(lambda f: f.suffix == '.csv',
                                   error="Suffix of demand_patterns should be .csv"))),
                    Optional('network_loss_data'): And(
                        Use(Path),
                        Use(lambda p: config_path.absolute().parent / p),
                        Schema(lambda l: Path.is_file, error="'network_loss_data' could not be found."),
                        Schema(lambda f: f.suffix == '.csv',
                               error="Suffix of network_loss_data should be .csv")),
                    Optional('network_delay_data'): And(
                        Use(Path),
                        Use(lambda p: config_path.absolute().parent / p),
                        Schema(lambda l: Path.is_file, error="'network_delay_data' could not be found."),
                        Schema(lambda f: f.suffix == '.csv',
                               error="Suffix of network_delay_data should be .csv")),
                    str: object
                }
            )
        ).validate(data)

    @staticmethod
    def validate_schema(data: dict) -> dict:
        """
        Apply a schema to the data. This schema make sure that every reuired parameter is given.
        It also fills in default values for missing parameters.
        It will test for types of parameters as well.
        Besides that, it converts some strings to lower case, like those of :code:'log_level'.

        :param data: data from the config file
        :type data: dict

        :return: A verified version of the data of the config file
        :rtype: dict
        """
        plc_schema = Schema([{
            'name': And(
                str,
                SchemaParser.string_pattern,
                Schema(lambda name: 1 <= len(name) <= 10,
                       error="Length of name must be between 1 and 10, '{}' has invalid length")
            ),
            Optional('sensors'): [And(
                str,
                SchemaParser.string_pattern
            )],
            Optional('actuators'): [And(
                str,
                SchemaParser.string_pattern
            )]
        }])

        config_schema = Schema({
            'plcs': plc_schema,
            'inp_file': Path,
            Optional('network_topology_type', default='simple'): And(
                str,
                Use(str.lower),
                Or('complex', 'simple')),
            'output_path': Path,
            Optional('iterations'): And(
                int,
                Schema(lambda i: i > 0, error="'iterations' must be positive.")),
            Optional('mininet_cli', default=False): bool,
            Optional('log_level', default='info'): And(
                str,
                Use(str.lower),
                Or('debug', 'info', 'warning', 'error', 'critical', error="'log_level' should be "
                                                                          "one of the following: "
                                                                          "'debug', 'info', 'warning', "
                                                                          "'error' or 'critical'.")),
            Optional('demand', default='pdd'): And(
                str,
                Use(str.lower),
                Or('pdd', 'dd'), error="'demand' should be one of the following: 'pdd' or 'dd'."),
            Optional('noise_scale', default=0.0): And(
                float,
                Schema(lambda i: i >= 0, error="'noise_scale' must be positive.")),
            Optional('attacks'): {
                Optional('device_attacks'): [SchemaParser.device_attacks],
                Optional('network_attacks'): [SchemaParser.network_attacks],
            },
            Optional('events'): {
                Optional('network_events'): [SchemaParser.network_events],
            },
            Optional('batch_simulations'): And(
                int,
                Schema(lambda i: i > 0, error="'batch_simulations' must be positive.")),
            Optional('saving_interval'): And(
                int,
                Schema(lambda i: i > 0, error="'saving_interval' must be positive.")),
            Optional('initial_tank_data'): Path,
            Optional('demand_patterns'): Path,
            Optional('network_loss_data'): Path,
            Optional('network_delay_data'): Path,
            Optional('simulator', default='wntr'): And(
                str,
                Use(str.lower),
                Or('wntr', 'epynet')),
        })

        return config_schema.validate(data)


class ConfigParser:
    """
    Class handling the parsing of the input config data.

    :param config_path: The path to the config file of the experiment in yaml format
    :type config_path: Path
    """

    def __init__(self, config_path: Path):
        self.batch_index = None
        self.yaml_path = None
        self.db_path = None

        self.config_path = config_path.absolute()

        # YamlIncludeConstructor.add_to_loader_class(loader_class=yaml.FullLoader,
        #                                            base_dir=config_path.absolute().parent)
        yaml.add_constructor("!include", Constructor(base_dir=config_path.absolute().parent), FullLoader)
        try:
            self.data = self.apply_schema(self.config_path)
        except SchemaError as exc:
            sys.exit(exc.code)

        try:
            self.do_checks(self.data)
        except Error as exc:
            sys.exit(exc)

        self.batch_mode = 'batch_simulations' in self.data
        if self.batch_mode:
            self.batch_simulations = self.data['batch_simulations']

    @staticmethod
    def do_checks(data: dict):
        """
        Perform various checks on the data provided

        :param data: The data to check
        """
        ConfigParser.not_too_many_nodes(data)

    @staticmethod
    def not_too_many_nodes(data: dict):
        """
        Check if there are not more then 250 plcs and network attacks.
        This would cause trouble with assigning IP and MAC addresses.

        :param data: the data to check on
        :raise TooManyNodes: When there are more then 250 nodes in the network
        """
        raise_message = "There are too many nodes in the network. Only 250 nodes are supported."

        if 'plcs' in data:
            n_plcs = len(data["plcs"])
            if n_plcs > 250:
                raise TooManyNodes(raise_message)
            if 'attacks' in data and 'network_attacks' in data['attacks'] and \
                    n_plcs + len(data['attacks']['network_attacks']) > 250:
                raise TooManyNodes(raise_message)
        elif 'attacks' in data and 'network_attacks' in data['attacks'] and \
                len(data['attacks']['network_attacks']) > 250:
            raise TooManyNodes(raise_message)

    @staticmethod
    def apply_schema(config_path: Path) -> dict:
        """
        Load the yaml data from the config file, and apply the schema.

        :param config_path: The to the config file
        :type config_path: Path

        :return: A verified version of the data of the config file
        :rtype: dict
        """
        data = ConfigParser.load_yaml(config_path)
        data = SchemaParser.path_schema(data, config_path)
        return SchemaParser.validate_schema(data)

    @staticmethod
    def load_yaml(path: Path) -> dict:
        """
        Uses :code:'pyyaml' and :code'pyyaml-include' to read in a yaml file.
        This means you can use '!include' to include yaml files in other yaml files.

        :param path: path to the yaml file to be loaded.
        :type path: Path
        :return: a dict representing the yaml file
        :rtype: dict
        """
        try:
            with path.open(mode='r') as file:
                data = yaml.load(file, Loader=yaml.FullLoader)
            return data
        except FileNotFoundError as exc:
            sys.exit(f"File not found: {exc.filename}")

    @property
    def output_path(self):
        """
        Property for the path to the output folder.
        ''output'' by default.

        :return: absolute path to the output folder
        :rtype: Path
        """
        path = self.data['output_path']
        if self.batch_mode:
            path /= 'batch_' + str(self.batch_index)
        return path

    @property
    def demand_patterns(self):
        """
        Function that returns path to demand pattern csv

        :return: absolute path to the demand pattern csv
        :rtype: Path
        """
        path = self.data.get('demand_patterns')

        # If running in batch mode, then have to use batch index in name
        if self.batch_mode:
            path /= str(self.batch_index) + '.csv'

        if not path.is_file():
            raise FileNotFoundError(str(path) + " is not a file.")
        return path

    def generate_device_attacks(self, yaml_data):
        """
        This function will add device attacks to the appropriate PLCs in the intermediate yaml

        :param yaml_data: The YAML data without the device attacks
        """
        if 'attacks' in self.data and 'device_attacks' in self.data['attacks']:
            for device_attack in self.data['attacks']['device_attacks']:
                for plc in yaml_data['plcs']:
                    if device_attack['actuator'] in plc['actuators']:
                        if 'attacks' not in plc.keys():
                            plc['attacks'] = []
                        plc['attacks'].append(device_attack)
                        break
        return yaml_data

    def generate_network_attacks(self):
        """
        This function will add network attacks to the appropriate PLCs in the intermediate yaml

        :param network_attacks: The YAML data of the network attacks
        """
        if 'attacks' in self.data and 'network_attacks' in self.data['attacks']:
            network_attacks = self.data['attacks']["network_attacks"]
            for network_attack in network_attacks:
                # Check existence and validity of target PLC

                # This is the only valid target of this attack
                if network_attack['type'] == 'unconstrained_blackbox_concealment_mitm':
                    target = 'scada'
                else:
                    target = network_attack['target']

                # Network attacks to SCADA do not need a target plc
                if target.lower() == 'scada':
                    continue

                target_plc = None
                for plc in self.data.get("plcs"):
                    if plc['name'] == target:
                        target_plc = plc
                        break
                if not target_plc:
                    raise NoSuchPlc("PLC {plc} does not exists".format(plc=target))

                if network_attack['type'] == 'server_mitm':
                    # Check existence of tags on target PLC
                    tags = []
                    for tag in network_attack['tags']:
                        tags.append(tag['tag'])
                    if not set(tags).issubset(set(target_plc['actuators'] + target_plc['sensors'])):
                        raise NoSuchTag(
                            f"PLC {target_plc['name']} does not have all the tags specified.")

                #todo: Checks for concealment_mitm


            return network_attacks
        return []

    def generate_network_events(self):
        """
        This function will add network events in the intermediate yaml
        """

        if 'events' in self.data and 'network_events' in self.data['events']:
            network_events = self.data['events']['network_events']
            for network_event in network_events:
                # Check the existence and validity of target node
                target = network_event['target']

                if target == 'scada':
                    continue

                target_node = None
                for node in self.data.get('plcs'):
                    if node['name'] == target:
                        target_node = target
                        break
                if not target_node:
                    raise NoSuchNode("Node {node} does not exists".format(node=target))

            return network_events
        return []

    def generate_temporary_dirs(self):
        """Generates the temporary directory and yaml/db paths"""
        # Create temp directory and intermediate yaml files in /tmp/
        temp_directory = tempfile.mkdtemp(prefix='dhalsim_')
        # Change read permissions in tempdir
        os.chmod(temp_directory, 0o775)
        self.yaml_path = Path(temp_directory + '/intermediate.yaml')
        self.db_path = temp_directory + '/dhalsim.sqlite'

    def generate_intermediate_yaml(self):
        """Writes the intermediate.yaml file to include all options specified in the config, the plc's and their
        data, and all valves/pumps/tanks etc.

        :return: the path to the yaml file
        :rtype: Path
        """
        self.generate_temporary_dirs()

        yaml_data = {}
        yaml_data['config_path'] = str(self.config_path)

        # Begin with PLC data specified in plcs section
        yaml_data['plcs'] = self.data['plcs']
        # Add path and database information
        yaml_data['inp_file'] = str(self.data['inp_file'])
        yaml_data['output_path'] = str(self.output_path)
        yaml_data['db_path'] = self.db_path
        yaml_data['network_topology_type'] = self.data['network_topology_type']

        # Simulator to be used, it can be EPANET WNTR or EPANET epynet
        yaml_data['simulator'] = self.data['simulator']

        # Add batch mode parameters
        if self.batch_mode:
            yaml_data['batch_index'] = self.batch_index
            yaml_data['batch_simulations'] = self.data['batch_simulations']
        # Initial physical values
        # If the user has not configured initial_tank_data, yaml_data will not have this key
        if 'initial_tank_data' in self.data:
            yaml_data['initial_tank_data'] = str(self.data['initial_tank_data'])
        if 'demand_patterns' in self.data:
            yaml_data['demand_patterns_data'] = str(self.demand_patterns)
        # Add network loss parameters
        if 'network_loss_data' in self.data:
            yaml_data['network_loss_data'] = str(self.data['network_loss_data'])
        # Add network delay parameters
        if 'network_delay_data' in self.data:
            yaml_data['network_delay_data'] = str(self.data['network_delay_data'])
        # Mininet cli parameter
        yaml_data['mininet_cli'] = self.data['mininet_cli']
        # Write intermittent saving interval to intermediate yaml
        if 'saving_interval' in self.data:
            yaml_data['saving_interval'] = self.data['saving_interval']
        # Write gaussian noise scale value to intermediate yaml
        if 'noise_scale' in self.data:
            yaml_data['noise_scale'] = self.data['noise_scale']
        else:
            yaml_data['noise_scale'] = 0

        # Demand
        yaml_data['demand'] = self.data['demand']

        # Note: if iterations not present then default value will be written in InputParser
        if 'iterations' in self.data:
            yaml_data['iterations'] = self.data['iterations']

        # Log level
        yaml_data['log_level'] = self.data['log_level']

        yaml_data['start_time'] = datetime.now()
        # Write values from INP file into yaml file (controls, tanks/valves/initial values, etc.)

        # toDo: test this - preparing DHALSIM to be used with other simulators
        if self.data['simulator'] == 'wntr' or self.data['simulator'] == 'epynet':
            yaml_data = InputParser(yaml_data).write()

        # Parse the device attacks from the config file
        yaml_data = self.generate_device_attacks(yaml_data)
        yaml_data["network_attacks"] = self.generate_network_attacks()

        # Parse network events from the config file
        yaml_data["network_events"] = self.generate_network_events()

        # Write data to yaml file
        with self.yaml_path.open(mode='w') as intermediate_yaml:
            yaml.safe_dump(yaml_data, intermediate_yaml)

        return self.yaml_path