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 # dict to find the vnf_name for any vnf id
153 self
.vnf_id2vnf_name
= dict()
157 Do all steps to prepare this service to be instantiated
160 # 1. extract the contents of the package and store them in our catalog
161 self
._unpack
_service
_package
()
162 # 2. read in all descriptor files
163 self
._load
_package
_descriptor
()
168 # 3. prepare container images (e.g. download or build Dockerfile)
170 self
._load
_docker
_files
()
171 self
._build
_images
_from
_dockerfiles
()
173 self
._load
_docker
_urls
()
174 self
._pull
_predefined
_dockerimages
()
175 LOG
.info("On-boarded service: %r" % self
.manifest
.get("name"))
177 def start_service(self
):
179 This methods creates and starts a new service instance.
180 It computes placements, iterates over all VNFDs, and starts
181 each VNFD as a Docker container in the data center selected
182 by the placement algorithm.
185 LOG
.info("Starting service %r" % self
.uuid
)
187 # 1. each service instance gets a new uuid to identify it
188 instance_uuid
= str(uuid
.uuid4())
189 # build a instances dict (a bit like a NSR :))
190 self
.instances
[instance_uuid
] = dict()
191 self
.instances
[instance_uuid
]["vnf_instances"] = list()
193 # 2. compute placement of this service instance (adds DC names to VNFDs)
194 if not GK_STANDALONE_MODE
:
195 #self._calculate_placement(FirstDcPlacement)
196 self
._calculate
_placement
(RoundRobinDcPlacementWithSAPs
)
197 # 3. start all vnfds that we have in the service (except SAPs)
198 for vnf_id
in self
.vnfds
:
199 vnfd
= self
.vnfds
[vnf_id
]
201 if not GK_STANDALONE_MODE
:
202 vnfi
= self
._start
_vnfd
(vnfd
, vnf_id
)
203 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
205 # 4. start all SAPs in the service
206 for sap
in self
.saps
:
207 self
._start
_sap
(self
.saps
[sap
], instance_uuid
)
209 # 5. Deploy E-Line and E_LAN links
210 if "virtual_links" in self
.nsd
:
211 vlinks
= self
.nsd
["virtual_links"]
212 # constituent virtual links are not checked
213 #fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
214 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
215 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
217 GK
.net
.deployed_elines
.extend(eline_fwd_links
)
218 GK
.net
.deployed_elans
.extend(elan_fwd_links
)
220 # 5a. deploy E-Line links
221 self
._connect
_elines
(eline_fwd_links
, instance_uuid
)
223 # 5b. deploy E-LAN links
224 self
._connect
_elans
(elan_fwd_links
, instance_uuid
)
226 # 6. run the emulator specific entrypoint scripts in the VNFIs of this service instance
227 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
229 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
232 def stop_service(self
, instance_uuid
):
234 This method stops a running service instance.
235 It iterates over all VNF instances, stopping them each
236 and removing them from their data center.
238 :param instance_uuid: the uuid of the service instance to be stopped
240 LOG
.info("Stopping service %r" % self
.uuid
)
241 # get relevant information
242 # instance_uuid = str(self.uuid.uuid4())
243 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
245 for v
in vnf_instances
:
248 for sap_name
in self
.saps_ext
:
249 ext_sap
= self
.saps
[sap_name
]
250 target_dc
= ext_sap
.get("dc")
251 target_dc
.removeExternalSAP(sap_name
, ext_sap
['net'])
252 LOG
.info("Stopping the SAP instance: %r in DC %r" % (sap_name
, target_dc
))
254 if not GK_STANDALONE_MODE
:
256 # self._remove_placement(RoundRobinPlacement)
259 # last step: remove the instance from the list of all instances
260 del self
.instances
[instance_uuid
]
262 def _start_vnfd(self
, vnfd
, vnf_id
):
264 Start a single VNFD of this service
265 :param vnfd: vnfd descriptor dict
266 :param vnf_id: unique id of this vnf in the nsd
269 # the vnf_name refers to the container image to be deployed
270 vnf_name
= vnfd
.get("name")
272 # iterate over all deployment units within each VNFDs
273 for u
in vnfd
.get("virtual_deployment_units"):
274 # 1. get the name of the docker image to start and the assigned DC
275 if vnf_id
not in self
.remote_docker_image_urls
:
276 raise Exception("No image name for %r found. Abort." % vnf_id
)
277 docker_name
= self
.remote_docker_image_urls
.get(vnf_id
)
278 target_dc
= vnfd
.get("dc")
279 # 2. perform some checks to ensure we can start the container
280 assert(docker_name
is not None)
281 assert(target_dc
is not None)
282 if not self
._check
_docker
_image
_exists
(docker_name
):
283 raise Exception("Docker image %r not found. Abort." % docker_name
)
285 # 3. get the resource limits
286 res_req
= u
.get("resource_requirements")
287 cpu_list
= res_req
.get("cpu").get("cores")
288 if not cpu_list
or len(cpu_list
)==0:
290 cpu_bw
= res_req
.get("cpu").get("cpu_bw")
293 mem_num
= str(res_req
.get("memory").get("size"))
296 mem_unit
= str(res_req
.get("memory").get("size_unit"))
299 mem_limit
= float(mem_num
)
301 mem_limit
=mem_limit
*1024*1024*1024
303 mem_limit
=mem_limit
*1024*1024
305 mem_limit
=mem_limit
*1024
306 mem_lim
= int(mem_limit
)
307 cpu_period
, cpu_quota
= self
._calculate
_cpu
_cfs
_values
(float(cpu_bw
))
309 # check if we need to deploy the management ports (defined as type:management both on in the vnfd and nsd)
310 intfs
= vnfd
.get("connection_points", [])
313 mgmt_intfs
= [vnf_id
+ ':' + intf
['id'] for intf
in intfs
if intf
.get('type') == 'management']
314 # check if any of these management interfaces are used in a management-type network in the nsd
315 for nsd_intf_name
in mgmt_intfs
:
316 vlinks
= [ l
["connection_points_reference"] for l
in self
.nsd
.get("virtual_links", [])]
318 if nsd_intf_name
in link
and self
.check_mgmt_interface(link
):
319 # this is indeed a management interface and can be skipped
320 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(nsd_intf_name
)
321 found_interfaces
= [intf
for intf
in intfs
if intf
.get('id') == vnf_interface
]
322 intfs
.remove(found_interfaces
[0])
323 mgmt_intf_names
.append(vnf_interface
)
325 # 4. generate the volume paths for the docker container
327 # a volume to extract log files
328 docker_log_path
= "/tmp/results/%s/%s"%(self
.uuid
,vnf_id
)
329 LOG
.debug("LOG path for vnf %s is %s."%(vnf_id
,docker_log_path
))
330 if not os
.path
.exists(docker_log_path
):
331 LOG
.debug("Creating folder %s"%docker
_log
_path
)
332 os
.makedirs(docker_log_path
)
334 volumes
.append(docker_log_path
+":/mnt/share/")
337 # 5. do the dc.startCompute(name="foobar") call to run the container
338 # TODO consider flavors, and other annotations
339 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
340 # use the vnf_id in the nsd as docker name
341 # so deployed containers can be easily mapped back to the nsd
342 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, vnf_id
, vnfd
.get("dc")))
343 LOG
.debug("Interfaces for %r: %r" % (vnf_id
, intfs
))
344 vnfi
= target_dc
.startCompute(
350 cpu_period
=cpu_period
,
355 # rename the docker0 interfaces (eth0) to the management port name defined in the VNFD
357 for intf_name
in mgmt_intf_names
:
358 self
._vnf
_reconfigure
_network
(vnfi
, 'eth0', new_name
=intf_name
)
362 def _stop_vnfi(self
, vnfi
):
366 :param vnfi: vnf instance to be stopped
368 # Find the correct datacenter
369 status
= vnfi
.getStatus()
373 LOG
.info("Stopping the vnf instance contained in %r in DC %r" % (status
["name"], dc
))
374 dc
.stopCompute(status
["name"])
376 def _get_vnf_instance(self
, instance_uuid
, vnf_id
):
378 Returns the Docker object for the given VNF id (or Docker name).
379 :param instance_uuid: UUID of the service instance to search in.
380 :param name: VNF name or Docker name. We are fuzzy here.
384 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
387 LOG
.warning("No container with name: {0} found.".format(dn
))
391 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
=None, new_name
=None):
393 Reconfigure the network configuration of a specific interface
394 of a running container.
395 :param vnfi: container instance
396 :param if_name: interface name
397 :param net_str: network configuration string, e.g., 1.2.3.4/24
401 # assign new ip address
402 if net_str
is not None:
403 intf
= vnfi
.intf(intf
=if_name
)
406 LOG
.debug("Reconfigured network of %s:%s to %r" % (vnfi
.name
, if_name
, net_str
))
408 LOG
.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi
.name
, if_name
))
410 if new_name
is not None:
411 vnfi
.cmd('ip link set', if_name
, 'down')
412 vnfi
.cmd('ip link set', if_name
, 'name', new_name
)
413 vnfi
.cmd('ip link set', new_name
, 'up')
414 LOG
.debug("Reconfigured interface name of %s:%s to %s" % (vnfi
.name
, if_name
, new_name
))
418 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
419 for vnfi
in vnfi_list
:
420 config
= vnfi
.dcinfo
.get("Config", dict())
421 env
= config
.get("Env", list())
423 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
424 LOG
.debug("%r = %r" % (var
, cmd
))
425 if var
=="SON_EMU_CMD":
426 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
427 # execute command in new thread to ensure that GK is not blocked by VNF
428 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
432 def _unpack_service_package(self
):
434 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
436 LOG
.info("Unzipping: %r" % self
.package_file_path
)
437 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
438 z
.extractall(self
.package_content_path
)
441 def _load_package_descriptor(self
):
443 Load the main package descriptor YAML and keep it as dict.
446 self
.manifest
= load_yaml(
448 self
.package_content_path
, "META-INF/MANIFEST.MF"))
452 Load the entry NSD YAML and keep it as dict.
455 if "entry_service_template" in self
.manifest
:
456 nsd_path
= os
.path
.join(
457 self
.package_content_path
,
458 make_relative_path(self
.manifest
.get("entry_service_template")))
459 self
.nsd
= load_yaml(nsd_path
)
460 GK
.net
.deployed_nsds
.append(self
.nsd
)
461 # create dict to find the vnf_name for any vnf id
462 self
.vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
463 reduce(lambda x
, y
: dict(x
, **y
),
464 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
465 self
.nsd
["network_functions"])))
467 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
469 def _load_vnfd(self
):
471 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
475 # first make a list of all the vnfds in the package
477 if "package_content" in self
.manifest
:
478 for pc
in self
.manifest
.get("package_content"):
479 if pc
.get("content-type") == "application/sonata.function_descriptor":
480 vnfd_path
= os
.path
.join(
481 self
.package_content_path
,
482 make_relative_path(pc
.get("name")))
483 vnfd
= load_yaml(vnfd_path
)
484 vnfd_set
[vnfd
.get("name")] = vnfd
485 # then link each vnf_id in the nsd to its vnfd
486 for vnf_id
in self
.vnf_id2vnf_name
:
487 vnf_name
= self
.vnf_id2vnf_name
[vnf_id
]
488 self
.vnfds
[vnf_id
] = vnfd_set
[vnf_name
]
489 LOG
.debug("Loaded VNFD: {0} id: {1}".format(vnf_name
, vnf_id
))
491 def _load_saps(self
):
492 # create list of all SAPs
493 # check if we need to deploy management ports
495 SAPs
= [p
for p
in self
.nsd
["connection_points"] if 'management' not in p
.get('type')]
497 SAPs
= [p
for p
in self
.nsd
["connection_points"]]
500 # endpoint needed in this service
501 sap_id
, sap_interface
, sap_docker_name
= parse_interface(sap
['id'])
502 # make sure SAP has type set (default internal)
503 sap
["type"] = sap
.get("type", 'internal')
505 # Each Service Access Point (connection_point) in the nsd is an IP address on the host
506 if sap
["type"] == "external":
507 # add to vnfds to calculate placement later on
508 sap_net
= SAP_SUBNETS
.pop(0)
509 self
.saps
[sap_docker_name
] = {"name": sap_docker_name
, "type": "external", "net": sap_net
}
510 # add SAP vnf to list in the NSD so it is deployed later on
511 # each SAP gets a unique VNFD and vnf_id in the NSD and custom type (only defined in the dummygatekeeper)
512 self
.nsd
["network_functions"].append(
513 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_ext"})
515 # Each Service Access Point (connection_point) in the nsd is getting its own container (default)
516 elif sap
["type"] == "internal" or sap
["type"] == "management":
517 # add SAP to self.vnfds
519 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
522 sap_vnfd
= load_yaml(sapfile
)
523 sap_vnfd
["connection_points"][0]["id"] = sap_interface
524 sap_vnfd
["name"] = sap_docker_name
525 sap_vnfd
["type"] = "internal"
526 # add to vnfds to calculate placement later on and deploy
527 self
.saps
[sap_docker_name
] = sap_vnfd
528 # add SAP vnf to list in the NSD so it is deployed later on
529 # each SAP get a unique VNFD and vnf_id in the NSD
530 self
.nsd
["network_functions"].append(
531 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_int"})
533 LOG
.debug("Loaded SAP: name: {0}, type: {1}".format(sap_docker_name
, sap
['type']))
536 self
.saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
537 self
.saps_int
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "internal"]
539 def _start_sap(self
, sap
, instance_uuid
):
543 LOG
.info('start SAP: {0} ,type: {1}'.format(sap
['name'],sap
['type']))
544 if sap
["type"] == "internal":
546 if not GK_STANDALONE_MODE
:
547 vnfi
= self
._start
_vnfd
(sap
, sap
['name'])
548 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
550 elif sap
["type"] == "external":
551 target_dc
= sap
.get("dc")
552 # add interface to dc switch
553 target_dc
.attachExternalSAP(sap
['name'], sap
['net'])
555 def _connect_elines(self
, eline_fwd_links
, instance_uuid
):
557 Connect all E-LINE links in the NSD
558 :param eline_fwd_links: list of E-LINE links in the NSD
559 :param: instance_uuid of the service
562 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
563 # eg. different services get a unique cookie for their flowrules
565 for link
in eline_fwd_links
:
566 # check if we need to deploy this link when its a management link:
568 if self
.check_mgmt_interface(link
["connection_points_reference"]):
571 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
572 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
575 # check if there is a SAP in the link and chain everything together
576 if src_sap_id
in self
.saps
and dst_sap_id
in self
.saps
:
577 LOG
.info('2 SAPs cannot be chained together : {0} - {1}'.format(src_sap_id
, dst_sap_id
))
580 elif src_sap_id
in self
.saps_ext
:
582 # set intf name to None so the chaining function will choose the first one
584 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_id
)
585 if dst_vnfi
is not None:
586 # choose first ip address in sap subnet
587 sap_net
= self
.saps
[src_sap_id
]['net']
588 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
589 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, sap_ip
)
592 elif dst_sap_id
in self
.saps_ext
:
594 # set intf name to None so the chaining function will choose the first one
596 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_id
)
597 if src_vnfi
is not None:
598 sap_net
= self
.saps
[dst_sap_id
]['net']
599 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
600 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, sap_ip
)
603 # Link between 2 VNFs
605 # make sure we use the correct sap vnf name
606 if src_sap_id
in self
.saps_int
:
608 if dst_sap_id
in self
.saps_int
:
610 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
611 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_id
)
612 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_id
)
613 if src_vnfi
is not None and dst_vnfi
is not None:
614 eline_net
= ELINE_SUBNETS
.pop(0)
615 ip1
= "{0}/{1}".format(str(eline_net
[1]), eline_net
.prefixlen
)
616 ip2
= "{0}/{1}".format(str(eline_net
[2]), eline_net
.prefixlen
)
617 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, ip1
)
618 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, ip2
)
623 ret
= GK
.net
.setChain(
625 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
626 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
628 "Setting up E-Line link. (%s:%s) -> (%s:%s)" % (
629 src_id
, src_if_name
, dst_id
, dst_if_name
))
632 def _connect_elans(self
, elan_fwd_links
, instance_uuid
):
634 Connect all E-LAN links in the NSD
635 :param elan_fwd_links: list of E-LAN links in the NSD
636 :param: instance_uuid of the service
639 for link
in elan_fwd_links
:
640 # check if we need to deploy this link when its a management link:
642 if self
.check_mgmt_interface(link
["connection_points_reference"]):
646 # check if an external SAP is in the E-LAN (then a subnet is already defined)
647 intfs_elan
= [intf
for intf
in link
["connection_points_reference"]]
648 lan_sap
= self
.check_ext_saps(intfs_elan
)
650 lan_net
= self
.saps
[lan_sap
]['net']
651 lan_hosts
= list(lan_net
.hosts())
652 sap_ip
= str(lan_hosts
.pop(0))
654 lan_net
= ELAN_SUBNETS
.pop(0)
655 lan_hosts
= list(lan_net
.hosts())
657 # generate lan ip address for all interfaces except external SAPs
658 for intf
in link
["connection_points_reference"]:
660 # skip external SAPs, they already have an ip
661 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf
)
662 if vnf_sap_docker_name
in self
.saps_ext
:
663 elan_vnf_list
.append({'name': vnf_sap_docker_name
, 'interface': vnf_interface
})
666 ip_address
= "{0}/{1}".format(str(lan_hosts
.pop(0)), lan_net
.prefixlen
)
667 vnf_id
, intf_name
, vnf_sap_id
= parse_interface(intf
)
669 # make sure we use the correct sap vnf name
670 src_docker_name
= vnf_id
671 if vnf_sap_id
in self
.saps_int
:
672 src_docker_name
= vnf_sap_id
676 "Setting up E-LAN interface. %s(%s:%s) -> %s" % (
677 vnf_id
, intf_name
, ip_address
))
679 if vnf_id
in self
.vnfds
:
680 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
681 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
682 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
683 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_id
)
685 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
686 # add this vnf and interface to the E-LAN for tagging
687 elan_vnf_list
.append({'name': src_docker_name
, 'interface': intf_name
})
689 # install the VLAN tags for this E-LAN
690 GK
.net
.setLAN(elan_vnf_list
)
693 def _load_docker_files(self
):
695 Get all paths to Dockerfiles from VNFDs and store them in dict.
698 for k
, v
in self
.vnfds
.iteritems():
699 for vu
in v
.get("virtual_deployment_units"):
700 if vu
.get("vm_image_format") == "docker":
701 vm_image
= vu
.get("vm_image")
702 docker_path
= os
.path
.join(
703 self
.package_content_path
,
704 make_relative_path(vm_image
))
705 self
.local_docker_files
[k
] = docker_path
706 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
708 def _load_docker_urls(self
):
710 Get all URLs to pre-build docker images in some repo.
713 # also merge sap dicts, because internal saps also need a docker container
714 all_vnfs
= self
.vnfds
.copy()
715 all_vnfs
.update(self
.saps
)
717 for k
, v
in all_vnfs
.iteritems():
718 for vu
in v
.get("virtual_deployment_units", {}):
719 if vu
.get("vm_image_format") == "docker":
720 url
= vu
.get("vm_image")
722 url
= url
.replace("http://", "")
723 self
.remote_docker_image_urls
[k
] = url
724 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
726 def _build_images_from_dockerfiles(self
):
728 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
730 if GK_STANDALONE_MODE
:
731 return # do not build anything in standalone mode
733 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
734 for k
, v
in self
.local_docker_files
.iteritems():
735 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
736 LOG
.debug("DOCKER BUILD: %s" % line
)
737 LOG
.info("Docker image created: %s" % k
)
739 def _pull_predefined_dockerimages(self
):
741 If the package contains URLs to pre-build Docker images, we download them with this method.
744 for url
in self
.remote_docker_image_urls
.itervalues():
745 if not FORCE_PULL
: # only pull if not present (speedup for development)
746 if len(dc
.images
.list(name
=url
)) > 0:
747 LOG
.debug("Image %r present. Skipping pull." % url
)
749 LOG
.info("Pulling image: %r" % url
)
750 # this seems to fail with latest docker api version 2.0.2
751 # dc.images.pull(url,
752 # insecure_registry=True)
753 #using docker cli instead
763 def _check_docker_image_exists(self
, image_name
):
765 Query the docker service and check if the given image exists
766 :param image_name: name of the docker image
769 return len(DockerClient().images
.list(name
=image_name
)) > 0
771 def _calculate_placement(self
, algorithm
):
773 Do placement by adding the a field "dc" to
774 each VNFD that points to one of our
775 data center objects known to the gatekeeper.
777 assert(len(self
.vnfds
) > 0)
778 assert(len(GK
.dcs
) > 0)
779 # instantiate algorithm an place
781 p
.place(self
.nsd
, self
.vnfds
, self
.saps
, GK
.dcs
)
782 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
783 # lets print the placement result
784 for name
, vnfd
in self
.vnfds
.iteritems():
785 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
786 for sap
in self
.saps
:
787 sap_dict
= self
.saps
[sap
]
788 LOG
.info("Placed SAP %r on DC %r" % (sap
, str(sap_dict
.get("dc"))))
791 def _calculate_cpu_cfs_values(self
, cpu_time_percentage
):
793 Calculate cpu period and quota for CFS
794 :param cpu_time_percentage: percentage of overall CPU to be used
795 :return: cpu_period, cpu_quota
797 if cpu_time_percentage
is None:
799 if cpu_time_percentage
< 0:
801 # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
802 # Attention minimum cpu_quota is 1ms (micro)
803 cpu_period
= 1000000 # lets consider a fixed period of 1000000 microseconds for now
804 LOG
.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period
, cpu_time_percentage
))
805 cpu_quota
= cpu_period
* cpu_time_percentage
# calculate the fraction of cpu time for this container
806 # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
808 LOG
.debug("cpu_quota before correcting: %r" % cpu_quota
)
810 LOG
.warning("Increased CPU quota to avoid system error.")
811 LOG
.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period
, cpu_quota
))
812 return int(cpu_period
), int(cpu_quota
)
814 def check_ext_saps(self
, intf_list
):
815 # check if the list of interfacs contains an external SAP
816 saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
817 for intf_name
in intf_list
:
818 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf_name
)
819 if vnf_sap_docker_name
in saps_ext
:
820 return vnf_sap_docker_name
822 def check_mgmt_interface(self
, intf_list
):
823 SAPs_mgmt
= [p
.get('id') for p
in self
.nsd
["connection_points"] if 'management' in p
.get('type')]
824 for intf_name
in intf_list
:
825 if intf_name
in SAPs_mgmt
:
829 Some (simple) placement algorithms
833 class FirstDcPlacement(object):
835 Placement: Always use one and the same data center from the GK.dcs dict.
837 def place(self
, nsd
, vnfds
, saps
, dcs
):
838 for id, vnfd
in vnfds
.iteritems():
839 vnfd
["dc"] = list(dcs
.itervalues())[0]
842 class RoundRobinDcPlacement(object):
844 Placement: Distribute VNFs across all available DCs in a round robin fashion.
846 def place(self
, nsd
, vnfds
, saps
, dcs
):
848 dcs_list
= list(dcs
.itervalues())
849 for id, vnfd
in vnfds
.iteritems():
850 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
851 c
+= 1 # inc. c to use next DC
853 class RoundRobinDcPlacementWithSAPs(object):
855 Placement: Distribute VNFs across all available DCs in a round robin fashion,
856 every SAP is instantiated on the same DC as the connected VNF.
858 def place(self
, nsd
, vnfds
, saps
, dcs
):
862 dcs_list
= list(dcs
.itervalues())
863 for id, vnfd
in vnfds
.iteritems():
864 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
865 c
+= 1 # inc. c to use next DC
868 vlinks
= nsd
.get("virtual_links", [])
869 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
870 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
872 # SAPs on E-Line links are placed on the same DC as the VNF on the E-Line
873 for link
in eline_fwd_links
:
874 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
875 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
877 # check if there is a SAP in the link
878 if src_sap_id
in saps
:
879 # get dc where connected vnf is mapped to
880 dc
= vnfds
[dst_id
]['dc']
881 saps
[src_sap_id
]['dc'] = dc
883 if dst_sap_id
in saps
:
884 # get dc where connected vnf is mapped to
885 dc
= vnfds
[src_id
]['dc']
886 saps
[dst_sap_id
]['dc'] = dc
888 # SAPs on E-LANs are placed on a random DC
889 dcs_list
= list(dcs
.itervalues())
890 dc_len
= len(dcs_list
)
891 for link
in elan_fwd_links
:
892 for intf
in link
["connection_points_reference"]:
893 # find SAP interfaces
894 intf_id
, intf_name
, intf_sap_id
= parse_interface(intf
)
895 if intf_sap_id
in saps
:
896 dc
= dcs_list
[randint(0, dc_len
-1)]
897 saps
[intf_sap_id
]['dc'] = dc
902 Resource definitions and API endpoints
906 class Packages(fr
.Resource
):
910 Upload a *.son service package to the dummy gatekeeper.
912 We expect request with a *.son file and store it in UPLOAD_FOLDER
917 LOG
.info("POST /packages called")
918 # lets search for the package in the request
919 is_file_object
= False # make API more robust: file can be in data or in files field
920 if "package" in request
.files
:
921 son_file
= request
.files
["package"]
922 is_file_object
= True
923 elif len(request
.data
) > 0:
924 son_file
= request
.data
926 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
927 # generate a uuid to reference this package
928 service_uuid
= str(uuid
.uuid4())
929 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
930 # ensure that upload folder exists
931 ensure_dir(UPLOAD_FOLDER
)
932 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
933 # store *.son file to disk
935 son_file
.save(upload_path
)
937 with
open(upload_path
, 'wb') as f
:
939 size
= os
.path
.getsize(upload_path
)
941 # first stop and delete any other running services
943 service_list
= copy
.copy(GK
.services
)
944 for service_uuid
in service_list
:
945 instances_list
= copy
.copy(GK
.services
[service_uuid
].instances
)
946 for instance_uuid
in instances_list
:
947 # valid service and instance UUID, stop service
948 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
949 LOG
.info("service instance with uuid %r stopped." % instance_uuid
)
951 # create a service object and register it
952 s
= Service(service_uuid
, file_hash
, upload_path
)
953 GK
.register_service_package(service_uuid
, s
)
955 # automatically deploy the service
957 # ok, we have a service uuid, lets start the service
959 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
961 # generate the JSON result
962 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
963 except Exception as ex
:
964 LOG
.exception("Service package upload failed:")
965 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
969 Return a list of UUID's of uploaded service packages.
972 LOG
.info("GET /packages")
973 return {"service_uuid_list": list(GK
.services
.iterkeys())}
976 class Instantiations(fr
.Resource
):
980 Instantiate a service specified by its UUID.
981 Will return a new UUID to identify the running service instance.
984 LOG
.info("POST /instantiations (or /requests) called")
985 # try to extract the service uuid from the request
986 json_data
= request
.get_json(force
=True)
987 service_uuid
= json_data
.get("service_uuid")
989 # lets be a bit fuzzy here to make testing easier
990 if (service_uuid
is None or service_uuid
=="latest") and len(GK
.services
) > 0:
991 # if we don't get a service uuid, we simple start the first service in the list
992 service_uuid
= list(GK
.services
.iterkeys())[0]
993 if service_uuid
in GK
.services
:
994 # ok, we have a service uuid, lets start the service
995 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
996 return {"service_instance_uuid": service_instance_uuid
}, 201
997 return "Service not found", 404
1001 Returns a list of UUIDs containing all running services.
1002 :return: dict / list
1004 LOG
.info("GET /instantiations")
1005 return {"service_instantiations_list": [
1006 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
1010 Stops a running service specified by its service and instance UUID.
1012 # try to extract the service and instance UUID from the request
1013 json_data
= request
.get_json(force
=True)
1014 service_uuid
= json_data
.get("service_uuid")
1015 instance_uuid
= json_data
.get("service_instance_uuid")
1018 if service_uuid
is None and len(GK
.services
) > 0:
1019 #if we don't get a service uuid, we simply stop the last service in the list
1020 service_uuid
= list(GK
.services
.iterkeys())[0]
1021 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
1022 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
1024 if service_uuid
in GK
.services
and instance_uuid
in GK
.services
[service_uuid
].instances
:
1025 # valid service and instance UUID, stop service
1026 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
1027 return "service instance with uuid %r stopped." % instance_uuid
,200
1028 return "Service not found", 404
1030 class Exit(fr
.Resource
):
1034 Stop the running Containernet instance regardless of data transmitted
1036 list(GK
.dcs
.values())[0].net
.stop()
1039 def initialize_GK():
1045 # create a single, global GK object
1049 app
= Flask(__name__
)
1050 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
1053 api
.add_resource(Packages
, '/packages', '/api/v2/packages')
1054 api
.add_resource(Instantiations
, '/instantiations', '/api/v2/instantiations', '/api/v2/requests')
1055 api
.add_resource(Exit
, '/emulator/exit')
1059 def start_rest_api(host
, port
, datacenters
=dict()):
1060 GK
.dcs
= datacenters
1061 GK
.net
= get_dc_network()
1062 # start the Flask server (not the best performance but ok for our use case)
1066 use_reloader
=False # this is needed to run Flask in a non-main thread
1070 def ensure_dir(name
):
1071 if not os
.path
.exists(name
):
1075 def load_yaml(path
):
1076 with
open(path
, "r") as f
:
1079 except yaml
.YAMLError
as exc
:
1080 LOG
.exception("YAML parse error")
1085 def make_relative_path(path
):
1086 if path
.startswith("file://"):
1087 path
= path
.replace("file://", "", 1)
1088 if path
.startswith("/"):
1089 path
= path
.replace("/", "", 1)
1093 def get_dc_network():
1095 retrieve the DCnetwork where this dummygatekeeper (GK) connects to.
1096 Assume at least 1 datacenter is connected to this GK, and that all datacenters belong to the same DCNetwork
1099 assert (len(GK
.dcs
) > 0)
1100 return GK
.dcs
.values()[0].net
1103 def parse_interface(interface_name
):
1105 convert the interface name in the nsd to the according vnf_id, vnf_interface names
1106 :param interface_name:
1110 if ':' in interface_name
:
1111 vnf_id
, vnf_interface
= interface_name
.split(':')
1112 vnf_sap_docker_name
= interface_name
.replace(':', '_')
1114 vnf_id
= interface_name
1115 vnf_interface
= interface_name
1116 vnf_sap_docker_name
= interface_name
1118 return vnf_id
, vnf_interface
, vnf_sap_docker_name
1120 def reset_subnets():
1121 # private subnet definitions for the generated interfaces
1124 SAP_SUBNETS
= generate_subnets('10.10', 0, subnet_size
=50, mask
=30)
1127 ELAN_SUBNETS
= generate_subnets('10.20', 0, subnet_size
=50, mask
=24)
1129 global ELINE_SUBNETS
1130 ELINE_SUBNETS
= generate_subnets('10.30', 0, subnet_size
=50, mask
=30)
1132 if __name__
== '__main__':
1134 Lets allow to run the API in standalone mode.
1136 GK_STANDALONE_MODE
= True
1137 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
1138 start_rest_api("0.0.0.0", 8000)