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
, APIClient
43 from flask
import Flask
, request
44 import flask_restful
as fr
45 from collections
import defaultdict
47 from subprocess
import Popen
48 from random
import randint
54 LOG
= logging
.getLogger("sonata-dummy-gatekeeper")
55 LOG
.setLevel(logging
.DEBUG
)
56 logging
.getLogger("werkzeug").setLevel(logging
.WARNING
)
58 GK_STORAGE
= "/tmp/son-dummy-gk/"
59 UPLOAD_FOLDER
= os
.path
.join(GK_STORAGE
, "uploads/")
60 CATALOG_FOLDER
= os
.path
.join(GK_STORAGE
, "catalog/")
62 # Enable Dockerfile build functionality
63 BUILD_DOCKERFILE
= False
65 # flag to indicate that we run without the emulator (only the bare API for integration testing)
66 GK_STANDALONE_MODE
= False
68 # should a new version of an image be pulled even if its available
71 # Automatically deploy SAPs (endpoints) of the service as new containers
72 # Attention: This is not a configuration switch but a global variable! Don't change its default value.
75 # flag to indicate if we use bidirectional forwarding rules in the automatic chaining process
76 BIDIRECTIONAL_CHAIN
= False
78 # override the management interfaces in the descriptors with default docker0 interfaces in the containers
79 USE_DOCKER_MGMT
= False
81 # automatically deploy uploaded packages (no need to execute son-access deploy --latest separately)
84 # and also automatically terminate any other running services
87 def generate_subnets(prefix
, base
, subnet_size
=50, mask
=24):
88 # Generate a list of ipaddress in subnets
90 for net
in range(base
, base
+ subnet_size
):
91 subnet
= "{0}.{1}.0/{2}".format(prefix
, net
, mask
)
92 r
.append(ipaddress
.ip_network(unicode(subnet
)))
94 # private subnet definitions for the generated interfaces
96 SAP_SUBNETS
= generate_subnets('10.10', 0, subnet_size
=50, mask
=30)
98 ELAN_SUBNETS
= generate_subnets('10.20', 0, subnet_size
=50, mask
=24)
100 ELINE_SUBNETS
= generate_subnets('10.30', 0, subnet_size
=50, mask
=30)
102 # path to the VNFD for the SAP VNF that is deployed as internal SAP point
105 # Time in seconds to wait for vnf stop scripts to execute fully
106 VNF_STOP_WAIT_TIME
= 5
108 class Gatekeeper(object):
111 self
.services
= dict()
114 self
.vnf_counter
= 0 # used to generate short names for VNFs (Mininet limitation)
115 LOG
.info("Create SONATA dummy gatekeeper.")
117 def register_service_package(self
, service_uuid
, service
):
119 register new service package
121 :param service object
123 self
.services
[service_uuid
] = service
124 # lets perform all steps needed to onboard the service
127 def get_next_vnf_name(self
):
128 self
.vnf_counter
+= 1
129 return "vnf%d" % self
.vnf_counter
132 class Service(object):
134 This class represents a NS uploaded as a *.son package to the
136 Can have multiple running instances of this service.
143 self
.uuid
= service_uuid
144 self
.package_file_hash
= package_file_hash
145 self
.package_file_path
= package_file_path
146 self
.package_content_path
= os
.path
.join(CATALOG_FOLDER
, "services/%s" % self
.uuid
)
151 self
.saps_ext
= list()
152 self
.saps_int
= list()
153 self
.local_docker_files
= dict()
154 self
.remote_docker_image_urls
= dict()
155 self
.instances
= dict()
156 # dict to find the vnf_name for any vnf id
157 self
.vnf_id2vnf_name
= dict()
161 Do all steps to prepare this service to be instantiated
164 # 1. extract the contents of the package and store them in our catalog
165 self
._unpack
_service
_package
()
166 # 2. read in all descriptor files
167 self
._load
_package
_descriptor
()
172 # 3. prepare container images (e.g. download or build Dockerfile)
174 self
._load
_docker
_files
()
175 self
._build
_images
_from
_dockerfiles
()
177 self
._load
_docker
_urls
()
178 self
._pull
_predefined
_dockerimages
()
179 LOG
.info("On-boarded service: %r" % self
.manifest
.get("name"))
181 def start_service(self
):
183 This methods creates and starts a new service instance.
184 It computes placements, iterates over all VNFDs, and starts
185 each VNFD as a Docker container in the data center selected
186 by the placement algorithm.
189 LOG
.info("Starting service %r" % self
.uuid
)
191 # 1. each service instance gets a new uuid to identify it
192 instance_uuid
= str(uuid
.uuid4())
193 # build a instances dict (a bit like a NSR :))
194 self
.instances
[instance_uuid
] = dict()
195 self
.instances
[instance_uuid
]["vnf_instances"] = list()
197 # 2. compute placement of this service instance (adds DC names to VNFDs)
198 if not GK_STANDALONE_MODE
:
199 #self._calculate_placement(FirstDcPlacement)
200 self
._calculate
_placement
(RoundRobinDcPlacementWithSAPs
)
201 # 3. start all vnfds that we have in the service (except SAPs)
202 for vnf_id
in self
.vnfds
:
203 vnfd
= self
.vnfds
[vnf_id
]
205 if not GK_STANDALONE_MODE
:
206 vnfi
= self
._start
_vnfd
(vnfd
, vnf_id
)
207 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
209 # 4. start all SAPs in the service
210 for sap
in self
.saps
:
211 self
._start
_sap
(self
.saps
[sap
], instance_uuid
)
213 # 5. Deploy E-Line and E_LAN links
214 if "virtual_links" in self
.nsd
:
215 vlinks
= self
.nsd
["virtual_links"]
216 # constituent virtual links are not checked
217 #fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
218 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
219 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
221 GK
.net
.deployed_elines
.extend(eline_fwd_links
)
222 GK
.net
.deployed_elans
.extend(elan_fwd_links
)
224 # 5a. deploy E-Line links
225 self
._connect
_elines
(eline_fwd_links
, instance_uuid
)
227 # 5b. deploy E-LAN links
228 self
._connect
_elans
(elan_fwd_links
, instance_uuid
)
230 # 6. run the emulator specific entrypoint scripts in the VNFIs of this service instance
231 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
233 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
236 def stop_service(self
, instance_uuid
):
238 This method stops a running service instance.
239 It iterates over all VNF instances, stopping them each
240 and removing them from their data center.
242 :param instance_uuid: the uuid of the service instance to be stopped
244 LOG
.info("Stopping service %r" % self
.uuid
)
245 # get relevant information
246 # instance_uuid = str(self.uuid.uuid4())
247 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
249 # trigger stop skripts in vnf instances and wait a few seconds for completion
250 self
._trigger
_emulator
_stop
_scripts
_in
_vnfis
(vnf_instances
)
251 time
.sleep(VNF_STOP_WAIT_TIME
)
253 for v
in vnf_instances
:
256 for sap_name
in self
.saps_ext
:
257 ext_sap
= self
.saps
[sap_name
]
258 target_dc
= ext_sap
.get("dc")
259 target_dc
.removeExternalSAP(sap_name
)
260 LOG
.info("Stopping the SAP instance: %r in DC %r" % (sap_name
, target_dc
))
262 if not GK_STANDALONE_MODE
:
264 # self._remove_placement(RoundRobinPlacement)
267 # last step: remove the instance from the list of all instances
268 del self
.instances
[instance_uuid
]
270 def _start_vnfd(self
, vnfd
, vnf_id
, **kwargs
):
272 Start a single VNFD of this service
273 :param vnfd: vnfd descriptor dict
274 :param vnf_id: unique id of this vnf in the nsd
277 # the vnf_name refers to the container image to be deployed
278 vnf_name
= vnfd
.get("name")
280 # iterate over all deployment units within each VNFDs
281 for u
in vnfd
.get("virtual_deployment_units"):
282 # 1. get the name of the docker image to start and the assigned DC
283 if vnf_id
not in self
.remote_docker_image_urls
:
284 raise Exception("No image name for %r found. Abort." % vnf_id
)
285 docker_name
= self
.remote_docker_image_urls
.get(vnf_id
)
286 target_dc
= vnfd
.get("dc")
287 # 2. perform some checks to ensure we can start the container
288 assert(docker_name
is not None)
289 assert(target_dc
is not None)
290 if not self
._check
_docker
_image
_exists
(docker_name
):
291 raise Exception("Docker image %r not found. Abort." % docker_name
)
293 # 3. get the resource limits
294 res_req
= u
.get("resource_requirements")
295 cpu_list
= res_req
.get("cpu").get("cores")
297 cpu_list
= res_req
.get("cpu").get("vcpus")
300 cpu_bw
= res_req
.get("cpu").get("cpu_bw")
303 mem_num
= str(res_req
.get("memory").get("size"))
306 mem_unit
= str(res_req
.get("memory").get("size_unit"))
309 mem_limit
= float(mem_num
)
311 mem_limit
=mem_limit
*1024*1024*1024
313 mem_limit
=mem_limit
*1024*1024
315 mem_limit
=mem_limit
*1024
316 mem_lim
= int(mem_limit
)
317 cpu_period
, cpu_quota
= self
._calculate
_cpu
_cfs
_values
(float(cpu_bw
))
319 # check if we need to deploy the management ports (defined as type:management both on in the vnfd and nsd)
320 intfs
= vnfd
.get("connection_points", [])
323 mgmt_intfs
= [vnf_id
+ ':' + intf
['id'] for intf
in intfs
if intf
.get('type') == 'management']
324 # check if any of these management interfaces are used in a management-type network in the nsd
325 for nsd_intf_name
in mgmt_intfs
:
326 vlinks
= [ l
["connection_points_reference"] for l
in self
.nsd
.get("virtual_links", [])]
328 if nsd_intf_name
in link
and self
.check_mgmt_interface(link
):
329 # this is indeed a management interface and can be skipped
330 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(nsd_intf_name
)
331 found_interfaces
= [intf
for intf
in intfs
if intf
.get('id') == vnf_interface
]
332 intfs
.remove(found_interfaces
[0])
333 mgmt_intf_names
.append(vnf_interface
)
335 # 4. generate the volume paths for the docker container
337 # a volume to extract log files
338 docker_log_path
= "/tmp/results/%s/%s"%(self
.uuid
,vnf_id
)
339 LOG
.debug("LOG path for vnf %s is %s."%(vnf_id
,docker_log_path
))
340 if not os
.path
.exists(docker_log_path
):
341 LOG
.debug("Creating folder %s"%docker
_log
_path
)
342 os
.makedirs(docker_log_path
)
344 volumes
.append(docker_log_path
+":/mnt/share/")
347 # 5. do the dc.startCompute(name="foobar") call to run the container
348 # TODO consider flavors, and other annotations
349 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
350 # use the vnf_id in the nsd as docker name
351 # so deployed containers can be easily mapped back to the nsd
352 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, vnf_id
, vnfd
.get("dc")))
353 LOG
.debug("Interfaces for %r: %r" % (vnf_id
, intfs
))
354 vnfi
= target_dc
.startCompute(
360 cpu_period
=cpu_period
,
364 type=kwargs
.get('type','docker'))
366 # rename the docker0 interfaces (eth0) to the management port name defined in the VNFD
368 for intf_name
in mgmt_intf_names
:
369 self
._vnf
_reconfigure
_network
(vnfi
, 'eth0', new_name
=intf_name
)
373 def _stop_vnfi(self
, vnfi
):
377 :param vnfi: vnf instance to be stopped
379 # Find the correct datacenter
380 status
= vnfi
.getStatus()
384 LOG
.info("Stopping the vnf instance contained in %r in DC %r" % (status
["name"], dc
))
385 dc
.stopCompute(status
["name"])
387 def _get_vnf_instance(self
, instance_uuid
, vnf_id
):
389 Returns the Docker object for the given VNF id (or Docker name).
390 :param instance_uuid: UUID of the service instance to search in.
391 :param name: VNF name or Docker name. We are fuzzy here.
395 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
398 LOG
.warning("No container with name: {0} found.".format(dn
))
402 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
=None, new_name
=None):
404 Reconfigure the network configuration of a specific interface
405 of a running container.
406 :param vnfi: container instance
407 :param if_name: interface name
408 :param net_str: network configuration string, e.g., 1.2.3.4/24
412 # assign new ip address
413 if net_str
is not None:
414 intf
= vnfi
.intf(intf
=if_name
)
417 LOG
.debug("Reconfigured network of %s:%s to %r" % (vnfi
.name
, if_name
, net_str
))
419 LOG
.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi
.name
, if_name
))
421 if new_name
is not None:
422 vnfi
.cmd('ip link set', if_name
, 'down')
423 vnfi
.cmd('ip link set', if_name
, 'name', new_name
)
424 vnfi
.cmd('ip link set', new_name
, 'up')
425 LOG
.debug("Reconfigured interface name of %s:%s to %s" % (vnfi
.name
, if_name
, new_name
))
429 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
430 for vnfi
in vnfi_list
:
431 config
= vnfi
.dcinfo
.get("Config", dict())
432 env
= config
.get("Env", list())
434 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
435 LOG
.debug("%r = %r" % (var
, cmd
))
436 if var
=="SON_EMU_CMD":
437 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
438 # execute command in new thread to ensure that GK is not blocked by VNF
439 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
443 def _trigger_emulator_stop_scripts_in_vnfis(self
, vnfi_list
):
444 for vnfi
in vnfi_list
:
445 config
= vnfi
.dcinfo
.get("Config", dict())
446 env
= config
.get("Env", list())
448 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
449 if var
=="SON_EMU_CMD_STOP":
450 LOG
.info("Executing stop script in %r: %r" % (vnfi
.name
, cmd
))
451 # execute command in new thread to ensure that GK is not blocked by VNF
452 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
458 def _unpack_service_package(self
):
460 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
462 LOG
.info("Unzipping: %r" % self
.package_file_path
)
463 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
464 z
.extractall(self
.package_content_path
)
467 def _load_package_descriptor(self
):
469 Load the main package descriptor YAML and keep it as dict.
472 self
.manifest
= load_yaml(
474 self
.package_content_path
, "META-INF/MANIFEST.MF"))
478 Load the entry NSD YAML and keep it as dict.
481 if "entry_service_template" in self
.manifest
:
482 nsd_path
= os
.path
.join(
483 self
.package_content_path
,
484 make_relative_path(self
.manifest
.get("entry_service_template")))
485 self
.nsd
= load_yaml(nsd_path
)
486 GK
.net
.deployed_nsds
.append(self
.nsd
)
487 # create dict to find the vnf_name for any vnf id
488 self
.vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
489 reduce(lambda x
, y
: dict(x
, **y
),
490 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
491 self
.nsd
["network_functions"])))
493 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
495 def _load_vnfd(self
):
497 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
501 # first make a list of all the vnfds in the package
503 if "package_content" in self
.manifest
:
504 for pc
in self
.manifest
.get("package_content"):
505 if pc
.get("content-type") == "application/sonata.function_descriptor":
506 vnfd_path
= os
.path
.join(
507 self
.package_content_path
,
508 make_relative_path(pc
.get("name")))
509 vnfd
= load_yaml(vnfd_path
)
510 vnfd_set
[vnfd
.get("name")] = vnfd
511 # then link each vnf_id in the nsd to its vnfd
512 for vnf_id
in self
.vnf_id2vnf_name
:
513 vnf_name
= self
.vnf_id2vnf_name
[vnf_id
]
514 self
.vnfds
[vnf_id
] = vnfd_set
[vnf_name
]
515 LOG
.debug("Loaded VNFD: {0} id: {1}".format(vnf_name
, vnf_id
))
517 def _load_saps(self
):
518 # create list of all SAPs
519 # check if we need to deploy management ports
521 SAPs
= [p
for p
in self
.nsd
["connection_points"] if 'management' not in p
.get('type')]
523 SAPs
= [p
for p
in self
.nsd
["connection_points"]]
526 # endpoint needed in this service
527 sap_id
, sap_interface
, sap_docker_name
= parse_interface(sap
['id'])
528 # make sure SAP has type set (default internal)
529 sap
["type"] = sap
.get("type", 'internal')
531 # Each Service Access Point (connection_point) in the nsd is an IP address on the host
532 if sap
["type"] == "external":
533 # add to vnfds to calculate placement later on
534 sap_net
= SAP_SUBNETS
.pop(0)
535 self
.saps
[sap_docker_name
] = {"name": sap_docker_name
, "type": "external", "net": sap_net
}
536 # add SAP vnf to list in the NSD so it is deployed later on
537 # each SAP gets a unique VNFD and vnf_id in the NSD and custom type (only defined in the dummygatekeeper)
538 self
.nsd
["network_functions"].append(
539 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_ext"})
541 # Each Service Access Point (connection_point) in the nsd is getting its own container (default)
542 elif sap
["type"] == "internal" or sap
["type"] == "management":
543 # add SAP to self.vnfds
545 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
548 sap_vnfd
= load_yaml(sapfile
)
549 sap_vnfd
["connection_points"][0]["id"] = sap_interface
550 sap_vnfd
["name"] = sap_docker_name
551 sap_vnfd
["type"] = "internal"
552 # add to vnfds to calculate placement later on and deploy
553 self
.saps
[sap_docker_name
] = sap_vnfd
554 # add SAP vnf to list in the NSD so it is deployed later on
555 # each SAP get a unique VNFD and vnf_id in the NSD
556 self
.nsd
["network_functions"].append(
557 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_int"})
559 LOG
.debug("Loaded SAP: name: {0}, type: {1}".format(sap_docker_name
, sap
['type']))
562 self
.saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
563 self
.saps_int
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "internal"]
565 def _start_sap(self
, sap
, instance_uuid
):
569 LOG
.info('start SAP: {0} ,type: {1}'.format(sap
['name'],sap
['type']))
570 if sap
["type"] == "internal":
572 if not GK_STANDALONE_MODE
:
573 vnfi
= self
._start
_vnfd
(sap
, sap
['name'], type='sap_int')
574 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
576 elif sap
["type"] == "external":
577 target_dc
= sap
.get("dc")
578 # add interface to dc switch
579 target_dc
.attachExternalSAP(sap
['name'], sap
['net'])
581 def _connect_elines(self
, eline_fwd_links
, instance_uuid
):
583 Connect all E-LINE links in the NSD
584 :param eline_fwd_links: list of E-LINE links in the NSD
585 :param: instance_uuid of the service
588 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
589 # eg. different services get a unique cookie for their flowrules
591 for link
in eline_fwd_links
:
592 # check if we need to deploy this link when its a management link:
594 if self
.check_mgmt_interface(link
["connection_points_reference"]):
597 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
598 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
601 # check if there is a SAP in the link and chain everything together
602 if src_sap_id
in self
.saps
and dst_sap_id
in self
.saps
:
603 LOG
.info('2 SAPs cannot be chained together : {0} - {1}'.format(src_sap_id
, dst_sap_id
))
606 elif src_sap_id
in self
.saps_ext
:
608 # set intf name to None so the chaining function will choose the first one
610 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_id
)
611 if dst_vnfi
is not None:
612 # choose first ip address in sap subnet
613 sap_net
= self
.saps
[src_sap_id
]['net']
614 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
615 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, sap_ip
)
618 elif dst_sap_id
in self
.saps_ext
:
620 # set intf name to None so the chaining function will choose the first one
622 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_id
)
623 if src_vnfi
is not None:
624 sap_net
= self
.saps
[dst_sap_id
]['net']
625 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
626 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, sap_ip
)
629 # Link between 2 VNFs
631 # make sure we use the correct sap vnf name
632 if src_sap_id
in self
.saps_int
:
634 if dst_sap_id
in self
.saps_int
:
636 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
637 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_id
)
638 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_id
)
639 if src_vnfi
is not None and dst_vnfi
is not None:
640 eline_net
= ELINE_SUBNETS
.pop(0)
641 ip1
= "{0}/{1}".format(str(eline_net
[1]), eline_net
.prefixlen
)
642 ip2
= "{0}/{1}".format(str(eline_net
[2]), eline_net
.prefixlen
)
643 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, ip1
)
644 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, ip2
)
649 ret
= GK
.net
.setChain(
651 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
652 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
654 "Setting up E-Line link. (%s:%s) -> (%s:%s)" % (
655 src_id
, src_if_name
, dst_id
, dst_if_name
))
658 def _connect_elans(self
, elan_fwd_links
, instance_uuid
):
660 Connect all E-LAN links in the NSD
661 :param elan_fwd_links: list of E-LAN links in the NSD
662 :param: instance_uuid of the service
665 for link
in elan_fwd_links
:
666 # check if we need to deploy this link when its a management link:
668 if self
.check_mgmt_interface(link
["connection_points_reference"]):
672 # check if an external SAP is in the E-LAN (then a subnet is already defined)
673 intfs_elan
= [intf
for intf
in link
["connection_points_reference"]]
674 lan_sap
= self
.check_ext_saps(intfs_elan
)
676 lan_net
= self
.saps
[lan_sap
]['net']
677 lan_hosts
= list(lan_net
.hosts())
678 sap_ip
= str(lan_hosts
.pop(0))
680 lan_net
= ELAN_SUBNETS
.pop(0)
681 lan_hosts
= list(lan_net
.hosts())
683 # generate lan ip address for all interfaces except external SAPs
684 for intf
in link
["connection_points_reference"]:
686 # skip external SAPs, they already have an ip
687 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf
)
688 if vnf_sap_docker_name
in self
.saps_ext
:
689 elan_vnf_list
.append({'name': vnf_sap_docker_name
, 'interface': vnf_interface
})
692 ip_address
= "{0}/{1}".format(str(lan_hosts
.pop(0)), lan_net
.prefixlen
)
693 vnf_id
, intf_name
, vnf_sap_id
= parse_interface(intf
)
695 # make sure we use the correct sap vnf name
696 src_docker_name
= vnf_id
697 if vnf_sap_id
in self
.saps_int
:
698 src_docker_name
= vnf_sap_id
702 "Setting up E-LAN interface. (%s:%s) -> %s" % (
703 vnf_id
, intf_name
, ip_address
))
705 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
706 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
707 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
708 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_id
)
710 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
711 # add this vnf and interface to the E-LAN for tagging
712 elan_vnf_list
.append({'name': src_docker_name
, 'interface': intf_name
})
714 # install the VLAN tags for this E-LAN
715 GK
.net
.setLAN(elan_vnf_list
)
718 def _load_docker_files(self
):
720 Get all paths to Dockerfiles from VNFDs and store them in dict.
723 for k
, v
in self
.vnfds
.iteritems():
724 for vu
in v
.get("virtual_deployment_units"):
725 if vu
.get("vm_image_format") == "docker":
726 vm_image
= vu
.get("vm_image")
727 docker_path
= os
.path
.join(
728 self
.package_content_path
,
729 make_relative_path(vm_image
))
730 self
.local_docker_files
[k
] = docker_path
731 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
733 def _load_docker_urls(self
):
735 Get all URLs to pre-build docker images in some repo.
738 # also merge sap dicts, because internal saps also need a docker container
739 all_vnfs
= self
.vnfds
.copy()
740 all_vnfs
.update(self
.saps
)
742 for k
, v
in all_vnfs
.iteritems():
743 for vu
in v
.get("virtual_deployment_units", {}):
744 if vu
.get("vm_image_format") == "docker":
745 url
= vu
.get("vm_image")
747 url
= url
.replace("http://", "")
748 self
.remote_docker_image_urls
[k
] = url
749 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
751 def _build_images_from_dockerfiles(self
):
753 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
755 if GK_STANDALONE_MODE
:
756 return # do not build anything in standalone mode
758 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
759 for k
, v
in self
.local_docker_files
.iteritems():
760 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
761 LOG
.debug("DOCKER BUILD: %s" % line
)
762 LOG
.info("Docker image created: %s" % k
)
764 def _pull_predefined_dockerimages(self
):
766 If the package contains URLs to pre-build Docker images, we download them with this method.
769 for url
in self
.remote_docker_image_urls
.itervalues():
770 if not FORCE_PULL
: # only pull if not present (speedup for development)
771 if len(dc
.images
.list(name
=url
)) > 0:
772 LOG
.debug("Image %r present. Skipping pull." % url
)
774 LOG
.info("Pulling image: %r" % url
)
775 # this seems to fail with latest docker api version 2.0.2
776 # dc.images.pull(url,
777 # insecure_registry=True)
778 #using docker cli instead
788 def _check_docker_image_exists(self
, image_name
):
790 Query the docker service and check if the given image exists
791 :param image_name: name of the docker image
794 return len(DockerClient().images
.list(name
=image_name
)) > 0
796 def _calculate_placement(self
, algorithm
):
798 Do placement by adding the a field "dc" to
799 each VNFD that points to one of our
800 data center objects known to the gatekeeper.
802 assert(len(self
.vnfds
) > 0)
803 assert(len(GK
.dcs
) > 0)
804 # instantiate algorithm an place
806 p
.place(self
.nsd
, self
.vnfds
, self
.saps
, GK
.dcs
)
807 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
808 # lets print the placement result
809 for name
, vnfd
in self
.vnfds
.iteritems():
810 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
811 for sap
in self
.saps
:
812 sap_dict
= self
.saps
[sap
]
813 LOG
.info("Placed SAP %r on DC %r" % (sap
, str(sap_dict
.get("dc"))))
816 def _calculate_cpu_cfs_values(self
, cpu_time_percentage
):
818 Calculate cpu period and quota for CFS
819 :param cpu_time_percentage: percentage of overall CPU to be used
820 :return: cpu_period, cpu_quota
822 if cpu_time_percentage
is None:
824 if cpu_time_percentage
< 0:
826 # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
827 # Attention minimum cpu_quota is 1ms (micro)
828 cpu_period
= 1000000 # lets consider a fixed period of 1000000 microseconds for now
829 LOG
.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period
, cpu_time_percentage
))
830 cpu_quota
= cpu_period
* cpu_time_percentage
# calculate the fraction of cpu time for this container
831 # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
833 LOG
.debug("cpu_quota before correcting: %r" % cpu_quota
)
835 LOG
.warning("Increased CPU quota to avoid system error.")
836 LOG
.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period
, cpu_quota
))
837 return int(cpu_period
), int(cpu_quota
)
839 def check_ext_saps(self
, intf_list
):
840 # check if the list of interfacs contains an external SAP
841 saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
842 for intf_name
in intf_list
:
843 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf_name
)
844 if vnf_sap_docker_name
in saps_ext
:
845 return vnf_sap_docker_name
847 def check_mgmt_interface(self
, intf_list
):
848 SAPs_mgmt
= [p
.get('id') for p
in self
.nsd
["connection_points"] if 'management' in p
.get('type')]
849 for intf_name
in intf_list
:
850 if intf_name
in SAPs_mgmt
:
854 Some (simple) placement algorithms
858 class FirstDcPlacement(object):
860 Placement: Always use one and the same data center from the GK.dcs dict.
862 def place(self
, nsd
, vnfds
, saps
, dcs
):
863 for id, vnfd
in vnfds
.iteritems():
864 vnfd
["dc"] = list(dcs
.itervalues())[0]
867 class RoundRobinDcPlacement(object):
869 Placement: Distribute VNFs across all available DCs in a round robin fashion.
871 def place(self
, nsd
, vnfds
, saps
, dcs
):
873 dcs_list
= list(dcs
.itervalues())
874 for id, vnfd
in vnfds
.iteritems():
875 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
876 c
+= 1 # inc. c to use next DC
878 class RoundRobinDcPlacementWithSAPs(object):
880 Placement: Distribute VNFs across all available DCs in a round robin fashion,
881 every SAP is instantiated on the same DC as the connected VNF.
883 def place(self
, nsd
, vnfds
, saps
, dcs
):
887 dcs_list
= list(dcs
.itervalues())
888 for id, vnfd
in vnfds
.iteritems():
889 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
890 c
+= 1 # inc. c to use next DC
893 vlinks
= nsd
.get("virtual_links", [])
894 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
895 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
897 # SAPs on E-Line links are placed on the same DC as the VNF on the E-Line
898 for link
in eline_fwd_links
:
899 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
900 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
902 # check if there is a SAP in the link
903 if src_sap_id
in saps
:
904 # get dc where connected vnf is mapped to
905 dc
= vnfds
[dst_id
]['dc']
906 saps
[src_sap_id
]['dc'] = dc
908 if dst_sap_id
in saps
:
909 # get dc where connected vnf is mapped to
910 dc
= vnfds
[src_id
]['dc']
911 saps
[dst_sap_id
]['dc'] = dc
913 # SAPs on E-LANs are placed on a random DC
914 dcs_list
= list(dcs
.itervalues())
915 dc_len
= len(dcs_list
)
916 for link
in elan_fwd_links
:
917 for intf
in link
["connection_points_reference"]:
918 # find SAP interfaces
919 intf_id
, intf_name
, intf_sap_id
= parse_interface(intf
)
920 if intf_sap_id
in saps
:
921 dc
= dcs_list
[randint(0, dc_len
-1)]
922 saps
[intf_sap_id
]['dc'] = dc
927 Resource definitions and API endpoints
931 class Packages(fr
.Resource
):
935 Upload a *.son service package to the dummy gatekeeper.
937 We expect request with a *.son file and store it in UPLOAD_FOLDER
942 LOG
.info("POST /packages called")
943 # lets search for the package in the request
944 is_file_object
= False # make API more robust: file can be in data or in files field
945 if "package" in request
.files
:
946 son_file
= request
.files
["package"]
947 is_file_object
= True
948 elif len(request
.data
) > 0:
949 son_file
= request
.data
951 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
952 # generate a uuid to reference this package
953 service_uuid
= str(uuid
.uuid4())
954 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
955 # ensure that upload folder exists
956 ensure_dir(UPLOAD_FOLDER
)
957 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
958 # store *.son file to disk
960 son_file
.save(upload_path
)
962 with
open(upload_path
, 'wb') as f
:
964 size
= os
.path
.getsize(upload_path
)
966 # first stop and delete any other running services
968 service_list
= copy
.copy(GK
.services
)
969 for service_uuid
in service_list
:
970 instances_list
= copy
.copy(GK
.services
[service_uuid
].instances
)
971 for instance_uuid
in instances_list
:
972 # valid service and instance UUID, stop service
973 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
974 LOG
.info("service instance with uuid %r stopped." % instance_uuid
)
976 # create a service object and register it
977 s
= Service(service_uuid
, file_hash
, upload_path
)
978 GK
.register_service_package(service_uuid
, s
)
980 # automatically deploy the service
982 # ok, we have a service uuid, lets start the service
984 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
986 # generate the JSON result
987 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
988 except Exception as ex
:
989 LOG
.exception("Service package upload failed:")
990 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
994 Return a list of UUID's of uploaded service packages.
997 LOG
.info("GET /packages")
998 return {"service_uuid_list": list(GK
.services
.iterkeys())}
1001 class Instantiations(fr
.Resource
):
1005 Instantiate a service specified by its UUID.
1006 Will return a new UUID to identify the running service instance.
1009 LOG
.info("POST /instantiations (or /requests) called")
1010 # try to extract the service uuid from the request
1011 json_data
= request
.get_json(force
=True)
1012 service_uuid
= json_data
.get("service_uuid")
1014 # lets be a bit fuzzy here to make testing easier
1015 if (service_uuid
is None or service_uuid
=="latest") and len(GK
.services
) > 0:
1016 # if we don't get a service uuid, we simple start the first service in the list
1017 service_uuid
= list(GK
.services
.iterkeys())[0]
1018 if service_uuid
in GK
.services
:
1019 # ok, we have a service uuid, lets start the service
1020 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
1021 return {"service_instance_uuid": service_instance_uuid
}, 201
1022 return "Service not found", 404
1026 Returns a list of UUIDs containing all running services.
1027 :return: dict / list
1029 LOG
.info("GET /instantiations")
1030 return {"service_instantiations_list": [
1031 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
1035 Stops a running service specified by its service and instance UUID.
1037 # try to extract the service and instance UUID from the request
1038 json_data
= request
.get_json(force
=True)
1039 service_uuid
= json_data
.get("service_uuid")
1040 instance_uuid
= json_data
.get("service_instance_uuid")
1043 if service_uuid
is None and len(GK
.services
) > 0:
1044 #if we don't get a service uuid, we simply stop the last service in the list
1045 service_uuid
= list(GK
.services
.iterkeys())[0]
1046 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
1047 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
1049 if service_uuid
in GK
.services
and instance_uuid
in GK
.services
[service_uuid
].instances
:
1050 # valid service and instance UUID, stop service
1051 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
1052 return "service instance with uuid %r stopped." % instance_uuid
,200
1053 return "Service not found", 404
1055 class Exit(fr
.Resource
):
1059 Stop the running Containernet instance regardless of data transmitted
1061 list(GK
.dcs
.values())[0].net
.stop()
1064 def initialize_GK():
1070 # create a single, global GK object
1074 app
= Flask(__name__
)
1075 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
1078 api
.add_resource(Packages
, '/packages', '/api/v2/packages')
1079 api
.add_resource(Instantiations
, '/instantiations', '/api/v2/instantiations', '/api/v2/requests')
1080 api
.add_resource(Exit
, '/emulator/exit')
1084 def start_rest_api(host
, port
, datacenters
=dict()):
1085 GK
.dcs
= datacenters
1086 GK
.net
= get_dc_network()
1087 # start the Flask server (not the best performance but ok for our use case)
1091 use_reloader
=False # this is needed to run Flask in a non-main thread
1095 def ensure_dir(name
):
1096 if not os
.path
.exists(name
):
1100 def load_yaml(path
):
1101 with
open(path
, "r") as f
:
1104 except yaml
.YAMLError
as exc
:
1105 LOG
.exception("YAML parse error")
1110 def make_relative_path(path
):
1111 if path
.startswith("file://"):
1112 path
= path
.replace("file://", "", 1)
1113 if path
.startswith("/"):
1114 path
= path
.replace("/", "", 1)
1118 def get_dc_network():
1120 retrieve the DCnetwork where this dummygatekeeper (GK) connects to.
1121 Assume at least 1 datacenter is connected to this GK, and that all datacenters belong to the same DCNetwork
1124 assert (len(GK
.dcs
) > 0)
1125 return GK
.dcs
.values()[0].net
1128 def parse_interface(interface_name
):
1130 convert the interface name in the nsd to the according vnf_id, vnf_interface names
1131 :param interface_name:
1135 if ':' in interface_name
:
1136 vnf_id
, vnf_interface
= interface_name
.split(':')
1137 vnf_sap_docker_name
= interface_name
.replace(':', '_')
1139 vnf_id
= interface_name
1140 vnf_interface
= interface_name
1141 vnf_sap_docker_name
= interface_name
1143 return vnf_id
, vnf_interface
, vnf_sap_docker_name
1145 def reset_subnets():
1146 # private subnet definitions for the generated interfaces
1149 SAP_SUBNETS
= generate_subnets('10.10', 0, subnet_size
=50, mask
=30)
1152 ELAN_SUBNETS
= generate_subnets('10.20', 0, subnet_size
=50, mask
=24)
1154 global ELINE_SUBNETS
1155 ELINE_SUBNETS
= generate_subnets('10.30', 0, subnet_size
=50, mask
=30)
1157 if __name__
== '__main__':
1159 Lets allow to run the API in standalone mode.
1161 GK_STANDALONE_MODE
= True
1162 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
1163 start_rest_api("0.0.0.0", 8000)