def __init__(self):
Overlay.__init__(self, self.__class__.__name__)
self._vertices = {}
self._edges = []
# Get a logger
self._log = Logger.get_instance()
def __init__(self, name):
# The logger
self._log = Logger.get_instance()
# The name of the service
self._name = name
# self._overlay = None
self._alternatives = []
def __init__(self):
Thread.__init__(self)
# This extractor is a observable object, due to the fact that upon extraction finishes, other actions will be
# undertaken
Observable.__init__(self)
# Logger
self._log = Logger.get_instance()
def __init__(self, topology, service, environment, alternative):
Thread.__init__(self)
""" Utils objects """
# Get the object for filesystem handling
self._fs = FileSystem.get_instance()
# Logger
self._log = Logger.get_instance()
# Root simulation path (simulation/)
self._root_simulation_path = self._fs.get_simulations_folder()
# Specific simulation path (simulation/service_name/timestamp/)
self._simulation_path = None
# The topology
self._topology = topology
# Service to evaluate
self._service = service
# The environment in which this simulation is running
self._environment = environment
# The alternative of the service to evaluate
self._alternative = alternative
# The metrics to evaluate during this simulation
self._metrics = alternative.get_metrics()
# Extractor count. This variable is used to keep track of how many extractors notified this object
self._extractor_number = len(self._metrics)
self._extractor_count = 0
# Initialize the simulation
self._init()
def __init__(self, overlay):
# Logger
self._log = Logger.get_instance()
# The overlay based on which the topology is created
self._overlay = overlay
# Create a Mininet instance
self._net = Mininet(controller=None, switch=CustomSwitch, listenPort=6634, inNamespace=False)
# Add controller to the network
self._net.addController('c0', controller=RemoteController, ip='127.0.0.1', port=6633)
def __init__(self):
Overlay.__init__(self, self.__class__.__name__)
# Logger
self._log = Logger.get_instance()
# Internal data structures
self._switches = {}
self._hosts = {}
# This is a map<device, list of all connected devices>; it is an OrderedDict to preserve the mapping between
# host-pe connections.
self._links = [] #OrderedDict()
def __init__(self, controller_path, controller_cmd):
# Get the framework file system handler
self._fs = FileSystem.get_instance()
# Logger
self._log = Logger.get_instance()
# Controller's parameters
self._path = controller_path
self._cmd = controller_cmd
# The controller process
self._controller_process = None
def __init__(self, topology):
self._name = None
self._overlays = {}
self._current_overlay = None
self._topology_as_graphml = topology
# Get a logger
self._log = Logger.get_instance()
# When create a Topology object, add it a Topology Overlay by default.
self._add_topology_overlay()
def __init__(self):
# Logger
self._log = Logger.get_instance()
# ConfigObj reference
self._parser = None
# System configuration parser
self._system_parser = SystemParser()
# Service parser factory
self._factory_service_parser = FactoryServiceParser.get_instance()
# The service specific parser
self._service_parser = None
# The factories for the creation of extractors and collectors
self._factory_extractor = FactoryExtractor.get_instance()
self._factory_collector = FactoryCollector.get_instance()
# All services expressed in the configuration file. Each service is an instance of model.service.Service
self._services = []
def __init__(self):
# Get a logger
self._log = Logger.get_instance()
# Create the parser
self._parser = Parser()
# The topology
self._topology = None
# Factory loader. For each alternative, a new environment is loaded in accord with the alternative itself.
self._loader = EnvironmentLoader()
# ArgParse
self._arg = argparse.ArgumentParser(description='Comparison Framework')
self._arg.add_argument('-c',
'--config-file',
required=True,
help='The framework configuration file.')
self._arg.add_argument('-t',
'--topology',
required=True,
help='The topology on which framework runs. It must be a GraphML file.')
def __init__(self):
# Reference to the file to parse
self._parser = XmlParser.parse('conf/system.xml')
# Logger
self._log = Logger.get_instance()
# All services. This is a map<name, parser_adapter>
self._services = {}
# Mapping between services and alternatives. This is a map<service_name, list(alternative_name)>
self._service_to_alternatives = {}
# All alternatives. This is a map<name, alternative_adapter>
self._alternatives = {}
# All metrics. This is a list
self._metrics = []
# Mapping between metric and collector adapter. This is a map<metric_name, collector_adapter_name>
self._metric_to_collector = {}
# Mapping between metric and extractor adapter. This is a map<metric_name, extractor_adapter_name>
self._metric_to_extractor = {}
# All environments. This is a map<env_name, adapter>
self._environments = {}
# Mapping between environments and alternatives. This is a map<env_name, list(alternative_name)>
self._environment_to_alternatives = {}
def main(nbargs=()):
parser = argparse.ArgumentParser()
parser.add_argument("--exp-name",
default="default",
help="Name of the experiment")
parser.add_argument("--logs-dir",
default="logs",
help="Directory for storing logs")
parser.add_argument("--config-file",
default=None,
help="Path to config.yml")
try:
_ = get_ipython().__class__.__name__
args = parser.parse_args(nbargs)
except NameError:
args = parser.parse_args()
cfg = load_config(args)
logger = Logger.get_instance(cfg)
logger.info("Configuration")
logger.info("-" * 50)
for key, value in cfg.items():
logger.info("{:25s}:\t{:s}".format(str(key), str(value)))
logger.info("-" * 50)
for i in tqdm(range(5)):
logger.info("Info message {:d}".format(i))
time.sleep(0.5)
return cfg
def __init__(self):
# Logger
self._log = Logger.get_instance()
# The reference to the extractor object
self._extractor = None
def __init__(self, mininet_topology):
Thread.__init__(self)
# Logger
self._log = Logger.get_instance()
# The reference to the topology executing into mininet
self._mininet_topology = mininet_topology
def __init__(self, name):
# Logger
self._log = Logger.get_instance()
# The name of the alternative
self._name = name
def __init__(self):
Thread.__init__(self)
# Logger
self._log = Logger.get_instance()
def __init__(self, service_name):
# Logger
self._log = Logger.get_instance()
# The service's name
self._service_name = service_name
#! /usr/bin/env python
from framework import ComparisonFramework
from utils.log import Logger
if __name__ == '__main__':
log = Logger.get_instance()
framework = ComparisonFramework()
log.info('Runner', 'Framework starts.')
framework.run()
def __init__(self):
# FileSystem handler
self._fs = FileSystem.get_instance()
# Logger
self._log = Logger.get_instance()
def __init__(self):
# The reference to the FileSystem object, useful for writing configuration in tmp folder
self._fs = FileSystem.get_instance()
# Logger
self._log = Logger.get_instance()
