def _handle_InstallationFinishedEvent(self, event):
"""
Get information from NFFG installation process.
:param event: event object info
:type event: :any:`InstallationFinishedEvent`
:return: None
"""
if not InstantiationFinishedEvent.is_error(event.result):
self.log.info(
"NF-FG(%s) instantiation has been finished successfully "
"with result: %s!" % (event.id, event.result))
else:
self.log.error(
"NF-FG(%s) instantiation has been finished with error "
"result: %s!" % (event.id, event.result))
if InstantiationFinishedEvent.is_deploy_error(event.result):
if CONFIG.get_trial_and_error(layer=LAYER_NAME):
log.info(
"TRIAL_AND_ERROR is enabled! Reschedule for mapping..."
)
self.__proceed_trial_and_error(
original_request_id=event.id)
return
else:
log.debug("TRIAL_AND_ERROR is disabled! Proceeding...")
if not event.is_pending(event.result):
self.__process_mapping_result(nffg_id=event.id,
fail=event.is_error(event.result))
self.raiseEventNoErrors(InstantiationFinishedEvent,
id=event.id,
result=event.result)
def __manage_neo4j_service(self):
"""
Manage neo4j service.
:return: None
"""
if not CONFIG.get_manage_neo4j_service():
log.debug("Skip Neo4j service management...")
return
log.debug("Detected Neo4j service name: %s" % self.service_name)
if check_service_status(self.service_name):
log.debug("%s service is already running..." % self.service_name)
return
log.info("Starting service: %s..." % self.service_name)
ret = run_cmd('sudo service %s start' % self.service_name)
if "failed" in ret:
log.error("Neo4j service initiation status: %s" % ret)
return
log.log(VERBOSE, "Neo4j service initiation status: %s" % ret)
# Check if the service has been started - only 5 try
if port_tester(host=self.DB_HOST,
port=self.DB_PORT,
interval=1,
period=10,
log=log):
log.debug("Neo4j service has been verified!")
else:
log.error("Neo4j service has not started correctly!")
def initialize(self):
"""
.. seealso::
:func:`AbstractAPI.initialize() <escape.util.api.AbstractAPI.initialize>`
"""
log.debug("Initializing Resource Orchestration Sublayer...")
self.resource_orchestrator = ResourceOrchestrator(self)
if self._nffg_file:
try:
service_request = self._read_data_from_file(self._nffg_file)
service_request = NFFG.parse(service_request)
self.__proceed_instantiation(nffg=service_request)
except (ValueError, IOError, TypeError) as e:
log.error("Can't load service request from file because of: " +
str(e))
else:
log.info("Graph representation is loaded successfully!")
# Initiate ROS REST-API if needed
if self._agent or self._rosapi:
self._initiate_ros_api()
# Initiate Cf-Or REST-API if needed
if self._cfor:
self._initiate_cfor_api()
log.info("Resource Orchestration Sublayer has been initialized!")
if self._agent:
log.warning(
"In AGENT mode Service Layer is not going to be initialized!")
def __process_mapping_result(self, nffg_id, fail):
"""
Perform common tasks after the mapping alg has run and deploy is performed.
:param nffg_id: deployed NFFG id
:type nffg_id: str or int
:param fail: mark the deploy step was failed
:type fail: bool
:return: None
"""
self.log.debug("Cache request status...")
req_status = self.api_mgr.request_cache.get_request_by_nffg_id(nffg_id)
if req_status is None:
self.log.debug("Request status is missing for NFFG: %s! "
"Skip result processing..." % nffg_id)
return
self.log.debug("Process mapping result...")
message_id = req_status.message_id
if message_id is not None:
if fail:
self.api_mgr.request_cache.set_error_result(id=message_id)
else:
self.api_mgr.request_cache.set_success_result(id=message_id)
log.info("Set request status: %s for message: %s" %
(req_status.status, req_status.message_id))
ret = self.api_mgr.invoke_callback(message_id=message_id)
if ret is None:
self.log.debug("No callback was defined!")
else:
self.log.debug(
"Callback: %s has invoked with return value: %s" %
(req_status.get_callback(), ret))
RequestScheduler().set_orchestration_finished(id=nffg_id)
def __process_info_result(self, status, fail):
"""
Perform common tasks after an Info request was processed and responses were
collected.
:param status: deploy status
:type status: :any:`DomainRequestStatus`
:param fail: mark the Info step was failed
:type fail: bool
:return: None
"""
self.log.debug("Cache collected 'info' request status...")
req_status = self.api_mgr.request_cache.get_request(
message_id=status.id)
if req_status is None:
self.log.debug("Request status is missing: %s! "
"Skip result processing..." % status.id)
return
self.log.debug("Process collected info result...")
if fail:
self.api_mgr.request_cache.set_error_result(id=status.id)
body = None
else:
self.api_mgr.request_cache.set_success_result(id=status.id)
body = status.data[0]
body = body.xml() if isinstance(body, Info) else str(body)
log.info("Set request status: %s for message: %s" %
(req_status.status, req_status.message_id))
log.log(VERBOSE, "Collected Info data:\n%s" % body)
ret = self.api_mgr.invoke_callback(message_id=status.id, body=body)
if ret is None:
self.log.debug("No callback was defined!")
else:
self.log.info("Callback: %s has invoked with return value: %s" %
(req_status.get_callback(), ret))
def timer_decorator(func, *args, **kwargs):
start = time.time()
try:
result = func(*args, **kwargs)
finally:
delta = time.time() - start
log.info("Mapping algorithm finished in %.3f seconds!" % delta)
return result
def shutdown(self, event):
"""
.. seealso::
:func:`AbstractAPI.shutdown() <escape.util.api.AbstractAPI.shutdown>`
:param event: event object
"""
log.info("Resource Orchestration Sublayer is going down...")
self.orchestrator.finalize()
def __init__(self, standalone=False, **kwargs):
"""
.. seealso::
:func:`AbstractAPI.__init__() <escape.util.api.AbstractAPI.__init__>`
"""
log.info("Starting Resource Orchestration Sublayer...")
# Mandatory super() call
self.resource_orchestrator = None
super(ResourceOrchestrationAPI, self).__init__(standalone, **kwargs)
def finalize(self):
"""
Finalize function for the class.
:return: None
"""
if CONFIG.get_manage_neo4j_service():
log.info("Stopping %s service..." % self.service_name)
ret = run_cmd('sudo service %s stop' % self.service_name)
log.log(VERBOSE, "Neo4j service shutdown status: %s" % ret)
def cprofiler_decorator(func, *args, **kwargs):
profiler = cProfile.Profile(builtins=False, subcalls=False)
try:
profiler.enable()
result = func(*args, **kwargs)
finally:
profiler.disable()
profiler.create_stats()
stat = pstats.Stats(profiler)
log.info("Mapping algorithm finished with %d function calls "
"(%d primitive calls) in %.3f seconds!" %
(stat.total_calls, stat.prim_calls, stat.total_tt))
return result
def _initiate_ros_api(self):
"""
Initialize and setup REST API in a different thread.
If agent_mod is set rewrite the received NFFG domain from REMOTE to
INTERNAL.
:return: None
"""
rest_api = self.get_dependent_component('REST-API')
rest_api.register_component(component=self)
if self._agent:
log.info("REST-API is set in AGENT mode")
def shutdown(self, event):
"""
.. seealso::
:func:`AbstractAPI.shutdown() <escape.util.api.AbstractAPI.shutdown>`
:param event: event object
"""
log.info("Resource Orchestration Sublayer is going down...")
if self._agent or self._rosapi:
log.debug("REST-API: %s is shutting down..." % self.ros_api.api_id)
# self.ros_api.stop()
if self._cfor:
log.debug("REST-API: %s is shutting down..." %
self.cfor_api.api_id)
def timer_decorator(func, *args, **kwargs):
"""
Decorator function to measure the runtime of given function.
:param func: profiled function
:type func: callable
:return: return value of given function
"""
start = time.time()
try:
result = func(*args, **kwargs)
finally:
delta = time.time() - start
log.info("Mapping algorithm finished in %.3f seconds!" % delta)
return result
def __init__(self, standalone=False, **kwargs):
"""
.. seealso::
:func:`AbstractAPI.__init__() <escape.util.api.AbstractAPI.__init__>`
"""
log.info("Starting Resource Orchestration Sublayer...")
# Mandatory super() call
self.orchestrator = None
""":type: ResourceOrchestrator"""
self.api_mgr = RESTAPIManager(
unique_bb_id=False,
unique_nf_id=CONFIG.ensure_unique_vnf_id(),
logger=log)
self.log = log.getChild('API')
super(ResourceOrchestrationAPI, self).__init__(standalone, **kwargs)
def _initiate_ros_api(self):
"""
Initialize and setup REST API in a different thread.
If agent_mod is set rewrite the received NFFG domain from REMOTE to
INTERNAL.
:return: None
"""
# set bounded layer name here to avoid circular dependency problem
handler = CONFIG.get_ros_agent_class()
handler.bounded_layer = self._core_name
params = CONFIG.get_ros_agent_params()
# can override from global config
if 'prefix' in params:
handler.prefix = params['prefix']
if 'unify_interface' in params:
handler.virtualizer_format_enabled = params['unify_interface']
if 'diff' in params:
handler.DEFAULT_DIFF = bool(params['diff'])
address = (params.get('address'), params.get('port'))
# Virtualizer ID of the Sl-Or interface
self.ros_api = RESTServer(handler, *address)
self.ros_api.api_id = handler.LOGGER_NAME = "Sl-Or"
# Virtualizer type for Sl-Or API
self.ros_api.virtualizer_type = CONFIG.get_api_virtualizer(
layer_name=LAYER_NAME, api_name=self.ros_api.api_id)
handler.log.info("Init REST-API for %s on %s:%s!" %
(self.ros_api.api_id, address[0], address[1]))
self.ros_api.start()
handler.log.debug(
"Enforced configuration for %s: virtualizer type: %s, interface: %s, "
"diff: %s" % (self.ros_api.api_id, self.ros_api.virtualizer_type,
"UNIFY" if handler.virtualizer_format_enabled else
"Internal-NFFG", handler.DEFAULT_DIFF))
if self._agent:
log.info("REST-API is set in AGENT mode")
def __initialize (self):
"""
Initialize NFIB with test data.
"""
log.info("Initializing NF database with NFs and decompositions...")
# start clean - all the existing info is removed from the DB
self.removeGraphDB()
# add new high-level NF to the DB, all the information related to the NF
# should be given as a dict
self.addNode({'label': 'NF', 'node_id': 'forwarder', 'type': 'NA'})
self.addNode({'label': 'NF', 'node_id': 'compressor', 'type': 'NA'})
self.addNode({'label': 'NF', 'node_id': 'decompressor', 'type': 'NA'})
log.debug(
"%s: high-level NFs were added to the DB" % self.__class__.__name__)
# generate a decomposition for a high-level forwarder NF (in form of
# networkx)
G1 = networkx.DiGraph()
G1.add_path(['SAP1', 'simpleForwarder', 'SAP2'])
# create node properties
for n in G1.nodes():
properties = {'node_id': n}
if 'SAP' in n:
properties['label'] = 'SAP'
properties['type'] = 'NA'
else:
properties['label'] = 'NF'
properties['type'] = 'click'
properties['cpu'] = 10
properties['mem'] = 100
properties['storage'] = 100
G1.node[n]['properties'] = properties
# create edge properties
properties = {'BW': 100, 'src_port': 1, 'dst_port': 1}
G1.edge['SAP1']['simpleForwarder']['properties'] = properties
properties1 = {'BW': 100, 'src_port': 2, 'dst_port': 2}
G1.edge['simpleForwarder']['SAP2']['properties'] = properties1
# generate a decomposition for a high-level compressor NF (in form of
# networkx)
G2 = networkx.DiGraph()
G2.add_path(['SAP3', 'headerCompressor', 'SAP4'])
# create node properties
for n in G2.nodes():
properties = {'node_id': n}
if 'SAP' in n:
properties['label'] = 'SAP'
properties['type'] = 'NA'
else:
properties['label'] = 'NF'
properties['type'] = 'click'
properties['cpu'] = 20
properties['mem'] = 200
properties['storage'] = 200
G2.node[n]['properties'] = properties
# create edge properties
properties3 = {'BW': 200, 'src_port': 1, 'dst_port': 1}
G2.edge['SAP3']['headerCompressor']['properties'] = properties3
properties4 = {'BW': 200, 'src_port': 2, 'dst_port': 2}
G2.edge['headerCompressor']['SAP4']['properties'] = properties4
# generate a decomposition for a high-level decompressor NF (in form of
# networkx)
G3 = networkx.DiGraph()
G3.add_path(['SAP5', 'headerDecompressor', 'SAP6'])
# create node properties
for n in G3.nodes():
properties = {'node_id': n}
if 'SAP' in n:
properties['label'] = 'SAP'
properties['type'] = 'NA'
else:
properties['label'] = 'NF'
properties['type'] = 'click'
properties['cpu'] = 30
properties['mem'] = 300
properties['storage'] = 300
G3.node[n]['properties'] = properties
# create edge properties
properties5 = {'BW': 300, 'src_port': 1, 'dst_port': 1}
G3.edge['SAP5']['headerDecompressor']['properties'] = properties5
properties6 = {'BW': 300, 'src_port': 2, 'dst_port': 2}
G3.edge['headerDecompressor']['SAP6']['properties'] = properties6
# required elementary NFs should be added first to the DB
self.addClickNF({'label': 'NF', 'node_id': 'Queue', 'type:': 'click'})
self.addClickNF({'label': 'NF', 'node_id': 'Classifier', 'type': 'click'})
self.addClickNF({'label': 'NF', 'node_id': 'Counter', 'type': 'click'})
self.addClickNF({'label': 'NF', 'node_id': 'RFC2507Comp', 'type': 'click'})
self.addClickNF(
{'label': 'NF', 'node_id': 'RFC2507Decomp', 'type': 'click'})
# the NF decompositions are added to the DB
self.addDecomp('forwarder', 'G1', G1)
self.addDecomp('compressor', 'G2', G2)
self.addDecomp('decompressor', 'G3', G3)
log.debug(
"%s: NF decompositions were added to the DB" % self.__class__.__name__)
def __proceed_instantiation(self, nffg, resource_nffg):
"""
Helper function to instantiate the NFFG mapping from different source.
:param nffg: pre-mapped service request
:type nffg: :class:`NFFG`
:return: None
"""
self.log.info("Invoke instantiation on %s with NF-FG: %s" %
(self.__class__.__name__, nffg.name))
stats.add_measurement_start_entry(type=stats.TYPE_ORCHESTRATION,
info=LAYER_NAME)
# Get shown topology view
if resource_nffg is None:
log.error("Missing resource for difference calculation!")
return
log.debug("Got resource view for difference calculation: %s" %
resource_nffg)
self.log.debug("Store received NFFG request info...")
msg_id = self.api_mgr.request_cache.cache_request_by_nffg(nffg=nffg)
if msg_id is not None:
self.api_mgr.request_cache.set_in_progress(id=msg_id)
self.log.debug("Request is stored with id: %s" % msg_id)
else:
self.log.debug("No request info detected.")
# Check if mapping mode is set globally in CONFIG
mapper_params = CONFIG.get_mapping_config(layer=LAYER_NAME)
if 'mode' in mapper_params and mapper_params['mode'] is not None:
mapping_mode = mapper_params['mode']
log.info("Detected mapping mode from configuration: %s" %
mapping_mode)
elif nffg.mode is not None:
mapping_mode = nffg.mode
log.info("Detected mapping mode from NFFG: %s" % mapping_mode)
else:
mapping_mode = None
log.info("No mapping mode was defined explicitly!")
if not CONFIG.get_mapping_enabled(layer=LAYER_NAME):
log.warning("Mapping is disabled! Skip difference calculation...")
elif nffg.status == NFFG.MAP_STATUS_SKIPPED:
log.debug("Detected NFFG map status: %s! "
"Skip difference calculation and "
"proceed with original request..." % nffg.status)
elif mapping_mode != NFFG.MODE_REMAP:
# Calculated ADD-DELETE difference
log.debug("Calculate ADD - DELETE difference with mapping mode...")
# Recreate SG-hops for diff calc.
log.debug("Recreate SG hops for difference calculation...")
NFFGToolBox.recreate_all_sghops(nffg=nffg)
NFFGToolBox.recreate_all_sghops(nffg=resource_nffg)
log.log(VERBOSE, "New NFFG:\n%s" % nffg.dump())
log.log(VERBOSE, "Resource NFFG:\n%s" % resource_nffg.dump())
# Calculate difference
add_nffg, del_nffg = NFFGToolBox.generate_difference_of_nffgs(
old=resource_nffg, new=nffg, ignore_infras=True)
log.log(VERBOSE, "Calculated ADD NFFG:\n%s" % add_nffg.dump())
log.log(VERBOSE, "Calculated DEL NFFG:\n%s" % del_nffg.dump())
if not add_nffg.is_bare() and del_nffg.is_bare():
nffg = add_nffg
log.info("DEL NFFG is bare! Calculated mapping mode: %s" %
nffg.mode)
elif add_nffg.is_bare() and not del_nffg.is_bare():
nffg = del_nffg
log.info("ADD NFFG is bare! Calculated mapping mode: %s" %
nffg.mode)
elif not add_nffg.is_bare() and not del_nffg.is_bare():
log.warning("Both ADD / DEL mode is not supported currently")
self.__process_mapping_result(nffg_id=nffg.id, fail=True)
stats.add_measurement_end_entry(type=stats.TYPE_ORCHESTRATION,
info=LAYER_NAME + "-FAILED")
self.raiseEventNoErrors(
InstantiationFinishedEvent,
id=nffg.id,
result=InstantiationFinishedEvent.ABORTED)
return
else:
log.debug("Difference calculation resulted empty subNFFGs!")
log.warning(
"No change has been detected in request! Skip mapping...")
self.log.debug("Invoked instantiation on %s is finished!" %
self.__class__.__name__)
self.__process_mapping_result(nffg_id=nffg.id, fail=False)
stats.add_measurement_end_entry(type=stats.TYPE_ORCHESTRATION,
info=LAYER_NAME + "-SKIPPED")
return
else:
log.debug(
"Mode: %s detected from config! Skip difference calculation..."
% mapping_mode)
try:
if CONFIG.get_mapping_enabled(layer=LAYER_NAME):
# Initiate request mapping
mapped_nffg = self.orchestrator.instantiate_nffg(nffg=nffg)
else:
log.warning("Mapping is disabled! Skip instantiation step...")
mapped_nffg = nffg
mapped_nffg.status = NFFG.MAP_STATUS_SKIPPED
log.debug("Mark NFFG status: %s!" % mapped_nffg.status)
# Rewrite REMAP mode for backward compatibility
if mapped_nffg is not None and mapping_mode == NFFG.MODE_REMAP:
mapped_nffg.mode = mapping_mode
log.debug("Rewrite mapping mode: %s into mapped NFFG..." %
mapped_nffg.mode)
else:
log.debug("Skip mapping mode rewriting! Mode remained: %s" %
mapping_mode)
self.log.debug("Invoked instantiate_nffg on %s is finished!" %
self.__class__.__name__)
# If mapping is not threaded and finished with OK
if mapped_nffg is not None and not self.orchestrator.mapper.threaded:
self._proceed_to_install_NFFG(mapped_nffg=mapped_nffg,
original_request=nffg)
else:
log.warning(
"Something went wrong in service request instantiation: "
"mapped service request is missing!")
self.__process_mapping_result(nffg_id=nffg.id, fail=True)
stats.add_measurement_end_entry(type=stats.TYPE_ORCHESTRATION,
info=LAYER_NAME + "-FAILED")
self.raiseEventNoErrors(
InstantiationFinishedEvent,
id=nffg.id,
result=InstantiationFinishedEvent.MAPPING_ERROR)
except ProcessorError as e:
self.__process_mapping_result(nffg_id=nffg.id, fail=True)
stats.add_measurement_end_entry(type=stats.TYPE_ORCHESTRATION,
info=LAYER_NAME + "-DENIED")
self.raiseEventNoErrors(
InstantiationFinishedEvent,
id=nffg.id,
result=InstantiationFinishedEvent.REFUSED_BY_VERIFICATION,
error=e)
def map(cls, graph, resource, persistent=None, pre_state=None):
"""
Default mapping algorithm of ESCAPEv2.
:param graph: Network Function forwarding Graph
:type graph: :class:`NFFG`
:param resource: global virtual resource info
:type resource: :class:`NFFG`
:param persistent: use persistent state object
:type persistent: object
:param pre_state: use mapping state for continued mapping
:type pre_state: :class:`MappingState`
:return: mapped Network Function Forwarding Graph
:rtype: :class:`NFFG`
"""
log.info("Invoke mapping algorithm: %s - request: %s resource: %s, "
"previous state: %s" %
(cls.__name__, graph, resource, pre_state))
if graph is None:
log.error("Missing request NFFG! Abort mapping process...")
return
if resource is None:
log.error("Missing resource NFFG! Abort mapping process...")
return
try:
# Run pre-mapping step to resolve target-less flowrules
cls._resolve_external_ports(graph, resource)
# Copy mapping config
mapper_params = CONFIG.get_mapping_config(
layer=cls.LAYER_NAME).copy()
mapper_params['persistent'] = persistent
if 'mode' in mapper_params and mapper_params['mode']:
log.debug("Setup mapping mode from configuration: %s" %
mapper_params['mode'])
elif graph.mode:
mapper_params['mode'] = graph.mode
log.debug("Setup mapping mode based on request: %s" %
mapper_params['mode'])
if CONFIG.get_trial_and_error(layer=cls.LAYER_NAME):
log.info("Use 'trial and error' approach for mapping")
mapper_params['return_mapping_state'] = True
mapper_params['mapping_state'] = pre_state
mapping_result = cls.call_mapping_algorithm(
request=graph.copy(),
topology=resource.copy(),
**mapper_params)
if isinstance(mapping_result, tuple or list):
mapped_nffg = mapping_result[0]
else:
mapped_nffg = mapping_result
# Set mapped NFFG id for original SG request tracking
log.debug("Move request metadata into mapping result...")
mapped_nffg.id = graph.id
mapped_nffg.name = "%s-%s-mapped" % (graph.name, cls.LAYER_NAME)
# Explicitly copy metadata
mapped_nffg.metadata = graph.metadata.copy()
# Explicit copy of SAP data
for sap in graph.saps:
if sap.id in mapped_nffg:
mapped_nffg[sap.id].metadata = graph[
sap.id].metadata.copy()
log.info("Mapping algorithm: %s is finished on NF-FG: %s" %
(cls.__name__, mapped_nffg))
return mapping_result
except MappingException as e:
log.error(
"Mapping algorithm unable to map given request! Cause:\n%s" %
e.msg)
log.error("Mapping algorithm on %s is aborted!" % graph)
return
except BadInputException as e:
log.error("Mapping algorithm refuse given input! Cause:\n%s" %
e.msg)
log.error("Mapping algorithm on %s is aborted!" % graph)
return
except InternalAlgorithmException as e:
log.critical(
"Mapping algorithm fails due to internal error! Cause:\n%s" %
e.msg)
log.error("Mapping algorithm on %s is aborted!" % graph)
return
except Exception:
log.exception("Got unexpected error during mapping process!")
def _perform_mapping(self, input_graph, resource_view):
"""
Orchestrate mapping of given NF-FG on given global resource.
:param input_graph: Network Function Forwarding Graph
:type input_graph: :any:`NFFG`
:param resource_view: global resource view
:type resource_view: :any:`DomainVirtualizer`
:return: mapped Network Function Forwarding Graph
:rtype: :any:`NFFG`
"""
if input_graph is None:
log.error(
"Missing mapping request information! Abort mapping process!")
return None
log.debug("Request %s to launch orchestration on NF-FG: %s with View: "
"%s" % (self.__class__.__name__, input_graph, resource_view))
# Steps before mapping (optional)
log.debug("Request global resource info...")
virt_resource = resource_view.get_resource_info()
if virt_resource is None:
log.error("Missing resource information! Abort mapping process!")
return None
# log a warning if resource is empty --> possibly mapping will be failed
if virt_resource.is_empty():
log.warning("Resource information is empty!")
# Log verbose resource view if it is exist
log.log(
VERBOSE,
"Orchestration Layer resource graph:\n%s" % virt_resource.dump())
# Check if the mapping algorithm is enabled
if not CONFIG.get_mapping_enabled(LAYER_NAME):
log.warning("Mapping algorithm in Layer: %s is disabled! "
"Skip mapping step and return service request "
"to lower layer..." % LAYER_NAME)
# virt_resource.id = input_graph.id
# return virt_resource
# Send request forward (probably to Remote ESCAPE)
return input_graph
# Run actual mapping algorithm
if self._threaded:
# Schedule a microtask which run mapping algorithm in a Python thread
log.info("Schedule mapping algorithm: %s in a worker thread" %
self.strategy.__name__)
call_as_coop_task(self._start_mapping,
graph=input_graph,
resource=virt_resource)
log.info("NF-FG: %s orchestration is finished by %s" %
(input_graph, self.__class__.__name__))
# Return with None
return None
else:
mapped_nffg = self.strategy.map(graph=input_graph,
resource=virt_resource)
if mapped_nffg is None:
log.error(
"Mapping process is failed! Abort orchestration process.")
else:
# Steps after mapping (optional)
log.info(
"NF-FG: %s orchestration is finished by %s successfully!" %
(input_graph, self.__class__.__name__))
return mapped_nffg
def _perform_mapping(self, input_graph, resource_view, continued=False):
"""
Orchestrate mapping of given NF-FG on given global resource.
:param input_graph: Network Function Forwarding Graph
:type input_graph: :class:`NFFG`
:param resource_view: global resource view
:type resource_view: :any:`DomainVirtualizer`
:return: mapped Network Function Forwarding Graph
:rtype: :class:`NFFG`
"""
if input_graph is None:
log.error(
"Missing mapping request information! Abort mapping process!")
return None
log.debug(
"Request %s to launch orchestration on NF-FG: %s with View: "
"%s, continued remap: %s" %
(self.__class__.__name__, input_graph, resource_view, continued))
# Steps before mapping (optional)
log.debug("Request global resource info...")
virt_resource = resource_view.get_resource_info()
if virt_resource is None:
log.error("Missing resource information! Abort mapping process!")
return None
# log a warning if resource is empty --> possibly mapping will be failed
if virt_resource.is_empty():
log.warning("Resource information is empty!")
# Log verbose resource view if it is exist
log.log(
VERBOSE,
"Orchestration Layer resource graph:\n%s" % virt_resource.dump())
# Check if the mapping algorithm is enabled
if not CONFIG.get_mapping_enabled(LAYER_NAME):
log.warning("Mapping algorithm in Layer: %s is disabled! "
"Skip mapping step and return service request "
"to lower layer..." % LAYER_NAME)
# virt_resource.id = input_graph.id
# return virt_resource
# Send request forward (probably to Remote ESCAPE)
input_graph.status = NFFG.MAP_STATUS_SKIPPED
log.debug("Mark NFFG status: %s!" % input_graph.status)
return input_graph
# Run actual mapping algorithm
if self._threaded:
# Schedule a microtask which run mapping algorithm in a Python thread
log.info("Schedule mapping algorithm: %s in a worker thread" %
self.strategy.__name__)
call_as_coop_task(self._start_mapping,
graph=input_graph,
resource=virt_resource)
log.info("NF-FG: %s orchestration is finished by %s" %
(input_graph, self.__class__.__name__))
# Return with None
return None
else:
state = self.last_mapping_state if continued else None
mapping_result = self.strategy.map(
graph=input_graph,
resource=virt_resource,
persistent=self.persistent_state,
pre_state=state)
if isinstance(mapping_result, tuple or list):
if len(mapping_result) == 2:
mapped_nffg = mapping_result[0]
self.persistent_state = mapping_result[1]
log.debug("Cache returned persistent state: %s" %
self.persistent_state)
elif len(mapping_result) == 3:
mapped_nffg = mapping_result[0]
self.persistent_state = mapping_result[1]
log.debug("Cache returned persistent state: %s" %
self.persistent_state)
self.last_mapping_state = mapping_result[2]
log.debug("Cache returned mapping state: %s" %
self.last_mapping_state)
else:
log.error("Mapping result is invalid: %s" %
repr(mapping_result))
mapped_nffg = None
else:
mapped_nffg = mapping_result
# Check error result
if mapped_nffg is None:
log.error(
"Mapping process is failed! Abort orchestration process.")
else:
# Steps after mapping (optional)
log.info(
"NF-FG: %s orchestration is finished by %s successfully!" %
(input_graph, self.__class__.__name__))
log.debug("Last mapping state: %s" % self.last_mapping_state)
if self.last_mapping_state:
log.debug("Mapping iteration: %s" %
self.last_mapping_state.get_number_of_trials()
if self.last_mapping_state else None)
return mapped_nffg
def instantiate_nffg (self, nffg):
"""
Main API function for NF-FG instantiation.
:param nffg: NFFG instance
:type nffg: :any:`NFFG`
:return: mapped NFFG instance
:rtype: :any:`NFFG`
"""
log.debug("Invoke %s to instantiate given NF-FG" % self.__class__.__name__)
# Store newly created NF-FG
self.nffgManager.save(nffg)
# Get Domain Virtualizer to acquire global domain view
global_view = self.virtualizerManager.dov
# Notify remote visualizer about resource view of this layer if it's needed
notify_remote_visualizer(data=global_view.get_resource_info(),
id=LAYER_NAME)
# Log verbose mapping request
log.log(VERBOSE, "Orchestration Layer request graph:\n%s" % nffg.dump())
# Start Orchestrator layer mapping
print nffg.dump()
if global_view is not None:
if isinstance(global_view, AbstractVirtualizer):
# If the request is a bare NFFG, it is probably an empty topo for domain
# deletion --> skip mapping to avoid BadInputException and forward
# topo to adaptation layer
if nffg.is_bare():
log.warning("No valid service request (VNFs/Flowrules/SGhops) has "
"been detected in SG request! Skip orchestration in "
"layer: %s and proceed with the bare %s..." %
(LAYER_NAME, nffg))
if nffg.is_virtualized():
if nffg.is_SBB():
log.debug("Request is a bare SingleBiSBiS representation!")
else:
log.warning(
"Detected virtualized representation with multiple BiSBiS "
"nodes! Currently this type of virtualization is nut fully"
"supported!")
else:
log.debug("Detected full view representation!")
# Return with the original request
return nffg
else:
log.info("Request check: detected valid content!")
try:
# Run Nf-FG mapping orchestration
log.debug("Starting request preprocession...")
log.info(int(round(time.time() * 1000)))
self.preprocess_nffg(nffg)
log.debug("Preprocession ended, start mapping")
log.info(int(round(time.time() * 1000)))
mapped_nffg = self.mapper.orchestrate(nffg, global_view)
log.debug("NF-FG instantiation is finished by %s" %
self.__class__.__name__)
log.info(int(round(time.time() * 1000)))
return mapped_nffg
except ProcessorError as e:
log.warning("Mapping pre/post processing was unsuccessful! "
"Cause: %s" % e)
else:
log.warning("Global view is not subclass of AbstractVirtualizer!")
else:
log.warning("Global view is not acquired correctly!")
log.error("Abort orchestration process!")
def instantiate_nffg(self, nffg, continued_request_id=None):
"""
Main API function for NF-FG instantiation.
:param nffg: NFFG instance
:type nffg: :class:`NFFG`
:param continued_request_id: use explicit request id if request is
continued after a trial and error (default: False)
:type continued_request_id: str or None
:return: mapped NFFG instance
:rtype: :class:`NFFG`
"""
log.debug("Invoke %s to instantiate given NF-FG" %
self.__class__.__name__)
if not continued_request_id:
# Store newly created NF-FG
self.nffgManager.save(nffg)
else:
# Use the original NFFG requested for getting the original request
nffg = self.nffgManager.get(nffg_id=continued_request_id)
log.info("Using original request for remapping: %s" % nffg)
# Get Domain Virtualizer to acquire global domain view
global_view = self.virtualizerManager.dov
# Notify remote visualizer about resource view of this layer if it's needed
# notify_remote_visualizer(data=global_view.get_resource_info(),
# id=LAYER_NAME)
# Log verbose mapping request
log.log(VERBOSE,
"Orchestration Layer request graph:\n%s" % nffg.dump())
# Start Orchestrator layer mapping
if global_view is not None:
# If the request is a bare NFFG, it is probably an empty topo for domain
# deletion --> skip mapping to avoid BadInputException and forward
# topo to adaptation layer
if not continued_request_id:
if nffg.is_bare():
log.warning(
"No valid service request (VNFs/Flowrules/SGhops) has "
"been detected in SG request! Skip orchestration in "
"layer: %s and proceed with the bare %s..." %
(LAYER_NAME, nffg))
if nffg.is_virtualized():
if nffg.is_SBB():
log.debug(
"Request is a bare SingleBiSBiS representation!"
)
else:
log.warning(
"Detected virtualized representation with multiple BiSBiS "
"nodes! Currently this type of virtualization is nut fully "
"supported!")
else:
log.debug("Detected full view representation!")
# Return with the original request
return nffg
else:
log.info("Request check: detected valid NFFG content!")
try:
# Run NF-FG mapping orchestration
mapped_nffg = self.mapper.orchestrate(
input_graph=nffg,
resource_view=global_view,
continued=bool(continued_request_id))
log.debug("NF-FG instantiation is finished by %s" %
self.__class__.__name__)
return mapped_nffg
except ProcessorError as e:
log.warning("Mapping pre/post processing was unsuccessful! "
"Cause: %s" % e)
# Propagate the ProcessError to API layer
raise
else:
log.warning("Global view is not acquired correctly!")
log.error("Abort orchestration process!")
