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 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")]
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
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(":")
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
196 src_docker_name
= src_id
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
202 dst_docker_name
= dst_id
204 src_name
= vnf_id2vnf_name
[src_id
]
205 dst_name
= vnf_id2vnf_name
[dst_id
]
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
))
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)
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))
227 # 4b. deploy E-LAN links
229 for link
in elan_fwd_links
:
230 # generate lan ip address
232 for intf
in link
["connection_points_reference"]:
233 ip_address
= generate_lan_string("10.0", base
, subnet_size
=24, ip
=ip
)
234 vnf_id
, intf_name
= intf
.split(":")
235 if vnf_id
in self
.sap_identifiers
:
236 src_docker_name
= "{0}_{1}".format(vnf_id
, intf_name
)
237 vnf_id
= src_docker_name
238 vnf_name
= vnf_id2vnf_name
[vnf_id
]
240 "Setting up E-LAN link. %s(%s:%s) -> %s" % (
241 vnf_name
, vnf_id
, intf_name
, ip_address
))
243 if vnf_name
in self
.vnfds
:
244 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
245 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
246 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
247 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_name
)
249 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
250 # increase for the next ip address on this E-LAN
252 # increase the base ip address for the next E-LAN
255 # 5. run the emulator specific entrypoint scripts in the VNFIs of this service instance
256 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
258 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
261 def stop_service(self
, instance_uuid
):
263 This method stops a running service instance.
264 It iterates over all VNFDs, stopping them each
265 and removing them from their data center.
269 LOG
.info("Stopping service %r" % self
.uuid
)
270 # get relevant information
271 # instance_uuid = str(self.uuid.uuid4())
272 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
274 for v
in vnf_instances
:
277 if not GK_STANDALONE_MODE
:
279 # self._remove_placement(RoundRobinPlacement)
282 # last step: remove the instance from the list of all instances
283 del self
.instances
[instance_uuid
]
288 def _start_vnfd(self
, vnfd
):
290 Start a single VNFD of this service
291 :param vnfd: vnfd descriptor dict
294 # iterate over all deployment units within each VNFDs
295 for u
in vnfd
.get("virtual_deployment_units"):
296 # 1. get the name of the docker image to start and the assigned DC
297 vnf_name
= vnfd
.get("name")
298 if vnf_name
not in self
.remote_docker_image_urls
:
299 raise Exception("No image name for %r found. Abort." % vnf_name
)
300 docker_name
= self
.remote_docker_image_urls
.get(vnf_name
)
301 target_dc
= vnfd
.get("dc")
302 # 2. perform some checks to ensure we can start the container
303 assert(docker_name
is not None)
304 assert(target_dc
is not None)
305 if not self
._check
_docker
_image
_exists
(docker_name
):
306 raise Exception("Docker image %r not found. Abort." % docker_name
)
307 # 3. do the dc.startCompute(name="foobar") call to run the container
308 # TODO consider flavors, and other annotations
309 intfs
= vnfd
.get("connection_points")
311 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
312 # use the vnf_id in the nsd as docker name
313 # so deployed containers can be easily mapped back to the nsd
314 vnf_name2id
= defaultdict(lambda: "NotExistingNode",
315 reduce(lambda x
, y
: dict(x
, **y
),
316 map(lambda d
: {d
["vnf_name"]: d
["vnf_id"]},
317 self
.nsd
["network_functions"])))
318 self
.vnf_name2docker_name
[vnf_name
] = vnf_name2id
[vnf_name
]
319 # self.vnf_name2docker_name[vnf_name] = GK.get_next_vnf_name()
321 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, self
.vnf_name2docker_name
[vnf_name
], vnfd
.get("dc")))
322 LOG
.debug("Interfaces for %r: %r" % (vnf_name
, intfs
))
323 vnfi
= target_dc
.startCompute(self
.vnf_name2docker_name
[vnf_name
], network
=intfs
, image
=docker_name
, flavor_name
="small")
326 def _stop_vnfd(self
, vnfi
):
328 Stop a VNFD specified by its name.
330 :param vnf_name: Name of the vnf to be stopped
333 # if vnf_name not in self.vnfds:
334 # raise Exception("VNFD with name %s not found." % vnf_name)
335 # Find the correct datacenter
336 status
= vnfi
.getStatus()
339 LOG
.info("Stopping the vnf instance contained in %r ind DC %r" % (status
["name"], dc
))
340 dc
.stopCompute(status
["name"])
342 def _get_vnf_instance(self
, instance_uuid
, name
):
344 Returns the Docker object for the given VNF name (or Docker name).
345 :param instance_uuid: UUID of the service instance to search in.
346 :param name: VNF name or Docker name. We are fuzzy here.
350 if name
in self
.vnf_name2docker_name
:
351 dn
= self
.vnf_name2docker_name
[name
]
352 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
355 LOG
.warning("No container with name: %r found.")
359 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
):
361 Reconfigure the network configuration of a specific interface
362 of a running container.
363 :param vnfi: container instacne
364 :param if_name: interface name
365 :param net_str: network configuration string, e.g., 1.2.3.4/24
368 intf
= vnfi
.intf(intf
=if_name
)
371 LOG
.debug("Reconfigured network of %s:%s to %r" % (vnfi
.name
, if_name
, net_str
))
373 LOG
.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi
.name
, if_name
))
376 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
377 for vnfi
in vnfi_list
:
378 config
= vnfi
.dcinfo
.get("Config", dict())
379 env
= config
.get("Env", list())
381 if "SON_EMU_CMD=" in env_var
:
382 cmd
= str(env_var
.split("=")[1])
383 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
384 # execute command in new thread to ensure that GK is not blocked by VNF
385 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
389 def _unpack_service_package(self
):
391 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
393 LOG
.info("Unzipping: %r" % self
.package_file_path
)
394 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
395 z
.extractall(self
.package_content_path
)
398 def _load_package_descriptor(self
):
400 Load the main package descriptor YAML and keep it as dict.
403 self
.manifest
= load_yaml(
405 self
.package_content_path
, "META-INF/MANIFEST.MF"))
409 Load the entry NSD YAML and keep it as dict.
412 if "entry_service_template" in self
.manifest
:
413 nsd_path
= os
.path
.join(
414 self
.package_content_path
,
415 make_relative_path(self
.manifest
.get("entry_service_template")))
416 self
.nsd
= load_yaml(nsd_path
)
417 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
419 def _load_vnfd(self
):
421 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
424 if "package_content" in self
.manifest
:
425 for pc
in self
.manifest
.get("package_content"):
426 if pc
.get("content-type") == "application/sonata.function_descriptor":
427 vnfd_path
= os
.path
.join(
428 self
.package_content_path
,
429 make_relative_path(pc
.get("name")))
430 vnfd
= load_yaml(vnfd_path
)
431 self
.vnfds
[vnfd
.get("name")] = vnfd
432 LOG
.debug("Loaded VNFD: %r" % vnfd
.get("name"))
434 def _load_saps(self
):
435 # Each Service Access Point (connection_point) in the nsd is getting its own container
436 SAPs
= [p
["id"] for p
in self
.nsd
["connection_points"] if p
["type"] == "interface"]
438 # endpoints needed in this service
439 sap_vnf_id
, sap_vnf_interface
= sap
.split(':')
440 # set of the connection_point ids found in the nsd (in the examples this is 'ns')
441 self
.sap_identifiers
.add(sap_vnf_id
)
443 sap_docker_name
= "%s_%s" % (sap_vnf_id
, sap_vnf_interface
)
445 # add SAP to self.vnfds
446 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
447 sap_vnfd
= load_yaml(sapfile
)
448 sap_vnfd
["connection_points"][0]["id"] = sap_vnf_interface
449 sap_vnfd
["name"] = sap_docker_name
450 self
.vnfds
[sap_docker_name
] = sap_vnfd
451 # add SAP vnf to list in the NSD so it is deployed later on
452 # each SAP get a unique VNFD and vnf_id in the NSD
453 self
.nsd
["network_functions"].append({"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
})
454 LOG
.debug("Loaded SAP: %r" % sap_vnfd
.get("name"))
456 def _load_docker_files(self
):
458 Get all paths to Dockerfiles from VNFDs and store them in dict.
461 for k
, v
in self
.vnfds
.iteritems():
462 for vu
in v
.get("virtual_deployment_units"):
463 if vu
.get("vm_image_format") == "docker":
464 vm_image
= vu
.get("vm_image")
465 docker_path
= os
.path
.join(
466 self
.package_content_path
,
467 make_relative_path(vm_image
))
468 self
.local_docker_files
[k
] = docker_path
469 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
471 def _load_docker_urls(self
):
473 Get all URLs to pre-build docker images in some repo.
476 for k
, v
in self
.vnfds
.iteritems():
477 for vu
in v
.get("virtual_deployment_units"):
478 if vu
.get("vm_image_format") == "docker":
479 url
= vu
.get("vm_image")
481 url
= url
.replace("http://", "")
482 self
.remote_docker_image_urls
[k
] = url
483 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
485 def _build_images_from_dockerfiles(self
):
487 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
489 if GK_STANDALONE_MODE
:
490 return # do not build anything in standalone mode
492 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
493 for k
, v
in self
.local_docker_files
.iteritems():
494 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
495 LOG
.debug("DOCKER BUILD: %s" % line
)
496 LOG
.info("Docker image created: %s" % k
)
498 def _pull_predefined_dockerimages(self
):
500 If the package contains URLs to pre-build Docker images, we download them with this method.
503 for url
in self
.remote_docker_image_urls
.itervalues():
504 if not FORCE_PULL
: # only pull if not present (speedup for development)
505 if len(dc
.images(name
=url
)) > 0:
506 LOG
.debug("Image %r present. Skipping pull." % url
)
508 LOG
.info("Pulling image: %r" % url
)
510 insecure_registry
=True)
512 def _check_docker_image_exists(self
, image_name
):
514 Query the docker service and check if the given image exists
515 :param image_name: name of the docker image
518 return len(DockerClient().images(image_name
)) > 0
520 def _calculate_placement(self
, algorithm
):
522 Do placement by adding the a field "dc" to
523 each VNFD that points to one of our
524 data center objects known to the gatekeeper.
526 assert(len(self
.vnfds
) > 0)
527 assert(len(GK
.dcs
) > 0)
528 # instantiate algorithm an place
530 p
.place(self
.nsd
, self
.vnfds
, GK
.dcs
)
531 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
532 # lets print the placement result
533 for name
, vnfd
in self
.vnfds
.iteritems():
534 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
538 Some (simple) placement algorithms
542 class FirstDcPlacement(object):
544 Placement: Always use one and the same data center from the GK.dcs dict.
546 def place(self
, nsd
, vnfds
, dcs
):
547 for name
, vnfd
in vnfds
.iteritems():
548 vnfd
["dc"] = list(dcs
.itervalues())[0]
551 class RoundRobinDcPlacement(object):
553 Placement: Distribute VNFs across all available DCs in a round robin fashion.
555 def place(self
, nsd
, vnfds
, dcs
):
557 dcs_list
= list(dcs
.itervalues())
558 for name
, vnfd
in vnfds
.iteritems():
559 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
560 c
+= 1 # inc. c to use next DC
566 Resource definitions and API endpoints
570 class Packages(fr
.Resource
):
574 Upload a *.son service package to the dummy gatekeeper.
576 We expect request with a *.son file and store it in UPLOAD_FOLDER
582 # lets search for the package in the request
583 if "package" in request
.files
:
584 son_file
= request
.files
["package"]
585 # elif "file" in request.files:
586 # son_file = request.files["file"]
588 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
589 # generate a uuid to reference this package
590 service_uuid
= str(uuid
.uuid4())
591 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
592 # ensure that upload folder exists
593 ensure_dir(UPLOAD_FOLDER
)
594 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
595 # store *.son file to disk
596 son_file
.save(upload_path
)
597 size
= os
.path
.getsize(upload_path
)
598 # create a service object and register it
599 s
= Service(service_uuid
, file_hash
, upload_path
)
600 GK
.register_service_package(service_uuid
, s
)
601 # generate the JSON result
602 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
603 except Exception as ex
:
604 LOG
.exception("Service package upload failed:")
605 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
609 Return a list of UUID's of uploaded service packages.
612 LOG
.info("GET /packages")
613 return {"service_uuid_list": list(GK
.services
.iterkeys())}
616 class Instantiations(fr
.Resource
):
620 Instantiate a service specified by its UUID.
621 Will return a new UUID to identify the running service instance.
624 # try to extract the service uuid from the request
625 json_data
= request
.get_json(force
=True)
626 service_uuid
= json_data
.get("service_uuid")
628 # lets be a bit fuzzy here to make testing easier
629 if service_uuid
is None and len(GK
.services
) > 0:
630 # if we don't get a service uuid, we simple start the first service in the list
631 service_uuid
= list(GK
.services
.iterkeys())[0]
633 if service_uuid
in GK
.services
:
634 # ok, we have a service uuid, lets start the service
635 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
636 return {"service_instance_uuid": service_instance_uuid
}
637 return "Service not found", 404
641 Returns a list of UUIDs containing all running services.
644 LOG
.info("GET /instantiations")
645 return {"service_instantiations_list": [
646 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
650 Stops a running service specified by its UUID.
654 # try to extract the service UUID from the request
655 json_data
= request
.get_json(force
=True)
656 service_uuid
= json_data
.get("service_uuid")
657 instance_uuid
= json_data
.get("instance_uuid")
660 if service_uuid
is None and len(GK
.services
) > 0:
661 #if we don't get a service uuid, we simply stop the last service in the list
662 service_uuid
= list(GK
.services
.iterkeys())[0]
663 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
664 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
666 if service_uuid
in GK
.services
:
667 # valid service UUID, stop service
668 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
670 return "Service not found", 404
672 class Exit(fr
.Resource
): # name not final
676 Stop the running Containernet instance regardless of data transmitted
678 # First, close the mininet CLI
680 # Second, stop the network
681 service
= GK
.services
[GK
.services
.keys
[0]]
682 network
= service
.vnfds
[service
.vnfds
.keys
[0]].get("dc").net
# there should be a cleaner way to find the DCNetwork
686 # create a single, global GK object
689 app
= Flask(__name__
)
690 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
693 api
.add_resource(Packages
, '/packages')
694 api
.add_resource(Instantiations
, '/instantiations')
695 api
.add_resource(Exit
, '/emulator/exit') # name not final TODO change it or remove TODO
698 def start_rest_api(host
, port
, datacenters
=dict()):
700 # start the Flask server (not the best performance but ok for our use case)
704 use_reloader
=False # this is needed to run Flask in a non-main thread
708 def ensure_dir(name
):
709 if not os
.path
.exists(name
):
714 with
open(path
, "r") as f
:
717 except yaml
.YAMLError
as exc
:
718 LOG
.exception("YAML parse error")
723 def make_relative_path(path
):
724 if path
.startswith("file://"):
725 path
= path
.replace("file://", "", 1)
726 if path
.startswith("/"):
727 path
= path
.replace("/", "", 1)
731 def generate_lan_string(prefix
, base
, subnet_size
=24, ip
=0):
733 Helper to generate different network configuration strings.
735 r
= "%s.%d.%d/%d" % (prefix
, base
, ip
, subnet_size
)
739 def generate_subnet_strings(n
, start
=1, subnet_size
=24, ip
=0):
741 Helper to generate different network configuration strings.
744 for i
in range(start
, start
+ n
):
745 r
.append("%d.0.0.%d/%d" % (i
, ip
, subnet_size
))
749 if __name__
== '__main__':
751 Lets allow to run the API in standalone mode.
753 GK_STANDALONE_MODE
= True
754 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
755 start_rest_api("0.0.0.0", 8000)