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)
102 class Gatekeeper(object):
105 self
.services
= dict()
108 self
.vnf_counter
= 0 # used to generate short names for VNFs (Mininet limitation)
109 LOG
.info("Create SONATA dummy gatekeeper.")
111 def register_service_package(self
, service_uuid
, service
):
113 register new service package
115 :param service object
117 self
.services
[service_uuid
] = service
118 # lets perform all steps needed to onboard the service
121 def get_next_vnf_name(self
):
122 self
.vnf_counter
+= 1
123 return "vnf%d" % self
.vnf_counter
126 class Service(object):
128 This class represents a NS uploaded as a *.son package to the
130 Can have multiple running instances of this service.
137 self
.uuid
= service_uuid
138 self
.package_file_hash
= package_file_hash
139 self
.package_file_path
= package_file_path
140 self
.package_content_path
= os
.path
.join(CATALOG_FOLDER
, "services/%s" % self
.uuid
)
145 self
.saps_ext
= list()
146 self
.saps_int
= list()
147 self
.local_docker_files
= dict()
148 self
.remote_docker_image_urls
= dict()
149 self
.instances
= dict()
150 self
.vnf_name2docker_name
= dict()
151 self
.vnf_id2vnf_name
= dict()
155 Do all steps to prepare this service to be instantiated
158 # 1. extract the contents of the package and store them in our catalog
159 self
._unpack
_service
_package
()
160 # 2. read in all descriptor files
161 self
._load
_package
_descriptor
()
166 # create dict to translate vnf names
167 self
.vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
168 reduce(lambda x
, y
: dict(x
, **y
),
169 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
170 self
.nsd
["network_functions"])))
171 # 3. prepare container images (e.g. download or build Dockerfile)
173 self
._load
_docker
_files
()
174 self
._build
_images
_from
_dockerfiles
()
176 self
._load
_docker
_urls
()
177 self
._pull
_predefined
_dockerimages
()
178 LOG
.info("On-boarded service: %r" % self
.manifest
.get("name"))
180 def start_service(self
):
182 This methods creates and starts a new service instance.
183 It computes placements, iterates over all VNFDs, and starts
184 each VNFD as a Docker container in the data center selected
185 by the placement algorithm.
188 LOG
.info("Starting service %r" % self
.uuid
)
190 # 1. each service instance gets a new uuid to identify it
191 instance_uuid
= str(uuid
.uuid4())
192 # build a instances dict (a bit like a NSR :))
193 self
.instances
[instance_uuid
] = dict()
194 self
.instances
[instance_uuid
]["vnf_instances"] = list()
196 # 2. compute placement of this service instance (adds DC names to VNFDs)
197 if not GK_STANDALONE_MODE
:
198 #self._calculate_placement(FirstDcPlacement)
199 self
._calculate
_placement
(RoundRobinDcPlacementWithSAPs
)
201 # 3. start all vnfds that we have in the service (except SAPs)
202 for vnfd
in self
.vnfds
.itervalues():
204 if not GK_STANDALONE_MODE
:
205 vnfi
= self
._start
_vnfd
(vnfd
)
206 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
208 # 4. start all SAPs in the service
209 for sap
in self
.saps
:
210 self
._start
_sap
(self
.saps
[sap
], instance_uuid
)
212 # 5. Deploy E-Line and E_LAN links
213 if "virtual_links" in self
.nsd
:
214 vlinks
= self
.nsd
["virtual_links"]
215 # constituent virtual links are not checked
216 #fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
217 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
218 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
220 GK
.net
.deployed_elines
.extend(eline_fwd_links
)
221 GK
.net
.deployed_elans
.extend(elan_fwd_links
)
223 # 5a. deploy E-Line links
224 self
._connect
_elines
(eline_fwd_links
, instance_uuid
)
226 # 5b. deploy E-LAN links
227 self
._connect
_elans
(elan_fwd_links
, instance_uuid
)
229 # 6. run the emulator specific entrypoint scripts in the VNFIs of this service instance
230 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
232 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
235 def stop_service(self
, instance_uuid
):
237 This method stops a running service instance.
238 It iterates over all VNF instances, stopping them each
239 and removing them from their data center.
241 :param instance_uuid: the uuid of the service instance to be stopped
243 LOG
.info("Stopping service %r" % self
.uuid
)
244 # get relevant information
245 # instance_uuid = str(self.uuid.uuid4())
246 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
248 for v
in vnf_instances
:
251 for sap_name
in self
.saps_ext
:
252 ext_sap
= self
.saps
[sap_name
]
253 target_dc
= ext_sap
.get("dc")
254 target_dc
.removeExternalSAP(sap_name
, ext_sap
['net'])
255 LOG
.info("Stopping the SAP instance: %r in DC %r" % (sap_name
, target_dc
))
257 if not GK_STANDALONE_MODE
:
259 # self._remove_placement(RoundRobinPlacement)
262 # last step: remove the instance from the list of all instances
263 del self
.instances
[instance_uuid
]
265 def _start_vnfd(self
, vnfd
):
267 Start a single VNFD of this service
268 :param vnfd: vnfd descriptor dict
271 # iterate over all deployment units within each VNFDs
272 for u
in vnfd
.get("virtual_deployment_units"):
273 # 1. get the name of the docker image to start and the assigned DC
274 vnf_name
= vnfd
.get("name")
275 if vnf_name
not in self
.remote_docker_image_urls
:
276 raise Exception("No image name for %r found. Abort." % vnf_name
)
277 docker_name
= self
.remote_docker_image_urls
.get(vnf_name
)
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 vnf_name2id
= defaultdict(lambda: "NotExistingNode",
310 reduce(lambda x
, y
: dict(x
, **y
),
311 map(lambda d
: {d
["vnf_name"]: d
["vnf_id"]},
312 self
.nsd
["network_functions"])))
314 # check if we need to deploy the management ports (defined as type:management both on in the vnfd and nsd)
315 intfs
= vnfd
.get("connection_points", [])
318 vnf_id
= vnf_name2id
[vnf_name
]
319 mgmt_intfs
= [vnf_id
+ ':' + intf
['id'] for intf
in intfs
if intf
.get('type') == 'management']
320 # check if any of these management interfaces are used in a management-type network in the nsd
321 for nsd_intf_name
in mgmt_intfs
:
322 vlinks
= [ l
["connection_points_reference"] for l
in self
.nsd
.get("virtual_links", [])]
324 if nsd_intf_name
in link
and self
.check_mgmt_interface(link
):
325 # this is indeed a management interface and can be skipped
326 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(nsd_intf_name
)
327 found_interfaces
= [intf
for intf
in intfs
if intf
.get('id') == vnf_interface
]
328 intfs
.remove(found_interfaces
[0])
329 mgmt_intf_names
.append(vnf_interface
)
331 # 4. generate the volume paths for the docker container
333 # a volume to extract log files
334 docker_log_path
= "/tmp/results/%s/%s"%(self
.uuid
,vnf_name
)
335 LOG
.debug("LOG path for vnf %s is %s."%(vnf_name
,docker_log_path
))
336 if not os
.path
.exists(docker_log_path
):
337 LOG
.debug("Creating folder %s"%docker
_log
_path
)
338 os
.makedirs(docker_log_path
)
340 volumes
.append(docker_log_path
+":/mnt/share/")
343 # 5. do the dc.startCompute(name="foobar") call to run the container
344 # TODO consider flavors, and other annotations
345 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
346 # use the vnf_id in the nsd as docker name
347 # so deployed containers can be easily mapped back to the nsd
349 self
.vnf_name2docker_name
[vnf_name
] = vnf_name2id
[vnf_name
]
351 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, self
.vnf_name2docker_name
[vnf_name
], vnfd
.get("dc")))
352 LOG
.debug("Interfaces for %r: %r" % (vnf_name
, intfs
))
353 vnfi
= target_dc
.startCompute(
354 self
.vnf_name2docker_name
[vnf_name
],
359 cpu_period
=cpu_period
,
364 # rename the docker0 interfaces (eth0) to the management port name defined in the VNFD
366 for intf_name
in mgmt_intf_names
:
367 self
._vnf
_reconfigure
_network
(vnfi
, 'eth0', new_name
=intf_name
)
371 def _stop_vnfi(self
, vnfi
):
375 :param vnfi: vnf instance to be stopped
377 # Find the correct datacenter
378 status
= vnfi
.getStatus()
382 LOG
.info("Stopping the vnf instance contained in %r in DC %r" % (status
["name"], dc
))
383 dc
.stopCompute(status
["name"])
385 def _get_vnf_instance(self
, instance_uuid
, name
):
387 Returns the Docker object for the given VNF name (or Docker name).
388 :param instance_uuid: UUID of the service instance to search in.
389 :param name: VNF name or Docker name. We are fuzzy here.
393 if name
in self
.vnf_name2docker_name
:
394 dn
= self
.vnf_name2docker_name
[name
]
395 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
398 LOG
.warning("No container with name: {0} found.".format(dn
))
402 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
=None, new_name
=None):
404 Reconfigure the network configuration of a specific interface
405 of a running container.
406 :param vnfi: container instance
407 :param if_name: interface name
408 :param net_str: network configuration string, e.g., 1.2.3.4/24
412 # assign new ip address
413 if net_str
is not None:
414 intf
= vnfi
.intf(intf
=if_name
)
417 LOG
.debug("Reconfigured network of %s:%s to %r" % (vnfi
.name
, if_name
, net_str
))
419 LOG
.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi
.name
, if_name
))
421 if new_name
is not None:
422 vnfi
.cmd('ip link set', if_name
, 'down')
423 vnfi
.cmd('ip link set', if_name
, 'name', new_name
)
424 vnfi
.cmd('ip link set', new_name
, 'up')
425 LOG
.debug("Reconfigured interface name of %s:%s to %s" % (vnfi
.name
, if_name
, new_name
))
429 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
430 for vnfi
in vnfi_list
:
431 config
= vnfi
.dcinfo
.get("Config", dict())
432 env
= config
.get("Env", list())
434 var
, cmd
= map(str.strip
, map(str, env_var
.split('=', 1)))
435 LOG
.debug("%r = %r" % (var
, cmd
))
436 if var
=="SON_EMU_CMD":
437 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
438 # execute command in new thread to ensure that GK is not blocked by VNF
439 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
443 def _unpack_service_package(self
):
445 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
447 LOG
.info("Unzipping: %r" % self
.package_file_path
)
448 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
449 z
.extractall(self
.package_content_path
)
452 def _load_package_descriptor(self
):
454 Load the main package descriptor YAML and keep it as dict.
457 self
.manifest
= load_yaml(
459 self
.package_content_path
, "META-INF/MANIFEST.MF"))
463 Load the entry NSD YAML and keep it as dict.
466 if "entry_service_template" in self
.manifest
:
467 nsd_path
= os
.path
.join(
468 self
.package_content_path
,
469 make_relative_path(self
.manifest
.get("entry_service_template")))
470 self
.nsd
= load_yaml(nsd_path
)
471 GK
.net
.deployed_nsds
.append(self
.nsd
)
473 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
475 def _load_vnfd(self
):
477 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
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 self
.vnfds
[vnfd
.get("name")] = vnfd
488 LOG
.debug("Loaded VNFD: %r" % vnfd
.get("name"))
490 def _load_saps(self
):
491 # create list of all SAPs
492 # check if we need to deploy management ports
494 SAPs
= [p
for p
in self
.nsd
["connection_points"] if 'management' not in p
.get('type')]
496 SAPs
= [p
for p
in self
.nsd
["connection_points"]]
499 # endpoint needed in this service
500 sap_id
, sap_interface
, sap_docker_name
= parse_interface(sap
['id'])
501 # make sure SAP has type set (default internal)
502 sap
["type"] = sap
.get("type", 'internal')
504 # Each Service Access Point (connection_point) in the nsd is an IP address on the host
505 if sap
["type"] == "external":
506 # add to vnfds to calculate placement later on
507 sap_net
= SAP_SUBNETS
.pop(0)
508 self
.saps
[sap_docker_name
] = {"name": sap_docker_name
, "type": "external", "net": sap_net
}
509 # add SAP vnf to list in the NSD so it is deployed later on
510 # each SAP get a unique VNFD and vnf_id in the NSD and custom type (only defined in the dummygatekeeper)
511 self
.nsd
["network_functions"].append(
512 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_ext"})
514 # Each Service Access Point (connection_point) in the nsd is getting its own container (default)
515 elif sap
["type"] == "internal" or sap
["type"] == "management":
516 # add SAP to self.vnfds
517 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
518 sap_vnfd
= load_yaml(sapfile
)
519 sap_vnfd
["connection_points"][0]["id"] = sap_interface
520 sap_vnfd
["name"] = sap_docker_name
521 sap_vnfd
["type"] = "internal"
522 # add to vnfds to calculate placement later on and deploy
523 self
.saps
[sap_docker_name
] = sap_vnfd
524 # add SAP vnf to list in the NSD so it is deployed later on
525 # each SAP get a unique VNFD and vnf_id in the NSD
526 self
.nsd
["network_functions"].append(
527 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_int"})
529 LOG
.debug("Loaded SAP: name: {0}, type: {1}".format(sap_docker_name
, sap
['type']))
532 self
.saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
533 self
.saps_int
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "internal"]
535 def _start_sap(self
, sap
, instance_uuid
):
539 LOG
.info('start SAP: {0} ,type: {1}'.format(sap
['name'],sap
['type']))
540 if sap
["type"] == "internal":
542 if not GK_STANDALONE_MODE
:
543 vnfi
= self
._start
_vnfd
(sap
)
544 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
546 elif sap
["type"] == "external":
547 target_dc
= sap
.get("dc")
548 # add interface to dc switch
549 target_dc
.attachExternalSAP(sap
['name'], sap
['net'])
551 def _connect_elines(self
, eline_fwd_links
, instance_uuid
):
553 Connect all E-LINE links in the NSD
554 :param eline_fwd_links: list of E-LINE links in the NSD
555 :param: instance_uuid of the service
558 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
559 # eg. different services get a unique cookie for their flowrules
561 for link
in eline_fwd_links
:
562 # check if we need to deploy this link when its a management link:
564 if self
.check_mgmt_interface(link
["connection_points_reference"]):
567 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
568 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
571 # check if there is a SAP in the link and chain everything together
572 if src_sap_id
in self
.saps
and dst_sap_id
in self
.saps
:
573 LOG
.info('2 SAPs cannot be chained together : {0} - {1}'.format(src_sap_id
, dst_sap_id
))
576 elif src_sap_id
in self
.saps_ext
:
578 # set intf name to None so the chaining function will choose the first one
580 src_name
= self
.vnf_id2vnf_name
[src_id
]
581 dst_name
= self
.vnf_id2vnf_name
[dst_id
]
582 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_name
)
583 if dst_vnfi
is not None:
584 # choose first ip address in sap subnet
585 sap_net
= self
.saps
[src_sap_id
]['net']
586 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
587 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, sap_ip
)
590 elif dst_sap_id
in self
.saps_ext
:
592 # set intf name to None so the chaining function will choose the first one
594 src_name
= self
.vnf_id2vnf_name
[src_id
]
595 dst_name
= self
.vnf_id2vnf_name
[dst_id
]
596 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_name
)
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 src_name
= self
.vnf_id2vnf_name
[src_id
]
611 dst_name
= self
.vnf_id2vnf_name
[dst_id
]
612 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
613 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_name
)
614 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_name
)
615 if src_vnfi
is not None and dst_vnfi
is not None:
616 eline_net
= ELINE_SUBNETS
.pop(0)
617 ip1
= "{0}/{1}".format(str(eline_net
[1]), eline_net
.prefixlen
)
618 ip2
= "{0}/{1}".format(str(eline_net
[2]), eline_net
.prefixlen
)
619 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, ip1
)
620 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, ip2
)
625 ret
= GK
.net
.setChain(
627 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
628 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
630 "Setting up E-Line link. %s(%s:%s) -> %s(%s:%s)" % (
631 src_name
, src_id
, src_if_name
, dst_name
, dst_id
, dst_if_name
))
634 def _connect_elans(self
, elan_fwd_links
, instance_uuid
):
636 Connect all E-LAN links in the NSD
637 :param elan_fwd_links: list of E-LAN links in the NSD
638 :param: instance_uuid of the service
641 for link
in elan_fwd_links
:
642 # check if we need to deploy this link when its a management link:
644 if self
.check_mgmt_interface(link
["connection_points_reference"]):
648 # check if an external SAP is in the E-LAN (then a subnet is already defined)
649 intfs_elan
= [intf
for intf
in link
["connection_points_reference"]]
650 lan_sap
= self
.check_ext_saps(intfs_elan
)
652 lan_net
= self
.saps
[lan_sap
]['net']
653 lan_hosts
= list(lan_net
.hosts())
654 sap_ip
= str(lan_hosts
.pop(0))
656 lan_net
= ELAN_SUBNETS
.pop(0)
657 lan_hosts
= list(lan_net
.hosts())
659 # generate lan ip address for all interfaces except external SAPs
660 for intf
in link
["connection_points_reference"]:
662 # skip external SAPs, they already have an ip
663 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf
)
664 if vnf_sap_docker_name
in self
.saps_ext
:
665 elan_vnf_list
.append({'name': vnf_sap_docker_name
, 'interface': vnf_interface
})
668 ip_address
= "{0}/{1}".format(str(lan_hosts
.pop(0)), lan_net
.prefixlen
)
669 vnf_id
, intf_name
, vnf_sap_id
= parse_interface(intf
)
671 # make sure we use the correct sap vnf name
672 src_docker_name
= vnf_id
673 if vnf_sap_id
in self
.saps_int
:
674 src_docker_name
= vnf_sap_id
677 vnf_name
= self
.vnf_id2vnf_name
[vnf_id
]
679 "Setting up E-LAN interface. %s(%s:%s) -> %s" % (
680 vnf_name
, vnf_id
, intf_name
, ip_address
))
682 if vnf_name
in self
.vnfds
:
683 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
684 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
685 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
686 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_name
)
688 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
689 # add this vnf and interface to the E-LAN for tagging
690 elan_vnf_list
.append({'name': src_docker_name
, 'interface': intf_name
})
692 # install the VLAN tags for this E-LAN
693 GK
.net
.setLAN(elan_vnf_list
)
696 def _load_docker_files(self
):
698 Get all paths to Dockerfiles from VNFDs and store them in dict.
701 for k
, v
in self
.vnfds
.iteritems():
702 for vu
in v
.get("virtual_deployment_units"):
703 if vu
.get("vm_image_format") == "docker":
704 vm_image
= vu
.get("vm_image")
705 docker_path
= os
.path
.join(
706 self
.package_content_path
,
707 make_relative_path(vm_image
))
708 self
.local_docker_files
[k
] = docker_path
709 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
711 def _load_docker_urls(self
):
713 Get all URLs to pre-build docker images in some repo.
716 # also merge sap dicts, because internal saps also need a docker container
717 all_vnfs
= self
.vnfds
.copy()
718 all_vnfs
.update(self
.saps
)
720 for k
, v
in all_vnfs
.iteritems():
721 for vu
in v
.get("virtual_deployment_units", {}):
722 if vu
.get("vm_image_format") == "docker":
723 url
= vu
.get("vm_image")
725 url
= url
.replace("http://", "")
726 self
.remote_docker_image_urls
[k
] = url
727 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
729 def _build_images_from_dockerfiles(self
):
731 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
733 if GK_STANDALONE_MODE
:
734 return # do not build anything in standalone mode
736 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
737 for k
, v
in self
.local_docker_files
.iteritems():
738 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
739 LOG
.debug("DOCKER BUILD: %s" % line
)
740 LOG
.info("Docker image created: %s" % k
)
742 def _pull_predefined_dockerimages(self
):
744 If the package contains URLs to pre-build Docker images, we download them with this method.
747 for url
in self
.remote_docker_image_urls
.itervalues():
748 if not FORCE_PULL
: # only pull if not present (speedup for development)
749 if len(dc
.images
.list(name
=url
)) > 0:
750 LOG
.debug("Image %r present. Skipping pull." % url
)
752 LOG
.info("Pulling image: %r" % url
)
753 # this seems to fail with latest docker api version 2.0.2
754 # dc.images.pull(url,
755 # insecure_registry=True)
756 #using docker cli instead
766 def _check_docker_image_exists(self
, image_name
):
768 Query the docker service and check if the given image exists
769 :param image_name: name of the docker image
772 return len(DockerClient().images
.list(name
=image_name
)) > 0
774 def _calculate_placement(self
, algorithm
):
776 Do placement by adding the a field "dc" to
777 each VNFD that points to one of our
778 data center objects known to the gatekeeper.
780 assert(len(self
.vnfds
) > 0)
781 assert(len(GK
.dcs
) > 0)
782 # instantiate algorithm an place
784 p
.place(self
.nsd
, self
.vnfds
, self
.saps
, GK
.dcs
)
785 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
786 # lets print the placement result
787 for name
, vnfd
in self
.vnfds
.iteritems():
788 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
789 for sap
in self
.saps
:
790 sap_dict
= self
.saps
[sap
]
791 LOG
.info("Placed SAP %r on DC %r" % (sap
, str(sap_dict
.get("dc"))))
794 def _calculate_cpu_cfs_values(self
, cpu_time_percentage
):
796 Calculate cpu period and quota for CFS
797 :param cpu_time_percentage: percentage of overall CPU to be used
798 :return: cpu_period, cpu_quota
800 if cpu_time_percentage
is None:
802 if cpu_time_percentage
< 0:
804 # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
805 # Attention minimum cpu_quota is 1ms (micro)
806 cpu_period
= 1000000 # lets consider a fixed period of 1000000 microseconds for now
807 LOG
.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period
, cpu_time_percentage
))
808 cpu_quota
= cpu_period
* cpu_time_percentage
# calculate the fraction of cpu time for this container
809 # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
811 LOG
.debug("cpu_quota before correcting: %r" % cpu_quota
)
813 LOG
.warning("Increased CPU quota to avoid system error.")
814 LOG
.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period
, cpu_quota
))
815 return int(cpu_period
), int(cpu_quota
)
817 def check_ext_saps(self
, intf_list
):
818 # check if the list of interfacs contains an externl SAP
819 saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
820 for intf_name
in intf_list
:
821 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf_name
)
822 if vnf_sap_docker_name
in saps_ext
:
823 return vnf_sap_docker_name
825 def check_mgmt_interface(self
, intf_list
):
826 SAPs_mgmt
= [p
.get('id') for p
in self
.nsd
["connection_points"] if 'management' in p
.get('type')]
827 for intf_name
in intf_list
:
828 if intf_name
in SAPs_mgmt
:
832 Some (simple) placement algorithms
836 class FirstDcPlacement(object):
838 Placement: Always use one and the same data center from the GK.dcs dict.
840 def place(self
, nsd
, vnfds
, saps
, dcs
):
841 for name
, vnfd
in vnfds
.iteritems():
842 vnfd
["dc"] = list(dcs
.itervalues())[0]
845 class RoundRobinDcPlacement(object):
847 Placement: Distribute VNFs across all available DCs in a round robin fashion.
849 def place(self
, nsd
, vnfds
, saps
, dcs
):
851 dcs_list
= list(dcs
.itervalues())
852 for name
, vnfd
in vnfds
.iteritems():
853 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
854 c
+= 1 # inc. c to use next DC
856 class RoundRobinDcPlacementWithSAPs(object):
858 Placement: Distribute VNFs across all available DCs in a round robin fashion,
859 every SAP is instantiated on the same DC as the connected VNF.
861 def place(self
, nsd
, vnfds
, saps
, dcs
):
865 dcs_list
= list(dcs
.itervalues())
866 for name
, vnfd
in vnfds
.iteritems():
867 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
868 c
+= 1 # inc. c to use next DC
871 vlinks
= nsd
.get("virtual_links", [])
872 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
873 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
875 vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
876 reduce(lambda x
, y
: dict(x
, **y
),
877 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
878 nsd
["network_functions"])))
880 # SAPs on E-Line links are placed on the same DC as the VNF on the E-Line
881 for link
in eline_fwd_links
:
882 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
883 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
885 # check if there is a SAP in the link
886 if src_sap_id
in saps
:
887 dst_vnf_name
= vnf_id2vnf_name
[dst_id
]
888 # get dc where connected vnf is mapped to
889 dc
= vnfds
[dst_vnf_name
]['dc']
890 saps
[src_sap_id
]['dc'] = dc
892 if dst_sap_id
in saps
:
893 src_vnf_name
= vnf_id2vnf_name
[src_id
]
894 # get dc where connected vnf is mapped to
895 dc
= vnfds
[src_vnf_name
]['dc']
896 saps
[dst_sap_id
]['dc'] = dc
898 # SAPs on E-LANs are placed on a random DC
899 dcs_list
= list(dcs
.itervalues())
900 dc_len
= len(dcs_list
)
901 for link
in elan_fwd_links
:
902 for intf
in link
["connection_points_reference"]:
903 # find SAP interfaces
904 intf_id
, intf_name
, intf_sap_id
= parse_interface(intf
)
905 if intf_sap_id
in saps
:
906 dc
= dcs_list
[randint(0, dc_len
-1)]
907 saps
[intf_sap_id
]['dc'] = dc
912 Resource definitions and API endpoints
916 class Packages(fr
.Resource
):
920 Upload a *.son service package to the dummy gatekeeper.
922 We expect request with a *.son file and store it in UPLOAD_FOLDER
927 LOG
.info("POST /packages called")
928 # lets search for the package in the request
929 is_file_object
= False # make API more robust: file can be in data or in files field
930 if "package" in request
.files
:
931 son_file
= request
.files
["package"]
932 is_file_object
= True
933 elif len(request
.data
) > 0:
934 son_file
= request
.data
936 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
937 # generate a uuid to reference this package
938 service_uuid
= str(uuid
.uuid4())
939 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
940 # ensure that upload folder exists
941 ensure_dir(UPLOAD_FOLDER
)
942 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
943 # store *.son file to disk
945 son_file
.save(upload_path
)
947 with
open(upload_path
, 'wb') as f
:
949 size
= os
.path
.getsize(upload_path
)
951 # first stop and delete any other running services
953 service_list
= copy
.copy(GK
.services
)
954 for service_uuid
in service_list
:
955 instances_list
= copy
.copy(GK
.services
[service_uuid
].instances
)
956 for instance_uuid
in instances_list
:
957 # valid service and instance UUID, stop service
958 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
959 LOG
.info("service instance with uuid %r stopped." % instance_uuid
)
961 # create a service object and register it
962 s
= Service(service_uuid
, file_hash
, upload_path
)
963 GK
.register_service_package(service_uuid
, s
)
965 # automatically deploy the service
967 # ok, we have a service uuid, lets start the service
968 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
970 # generate the JSON result
971 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
972 except Exception as ex
:
973 LOG
.exception("Service package upload failed:")
974 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
978 Return a list of UUID's of uploaded service packages.
981 LOG
.info("GET /packages")
982 return {"service_uuid_list": list(GK
.services
.iterkeys())}
985 class Instantiations(fr
.Resource
):
989 Instantiate a service specified by its UUID.
990 Will return a new UUID to identify the running service instance.
993 LOG
.info("POST /instantiations (or /requests) called")
994 # try to extract the service uuid from the request
995 json_data
= request
.get_json(force
=True)
996 service_uuid
= json_data
.get("service_uuid")
998 # lets be a bit fuzzy here to make testing easier
999 if (service_uuid
is None or service_uuid
=="latest") and len(GK
.services
) > 0:
1000 # if we don't get a service uuid, we simple start the first service in the list
1001 service_uuid
= list(GK
.services
.iterkeys())[0]
1002 if service_uuid
in GK
.services
:
1003 # ok, we have a service uuid, lets start the service
1004 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
1005 return {"service_instance_uuid": service_instance_uuid
}, 201
1006 return "Service not found", 404
1010 Returns a list of UUIDs containing all running services.
1011 :return: dict / list
1013 LOG
.info("GET /instantiations")
1014 return {"service_instantiations_list": [
1015 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
1019 Stops a running service specified by its service and instance UUID.
1021 # try to extract the service and instance UUID from the request
1022 json_data
= request
.get_json(force
=True)
1023 service_uuid
= json_data
.get("service_uuid")
1024 instance_uuid
= json_data
.get("service_instance_uuid")
1027 if service_uuid
is None and len(GK
.services
) > 0:
1028 #if we don't get a service uuid, we simply stop the last service in the list
1029 service_uuid
= list(GK
.services
.iterkeys())[0]
1030 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
1031 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
1033 if service_uuid
in GK
.services
and instance_uuid
in GK
.services
[service_uuid
].instances
:
1034 # valid service and instance UUID, stop service
1035 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
1036 return "service instance with uuid %r stopped." % instance_uuid
,200
1037 return "Service not found", 404
1039 class Exit(fr
.Resource
):
1043 Stop the running Containernet instance regardless of data transmitted
1045 list(GK
.dcs
.values())[0].net
.stop()
1048 def initialize_GK():
1054 # create a single, global GK object
1058 app
= Flask(__name__
)
1059 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
1062 api
.add_resource(Packages
, '/packages', '/api/v2/packages')
1063 api
.add_resource(Instantiations
, '/instantiations', '/api/v2/instantiations', '/api/v2/requests')
1064 api
.add_resource(Exit
, '/emulator/exit')
1068 def start_rest_api(host
, port
, datacenters
=dict()):
1069 GK
.dcs
= datacenters
1070 GK
.net
= get_dc_network()
1071 # start the Flask server (not the best performance but ok for our use case)
1075 use_reloader
=False # this is needed to run Flask in a non-main thread
1079 def ensure_dir(name
):
1080 if not os
.path
.exists(name
):
1084 def load_yaml(path
):
1085 with
open(path
, "r") as f
:
1088 except yaml
.YAMLError
as exc
:
1089 LOG
.exception("YAML parse error")
1094 def make_relative_path(path
):
1095 if path
.startswith("file://"):
1096 path
= path
.replace("file://", "", 1)
1097 if path
.startswith("/"):
1098 path
= path
.replace("/", "", 1)
1102 def get_dc_network():
1104 retrieve the DCnetwork where this dummygatekeeper (GK) connects to.
1105 Assume at least 1 datacenter is connected to this GK, and that all datacenters belong to the same DCNetwork
1108 assert (len(GK
.dcs
) > 0)
1109 return GK
.dcs
.values()[0].net
1112 def parse_interface(interface_name
):
1114 convert the interface name in the nsd to the according vnf_id, vnf_interface names
1115 :param interface_name:
1119 if ':' in interface_name
:
1120 vnf_id
, vnf_interface
= interface_name
.split(':')
1121 vnf_sap_docker_name
= interface_name
.replace(':', '_')
1123 vnf_id
= interface_name
1124 vnf_interface
= interface_name
1125 vnf_sap_docker_name
= interface_name
1127 return vnf_id
, vnf_interface
, vnf_sap_docker_name
1129 if __name__
== '__main__':
1131 Lets allow to run the API in standalone mode.
1133 GK_STANDALONE_MODE
= True
1134 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
1135 start_rest_api("0.0.0.0", 8000)