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 Client as DockerClient
  43 from flask import Flask, request
  44 import flask_restful as fr
  45 from collections import defaultdict
  46 import pkg_resources
  47
  48 logging.basicConfig()
  49 LOG = logging.getLogger("sonata-dummy-gatekeeper")
  50 LOG.setLevel(logging.DEBUG)
  51 logging.getLogger("werkzeug").setLevel(logging.WARNING)
  52
  53 GK_STORAGE = "/tmp/son-dummy-gk/"
  54 UPLOAD_FOLDER = os.path.join(GK_STORAGE, "uploads/")
  55 CATALOG_FOLDER = os.path.join(GK_STORAGE, "catalog/")
  56
  57 # Enable Dockerfile build functionality
  58 BUILD_DOCKERFILE = False
  59
  60 # flag to indicate that we run without the emulator (only the bare API for integration testing)
  61 GK_STANDALONE_MODE = False
  62
  63 # should a new version of an image be pulled even if its available
  64 FORCE_PULL = False
  65
  66 # Automatically deploy SAPs (endpoints) of the service as new containers
  67 # Attention: This is not a configuration switch but a global variable! Don't change its default value.
  68 DEPLOY_SAP = False
  69
  70 # flag to indicate if we use bidirectional forwarding rules in the automatic chaining process
  71 BIDIRECTIONAL_CHAIN = False
  72
  73 class Gatekeeper(object):
  74
  75     def __init__(self):
  76         self.services = dict()
  77         self.dcs = dict()
  78         self.vnf_counter = 0  # used to generate short names for VNFs (Mininet limitation)
  79         LOG.info("Create SONATA dummy gatekeeper.")
  80
  81     def register_service_package(self, service_uuid, service):
  82         """
  83         register new service package
  84         :param service_uuid
  85         :param service object
  86         """
  87         self.services[service_uuid] = service
  88         # lets perform all steps needed to onboard the service
  89         service.onboard()
  90
  91     def get_next_vnf_name(self):
  92         self.vnf_counter += 1
  93         return "vnf%d" % self.vnf_counter
  94
  95
  96 class Service(object):
  97     """
  98     This class represents a NS uploaded as a *.son package to the
  99     dummy gatekeeper.
 100     Can have multiple running instances of this service.
 101     """
 102
 103     def __init__(self,
 104                  service_uuid,
 105                  package_file_hash,
 106                  package_file_path):
 107         self.uuid = service_uuid
 108         self.package_file_hash = package_file_hash
 109         self.package_file_path = package_file_path
 110         self.package_content_path = os.path.join(CATALOG_FOLDER, "services/%s" % self.uuid)
 111         self.manifest = None
 112         self.nsd = None
 113         self.vnfds = dict()
 114         self.local_docker_files = dict()
 115         self.remote_docker_image_urls = dict()
 116         self.instances = dict()
 117         self.vnf_name2docker_name = dict()
 118         self.sap_identifiers = set()
 119         # lets generate a set of subnet configurations used for e-line chaining setup
 120         self.eline_subnets_src = generate_subnet_strings(50, start=200, subnet_size=24, ip=1)
 121         self.eline_subnets_dst = generate_subnet_strings(50, start=200, subnet_size=24, ip=2)
 122
 123     def onboard(self):
 124         """
 125         Do all steps to prepare this service to be instantiated
 126         :return:
 127         """
 128         # 1. extract the contents of the package and store them in our catalog
 129         self._unpack_service_package()
 130         # 2. read in all descriptor files
 131         self._load_package_descriptor()
 132         self._load_nsd()
 133         self._load_vnfd()
 134         if DEPLOY_SAP:
 135             self._load_saps()
 136         # 3. prepare container images (e.g. download or build Dockerfile)
 137         if BUILD_DOCKERFILE:
 138             self._load_docker_files()
 139             self._build_images_from_dockerfiles()
 140         else:
 141             self._load_docker_urls()
 142             self._pull_predefined_dockerimages()
 143         LOG.info("On-boarded service: %r" % self.manifest.get("name"))
 144
 145     def start_service(self):
 146         """
 147         This methods creates and starts a new service instance.
 148         It computes placements, iterates over all VNFDs, and starts
 149         each VNFD as a Docker container in the data center selected
 150         by the placement algorithm.
 151         :return:
 152         """
 153         LOG.info("Starting service %r" % self.uuid)
 154
 155         # 1. each service instance gets a new uuid to identify it
 156         instance_uuid = str(uuid.uuid4())
 157         # build a instances dict (a bit like a NSR :))
 158         self.instances[instance_uuid] = dict()
 159         self.instances[instance_uuid]["vnf_instances"] = list()
 160
 161         # 2. Configure the chaining of the network functions (currently only E-Line and E-LAN links supported)
 162         vnf_id2vnf_name = defaultdict(lambda: "NotExistingNode",
 163                                       reduce(lambda x, y: dict(x, **y),
 164                                              map(lambda d: {d["vnf_id"]: d["vnf_name"]},
 165                                                  self.nsd["network_functions"])))
 166
 167         # 3. compute placement of this service instance (adds DC names to VNFDs)
 168         if not GK_STANDALONE_MODE:
 169             #self._calculate_placement(FirstDcPlacement)
 170             self._calculate_placement(RoundRobinDcPlacement)
 171         # iterate over all vnfds that we have to start
 172         for vnfd in self.vnfds.itervalues():
 173             vnfi = None
 174             if not GK_STANDALONE_MODE:
 175                 vnfi = self._start_vnfd(vnfd)
 176             self.instances[instance_uuid]["vnf_instances"].append(vnfi)
 177
 178         vlinks = self.nsd["virtual_links"]
 179         fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
 180         eline_fwd_links = [l for l in vlinks if (l["id"] in fwd_links) and (l["connectivity_type"] == "E-Line")]
 181         elan_fwd_links = [l for l in vlinks if (l["id"] in fwd_links) and (l["connectivity_type"] == "E-LAN")]
 182
 183         # 4a. deploy E-Line links
 184         # cookie is used as identifier for the flowrules installed by the dummygatekeeper
 185         # eg. different services get a unique cookie for their flowrules
 186         cookie = 1
 187         for link in eline_fwd_links:
 188             src_id, src_if_name = link["connection_points_reference"][0].split(":")
 189             dst_id, dst_if_name = link["connection_points_reference"][1].split(":")
 190
 191             # check if there is a SAP in the link
 192             if src_id in self.sap_identifiers:
 193                 src_docker_name = "{0}_{1}".format(src_id, src_if_name)
 194                 src_id = src_docker_name
 195             else:
 196                 src_docker_name = src_id
 197
 198             if dst_id in self.sap_identifiers:
 199                 dst_docker_name = "{0}_{1}".format(dst_id, dst_if_name)
 200                 dst_id = dst_docker_name
 201             else:
 202                 dst_docker_name = dst_id
 203
 204             src_name = vnf_id2vnf_name[src_id]
 205             dst_name = vnf_id2vnf_name[dst_id]
 206
 207             LOG.debug(
 208                 "Setting up E-Line link. %s(%s:%s) -> %s(%s:%s)" % (
 209                     src_name, src_id, src_if_name, dst_name, dst_id, dst_if_name))
 210
 211             if (src_name in self.vnfds) and (dst_name in self.vnfds):
 212                 network = self.vnfds[src_name].get("dc").net  # there should be a cleaner way to find the DCNetwork
 213                 LOG.debug(src_docker_name)
 214                 ret = network.setChain(
 215                     src_docker_name, dst_docker_name,
 216                     vnf_src_interface=src_if_name, vnf_dst_interface=dst_if_name,
 217                     bidirectional=BIDIRECTIONAL_CHAIN, cmd="add-flow", cookie=cookie, priority=10)
 218
 219                 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
 220                 src_vnfi = self._get_vnf_instance(instance_uuid, src_name)
 221                 if src_vnfi is not None:
 222                     self._vnf_reconfigure_network(src_vnfi, src_if_name, self.eline_subnets_src.pop(0))
 223                 dst_vnfi = self._get_vnf_instance(instance_uuid, dst_name)
 224                 if dst_vnfi is not None:
 225                     self._vnf_reconfigure_network(dst_vnfi, dst_if_name, self.eline_subnets_dst.pop(0))
 226
 227         # 4b. deploy E-LAN links
 228         base = 10
 229         for link in elan_fwd_links:
 230
 231             elan=[]
 232
 233             # generate lan ip address
 234             ip = 1
 235             for intf in link["connection_points_reference"]:
 236                 ip_address = generate_lan_string("10.0", base, subnet_size=24, ip=ip)
 237                 vnf_id, intf_name = intf.split(":")
 238                 if vnf_id in self.sap_identifiers:
 239                     src_docker_name = "{0}_{1}".format(vnf_id, intf_name)
 240                     vnf_id = src_docker_name
 241                 else:
 242                     src_docker_name = vnf_id
 243                 vnf_name = vnf_id2vnf_name[vnf_id]
 244                 LOG.debug(
 245                     "Setting up E-LAN link. %s(%s:%s) -> %s" % (
 246                         vnf_name, vnf_id, intf_name, ip_address))
 247
 248                 if vnf_name in self.vnfds:
 249                     # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
 250                     # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
 251                     # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
 252                     vnfi = self._get_vnf_instance(instance_uuid, vnf_name)
 253                     if vnfi is not None:
 254                         self._vnf_reconfigure_network(vnfi, intf_name, ip_address)
 255                         # increase for the next ip address on this E-LAN
 256                         ip += 1
 257
 258                         # add this vnf and interface to the E-LAN for tagging
 259                         network = self.vnfds[vnf_name].get("dc").net  # there should be a cleaner way to find the DCNetwork
 260                         elan.append({'name':src_docker_name,'interface':intf_name})
 261
 262
 263             # install the VLAN tags for this E-LAN
 264             print(elan)
 265             network.setLAN(elan)
 266             # increase the base ip address for the next E-LAN
 267             base += 1
 268
 269         # 5. run the emulator specific entrypoint scripts in the VNFIs of this service instance
 270         self._trigger_emulator_start_scripts_in_vnfis(self.instances[instance_uuid]["vnf_instances"])
 271
 272         LOG.info("Service started. Instance id: %r" % instance_uuid)
 273         return instance_uuid
 274
 275     def _start_vnfd(self, vnfd):
 276         """
 277         Start a single VNFD of this service
 278         :param vnfd: vnfd descriptor dict
 279         :return:
 280         """
 281         # iterate over all deployment units within each VNFDs
 282         for u in vnfd.get("virtual_deployment_units"):
 283             # 1. get the name of the docker image to start and the assigned DC
 284             vnf_name = vnfd.get("name")
 285             if vnf_name not in self.remote_docker_image_urls:
 286                 raise Exception("No image name for %r found. Abort." % vnf_name)
 287             docker_name = self.remote_docker_image_urls.get(vnf_name)
 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             # 3. do the dc.startCompute(name="foobar") call to run the container
 295             # TODO consider flavors, and other annotations
 296             intfs = vnfd.get("connection_points")
 297
 298             # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
 299             # use the vnf_id in the nsd as docker name
 300             # so deployed containers can be easily mapped back to the nsd
 301             vnf_name2id = defaultdict(lambda: "NotExistingNode",
 302                                           reduce(lambda x, y: dict(x, **y),
 303                                                  map(lambda d: {d["vnf_name"]: d["vnf_id"]},
 304                                                      self.nsd["network_functions"])))
 305             self.vnf_name2docker_name[vnf_name] = vnf_name2id[vnf_name]
 306             # self.vnf_name2docker_name[vnf_name] = GK.get_next_vnf_name()
 307
 308             LOG.info("Starting %r as %r in DC %r" % (vnf_name, self.vnf_name2docker_name[vnf_name], vnfd.get("dc")))
 309             LOG.debug("Interfaces for %r: %r" % (vnf_name, intfs))
 310             vnfi = target_dc.startCompute(self.vnf_name2docker_name[vnf_name], network=intfs, image=docker_name, flavor_name="small")
 311             return vnfi
 312
 313     def _get_vnf_instance(self, instance_uuid, name):
 314         """
 315         Returns the Docker object for the given VNF name (or Docker name).
 316         :param instance_uuid: UUID of the service instance to search in.
 317         :param name: VNF name or Docker name. We are fuzzy here.
 318         :return:
 319         """
 320         dn = name
 321         if name in self.vnf_name2docker_name:
 322             dn = self.vnf_name2docker_name[name]
 323         for vnfi in self.instances[instance_uuid]["vnf_instances"]:
 324             if vnfi.name == dn:
 325                 return vnfi
 326         LOG.warning("No container with name: %r found.")
 327         return None
 328
 329     @staticmethod
 330     def _vnf_reconfigure_network(vnfi, if_name, net_str):
 331         """
 332         Reconfigure the network configuration of a specific interface
 333         of a running container.
 334         :param vnfi: container instacne
 335         :param if_name: interface name
 336         :param net_str: network configuration string, e.g., 1.2.3.4/24
 337         :return:
 338         """
 339         intf = vnfi.intf(intf=if_name)
 340         if intf is not None:
 341             intf.setIP(net_str)
 342             LOG.debug("Reconfigured network of %s:%s to %r" % (vnfi.name, if_name, net_str))
 343         else:
 344             LOG.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi.name, if_name))
 345
 346
 347     def _trigger_emulator_start_scripts_in_vnfis(self, vnfi_list):
 348         for vnfi in vnfi_list:
 349             config = vnfi.dcinfo.get("Config", dict())
 350             env = config.get("Env", list())
 351             for env_var in env:
 352                 if "SON_EMU_CMD=" in env_var:
 353                     cmd = str(env_var.split("=")[1])
 354                     LOG.info("Executing entry point script in %r: %r" % (vnfi.name, cmd))
 355                     # execute command in new thread to ensure that GK is not blocked by VNF
 356                     t = threading.Thread(target=vnfi.cmdPrint, args=(cmd,))
 357                     t.daemon = True
 358                     t.start()
 359
 360     def _unpack_service_package(self):
 361         """
 362         unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
 363         """
 364         LOG.info("Unzipping: %r" % self.package_file_path)
 365         with zipfile.ZipFile(self.package_file_path, "r") as z:
 366             z.extractall(self.package_content_path)
 367
 368
 369     def _load_package_descriptor(self):
 370         """
 371         Load the main package descriptor YAML and keep it as dict.
 372         :return:
 373         """
 374         self.manifest = load_yaml(
 375             os.path.join(
 376                 self.package_content_path, "META-INF/MANIFEST.MF"))
 377
 378     def _load_nsd(self):
 379         """
 380         Load the entry NSD YAML and keep it as dict.
 381         :return:
 382         """
 383         if "entry_service_template" in self.manifest:
 384             nsd_path = os.path.join(
 385                 self.package_content_path,
 386                 make_relative_path(self.manifest.get("entry_service_template")))
 387             self.nsd = load_yaml(nsd_path)
 388             LOG.debug("Loaded NSD: %r" % self.nsd.get("name"))
 389
 390     def _load_vnfd(self):
 391         """
 392         Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
 393         :return:
 394         """
 395         if "package_content" in self.manifest:
 396             for pc in self.manifest.get("package_content"):
 397                 if pc.get("content-type") == "application/sonata.function_descriptor":
 398                     vnfd_path = os.path.join(
 399                         self.package_content_path,
 400                         make_relative_path(pc.get("name")))
 401                     vnfd = load_yaml(vnfd_path)
 402                     self.vnfds[vnfd.get("name")] = vnfd
 403                     LOG.debug("Loaded VNFD: %r" % vnfd.get("name"))
 404
 405     def _load_saps(self):
 406         # Each Service Access Point (connection_point) in the nsd is getting its own container
 407         SAPs = [p["id"] for p in self.nsd["connection_points"] if p["type"] == "interface"]
 408         for sap in SAPs:
 409             # endpoints needed in this service
 410             sap_vnf_id, sap_vnf_interface = sap.split(':')
 411             # set of the connection_point ids found in the nsd (in the examples this is 'ns')
 412             self.sap_identifiers.add(sap_vnf_id)
 413
 414             sap_docker_name = "%s_%s" % (sap_vnf_id, sap_vnf_interface)
 415
 416             # add SAP to self.vnfds
 417             sapfile = pkg_resources.resource_filename(__name__, "sap_vnfd.yml")
 418             sap_vnfd = load_yaml(sapfile)
 419             sap_vnfd["connection_points"][0]["id"] = sap_vnf_interface
 420             sap_vnfd["name"] = sap_docker_name
 421             self.vnfds[sap_docker_name] = sap_vnfd
 422             # add SAP vnf to list in the NSD so it is deployed later on
 423             # each SAP get a unique VNFD and vnf_id in the NSD
 424             self.nsd["network_functions"].append({"vnf_id": sap_docker_name, "vnf_name": sap_docker_name})
 425             LOG.debug("Loaded SAP: %r" % sap_vnfd.get("name"))
 426
 427     def _load_docker_files(self):
 428         """
 429         Get all paths to Dockerfiles from VNFDs and store them in dict.
 430         :return:
 431         """
 432         for k, v in self.vnfds.iteritems():
 433             for vu in v.get("virtual_deployment_units"):
 434                 if vu.get("vm_image_format") == "docker":
 435                     vm_image = vu.get("vm_image")
 436                     docker_path = os.path.join(
 437                         self.package_content_path,
 438                         make_relative_path(vm_image))
 439                     self.local_docker_files[k] = docker_path
 440                     LOG.debug("Found Dockerfile (%r): %r" % (k, docker_path))
 441
 442     def _load_docker_urls(self):
 443         """
 444         Get all URLs to pre-build docker images in some repo.
 445         :return:
 446         """
 447         for k, v in self.vnfds.iteritems():
 448             for vu in v.get("virtual_deployment_units"):
 449                 if vu.get("vm_image_format") == "docker":
 450                     url = vu.get("vm_image")
 451                     if url is not None:
 452                         url = url.replace("http://", "")
 453                         self.remote_docker_image_urls[k] = url
 454                         LOG.debug("Found Docker image URL (%r): %r" % (k, self.remote_docker_image_urls[k]))
 455
 456     def _build_images_from_dockerfiles(self):
 457         """
 458         Build Docker images for each local Dockerfile found in the package: self.local_docker_files
 459         """
 460         if GK_STANDALONE_MODE:
 461             return  # do not build anything in standalone mode
 462         dc = DockerClient()
 463         LOG.info("Building %d Docker images (this may take several minutes) ..." % len(self.local_docker_files))
 464         for k, v in self.local_docker_files.iteritems():
 465             for line in dc.build(path=v.replace("Dockerfile", ""), tag=k, rm=False, nocache=False):
 466                 LOG.debug("DOCKER BUILD: %s" % line)
 467             LOG.info("Docker image created: %s" % k)
 468
 469     def _pull_predefined_dockerimages(self):
 470         """
 471         If the package contains URLs to pre-build Docker images, we download them with this method.
 472         """
 473         dc = DockerClient()
 474         for url in self.remote_docker_image_urls.itervalues():
 475             if not FORCE_PULL:  # only pull if not present (speedup for development)
 476                 if len(dc.images(name=url)) > 0:
 477                     LOG.debug("Image %r present. Skipping pull." % url)
 478                     continue
 479             LOG.info("Pulling image: %r" % url)
 480             dc.pull(url,
 481                     insecure_registry=True)
 482
 483     def _check_docker_image_exists(self, image_name):
 484         """
 485         Query the docker service and check if the given image exists
 486         :param image_name: name of the docker image
 487         :return:
 488         """
 489         return len(DockerClient().images(image_name)) > 0
 490
 491     def _calculate_placement(self, algorithm):
 492         """
 493         Do placement by adding the a field "dc" to
 494         each VNFD that points to one of our
 495         data center objects known to the gatekeeper.
 496         """
 497         assert(len(self.vnfds) > 0)
 498         assert(len(GK.dcs) > 0)
 499         # instantiate algorithm an place
 500         p = algorithm()
 501         p.place(self.nsd, self.vnfds, GK.dcs)
 502         LOG.info("Using placement algorithm: %r" % p.__class__.__name__)
 503         # lets print the placement result
 504         for name, vnfd in self.vnfds.iteritems():
 505             LOG.info("Placed VNF %r on DC %r" % (name, str(vnfd.get("dc"))))
 506
 507
 508 """
 509 Some (simple) placement algorithms
 510 """
 511
 512
 513 class FirstDcPlacement(object):
 514     """
 515     Placement: Always use one and the same data center from the GK.dcs dict.
 516     """
 517     def place(self, nsd, vnfds, dcs):
 518         for name, vnfd in vnfds.iteritems():
 519             vnfd["dc"] = list(dcs.itervalues())[0]
 520
 521
 522 class RoundRobinDcPlacement(object):
 523     """
 524     Placement: Distribute VNFs across all available DCs in a round robin fashion.
 525     """
 526     def place(self, nsd, vnfds, dcs):
 527         c = 0
 528         dcs_list = list(dcs.itervalues())
 529         for name, vnfd in vnfds.iteritems():
 530             vnfd["dc"] = dcs_list[c % len(dcs_list)]
 531             c += 1  # inc. c to use next DC
 532
 533
 534
 535
 536 """
 537 Resource definitions and API endpoints
 538 """
 539
 540
 541 class Packages(fr.Resource):
 542
 543     def post(self):
 544         """
 545         Upload a *.son service package to the dummy gatekeeper.
 546
 547         We expect request with a *.son file and store it in UPLOAD_FOLDER
 548         :return: UUID
 549         """
 550         try:
 551             # get file contents
 552             print(request.files)
 553             # lets search for the package in the request
 554             if "package" in request.files:
 555                 son_file = request.files["package"]
 556             # elif "file" in request.files:
 557             #     son_file = request.files["file"]
 558             else:
 559                 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
 560             # generate a uuid to reference this package
 561             service_uuid = str(uuid.uuid4())
 562             file_hash = hashlib.sha1(str(son_file)).hexdigest()
 563             # ensure that upload folder exists
 564             ensure_dir(UPLOAD_FOLDER)
 565             upload_path = os.path.join(UPLOAD_FOLDER, "%s.son" % service_uuid)
 566             # store *.son file to disk
 567             son_file.save(upload_path)
 568             size = os.path.getsize(upload_path)
 569             # create a service object and register it
 570             s = Service(service_uuid, file_hash, upload_path)
 571             GK.register_service_package(service_uuid, s)
 572             # generate the JSON result
 573             return {"service_uuid": service_uuid, "size": size, "sha1": file_hash, "error": None}, 201
 574         except Exception as ex:
 575             LOG.exception("Service package upload failed:")
 576             return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
 577
 578     def get(self):
 579         """
 580         Return a list of UUID's of uploaded service packages.
 581         :return: dict/list
 582         """
 583         LOG.info("GET /packages")
 584         return {"service_uuid_list": list(GK.services.iterkeys())}
 585
 586
 587 class Instantiations(fr.Resource):
 588
 589     def post(self):
 590         """
 591         Instantiate a service specified by its UUID.
 592         Will return a new UUID to identify the running service instance.
 593         :return: UUID
 594         """
 595         # try to extract the service uuid from the request
 596         json_data = request.get_json(force=True)
 597         service_uuid = json_data.get("service_uuid")
 598
 599         # lets be a bit fuzzy here to make testing easier
 600         if service_uuid is None and len(GK.services) > 0:
 601             # if we don't get a service uuid, we simple start the first service in the list
 602             service_uuid = list(GK.services.iterkeys())[0]
 603
 604         if service_uuid in GK.services:
 605             # ok, we have a service uuid, lets start the service
 606             service_instance_uuid = GK.services.get(service_uuid).start_service()
 607             return {"service_instance_uuid": service_instance_uuid}
 608         return "Service not found", 404
 609
 610     def get(self):
 611         """
 612         Returns a list of UUIDs containing all running services.
 613         :return: dict / list
 614         """
 615         LOG.info("GET /instantiations")
 616         return {"service_instantiations_list": [
 617             list(s.instances.iterkeys()) for s in GK.services.itervalues()]}
 618
 619
 620 # create a single, global GK object
 621 GK = Gatekeeper()
 622 # setup Flask
 623 app = Flask(__name__)
 624 app.config['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024  # 512 MB max upload
 625 api = fr.Api(app)
 626 # define endpoints
 627 api.add_resource(Packages, '/packages')
 628 api.add_resource(Instantiations, '/instantiations')
 629
 630
 631 def start_rest_api(host, port, datacenters=dict()):
 632     GK.dcs = datacenters
 633     # start the Flask server (not the best performance but ok for our use case)
 634     app.run(host=host,
 635             port=port,
 636             debug=True,
 637             use_reloader=False  # this is needed to run Flask in a non-main thread
 638             )
 639
 640
 641 def ensure_dir(name):
 642     if not os.path.exists(name):
 643         os.makedirs(name)
 644
 645
 646 def load_yaml(path):
 647     with open(path, "r") as f:
 648         try:
 649             r = yaml.load(f)
 650         except yaml.YAMLError as exc:
 651             LOG.exception("YAML parse error")
 652             r = dict()
 653     return r
 654
 655
 656 def make_relative_path(path):
 657     if path.startswith("file://"):
 658         path = path.replace("file://", "", 1)
 659     if path.startswith("/"):
 660         path = path.replace("/", "", 1)
 661     return path
 662
 663
 664 def generate_lan_string(prefix, base, subnet_size=24, ip=0):
 665     """
 666     Helper to generate different network configuration strings.
 667     """
 668     r = "%s.%d.%d/%d" % (prefix, base, ip, subnet_size)
 669     return r
 670
 671
 672 def generate_subnet_strings(n, start=1, subnet_size=24, ip=0):
 673     """
 674     Helper to generate different network configuration strings.
 675     """
 676     r = list()
 677     for i in range(start, start + n):
 678         r.append("%d.0.0.%d/%d" % (i, ip, subnet_size))
 679     return r
 680
 681
 682 if __name__ == '__main__':
 683     """
 684     Lets allow to run the API in standalone mode.
 685     """
 686     GK_STANDALONE_MODE = True
 687     logging.getLogger("werkzeug").setLevel(logging.INFO)
 688     start_rest_api("0.0.0.0", 8000)
 689