2 Copyright (c) 2015 SONATA-NFV and Paderborn University
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
9 http://www.apache.org/licenses/LICENSE-2.0
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
17 Neither the name of the SONATA-NFV [, ANY ADDITIONAL AFFILIATION]
18 nor the names of its contributors may be used to endorse or promote
19 products derived from this software without specific prior written
22 This work has been performed in the framework of the SONATA project,
23 funded by the European Commission under Grant number 671517 through
24 the Horizon 2020 and 5G-PPP programmes. The authors would like to
25 acknowledge the contributions of their colleagues of the SONATA
26 partner consortium (www.sonata-nfv.eu).
29 This module implements a simple REST API that behaves like SONATA's gatekeeper.
31 It is only used to support the development of SONATA's SDK tools and to demonstrate
32 the year 1 version of the emulator until the integration with WP4's orchestrator is done.
42 from docker
import DockerClient
, APIClient
43 from flask
import Flask
, request
44 import flask_restful
as fr
45 from collections
import defaultdict
47 from subprocess
import Popen
48 from random
import randint
53 LOG
= logging
.getLogger("sonata-dummy-gatekeeper")
54 LOG
.setLevel(logging
.DEBUG
)
55 logging
.getLogger("werkzeug").setLevel(logging
.WARNING
)
57 GK_STORAGE
= "/tmp/son-dummy-gk/"
58 UPLOAD_FOLDER
= os
.path
.join(GK_STORAGE
, "uploads/")
59 CATALOG_FOLDER
= os
.path
.join(GK_STORAGE
, "catalog/")
61 # Enable Dockerfile build functionality
62 BUILD_DOCKERFILE
= False
64 # flag to indicate that we run without the emulator (only the bare API for integration testing)
65 GK_STANDALONE_MODE
= False
67 # should a new version of an image be pulled even if its available
70 # Automatically deploy SAPs (endpoints) of the service as new containers
71 # Attention: This is not a configuration switch but a global variable! Don't change its default value.
74 # flag to indicate if we use bidirectional forwarding rules in the automatic chaining process
75 BIDIRECTIONAL_CHAIN
= False
77 # override the management interfaces in the descriptors with default docker0 interfaces in the containers
78 USE_DOCKER_MGMT
= False
80 # automatically deploy uploaded packages (no need to execute son-access deploy --latest separately)
83 # and also automatically terminate any other running services
86 def generate_subnets(prefix
, base
, subnet_size
=50, mask
=24):
87 # Generate a list of ipaddress in subnets
89 for net
in range(base
, base
+ subnet_size
):
90 subnet
= "{0}.{1}.0/{2}".format(prefix
, net
, mask
)
91 r
.append(ipaddress
.ip_network(unicode(subnet
)))
93 # private subnet definitions for the generated interfaces
95 SAP_SUBNETS
= generate_subnets('10.10', 0, subnet_size
=50, mask
=30)
97 ELAN_SUBNETS
= generate_subnets('10.20', 0, subnet_size
=50, mask
=24)
99 ELINE_SUBNETS
= generate_subnets('10.30', 0, subnet_size
=50, mask
=30)
101 # path to the VNFD for the SAP VNF that is deployed as internal SAP point
104 class Gatekeeper(object):
107 self
.services
= dict()
110 self
.vnf_counter
= 0 # used to generate short names for VNFs (Mininet limitation)
111 LOG
.info("Create SONATA dummy gatekeeper.")
113 def register_service_package(self
, service_uuid
, service
):
115 register new service package
117 :param service object
119 self
.services
[service_uuid
] = service
120 # lets perform all steps needed to onboard the service
123 def get_next_vnf_name(self
):
124 self
.vnf_counter
+= 1
125 return "vnf%d" % self
.vnf_counter
128 class Service(object):
130 This class represents a NS uploaded as a *.son package to the
132 Can have multiple running instances of this service.
139 self
.uuid
= service_uuid
140 self
.package_file_hash
= package_file_hash
141 self
.package_file_path
= package_file_path
142 self
.package_content_path
= os
.path
.join(CATALOG_FOLDER
, "services/%s" % self
.uuid
)
147 self
.saps_ext
= list()
148 self
.saps_int
= list()
149 self
.local_docker_files
= dict()
150 self
.remote_docker_image_urls
= dict()
151 self
.instances
= dict()
152 self
.vnf_name2docker_name
= dict()
153 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 # create dict to translate vnf names
169 self
.vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
170 reduce(lambda x
, y
: dict(x
, **y
),
171 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
172 self
.nsd
["network_functions"])))
173 # 3. prepare container images (e.g. download or build Dockerfile)
175 self
._load
_docker
_files
()
176 self
._build
_images
_from
_dockerfiles
()
178 self
._load
_docker
_urls
()
179 self
._pull
_predefined
_dockerimages
()
180 LOG
.info("On-boarded service: %r" % self
.manifest
.get("name"))
182 def start_service(self
):
184 This methods creates and starts a new service instance.
185 It computes placements, iterates over all VNFDs, and starts
186 each VNFD as a Docker container in the data center selected
187 by the placement algorithm.
190 LOG
.info("Starting service %r" % self
.uuid
)
192 # 1. each service instance gets a new uuid to identify it
193 instance_uuid
= str(uuid
.uuid4())
194 # build a instances dict (a bit like a NSR :))
195 self
.instances
[instance_uuid
] = dict()
196 self
.instances
[instance_uuid
]["vnf_instances"] = list()
198 # 2. compute placement of this service instance (adds DC names to VNFDs)
199 if not GK_STANDALONE_MODE
:
200 #self._calculate_placement(FirstDcPlacement)
201 self
._calculate
_placement
(RoundRobinDcPlacementWithSAPs
)
203 # 3. start all vnfds that we have in the service (except SAPs)
204 for vnfd
in self
.vnfds
.itervalues():
206 if not GK_STANDALONE_MODE
:
207 vnfi
= self
._start
_vnfd
(vnfd
)
208 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
210 # 4. start all SAPs in the service
211 for sap
in self
.saps
:
212 self
._start
_sap
(self
.saps
[sap
], instance_uuid
)
214 # 5. Deploy E-Line and E_LAN links
215 if "virtual_links" in self
.nsd
:
216 vlinks
= self
.nsd
["virtual_links"]
217 # constituent virtual links are not checked
218 #fwd_links = self.nsd["forwarding_graphs"][0]["constituent_virtual_links"]
219 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
220 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
222 GK
.net
.deployed_elines
.extend(eline_fwd_links
)
223 GK
.net
.deployed_elans
.extend(elan_fwd_links
)
225 # 5a. deploy E-Line links
226 self
._connect
_elines
(eline_fwd_links
, instance_uuid
)
228 # 5b. deploy E-LAN links
229 self
._connect
_elans
(elan_fwd_links
, instance_uuid
)
231 # 6. run the emulator specific entrypoint scripts in the VNFIs of this service instance
232 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
234 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
237 def stop_service(self
, instance_uuid
):
239 This method stops a running service instance.
240 It iterates over all VNF instances, stopping them each
241 and removing them from their data center.
243 :param instance_uuid: the uuid of the service instance to be stopped
245 LOG
.info("Stopping service %r" % self
.uuid
)
246 # get relevant information
247 # instance_uuid = str(self.uuid.uuid4())
248 vnf_instances
= self
.instances
[instance_uuid
]["vnf_instances"]
250 for v
in vnf_instances
:
253 for sap_name
in self
.saps_ext
:
254 ext_sap
= self
.saps
[sap_name
]
255 target_dc
= ext_sap
.get("dc")
256 target_dc
.removeExternalSAP(sap_name
, ext_sap
['net'])
257 LOG
.info("Stopping the SAP instance: %r in DC %r" % (sap_name
, target_dc
))
259 if not GK_STANDALONE_MODE
:
261 # self._remove_placement(RoundRobinPlacement)
264 # last step: remove the instance from the list of all instances
265 del self
.instances
[instance_uuid
]
267 def _start_vnfd(self
, vnfd
):
269 Start a single VNFD of this service
270 :param vnfd: vnfd descriptor dict
273 # iterate over all deployment units within each VNFDs
274 for u
in vnfd
.get("virtual_deployment_units"):
275 # 1. get the name of the docker image to start and the assigned DC
276 vnf_name
= vnfd
.get("name")
277 if vnf_name
not in self
.remote_docker_image_urls
:
278 raise Exception("No image name for %r found. Abort." % vnf_name
)
279 docker_name
= self
.remote_docker_image_urls
.get(vnf_name
)
280 target_dc
= vnfd
.get("dc")
281 # 2. perform some checks to ensure we can start the container
282 assert(docker_name
is not None)
283 assert(target_dc
is not None)
284 if not self
._check
_docker
_image
_exists
(docker_name
):
285 raise Exception("Docker image %r not found. Abort." % docker_name
)
287 # 3. get the resource limits
288 res_req
= u
.get("resource_requirements")
289 cpu_list
= res_req
.get("cpu").get("cores")
290 if not cpu_list
or len(cpu_list
)==0:
292 cpu_bw
= res_req
.get("cpu").get("cpu_bw")
295 mem_num
= str(res_req
.get("memory").get("size"))
298 mem_unit
= str(res_req
.get("memory").get("size_unit"))
301 mem_limit
= float(mem_num
)
303 mem_limit
=mem_limit
*1024*1024*1024
305 mem_limit
=mem_limit
*1024*1024
307 mem_limit
=mem_limit
*1024
308 mem_lim
= int(mem_limit
)
309 cpu_period
, cpu_quota
= self
._calculate
_cpu
_cfs
_values
(float(cpu_bw
))
311 vnf_name2id
= defaultdict(lambda: "NotExistingNode",
312 reduce(lambda x
, y
: dict(x
, **y
),
313 map(lambda d
: {d
["vnf_name"]: d
["vnf_id"]},
314 self
.nsd
["network_functions"])))
316 # check if we need to deploy the management ports (defined as type:management both on in the vnfd and nsd)
317 intfs
= vnfd
.get("connection_points", [])
320 vnf_id
= vnf_name2id
[vnf_name
]
321 mgmt_intfs
= [vnf_id
+ ':' + intf
['id'] for intf
in intfs
if intf
.get('type') == 'management']
322 # check if any of these management interfaces are used in a management-type network in the nsd
323 for nsd_intf_name
in mgmt_intfs
:
324 vlinks
= [ l
["connection_points_reference"] for l
in self
.nsd
.get("virtual_links", [])]
326 if nsd_intf_name
in link
and self
.check_mgmt_interface(link
):
327 # this is indeed a management interface and can be skipped
328 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(nsd_intf_name
)
329 found_interfaces
= [intf
for intf
in intfs
if intf
.get('id') == vnf_interface
]
330 intfs
.remove(found_interfaces
[0])
331 mgmt_intf_names
.append(vnf_interface
)
333 # 4. generate the volume paths for the docker container
335 # a volume to extract log files
336 docker_log_path
= "/tmp/results/%s/%s"%(self
.uuid
,vnf_name
)
337 LOG
.debug("LOG path for vnf %s is %s."%(vnf_name
,docker_log_path
))
338 if not os
.path
.exists(docker_log_path
):
339 LOG
.debug("Creating folder %s"%docker
_log
_path
)
340 os
.makedirs(docker_log_path
)
342 volumes
.append(docker_log_path
+":/mnt/share/")
345 # 5. do the dc.startCompute(name="foobar") call to run the container
346 # TODO consider flavors, and other annotations
347 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
348 # use the vnf_id in the nsd as docker name
349 # so deployed containers can be easily mapped back to the nsd
351 self
.vnf_name2docker_name
[vnf_name
] = vnf_name2id
[vnf_name
]
353 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, self
.vnf_name2docker_name
[vnf_name
], vnfd
.get("dc")))
354 LOG
.debug("Interfaces for %r: %r" % (vnf_name
, intfs
))
355 vnfi
= target_dc
.startCompute(
356 self
.vnf_name2docker_name
[vnf_name
],
361 cpu_period
=cpu_period
,
366 # rename the docker0 interfaces (eth0) to the management port name defined in the VNFD
368 for intf_name
in mgmt_intf_names
:
369 self
._vnf
_reconfigure
_network
(vnfi
, 'eth0', new_name
=intf_name
)
373 def _stop_vnfi(self
, vnfi
):
377 :param vnfi: vnf instance to be stopped
379 # Find the correct datacenter
380 status
= vnfi
.getStatus()
384 LOG
.info("Stopping the vnf instance contained in %r in DC %r" % (status
["name"], dc
))
385 dc
.stopCompute(status
["name"])
387 def _get_vnf_instance(self
, instance_uuid
, name
):
389 Returns the Docker object for the given VNF name (or Docker name).
390 :param instance_uuid: UUID of the service instance to search in.
391 :param name: VNF name or Docker name. We are fuzzy here.
395 if name
in self
.vnf_name2docker_name
:
396 dn
= self
.vnf_name2docker_name
[name
]
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 _unpack_service_package(self
):
447 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
449 LOG
.info("Unzipping: %r" % self
.package_file_path
)
450 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
451 z
.extractall(self
.package_content_path
)
454 def _load_package_descriptor(self
):
456 Load the main package descriptor YAML and keep it as dict.
459 self
.manifest
= load_yaml(
461 self
.package_content_path
, "META-INF/MANIFEST.MF"))
465 Load the entry NSD YAML and keep it as dict.
468 if "entry_service_template" in self
.manifest
:
469 nsd_path
= os
.path
.join(
470 self
.package_content_path
,
471 make_relative_path(self
.manifest
.get("entry_service_template")))
472 self
.nsd
= load_yaml(nsd_path
)
473 GK
.net
.deployed_nsds
.append(self
.nsd
)
475 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
477 def _load_vnfd(self
):
479 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
482 if "package_content" in self
.manifest
:
483 for pc
in self
.manifest
.get("package_content"):
484 if pc
.get("content-type") == "application/sonata.function_descriptor":
485 vnfd_path
= os
.path
.join(
486 self
.package_content_path
,
487 make_relative_path(pc
.get("name")))
488 vnfd
= load_yaml(vnfd_path
)
489 self
.vnfds
[vnfd
.get("name")] = vnfd
490 LOG
.debug("Loaded VNFD: %r" % vnfd
.get("name"))
492 def _load_saps(self
):
493 # create list of all SAPs
494 # check if we need to deploy management ports
496 SAPs
= [p
for p
in self
.nsd
["connection_points"] if 'management' not in p
.get('type')]
498 SAPs
= [p
for p
in self
.nsd
["connection_points"]]
501 # endpoint needed in this service
502 sap_id
, sap_interface
, sap_docker_name
= parse_interface(sap
['id'])
503 # make sure SAP has type set (default internal)
504 sap
["type"] = sap
.get("type", 'internal')
506 # Each Service Access Point (connection_point) in the nsd is an IP address on the host
507 if sap
["type"] == "external":
508 # add to vnfds to calculate placement later on
509 sap_net
= SAP_SUBNETS
.pop(0)
510 self
.saps
[sap_docker_name
] = {"name": sap_docker_name
, "type": "external", "net": sap_net
}
511 # add SAP vnf to list in the NSD so it is deployed later on
512 # each SAP get a unique VNFD and vnf_id in the NSD and custom type (only defined in the dummygatekeeper)
513 self
.nsd
["network_functions"].append(
514 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_ext"})
516 # Each Service Access Point (connection_point) in the nsd is getting its own container (default)
517 elif sap
["type"] == "internal" or sap
["type"] == "management":
518 # add SAP to self.vnfds
520 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
523 sap_vnfd
= load_yaml(sapfile
)
524 sap_vnfd
["connection_points"][0]["id"] = sap_interface
525 sap_vnfd
["name"] = sap_docker_name
526 sap_vnfd
["type"] = "internal"
527 # add to vnfds to calculate placement later on and deploy
528 self
.saps
[sap_docker_name
] = sap_vnfd
529 # add SAP vnf to list in the NSD so it is deployed later on
530 # each SAP get a unique VNFD and vnf_id in the NSD
531 self
.nsd
["network_functions"].append(
532 {"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
, "vnf_type": "sap_int"})
534 LOG
.debug("Loaded SAP: name: {0}, type: {1}".format(sap_docker_name
, sap
['type']))
537 self
.saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
538 self
.saps_int
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "internal"]
540 def _start_sap(self
, sap
, instance_uuid
):
544 LOG
.info('start SAP: {0} ,type: {1}'.format(sap
['name'],sap
['type']))
545 if sap
["type"] == "internal":
547 if not GK_STANDALONE_MODE
:
548 vnfi
= self
._start
_vnfd
(sap
)
549 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
551 elif sap
["type"] == "external":
552 target_dc
= sap
.get("dc")
553 # add interface to dc switch
554 target_dc
.attachExternalSAP(sap
['name'], sap
['net'])
556 def _connect_elines(self
, eline_fwd_links
, instance_uuid
):
558 Connect all E-LINE links in the NSD
559 :param eline_fwd_links: list of E-LINE links in the NSD
560 :param: instance_uuid of the service
563 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
564 # eg. different services get a unique cookie for their flowrules
566 for link
in eline_fwd_links
:
567 # check if we need to deploy this link when its a management link:
569 if self
.check_mgmt_interface(link
["connection_points_reference"]):
572 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
573 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
576 # check if there is a SAP in the link and chain everything together
577 if src_sap_id
in self
.saps
and dst_sap_id
in self
.saps
:
578 LOG
.info('2 SAPs cannot be chained together : {0} - {1}'.format(src_sap_id
, dst_sap_id
))
581 elif src_sap_id
in self
.saps_ext
:
583 # set intf name to None so the chaining function will choose the first one
585 src_name
= self
.vnf_id2vnf_name
[src_id
]
586 dst_name
= self
.vnf_id2vnf_name
[dst_id
]
587 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_name
)
588 if dst_vnfi
is not None:
589 # choose first ip address in sap subnet
590 sap_net
= self
.saps
[src_sap_id
]['net']
591 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
592 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, sap_ip
)
595 elif dst_sap_id
in self
.saps_ext
:
597 # set intf name to None so the chaining function will choose the first one
599 src_name
= self
.vnf_id2vnf_name
[src_id
]
600 dst_name
= self
.vnf_id2vnf_name
[dst_id
]
601 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_name
)
602 if src_vnfi
is not None:
603 sap_net
= self
.saps
[dst_sap_id
]['net']
604 sap_ip
= "{0}/{1}".format(str(sap_net
[2]), sap_net
.prefixlen
)
605 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, sap_ip
)
608 # Link between 2 VNFs
610 # make sure we use the correct sap vnf name
611 if src_sap_id
in self
.saps_int
:
613 if dst_sap_id
in self
.saps_int
:
615 src_name
= self
.vnf_id2vnf_name
[src_id
]
616 dst_name
= self
.vnf_id2vnf_name
[dst_id
]
617 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
618 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_name
)
619 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_name
)
620 if src_vnfi
is not None and dst_vnfi
is not None:
621 eline_net
= ELINE_SUBNETS
.pop(0)
622 ip1
= "{0}/{1}".format(str(eline_net
[1]), eline_net
.prefixlen
)
623 ip2
= "{0}/{1}".format(str(eline_net
[2]), eline_net
.prefixlen
)
624 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, ip1
)
625 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, ip2
)
630 ret
= GK
.net
.setChain(
632 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
633 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
635 "Setting up E-Line link. %s(%s:%s) -> %s(%s:%s)" % (
636 src_name
, src_id
, src_if_name
, dst_name
, dst_id
, dst_if_name
))
639 def _connect_elans(self
, elan_fwd_links
, instance_uuid
):
641 Connect all E-LAN links in the NSD
642 :param elan_fwd_links: list of E-LAN links in the NSD
643 :param: instance_uuid of the service
646 for link
in elan_fwd_links
:
647 # check if we need to deploy this link when its a management link:
649 if self
.check_mgmt_interface(link
["connection_points_reference"]):
653 # check if an external SAP is in the E-LAN (then a subnet is already defined)
654 intfs_elan
= [intf
for intf
in link
["connection_points_reference"]]
655 lan_sap
= self
.check_ext_saps(intfs_elan
)
657 lan_net
= self
.saps
[lan_sap
]['net']
658 lan_hosts
= list(lan_net
.hosts())
659 sap_ip
= str(lan_hosts
.pop(0))
661 lan_net
= ELAN_SUBNETS
.pop(0)
662 lan_hosts
= list(lan_net
.hosts())
664 # generate lan ip address for all interfaces except external SAPs
665 for intf
in link
["connection_points_reference"]:
667 # skip external SAPs, they already have an ip
668 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf
)
669 if vnf_sap_docker_name
in self
.saps_ext
:
670 elan_vnf_list
.append({'name': vnf_sap_docker_name
, 'interface': vnf_interface
})
673 ip_address
= "{0}/{1}".format(str(lan_hosts
.pop(0)), lan_net
.prefixlen
)
674 vnf_id
, intf_name
, vnf_sap_id
= parse_interface(intf
)
676 # make sure we use the correct sap vnf name
677 src_docker_name
= vnf_id
678 if vnf_sap_id
in self
.saps_int
:
679 src_docker_name
= vnf_sap_id
682 vnf_name
= self
.vnf_id2vnf_name
[vnf_id
]
684 "Setting up E-LAN interface. %s(%s:%s) -> %s" % (
685 vnf_name
, vnf_id
, intf_name
, ip_address
))
687 if vnf_name
in self
.vnfds
:
688 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
689 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
690 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
691 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_name
)
693 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
694 # add this vnf and interface to the E-LAN for tagging
695 elan_vnf_list
.append({'name': src_docker_name
, 'interface': intf_name
})
697 # install the VLAN tags for this E-LAN
698 GK
.net
.setLAN(elan_vnf_list
)
701 def _load_docker_files(self
):
703 Get all paths to Dockerfiles from VNFDs and store them in dict.
706 for k
, v
in self
.vnfds
.iteritems():
707 for vu
in v
.get("virtual_deployment_units"):
708 if vu
.get("vm_image_format") == "docker":
709 vm_image
= vu
.get("vm_image")
710 docker_path
= os
.path
.join(
711 self
.package_content_path
,
712 make_relative_path(vm_image
))
713 self
.local_docker_files
[k
] = docker_path
714 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
716 def _load_docker_urls(self
):
718 Get all URLs to pre-build docker images in some repo.
721 # also merge sap dicts, because internal saps also need a docker container
722 all_vnfs
= self
.vnfds
.copy()
723 all_vnfs
.update(self
.saps
)
725 for k
, v
in all_vnfs
.iteritems():
726 for vu
in v
.get("virtual_deployment_units", {}):
727 if vu
.get("vm_image_format") == "docker":
728 url
= vu
.get("vm_image")
730 url
= url
.replace("http://", "")
731 self
.remote_docker_image_urls
[k
] = url
732 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
734 def _build_images_from_dockerfiles(self
):
736 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
738 if GK_STANDALONE_MODE
:
739 return # do not build anything in standalone mode
741 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
742 for k
, v
in self
.local_docker_files
.iteritems():
743 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
744 LOG
.debug("DOCKER BUILD: %s" % line
)
745 LOG
.info("Docker image created: %s" % k
)
747 def _pull_predefined_dockerimages(self
):
749 If the package contains URLs to pre-build Docker images, we download them with this method.
752 for url
in self
.remote_docker_image_urls
.itervalues():
753 if not FORCE_PULL
: # only pull if not present (speedup for development)
754 if len(dc
.images
.list(name
=url
)) > 0:
755 LOG
.debug("Image %r present. Skipping pull." % url
)
757 LOG
.info("Pulling image: %r" % url
)
758 # this seems to fail with latest docker api version 2.0.2
759 # dc.images.pull(url,
760 # insecure_registry=True)
761 #using docker cli instead
771 def _check_docker_image_exists(self
, image_name
):
773 Query the docker service and check if the given image exists
774 :param image_name: name of the docker image
777 return len(DockerClient().images
.list(name
=image_name
)) > 0
779 def _calculate_placement(self
, algorithm
):
781 Do placement by adding the a field "dc" to
782 each VNFD that points to one of our
783 data center objects known to the gatekeeper.
785 assert(len(self
.vnfds
) > 0)
786 assert(len(GK
.dcs
) > 0)
787 # instantiate algorithm an place
789 p
.place(self
.nsd
, self
.vnfds
, self
.saps
, GK
.dcs
)
790 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
791 # lets print the placement result
792 for name
, vnfd
in self
.vnfds
.iteritems():
793 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
794 for sap
in self
.saps
:
795 sap_dict
= self
.saps
[sap
]
796 LOG
.info("Placed SAP %r on DC %r" % (sap
, str(sap_dict
.get("dc"))))
799 def _calculate_cpu_cfs_values(self
, cpu_time_percentage
):
801 Calculate cpu period and quota for CFS
802 :param cpu_time_percentage: percentage of overall CPU to be used
803 :return: cpu_period, cpu_quota
805 if cpu_time_percentage
is None:
807 if cpu_time_percentage
< 0:
809 # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
810 # Attention minimum cpu_quota is 1ms (micro)
811 cpu_period
= 1000000 # lets consider a fixed period of 1000000 microseconds for now
812 LOG
.debug("cpu_period is %r, cpu_percentage is %r" % (cpu_period
, cpu_time_percentage
))
813 cpu_quota
= cpu_period
* cpu_time_percentage
# calculate the fraction of cpu time for this container
814 # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
816 LOG
.debug("cpu_quota before correcting: %r" % cpu_quota
)
818 LOG
.warning("Increased CPU quota to avoid system error.")
819 LOG
.debug("Calculated: cpu_period=%f / cpu_quota=%f" % (cpu_period
, cpu_quota
))
820 return int(cpu_period
), int(cpu_quota
)
822 def check_ext_saps(self
, intf_list
):
823 # check if the list of interfacs contains an externl SAP
824 saps_ext
= [self
.saps
[sap
]['name'] for sap
in self
.saps
if self
.saps
[sap
]["type"] == "external"]
825 for intf_name
in intf_list
:
826 vnf_id
, vnf_interface
, vnf_sap_docker_name
= parse_interface(intf_name
)
827 if vnf_sap_docker_name
in saps_ext
:
828 return vnf_sap_docker_name
830 def check_mgmt_interface(self
, intf_list
):
831 SAPs_mgmt
= [p
.get('id') for p
in self
.nsd
["connection_points"] if 'management' in p
.get('type')]
832 for intf_name
in intf_list
:
833 if intf_name
in SAPs_mgmt
:
837 Some (simple) placement algorithms
841 class FirstDcPlacement(object):
843 Placement: Always use one and the same data center from the GK.dcs dict.
845 def place(self
, nsd
, vnfds
, saps
, dcs
):
846 for name
, vnfd
in vnfds
.iteritems():
847 vnfd
["dc"] = list(dcs
.itervalues())[0]
850 class RoundRobinDcPlacement(object):
852 Placement: Distribute VNFs across all available DCs in a round robin fashion.
854 def place(self
, nsd
, vnfds
, saps
, dcs
):
856 dcs_list
= list(dcs
.itervalues())
857 for name
, vnfd
in vnfds
.iteritems():
858 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
859 c
+= 1 # inc. c to use next DC
861 class RoundRobinDcPlacementWithSAPs(object):
863 Placement: Distribute VNFs across all available DCs in a round robin fashion,
864 every SAP is instantiated on the same DC as the connected VNF.
866 def place(self
, nsd
, vnfds
, saps
, dcs
):
870 dcs_list
= list(dcs
.itervalues())
871 for name
, vnfd
in vnfds
.iteritems():
872 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
873 c
+= 1 # inc. c to use next DC
876 vlinks
= nsd
.get("virtual_links", [])
877 eline_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-Line")]
878 elan_fwd_links
= [l
for l
in vlinks
if (l
["connectivity_type"] == "E-LAN")]
880 vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
881 reduce(lambda x
, y
: dict(x
, **y
),
882 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
883 nsd
["network_functions"])))
885 # SAPs on E-Line links are placed on the same DC as the VNF on the E-Line
886 for link
in eline_fwd_links
:
887 src_id
, src_if_name
, src_sap_id
= parse_interface(link
["connection_points_reference"][0])
888 dst_id
, dst_if_name
, dst_sap_id
= parse_interface(link
["connection_points_reference"][1])
890 # check if there is a SAP in the link
891 if src_sap_id
in saps
:
892 dst_vnf_name
= vnf_id2vnf_name
[dst_id
]
893 # get dc where connected vnf is mapped to
894 dc
= vnfds
[dst_vnf_name
]['dc']
895 saps
[src_sap_id
]['dc'] = dc
897 if dst_sap_id
in saps
:
898 src_vnf_name
= vnf_id2vnf_name
[src_id
]
899 # get dc where connected vnf is mapped to
900 dc
= vnfds
[src_vnf_name
]['dc']
901 saps
[dst_sap_id
]['dc'] = dc
903 # SAPs on E-LANs are placed on a random DC
904 dcs_list
= list(dcs
.itervalues())
905 dc_len
= len(dcs_list
)
906 for link
in elan_fwd_links
:
907 for intf
in link
["connection_points_reference"]:
908 # find SAP interfaces
909 intf_id
, intf_name
, intf_sap_id
= parse_interface(intf
)
910 if intf_sap_id
in saps
:
911 dc
= dcs_list
[randint(0, dc_len
-1)]
912 saps
[intf_sap_id
]['dc'] = dc
917 Resource definitions and API endpoints
921 class Packages(fr
.Resource
):
925 Upload a *.son service package to the dummy gatekeeper.
927 We expect request with a *.son file and store it in UPLOAD_FOLDER
932 LOG
.info("POST /packages called")
933 # lets search for the package in the request
934 is_file_object
= False # make API more robust: file can be in data or in files field
935 if "package" in request
.files
:
936 son_file
= request
.files
["package"]
937 is_file_object
= True
938 elif len(request
.data
) > 0:
939 son_file
= request
.data
941 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
942 # generate a uuid to reference this package
943 service_uuid
= str(uuid
.uuid4())
944 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
945 # ensure that upload folder exists
946 ensure_dir(UPLOAD_FOLDER
)
947 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
948 # store *.son file to disk
950 son_file
.save(upload_path
)
952 with
open(upload_path
, 'wb') as f
:
954 size
= os
.path
.getsize(upload_path
)
956 # first stop and delete any other running services
958 service_list
= copy
.copy(GK
.services
)
959 for service_uuid
in service_list
:
960 instances_list
= copy
.copy(GK
.services
[service_uuid
].instances
)
961 for instance_uuid
in instances_list
:
962 # valid service and instance UUID, stop service
963 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
964 LOG
.info("service instance with uuid %r stopped." % instance_uuid
)
966 # create a service object and register it
967 s
= Service(service_uuid
, file_hash
, upload_path
)
968 GK
.register_service_package(service_uuid
, s
)
970 # automatically deploy the service
972 # ok, we have a service uuid, lets start the service
974 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
976 # generate the JSON result
977 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}, 201
978 except Exception as ex
:
979 LOG
.exception("Service package upload failed:")
980 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
984 Return a list of UUID's of uploaded service packages.
987 LOG
.info("GET /packages")
988 return {"service_uuid_list": list(GK
.services
.iterkeys())}
991 class Instantiations(fr
.Resource
):
995 Instantiate a service specified by its UUID.
996 Will return a new UUID to identify the running service instance.
999 LOG
.info("POST /instantiations (or /requests) called")
1000 # try to extract the service uuid from the request
1001 json_data
= request
.get_json(force
=True)
1002 service_uuid
= json_data
.get("service_uuid")
1004 # lets be a bit fuzzy here to make testing easier
1005 if (service_uuid
is None or service_uuid
=="latest") and len(GK
.services
) > 0:
1006 # if we don't get a service uuid, we simple start the first service in the list
1007 service_uuid
= list(GK
.services
.iterkeys())[0]
1008 if service_uuid
in GK
.services
:
1009 # ok, we have a service uuid, lets start the service
1010 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
1011 return {"service_instance_uuid": service_instance_uuid
}, 201
1012 return "Service not found", 404
1016 Returns a list of UUIDs containing all running services.
1017 :return: dict / list
1019 LOG
.info("GET /instantiations")
1020 return {"service_instantiations_list": [
1021 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
1025 Stops a running service specified by its service and instance UUID.
1027 # try to extract the service and instance UUID from the request
1028 json_data
= request
.get_json(force
=True)
1029 service_uuid
= json_data
.get("service_uuid")
1030 instance_uuid
= json_data
.get("service_instance_uuid")
1033 if service_uuid
is None and len(GK
.services
) > 0:
1034 #if we don't get a service uuid, we simply stop the last service in the list
1035 service_uuid
= list(GK
.services
.iterkeys())[0]
1036 if instance_uuid
is None and len(GK
.services
[service_uuid
].instances
) > 0:
1037 instance_uuid
= list(GK
.services
[service_uuid
].instances
.iterkeys())[0]
1039 if service_uuid
in GK
.services
and instance_uuid
in GK
.services
[service_uuid
].instances
:
1040 # valid service and instance UUID, stop service
1041 GK
.services
.get(service_uuid
).stop_service(instance_uuid
)
1042 return "service instance with uuid %r stopped." % instance_uuid
,200
1043 return "Service not found", 404
1045 class Exit(fr
.Resource
):
1049 Stop the running Containernet instance regardless of data transmitted
1051 list(GK
.dcs
.values())[0].net
.stop()
1054 def initialize_GK():
1060 # create a single, global GK object
1064 app
= Flask(__name__
)
1065 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
1068 api
.add_resource(Packages
, '/packages', '/api/v2/packages')
1069 api
.add_resource(Instantiations
, '/instantiations', '/api/v2/instantiations', '/api/v2/requests')
1070 api
.add_resource(Exit
, '/emulator/exit')
1074 def start_rest_api(host
, port
, datacenters
=dict()):
1075 GK
.dcs
= datacenters
1076 GK
.net
= get_dc_network()
1077 # start the Flask server (not the best performance but ok for our use case)
1081 use_reloader
=False # this is needed to run Flask in a non-main thread
1085 def ensure_dir(name
):
1086 if not os
.path
.exists(name
):
1090 def load_yaml(path
):
1091 with
open(path
, "r") as f
:
1094 except yaml
.YAMLError
as exc
:
1095 LOG
.exception("YAML parse error")
1100 def make_relative_path(path
):
1101 if path
.startswith("file://"):
1102 path
= path
.replace("file://", "", 1)
1103 if path
.startswith("/"):
1104 path
= path
.replace("/", "", 1)
1108 def get_dc_network():
1110 retrieve the DCnetwork where this dummygatekeeper (GK) connects to.
1111 Assume at least 1 datacenter is connected to this GK, and that all datacenters belong to the same DCNetwork
1114 assert (len(GK
.dcs
) > 0)
1115 return GK
.dcs
.values()[0].net
1118 def parse_interface(interface_name
):
1120 convert the interface name in the nsd to the according vnf_id, vnf_interface names
1121 :param interface_name:
1125 if ':' in interface_name
:
1126 vnf_id
, vnf_interface
= interface_name
.split(':')
1127 vnf_sap_docker_name
= interface_name
.replace(':', '_')
1129 vnf_id
= interface_name
1130 vnf_interface
= interface_name
1131 vnf_sap_docker_name
= interface_name
1133 return vnf_id
, vnf_interface
, vnf_sap_docker_name
1135 def reset_subnets():
1136 # private subnet definitions for the generated interfaces
1139 SAP_SUBNETS
= generate_subnets('10.10', 0, subnet_size
=50, mask
=30)
1142 ELAN_SUBNETS
= generate_subnets('10.20', 0, subnet_size
=50, mask
=24)
1144 global ELINE_SUBNETS
1145 ELINE_SUBNETS
= generate_subnets('10.30', 0, subnet_size
=50, mask
=30)
1147 if __name__
== '__main__':
1149 Lets allow to run the API in standalone mode.
1151 GK_STANDALONE_MODE
= True
1152 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
1153 start_rest_api("0.0.0.0", 8000)