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, Paderborn University
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 # Attention: Only done if ""forwarding_graphs" section in NSD exists,
215 # even if "forwarding_graphs" are not used directly.
216 if "virtual_links" in self
.nsd
and "forwarding_graphs" in self
.nsd
:
217 vlinks
= self
.nsd
["virtual_links"]
218 # constituent virtual links are not checked
219 #fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
220 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
221 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
223 GK
.net
.deployed_elines
.extend(eline_fwd_links
)
224 GK
.net
.deployed_elans
.extend(elan_fwd_links
)
226 # 5a. deploy E-Line links
227 self
._connect
_elines
(eline_fwd_links
, instance_uuid
)
229 # 5b. deploy E-LAN links
230 self
._connect
_elans
(elan_fwd_links
, instance_uuid
)
232 # 6. run the emulator specific entrypoint scripts in the VNFIs of this service instance
233 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
235 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
238 def stop_service(self
, instance_uuid
):
240 This method stops a running service instance.
241 It iterates over all VNF instances, stopping them each
242 and removing them from their data center.
244 :param instance_uuid: the uuid of the service instance to be stopped
246 LOG
.info("Stopping service %r" % self
.uuid
)
247 # get relevant information
248 # instance_uuid = str(self.uuid.uuid4())
249 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
251 # trigger stop skripts in vnf instances and wait a few seconds for completion
252 self
._trigger
_emulator
_stop
_scripts
_in
_vnfis
(vnf_instances
)
253 time
.sleep(VNF_STOP_WAIT_TIME
)
255 for v
in vnf_instances
:
258 for sap_name
in self
.saps_ext
:
259 ext_sap
= self
.saps
[sap_name
]
260 target_dc
= ext_sap
.get("dc")
261 target_dc
.removeExternalSAP(sap_name
)
262 LOG
.info("Stopping the SAP instance: %r in DC %r" % (sap_name
, target_dc
))
264 if not GK_STANDALONE_MODE
:
266 # self._remove_placement(RoundRobinPlacement)
269 # last step: remove the instance from the list of all instances
270 del self
.instances
[instance_uuid
]
272 def _start_vnfd(self
, vnfd
, vnf_id
, **kwargs
):
274 Start a single VNFD of this service
275 :param vnfd: vnfd descriptor dict
276 :param vnf_id: unique id of this vnf in the nsd
279 # the vnf_name refers to the container image to be deployed
280 vnf_name
= vnfd
.get("name")
282 # iterate over all deployment units within each VNFDs
283 for u
in vnfd
.get("virtual_deployment_units"):
284 # 1. get the name of the docker image to start and the assigned DC
285 if vnf_id
not in self
.remote_docker_image_urls
:
286 raise Exception("No image name for %r found. Abort." % vnf_id
)
287 docker_name
= self
.remote_docker_image_urls
.get(vnf_id
)
288 target_dc
= vnfd
.get("dc")
289 # 2. perform some checks to ensure we can start the container
290 assert(docker_name
is not None)
291 assert(target_dc
is not None)
292 if not self
._check
_docker
_image
_exists
(docker_name
):
293 raise Exception("Docker image %r not found. Abort." % docker_name
)
295 # 3. get the resource limits
296 res_req
= u
.get("resource_requirements")
297 cpu_list
= res_req
.get("cpu").get("cores")
299 cpu_list
= res_req
.get("cpu").get("vcpus")
302 cpu_bw
= res_req
.get("cpu").get("cpu_bw")
305 mem_num
= str(res_req
.get("memory").get("size"))
308 mem_unit
= str(res_req
.get("memory").get("size_unit"))
311 mem_limit
= float(mem_num
)
313 mem_limit
=mem_limit
*1024*1024*1024
315 mem_limit
=mem_limit
*1024*1024
317 mem_limit
=mem_limit
*1024
318 mem_lim
= int(mem_limit
)
319 cpu_period
, cpu_quota
= self
._calculate
_cpu
_cfs
_values
(float(cpu_bw
))
321 # check if we need to deploy the management ports (defined as type:management both on in the vnfd and nsd)
322 intfs
= vnfd
.get("connection_points", [])
325 mgmt_intfs
= [vnf_id
+ ':' + intf
['id'] for intf
in intfs
if intf
.get('type') == 'management']
326 # check if any of these management interfaces are used in a management-type network in the nsd
327 for nsd_intf_name
in mgmt_intfs
:
328 vlinks
= [ l
["connection_points_reference"] for l
in self
.nsd
.get("virtual_links", [])]
330 if nsd_intf_name
in link
and self
.check_mgmt_interface(link
):
331 # this is indeed a management interface and can be skipped
332 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(nsd_intf_name
)
333 found_interfaces
= [intf
for intf
in intfs
if intf
.get('id') == vnf_interface
]
334 intfs
.remove(found_interfaces
[0])
335 mgmt_intf_names
.append(vnf_interface
)
337 # 4. generate the volume paths for the docker container
339 # a volume to extract log files
340 docker_log_path
= "/tmp/results/%s/%s"%(self
.uuid
,vnf_id
)
341 LOG
.debug("LOG path for vnf %s is %s."%(vnf_id
,docker_log_path
))
342 if not os
.path
.exists(docker_log_path
):
343 LOG
.debug("Creating folder %s"%docker
_log
_path
)
344 os
.makedirs(docker_log_path
)
346 volumes
.append(docker_log_path
+":/mnt/share/")
349 # 5. do the dc.startCompute(name="foobar") call to run the container
350 # TODO consider flavors, and other annotations
351 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
352 # use the vnf_id in the nsd as docker name
353 # so deployed containers can be easily mapped back to the nsd
354 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, vnf_id
, vnfd
.get("dc")))
355 LOG
.debug("Interfaces for %r: %r" % (vnf_id
, intfs
))
356 vnfi
= target_dc
.startCompute(
362 cpu_period
=cpu_period
,
366 type=kwargs
.get('type','docker'))
368 # rename the docker0 interfaces (eth0) to the management port name defined in the VNFD
370 for intf_name
in mgmt_intf_names
:
371 self
._vnf
_reconfigure
_network
(vnfi
, 'eth0', new_name
=intf_name
)
375 def _stop_vnfi(self
, vnfi
):
379 :param vnfi: vnf instance to be stopped
381 # Find the correct datacenter
382 status
= vnfi
.getStatus()
386 LOG
.info("Stopping the vnf instance contained in %r in DC %r" % (status
["name"], dc
))
387 dc
.stopCompute(status
["name"])
389 def _get_vnf_instance(self
, instance_uuid
, vnf_id
):
391 Returns the Docker object for the given VNF id (or Docker name).
392 :param instance_uuid: UUID of the service instance to search in.
393 :param name: VNF name or Docker name. We are fuzzy here.
397 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
400 LOG
.warning("No container with name: {0} found.".format(dn
))
404 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
=None, new_name
=None):
406 Reconfigure the network configuration of a specific interface
407 of a running container.
408 :param vnfi: container instance
409 :param if_name: interface name
410 :param net_str: network configuration string, e.g., 1.2.3.4/24
414 # assign new ip address
415 if net_str
is not None:
416 intf
= vnfi
.intf(intf
=if_name
)
419 LOG
.debug("Reconfigured network of %s:%s to %r" % (vnfi
.name
, if_name
, net_str
))
421 LOG
.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi
.name
, if_name
))
423 if new_name
is not None:
424 vnfi
.cmd('ip link set', if_name
, 'down')
425 vnfi
.cmd('ip link set', if_name
, 'name', new_name
)
426 vnfi
.cmd('ip link set', new_name
, 'up')
427 LOG
.debug("Reconfigured interface name of %s:%s to %s" % (vnfi
.name
, if_name
, new_name
))
431 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
432 for vnfi
in vnfi_list
:
433 config
= vnfi
.dcinfo
.get("Config", dict())
434 env
= config
.get("Env", list())
436 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
437 LOG
.debug("%r = %r" % (var
, cmd
))
438 if var
=="SON_EMU_CMD":
439 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
440 # execute command in new thread to ensure that GK is not blocked by VNF
441 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
445 def _trigger_emulator_stop_scripts_in_vnfis(self
, vnfi_list
):
446 for vnfi
in vnfi_list
:
447 config
= vnfi
.dcinfo
.get("Config", dict())
448 env
= config
.get("Env", list())
450 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
451 if var
=="SON_EMU_CMD_STOP":
452 LOG
.info("Executing stop script in %r: %r" % (vnfi
.name
, cmd
))
453 # execute command in new thread to ensure that GK is not blocked by VNF
454 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
460 def _unpack_service_package(self
):
462 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
464 LOG
.info("Unzipping: %r" % self
.package_file_path
)
465 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
466 z
.extractall(self
.package_content_path
)
469 def _load_package_descriptor(self
):
471 Load the main package descriptor YAML and keep it as dict.
474 self
.manifest
= load_yaml(
476 self
.package_content_path
, "META-INF/MANIFEST.MF"))
480 Load the entry NSD YAML and keep it as dict.
483 if "entry_service_template" in self
.manifest
:
484 nsd_path
= os
.path
.join(
485 self
.package_content_path
,
486 make_relative_path(self
.manifest
.get("entry_service_template")))
487 self
.nsd
= load_yaml(nsd_path
)
488 GK
.net
.deployed_nsds
.append(self
.nsd
)
489 # create dict to find the vnf_name for any vnf id
490 self
.vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
491 reduce(lambda x
, y
: dict(x
, **y
),
492 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
493 self
.nsd
["network_functions"])))
495 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
497 def _load_vnfd(self
):
499 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
503 # first make a list of all the vnfds in the package
505 if "package_content" in self
.manifest
:
506 for pc
in self
.manifest
.get("package_content"):
507 if pc
.get("content-type") == "application/sonata.function_descriptor":
508 vnfd_path
= os
.path
.join(
509 self
.package_content_path
,
510 make_relative_path(pc
.get("name")))
511 vnfd
= load_yaml(vnfd_path
)
512 vnfd_set
[vnfd
.get("name")] = vnfd
513 # then link each vnf_id in the nsd to its vnfd
514 for vnf_id
in self
.vnf_id2vnf_name
:
515 vnf_name
= self
.vnf_id2vnf_name
[vnf_id
]
516 self
.vnfds
[vnf_id
] = vnfd_set
[vnf_name
]
517 LOG
.debug("Loaded VNFD: {0} id: {1}".format(vnf_name
, vnf_id
))
519 def _load_saps(self
):
520 # create list of all SAPs
521 # check if we need to deploy management ports
523 SAPs
= [p
for p
in self
.nsd
["connection_points"] if 'management' not in p
.get('type')]
525 SAPs
= [p
for p
in self
.nsd
["connection_points"]]
528 # endpoint needed in this service
529 sap_id
, sap_interface
, sap_docker_name
= parse_interface(sap
['id'])
530 # make sure SAP has type set (default internal)
531 sap
["type"] = sap
.get("type", 'internal')
533 # Each Service Access Point (connection_point) in the nsd is an IP address on the host
534 if sap
["type"] == "external":
535 # add to vnfds to calculate placement later on
536 sap_net
= SAP_SUBNETS
.pop(0)
537 self
.saps
[sap_docker_name
] = {"name": sap_docker_name
, "type": "external", "net": sap_net
}
538 # add SAP vnf to list in the NSD so it is deployed later on
539 # each SAP gets a unique VNFD and vnf_id in the NSD and custom type (only defined in the dummygatekeeper)
540 self
.nsd
["network_functions"].append(
541 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_ext"})
543 # Each Service Access Point (connection_point) in the nsd is getting its own container (default)
544 elif sap
["type"] == "internal" or sap
["type"] == "management":
545 # add SAP to self.vnfds
547 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
550 sap_vnfd
= load_yaml(sapfile
)
551 sap_vnfd
["connection_points"][0]["id"] = sap_interface
552 sap_vnfd
["name"] = sap_docker_name
553 sap_vnfd
["type"] = "internal"
554 # add to vnfds to calculate placement later on and deploy
555 self
.saps
[sap_docker_name
] = sap_vnfd
556 # add SAP vnf to list in the NSD so it is deployed later on
557 # each SAP get a unique VNFD and vnf_id in the NSD
558 self
.nsd
["network_functions"].append(
559 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_int"})
561 LOG
.debug("Loaded SAP: name: {0}, type: {1}".format(sap_docker_name
, sap
['type']))
564 self
.saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
565 self
.saps_int
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "internal"]
567 def _start_sap(self
, sap
, instance_uuid
):
571 LOG
.info('start SAP: {0} ,type: {1}'.format(sap
['name'],sap
['type']))
572 if sap
["type"] == "internal":
574 if not GK_STANDALONE_MODE
:
575 vnfi
= self
._start
_vnfd
(sap
, sap
['name'], type='sap_int')
576 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
578 elif sap
["type"] == "external":
579 target_dc
= sap
.get("dc")
580 # add interface to dc switch
581 target_dc
.attachExternalSAP(sap
['name'], sap
['net'])
583 def _connect_elines(self
, eline_fwd_links
, instance_uuid
):
585 Connect all E-LINE links in the NSD
586 :param eline_fwd_links: list of E-LINE links in the NSD
587 :param: instance_uuid of the service
590 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
591 # eg. different services get a unique cookie for their flowrules
593 for link
in eline_fwd_links
:
594 # check if we need to deploy this link when its a management link:
596 if self
.check_mgmt_interface(link
["connection_points_reference"]):
599 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
600 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
603 # check if there is a SAP in the link and chain everything together
604 if src_sap_id
in self
.saps
and dst_sap_id
in self
.saps
:
605 LOG
.info('2 SAPs cannot be chained together : {0} - {1}'.format(src_sap_id
, dst_sap_id
))
608 elif src_sap_id
in self
.saps_ext
:
610 # set intf name to None so the chaining function will choose the first one
612 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_id
)
613 if dst_vnfi
is not None:
614 # choose first ip address in sap subnet
615 sap_net
= self
.saps
[src_sap_id
]['net']
616 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
617 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, sap_ip
)
620 elif dst_sap_id
in self
.saps_ext
:
622 # set intf name to None so the chaining function will choose the first one
624 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_id
)
625 if src_vnfi
is not None:
626 sap_net
= self
.saps
[dst_sap_id
]['net']
627 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
628 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, sap_ip
)
631 # Link between 2 VNFs
633 # make sure we use the correct sap vnf name
634 if src_sap_id
in self
.saps_int
:
636 if dst_sap_id
in self
.saps_int
:
638 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
639 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_id
)
640 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_id
)
641 if src_vnfi
is not None and dst_vnfi
is not None:
642 eline_net
= ELINE_SUBNETS
.pop(0)
643 ip1
= "{0}/{1}".format(str(eline_net
[1]), eline_net
.prefixlen
)
644 ip2
= "{0}/{1}".format(str(eline_net
[2]), eline_net
.prefixlen
)
645 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, ip1
)
646 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, ip2
)
651 ret
= GK
.net
.setChain(
653 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
654 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
656 "Setting up E-Line link. (%s:%s) -> (%s:%s)" % (
657 src_id
, src_if_name
, dst_id
, dst_if_name
))
660 def _connect_elans(self
, elan_fwd_links
, instance_uuid
):
662 Connect all E-LAN links in the NSD
663 :param elan_fwd_links: list of E-LAN links in the NSD
664 :param: instance_uuid of the service
667 for link
in elan_fwd_links
:
668 # check if we need to deploy this link when its a management link:
670 if self
.check_mgmt_interface(link
["connection_points_reference"]):
674 # check if an external SAP is in the E-LAN (then a subnet is already defined)
675 intfs_elan
= [intf
for intf
in link
["connection_points_reference"]]
676 lan_sap
= self
.check_ext_saps(intfs_elan
)
678 lan_net
= self
.saps
[lan_sap
]['net']
679 lan_hosts
= list(lan_net
.hosts())
680 sap_ip
= str(lan_hosts
.pop(0))
682 lan_net
= ELAN_SUBNETS
.pop(0)
683 lan_hosts
= list(lan_net
.hosts())
685 # generate lan ip address for all interfaces except external SAPs
686 for intf
in link
["connection_points_reference"]:
688 # skip external SAPs, they already have an ip
689 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf
)
690 if vnf_sap_docker_name
in self
.saps_ext
:
691 elan_vnf_list
.append({'name': vnf_sap_docker_name
, 'interface': vnf_interface
})
694 ip_address
= "{0}/{1}".format(str(lan_hosts
.pop(0)), lan_net
.prefixlen
)
695 vnf_id
, intf_name
, vnf_sap_id
= parse_interface(intf
)
697 # make sure we use the correct sap vnf name
698 src_docker_name
= vnf_id
699 if vnf_sap_id
in self
.saps_int
:
700 src_docker_name
= vnf_sap_id
704 "Setting up E-LAN interface. (%s:%s) -> %s" % (
705 vnf_id
, intf_name
, ip_address
))
707 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
708 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
709 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
710 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_id
)
712 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
713 # add this vnf and interface to the E-LAN for tagging
714 elan_vnf_list
.append({'name': src_docker_name
, 'interface': intf_name
})
716 # install the VLAN tags for this E-LAN
717 GK
.net
.setLAN(elan_vnf_list
)
720 def _load_docker_files(self
):
722 Get all paths to Dockerfiles from VNFDs and store them in dict.
725 for k
, v
in self
.vnfds
.iteritems():
726 for vu
in v
.get("virtual_deployment_units"):
727 if vu
.get("vm_image_format") == "docker":
728 vm_image
= vu
.get("vm_image")
729 docker_path
= os
.path
.join(
730 self
.package_content_path
,
731 make_relative_path(vm_image
))
732 self
.local_docker_files
[k
] = docker_path
733 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
735 def _load_docker_urls(self
):
737 Get all URLs to pre-build docker images in some repo.
740 # also merge sap dicts, because internal saps also need a docker container
741 all_vnfs
= self
.vnfds
.copy()
742 all_vnfs
.update(self
.saps
)
744 for k
, v
in all_vnfs
.iteritems():
745 for vu
in v
.get("virtual_deployment_units", {}):
746 if vu
.get("vm_image_format") == "docker":
747 url
= vu
.get("vm_image")
749 url
= url
.replace("http://", "")
750 self
.remote_docker_image_urls
[k
] = url
751 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
753 def _build_images_from_dockerfiles(self
):
755 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
757 if GK_STANDALONE_MODE
:
758 return # do not build anything in standalone mode
760 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
761 for k
, v
in self
.local_docker_files
.iteritems():
762 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
763 LOG
.debug("DOCKER BUILD: %s" % line
)
764 LOG
.info("Docker image created: %s" % k
)
766 def _pull_predefined_dockerimages(self
):
768 If the package contains URLs to pre-build Docker images, we download them with this method.
771 for url
in self
.remote_docker_image_urls
.itervalues():
772 if not FORCE_PULL
: # only pull if not present (speedup for development)
773 if len(dc
.images
.list(name
=url
)) > 0:
774 LOG
.debug("Image %r present. Skipping pull." % url
)
776 LOG
.info("Pulling image: %r" % url
)
777 # this seems to fail with latest docker api version 2.0.2
778 # dc.images.pull(url,
779 # insecure_registry=True)
780 #using docker cli instead
790 def _check_docker_image_exists(self
, image_name
):
792 Query the docker service and check if the given image exists
793 :param image_name: name of the docker image
796 return len(DockerClient().images
.list(name
=image_name
)) > 0
798 def _calculate_placement(self
, algorithm
):
800 Do placement by adding the a field "dc" to
801 each VNFD that points to one of our
802 data center objects known to the gatekeeper.
804 assert(len(self
.vnfds
) > 0)
805 assert(len(GK
.dcs
) > 0)
806 # instantiate algorithm an place
808 p
.place(self
.nsd
, self
.vnfds
, self
.saps
, GK
.dcs
)
809 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
810 # lets print the placement result
811 for name
, vnfd
in self
.vnfds
.iteritems():
812 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
813 for sap
in self
.saps
:
814 sap_dict
= self
.saps
[sap
]
815 LOG
.info("Placed SAP %r on DC %r" % (sap
, str(sap_dict
.get("dc"))))
818 def _calculate_cpu_cfs_values(self
, cpu_time_percentage
):
820 Calculate cpu period and quota for CFS
821 :param cpu_time_percentage: percentage of overall CPU to be used
822 :return: cpu_period, cpu_quota
824 if cpu_time_percentage
is None:
826 if cpu_time_percentage
< 0:
828 # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
829 # Attention minimum cpu_quota is 1ms (micro)
830 cpu_period
= 1000000 # lets consider a fixed period of 1000000 microseconds for now
831 LOG
.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period
, cpu_time_percentage
))
832 cpu_quota
= cpu_period
* cpu_time_percentage
# calculate the fraction of cpu time for this container
833 # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
835 LOG
.debug("cpu_quota before correcting: %r" % cpu_quota
)
837 LOG
.warning("Increased CPU quota to avoid system error.")
838 LOG
.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period
, cpu_quota
))
839 return int(cpu_period
), int(cpu_quota
)
841 def check_ext_saps(self
, intf_list
):
842 # check if the list of interfacs contains an external SAP
843 saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
844 for intf_name
in intf_list
:
845 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf_name
)
846 if vnf_sap_docker_name
in saps_ext
:
847 return vnf_sap_docker_name
849 def check_mgmt_interface(self
, intf_list
):
850 SAPs_mgmt
= [p
.get('id') for p
in self
.nsd
["connection_points"] if 'management' in p
.get('type')]
851 for intf_name
in intf_list
:
852 if intf_name
in SAPs_mgmt
:
856 Some (simple) placement algorithms
860 class FirstDcPlacement(object):
862 Placement: Always use one and the same data center from the GK.dcs dict.
864 def place(self
, nsd
, vnfds
, saps
, dcs
):
865 for id, vnfd
in vnfds
.iteritems():
866 vnfd
["dc"] = list(dcs
.itervalues())[0]
869 class RoundRobinDcPlacement(object):
871 Placement: Distribute VNFs across all available DCs in a round robin fashion.
873 def place(self
, nsd
, vnfds
, saps
, dcs
):
875 dcs_list
= list(dcs
.itervalues())
876 for id, vnfd
in vnfds
.iteritems():
877 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
878 c
+= 1 # inc. c to use next DC
880 class RoundRobinDcPlacementWithSAPs(object):
882 Placement: Distribute VNFs across all available DCs in a round robin fashion,
883 every SAP is instantiated on the same DC as the connected VNF.
885 def place(self
, nsd
, vnfds
, saps
, dcs
):
889 dcs_list
= list(dcs
.itervalues())
890 for id, vnfd
in vnfds
.iteritems():
891 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
892 c
+= 1 # inc. c to use next DC
895 vlinks
= nsd
.get("virtual_links", [])
896 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
897 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
899 # SAPs on E-Line links are placed on the same DC as the VNF on the E-Line
900 for link
in eline_fwd_links
:
901 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
902 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
904 # check if there is a SAP in the link
905 if src_sap_id
in saps
:
906 # get dc where connected vnf is mapped to
907 dc
= vnfds
[dst_id
]['dc']
908 saps
[src_sap_id
]['dc'] = dc
910 if dst_sap_id
in saps
:
911 # get dc where connected vnf is mapped to
912 dc
= vnfds
[src_id
]['dc']
913 saps
[dst_sap_id
]['dc'] = dc
915 # SAPs on E-LANs are placed on a random DC
916 dcs_list
= list(dcs
.itervalues())
917 dc_len
= len(dcs_list
)
918 for link
in elan_fwd_links
:
919 for intf
in link
["connection_points_reference"]:
920 # find SAP interfaces
921 intf_id
, intf_name
, intf_sap_id
= parse_interface(intf
)
922 if intf_sap_id
in saps
:
923 dc
= dcs_list
[randint(0, dc_len
-1)]
924 saps
[intf_sap_id
]['dc'] = dc
929 Resource definitions and API endpoints
933 class Packages(fr
.Resource
):
937 Upload a *.son service package to the dummy gatekeeper.
939 We expect request with a *.son file and store it in UPLOAD_FOLDER
944 LOG
.info("POST /packages called")
945 # lets search for the package in the request
946 is_file_object
= False # make API more robust: file can be in data or in files field
947 if "package" in request
.files
:
948 son_file
= request
.files
["package"]
949 is_file_object
= True
950 elif len(request
.data
) > 0:
951 son_file
= request
.data
953 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
954 # generate a uuid to reference this package
955 service_uuid
= str(uuid
.uuid4())
956 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
957 # ensure that upload folder exists
958 ensure_dir(UPLOAD_FOLDER
)
959 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
960 # store *.son file to disk
962 son_file
.save(upload_path
)
964 with
open(upload_path
, 'wb') as f
:
966 size
= os
.path
.getsize(upload_path
)
968 # first stop and delete any other running services
970 service_list
= copy
.copy(GK
.services
)
971 for service_uuid
in service_list
:
972 instances_list
= copy
.copy(GK
.services
[service_uuid
].instances
)
973 for instance_uuid
in instances_list
:
974 # valid service and instance UUID, stop service
975 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
976 LOG
.info("service instance with uuid %r stopped." % instance_uuid
)
978 # create a service object and register it
979 s
= Service(service_uuid
, file_hash
, upload_path
)
980 GK
.register_service_package(service_uuid
, s
)
982 # automatically deploy the service
984 # ok, we have a service uuid, lets start the service
986 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
988 # generate the JSON result
989 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
990 except Exception as ex
:
991 LOG
.exception("Service package upload failed:")
992 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
996 Return a list of UUID's of uploaded service packages.
999 LOG
.info("GET /packages")
1000 return {"service_uuid_list": list(GK
.services
.iterkeys())}
1003 class Instantiations(fr
.Resource
):
1007 Instantiate a service specified by its UUID.
1008 Will return a new UUID to identify the running service instance.
1011 LOG
.info("POST /instantiations (or /requests) called")
1012 # try to extract the service uuid from the request
1013 json_data
= request
.get_json(force
=True)
1014 service_uuid
= json_data
.get("service_uuid")
1016 # lets be a bit fuzzy here to make testing easier
1017 if (service_uuid
is None or service_uuid
=="latest") and len(GK
.services
) > 0:
1018 # if we don't get a service uuid, we simple start the first service in the list
1019 service_uuid
= list(GK
.services
.iterkeys())[0]
1020 if service_uuid
in GK
.services
:
1021 # ok, we have a service uuid, lets start the service
1022 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
1023 return {"service_instance_uuid": service_instance_uuid
}, 201
1024 return "Service not found", 404
1028 Returns a list of UUIDs containing all running services.
1029 :return: dict / list
1031 LOG
.info("GET /instantiations")
1032 return {"service_instantiations_list": [
1033 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
1037 Stops a running service specified by its service and instance UUID.
1039 # try to extract the service and instance UUID from the request
1040 json_data
= request
.get_json(force
=True)
1041 service_uuid
= json_data
.get("service_uuid")
1042 instance_uuid
= json_data
.get("service_instance_uuid")
1045 if service_uuid
is None and len(GK
.services
) > 0:
1046 #if we don't get a service uuid, we simply stop the last service in the list
1047 service_uuid
= list(GK
.services
.iterkeys())[0]
1048 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
1049 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
1051 if service_uuid
in GK
.services
and instance_uuid
in GK
.services
[service_uuid
].instances
:
1052 # valid service and instance UUID, stop service
1053 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
1054 return "service instance with uuid %r stopped." % instance_uuid
,200
1055 return "Service not found", 404
1057 class Exit(fr
.Resource
):
1061 Stop the running Containernet instance regardless of data transmitted
1063 list(GK
.dcs
.values())[0].net
.stop()
1066 def initialize_GK():
1072 # create a single, global GK object
1076 app
= Flask(__name__
)
1077 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
1080 api
.add_resource(Packages
, '/packages', '/api/v2/packages')
1081 api
.add_resource(Instantiations
, '/instantiations', '/api/v2/instantiations', '/api/v2/requests')
1082 api
.add_resource(Exit
, '/emulator/exit')
1086 def start_rest_api(host
, port
, datacenters
=dict()):
1087 GK
.dcs
= datacenters
1088 GK
.net
= get_dc_network()
1089 # start the Flask server (not the best performance but ok for our use case)
1093 use_reloader
=False # this is needed to run Flask in a non-main thread
1097 def ensure_dir(name
):
1098 if not os
.path
.exists(name
):
1102 def load_yaml(path
):
1103 with
open(path
, "r") as f
:
1106 except yaml
.YAMLError
as exc
:
1107 LOG
.exception("YAML parse error")
1112 def make_relative_path(path
):
1113 if path
.startswith("file://"):
1114 path
= path
.replace("file://", "", 1)
1115 if path
.startswith("/"):
1116 path
= path
.replace("/", "", 1)
1120 def get_dc_network():
1122 retrieve the DCnetwork where this dummygatekeeper (GK) connects to.
1123 Assume at least 1 datacenter is connected to this GK, and that all datacenters belong to the same DCNetwork
1126 assert (len(GK
.dcs
) > 0)
1127 return GK
.dcs
.values()[0].net
1130 def parse_interface(interface_name
):
1132 convert the interface name in the nsd to the according vnf_id, vnf_interface names
1133 :param interface_name:
1137 if ':' in interface_name
:
1138 vnf_id
, vnf_interface
= interface_name
.split(':')
1139 vnf_sap_docker_name
= interface_name
.replace(':', '_')
1141 vnf_id
= interface_name
1142 vnf_interface
= interface_name
1143 vnf_sap_docker_name
= interface_name
1145 return vnf_id
, vnf_interface
, vnf_sap_docker_name
1147 def reset_subnets():
1148 # private subnet definitions for the generated interfaces
1151 SAP_SUBNETS
= generate_subnets('10.10', 0, subnet_size
=50, mask
=30)
1154 ELAN_SUBNETS
= generate_subnets('10.20', 0, subnet_size
=50, mask
=24)
1156 global ELINE_SUBNETS
1157 ELINE_SUBNETS
= generate_subnets('10.30', 0, subnet_size
=50, mask
=30)
1159 if __name__
== '__main__':
1161 Lets allow to run the API in standalone mode.
1163 GK_STANDALONE_MODE
= True
1164 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
1165 start_rest_api("0.0.0.0", 8000)