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 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()
79 self
.vnf_counter
= 0 # used to generate short names for VNFs (Mininet limitation)
80 LOG
.info("Create SONATA dummy gatekeeper.")
82 def register_service_package(self
, service_uuid
, service
):
84 register new service package
88 self
.services
[service_uuid
] = service
89 # lets perform all steps needed to onboard the service
92 def get_next_vnf_name(self
):
94 return "vnf%d" % self
.vnf_counter
97 class Service(object):
99 This class represents a NS uploaded as a *.son package to the
101 Can have multiple running instances of this service.
108 self
.uuid
= service_uuid
109 self
.package_file_hash
= package_file_hash
110 self
.package_file_path
= package_file_path
111 self
.package_content_path
= os
.path
.join(CATALOG_FOLDER
, "services/%s" % self
.uuid
)
115 self
.local_docker_files
= dict()
116 self
.remote_docker_image_urls
= dict()
117 self
.instances
= dict()
118 self
.vnf_name2docker_name
= dict()
119 self
.sap_identifiers
= set()
120 # lets generate a set of subnet configurations used for e-line chaining setup
121 self
.eline_subnets_src
= generate_subnet_strings(50, start
=200, subnet_size
=24, ip
=1)
122 self
.eline_subnets_dst
= generate_subnet_strings(50, start
=200, subnet_size
=24, ip
=2)
126 Do all steps to prepare this service to be instantiated
129 # 1. extract the contents of the package and store them in our catalog
130 self
._unpack
_service
_package
()
131 # 2. read in all descriptor files
132 self
._load
_package
_descriptor
()
137 # 3. prepare container images (e.g. download or build Dockerfile)
139 self
._load
_docker
_files
()
140 self
._build
_images
_from
_dockerfiles
()
142 self
._load
_docker
_urls
()
143 self
._pull
_predefined
_dockerimages
()
144 LOG
.info("On-boarded service: %r" % self
.manifest
.get("name"))
146 def start_service(self
):
148 This methods creates and starts a new service instance.
149 It computes placements, iterates over all VNFDs, and starts
150 each VNFD as a Docker container in the data center selected
151 by the placement algorithm.
154 LOG
.info("Starting service %r" % self
.uuid
)
156 # 1. each service instance gets a new uuid to identify it
157 instance_uuid
= str(uuid
.uuid4())
158 # build a instances dict (a bit like a NSR :))
159 self
.instances
[instance_uuid
] = dict()
160 self
.instances
[instance_uuid
]["vnf_instances"] = list()
162 # 2. Configure the chaining of the network functions (currently only E-Line and E-LAN links supported)
163 vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
164 reduce(lambda x
, y
: dict(x
, **y
),
165 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
166 self
.nsd
["network_functions"])))
168 # 3. compute placement of this service instance (adds DC names to VNFDs)
169 if not GK_STANDALONE_MODE
:
170 #self._calculate_placement(FirstDcPlacement)
171 self
._calculate
_placement
(RoundRobinDcPlacement
)
172 # iterate over all vnfds that we have to start
173 for vnfd
in self
.vnfds
.itervalues():
175 if not GK_STANDALONE_MODE
:
176 vnfi
= self
._start
_vnfd
(vnfd
)
177 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
179 if "virtual_links" in self
.nsd
:
180 vlinks
= self
.nsd
["virtual_links"]
181 fwd_links
= self
.nsd
["forwarding_graphs"][0]["constituent_virtual_links"]
182 eline_fwd_links
= [l
for l
in vlinks
if (l
["id"] in fwd_links
) and (l
["connectivity_type"] == "E-Line")]
183 elan_fwd_links
= [l
for l
in vlinks
if (l
["id"] in fwd_links
) and (l
["connectivity_type"] == "E-LAN")]
185 GK
.net
.deployed_elines
.extend(eline_fwd_links
)
186 GK
.net
.deployed_elans
.extend(elan_fwd_links
)
188 # 4a. deploy E-Line links
189 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
190 # eg. different services get a unique cookie for their flowrules
192 for link
in eline_fwd_links
:
193 src_id
, src_if_name
= link
["connection_points_reference"][0].split(":")
194 dst_id
, dst_if_name
= link
["connection_points_reference"][1].split(":")
196 # check if there is a SAP in the link
197 if src_id
in self
.sap_identifiers
:
198 src_docker_name
= "{0}_{1}".format(src_id
, src_if_name
)
199 src_id
= src_docker_name
201 src_docker_name
= src_id
203 if dst_id
in self
.sap_identifiers
:
204 dst_docker_name
= "{0}_{1}".format(dst_id
, dst_if_name
)
205 dst_id
= dst_docker_name
207 dst_docker_name
= dst_id
209 src_name
= vnf_id2vnf_name
[src_id
]
210 dst_name
= vnf_id2vnf_name
[dst_id
]
213 "Setting up E-Line link. %s(%s:%s) -> %s(%s:%s)" % (
214 src_name
, src_id
, src_if_name
, dst_name
, dst_id
, dst_if_name
))
216 if (src_name
in self
.vnfds
) and (dst_name
in self
.vnfds
):
217 network
= self
.vnfds
[src_name
].get("dc").net
# there should be a cleaner way to find the DCNetwork
218 LOG
.debug(src_docker_name
)
219 ret
= network
.setChain(
220 src_docker_name
, dst_docker_name
,
221 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
222 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
224 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
225 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_name
)
226 if src_vnfi
is not None:
227 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, self
.eline_subnets_src
.pop(0))
228 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_name
)
229 if dst_vnfi
is not None:
230 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, self
.eline_subnets_dst
.pop(0))
232 # 4b. deploy E-LAN links
234 for link
in elan_fwd_links
:
238 # generate lan ip address
240 for intf
in link
["connection_points_reference"]:
241 ip_address
= generate_lan_string("10.0", base
, subnet_size
=24, ip
=ip
)
242 vnf_id
, intf_name
= intf
.split(":")
243 if vnf_id
in self
.sap_identifiers
:
244 src_docker_name
= "{0}_{1}".format(vnf_id
, intf_name
)
245 vnf_id
= src_docker_name
247 src_docker_name
= vnf_id
248 vnf_name
= vnf_id2vnf_name
[vnf_id
]
250 "Setting up E-LAN link. %s(%s:%s) -> %s" % (
251 vnf_name
, vnf_id
, intf_name
, ip_address
))
253 if vnf_name
in self
.vnfds
:
254 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
255 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
256 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
257 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_name
)
259 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
260 # increase for the next ip address on this E-LAN
263 # add this vnf and interface to the E-LAN for tagging
264 network
= self
.vnfds
[vnf_name
].get("dc").net
# there should be a cleaner way to find the DCNetwork
265 elan_vnf_list
.append({'name':src_docker_name
,'interface':intf_name
})
268 # install the VLAN tags for this E-LAN
269 network
.setLAN(elan_vnf_list
)
270 # increase the base ip address for the next E-LAN
273 # 5. run the emulator specific entrypoint scripts in the VNFIs of this service instance
274 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
276 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
279 def stop_service(self
, instance_uuid
):
281 This method stops a running service instance.
282 It iterates over all VNF instances, stopping them each
283 and removing them from their data center.
285 :param instance_uuid: the uuid of the service instance to be stopped
287 LOG
.info("Stopping service %r" % self
.uuid
)
288 # get relevant information
289 # instance_uuid = str(self.uuid.uuid4())
290 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
292 for v
in vnf_instances
:
295 if not GK_STANDALONE_MODE
:
297 # self._remove_placement(RoundRobinPlacement)
300 # last step: remove the instance from the list of all instances
301 del self
.instances
[instance_uuid
]
303 def _start_vnfd(self
, vnfd
):
305 Start a single VNFD of this service
306 :param vnfd: vnfd descriptor dict
309 # iterate over all deployment units within each VNFDs
310 for u
in vnfd
.get("virtual_deployment_units"):
311 # 1. get the name of the docker image to start and the assigned DC
312 vnf_name
= vnfd
.get("name")
313 if vnf_name
not in self
.remote_docker_image_urls
:
314 raise Exception("No image name for %r found. Abort." % vnf_name
)
315 docker_name
= self
.remote_docker_image_urls
.get(vnf_name
)
316 target_dc
= vnfd
.get("dc")
317 # 2. perform some checks to ensure we can start the container
318 assert(docker_name
is not None)
319 assert(target_dc
is not None)
320 if not self
._check
_docker
_image
_exists
(docker_name
):
321 raise Exception("Docker image %r not found. Abort." % docker_name
)
323 # 3. get the resource limits
324 res_req
= u
.get("resource_requirements")
325 cpu_list
= res_req
.get("cpu").get("cores")
326 if not cpu_list
or len(cpu_list
)==0:
328 cpu_bw
= res_req
.get("cpu").get("cpu_bw")
331 mem_num
= str(res_req
.get("memory").get("size"))
334 mem_unit
= str(res_req
.get("memory").get("size_unit"))
337 mem_limit
= float(mem_num
)
339 mem_limit
=mem_limit
*1024*1024*1024
341 mem_limit
=mem_limit
*1024*1024
343 mem_limit
=mem_limit
*1024
344 mem_lim
= int(mem_limit
)
345 cpu_period
, cpu_quota
= self
._calculate
_cpu
_cfs
_values
(float(cpu_bw
))
347 # 4. do the dc.startCompute(name="foobar") call to run the container
348 # TODO consider flavors, and other annotations
349 intfs
= vnfd
.get("connection_points")
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 vnf_name2id
= defaultdict(lambda: "NotExistingNode",
355 reduce(lambda x
, y
: dict(x
, **y
),
356 map(lambda d
: {d
["vnf_name"]: d
["vnf_id"]},
357 self
.nsd
["network_functions"])))
358 self
.vnf_name2docker_name
[vnf_name
] = vnf_name2id
[vnf_name
]
359 # self.vnf_name2docker_name[vnf_name] = GK.get_next_vnf_name()
361 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, self
.vnf_name2docker_name
[vnf_name
], vnfd
.get("dc")))
362 LOG
.debug("Interfaces for %r: %r" % (vnf_name
, intfs
))
363 vnfi
= target_dc
.startCompute(self
.vnf_name2docker_name
[vnf_name
], network
=intfs
, image
=docker_name
, flavor_name
="small",
364 cpu_quota
=cpu_quota
, cpu_period
=cpu_period
, cpuset
=cpu_list
, mem_limit
=mem_lim
)
367 def _stop_vnfi(self
, vnfi
):
371 :param vnfi: vnf instance to be stopped
373 # Find the correct datacenter
374 status
= vnfi
.getStatus()
377 LOG
.info("Stopping the vnf instance contained in %r in DC %r" % (status
["name"], dc
))
378 dc
.stopCompute(status
["name"])
380 def _get_vnf_instance(self
, instance_uuid
, name
):
382 Returns the Docker object for the given VNF name (or Docker name).
383 :param instance_uuid: UUID of the service instance to search in.
384 :param name: VNF name or Docker name. We are fuzzy here.
388 if name
in self
.vnf_name2docker_name
:
389 dn
= self
.vnf_name2docker_name
[name
]
390 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
393 LOG
.warning("No container with name: %r found.")
397 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
):
399 Reconfigure the network configuration of a specific interface
400 of a running container.
401 :param vnfi: container instacne
402 :param if_name: interface name
403 :param net_str: network configuration string, e.g., 1.2.3.4/24
406 intf
= vnfi
.intf(intf
=if_name
)
409 LOG
.debug("Reconfigured network of %s:%s to %r" % (vnfi
.name
, if_name
, net_str
))
411 LOG
.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi
.name
, if_name
))
414 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
415 for vnfi
in vnfi_list
:
416 config
= vnfi
.dcinfo
.get("Config", dict())
417 env
= config
.get("Env", list())
419 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
420 LOG
.debug("%r = %r" % (var
, cmd
))
421 if var
=="SON_EMU_CMD":
422 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
423 # execute command in new thread to ensure that GK is not blocked by VNF
424 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
428 def _unpack_service_package(self
):
430 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
432 LOG
.info("Unzipping: %r" % self
.package_file_path
)
433 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
434 z
.extractall(self
.package_content_path
)
437 def _load_package_descriptor(self
):
439 Load the main package descriptor YAML and keep it as dict.
442 self
.manifest
= load_yaml(
444 self
.package_content_path
, "META-INF/MANIFEST.MF"))
448 Load the entry NSD YAML and keep it as dict.
451 if "entry_service_template" in self
.manifest
:
452 nsd_path
= os
.path
.join(
453 self
.package_content_path
,
454 make_relative_path(self
.manifest
.get("entry_service_template")))
455 self
.nsd
= load_yaml(nsd_path
)
456 GK
.net
.deployed_nsds
.append(self
.nsd
)
457 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
459 def _load_vnfd(self
):
461 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
464 if "package_content" in self
.manifest
:
465 for pc
in self
.manifest
.get("package_content"):
466 if pc
.get("content-type") == "application/sonata.function_descriptor":
467 vnfd_path
= os
.path
.join(
468 self
.package_content_path
,
469 make_relative_path(pc
.get("name")))
470 vnfd
= load_yaml(vnfd_path
)
471 self
.vnfds
[vnfd
.get("name")] = vnfd
472 LOG
.debug("Loaded VNFD: %r" % vnfd
.get("name"))
474 def _load_saps(self
):
475 # Each Service Access Point (connection_point) in the nsd is getting its own container
476 SAPs
= [p
["id"] for p
in self
.nsd
["connection_points"] if p
["type"] == "interface"]
478 # endpoints needed in this service
479 sap_vnf_id
, sap_vnf_interface
= sap
.split(':')
480 # set of the connection_point ids found in the nsd (in the examples this is 'ns')
481 self
.sap_identifiers
.add(sap_vnf_id
)
483 sap_docker_name
= "%s_%s" % (sap_vnf_id
, sap_vnf_interface
)
485 # add SAP to self.vnfds
486 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
487 sap_vnfd
= load_yaml(sapfile
)
488 sap_vnfd
["connection_points"][0]["id"] = sap_vnf_interface
489 sap_vnfd
["name"] = sap_docker_name
490 self
.vnfds
[sap_docker_name
] = sap_vnfd
491 # add SAP vnf to list in the NSD so it is deployed later on
492 # each SAP get a unique VNFD and vnf_id in the NSD
493 self
.nsd
["network_functions"].append({"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
})
494 LOG
.debug("Loaded SAP: %r" % sap_vnfd
.get("name"))
496 def _load_docker_files(self
):
498 Get all paths to Dockerfiles from VNFDs and store them in dict.
501 for k
, v
in self
.vnfds
.iteritems():
502 for vu
in v
.get("virtual_deployment_units"):
503 if vu
.get("vm_image_format") == "docker":
504 vm_image
= vu
.get("vm_image")
505 docker_path
= os
.path
.join(
506 self
.package_content_path
,
507 make_relative_path(vm_image
))
508 self
.local_docker_files
[k
] = docker_path
509 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
511 def _load_docker_urls(self
):
513 Get all URLs to pre-build docker images in some repo.
516 for k
, v
in self
.vnfds
.iteritems():
517 for vu
in v
.get("virtual_deployment_units"):
518 if vu
.get("vm_image_format") == "docker":
519 url
= vu
.get("vm_image")
521 url
= url
.replace("http://", "")
522 self
.remote_docker_image_urls
[k
] = url
523 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
525 def _build_images_from_dockerfiles(self
):
527 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
529 if GK_STANDALONE_MODE
:
530 return # do not build anything in standalone mode
532 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
533 for k
, v
in self
.local_docker_files
.iteritems():
534 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
535 LOG
.debug("DOCKER BUILD: %s" % line
)
536 LOG
.info("Docker image created: %s" % k
)
538 def _pull_predefined_dockerimages(self
):
540 If the package contains URLs to pre-build Docker images, we download them with this method.
543 for url
in self
.remote_docker_image_urls
.itervalues():
544 if not FORCE_PULL
: # only pull if not present (speedup for development)
545 if len(dc
.images
.list(name
=url
)) > 0:
546 LOG
.debug("Image %r present. Skipping pull." % url
)
548 LOG
.info("Pulling image: %r" % url
)
550 insecure_registry
=True)
552 def _check_docker_image_exists(self
, image_name
):
554 Query the docker service and check if the given image exists
555 :param image_name: name of the docker image
558 return len(DockerClient().images
.list(name
=image_name
)) > 0
560 def _calculate_placement(self
, algorithm
):
562 Do placement by adding the a field "dc" to
563 each VNFD that points to one of our
564 data center objects known to the gatekeeper.
566 assert(len(self
.vnfds
) > 0)
567 assert(len(GK
.dcs
) > 0)
568 # instantiate algorithm an place
570 p
.place(self
.nsd
, self
.vnfds
, GK
.dcs
)
571 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
572 # lets print the placement result
573 for name
, vnfd
in self
.vnfds
.iteritems():
574 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
576 def _calculate_cpu_cfs_values(self
, cpu_time_percentage
):
578 Calculate cpu period and quota for CFS
579 :param cpu_time_percentage: percentage of overall CPU to be used
580 :return: cpu_period, cpu_quota
582 if cpu_time_percentage
is None:
584 if cpu_time_percentage
< 0:
586 # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
587 # Attention minimum cpu_quota is 1ms (micro)
588 cpu_period
= 1000000 # lets consider a fixed period of 1000000 microseconds for now
589 LOG
.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period
, cpu_time_percentage
))
590 cpu_quota
= cpu_period
* cpu_time_percentage
# calculate the fraction of cpu time for this container
591 # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
593 LOG
.debug("cpu_quota before correcting: %r" % cpu_quota
)
595 LOG
.warning("Increased CPU quota to avoid system error.")
596 LOG
.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period
, cpu_quota
))
597 return int(cpu_period
), int(cpu_quota
)
601 Some (simple) placement algorithms
605 class FirstDcPlacement(object):
607 Placement: Always use one and the same data center from the GK.dcs dict.
609 def place(self
, nsd
, vnfds
, dcs
):
610 for name
, vnfd
in vnfds
.iteritems():
611 vnfd
["dc"] = list(dcs
.itervalues())[0]
614 class RoundRobinDcPlacement(object):
616 Placement: Distribute VNFs across all available DCs in a round robin fashion.
618 def place(self
, nsd
, vnfds
, dcs
):
620 dcs_list
= list(dcs
.itervalues())
621 for name
, vnfd
in vnfds
.iteritems():
622 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
623 c
+= 1 # inc. c to use next DC
629 Resource definitions and API endpoints
633 class Packages(fr
.Resource
):
637 Upload a *.son service package to the dummy gatekeeper.
639 We expect request with a *.son file and store it in UPLOAD_FOLDER
645 # lets search for the package in the request
646 if "package" in request
.files
:
647 son_file
= request
.files
["package"]
648 # elif "file" in request.files:
649 # son_file = request.files["file"]
651 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
652 # generate a uuid to reference this package
653 service_uuid
= str(uuid
.uuid4())
654 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
655 # ensure that upload folder exists
656 ensure_dir(UPLOAD_FOLDER
)
657 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
658 # store *.son file to disk
659 son_file
.save(upload_path
)
660 size
= os
.path
.getsize(upload_path
)
661 # create a service object and register it
662 s
= Service(service_uuid
, file_hash
, upload_path
)
663 GK
.register_service_package(service_uuid
, s
)
664 # generate the JSON result
665 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
666 except Exception as ex
:
667 LOG
.exception("Service package upload failed:")
668 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
672 Return a list of UUID's of uploaded service packages.
675 LOG
.info("GET /packages")
676 return {"service_uuid_list": list(GK
.services
.iterkeys())}
679 class Instantiations(fr
.Resource
):
683 Instantiate a service specified by its UUID.
684 Will return a new UUID to identify the running service instance.
687 # try to extract the service uuid from the request
688 json_data
= request
.get_json(force
=True)
689 service_uuid
= json_data
.get("service_uuid")
691 # lets be a bit fuzzy here to make testing easier
692 if service_uuid
is None and len(GK
.services
) > 0:
693 # if we don't get a service uuid, we simple start the first service in the list
694 service_uuid
= list(GK
.services
.iterkeys())[0]
696 if service_uuid
in GK
.services
:
697 # ok, we have a service uuid, lets start the service
698 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
699 return {"service_instance_uuid": service_instance_uuid
}, 201
700 return "Service not found", 404
704 Returns a list of UUIDs containing all running services.
707 LOG
.info("GET /instantiations")
708 return {"service_instantiations_list": [
709 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
713 Stops a running service specified by its service and instance UUID.
715 # try to extract the service and instance UUID from the request
716 json_data
= request
.get_json(force
=True)
717 service_uuid
= json_data
.get("service_uuid")
718 instance_uuid
= json_data
.get("service_instance_uuid")
721 if service_uuid
is None and len(GK
.services
) > 0:
722 #if we don't get a service uuid, we simply stop the last service in the list
723 service_uuid
= list(GK
.services
.iterkeys())[0]
724 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
725 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
727 if service_uuid
in GK
.services
and instance_uuid
in GK
.services
[service_uuid
].instances
:
728 # valid service and instance UUID, stop service
729 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
730 return "service instance with uuid %r stopped." % instance_uuid
,200
731 return "Service not found", 404
733 class Exit(fr
.Resource
):
737 Stop the running Containernet instance regardless of data transmitted
739 list(GK
.dcs
.values())[0].net
.stop()
748 # create a single, global GK object
752 app
= Flask(__name__
)
753 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
756 api
.add_resource(Packages
, '/packages')
757 api
.add_resource(Instantiations
, '/instantiations')
758 api
.add_resource(Exit
, '/emulator/exit')
761 #def initialize_GK():
766 def start_rest_api(host
, port
, datacenters
=dict()):
768 GK
.net
= get_dc_network()
769 # start the Flask server (not the best performance but ok for our use case)
773 use_reloader
=False # this is needed to run Flask in a non-main thread
777 def ensure_dir(name
):
778 if not os
.path
.exists(name
):
783 with
open(path
, "r") as f
:
786 except yaml
.YAMLError
as exc
:
787 LOG
.exception("YAML parse error")
792 def make_relative_path(path
):
793 if path
.startswith("file://"):
794 path
= path
.replace("file://", "", 1)
795 if path
.startswith("/"):
796 path
= path
.replace("/", "", 1)
800 def generate_lan_string(prefix
, base
, subnet_size
=24, ip
=0):
802 Helper to generate different network configuration strings.
804 r
= "%s.%d.%d/%d" % (prefix
, base
, ip
, subnet_size
)
808 def generate_subnet_strings(n
, start
=1, subnet_size
=24, ip
=0):
810 Helper to generate different network configuration strings.
813 for i
in range(start
, start
+ n
):
814 r
.append("%d.0.0.%d/%d" % (i
, ip
, subnet_size
))
817 def get_dc_network():
819 retrieve the DCnetwork where this dummygatekeeper (GK) connects to.
820 Assume at least 1 datacenter is connected to this GK, and that all datacenters belong to the same DCNetwork
823 assert (len(GK
.dcs
) > 0)
824 return GK
.dcs
.values()[0].net
826 if __name__
== '__main__':
828 Lets allow to run the API in standalone mode.
830 GK_STANDALONE_MODE
= True
831 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
832 start_rest_api("0.0.0.0", 8000)