src/emuvim/api/sonata/dummygatekeeper.py

   1 """
   2 Copyright (c) 2015 SONATA-NFV and Paderborn University
   3 ALL RIGHTS RESERVED.
   4
   5 Licensed under the Apache License, Version 2.0 (the "License");
   6 you may not use this file except in compliance with the License.
   7 You may obtain a copy of the License at
   8
   9     http://www.apache.org/licenses/LICENSE-2.0
  10
  11 Unless required by applicable law or agreed to in writing, software
  12 distributed under the License is distributed on an "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 See the License for the specific language governing permissions and
  15 limitations under the License.
  16
  17 Neither the name of the SONATA-NFV [, ANY ADDITIONAL AFFILIATION]
  18 nor the names of its contributors may be used to endorse or promote
  19 products derived from this software without specific prior written
  20 permission.
  21
  22 This work has been performed in the framework of the SONATA project,
  23 funded by the European Commission under Grant number 671517 through
  24 the Horizon 2020 and 5G-PPP programmes. The authors would like to
  25 acknowledge the contributions of their colleagues of the SONATA
  26 partner consortium (www.sonata-nfv.eu).
  27 """
  28 """
  29 This module implements a simple REST API that behaves like SONATA's gatekeeper.
  30
  31 It is only used to support the development of SONATA's SDK tools and to demonstrate
  32 the year 1 version of the emulator until the integration with WP4's orchestrator is done.
  33 """
  34
  35 import logging
  36 import os
  37 import uuid
  38 import hashlib
  39 import zipfile
  40 import yaml
  41 import threading
  42 from docker import DockerClient, APIClient
  43 from flask import Flask, request
  44 import flask_restful as fr
  45 from collections import defaultdict
  46 import pkg_resources
  47 from subprocess import Popen
  48 from random import randint
  49 import ipaddress
  50 import copy
  51 import time
  52
  53 logging.basicConfig()
  54 LOG = logging.getLogger("sonata-dummy-gatekeeper")
  55 LOG.setLevel(logging.DEBUG)
  56 logging.getLogger("werkzeug").setLevel(logging.WARNING)
  57
  58 GK_STORAGE = "/tmp/son-dummy-gk/"
  59 UPLOAD_FOLDER = os.path.join(GK_STORAGE, "uploads/")
  60 CATALOG_FOLDER = os.path.join(GK_STORAGE, "catalog/")
  61
  62 # Enable Dockerfile build functionality
  63 BUILD_DOCKERFILE = False
  64
  65 # flag to indicate that we run without the emulator (only the bare API for integration testing)
  66 GK_STANDALONE_MODE = False
  67
  68 # should a new version of an image be pulled even if its available
  69 FORCE_PULL = False
  70
  71 # Automatically deploy SAPs (endpoints) of the service as new containers
  72 # Attention: This is not a configuration switch but a global variable! Don't change its default value.
  73 DEPLOY_SAP = False
  74
  75 # flag to indicate if we use bidirectional forwarding rules in the automatic chaining process
  76 BIDIRECTIONAL_CHAIN = False
  77
  78 # override the management interfaces in the descriptors with default docker0 interfaces in the containers
  79 USE_DOCKER_MGMT = False
  80
  81 # automatically deploy uploaded packages (no need to execute son-access deploy --latest separately)
  82 AUTO_DEPLOY = False
  83
  84 # and also automatically terminate any other running services
  85 AUTO_DELETE = False
  86
  87 def generate_subnets(prefix, base, subnet_size=50, mask=24):
  88     # Generate a list of ipaddress in subnets
  89     r = list()
  90     for net in range(base, base + subnet_size):
  91         subnet = "{0}.{1}.0/{2}".format(prefix, net, mask)
  92         r.append(ipaddress.ip_network(unicode(subnet)))
  93     return r
  94 # private subnet definitions for the generated interfaces
  95 # 10.10.xxx.0/24
  96 SAP_SUBNETS = generate_subnets('10.10', 0, subnet_size=50, mask=30)
  97 # 10.20.xxx.0/30
  98 ELAN_SUBNETS = generate_subnets('10.20', 0, subnet_size=50, mask=24)
  99 # 10.30.xxx.0/30
 100 ELINE_SUBNETS = generate_subnets('10.30', 0, subnet_size=50, mask=30)
 101
 102 # path to the VNFD for the SAP VNF that is deployed as internal SAP point
 103 SAP_VNFD=None
 104
 105 # Time in seconds to wait for vnf stop scripts to execute fully
 106 VNF_STOP_WAIT_TIME = 5
 107
 108 class Gatekeeper(object):
 109
 110     def __init__(self):
 111         self.services = dict()
 112         self.dcs = dict()
 113         self.net = None
 114         self.vnf_counter = 0  # used to generate short names for VNFs (Mininet limitation)
 115         LOG.info("Create SONATA dummy gatekeeper.")
 116
 117     def register_service_package(self, service_uuid, service):
 118         """
 119         register new service package
 120         :param service_uuid
 121         :param service object
 122         """
 123         self.services[service_uuid] = service
 124         # lets perform all steps needed to onboard the service
 125         service.onboard()
 126
 127     def get_next_vnf_name(self):
 128         self.vnf_counter += 1
 129         return "vnf%d" % self.vnf_counter
 130
 131
 132 class Service(object):
 133     """
 134     This class represents a NS uploaded as a *.son package to the
 135     dummy gatekeeper.
 136     Can have multiple running instances of this service.
 137     """
 138
 139     def __init__(self,
 140                  service_uuid,
 141                  package_file_hash,
 142                  package_file_path):
 143         self.uuid = service_uuid
 144         self.package_file_hash = package_file_hash
 145         self.package_file_path = package_file_path
 146         self.package_content_path = os.path.join(CATALOG_FOLDER, "services/%s" % self.uuid)
 147         self.manifest = None
 148         self.nsd = None
 149         self.vnfds = dict()
 150         self.saps = dict()
 151         self.saps_ext = list()
 152         self.saps_int = list()
 153         self.local_docker_files = dict()
 154         self.remote_docker_image_urls = dict()
 155         self.instances = dict()
 156         # dict to find the vnf_name for any vnf id
 157         self.vnf_id2vnf_name = dict()
 158
 159     def onboard(self):
 160         """
 161         Do all steps to prepare this service to be instantiated
 162         :return:
 163         """
 164         # 1. extract the contents of the package and store them in our catalog
 165         self._unpack_service_package()
 166         # 2. read in all descriptor files
 167         self._load_package_descriptor()
 168         self._load_nsd()
 169         self._load_vnfd()
 170         if DEPLOY_SAP:
 171             self._load_saps()
 172         # 3. prepare container images (e.g. download or build Dockerfile)
 173         if BUILD_DOCKERFILE:
 174             self._load_docker_files()
 175             self._build_images_from_dockerfiles()
 176         else:
 177             self._load_docker_urls()
 178             self._pull_predefined_dockerimages()
 179         LOG.info("On-boarded service: %r" % self.manifest.get("name"))
 180
 181     def start_service(self):
 182         """
 183         This methods creates and starts a new service instance.
 184         It computes placements, iterates over all VNFDs, and starts
 185         each VNFD as a Docker container in the data center selected
 186         by the placement algorithm.
 187         :return:
 188         """
 189         LOG.info("Starting service %r" % self.uuid)
 190
 191         # 1. each service instance gets a new uuid to identify it
 192         instance_uuid = str(uuid.uuid4())
 193         # build a instances dict (a bit like a NSR :))
 194         self.instances[instance_uuid] = dict()
 195         self.instances[instance_uuid]["vnf_instances"] = list()
 196
 197         # 2. compute placement of this service instance (adds DC names to VNFDs)
 198         if not GK_STANDALONE_MODE:
 199             #self._calculate_placement(FirstDcPlacement)
 200             self._calculate_placement(RoundRobinDcPlacementWithSAPs)
 201         # 3. start all vnfds that we have in the service (except SAPs)
 202         for vnf_id in self.vnfds:
 203             vnfd = self.vnfds[vnf_id]
 204             vnfi = None
 205             if not GK_STANDALONE_MODE:
 206                 vnfi = self._start_vnfd(vnfd, vnf_id)
 207             self.instances[instance_uuid]["vnf_instances"].append(vnfi)
 208
 209         # 4. start all SAPs in the service
 210         for sap in self.saps:
 211             self._start_sap(self.saps[sap], instance_uuid)
 212
 213         # 5. Deploy E-Line and E_LAN links
 214         # Attention: Only done if ""forwarding_graphs" section in NSD exists,
 215         # even if "forwarding_graphs" are not used directly.
 216         if "virtual_links" in self.nsd and "forwarding_graphs" in self.nsd:
 217             vlinks = self.nsd["virtual_links"]
 218             # constituent virtual links are not checked
 219             #fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
 220             eline_fwd_links = [l for l in vlinks if (l["connectivity_type"] == "E-Line")]
 221             elan_fwd_links = [l for l in vlinks if (l["connectivity_type"] == "E-LAN")]
 222
 223             GK.net.deployed_elines.extend(eline_fwd_links)
 224             GK.net.deployed_elans.extend(elan_fwd_links)
 225
 226             # 5a. deploy E-Line links
 227             self._connect_elines(eline_fwd_links, instance_uuid)
 228
 229             # 5b. deploy E-LAN links
 230             self._connect_elans(elan_fwd_links, instance_uuid)
 231
 232         # 6. run the emulator specific entrypoint scripts in the VNFIs of this service instance
 233         self._trigger_emulator_start_scripts_in_vnfis(self.instances[instance_uuid]["vnf_instances"])
 234
 235         LOG.info("Service started. Instance id: %r" % instance_uuid)
 236         return instance_uuid
 237
 238     def stop_service(self, instance_uuid):
 239         """
 240         This method stops a running service instance.
 241         It iterates over all VNF instances, stopping them each
 242         and removing them from their data center.
 243
 244         :param instance_uuid: the uuid of the service instance to be stopped
 245         """
 246         LOG.info("Stopping service %r" % self.uuid)
 247         # get relevant information
 248         # instance_uuid = str(self.uuid.uuid4())
 249         vnf_instances = self.instances[instance_uuid]["vnf_instances"]
 250
 251         # trigger stop skripts in vnf instances and wait a few seconds for completion
 252         self._trigger_emulator_stop_scripts_in_vnfis(vnf_instances)
 253         time.sleep(VNF_STOP_WAIT_TIME)
 254
 255         for v in vnf_instances:
 256             self._stop_vnfi(v)
 257
 258         for sap_name in self.saps_ext:
 259             ext_sap = self.saps[sap_name]
 260             target_dc = ext_sap.get("dc")
 261             target_dc.removeExternalSAP(sap_name)
 262             LOG.info("Stopping the SAP instance: %r in DC %r" % (sap_name, target_dc))
 263
 264         if not GK_STANDALONE_MODE:
 265             # remove placement?
 266             # self._remove_placement(RoundRobinPlacement)
 267             None
 268
 269         # last step: remove the instance from the list of all instances
 270         del self.instances[instance_uuid]
 271
 272     def _start_vnfd(self, vnfd, vnf_id, **kwargs):
 273         """
 274         Start a single VNFD of this service
 275         :param vnfd: vnfd descriptor dict
 276         :param vnf_id: unique id of this vnf in the nsd
 277         :return:
 278         """
 279         # the vnf_name refers to the container image to be deployed
 280         vnf_name = vnfd.get("name")
 281
 282         # iterate over all deployment units within each VNFDs
 283         for u in vnfd.get("virtual_deployment_units"):
 284             # 1. get the name of the docker image to start and the assigned DC
 285             if vnf_id not in self.remote_docker_image_urls:
 286                 raise Exception("No image name for %r found. Abort." % vnf_id)
 287             docker_name = self.remote_docker_image_urls.get(vnf_id)
 288             target_dc = vnfd.get("dc")
 289             # 2. perform some checks to ensure we can start the container
 290             assert(docker_name is not None)
 291             assert(target_dc is not None)
 292             if not self._check_docker_image_exists(docker_name):
 293                 raise Exception("Docker image %r not found. Abort." % docker_name)
 294
 295             # 3. get the resource limits
 296             res_req = u.get("resource_requirements")
 297             cpu_list = res_req.get("cpu").get("cores")
 298             if cpu_list is None:
 299                 cpu_list = res_req.get("cpu").get("vcpus")
 300             if cpu_list is None:
 301                 cpu_list="1"
 302             cpu_bw = res_req.get("cpu").get("cpu_bw")
 303             if not cpu_bw:
 304                 cpu_bw=1
 305             mem_num = str(res_req.get("memory").get("size"))
 306             if len(mem_num)==0:
 307                 mem_num="2"
 308             mem_unit = str(res_req.get("memory").get("size_unit"))
 309             if str(mem_unit)==0:
 310                 mem_unit="GB"
 311             mem_limit = float(mem_num)
 312             if mem_unit=="GB":
 313                 mem_limit=mem_limit*1024*1024*1024
 314             elif mem_unit=="MB":
 315                 mem_limit=mem_limit*1024*1024
 316             elif mem_unit=="KB":
 317                 mem_limit=mem_limit*1024
 318             mem_lim = int(mem_limit)
 319             cpu_period, cpu_quota = self._calculate_cpu_cfs_values(float(cpu_bw))
 320
 321             # check if we need to deploy the management ports (defined as type:management both on in the vnfd and nsd)
 322             intfs = vnfd.get("connection_points", [])
 323             mgmt_intf_names = []
 324             if USE_DOCKER_MGMT:
 325                 mgmt_intfs = [vnf_id + ':' + intf['id'] for intf in intfs if intf.get('type') == 'management']
 326                 # check if any of these management interfaces are used in a management-type network in the nsd
 327                 for nsd_intf_name in mgmt_intfs:
 328                     vlinks = [ l["connection_points_reference"] for l in self.nsd.get("virtual_links", [])]
 329                     for link in vlinks:
 330                         if nsd_intf_name in link and self.check_mgmt_interface(link):
 331                             # this is indeed a management interface and can be skipped
 332                             vnf_id, vnf_interface, vnf_sap_docker_name = parse_interface(nsd_intf_name)
 333                             found_interfaces = [intf for intf in intfs if intf.get('id') == vnf_interface]
 334                             intfs.remove(found_interfaces[0])
 335                             mgmt_intf_names.append(vnf_interface)
 336
 337             # 4. generate the volume paths for the docker container
 338             volumes=list()
 339             # a volume to extract log files
 340             docker_log_path = "/tmp/results/%s/%s"%(self.uuid,vnf_id)
 341             LOG.debug("LOG path for vnf %s is %s."%(vnf_id,docker_log_path))
 342             if not os.path.exists(docker_log_path):
 343                 LOG.debug("Creating folder %s"%docker_log_path)
 344                 os.makedirs(docker_log_path)
 345
 346             volumes.append(docker_log_path+":/mnt/share/")
 347
 348
 349             # 5. do the dc.startCompute(name="foobar") call to run the container
 350             # TODO consider flavors, and other annotations
 351             # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
 352             # use the vnf_id in the nsd as docker name
 353             # so deployed containers can be easily mapped back to the nsd
 354             LOG.info("Starting %r as %r in DC %r" % (vnf_name, vnf_id, vnfd.get("dc")))
 355             LOG.debug("Interfaces for %r: %r" % (vnf_id, intfs))
 356             vnfi = target_dc.startCompute(
 357                     vnf_id,
 358                     network=intfs,
 359                     image=docker_name,
 360                     flavor_name="small",
 361                     cpu_quota=cpu_quota,
 362                     cpu_period=cpu_period,
 363                     cpuset=cpu_list,
 364                     mem_limit=mem_lim,
 365                     volumes=volumes,
 366                     type=kwargs.get('type','docker'))
 367
 368             # rename the docker0 interfaces (eth0) to the management port name defined in the VNFD
 369             if USE_DOCKER_MGMT:
 370                 for intf_name in mgmt_intf_names:
 371                     self._vnf_reconfigure_network(vnfi, 'eth0', new_name=intf_name)
 372
 373             return vnfi
 374
 375     def _stop_vnfi(self, vnfi):
 376         """
 377         Stop a VNF instance.
 378
 379         :param vnfi: vnf instance to be stopped
 380         """
 381         # Find the correct datacenter
 382         status = vnfi.getStatus()
 383         dc = vnfi.datacenter
 384
 385         # stop the vnfi
 386         LOG.info("Stopping the vnf instance contained in %r in DC %r" % (status["name"], dc))
 387         dc.stopCompute(status["name"])
 388
 389     def _get_vnf_instance(self, instance_uuid, vnf_id):
 390         """
 391         Returns the Docker object for the given VNF id (or Docker name).
 392         :param instance_uuid: UUID of the service instance to search in.
 393         :param name: VNF name or Docker name. We are fuzzy here.
 394         :return:
 395         """
 396         dn = vnf_id
 397         for vnfi in self.instances[instance_uuid]["vnf_instances"]:
 398             if vnfi.name == dn:
 399                 return vnfi
 400         LOG.warning("No container with name: {0} found.".format(dn))
 401         return None
 402
 403     @staticmethod
 404     def _vnf_reconfigure_network(vnfi, if_name, net_str=None, new_name=None):
 405         """
 406         Reconfigure the network configuration of a specific interface
 407         of a running container.
 408         :param vnfi: container instance
 409         :param if_name: interface name
 410         :param net_str: network configuration string, e.g., 1.2.3.4/24
 411         :return:
 412         """
 413
 414         # assign new ip address
 415         if net_str is not None:
 416             intf = vnfi.intf(intf=if_name)
 417             if intf is not None:
 418                 intf.setIP(net_str)
 419                 LOG.debug("Reconfigured network of %s:%s to %r" % (vnfi.name, if_name, net_str))
 420             else:
 421                 LOG.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi.name, if_name))
 422
 423         if new_name is not None:
 424             vnfi.cmd('ip link set', if_name, 'down')
 425             vnfi.cmd('ip link set', if_name, 'name', new_name)
 426             vnfi.cmd('ip link set', new_name, 'up')
 427             LOG.debug("Reconfigured interface name of %s:%s to %s" % (vnfi.name, if_name, new_name))
 428
 429
 430
 431     def _trigger_emulator_start_scripts_in_vnfis(self, vnfi_list):
 432         for vnfi in vnfi_list:
 433             config = vnfi.dcinfo.get("Config", dict())
 434             env = config.get("Env", list())
 435             for env_var in env:
 436                 var, cmd = map(str.strip, map(str, env_var.split('=', 1)))
 437                 LOG.debug("%r = %r" % (var , cmd))
 438                 if var=="SON_EMU_CMD":
 439                     LOG.info("Executing entry point script in %r: %r" % (vnfi.name, cmd))
 440                     # execute command in new thread to ensure that GK is not blocked by VNF
 441                     t = threading.Thread(target=vnfi.cmdPrint, args=(cmd,))
 442                     t.daemon = True
 443                     t.start()
 444
 445     def _trigger_emulator_stop_scripts_in_vnfis(self, vnfi_list):
 446         for vnfi in vnfi_list:
 447             config = vnfi.dcinfo.get("Config", dict())
 448             env = config.get("Env", list())
 449             for env_var in env:
 450                 var, cmd = map(str.strip, map(str, env_var.split('=', 1)))
 451                 if var=="SON_EMU_CMD_STOP":
 452                     LOG.info("Executing stop script in %r: %r" % (vnfi.name, cmd))
 453                     # execute command in new thread to ensure that GK is not blocked by VNF
 454                     t = threading.Thread(target=vnfi.cmdPrint, args=(cmd,))
 455                     t.daemon = True
 456                     t.start()
 457
 458
 459
 460     def _unpack_service_package(self):
 461         """
 462         unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
 463         """
 464         LOG.info("Unzipping: %r" % self.package_file_path)
 465         with zipfile.ZipFile(self.package_file_path, "r") as z:
 466             z.extractall(self.package_content_path)
 467
 468
 469     def _load_package_descriptor(self):
 470         """
 471         Load the main package descriptor YAML and keep it as dict.
 472         :return:
 473         """
 474         self.manifest = load_yaml(
 475             os.path.join(
 476                 self.package_content_path, "META-INF/MANIFEST.MF"))
 477
 478     def _load_nsd(self):
 479         """
 480         Load the entry NSD YAML and keep it as dict.
 481         :return:
 482         """
 483         if "entry_service_template" in self.manifest:
 484             nsd_path = os.path.join(
 485                 self.package_content_path,
 486                 make_relative_path(self.manifest.get("entry_service_template")))
 487             self.nsd = load_yaml(nsd_path)
 488             GK.net.deployed_nsds.append(self.nsd)
 489             # create dict to find the vnf_name for any vnf id
 490             self.vnf_id2vnf_name = defaultdict(lambda: "NotExistingNode",
 491                                                 reduce(lambda x, y: dict(x, **y),
 492                                                        map(lambda d: {d["vnf_id"]: d["vnf_name"]},
 493                                                            self.nsd["network_functions"])))
 494
 495             LOG.debug("Loaded NSD: %r" % self.nsd.get("name"))
 496
 497     def _load_vnfd(self):
 498         """
 499         Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
 500         :return:
 501         """
 502
 503         # first make a list of all the vnfds in the package
 504         vnfd_set = dict()
 505         if "package_content" in self.manifest:
 506             for pc in self.manifest.get("package_content"):
 507                 if pc.get("content-type") == "application/sonata.function_descriptor":
 508                     vnfd_path = os.path.join(
 509                         self.package_content_path,
 510                         make_relative_path(pc.get("name")))
 511                     vnfd = load_yaml(vnfd_path)
 512                     vnfd_set[vnfd.get("name")] = vnfd
 513             # then link each vnf_id in the nsd to its vnfd
 514             for  vnf_id in self.vnf_id2vnf_name:
 515                 vnf_name = self.vnf_id2vnf_name[vnf_id]
 516                 self.vnfds[vnf_id] = vnfd_set[vnf_name]
 517                 LOG.debug("Loaded VNFD: {0} id: {1}".format(vnf_name, vnf_id))
 518
 519     def _load_saps(self):
 520         # create list of all SAPs
 521         # check if we need to deploy management ports
 522         if USE_DOCKER_MGMT:
 523             SAPs = [p for p in self.nsd["connection_points"] if 'management' not in p.get('type')]
 524         else:
 525             SAPs = [p for p in self.nsd["connection_points"]]
 526
 527         for sap in SAPs:
 528             # endpoint needed in this service
 529             sap_id, sap_interface, sap_docker_name = parse_interface(sap['id'])
 530             # make sure SAP has type set (default internal)
 531             sap["type"] = sap.get("type", 'internal')
 532
 533             # Each Service Access Point (connection_point) in the nsd is an IP address on the host
 534             if sap["type"] == "external":
 535                 # add to vnfds to calculate placement later on
 536                 sap_net = SAP_SUBNETS.pop(0)
 537                 self.saps[sap_docker_name] = {"name": sap_docker_name , "type": "external", "net": sap_net}
 538                 # add SAP vnf to list in the NSD so it is deployed later on
 539                 # each SAP gets a unique VNFD and vnf_id in the NSD and custom type (only defined in the dummygatekeeper)
 540                 self.nsd["network_functions"].append(
 541                     {"vnf_id": sap_docker_name, "vnf_name": sap_docker_name, "vnf_type": "sap_ext"})
 542
 543             # Each Service Access Point (connection_point) in the nsd is getting its own container (default)
 544             elif sap["type"] == "internal" or sap["type"] == "management":
 545                 # add SAP to self.vnfds
 546                 if SAP_VNFD is None:
 547                     sapfile = pkg_resources.resource_filename(__name__, "sap_vnfd.yml")
 548                 else:
 549                     sapfile = SAP_VNFD
 550                 sap_vnfd = load_yaml(sapfile)
 551                 sap_vnfd["connection_points"][0]["id"] = sap_interface
 552                 sap_vnfd["name"] = sap_docker_name
 553                 sap_vnfd["type"] = "internal"
 554                 # add to vnfds to calculate placement later on and deploy
 555                 self.saps[sap_docker_name] = sap_vnfd
 556                 # add SAP vnf to list in the NSD so it is deployed later on
 557                 # each SAP get a unique VNFD and vnf_id in the NSD
 558                 self.nsd["network_functions"].append(
 559                     {"vnf_id": sap_docker_name, "vnf_name": sap_docker_name, "vnf_type": "sap_int"})
 560
 561             LOG.debug("Loaded SAP: name: {0}, type: {1}".format(sap_docker_name, sap['type']))
 562
 563         # create sap lists
 564         self.saps_ext = [self.saps[sap]['name'] for sap in self.saps if self.saps[sap]["type"] == "external"]
 565         self.saps_int = [self.saps[sap]['name'] for sap in self.saps if self.saps[sap]["type"] == "internal"]
 566
 567     def _start_sap(self, sap, instance_uuid):
 568         if not DEPLOY_SAP:
 569             return
 570
 571         LOG.info('start SAP: {0} ,type: {1}'.format(sap['name'],sap['type']))
 572         if sap["type"] == "internal":
 573             vnfi = None
 574             if not GK_STANDALONE_MODE:
 575                 vnfi = self._start_vnfd(sap, sap['name'], type='sap_int')
 576             self.instances[instance_uuid]["vnf_instances"].append(vnfi)
 577
 578         elif sap["type"] == "external":
 579             target_dc = sap.get("dc")
 580             # add interface to dc switch
 581             target_dc.attachExternalSAP(sap['name'], sap['net'])
 582
 583     def _connect_elines(self, eline_fwd_links, instance_uuid):
 584         """
 585         Connect all E-LINE links in the NSD
 586         :param eline_fwd_links: list of E-LINE links in the NSD
 587         :param: instance_uuid of the service
 588         :return:
 589         """
 590         # cookie is used as identifier for the flowrules installed by the dummygatekeeper
 591         # eg. different services get a unique cookie for their flowrules
 592         cookie = 1
 593         for link in eline_fwd_links:
 594             # check if we need to deploy this link when its a management link:
 595             if USE_DOCKER_MGMT:
 596                 if self.check_mgmt_interface(link["connection_points_reference"]):
 597                     continue
 598
 599             src_id, src_if_name, src_sap_id = parse_interface(link["connection_points_reference"][0])
 600             dst_id, dst_if_name, dst_sap_id = parse_interface(link["connection_points_reference"][1])
 601
 602             setChaining = False
 603             # check if there is a SAP in the link and chain everything together
 604             if src_sap_id in self.saps and dst_sap_id in self.saps:
 605                 LOG.info('2 SAPs cannot be chained together : {0} - {1}'.format(src_sap_id, dst_sap_id))
 606                 continue
 607
 608             elif src_sap_id in self.saps_ext:
 609                 src_id = src_sap_id
 610                 # set intf name to None so the chaining function will choose the first one
 611                 src_if_name = None
 612                 dst_vnfi = self._get_vnf_instance(instance_uuid, dst_id)
 613                 if dst_vnfi is not None:
 614                     # choose first ip address in sap subnet
 615                     sap_net = self.saps[src_sap_id]['net']
 616                     sap_ip = "{0}/{1}".format(str(sap_net[2]), sap_net.prefixlen)
 617                     self._vnf_reconfigure_network(dst_vnfi, dst_if_name, sap_ip)
 618                     setChaining = True
 619
 620             elif dst_sap_id in self.saps_ext:
 621                 dst_id = dst_sap_id
 622                 # set intf name to None so the chaining function will choose the first one
 623                 dst_if_name = None
 624                 src_vnfi = self._get_vnf_instance(instance_uuid, src_id)
 625                 if src_vnfi is not None:
 626                     sap_net = self.saps[dst_sap_id]['net']
 627                     sap_ip = "{0}/{1}".format(str(sap_net[2]), sap_net.prefixlen)
 628                     self._vnf_reconfigure_network(src_vnfi, src_if_name, sap_ip)
 629                     setChaining = True
 630
 631             # Link between 2 VNFs
 632             else:
 633                 # make sure we use the correct sap vnf name
 634                 if src_sap_id in self.saps_int:
 635                     src_id = src_sap_id
 636                 if dst_sap_id in self.saps_int:
 637                     dst_id = dst_sap_id
 638                 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
 639                 src_vnfi = self._get_vnf_instance(instance_uuid, src_id)
 640                 dst_vnfi = self._get_vnf_instance(instance_uuid, dst_id)
 641                 if src_vnfi is not None and dst_vnfi is not None:
 642                     eline_net = ELINE_SUBNETS.pop(0)
 643                     ip1 = "{0}/{1}".format(str(eline_net[1]), eline_net.prefixlen)
 644                     ip2 = "{0}/{1}".format(str(eline_net[2]), eline_net.prefixlen)
 645                     self._vnf_reconfigure_network(src_vnfi, src_if_name, ip1)
 646                     self._vnf_reconfigure_network(dst_vnfi, dst_if_name, ip2)
 647                     setChaining = True
 648
 649             # Set the chaining
 650             if setChaining:
 651                 ret = GK.net.setChain(
 652                     src_id, dst_id,
 653                     vnf_src_interface=src_if_name, vnf_dst_interface=dst_if_name,
 654                     bidirectional=BIDIRECTIONAL_CHAIN, cmd="add-flow", cookie=cookie, priority=10)
 655                 LOG.debug(
 656                     "Setting up E-Line link. (%s:%s) -> (%s:%s)" % (
 657                         src_id, src_if_name, dst_id, dst_if_name))
 658
 659
 660     def _connect_elans(self, elan_fwd_links, instance_uuid):
 661         """
 662         Connect all E-LAN links in the NSD
 663         :param elan_fwd_links: list of E-LAN links in the NSD
 664         :param: instance_uuid of the service
 665         :return:
 666         """
 667         for link in elan_fwd_links:
 668             # check if we need to deploy this link when its a management link:
 669             if USE_DOCKER_MGMT:
 670                 if self.check_mgmt_interface(link["connection_points_reference"]):
 671                     continue
 672
 673             elan_vnf_list = []
 674             # check if an external SAP is in the E-LAN (then a subnet is already defined)
 675             intfs_elan = [intf for intf in link["connection_points_reference"]]
 676             lan_sap = self.check_ext_saps(intfs_elan)
 677             if lan_sap:
 678                 lan_net = self.saps[lan_sap]['net']
 679                 lan_hosts = list(lan_net.hosts())
 680                 sap_ip = str(lan_hosts.pop(0))
 681             else:
 682                 lan_net = ELAN_SUBNETS.pop(0)
 683                 lan_hosts = list(lan_net.hosts())
 684
 685             # generate lan ip address for all interfaces except external SAPs
 686             for intf in link["connection_points_reference"]:
 687
 688                 # skip external SAPs, they already have an ip
 689                 vnf_id, vnf_interface, vnf_sap_docker_name = parse_interface(intf)
 690                 if vnf_sap_docker_name in self.saps_ext:
 691                     elan_vnf_list.append({'name': vnf_sap_docker_name, 'interface': vnf_interface})
 692                     continue
 693
 694                 ip_address = "{0}/{1}".format(str(lan_hosts.pop(0)), lan_net.prefixlen)
 695                 vnf_id, intf_name, vnf_sap_id = parse_interface(intf)
 696
 697                 # make sure we use the correct sap vnf name
 698                 src_docker_name = vnf_id
 699                 if vnf_sap_id in self.saps_int:
 700                     src_docker_name = vnf_sap_id
 701                     vnf_id = vnf_sap_id
 702
 703                 LOG.debug(
 704                     "Setting up E-LAN interface. (%s:%s) -> %s" % (
 705                         vnf_id, intf_name, ip_address))
 706
 707                 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
 708                 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
 709                 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
 710                 vnfi = self._get_vnf_instance(instance_uuid, vnf_id)
 711                 if vnfi is not None:
 712                     self._vnf_reconfigure_network(vnfi, intf_name, ip_address)
 713                     # add this vnf and interface to the E-LAN for tagging
 714                     elan_vnf_list.append({'name': src_docker_name, 'interface': intf_name})
 715
 716             # install the VLAN tags for this E-LAN
 717             GK.net.setLAN(elan_vnf_list)
 718
 719
 720     def _load_docker_files(self):
 721         """
 722         Get all paths to Dockerfiles from VNFDs and store them in dict.
 723         :return:
 724         """
 725         for k, v in self.vnfds.iteritems():
 726             for vu in v.get("virtual_deployment_units"):
 727                 if vu.get("vm_image_format") == "docker":
 728                     vm_image = vu.get("vm_image")
 729                     docker_path = os.path.join(
 730                         self.package_content_path,
 731                         make_relative_path(vm_image))
 732                     self.local_docker_files[k] = docker_path
 733                     LOG.debug("Found Dockerfile (%r): %r" % (k, docker_path))
 734
 735     def _load_docker_urls(self):
 736         """
 737         Get all URLs to pre-build docker images in some repo.
 738         :return:
 739         """
 740         # also merge sap dicts, because internal saps also need a docker container
 741         all_vnfs = self.vnfds.copy()
 742         all_vnfs.update(self.saps)
 743
 744         for k, v in all_vnfs.iteritems():
 745             for vu in v.get("virtual_deployment_units", {}):
 746                 if vu.get("vm_image_format") == "docker":
 747                     url = vu.get("vm_image")
 748                     if url is not None:
 749                         url = url.replace("http://", "")
 750                         self.remote_docker_image_urls[k] = url
 751                         LOG.debug("Found Docker image URL (%r): %r" % (k, self.remote_docker_image_urls[k]))
 752
 753     def _build_images_from_dockerfiles(self):
 754         """
 755         Build Docker images for each local Dockerfile found in the package: self.local_docker_files
 756         """
 757         if GK_STANDALONE_MODE:
 758             return  # do not build anything in standalone mode
 759         dc = DockerClient()
 760         LOG.info("Building %d Docker images (this may take several minutes) ..." % len(self.local_docker_files))
 761         for k, v in self.local_docker_files.iteritems():
 762             for line in dc.build(path=v.replace("Dockerfile", ""), tag=k, rm=False, nocache=False):
 763                 LOG.debug("DOCKER BUILD: %s" % line)
 764             LOG.info("Docker image created: %s" % k)
 765
 766     def _pull_predefined_dockerimages(self):
 767         """
 768         If the package contains URLs to pre-build Docker images, we download them with this method.
 769         """
 770         dc = DockerClient()
 771         for url in self.remote_docker_image_urls.itervalues():
 772             if not FORCE_PULL:  # only pull if not present (speedup for development)
 773                 if len(dc.images.list(name=url)) > 0:
 774                     LOG.debug("Image %r present. Skipping pull." % url)
 775                     continue
 776             LOG.info("Pulling image: %r" % url)
 777             # this seems to fail with latest docker api version 2.0.2
 778             # dc.images.pull(url,
 779             #        insecure_registry=True)
 780             #using docker cli instead
 781             cmd = ["docker",
 782                    "pull",
 783                    url,
 784                    ]
 785             Popen(cmd).wait()
 786
 787
 788
 789
 790     def _check_docker_image_exists(self, image_name):
 791         """
 792         Query the docker service and check if the given image exists
 793         :param image_name: name of the docker image
 794         :return:
 795         """
 796         return len(DockerClient().images.list(name=image_name)) > 0
 797
 798     def _calculate_placement(self, algorithm):
 799         """
 800         Do placement by adding the a field "dc" to
 801         each VNFD that points to one of our
 802         data center objects known to the gatekeeper.
 803         """
 804         assert(len(self.vnfds) > 0)
 805         assert(len(GK.dcs) > 0)
 806         # instantiate algorithm an place
 807         p = algorithm()
 808         p.place(self.nsd, self.vnfds, self.saps, GK.dcs)
 809         LOG.info("Using placement algorithm: %r" % p.__class__.__name__)
 810         # lets print the placement result
 811         for name, vnfd in self.vnfds.iteritems():
 812             LOG.info("Placed VNF %r on DC %r" % (name, str(vnfd.get("dc"))))
 813         for sap in self.saps:
 814             sap_dict = self.saps[sap]
 815             LOG.info("Placed SAP %r on DC %r" % (sap, str(sap_dict.get("dc"))))
 816
 817
 818     def _calculate_cpu_cfs_values(self, cpu_time_percentage):
 819         """
 820         Calculate cpu period and quota for CFS
 821         :param cpu_time_percentage: percentage of overall CPU to be used
 822         :return: cpu_period, cpu_quota
 823         """
 824         if cpu_time_percentage is None:
 825             return -1, -1
 826         if cpu_time_percentage < 0:
 827             return -1, -1
 828         # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
 829         # Attention minimum cpu_quota is 1ms (micro)
 830         cpu_period = 1000000  # lets consider a fixed period of 1000000 microseconds for now
 831         LOG.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period, cpu_time_percentage))
 832         cpu_quota = cpu_period * cpu_time_percentage  # calculate the fraction of cpu time for this container
 833         # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
 834         if cpu_quota < 1000:
 835             LOG.debug("cpu_quota before correcting: %r" % cpu_quota)
 836             cpu_quota = 1000
 837             LOG.warning("Increased CPU quota to avoid system error.")
 838         LOG.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period, cpu_quota))
 839         return int(cpu_period), int(cpu_quota)
 840
 841     def check_ext_saps(self, intf_list):
 842         # check if the list of interfacs contains an external SAP
 843         saps_ext = [self.saps[sap]['name'] for sap in self.saps if self.saps[sap]["type"] == "external"]
 844         for intf_name in intf_list:
 845             vnf_id, vnf_interface, vnf_sap_docker_name = parse_interface(intf_name)
 846             if vnf_sap_docker_name in saps_ext:
 847                 return vnf_sap_docker_name
 848
 849     def check_mgmt_interface(self, intf_list):
 850         SAPs_mgmt = [p.get('id') for p in self.nsd["connection_points"] if 'management' in p.get('type')]
 851         for intf_name in intf_list:
 852             if intf_name in SAPs_mgmt:
 853                 return True
 854
 855 """
 856 Some (simple) placement algorithms
 857 """
 858
 859
 860 class FirstDcPlacement(object):
 861     """
 862     Placement: Always use one and the same data center from the GK.dcs dict.
 863     """
 864     def place(self, nsd, vnfds, saps, dcs):
 865         for id, vnfd in vnfds.iteritems():
 866             vnfd["dc"] = list(dcs.itervalues())[0]
 867
 868
 869 class RoundRobinDcPlacement(object):
 870     """
 871     Placement: Distribute VNFs across all available DCs in a round robin fashion.
 872     """
 873     def place(self, nsd, vnfds, saps, dcs):
 874         c = 0
 875         dcs_list = list(dcs.itervalues())
 876         for id, vnfd in vnfds.iteritems():
 877             vnfd["dc"] = dcs_list[c % len(dcs_list)]
 878             c += 1  # inc. c to use next DC
 879
 880 class RoundRobinDcPlacementWithSAPs(object):
 881     """
 882     Placement: Distribute VNFs across all available DCs in a round robin fashion,
 883     every SAP is instantiated on the same DC as the connected VNF.
 884     """
 885     def place(self, nsd, vnfds, saps, dcs):
 886
 887         # place vnfs
 888         c = 0
 889         dcs_list = list(dcs.itervalues())
 890         for id, vnfd in vnfds.iteritems():
 891             vnfd["dc"] = dcs_list[c % len(dcs_list)]
 892             c += 1  # inc. c to use next DC
 893
 894         # place SAPs
 895         vlinks = nsd.get("virtual_links", [])
 896         eline_fwd_links = [l for l in vlinks if (l["connectivity_type"] == "E-Line")]
 897         elan_fwd_links = [l for l in vlinks if  (l["connectivity_type"] == "E-LAN")]
 898
 899         # SAPs on E-Line links are placed on the same DC as the VNF on the E-Line
 900         for link in eline_fwd_links:
 901             src_id, src_if_name, src_sap_id = parse_interface(link["connection_points_reference"][0])
 902             dst_id, dst_if_name, dst_sap_id = parse_interface(link["connection_points_reference"][1])
 903
 904             # check if there is a SAP in the link
 905             if src_sap_id in saps:
 906                 # get dc where connected vnf is mapped to
 907                 dc = vnfds[dst_id]['dc']
 908                 saps[src_sap_id]['dc'] = dc
 909
 910             if dst_sap_id in saps:
 911                 # get dc where connected vnf is mapped to
 912                 dc = vnfds[src_id]['dc']
 913                 saps[dst_sap_id]['dc'] = dc
 914
 915         # SAPs on E-LANs are placed on a random DC
 916         dcs_list = list(dcs.itervalues())
 917         dc_len = len(dcs_list)
 918         for link in elan_fwd_links:
 919             for intf in link["connection_points_reference"]:
 920                 # find SAP interfaces
 921                 intf_id, intf_name, intf_sap_id = parse_interface(intf)
 922                 if intf_sap_id in saps:
 923                     dc = dcs_list[randint(0, dc_len-1)]
 924                     saps[intf_sap_id]['dc'] = dc
 925
 926
 927
 928 """
 929 Resource definitions and API endpoints
 930 """
 931
 932
 933 class Packages(fr.Resource):
 934
 935     def post(self):
 936         """
 937         Upload a *.son service package to the dummy gatekeeper.
 938
 939         We expect request with a *.son file and store it in UPLOAD_FOLDER
 940         :return: UUID
 941         """
 942         try:
 943             # get file contents
 944             LOG.info("POST /packages called")
 945             # lets search for the package in the request
 946             is_file_object = False  # make API more robust: file can be in data or in files field
 947             if "package" in request.files:
 948                 son_file = request.files["package"]
 949                 is_file_object = True
 950             elif len(request.data) > 0:
 951                 son_file = request.data
 952             else:
 953                 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
 954             # generate a uuid to reference this package
 955             service_uuid = str(uuid.uuid4())
 956             file_hash = hashlib.sha1(str(son_file)).hexdigest()
 957             # ensure that upload folder exists
 958             ensure_dir(UPLOAD_FOLDER)
 959             upload_path = os.path.join(UPLOAD_FOLDER, "%s.son" % service_uuid)
 960             # store *.son file to disk
 961             if is_file_object:
 962                 son_file.save(upload_path)
 963             else:
 964                 with open(upload_path, 'wb') as f:
 965                     f.write(son_file)
 966             size = os.path.getsize(upload_path)
 967
 968             # first stop and delete any other running services
 969             if AUTO_DELETE:
 970                 service_list = copy.copy(GK.services)
 971                 for service_uuid in service_list:
 972                     instances_list = copy.copy(GK.services[service_uuid].instances)
 973                     for instance_uuid in instances_list:
 974                         # valid service and instance UUID, stop service
 975                         GK.services.get(service_uuid).stop_service(instance_uuid)
 976                         LOG.info("service instance with uuid %r stopped." % instance_uuid)
 977
 978             # create a service object and register it
 979             s = Service(service_uuid, file_hash, upload_path)
 980             GK.register_service_package(service_uuid, s)
 981
 982             # automatically deploy the service
 983             if AUTO_DEPLOY:
 984                 # ok, we have a service uuid, lets start the service
 985                 reset_subnets()
 986                 service_instance_uuid = GK.services.get(service_uuid).start_service()
 987
 988             # generate the JSON result
 989             return {"service_uuid": service_uuid, "size": size, "sha1": file_hash, "error": None}, 201
 990         except Exception as ex:
 991             LOG.exception("Service package upload failed:")
 992             return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
 993
 994     def get(self):
 995         """
 996         Return a list of UUID's of uploaded service packages.
 997         :return: dict/list
 998         """
 999         LOG.info("GET /packages")
1000         return {"service_uuid_list": list(GK.services.iterkeys())}
1001
1002
1003 class Instantiations(fr.Resource):
1004
1005     def post(self):
1006         """
1007         Instantiate a service specified by its UUID.
1008         Will return a new UUID to identify the running service instance.
1009         :return: UUID
1010         """
1011         LOG.info("POST /instantiations (or /requests) called")
1012         # try to extract the service uuid from the request
1013         json_data = request.get_json(force=True)
1014         service_uuid = json_data.get("service_uuid")
1015
1016         # lets be a bit fuzzy here to make testing easier
1017         if (service_uuid is None or service_uuid=="latest") and len(GK.services) > 0:
1018             # if we don't get a service uuid, we simple start the first service in the list
1019             service_uuid = list(GK.services.iterkeys())[0]
1020         if service_uuid in GK.services:
1021             # ok, we have a service uuid, lets start the service
1022             service_instance_uuid = GK.services.get(service_uuid).start_service()
1023             return {"service_instance_uuid": service_instance_uuid}, 201
1024         return "Service not found", 404
1025
1026     def get(self):
1027         """
1028         Returns a list of UUIDs containing all running services.
1029         :return: dict / list
1030         """
1031         LOG.info("GET /instantiations")
1032         return {"service_instantiations_list": [
1033             list(s.instances.iterkeys()) for s in GK.services.itervalues()]}
1034
1035     def delete(self):
1036         """
1037         Stops a running service specified by its service and instance UUID.
1038         """
1039         # try to extract the service  and instance UUID from the request
1040         json_data = request.get_json(force=True)
1041         service_uuid = json_data.get("service_uuid")
1042         instance_uuid = json_data.get("service_instance_uuid")
1043
1044         # try to be fuzzy
1045         if service_uuid is None and len(GK.services) > 0:
1046             #if we don't get a service uuid, we simply stop the last service in the list
1047             service_uuid = list(GK.services.iterkeys())[0]
1048         if instance_uuid is None and len(GK.services[service_uuid].instances) > 0:
1049             instance_uuid = list(GK.services[service_uuid].instances.iterkeys())[0]
1050
1051         if service_uuid in GK.services and instance_uuid in GK.services[service_uuid].instances:
1052             # valid service and instance UUID, stop service
1053             GK.services.get(service_uuid).stop_service(instance_uuid)
1054             return "service instance with uuid %r stopped." % instance_uuid,200
1055         return "Service not found", 404
1056
1057 class Exit(fr.Resource):
1058
1059     def put(self):
1060         """
1061         Stop the running Containernet instance regardless of data transmitted
1062         """
1063         list(GK.dcs.values())[0].net.stop()
1064
1065
1066 def initialize_GK():
1067     global GK
1068     GK = Gatekeeper()
1069
1070
1071
1072 # create a single, global GK object
1073 GK = None
1074 initialize_GK()
1075 # setup Flask
1076 app = Flask(__name__)
1077 app.config['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024  # 512 MB max upload
1078 api = fr.Api(app)
1079 # define endpoints
1080 api.add_resource(Packages, '/packages', '/api/v2/packages')
1081 api.add_resource(Instantiations, '/instantiations', '/api/v2/instantiations', '/api/v2/requests')
1082 api.add_resource(Exit, '/emulator/exit')
1083
1084
1085
1086 def start_rest_api(host, port, datacenters=dict()):
1087     GK.dcs = datacenters
1088     GK.net = get_dc_network()
1089     # start the Flask server (not the best performance but ok for our use case)
1090     app.run(host=host,
1091             port=port,
1092             debug=True,
1093             use_reloader=False  # this is needed to run Flask in a non-main thread
1094             )
1095
1096
1097 def ensure_dir(name):
1098     if not os.path.exists(name):
1099         os.makedirs(name)
1100
1101
1102 def load_yaml(path):
1103     with open(path, "r") as f:
1104         try:
1105             r = yaml.load(f)
1106         except yaml.YAMLError as exc:
1107             LOG.exception("YAML parse error")
1108             r = dict()
1109     return r
1110
1111
1112 def make_relative_path(path):
1113     if path.startswith("file://"):
1114         path = path.replace("file://", "", 1)
1115     if path.startswith("/"):
1116         path = path.replace("/", "", 1)
1117     return path
1118
1119
1120 def get_dc_network():
1121     """
1122     retrieve the DCnetwork where this dummygatekeeper (GK) connects to.
1123     Assume at least 1 datacenter is connected to this GK, and that all datacenters belong to the same DCNetwork
1124     :return:
1125     """
1126     assert (len(GK.dcs) > 0)
1127     return GK.dcs.values()[0].net
1128
1129
1130 def parse_interface(interface_name):
1131     """
1132     convert the interface name in the nsd to the according vnf_id, vnf_interface names
1133     :param interface_name:
1134     :return:
1135     """
1136
1137     if ':' in interface_name:
1138         vnf_id, vnf_interface = interface_name.split(':')
1139         vnf_sap_docker_name = interface_name.replace(':', '_')
1140     else:
1141         vnf_id = interface_name
1142         vnf_interface = interface_name
1143         vnf_sap_docker_name = interface_name
1144
1145     return vnf_id, vnf_interface, vnf_sap_docker_name
1146
1147 def reset_subnets():
1148     # private subnet definitions for the generated interfaces
1149     # 10.10.xxx.0/24
1150     global SAP_SUBNETS
1151     SAP_SUBNETS = generate_subnets('10.10', 0, subnet_size=50, mask=30)
1152     # 10.20.xxx.0/30
1153     global ELAN_SUBNETS
1154     ELAN_SUBNETS = generate_subnets('10.20', 0, subnet_size=50, mask=24)
1155     # 10.30.xxx.0/30
1156     global ELINE_SUBNETS
1157     ELINE_SUBNETS = generate_subnets('10.30', 0, subnet_size=50, mask=30)
1158
1159 if __name__ == '__main__':
1160     """
1161     Lets allow to run the API in standalone mode.
1162     """
1163     GK_STANDALONE_MODE = True
1164     logging.getLogger("werkzeug").setLevel(logging.INFO)
1165     start_rest_api("0.0.0.0", 8000)
1166