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
53 LOG
= logging
.getLogger("sonata-dummy-gatekeeper")
54 LOG
.setLevel(logging
.DEBUG
)
55 logging
.getLogger("werkzeug").setLevel(logging
.WARNING
)
57 GK_STORAGE
= "/tmp/son-dummy-gk/"
58 UPLOAD_FOLDER
= os
.path
.join(GK_STORAGE
, "uploads/")
59 CATALOG_FOLDER
= os
.path
.join(GK_STORAGE
, "catalog/")
61 # Enable Dockerfile build functionality
62 BUILD_DOCKERFILE
= False
64 # flag to indicate that we run without the emulator (only the bare API for integration testing)
65 GK_STANDALONE_MODE
= False
67 # should a new version of an image be pulled even if its available
70 # Automatically deploy SAPs (endpoints) of the service as new containers
71 # Attention: This is not a configuration switch but a global variable! Don't change its default value.
74 # flag to indicate if we use bidirectional forwarding rules in the automatic chaining process
75 BIDIRECTIONAL_CHAIN
= False
77 # override the management interfaces in the descriptors with default docker0 interfaces in the containers
78 USE_DOCKER_MGMT
= False
80 # automatically deploy uploaded packages (no need to execute son-access deploy --latest separately)
83 # and also automatically terminate any other running services
86 def generate_subnets(prefix
, base
, subnet_size
=50, mask
=24):
87 # Generate a list of ipaddress in subnets
89 for net
in range(base
, base
+ subnet_size
):
90 subnet
= "{0}.{1}.0/{2}".format(prefix
, net
, mask
)
91 r
.append(ipaddress
.ip_network(unicode(subnet
)))
93 # private subnet definitions for the generated interfaces
95 SAP_SUBNETS
= generate_subnets('10.10', 0, subnet_size
=50, mask
=30)
97 ELAN_SUBNETS
= generate_subnets('10.20', 0, subnet_size
=50, mask
=24)
99 ELINE_SUBNETS
= generate_subnets('10.30', 0, subnet_size
=50, mask
=30)
101 # path to the VNFD for the SAP VNF that is deployed as internal SAP point
104 class Gatekeeper(object):
107 self
.services
= dict()
110 self
.vnf_counter
= 0 # used to generate short names for VNFs (Mininet limitation)
111 LOG
.info("Create SONATA dummy gatekeeper.")
113 def register_service_package(self
, service_uuid
, service
):
115 register new service package
117 :param service object
119 self
.services
[service_uuid
] = service
120 # lets perform all steps needed to onboard the service
123 def get_next_vnf_name(self
):
124 self
.vnf_counter
+= 1
125 return "vnf%d" % self
.vnf_counter
128 class Service(object):
130 This class represents a NS uploaded as a *.son package to the
132 Can have multiple running instances of this service.
139 self
.uuid
= service_uuid
140 self
.package_file_hash
= package_file_hash
141 self
.package_file_path
= package_file_path
142 self
.package_content_path
= os
.path
.join(CATALOG_FOLDER
, "services/%s" % self
.uuid
)
147 self
.saps_ext
= list()
148 self
.saps_int
= list()
149 self
.local_docker_files
= dict()
150 self
.remote_docker_image_urls
= dict()
151 self
.instances
= dict()
152 #self.vnf_name2docker_name = dict()
153 # dict to find the vnf_name for any vnf id
154 self
.vnf_id2vnf_name
= dict()
158 Do all steps to prepare this service to be instantiated
161 # 1. extract the contents of the package and store them in our catalog
162 self
._unpack
_service
_package
()
163 # 2. read in all descriptor files
164 self
._load
_package
_descriptor
()
169 # 3. prepare container images (e.g. download or build Dockerfile)
171 self
._load
_docker
_files
()
172 self
._build
_images
_from
_dockerfiles
()
174 self
._load
_docker
_urls
()
175 self
._pull
_predefined
_dockerimages
()
176 LOG
.info("On-boarded service: %r" % self
.manifest
.get("name"))
178 def start_service(self
):
180 This methods creates and starts a new service instance.
181 It computes placements, iterates over all VNFDs, and starts
182 each VNFD as a Docker container in the data center selected
183 by the placement algorithm.
186 LOG
.info("Starting service %r" % self
.uuid
)
188 # 1. each service instance gets a new uuid to identify it
189 instance_uuid
= str(uuid
.uuid4())
190 # build a instances dict (a bit like a NSR :))
191 self
.instances
[instance_uuid
] = dict()
192 self
.instances
[instance_uuid
]["vnf_instances"] = list()
194 # 2. compute placement of this service instance (adds DC names to VNFDs)
195 if not GK_STANDALONE_MODE
:
196 #self._calculate_placement(FirstDcPlacement)
197 self
._calculate
_placement
(RoundRobinDcPlacementWithSAPs
)
198 # 3. start all vnfds that we have in the service (except SAPs)
199 for vnf_id
in self
.vnfds
:
200 vnfd
= self
.vnfds
[vnf_id
]
202 if not GK_STANDALONE_MODE
:
203 vnfi
= self
._start
_vnfd
(vnfd
, vnf_id
)
204 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
206 # 4. start all SAPs in the service
207 for sap
in self
.saps
:
208 self
._start
_sap
(self
.saps
[sap
], instance_uuid
)
210 # 5. Deploy E-Line and E_LAN links
211 if "virtual_links" in self
.nsd
:
212 vlinks
= self
.nsd
["virtual_links"]
213 # constituent virtual links are not checked
214 #fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
215 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
216 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
218 GK
.net
.deployed_elines
.extend(eline_fwd_links
)
219 GK
.net
.deployed_elans
.extend(elan_fwd_links
)
221 # 5a. deploy E-Line links
222 self
._connect
_elines
(eline_fwd_links
, instance_uuid
)
224 # 5b. deploy E-LAN links
225 self
._connect
_elans
(elan_fwd_links
, instance_uuid
)
227 # 6. run the emulator specific entrypoint scripts in the VNFIs of this service instance
228 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
230 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
233 def stop_service(self
, instance_uuid
):
235 This method stops a running service instance.
236 It iterates over all VNF instances, stopping them each
237 and removing them from their data center.
239 :param instance_uuid: the uuid of the service instance to be stopped
241 LOG
.info("Stopping service %r" % self
.uuid
)
242 # get relevant information
243 # instance_uuid = str(self.uuid.uuid4())
244 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
246 for v
in vnf_instances
:
249 for sap_name
in self
.saps_ext
:
250 ext_sap
= self
.saps
[sap_name
]
251 target_dc
= ext_sap
.get("dc")
252 target_dc
.removeExternalSAP(sap_name
, ext_sap
['net'])
253 LOG
.info("Stopping the SAP instance: %r in DC %r" % (sap_name
, target_dc
))
255 if not GK_STANDALONE_MODE
:
257 # self._remove_placement(RoundRobinPlacement)
260 # last step: remove the instance from the list of all instances
261 del self
.instances
[instance_uuid
]
263 def _start_vnfd(self
, vnfd
, vnf_id
):
265 Start a single VNFD of this service
266 :param vnfd: vnfd descriptor dict
267 :param vnf_id: unique id of this vnf in the nsd
270 # the vnf_name refers to the container image to be deployed
271 vnf_name
= vnfd
.get("name")
273 # iterate over all deployment units within each VNFDs
274 for u
in vnfd
.get("virtual_deployment_units"):
275 # 1. get the name of the docker image to start and the assigned DC
276 if vnf_id
not in self
.remote_docker_image_urls
:
277 raise Exception("No image name for %r found. Abort." % vnf_id
)
278 docker_name
= self
.remote_docker_image_urls
.get(vnf_id
)
279 target_dc
= vnfd
.get("dc")
280 # 2. perform some checks to ensure we can start the container
281 assert(docker_name
is not None)
282 assert(target_dc
is not None)
283 if not self
._check
_docker
_image
_exists
(docker_name
):
284 raise Exception("Docker image %r not found. Abort." % docker_name
)
286 # 3. get the resource limits
287 res_req
= u
.get("resource_requirements")
288 cpu_list
= res_req
.get("cpu").get("cores")
289 if not cpu_list
or len(cpu_list
)==0:
291 cpu_bw
= res_req
.get("cpu").get("cpu_bw")
294 mem_num
= str(res_req
.get("memory").get("size"))
297 mem_unit
= str(res_req
.get("memory").get("size_unit"))
300 mem_limit
= float(mem_num
)
302 mem_limit
=mem_limit
*1024*1024*1024
304 mem_limit
=mem_limit
*1024*1024
306 mem_limit
=mem_limit
*1024
307 mem_lim
= int(mem_limit
)
308 cpu_period
, cpu_quota
= self
._calculate
_cpu
_cfs
_values
(float(cpu_bw
))
310 # check if we need to deploy the management ports (defined as type:management both on in the vnfd and nsd)
311 intfs
= vnfd
.get("connection_points", [])
314 mgmt_intfs
= [vnf_id
+ ':' + intf
['id'] for intf
in intfs
if intf
.get('type') == 'management']
315 # check if any of these management interfaces are used in a management-type network in the nsd
316 for nsd_intf_name
in mgmt_intfs
:
317 vlinks
= [ l
["connection_points_reference"] for l
in self
.nsd
.get("virtual_links", [])]
319 if nsd_intf_name
in link
and self
.check_mgmt_interface(link
):
320 # this is indeed a management interface and can be skipped
321 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(nsd_intf_name
)
322 found_interfaces
= [intf
for intf
in intfs
if intf
.get('id') == vnf_interface
]
323 intfs
.remove(found_interfaces
[0])
324 mgmt_intf_names
.append(vnf_interface
)
326 # 4. generate the volume paths for the docker container
328 # a volume to extract log files
329 docker_log_path
= "/tmp/results/%s/%s"%(self
.uuid
,vnf_id
)
330 LOG
.debug("LOG path for vnf %s is %s."%(vnf_id
,docker_log_path
))
331 if not os
.path
.exists(docker_log_path
):
332 LOG
.debug("Creating folder %s"%docker
_log
_path
)
333 os
.makedirs(docker_log_path
)
335 volumes
.append(docker_log_path
+":/mnt/share/")
338 # 5. do the dc.startCompute(name="foobar") call to run the container
339 # TODO consider flavors, and other annotations
340 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
341 # use the vnf_id in the nsd as docker name
342 # so deployed containers can be easily mapped back to the nsd
343 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, vnf_id
, vnfd
.get("dc")))
344 LOG
.debug("Interfaces for %r: %r" % (vnf_id
, intfs
))
345 vnfi
= target_dc
.startCompute(
351 cpu_period
=cpu_period
,
356 # rename the docker0 interfaces (eth0) to the management port name defined in the VNFD
358 for intf_name
in mgmt_intf_names
:
359 self
._vnf
_reconfigure
_network
(vnfi
, 'eth0', new_name
=intf_name
)
363 def _stop_vnfi(self
, vnfi
):
367 :param vnfi: vnf instance to be stopped
369 # Find the correct datacenter
370 status
= vnfi
.getStatus()
374 LOG
.info("Stopping the vnf instance contained in %r in DC %r" % (status
["name"], dc
))
375 dc
.stopCompute(status
["name"])
377 def _get_vnf_instance(self
, instance_uuid
, vnf_id
):
379 Returns the Docker object for the given VNF id (or Docker name).
380 :param instance_uuid: UUID of the service instance to search in.
381 :param name: VNF name or Docker name. We are fuzzy here.
385 #if vnf_id in self.vnf_name2docker_name:
386 # dn = self.vnf_name2docker_name[name]
387 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
390 LOG
.warning("No container with name: {0} found.".format(dn
))
394 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
=None, new_name
=None):
396 Reconfigure the network configuration of a specific interface
397 of a running container.
398 :param vnfi: container instance
399 :param if_name: interface name
400 :param net_str: network configuration string, e.g., 1.2.3.4/24
404 # assign new ip address
405 if net_str
is not None:
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
))
413 if new_name
is not None:
414 vnfi
.cmd('ip link set', if_name
, 'down')
415 vnfi
.cmd('ip link set', if_name
, 'name', new_name
)
416 vnfi
.cmd('ip link set', new_name
, 'up')
417 LOG
.debug("Reconfigured interface name of %s:%s to %s" % (vnfi
.name
, if_name
, new_name
))
421 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
422 for vnfi
in vnfi_list
:
423 config
= vnfi
.dcinfo
.get("Config", dict())
424 env
= config
.get("Env", list())
426 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
427 LOG
.debug("%r = %r" % (var
, cmd
))
428 if var
=="SON_EMU_CMD":
429 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
430 # execute command in new thread to ensure that GK is not blocked by VNF
431 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
435 def _unpack_service_package(self
):
437 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
439 LOG
.info("Unzipping: %r" % self
.package_file_path
)
440 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
441 z
.extractall(self
.package_content_path
)
444 def _load_package_descriptor(self
):
446 Load the main package descriptor YAML and keep it as dict.
449 self
.manifest
= load_yaml(
451 self
.package_content_path
, "META-INF/MANIFEST.MF"))
455 Load the entry NSD YAML and keep it as dict.
458 if "entry_service_template" in self
.manifest
:
459 nsd_path
= os
.path
.join(
460 self
.package_content_path
,
461 make_relative_path(self
.manifest
.get("entry_service_template")))
462 self
.nsd
= load_yaml(nsd_path
)
463 GK
.net
.deployed_nsds
.append(self
.nsd
)
464 # create dict to find the vnf_name for any vnf id
465 self
.vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
466 reduce(lambda x
, y
: dict(x
, **y
),
467 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
468 self
.nsd
["network_functions"])))
470 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
472 def _load_vnfd(self
):
474 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
478 # first make a list of all the vnfds in the package
480 if "package_content" in self
.manifest
:
481 for pc
in self
.manifest
.get("package_content"):
482 if pc
.get("content-type") == "application/sonata.function_descriptor":
483 vnfd_path
= os
.path
.join(
484 self
.package_content_path
,
485 make_relative_path(pc
.get("name")))
486 vnfd
= load_yaml(vnfd_path
)
487 vnfd_set
[vnfd
.get("name")] = vnfd
488 # then link each vnf_id in the nsd to its vnfd
489 for vnf_id
in self
.vnf_id2vnf_name
:
490 vnf_name
= self
.vnf_id2vnf_name
[vnf_id
]
491 self
.vnfds
[vnf_id
] = vnfd_set
[vnf_name
]
492 LOG
.debug("Loaded VNFD: {0} id: {1}".format(vnf_name
, vnf_id
))
494 def _load_saps(self
):
495 # create list of all SAPs
496 # check if we need to deploy management ports
498 SAPs
= [p
for p
in self
.nsd
["connection_points"] if 'management' not in p
.get('type')]
500 SAPs
= [p
for p
in self
.nsd
["connection_points"]]
503 # endpoint needed in this service
504 sap_id
, sap_interface
, sap_docker_name
= parse_interface(sap
['id'])
505 # make sure SAP has type set (default internal)
506 sap
["type"] = sap
.get("type", 'internal')
508 # Each Service Access Point (connection_point) in the nsd is an IP address on the host
509 if sap
["type"] == "external":
510 # add to vnfds to calculate placement later on
511 sap_net
= SAP_SUBNETS
.pop(0)
512 self
.saps
[sap_docker_name
] = {"name": sap_docker_name
, "type": "external", "net": sap_net
}
513 # add SAP vnf to list in the NSD so it is deployed later on
514 # each SAP gets a unique VNFD and vnf_id in the NSD and custom type (only defined in the dummygatekeeper)
515 self
.nsd
["network_functions"].append(
516 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_ext"})
518 # Each Service Access Point (connection_point) in the nsd is getting its own container (default)
519 elif sap
["type"] == "internal" or sap
["type"] == "management":
520 # add SAP to self.vnfds
522 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
525 sap_vnfd
= load_yaml(sapfile
)
526 sap_vnfd
["connection_points"][0]["id"] = sap_interface
527 sap_vnfd
["name"] = sap_docker_name
528 sap_vnfd
["type"] = "internal"
529 # add to vnfds to calculate placement later on and deploy
530 self
.saps
[sap_docker_name
] = sap_vnfd
531 # add SAP vnf to list in the NSD so it is deployed later on
532 # each SAP get a unique VNFD and vnf_id in the NSD
533 self
.nsd
["network_functions"].append(
534 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_int"})
536 LOG
.debug("Loaded SAP: name: {0}, type: {1}".format(sap_docker_name
, sap
['type']))
539 self
.saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
540 self
.saps_int
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "internal"]
542 def _start_sap(self
, sap
, instance_uuid
):
546 LOG
.info('start SAP: {0} ,type: {1}'.format(sap
['name'],sap
['type']))
547 if sap
["type"] == "internal":
549 if not GK_STANDALONE_MODE
:
550 vnfi
= self
._start
_vnfd
(sap
, sap
['name'])
551 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
553 elif sap
["type"] == "external":
554 target_dc
= sap
.get("dc")
555 # add interface to dc switch
556 target_dc
.attachExternalSAP(sap
['name'], sap
['net'])
558 def _connect_elines(self
, eline_fwd_links
, instance_uuid
):
560 Connect all E-LINE links in the NSD
561 :param eline_fwd_links: list of E-LINE links in the NSD
562 :param: instance_uuid of the service
565 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
566 # eg. different services get a unique cookie for their flowrules
568 for link
in eline_fwd_links
:
569 # check if we need to deploy this link when its a management link:
571 if self
.check_mgmt_interface(link
["connection_points_reference"]):
574 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
575 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
578 # check if there is a SAP in the link and chain everything together
579 if src_sap_id
in self
.saps
and dst_sap_id
in self
.saps
:
580 LOG
.info('2 SAPs cannot be chained together : {0} - {1}'.format(src_sap_id
, dst_sap_id
))
583 elif src_sap_id
in self
.saps_ext
:
585 # set intf name to None so the chaining function will choose the first one
587 #src_name = self.vnf_id2vnf_name[src_id]
588 #dst_name = self.vnf_id2vnf_name[dst_id]
589 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_id
)
590 if dst_vnfi
is not None:
591 # choose first ip address in sap subnet
592 sap_net
= self
.saps
[src_sap_id
]['net']
593 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
594 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, sap_ip
)
597 elif dst_sap_id
in self
.saps_ext
:
599 # set intf name to None so the chaining function will choose the first one
601 #src_name = self.vnf_id2vnf_name[src_id]
602 #dst_name = self.vnf_id2vnf_name[dst_id]
603 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_id
)
604 if src_vnfi
is not None:
605 sap_net
= self
.saps
[dst_sap_id
]['net']
606 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
607 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, sap_ip
)
610 # Link between 2 VNFs
612 # make sure we use the correct sap vnf name
613 if src_sap_id
in self
.saps_int
:
615 if dst_sap_id
in self
.saps_int
:
617 #src_name = self.vnf_id2vnf_name[src_id]
618 #dst_name = self.vnf_id2vnf_name[dst_id]
619 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
620 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_id
)
621 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_id
)
622 if src_vnfi
is not None and dst_vnfi
is not None:
623 eline_net
= ELINE_SUBNETS
.pop(0)
624 ip1
= "{0}/{1}".format(str(eline_net
[1]), eline_net
.prefixlen
)
625 ip2
= "{0}/{1}".format(str(eline_net
[2]), eline_net
.prefixlen
)
626 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, ip1
)
627 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, ip2
)
632 ret
= GK
.net
.setChain(
634 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
635 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
637 "Setting up E-Line link. (%s:%s) -> (%s:%s)" % (
638 src_id
, src_if_name
, dst_id
, dst_if_name
))
641 def _connect_elans(self
, elan_fwd_links
, instance_uuid
):
643 Connect all E-LAN links in the NSD
644 :param elan_fwd_links: list of E-LAN links in the NSD
645 :param: instance_uuid of the service
648 for link
in elan_fwd_links
:
649 # check if we need to deploy this link when its a management link:
651 if self
.check_mgmt_interface(link
["connection_points_reference"]):
655 # check if an external SAP is in the E-LAN (then a subnet is already defined)
656 intfs_elan
= [intf
for intf
in link
["connection_points_reference"]]
657 lan_sap
= self
.check_ext_saps(intfs_elan
)
659 lan_net
= self
.saps
[lan_sap
]['net']
660 lan_hosts
= list(lan_net
.hosts())
661 sap_ip
= str(lan_hosts
.pop(0))
663 lan_net
= ELAN_SUBNETS
.pop(0)
664 lan_hosts
= list(lan_net
.hosts())
666 # generate lan ip address for all interfaces except external SAPs
667 for intf
in link
["connection_points_reference"]:
669 # skip external SAPs, they already have an ip
670 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf
)
671 if vnf_sap_docker_name
in self
.saps_ext
:
672 elan_vnf_list
.append({'name': vnf_sap_docker_name
, 'interface': vnf_interface
})
675 ip_address
= "{0}/{1}".format(str(lan_hosts
.pop(0)), lan_net
.prefixlen
)
676 vnf_id
, intf_name
, vnf_sap_id
= parse_interface(intf
)
678 # make sure we use the correct sap vnf name
679 src_docker_name
= vnf_id
680 if vnf_sap_id
in self
.saps_int
:
681 src_docker_name
= vnf_sap_id
684 #vnf_name = self.vnf_id2vnf_name[vnf_id]
686 "Setting up E-LAN interface. %s(%s:%s) -> %s" % (
687 vnf_id
, intf_name
, ip_address
))
689 if vnf_id
in self
.vnfds
:
690 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
691 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
692 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
693 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_id
)
695 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
696 # add this vnf and interface to the E-LAN for tagging
697 elan_vnf_list
.append({'name': src_docker_name
, 'interface': intf_name
})
699 # install the VLAN tags for this E-LAN
700 GK
.net
.setLAN(elan_vnf_list
)
703 def _load_docker_files(self
):
705 Get all paths to Dockerfiles from VNFDs and store them in dict.
708 for k
, v
in self
.vnfds
.iteritems():
709 for vu
in v
.get("virtual_deployment_units"):
710 if vu
.get("vm_image_format") == "docker":
711 vm_image
= vu
.get("vm_image")
712 docker_path
= os
.path
.join(
713 self
.package_content_path
,
714 make_relative_path(vm_image
))
715 self
.local_docker_files
[k
] = docker_path
716 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
718 def _load_docker_urls(self
):
720 Get all URLs to pre-build docker images in some repo.
723 # also merge sap dicts, because internal saps also need a docker container
724 all_vnfs
= self
.vnfds
.copy()
725 all_vnfs
.update(self
.saps
)
727 for k
, v
in all_vnfs
.iteritems():
728 for vu
in v
.get("virtual_deployment_units", {}):
729 if vu
.get("vm_image_format") == "docker":
730 url
= vu
.get("vm_image")
732 url
= url
.replace("http://", "")
733 self
.remote_docker_image_urls
[k
] = url
734 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
736 def _build_images_from_dockerfiles(self
):
738 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
740 if GK_STANDALONE_MODE
:
741 return # do not build anything in standalone mode
743 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
744 for k
, v
in self
.local_docker_files
.iteritems():
745 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
746 LOG
.debug("DOCKER BUILD: %s" % line
)
747 LOG
.info("Docker image created: %s" % k
)
749 def _pull_predefined_dockerimages(self
):
751 If the package contains URLs to pre-build Docker images, we download them with this method.
754 for url
in self
.remote_docker_image_urls
.itervalues():
755 if not FORCE_PULL
: # only pull if not present (speedup for development)
756 if len(dc
.images
.list(name
=url
)) > 0:
757 LOG
.debug("Image %r present. Skipping pull." % url
)
759 LOG
.info("Pulling image: %r" % url
)
760 # this seems to fail with latest docker api version 2.0.2
761 # dc.images.pull(url,
762 # insecure_registry=True)
763 #using docker cli instead
773 def _check_docker_image_exists(self
, image_name
):
775 Query the docker service and check if the given image exists
776 :param image_name: name of the docker image
779 return len(DockerClient().images
.list(name
=image_name
)) > 0
781 def _calculate_placement(self
, algorithm
):
783 Do placement by adding the a field "dc" to
784 each VNFD that points to one of our
785 data center objects known to the gatekeeper.
787 assert(len(self
.vnfds
) > 0)
788 assert(len(GK
.dcs
) > 0)
789 # instantiate algorithm an place
791 p
.place(self
.nsd
, self
.vnfds
, self
.saps
, GK
.dcs
)
792 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
793 # lets print the placement result
794 for name
, vnfd
in self
.vnfds
.iteritems():
795 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
796 for sap
in self
.saps
:
797 sap_dict
= self
.saps
[sap
]
798 LOG
.info("Placed SAP %r on DC %r" % (sap
, str(sap_dict
.get("dc"))))
801 def _calculate_cpu_cfs_values(self
, cpu_time_percentage
):
803 Calculate cpu period and quota for CFS
804 :param cpu_time_percentage: percentage of overall CPU to be used
805 :return: cpu_period, cpu_quota
807 if cpu_time_percentage
is None:
809 if cpu_time_percentage
< 0:
811 # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
812 # Attention minimum cpu_quota is 1ms (micro)
813 cpu_period
= 1000000 # lets consider a fixed period of 1000000 microseconds for now
814 LOG
.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period
, cpu_time_percentage
))
815 cpu_quota
= cpu_period
* cpu_time_percentage
# calculate the fraction of cpu time for this container
816 # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
818 LOG
.debug("cpu_quota before correcting: %r" % cpu_quota
)
820 LOG
.warning("Increased CPU quota to avoid system error.")
821 LOG
.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period
, cpu_quota
))
822 return int(cpu_period
), int(cpu_quota
)
824 def check_ext_saps(self
, intf_list
):
825 # check if the list of interfacs contains an external SAP
826 saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
827 for intf_name
in intf_list
:
828 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf_name
)
829 if vnf_sap_docker_name
in saps_ext
:
830 return vnf_sap_docker_name
832 def check_mgmt_interface(self
, intf_list
):
833 SAPs_mgmt
= [p
.get('id') for p
in self
.nsd
["connection_points"] if 'management' in p
.get('type')]
834 for intf_name
in intf_list
:
835 if intf_name
in SAPs_mgmt
:
839 Some (simple) placement algorithms
843 class FirstDcPlacement(object):
845 Placement: Always use one and the same data center from the GK.dcs dict.
847 def place(self
, nsd
, vnfds
, saps
, dcs
):
848 for id, vnfd
in vnfds
.iteritems():
849 vnfd
["dc"] = list(dcs
.itervalues())[0]
852 class RoundRobinDcPlacement(object):
854 Placement: Distribute VNFs across all available DCs in a round robin fashion.
856 def place(self
, nsd
, vnfds
, saps
, dcs
):
858 dcs_list
= list(dcs
.itervalues())
859 for id, vnfd
in vnfds
.iteritems():
860 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
861 c
+= 1 # inc. c to use next DC
863 class RoundRobinDcPlacementWithSAPs(object):
865 Placement: Distribute VNFs across all available DCs in a round robin fashion,
866 every SAP is instantiated on the same DC as the connected VNF.
868 def place(self
, nsd
, vnfds
, saps
, dcs
):
872 dcs_list
= list(dcs
.itervalues())
873 for id, vnfd
in vnfds
.iteritems():
874 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
875 c
+= 1 # inc. c to use next DC
878 vlinks
= nsd
.get("virtual_links", [])
879 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
880 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
882 # SAPs on E-Line links are placed on the same DC as the VNF on the E-Line
883 for link
in eline_fwd_links
:
884 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
885 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
887 # check if there is a SAP in the link
888 if src_sap_id
in saps
:
889 #dst_vnf_name = vnf_id2vnf_name[dst_id]
890 # get dc where connected vnf is mapped to
891 dc
= vnfds
[dst_id
]['dc']
892 saps
[src_sap_id
]['dc'] = dc
894 if dst_sap_id
in saps
:
895 #src_vnf_name = vnf_id2vnf_name[src_id]
896 # get dc where connected vnf is mapped to
897 dc
= vnfds
[src_id
]['dc']
898 saps
[dst_sap_id
]['dc'] = dc
900 # SAPs on E-LANs are placed on a random DC
901 dcs_list
= list(dcs
.itervalues())
902 dc_len
= len(dcs_list
)
903 for link
in elan_fwd_links
:
904 for intf
in link
["connection_points_reference"]:
905 # find SAP interfaces
906 intf_id
, intf_name
, intf_sap_id
= parse_interface(intf
)
907 if intf_sap_id
in saps
:
908 dc
= dcs_list
[randint(0, dc_len
-1)]
909 saps
[intf_sap_id
]['dc'] = dc
914 Resource definitions and API endpoints
918 class Packages(fr
.Resource
):
922 Upload a *.son service package to the dummy gatekeeper.
924 We expect request with a *.son file and store it in UPLOAD_FOLDER
929 LOG
.info("POST /packages called")
930 # lets search for the package in the request
931 is_file_object
= False # make API more robust: file can be in data or in files field
932 if "package" in request
.files
:
933 son_file
= request
.files
["package"]
934 is_file_object
= True
935 elif len(request
.data
) > 0:
936 son_file
= request
.data
938 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
939 # generate a uuid to reference this package
940 service_uuid
= str(uuid
.uuid4())
941 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
942 # ensure that upload folder exists
943 ensure_dir(UPLOAD_FOLDER
)
944 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
945 # store *.son file to disk
947 son_file
.save(upload_path
)
949 with
open(upload_path
, 'wb') as f
:
951 size
= os
.path
.getsize(upload_path
)
953 # first stop and delete any other running services
955 service_list
= copy
.copy(GK
.services
)
956 for service_uuid
in service_list
:
957 instances_list
= copy
.copy(GK
.services
[service_uuid
].instances
)
958 for instance_uuid
in instances_list
:
959 # valid service and instance UUID, stop service
960 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
961 LOG
.info("service instance with uuid %r stopped." % instance_uuid
)
963 # create a service object and register it
964 s
= Service(service_uuid
, file_hash
, upload_path
)
965 GK
.register_service_package(service_uuid
, s
)
967 # automatically deploy the service
969 # ok, we have a service uuid, lets start the service
971 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
973 # generate the JSON result
974 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
975 except Exception as ex
:
976 LOG
.exception("Service package upload failed:")
977 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
981 Return a list of UUID's of uploaded service packages.
984 LOG
.info("GET /packages")
985 return {"service_uuid_list": list(GK
.services
.iterkeys())}
988 class Instantiations(fr
.Resource
):
992 Instantiate a service specified by its UUID.
993 Will return a new UUID to identify the running service instance.
996 LOG
.info("POST /instantiations (or /requests) called")
997 # try to extract the service uuid from the request
998 json_data
= request
.get_json(force
=True)
999 service_uuid
= json_data
.get("service_uuid")
1001 # lets be a bit fuzzy here to make testing easier
1002 if (service_uuid
is None or service_uuid
=="latest") and len(GK
.services
) > 0:
1003 # if we don't get a service uuid, we simple start the first service in the list
1004 service_uuid
= list(GK
.services
.iterkeys())[0]
1005 if service_uuid
in GK
.services
:
1006 # ok, we have a service uuid, lets start the service
1007 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
1008 return {"service_instance_uuid": service_instance_uuid
}, 201
1009 return "Service not found", 404
1013 Returns a list of UUIDs containing all running services.
1014 :return: dict / list
1016 LOG
.info("GET /instantiations")
1017 return {"service_instantiations_list": [
1018 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
1022 Stops a running service specified by its service and instance UUID.
1024 # try to extract the service and instance UUID from the request
1025 json_data
= request
.get_json(force
=True)
1026 service_uuid
= json_data
.get("service_uuid")
1027 instance_uuid
= json_data
.get("service_instance_uuid")
1030 if service_uuid
is None and len(GK
.services
) > 0:
1031 #if we don't get a service uuid, we simply stop the last service in the list
1032 service_uuid
= list(GK
.services
.iterkeys())[0]
1033 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
1034 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
1036 if service_uuid
in GK
.services
and instance_uuid
in GK
.services
[service_uuid
].instances
:
1037 # valid service and instance UUID, stop service
1038 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
1039 return "service instance with uuid %r stopped." % instance_uuid
,200
1040 return "Service not found", 404
1042 class Exit(fr
.Resource
):
1046 Stop the running Containernet instance regardless of data transmitted
1048 list(GK
.dcs
.values())[0].net
.stop()
1051 def initialize_GK():
1057 # create a single, global GK object
1061 app
= Flask(__name__
)
1062 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
1065 api
.add_resource(Packages
, '/packages', '/api/v2/packages')
1066 api
.add_resource(Instantiations
, '/instantiations', '/api/v2/instantiations', '/api/v2/requests')
1067 api
.add_resource(Exit
, '/emulator/exit')
1071 def start_rest_api(host
, port
, datacenters
=dict()):
1072 GK
.dcs
= datacenters
1073 GK
.net
= get_dc_network()
1074 # start the Flask server (not the best performance but ok for our use case)
1078 use_reloader
=False # this is needed to run Flask in a non-main thread
1082 def ensure_dir(name
):
1083 if not os
.path
.exists(name
):
1087 def load_yaml(path
):
1088 with
open(path
, "r") as f
:
1091 except yaml
.YAMLError
as exc
:
1092 LOG
.exception("YAML parse error")
1097 def make_relative_path(path
):
1098 if path
.startswith("file://"):
1099 path
= path
.replace("file://", "", 1)
1100 if path
.startswith("/"):
1101 path
= path
.replace("/", "", 1)
1105 def get_dc_network():
1107 retrieve the DCnetwork where this dummygatekeeper (GK) connects to.
1108 Assume at least 1 datacenter is connected to this GK, and that all datacenters belong to the same DCNetwork
1111 assert (len(GK
.dcs
) > 0)
1112 return GK
.dcs
.values()[0].net
1115 def parse_interface(interface_name
):
1117 convert the interface name in the nsd to the according vnf_id, vnf_interface names
1118 :param interface_name:
1122 if ':' in interface_name
:
1123 vnf_id
, vnf_interface
= interface_name
.split(':')
1124 vnf_sap_docker_name
= interface_name
.replace(':', '_')
1126 vnf_id
= interface_name
1127 vnf_interface
= interface_name
1128 vnf_sap_docker_name
= interface_name
1130 return vnf_id
, vnf_interface
, vnf_sap_docker_name
1132 def reset_subnets():
1133 # private subnet definitions for the generated interfaces
1136 SAP_SUBNETS
= generate_subnets('10.10', 0, subnet_size
=50, mask
=30)
1139 ELAN_SUBNETS
= generate_subnets('10.20', 0, subnet_size
=50, mask
=24)
1141 global ELINE_SUBNETS
1142 ELINE_SUBNETS
= generate_subnets('10.30', 0, subnet_size
=50, mask
=30)
1144 if __name__
== '__main__':
1146 Lets allow to run the API in standalone mode.
1148 GK_STANDALONE_MODE
= True
1149 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
1150 start_rest_api("0.0.0.0", 8000)