def run ():
core.getLogger("worker").info(
"Schedule mapping algorithm: %s" % self.strategy.__name__)
nffg = self.strategy.map(graph=graph, resource=resource)
# Must use call_as_coop_task because we want to call a function in a
# coop microtask environment from a separate thread
call_as_coop_task(self._mapping_finished, mapped_nffg=nffg)
def _perform_mapping (self, input_graph, resource_view):
"""
Orchestrate mapping of given service graph on given virtual resource.
:param input_graph: Service Graph
:type input_graph: :any:`NFFG`
:param resource_view: virtual resource view
:param resource_view: :any:`AbstractVirtualizer`
:return: Network Function Forwarding Graph
:rtype: :any:`NFFG`
"""
if input_graph is None:
log.error("Missing service request information! Abort mapping process!")
return None
log.debug("Request %s to launch orchestration on SG: %s with View: %s" % (
self.__class__.__name__, input_graph, resource_view))
# Steps before mapping (optional)
log.debug("Request resource info from layer virtualizer...")
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, "Service layer resource graph:\n%s" % virt_resource.dump())
# resource_view.sanity_check(input_graph)
# 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 "
"forward service request to lower layer..." % LAYER_NAME)
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("SG: %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)
# Steps after mapping (optional) if the mapping was not threaded
if mapped_nffg is None:
log.error("Mapping process is failed! Abort orchestration process.")
else:
log.info("SG: %s orchestration is finished by %s successfully!" % (
input_graph, self.__class__.__name__))
return mapped_nffg
def update(param=None):
call_as_coop_task(func=quit_with_code, ret_code=UPDATE_VALUE)
if param is not None:
with open(".checkout", 'w') as f:
f.write(param)
log.info("Update task scheduled with explicit checkpoint: %s" %
param)
return Response("UPDATE accepted (%s).\n" % param,
httplib.ACCEPTED)
else:
log.info("Update task scheduled")
return Response("UPDATE accepted.\n", httplib.ACCEPTED)
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 restart():
call_as_coop_task(func=quit_with_code, ret_code=RESTART_VALUE)
log.info("Restart task scheduled")
return Response("RESTART accepted.\n", httplib.ACCEPTED)
def stop():
call_as_coop_task(func=quit_with_code, ret_code=STOP_VALUE)
log.info("Shutdown task scheduled")
return Response("SHUTDOWN accepted.\n", httplib.ACCEPTED)
def shutdown():
call_as_coop_task(func=quit_with_ok)
log.info("Shutdown task scheduled")
return Response("SHUTDOWN accepted.\n", httplib.ACCEPTED)
