2 Copyright (c) 2015 SONATA-NFV and Paderborn University
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
9 http://www.apache.org/licenses/LICENSE-2.0
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.
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
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).
29 This module implements a simple REST API that behaves like SONATA's gatekeeper.
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.
42 from docker
import Client
as DockerClient
43 from flask
import Flask
, request
44 import flask_restful
as fr
45 from collections
import defaultdict
49 LOG
= logging
.getLogger("sonata-dummy-gatekeeper")
50 LOG
.setLevel(logging
.DEBUG
)
51 logging
.getLogger("werkzeug").setLevel(logging
.WARNING
)
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/")
57 # Enable Dockerfile build functionality
58 BUILD_DOCKERFILE
= False
60 # flag to indicate that we run without the emulator (only the bare API for integration testing)
61 GK_STANDALONE_MODE
= False
63 # should a new version of an image be pulled even if its available
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.
70 # flag to indicate if we use bidirectional forwarding rules in the automatic chaining process
71 BIDIRECTIONAL_CHAIN
= False
73 class Gatekeeper(object):
76 self
.services
= dict()
78 self
.vnf_counter
= 0 # used to generate short names for VNFs (Mininet limitation)
79 LOG
.info("Create SONATA dummy gatekeeper.")
81 def register_service_package(self
, service_uuid
, service
):
83 register new service package
87 self
.services
[service_uuid
] = service
88 # lets perform all steps needed to onboard the service
91 def get_next_vnf_name(self
):
93 return "vnf%d" % self
.vnf_counter
96 class Service(object):
98 This class represents a NS uploaded as a *.son package to the
100 Can have multiple running instances of this service.
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
)
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)
125 Do all steps to prepare this service to be instantiated
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
()
136 # 3. prepare container images (e.g. download or build Dockerfile)
138 self
._load
_docker
_files
()
139 self
._build
_images
_from
_dockerfiles
()
141 self
._load
_docker
_urls
()
142 self
._pull
_predefined
_dockerimages
()
143 LOG
.info("On-boarded service: %r" % self
.manifest
.get("name"))
145 def start_service(self
):
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.
153 LOG
.info("Starting service %r" % self
.uuid
)
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()
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"])))
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():
174 if not GK_STANDALONE_MODE
:
175 vnfi
= self
._start
_vnfd
(vnfd
)
176 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
178 if "virtual_links" in self
.nsd
:
179 vlinks
= self
.nsd
["virtual_links"]
180 fwd_links
= self
.nsd
["forwarding_graphs"][0]["constituent_virtual_links"]
181 eline_fwd_links
= [l
for l
in vlinks
if (l
["id"] in fwd_links
) and (l
["connectivity_type"] == "E-Line")]
182 elan_fwd_links
= [l
for l
in vlinks
if (l
["id"] in fwd_links
) and (l
["connectivity_type"] == "E-LAN")]
184 # 4a. deploy E-Line links
185 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
186 # eg. different services get a unique cookie for their flowrules
188 for link
in eline_fwd_links
:
189 src_id
, src_if_name
= link
["connection_points_reference"][0].split(":")
190 dst_id
, dst_if_name
= link
["connection_points_reference"][1].split(":")
192 # check if there is a SAP in the link
193 if src_id
in self
.sap_identifiers
:
194 src_docker_name
= "{0}_{1}".format(src_id
, src_if_name
)
195 src_id
= src_docker_name
197 src_docker_name
= src_id
199 if dst_id
in self
.sap_identifiers
:
200 dst_docker_name
= "{0}_{1}".format(dst_id
, dst_if_name
)
201 dst_id
= dst_docker_name
203 dst_docker_name
= dst_id
205 src_name
= vnf_id2vnf_name
[src_id
]
206 dst_name
= vnf_id2vnf_name
[dst_id
]
209 "Setting up E-Line link. %s(%s:%s) -> %s(%s:%s)" % (
210 src_name
, src_id
, src_if_name
, dst_name
, dst_id
, dst_if_name
))
212 if (src_name
in self
.vnfds
) and (dst_name
in self
.vnfds
):
213 network
= self
.vnfds
[src_name
].get("dc").net
# there should be a cleaner way to find the DCNetwork
214 LOG
.debug(src_docker_name
)
215 ret
= network
.setChain(
216 src_docker_name
, dst_docker_name
,
217 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
218 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
220 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
221 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_name
)
222 if src_vnfi
is not None:
223 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, self
.eline_subnets_src
.pop(0))
224 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_name
)
225 if dst_vnfi
is not None:
226 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, self
.eline_subnets_dst
.pop(0))
228 # 4b. deploy E-LAN links
230 for link
in elan_fwd_links
:
231 # generate lan ip address
233 for intf
in link
["connection_points_reference"]:
234 ip_address
= generate_lan_string("10.0", base
, subnet_size
=24, ip
=ip
)
235 vnf_id
, intf_name
= intf
.split(":")
236 if vnf_id
in self
.sap_identifiers
:
237 src_docker_name
= "{0}_{1}".format(vnf_id
, intf_name
)
238 vnf_id
= src_docker_name
239 vnf_name
= vnf_id2vnf_name
[vnf_id
]
241 "Setting up E-LAN link. %s(%s:%s) -> %s" % (
242 vnf_name
, vnf_id
, intf_name
, ip_address
))
244 if vnf_name
in self
.vnfds
:
245 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
246 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
247 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
248 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_name
)
250 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
251 # increase for the next ip address on this E-LAN
253 # increase the base ip address for the next E-LAN
256 # 5. run the emulator specific entrypoint scripts in the VNFIs of this service instance
257 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
259 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
262 def stop_service(self
, instance_uuid
):
264 This method stops a running service instance.
265 It iterates over all VNF instances, stopping them each
266 and removing them from their data center.
268 :param instance_uuid: the uuid of the service instance to be stopped
270 LOG
.info("Stopping service %r" % self
.uuid
)
271 # get relevant information
272 # instance_uuid = str(self.uuid.uuid4())
273 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
275 for v
in vnf_instances
:
278 if not GK_STANDALONE_MODE
:
280 # self._remove_placement(RoundRobinPlacement)
283 # last step: remove the instance from the list of all instances
284 del self
.instances
[instance_uuid
]
286 def _start_vnfd(self
, vnfd
):
288 Start a single VNFD of this service
289 :param vnfd: vnfd descriptor dict
292 # iterate over all deployment units within each VNFDs
293 for u
in vnfd
.get("virtual_deployment_units"):
294 # 1. get the name of the docker image to start and the assigned DC
295 vnf_name
= vnfd
.get("name")
296 if vnf_name
not in self
.remote_docker_image_urls
:
297 raise Exception("No image name for %r found. Abort." % vnf_name
)
298 docker_name
= self
.remote_docker_image_urls
.get(vnf_name
)
299 target_dc
= vnfd
.get("dc")
300 # 2. perform some checks to ensure we can start the container
301 assert(docker_name
is not None)
302 assert(target_dc
is not None)
303 if not self
._check
_docker
_image
_exists
(docker_name
):
304 raise Exception("Docker image %r not found. Abort." % docker_name
)
306 # 3. get the resource limits
307 res_req
= u
.get("resource_requirements")
308 cpu_list
= res_req
.get("cpu").get("cores")
309 if not cpu_list
or len(cpu_list
)==0:
311 cpu_bw
= res_req
.get("cpu").get("cpu_bw")
314 mem_num
= str(res_req
.get("memory").get("size"))
317 mem_unit
= str(res_req
.get("memory").get("size_unit"))
320 mem_limit
= float(mem_num
)
322 mem_limit
=mem_limit
*1024*1024*1024
324 mem_limit
=mem_limit
*1024*1024
326 mem_limit
=mem_limit
*1024
327 mem_lim
= int(mem_limit
)
328 cpu_period
, cpu_quota
= self
._calculate
_cpu
_cfs
_values
(float(cpu_bw
))
330 # 4. do the dc.startCompute(name="foobar") call to run the container
331 # TODO consider flavors, and other annotations
332 intfs
= vnfd
.get("connection_points")
334 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
335 # use the vnf_id in the nsd as docker name
336 # so deployed containers can be easily mapped back to the nsd
337 vnf_name2id
= defaultdict(lambda: "NotExistingNode",
338 reduce(lambda x
, y
: dict(x
, **y
),
339 map(lambda d
: {d
["vnf_name"]: d
["vnf_id"]},
340 self
.nsd
["network_functions"])))
341 self
.vnf_name2docker_name
[vnf_name
] = vnf_name2id
[vnf_name
]
342 # self.vnf_name2docker_name[vnf_name] = GK.get_next_vnf_name()
344 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, self
.vnf_name2docker_name
[vnf_name
], vnfd
.get("dc")))
345 LOG
.debug("Interfaces for %r: %r" % (vnf_name
, intfs
))
346 vnfi
= target_dc
.startCompute(self
.vnf_name2docker_name
[vnf_name
], network
=intfs
, image
=docker_name
, flavor_name
="small",
347 cpu_quota
=cpu_quota
, cpu_period
=cpu_period
, cpuset
=cpu_list
, mem_limit
=mem_lim
)
350 def _stop_vnfi(self
, vnfi
):
354 :param vnfi: vnf instance to be stopped
356 # Find the correct datacenter
357 status
= vnfi
.getStatus()
360 LOG
.info("Stopping the vnf instance contained in %r in DC %r" % (status
["name"], dc
))
361 dc
.stopCompute(status
["name"])
363 def _get_vnf_instance(self
, instance_uuid
, name
):
365 Returns the Docker object for the given VNF name (or Docker name).
366 :param instance_uuid: UUID of the service instance to search in.
367 :param name: VNF name or Docker name. We are fuzzy here.
371 if name
in self
.vnf_name2docker_name
:
372 dn
= self
.vnf_name2docker_name
[name
]
373 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
376 LOG
.warning("No container with name: %r found.")
380 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
):
382 Reconfigure the network configuration of a specific interface
383 of a running container.
384 :param vnfi: container instacne
385 :param if_name: interface name
386 :param net_str: network configuration string, e.g., 1.2.3.4/24
389 intf
= vnfi
.intf(intf
=if_name
)
392 LOG
.debug("Reconfigured network of %s:%s to %r" % (vnfi
.name
, if_name
, net_str
))
394 LOG
.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi
.name
, if_name
))
397 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
398 for vnfi
in vnfi_list
:
399 config
= vnfi
.dcinfo
.get("Config", dict())
400 env
= config
.get("Env", list())
402 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
403 LOG
.debug("%r = %r" % (var
, cmd
))
404 if var
=="SON_EMU_CMD":
405 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
406 # execute command in new thread to ensure that GK is not blocked by VNF
407 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
411 def _unpack_service_package(self
):
413 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
415 LOG
.info("Unzipping: %r" % self
.package_file_path
)
416 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
417 z
.extractall(self
.package_content_path
)
420 def _load_package_descriptor(self
):
422 Load the main package descriptor YAML and keep it as dict.
425 self
.manifest
= load_yaml(
427 self
.package_content_path
, "META-INF/MANIFEST.MF"))
431 Load the entry NSD YAML and keep it as dict.
434 if "entry_service_template" in self
.manifest
:
435 nsd_path
= os
.path
.join(
436 self
.package_content_path
,
437 make_relative_path(self
.manifest
.get("entry_service_template")))
438 self
.nsd
= load_yaml(nsd_path
)
439 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
441 def _load_vnfd(self
):
443 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
446 if "package_content" in self
.manifest
:
447 for pc
in self
.manifest
.get("package_content"):
448 if pc
.get("content-type") == "application/sonata.function_descriptor":
449 vnfd_path
= os
.path
.join(
450 self
.package_content_path
,
451 make_relative_path(pc
.get("name")))
452 vnfd
= load_yaml(vnfd_path
)
453 self
.vnfds
[vnfd
.get("name")] = vnfd
454 LOG
.debug("Loaded VNFD: %r" % vnfd
.get("name"))
456 def _load_saps(self
):
457 # Each Service Access Point (connection_point) in the nsd is getting its own container
458 SAPs
= [p
["id"] for p
in self
.nsd
["connection_points"] if p
["type"] == "interface"]
460 # endpoints needed in this service
461 sap_vnf_id
, sap_vnf_interface
= sap
.split(':')
462 # set of the connection_point ids found in the nsd (in the examples this is 'ns')
463 self
.sap_identifiers
.add(sap_vnf_id
)
465 sap_docker_name
= "%s_%s" % (sap_vnf_id
, sap_vnf_interface
)
467 # add SAP to self.vnfds
468 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
469 sap_vnfd
= load_yaml(sapfile
)
470 sap_vnfd
["connection_points"][0]["id"] = sap_vnf_interface
471 sap_vnfd
["name"] = sap_docker_name
472 self
.vnfds
[sap_docker_name
] = sap_vnfd
473 # add SAP vnf to list in the NSD so it is deployed later on
474 # each SAP get a unique VNFD and vnf_id in the NSD
475 self
.nsd
["network_functions"].append({"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
})
476 LOG
.debug("Loaded SAP: %r" % sap_vnfd
.get("name"))
478 def _load_docker_files(self
):
480 Get all paths to Dockerfiles from VNFDs and store them in dict.
483 for k
, v
in self
.vnfds
.iteritems():
484 for vu
in v
.get("virtual_deployment_units"):
485 if vu
.get("vm_image_format") == "docker":
486 vm_image
= vu
.get("vm_image")
487 docker_path
= os
.path
.join(
488 self
.package_content_path
,
489 make_relative_path(vm_image
))
490 self
.local_docker_files
[k
] = docker_path
491 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
493 def _load_docker_urls(self
):
495 Get all URLs to pre-build docker images in some repo.
498 for k
, v
in self
.vnfds
.iteritems():
499 for vu
in v
.get("virtual_deployment_units"):
500 if vu
.get("vm_image_format") == "docker":
501 url
= vu
.get("vm_image")
503 url
= url
.replace("http://", "")
504 self
.remote_docker_image_urls
[k
] = url
505 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
507 def _build_images_from_dockerfiles(self
):
509 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
511 if GK_STANDALONE_MODE
:
512 return # do not build anything in standalone mode
514 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
515 for k
, v
in self
.local_docker_files
.iteritems():
516 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
517 LOG
.debug("DOCKER BUILD: %s" % line
)
518 LOG
.info("Docker image created: %s" % k
)
520 def _pull_predefined_dockerimages(self
):
522 If the package contains URLs to pre-build Docker images, we download them with this method.
525 for url
in self
.remote_docker_image_urls
.itervalues():
526 if not FORCE_PULL
: # only pull if not present (speedup for development)
527 if len(dc
.images(name
=url
)) > 0:
528 LOG
.debug("Image %r present. Skipping pull." % url
)
530 LOG
.info("Pulling image: %r" % url
)
532 insecure_registry
=True)
534 def _check_docker_image_exists(self
, image_name
):
536 Query the docker service and check if the given image exists
537 :param image_name: name of the docker image
540 return len(DockerClient().images(image_name
)) > 0
542 def _calculate_placement(self
, algorithm
):
544 Do placement by adding the a field "dc" to
545 each VNFD that points to one of our
546 data center objects known to the gatekeeper.
548 assert(len(self
.vnfds
) > 0)
549 assert(len(GK
.dcs
) > 0)
550 # instantiate algorithm an place
552 p
.place(self
.nsd
, self
.vnfds
, GK
.dcs
)
553 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
554 # lets print the placement result
555 for name
, vnfd
in self
.vnfds
.iteritems():
556 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
558 def _calculate_cpu_cfs_values(self
, cpu_time_percentage
):
560 Calculate cpu period and quota for CFS
561 :param cpu_time_percentage: percentage of overall CPU to be used
562 :return: cpu_period, cpu_quota
564 if cpu_time_percentage
is None:
566 if cpu_time_percentage
< 0:
568 # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
569 # Attention minimum cpu_quota is 1ms (micro)
570 cpu_period
= 1000000 # lets consider a fixed period of 1000000 microseconds for now
571 LOG
.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period
, cpu_time_percentage
))
572 cpu_quota
= cpu_period
* cpu_time_percentage
# calculate the fraction of cpu time for this container
573 # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
575 LOG
.debug("cpu_quota before correcting: %r" % cpu_quota
)
577 LOG
.warning("Increased CPU quota to avoid system error.")
578 LOG
.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period
, cpu_quota
))
579 return int(cpu_period
), int(cpu_quota
)
583 Some (simple) placement algorithms
587 class FirstDcPlacement(object):
589 Placement: Always use one and the same data center from the GK.dcs dict.
591 def place(self
, nsd
, vnfds
, dcs
):
592 for name
, vnfd
in vnfds
.iteritems():
593 vnfd
["dc"] = list(dcs
.itervalues())[0]
596 class RoundRobinDcPlacement(object):
598 Placement: Distribute VNFs across all available DCs in a round robin fashion.
600 def place(self
, nsd
, vnfds
, dcs
):
602 dcs_list
= list(dcs
.itervalues())
603 for name
, vnfd
in vnfds
.iteritems():
604 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
605 c
+= 1 # inc. c to use next DC
611 Resource definitions and API endpoints
615 class Packages(fr
.Resource
):
619 Upload a *.son service package to the dummy gatekeeper.
621 We expect request with a *.son file and store it in UPLOAD_FOLDER
627 # lets search for the package in the request
628 if "package" in request
.files
:
629 son_file
= request
.files
["package"]
630 # elif "file" in request.files:
631 # son_file = request.files["file"]
633 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
634 # generate a uuid to reference this package
635 service_uuid
= str(uuid
.uuid4())
636 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
637 # ensure that upload folder exists
638 ensure_dir(UPLOAD_FOLDER
)
639 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
640 # store *.son file to disk
641 son_file
.save(upload_path
)
642 size
= os
.path
.getsize(upload_path
)
643 # create a service object and register it
644 s
= Service(service_uuid
, file_hash
, upload_path
)
645 GK
.register_service_package(service_uuid
, s
)
646 # generate the JSON result
647 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
648 except Exception as ex
:
649 LOG
.exception("Service package upload failed:")
650 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
654 Return a list of UUID's of uploaded service packages.
657 LOG
.info("GET /packages")
658 return {"service_uuid_list": list(GK
.services
.iterkeys())}
661 class Instantiations(fr
.Resource
):
665 Instantiate a service specified by its UUID.
666 Will return a new UUID to identify the running service instance.
669 # try to extract the service uuid from the request
670 json_data
= request
.get_json(force
=True)
671 service_uuid
= json_data
.get("service_uuid")
673 # lets be a bit fuzzy here to make testing easier
674 if service_uuid
is None and len(GK
.services
) > 0:
675 # if we don't get a service uuid, we simple start the first service in the list
676 service_uuid
= list(GK
.services
.iterkeys())[0]
678 if service_uuid
in GK
.services
:
679 # ok, we have a service uuid, lets start the service
680 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
681 return {"service_instance_uuid": service_instance_uuid
}, 201
682 return "Service not found", 404
686 Returns a list of UUIDs containing all running services.
689 LOG
.info("GET /instantiations")
690 return {"service_instantiations_list": [
691 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
695 Stops a running service specified by its service and instance UUID.
697 # try to extract the service and instance UUID from the request
698 json_data
= request
.get_json(force
=True)
699 service_uuid
= json_data
.get("service_uuid")
700 instance_uuid
= json_data
.get("service_instance_uuid")
703 if service_uuid
is None and len(GK
.services
) > 0:
704 #if we don't get a service uuid, we simply stop the last service in the list
705 service_uuid
= list(GK
.services
.iterkeys())[0]
706 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
707 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
709 if service_uuid
in GK
.services
and instance_uuid
in GK
.services
[service_uuid
].instances
:
710 # valid service and instance UUID, stop service
711 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
712 return "service instance with uuid %r stopped." % instance_uuid
,200
713 return "Service not found", 404
715 class Exit(fr
.Resource
):
719 Stop the running Containernet instance regardless of data transmitted
721 list(GK
.dcs
.values())[0].net
.stop()
730 # create a single, global GK object
734 app
= Flask(__name__
)
735 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
738 api
.add_resource(Packages
, '/packages')
739 api
.add_resource(Instantiations
, '/instantiations')
740 api
.add_resource(Exit
, '/emulator/exit')
743 #def initialize_GK():
748 def start_rest_api(host
, port
, datacenters
=dict()):
750 # start the Flask server (not the best performance but ok for our use case)
754 use_reloader
=False # this is needed to run Flask in a non-main thread
758 def ensure_dir(name
):
759 if not os
.path
.exists(name
):
764 with
open(path
, "r") as f
:
767 except yaml
.YAMLError
as exc
:
768 LOG
.exception("YAML parse error")
773 def make_relative_path(path
):
774 if path
.startswith("file://"):
775 path
= path
.replace("file://", "", 1)
776 if path
.startswith("/"):
777 path
= path
.replace("/", "", 1)
781 def generate_lan_string(prefix
, base
, subnet_size
=24, ip
=0):
783 Helper to generate different network configuration strings.
785 r
= "%s.%d.%d/%d" % (prefix
, base
, ip
, subnet_size
)
789 def generate_subnet_strings(n
, start
=1, subnet_size
=24, ip
=0):
791 Helper to generate different network configuration strings.
794 for i
in range(start
, start
+ n
):
795 r
.append("%d.0.0.%d/%d" % (i
, ip
, subnet_size
))
799 if __name__
== '__main__':
801 Lets allow to run the API in standalone mode.
803 GK_STANDALONE_MODE
= True
804 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
805 start_rest_api("0.0.0.0", 8000)