+ self.services = dict()
+ self.dcs = dict()
+ self.net = None
+ self.vnf_counter = 0 # used to generate short names for VNFs (Mininet limitation)
+ LOG.info("Create SONATA dummy gatekeeper.")
+
+ def register_service_package(self, service_uuid, service):
+ """
+ register new service package
+ :param service_uuid
+ :param service object
+ """
+ self.services[service_uuid] = service
+ # lets perform all steps needed to onboard the service
+ service.onboard()
+
+ def get_next_vnf_name(self):
+ self.vnf_counter += 1
+ return "vnf%d" % self.vnf_counter
+
+
+class Service(object):
+ """
+ This class represents a NS uploaded as a *.son package to the
+ dummy gatekeeper.
+ Can have multiple running instances of this service.
+ """
+
+ def __init__(self,
+ service_uuid,
+ package_file_hash,
+ package_file_path):
+ self.uuid = service_uuid
+ self.package_file_hash = package_file_hash
+ self.package_file_path = package_file_path
+ self.package_content_path = os.path.join(CATALOG_FOLDER, "services/%s" % self.uuid)
+ self.manifest = None
+ self.nsd = None
+ self.vnfds = dict()
+ self.saps = dict()
+ self.saps_ext = list()
+ self.saps_int = list()
+ self.local_docker_files = dict()
+ self.remote_docker_image_urls = dict()
+ self.instances = dict()
+ self.vnf_name2docker_name = dict()
+ self.vnf_id2vnf_name = dict()
+
+ def onboard(self):
+ """
+ Do all steps to prepare this service to be instantiated
+ :return:
+ """
+ # 1. extract the contents of the package and store them in our catalog
+ self._unpack_service_package()
+ # 2. read in all descriptor files
+ self._load_package_descriptor()
+ self._load_nsd()
+ self._load_vnfd()
+ if DEPLOY_SAP:
+ self._load_saps()
+ # create dict to translate vnf names
+ self.vnf_id2vnf_name = defaultdict(lambda: "NotExistingNode",
+ reduce(lambda x, y: dict(x, **y),
+ map(lambda d: {d["vnf_id"]: d["vnf_name"]},
+ self.nsd["network_functions"])))
+ # 3. prepare container images (e.g. download or build Dockerfile)
+ if BUILD_DOCKERFILE:
+ self._load_docker_files()
+ self._build_images_from_dockerfiles()
+ else:
+ self._load_docker_urls()
+ self._pull_predefined_dockerimages()
+ LOG.info("On-boarded service: %r" % self.manifest.get("name"))
+
+ def start_service(self):
+ """
+ This methods creates and starts a new service instance.
+ It computes placements, iterates over all VNFDs, and starts
+ each VNFD as a Docker container in the data center selected
+ by the placement algorithm.
+ :return:
+ """
+ LOG.info("Starting service %r" % self.uuid)
+
+ # 1. each service instance gets a new uuid to identify it
+ instance_uuid = str(uuid.uuid4())
+ # build a instances dict (a bit like a NSR :))
+ self.instances[instance_uuid] = dict()
+ self.instances[instance_uuid]["vnf_instances"] = list()
+
+ # 2. compute placement of this service instance (adds DC names to VNFDs)
+ if not GK_STANDALONE_MODE:
+ #self._calculate_placement(FirstDcPlacement)
+ self._calculate_placement(RoundRobinDcPlacementWithSAPs)
+
+ # 3. start all vnfds that we have in the service (except SAPs)
+ for vnfd in self.vnfds.itervalues():
+ vnfi = None
+ if not GK_STANDALONE_MODE:
+ vnfi = self._start_vnfd(vnfd)
+ self.instances[instance_uuid]["vnf_instances"].append(vnfi)
+
+ # 4. start all SAPs in the service
+ for sap in self.saps:
+ self._start_sap(self.saps[sap], instance_uuid)
+
+ # 5. Deploy E-Line and E_LAN links
+ if "virtual_links" in self.nsd:
+ vlinks = self.nsd["virtual_links"]
+ # constituent virtual links are not checked
+ #fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
+ eline_fwd_links = [l for l in vlinks if (l["connectivity_type"] == "E-Line")]
+ elan_fwd_links = [l for l in vlinks if (l["connectivity_type"] == "E-LAN")]
+
+ GK.net.deployed_elines.extend(eline_fwd_links)
+ GK.net.deployed_elans.extend(elan_fwd_links)
+
+ # 5a. deploy E-Line links
+ self._connect_elines(eline_fwd_links, instance_uuid)
+
+ # 5b. deploy E-LAN links
+ self._connect_elans(elan_fwd_links, instance_uuid)
+
+ # 6. run the emulator specific entrypoint scripts in the VNFIs of this service instance
+ self._trigger_emulator_start_scripts_in_vnfis(self.instances[instance_uuid]["vnf_instances"])
+
+ LOG.info("Service started. Instance id: %r" % instance_uuid)
+ return instance_uuid
+
+ def stop_service(self, instance_uuid):
+ """
+ This method stops a running service instance.
+ It iterates over all VNF instances, stopping them each
+ and removing them from their data center.
+
+ :param instance_uuid: the uuid of the service instance to be stopped
+ """
+ LOG.info("Stopping service %r" % self.uuid)
+ # get relevant information
+ # instance_uuid = str(self.uuid.uuid4())
+ vnf_instances = self.instances[instance_uuid]["vnf_instances"]
+
+ for v in vnf_instances:
+ self._stop_vnfi(v)
+
+ for sap_name in self.saps_ext:
+ ext_sap = self.saps[sap_name]
+ target_dc = ext_sap.get("dc")
+ target_dc.removeExternalSAP(sap_name, ext_sap['net'])
+ LOG.info("Stopping the SAP instance: %r in DC %r" % (sap_name, target_dc))
+
+ if not GK_STANDALONE_MODE:
+ # remove placement?
+ # self._remove_placement(RoundRobinPlacement)
+ None
+
+ # last step: remove the instance from the list of all instances
+ del self.instances[instance_uuid]
+
+ def _start_vnfd(self, vnfd):
+ """
+ Start a single VNFD of this service
+ :param vnfd: vnfd descriptor dict
+ :return:
+ """
+ # iterate over all deployment units within each VNFDs
+ for u in vnfd.get("virtual_deployment_units"):
+ # 1. get the name of the docker image to start and the assigned DC
+ vnf_name = vnfd.get("name")
+ if vnf_name not in self.remote_docker_image_urls:
+ raise Exception("No image name for %r found. Abort." % vnf_name)
+ docker_name = self.remote_docker_image_urls.get(vnf_name)
+ target_dc = vnfd.get("dc")
+ # 2. perform some checks to ensure we can start the container
+ assert(docker_name is not None)
+ assert(target_dc is not None)
+ if not self._check_docker_image_exists(docker_name):
+ raise Exception("Docker image %r not found. Abort." % docker_name)
+
+ # 3. get the resource limits
+ res_req = u.get("resource_requirements")
+ cpu_list = res_req.get("cpu").get("cores")
+ if not cpu_list or len(cpu_list)==0:
+ cpu_list="1"
+ cpu_bw = res_req.get("cpu").get("cpu_bw")
+ if not cpu_bw:
+ cpu_bw=1
+ mem_num = str(res_req.get("memory").get("size"))
+ if len(mem_num)==0:
+ mem_num="2"
+ mem_unit = str(res_req.get("memory").get("size_unit"))
+ if str(mem_unit)==0:
+ mem_unit="GB"
+ mem_limit = float(mem_num)
+ if mem_unit=="GB":
+ mem_limit=mem_limit*1024*1024*1024
+ elif mem_unit=="MB":
+ mem_limit=mem_limit*1024*1024
+ elif mem_unit=="KB":
+ mem_limit=mem_limit*1024
+ mem_lim = int(mem_limit)
+ cpu_period, cpu_quota = self._calculate_cpu_cfs_values(float(cpu_bw))
+
+ vnf_name2id = defaultdict(lambda: "NotExistingNode",
+ reduce(lambda x, y: dict(x, **y),
+ map(lambda d: {d["vnf_name"]: d["vnf_id"]},
+ self.nsd["network_functions"])))
+
+ # check if we need to deploy the management ports (defined as type:management both on in the vnfd and nsd)
+ intfs = vnfd.get("connection_points", [])
+ mgmt_intf_names = []
+ if USE_DOCKER_MGMT:
+ vnf_id = vnf_name2id[vnf_name]
+ mgmt_intfs = [vnf_id + ':' + intf['id'] for intf in intfs if intf.get('type') == 'management']
+ # check if any of these management interfaces are used in a management-type network in the nsd
+ for nsd_intf_name in mgmt_intfs:
+ vlinks = [ l["connection_points_reference"] for l in self.nsd.get("virtual_links", [])]
+ for link in vlinks:
+ if nsd_intf_name in link and self.check_mgmt_interface(link):
+ # this is indeed a management interface and can be skipped
+ vnf_id, vnf_interface, vnf_sap_docker_name = parse_interface(nsd_intf_name)
+ found_interfaces = [intf for intf in intfs if intf.get('id') == vnf_interface]
+ intfs.remove(found_interfaces[0])
+ mgmt_intf_names.append(vnf_interface)
+
+ # 4. generate the volume paths for the docker container
+ volumes=list()
+ # a volume to extract log files
+ docker_log_path = "/tmp/results/%s/%s"%(self.uuid,vnf_name)
+ LOG.debug("LOG path for vnf %s is %s."%(vnf_name,docker_log_path))
+ if not os.path.exists(docker_log_path):
+ LOG.debug("Creating folder %s"%docker_log_path)
+ os.makedirs(docker_log_path)
+
+ volumes.append(docker_log_path+":/mnt/share/")
+
+
+ # 5. do the dc.startCompute(name="foobar") call to run the container
+ # TODO consider flavors, and other annotations
+ # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
+ # use the vnf_id in the nsd as docker name
+ # so deployed containers can be easily mapped back to the nsd
+
+ self.vnf_name2docker_name[vnf_name] = vnf_name2id[vnf_name]
+
+ LOG.info("Starting %r as %r in DC %r" % (vnf_name, self.vnf_name2docker_name[vnf_name], vnfd.get("dc")))
+ LOG.debug("Interfaces for %r: %r" % (vnf_name, intfs))
+ vnfi = target_dc.startCompute(
+ self.vnf_name2docker_name[vnf_name],
+ network=intfs,
+ image=docker_name,
+ flavor_name="small",
+ cpu_quota=cpu_quota,
+ cpu_period=cpu_period,
+ cpuset=cpu_list,
+ mem_limit=mem_lim,
+ volumes=volumes)
+
+ # rename the docker0 interfaces (eth0) to the management port name defined in the VNFD
+ if USE_DOCKER_MGMT:
+ for intf_name in mgmt_intf_names:
+ self._vnf_reconfigure_network(vnfi, 'eth0', new_name=intf_name)
+
+ return vnfi
+
+ def _stop_vnfi(self, vnfi):
+ """
+ Stop a VNF instance.
+
+ :param vnfi: vnf instance to be stopped
+ """
+ # Find the correct datacenter
+ status = vnfi.getStatus()
+ dc = vnfi.datacenter
+
+ # stop the vnfi
+ LOG.info("Stopping the vnf instance contained in %r in DC %r" % (status["name"], dc))
+ dc.stopCompute(status["name"])
+
+ def _get_vnf_instance(self, instance_uuid, name):
+ """
+ Returns the Docker object for the given VNF name (or Docker name).
+ :param instance_uuid: UUID of the service instance to search in.
+ :param name: VNF name or Docker name. We are fuzzy here.
+ :return:
+ """
+ dn = name
+ if name in self.vnf_name2docker_name:
+ dn = self.vnf_name2docker_name[name]
+ for vnfi in self.instances[instance_uuid]["vnf_instances"]:
+ if vnfi.name == dn:
+ return vnfi
+ LOG.warning("No container with name: {0} found.".format(dn))
+ return None
+
+ @staticmethod
+ def _vnf_reconfigure_network(vnfi, if_name, net_str=None, new_name=None):
+ """
+ Reconfigure the network configuration of a specific interface
+ of a running container.
+ :param vnfi: container instance
+ :param if_name: interface name
+ :param net_str: network configuration string, e.g., 1.2.3.4/24
+ :return:
+ """
+
+ # assign new ip address
+ if net_str is not None:
+ intf = vnfi.intf(intf=if_name)
+ if intf is not None:
+ intf.setIP(net_str)
+ LOG.debug("Reconfigured network of %s:%s to %r" % (vnfi.name, if_name, net_str))
+ else:
+ LOG.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi.name, if_name))
+
+ if new_name is not None:
+ vnfi.cmd('ip link set', if_name, 'down')
+ vnfi.cmd('ip link set', if_name, 'name', new_name)
+ vnfi.cmd('ip link set', new_name, 'up')
+ LOG.debug("Reconfigured interface name of %s:%s to %s" % (vnfi.name, if_name, new_name))
+
+
+
+ def _trigger_emulator_start_scripts_in_vnfis(self, vnfi_list):
+ for vnfi in vnfi_list:
+ config = vnfi.dcinfo.get("Config", dict())
+ env = config.get("Env", list())
+ for env_var in env:
+ var, cmd = map(str.strip, map(str, env_var.split('=', 1)))
+ LOG.debug("%r = %r" % (var , cmd))
+ if var=="SON_EMU_CMD":
+ LOG.info("Executing entry point script in %r: %r" % (vnfi.name, cmd))
+ # execute command in new thread to ensure that GK is not blocked by VNF
+ t = threading.Thread(target=vnfi.cmdPrint, args=(cmd,))
+ t.daemon = True
+ t.start()
+
+ def _unpack_service_package(self):
+ """
+ unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
+ """
+ LOG.info("Unzipping: %r" % self.package_file_path)
+ with zipfile.ZipFile(self.package_file_path, "r") as z:
+ z.extractall(self.package_content_path)
+
+
+ def _load_package_descriptor(self):
+ """
+ Load the main package descriptor YAML and keep it as dict.
+ :return:
+ """
+ self.manifest = load_yaml(
+ os.path.join(
+ self.package_content_path, "META-INF/MANIFEST.MF"))
+
+ def _load_nsd(self):
+ """
+ Load the entry NSD YAML and keep it as dict.
+ :return:
+ """
+ if "entry_service_template" in self.manifest:
+ nsd_path = os.path.join(
+ self.package_content_path,
+ make_relative_path(self.manifest.get("entry_service_template")))
+ self.nsd = load_yaml(nsd_path)
+ GK.net.deployed_nsds.append(self.nsd)
+
+ LOG.debug("Loaded NSD: %r" % self.nsd.get("name"))
+
+ def _load_vnfd(self):
+ """
+ Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
+ :return:
+ """
+ if "package_content" in self.manifest:
+ for pc in self.manifest.get("package_content"):
+ if pc.get("content-type") == "application/sonata.function_descriptor":
+ vnfd_path = os.path.join(
+ self.package_content_path,
+ make_relative_path(pc.get("name")))
+ vnfd = load_yaml(vnfd_path)
+ self.vnfds[vnfd.get("name")] = vnfd
+ LOG.debug("Loaded VNFD: %r" % vnfd.get("name"))
+
+ def _load_saps(self):
+ # create list of all SAPs
+ # check if we need to deploy management ports
+ if USE_DOCKER_MGMT:
+ SAPs = [p for p in self.nsd["connection_points"] if 'management' not in p.get('type')]
+ else:
+ SAPs = [p for p in self.nsd["connection_points"]]
+
+ for sap in SAPs:
+ # endpoint needed in this service
+ sap_id, sap_interface, sap_docker_name = parse_interface(sap['id'])
+ # make sure SAP has type set (default internal)
+ sap["type"] = sap.get("type", 'internal')
+
+ # Each Service Access Point (connection_point) in the nsd is an IP address on the host
+ if sap["type"] == "external":
+ # add to vnfds to calculate placement later on
+ sap_net = SAP_SUBNETS.pop(0)
+ self.saps[sap_docker_name] = {"name": sap_docker_name , "type": "external", "net": sap_net}
+ # add SAP vnf to list in the NSD so it is deployed later on
+ # each SAP get a unique VNFD and vnf_id in the NSD and custom type (only defined in the dummygatekeeper)
+ self.nsd["network_functions"].append(
+ {"vnf_id": sap_docker_name, "vnf_name": sap_docker_name, "vnf_type": "sap_ext"})
+
+ # Each Service Access Point (connection_point) in the nsd is getting its own container (default)
+ elif sap["type"] == "internal" or sap["type"] == "management":
+ # add SAP to self.vnfds
+ sapfile = pkg_resources.resource_filename(__name__, "sap_vnfd.yml")
+ sap_vnfd = load_yaml(sapfile)
+ sap_vnfd["connection_points"][0]["id"] = sap_interface
+ sap_vnfd["name"] = sap_docker_name
+ sap_vnfd["type"] = "internal"
+ # add to vnfds to calculate placement later on and deploy
+ self.saps[sap_docker_name] = sap_vnfd
+ # add SAP vnf to list in the NSD so it is deployed later on
+ # each SAP get a unique VNFD and vnf_id in the NSD
+ self.nsd["network_functions"].append(
+ {"vnf_id": sap_docker_name, "vnf_name": sap_docker_name, "vnf_type": "sap_int"})
+
+ LOG.debug("Loaded SAP: name: {0}, type: {1}".format(sap_docker_name, sap['type']))
+
+ # create sap lists
+ self.saps_ext = [self.saps[sap]['name'] for sap in self.saps if self.saps[sap]["type"] == "external"]
+ self.saps_int = [self.saps[sap]['name'] for sap in self.saps if self.saps[sap]["type"] == "internal"]
+
+ def _start_sap(self, sap, instance_uuid):
+ if not DEPLOY_SAP:
+ return
+
+ LOG.info('start SAP: {0} ,type: {1}'.format(sap['name'],sap['type']))
+ if sap["type"] == "internal":
+ vnfi = None
+ if not GK_STANDALONE_MODE:
+ vnfi = self._start_vnfd(sap)
+ self.instances[instance_uuid]["vnf_instances"].append(vnfi)
+
+ elif sap["type"] == "external":
+ target_dc = sap.get("dc")
+ # add interface to dc switch
+ target_dc.attachExternalSAP(sap['name'], sap['net'])
+
+ def _connect_elines(self, eline_fwd_links, instance_uuid):
+ """
+ Connect all E-LINE links in the NSD
+ :param eline_fwd_links: list of E-LINE links in the NSD
+ :param: instance_uuid of the service
+ :return:
+ """
+ # cookie is used as identifier for the flowrules installed by the dummygatekeeper
+ # eg. different services get a unique cookie for their flowrules
+ cookie = 1
+ for link in eline_fwd_links:
+ # check if we need to deploy this link when its a management link:
+ if USE_DOCKER_MGMT:
+ if self.check_mgmt_interface(link["connection_points_reference"]):
+ continue
+
+ src_id, src_if_name, src_sap_id = parse_interface(link["connection_points_reference"][0])
+ dst_id, dst_if_name, dst_sap_id = parse_interface(link["connection_points_reference"][1])
+
+ setChaining = False
+ # check if there is a SAP in the link and chain everything together
+ if src_sap_id in self.saps and dst_sap_id in self.saps:
+ LOG.info('2 SAPs cannot be chained together : {0} - {1}'.format(src_sap_id, dst_sap_id))
+ continue