Fix cloud-init insertion with v3 IM
[osm/RO.git] / osm_ro / nfvo.py
1 # -*- coding: utf-8 -*-
2
3 ##
4 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
5 # This file is part of openmano
6 # All Rights Reserved.
7 #
8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
9 # not use this file except in compliance with the License. You may obtain
10 # a copy of the License at
11 #
12 # http://www.apache.org/licenses/LICENSE-2.0
13 #
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17 # License for the specific language governing permissions and limitations
18 # under the License.
19 #
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact with: nfvlabs@tid.es
22 ##
23
24 '''
25 NFVO engine, implementing all the methods for the creation, deletion and management of vnfs, scenarios and instances
26 '''
27 __author__="Alfonso Tierno, Gerardo Garcia, Pablo Montes"
28 __date__ ="$16-sep-2014 22:05:01$"
29
30 # import imp
31 # import json
32 import yaml
33 import utils
34 import vim_thread
35 from db_base import HTTP_Unauthorized, HTTP_Bad_Request, HTTP_Internal_Server_Error, HTTP_Not_Found,\
36 HTTP_Conflict, HTTP_Method_Not_Allowed
37 import console_proxy_thread as cli
38 import vimconn
39 import logging
40 import collections
41 from uuid import uuid4
42 from db_base import db_base_Exception
43
44 import nfvo_db
45 from threading import Lock
46 import time as t
47 from lib_osm_openvim import ovim as ovim_module
48 from lib_osm_openvim.ovim import ovimException
49 from Crypto.PublicKey import RSA
50
51 import osm_im.vnfd as vnfd_catalog
52 import osm_im.nsd as nsd_catalog
53 from pyangbind.lib.serialise import pybindJSONDecoder
54 from itertools import chain
55
56 global global_config
57 global vimconn_imported
58 global logger
59 global default_volume_size
60 default_volume_size = '5' #size in GB
61 global ovim
62 ovim = None
63 global_config = None
64
65 vimconn_imported = {} # dictionary with VIM type as key, loaded module as value
66 vim_threads = {"running":{}, "deleting": {}, "names": []} # threads running for attached-VIMs
67 vim_persistent_info = {}
68 logger = logging.getLogger('openmano.nfvo')
69 task_lock = Lock()
70 last_task_id = 0.0
71 db = None
72 db_lock = Lock()
73
74 class NfvoException(Exception):
75 def __init__(self, message, http_code):
76 self.http_code = http_code
77 Exception.__init__(self, message)
78
79
80 def get_task_id():
81 global last_task_id
82 task_id = t.time()
83 if task_id <= last_task_id:
84 task_id = last_task_id + 0.000001
85 last_task_id = task_id
86 return "ACTION-{:.6f}".format(task_id)
87 # return (t.strftime("%Y%m%dT%H%M%S.{}%Z", t.localtime(task_id))).format(int((task_id % 1)*1e6))
88
89
90 def new_task(name, params, depends=None):
91 """Deprected!!!"""
92 task_id = get_task_id()
93 task = {"status": "enqueued", "id": task_id, "name": name, "params": params}
94 if depends:
95 task["depends"] = depends
96 return task
97
98
99 def is_task_id(id):
100 return True if id[:5] == "TASK-" else False
101
102
103 def get_non_used_vim_name(datacenter_name, datacenter_id, tenant_name, tenant_id):
104 name = datacenter_name[:16]
105 if name not in vim_threads["names"]:
106 vim_threads["names"].append(name)
107 return name
108 name = datacenter_name[:16] + "." + tenant_name[:16]
109 if name not in vim_threads["names"]:
110 vim_threads["names"].append(name)
111 return name
112 name = datacenter_id + "-" + tenant_id
113 vim_threads["names"].append(name)
114 return name
115
116
117 def start_service(mydb):
118 global db, global_config
119 db = nfvo_db.nfvo_db()
120 db.connect(global_config['db_host'], global_config['db_user'], global_config['db_passwd'], global_config['db_name'])
121 global ovim
122
123 # Initialize openvim for SDN control
124 # TODO: Avoid static configuration by adding new parameters to openmanod.cfg
125 # TODO: review ovim.py to delete not needed configuration
126 ovim_configuration = {
127 'logger_name': 'openmano.ovim',
128 'network_vlan_range_start': 1000,
129 'network_vlan_range_end': 4096,
130 'db_name': global_config["db_ovim_name"],
131 'db_host': global_config["db_ovim_host"],
132 'db_user': global_config["db_ovim_user"],
133 'db_passwd': global_config["db_ovim_passwd"],
134 'bridge_ifaces': {},
135 'mode': 'normal',
136 'network_type': 'bridge',
137 #TODO: log_level_of should not be needed. To be modified in ovim
138 'log_level_of': 'DEBUG'
139 }
140 try:
141 ovim = ovim_module.ovim(ovim_configuration)
142 ovim.start_service()
143
144 from_= 'tenants_datacenters as td join datacenters as d on td.datacenter_id=d.uuid join '\
145 'datacenter_tenants as dt on td.datacenter_tenant_id=dt.uuid'
146 select_ = ('type', 'd.config as config', 'd.uuid as datacenter_id', 'vim_url', 'vim_url_admin',
147 'd.name as datacenter_name', 'dt.uuid as datacenter_tenant_id',
148 'dt.vim_tenant_name as vim_tenant_name', 'dt.vim_tenant_id as vim_tenant_id',
149 'user', 'passwd', 'dt.config as dt_config', 'nfvo_tenant_id')
150 vims = mydb.get_rows(FROM=from_, SELECT=select_)
151 for vim in vims:
152 extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'),
153 'datacenter_id': vim.get('datacenter_id')}
154 if vim["config"]:
155 extra.update(yaml.load(vim["config"]))
156 if vim.get('dt_config'):
157 extra.update(yaml.load(vim["dt_config"]))
158 if vim["type"] not in vimconn_imported:
159 module_info=None
160 try:
161 module = "vimconn_" + vim["type"]
162 pkg = __import__("osm_ro." + module)
163 vim_conn = getattr(pkg, module)
164 # module_info = imp.find_module(module, [__file__[:__file__.rfind("/")]])
165 # vim_conn = imp.load_module(vim["type"], *module_info)
166 vimconn_imported[vim["type"]] = vim_conn
167 except (IOError, ImportError) as e:
168 # if module_info and module_info[0]:
169 # file.close(module_info[0])
170 raise NfvoException("Unknown vim type '{}'. Cannot open file '{}.py'; {}: {}".format(
171 vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request)
172
173 thread_id = vim['datacenter_tenant_id']
174 vim_persistent_info[thread_id] = {}
175 try:
176 #if not tenant:
177 # return -HTTP_Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"])
178 myvim = vimconn_imported[ vim["type"] ].vimconnector(
179 uuid=vim['datacenter_id'], name=vim['datacenter_name'],
180 tenant_id=vim['vim_tenant_id'], tenant_name=vim['vim_tenant_name'],
181 url=vim['vim_url'], url_admin=vim['vim_url_admin'],
182 user=vim['user'], passwd=vim['passwd'],
183 config=extra, persistent_info=vim_persistent_info[thread_id]
184 )
185 except Exception as e:
186 raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, e),
187 HTTP_Internal_Server_Error)
188 thread_name = get_non_used_vim_name(vim['datacenter_name'], vim['vim_tenant_id'], vim['vim_tenant_name'],
189 vim['vim_tenant_id'])
190 new_thread = vim_thread.vim_thread(myvim, task_lock, thread_name, vim['datacenter_name'],
191 vim['datacenter_tenant_id'], db=db, db_lock=db_lock, ovim=ovim)
192 new_thread.start()
193 vim_threads["running"][thread_id] = new_thread
194 except db_base_Exception as e:
195 raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code)
196 except ovim_module.ovimException as e:
197 message = str(e)
198 if message[:22] == "DATABASE wrong version":
199 message = "DATABASE wrong version of lib_osm_openvim {msg} -d{dbname} -u{dbuser} -p{dbpass} {ver}' "\
200 "at host {dbhost}".format(
201 msg=message[22:-3], dbname=global_config["db_ovim_name"],
202 dbuser=global_config["db_ovim_user"], dbpass=global_config["db_ovim_passwd"],
203 ver=message[-3:-1], dbhost=global_config["db_ovim_host"])
204 raise NfvoException(message, HTTP_Bad_Request)
205
206
207 def stop_service():
208 global ovim, global_config
209 if ovim:
210 ovim.stop_service()
211 for thread_id,thread in vim_threads["running"].items():
212 thread.insert_task("exit")
213 vim_threads["deleting"][thread_id] = thread
214 vim_threads["running"] = {}
215 if global_config and global_config.get("console_thread"):
216 for thread in global_config["console_thread"]:
217 thread.terminate = True
218
219 def get_version():
220 return ("openmanod version {} {}\n(c) Copyright Telefonica".format(global_config["version"],
221 global_config["version_date"] ))
222
223
224 def get_flavorlist(mydb, vnf_id, nfvo_tenant=None):
225 '''Obtain flavorList
226 return result, content:
227 <0, error_text upon error
228 nb_records, flavor_list on success
229 '''
230 WHERE_dict={}
231 WHERE_dict['vnf_id'] = vnf_id
232 if nfvo_tenant is not None:
233 WHERE_dict['nfvo_tenant_id'] = nfvo_tenant
234
235 #result, content = mydb.get_table(FROM='vms join vnfs on vms.vnf_id = vnfs.uuid',SELECT=('uuid'),WHERE=WHERE_dict )
236 #result, content = mydb.get_table(FROM='vms',SELECT=('vim_flavor_id',),WHERE=WHERE_dict )
237 flavors = mydb.get_rows(FROM='vms join flavors on vms.flavor_id=flavors.uuid',SELECT=('flavor_id',),WHERE=WHERE_dict )
238 #print "get_flavor_list result:", result
239 #print "get_flavor_list content:", content
240 flavorList=[]
241 for flavor in flavors:
242 flavorList.append(flavor['flavor_id'])
243 return flavorList
244
245
246 def get_imagelist(mydb, vnf_id, nfvo_tenant=None):
247 '''Obtain imageList
248 return result, content:
249 <0, error_text upon error
250 nb_records, flavor_list on success
251 '''
252 WHERE_dict={}
253 WHERE_dict['vnf_id'] = vnf_id
254 if nfvo_tenant is not None:
255 WHERE_dict['nfvo_tenant_id'] = nfvo_tenant
256
257 #result, content = mydb.get_table(FROM='vms join vnfs on vms-vnf_id = vnfs.uuid',SELECT=('uuid'),WHERE=WHERE_dict )
258 images = mydb.get_rows(FROM='vms join images on vms.image_id=images.uuid',SELECT=('image_id',),WHERE=WHERE_dict )
259 imageList=[]
260 for image in images:
261 imageList.append(image['image_id'])
262 return imageList
263
264
265 def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, datacenter_tenant_id=None,
266 vim_tenant=None, vim_tenant_name=None, vim_user=None, vim_passwd=None):
267 '''Obtain a dictionary of VIM (datacenter) classes with some of the input parameters
268 return dictionary with {datacenter_id: vim_class, ... }. vim_class contain:
269 'nfvo_tenant_id','datacenter_id','vim_tenant_id','vim_url','vim_url_admin','datacenter_name','type','user','passwd'
270 raise exception upon error
271 '''
272 WHERE_dict={}
273 if nfvo_tenant is not None: WHERE_dict['nfvo_tenant_id'] = nfvo_tenant
274 if datacenter_id is not None: WHERE_dict['d.uuid'] = datacenter_id
275 if datacenter_tenant_id is not None: WHERE_dict['datacenter_tenant_id'] = datacenter_tenant_id
276 if datacenter_name is not None: WHERE_dict['d.name'] = datacenter_name
277 if vim_tenant is not None: WHERE_dict['dt.vim_tenant_id'] = vim_tenant
278 if vim_tenant_name is not None: WHERE_dict['vim_tenant_name'] = vim_tenant_name
279 if nfvo_tenant or vim_tenant or vim_tenant_name or datacenter_tenant_id:
280 from_= 'tenants_datacenters as td join datacenters as d on td.datacenter_id=d.uuid join datacenter_tenants as dt on td.datacenter_tenant_id=dt.uuid'
281 select_ = ('type','d.config as config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name',
282 'dt.uuid as datacenter_tenant_id','dt.vim_tenant_name as vim_tenant_name','dt.vim_tenant_id as vim_tenant_id',
283 'user','passwd', 'dt.config as dt_config')
284 else:
285 from_ = 'datacenters as d'
286 select_ = ('type','config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name')
287 try:
288 vims = mydb.get_rows(FROM=from_, SELECT=select_, WHERE=WHERE_dict )
289 vim_dict={}
290 for vim in vims:
291 extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'),
292 'datacenter_id': vim.get('datacenter_id')}
293 if vim["config"]:
294 extra.update(yaml.load(vim["config"]))
295 if vim.get('dt_config'):
296 extra.update(yaml.load(vim["dt_config"]))
297 if vim["type"] not in vimconn_imported:
298 module_info=None
299 try:
300 module = "vimconn_" + vim["type"]
301 pkg = __import__("osm_ro." + module)
302 vim_conn = getattr(pkg, module)
303 # module_info = imp.find_module(module, [__file__[:__file__.rfind("/")]])
304 # vim_conn = imp.load_module(vim["type"], *module_info)
305 vimconn_imported[vim["type"]] = vim_conn
306 except (IOError, ImportError) as e:
307 # if module_info and module_info[0]:
308 # file.close(module_info[0])
309 raise NfvoException("Unknown vim type '{}'. Can not open file '{}.py'; {}: {}".format(
310 vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request)
311
312 try:
313 if 'datacenter_tenant_id' in vim:
314 thread_id = vim["datacenter_tenant_id"]
315 if thread_id not in vim_persistent_info:
316 vim_persistent_info[thread_id] = {}
317 persistent_info = vim_persistent_info[thread_id]
318 else:
319 persistent_info = {}
320 #if not tenant:
321 # return -HTTP_Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"])
322 vim_dict[ vim['datacenter_id'] ] = vimconn_imported[ vim["type"] ].vimconnector(
323 uuid=vim['datacenter_id'], name=vim['datacenter_name'],
324 tenant_id=vim.get('vim_tenant_id',vim_tenant),
325 tenant_name=vim.get('vim_tenant_name',vim_tenant_name),
326 url=vim['vim_url'], url_admin=vim['vim_url_admin'],
327 user=vim.get('user',vim_user), passwd=vim.get('passwd',vim_passwd),
328 config=extra, persistent_info=persistent_info
329 )
330 except Exception as e:
331 raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)), HTTP_Internal_Server_Error)
332 return vim_dict
333 except db_base_Exception as e:
334 raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code)
335
336
337 def rollback(mydb, vims, rollback_list):
338 undeleted_items=[]
339 #delete things by reverse order
340 for i in range(len(rollback_list)-1, -1, -1):
341 item = rollback_list[i]
342 if item["where"]=="vim":
343 if item["vim_id"] not in vims:
344 continue
345 if is_task_id(item["uuid"]):
346 continue
347 vim = vims[item["vim_id"]]
348 try:
349 if item["what"]=="image":
350 vim.delete_image(item["uuid"])
351 mydb.delete_row(FROM="datacenters_images", WHERE={"datacenter_vim_id": vim["id"], "vim_id":item["uuid"]})
352 elif item["what"]=="flavor":
353 vim.delete_flavor(item["uuid"])
354 mydb.delete_row(FROM="datacenters_flavors", WHERE={"datacenter_id": vim["id"], "vim_id":item["uuid"]})
355 elif item["what"]=="network":
356 vim.delete_network(item["uuid"])
357 elif item["what"]=="vm":
358 vim.delete_vminstance(item["uuid"])
359 except vimconn.vimconnException as e:
360 logger.error("Error in rollback. Not possible to delete VIM %s '%s'. Message: %s", item['what'], item["uuid"], str(e))
361 undeleted_items.append("{} {} from VIM {}".format(item['what'], item["uuid"], vim["name"]))
362 except db_base_Exception as e:
363 logger.error("Error in rollback. Not possible to delete %s '%s' from DB.datacenters Message: %s", item['what'], item["uuid"], str(e))
364
365 else: # where==mano
366 try:
367 if item["what"]=="image":
368 mydb.delete_row(FROM="images", WHERE={"uuid": item["uuid"]})
369 elif item["what"]=="flavor":
370 mydb.delete_row(FROM="flavors", WHERE={"uuid": item["uuid"]})
371 except db_base_Exception as e:
372 logger.error("Error in rollback. Not possible to delete %s '%s' from DB. Message: %s", item['what'], item["uuid"], str(e))
373 undeleted_items.append("{} '{}'".format(item['what'], item["uuid"]))
374 if len(undeleted_items)==0:
375 return True," Rollback successful."
376 else:
377 return False," Rollback fails to delete: " + str(undeleted_items)
378
379
380 def check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=1):
381 global global_config
382 #create a dictionary with vnfc-name: vnfc:interface-list key:values pairs
383 vnfc_interfaces={}
384 for vnfc in vnf_descriptor["vnf"]["VNFC"]:
385 name_dict = {}
386 #dataplane interfaces
387 for numa in vnfc.get("numas",() ):
388 for interface in numa.get("interfaces",()):
389 if interface["name"] in name_dict:
390 raise NfvoException(
391 "Error at vnf:VNFC[name:'{}']:numas:interfaces:name, interface name '{}' already used in this VNFC".format(
392 vnfc["name"], interface["name"]),
393 HTTP_Bad_Request)
394 name_dict[ interface["name"] ] = "underlay"
395 #bridge interfaces
396 for interface in vnfc.get("bridge-ifaces",() ):
397 if interface["name"] in name_dict:
398 raise NfvoException(
399 "Error at vnf:VNFC[name:'{}']:bridge-ifaces:name, interface name '{}' already used in this VNFC".format(
400 vnfc["name"], interface["name"]),
401 HTTP_Bad_Request)
402 name_dict[ interface["name"] ] = "overlay"
403 vnfc_interfaces[ vnfc["name"] ] = name_dict
404 # check bood-data info
405 # if "boot-data" in vnfc:
406 # # check that user-data is incompatible with users and config-files
407 # if (vnfc["boot-data"].get("users") or vnfc["boot-data"].get("config-files")) and vnfc["boot-data"].get("user-data"):
408 # raise NfvoException(
409 # "Error at vnf:VNFC:boot-data, fields 'users' and 'config-files' are not compatible with 'user-data'",
410 # HTTP_Bad_Request)
411
412 #check if the info in external_connections matches with the one in the vnfcs
413 name_list=[]
414 for external_connection in vnf_descriptor["vnf"].get("external-connections",() ):
415 if external_connection["name"] in name_list:
416 raise NfvoException(
417 "Error at vnf:external-connections:name, value '{}' already used as an external-connection".format(
418 external_connection["name"]),
419 HTTP_Bad_Request)
420 name_list.append(external_connection["name"])
421 if external_connection["VNFC"] not in vnfc_interfaces:
422 raise NfvoException(
423 "Error at vnf:external-connections[name:'{}']:VNFC, value '{}' does not match any VNFC".format(
424 external_connection["name"], external_connection["VNFC"]),
425 HTTP_Bad_Request)
426
427 if external_connection["local_iface_name"] not in vnfc_interfaces[ external_connection["VNFC"] ]:
428 raise NfvoException(
429 "Error at vnf:external-connections[name:'{}']:local_iface_name, value '{}' does not match any interface of this VNFC".format(
430 external_connection["name"],
431 external_connection["local_iface_name"]),
432 HTTP_Bad_Request )
433
434 #check if the info in internal_connections matches with the one in the vnfcs
435 name_list=[]
436 for internal_connection in vnf_descriptor["vnf"].get("internal-connections",() ):
437 if internal_connection["name"] in name_list:
438 raise NfvoException(
439 "Error at vnf:internal-connections:name, value '%s' already used as an internal-connection".format(
440 internal_connection["name"]),
441 HTTP_Bad_Request)
442 name_list.append(internal_connection["name"])
443 #We should check that internal-connections of type "ptp" have only 2 elements
444
445 if len(internal_connection["elements"])>2 and (internal_connection.get("type") == "ptp" or internal_connection.get("type") == "e-line"):
446 raise NfvoException(
447 "Error at 'vnf:internal-connections[name:'{}']:elements', size must be 2 for a '{}' type. Consider change it to '{}' type".format(
448 internal_connection["name"],
449 'ptp' if vnf_descriptor_version==1 else 'e-line',
450 'data' if vnf_descriptor_version==1 else "e-lan"),
451 HTTP_Bad_Request)
452 for port in internal_connection["elements"]:
453 vnf = port["VNFC"]
454 iface = port["local_iface_name"]
455 if vnf not in vnfc_interfaces:
456 raise NfvoException(
457 "Error at vnf:internal-connections[name:'{}']:elements[]:VNFC, value '{}' does not match any VNFC".format(
458 internal_connection["name"], vnf),
459 HTTP_Bad_Request)
460 if iface not in vnfc_interfaces[ vnf ]:
461 raise NfvoException(
462 "Error at vnf:internal-connections[name:'{}']:elements[]:local_iface_name, value '{}' does not match any interface of this VNFC".format(
463 internal_connection["name"], iface),
464 HTTP_Bad_Request)
465 return -HTTP_Bad_Request,
466 if vnf_descriptor_version==1 and "type" not in internal_connection:
467 if vnfc_interfaces[vnf][iface] == "overlay":
468 internal_connection["type"] = "bridge"
469 else:
470 internal_connection["type"] = "data"
471 if vnf_descriptor_version==2 and "implementation" not in internal_connection:
472 if vnfc_interfaces[vnf][iface] == "overlay":
473 internal_connection["implementation"] = "overlay"
474 else:
475 internal_connection["implementation"] = "underlay"
476 if (internal_connection.get("type") == "data" or internal_connection.get("type") == "ptp" or \
477 internal_connection.get("implementation") == "underlay") and vnfc_interfaces[vnf][iface] == "overlay":
478 raise NfvoException(
479 "Error at vnf:internal-connections[name:'{}']:elements[]:{}, interface of type {} connected to an {} network".format(
480 internal_connection["name"],
481 iface, 'bridge' if vnf_descriptor_version==1 else 'overlay',
482 'data' if vnf_descriptor_version==1 else 'underlay'),
483 HTTP_Bad_Request)
484 if (internal_connection.get("type") == "bridge" or internal_connection.get("implementation") == "overlay") and \
485 vnfc_interfaces[vnf][iface] == "underlay":
486 raise NfvoException(
487 "Error at vnf:internal-connections[name:'{}']:elements[]:{}, interface of type {} connected to an {} network".format(
488 internal_connection["name"], iface,
489 'data' if vnf_descriptor_version==1 else 'underlay',
490 'bridge' if vnf_descriptor_version==1 else 'overlay'),
491 HTTP_Bad_Request)
492
493
494 def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error=None):
495 #look if image exist
496 if only_create_at_vim:
497 image_mano_id = image_dict['uuid']
498 if return_on_error == None:
499 return_on_error = True
500 else:
501 if image_dict['location']:
502 images = mydb.get_rows(FROM="images", WHERE={'location':image_dict['location'], 'metadata':image_dict['metadata']})
503 else:
504 images = mydb.get_rows(FROM="images", WHERE={'universal_name':image_dict['universal_name'], 'checksum':image_dict['checksum']})
505 if len(images)>=1:
506 image_mano_id = images[0]['uuid']
507 else:
508 #create image in MANO DB
509 temp_image_dict={'name':image_dict['name'], 'description':image_dict.get('description',None),
510 'location':image_dict['location'], 'metadata':image_dict.get('metadata',None),
511 'universal_name':image_dict['universal_name'] , 'checksum':image_dict['checksum']
512 }
513 #temp_image_dict['location'] = image_dict.get('new_location') if image_dict['location'] is None
514 image_mano_id = mydb.new_row('images', temp_image_dict, add_uuid=True)
515 rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id})
516 #create image at every vim
517 for vim_id,vim in vims.iteritems():
518 datacenter_vim_id = vim["config"]["datacenter_tenant_id"]
519 image_created="false"
520 #look at database
521 image_db = mydb.get_rows(FROM="datacenters_images",
522 WHERE={'datacenter_vim_id': datacenter_vim_id, 'image_id': image_mano_id})
523 #look at VIM if this image exist
524 try:
525 if image_dict['location'] is not None:
526 image_vim_id = vim.get_image_id_from_path(image_dict['location'])
527 else:
528 filter_dict = {}
529 filter_dict['name'] = image_dict['universal_name']
530 if image_dict.get('checksum') != None:
531 filter_dict['checksum'] = image_dict['checksum']
532 #logger.debug('>>>>>>>> Filter dict: %s', str(filter_dict))
533 vim_images = vim.get_image_list(filter_dict)
534 #logger.debug('>>>>>>>> VIM images: %s', str(vim_images))
535 if len(vim_images) > 1:
536 raise vimconn.vimconnException("More than one candidate VIM image found for filter: {}".format(str(filter_dict)), HTTP_Conflict)
537 elif len(vim_images) == 0:
538 raise vimconn.vimconnNotFoundException("Image not found at VIM with filter: '{}'".format(str(filter_dict)))
539 else:
540 #logger.debug('>>>>>>>> VIM image 0: %s', str(vim_images[0]))
541 image_vim_id = vim_images[0]['id']
542
543 except vimconn.vimconnNotFoundException as e:
544 #Create the image in VIM only if image_dict['location'] or image_dict['new_location'] is not None
545 try:
546 #image_dict['location']=image_dict.get('new_location') if image_dict['location'] is None
547 if image_dict['location']:
548 image_vim_id = vim.new_image(image_dict)
549 rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"image","uuid":image_vim_id})
550 image_created="true"
551 else:
552 #If we reach this point, then the image has image name, and optionally checksum, and could not be found
553 raise vimconn.vimconnException(str(e))
554 except vimconn.vimconnException as e:
555 if return_on_error:
556 logger.error("Error creating image at VIM '%s': %s", vim["name"], str(e))
557 raise
558 image_vim_id = None
559 logger.warn("Error creating image at VIM '%s': %s", vim["name"], str(e))
560 continue
561 except vimconn.vimconnException as e:
562 if return_on_error:
563 logger.error("Error contacting VIM to know if the image exists at VIM: %s", str(e))
564 raise
565 logger.warn("Error contacting VIM to know if the image exists at VIM: %s", str(e))
566 image_vim_id = None
567 continue
568 #if we reach here, the image has been created or existed
569 if len(image_db)==0:
570 #add new vim_id at datacenters_images
571 mydb.new_row('datacenters_images', {'datacenter_vim_id': datacenter_vim_id,
572 'image_id':image_mano_id,
573 'vim_id': image_vim_id,
574 'created':image_created})
575 elif image_db[0]["vim_id"]!=image_vim_id:
576 #modify existing vim_id at datacenters_images
577 mydb.update_rows('datacenters_images', UPDATE={'vim_id':image_vim_id}, WHERE={'datacenter_vim_id':vim_id, 'image_id':image_mano_id})
578
579 return image_vim_id if only_create_at_vim else image_mano_id
580
581
582 def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_vim=False, return_on_error = None):
583 temp_flavor_dict= {'disk':flavor_dict.get('disk',1),
584 'ram':flavor_dict.get('ram'),
585 'vcpus':flavor_dict.get('vcpus'),
586 }
587 if 'extended' in flavor_dict and flavor_dict['extended']==None:
588 del flavor_dict['extended']
589 if 'extended' in flavor_dict:
590 temp_flavor_dict['extended']=yaml.safe_dump(flavor_dict['extended'],default_flow_style=True,width=256)
591
592 #look if flavor exist
593 if only_create_at_vim:
594 flavor_mano_id = flavor_dict['uuid']
595 if return_on_error == None:
596 return_on_error = True
597 else:
598 flavors = mydb.get_rows(FROM="flavors", WHERE=temp_flavor_dict)
599 if len(flavors)>=1:
600 flavor_mano_id = flavors[0]['uuid']
601 else:
602 #create flavor
603 #create one by one the images of aditional disks
604 dev_image_list=[] #list of images
605 if 'extended' in flavor_dict and flavor_dict['extended']!=None:
606 dev_nb=0
607 for device in flavor_dict['extended'].get('devices',[]):
608 if "image" not in device and "image name" not in device:
609 continue
610 image_dict={}
611 image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img")
612 image_dict['universal_name']=device.get('image name')
613 image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img"
614 image_dict['location']=device.get('image')
615 #image_dict['new_location']=vnfc.get('image location')
616 image_dict['checksum']=device.get('image checksum')
617 image_metadata_dict = device.get('image metadata', None)
618 image_metadata_str = None
619 if image_metadata_dict != None:
620 image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
621 image_dict['metadata']=image_metadata_str
622 image_id = create_or_use_image(mydb, vims, image_dict, rollback_list)
623 #print "Additional disk image id for VNFC %s: %s" % (flavor_dict['name']+str(dev_nb)+"-img", image_id)
624 dev_image_list.append(image_id)
625 dev_nb += 1
626 temp_flavor_dict['name'] = flavor_dict['name']
627 temp_flavor_dict['description'] = flavor_dict.get('description',None)
628 content = mydb.new_row('flavors', temp_flavor_dict, add_uuid=True)
629 flavor_mano_id= content
630 rollback_list.append({"where":"mano", "what":"flavor","uuid":flavor_mano_id})
631 #create flavor at every vim
632 if 'uuid' in flavor_dict:
633 del flavor_dict['uuid']
634 flavor_vim_id=None
635 for vim_id,vim in vims.items():
636 datacenter_vim_id = vim["config"]["datacenter_tenant_id"]
637 flavor_created="false"
638 #look at database
639 flavor_db = mydb.get_rows(FROM="datacenters_flavors",
640 WHERE={'datacenter_vim_id': datacenter_vim_id, 'flavor_id': flavor_mano_id})
641 #look at VIM if this flavor exist SKIPPED
642 #res_vim, flavor_vim_id = vim.get_flavor_id_from_path(flavor_dict['location'])
643 #if res_vim < 0:
644 # print "Error contacting VIM to know if the flavor %s existed previously." %flavor_vim_id
645 # continue
646 #elif res_vim==0:
647
648 # Create the flavor in VIM
649 # Translate images at devices from MANO id to VIM id
650 disk_list = []
651 if 'extended' in flavor_dict and flavor_dict['extended']!=None and "devices" in flavor_dict['extended']:
652 # make a copy of original devices
653 devices_original=[]
654
655 for device in flavor_dict["extended"].get("devices",[]):
656 dev={}
657 dev.update(device)
658 devices_original.append(dev)
659 if 'image' in device:
660 del device['image']
661 if 'image metadata' in device:
662 del device['image metadata']
663 if 'image checksum' in device:
664 del device['image checksum']
665 dev_nb = 0
666 for index in range(0,len(devices_original)) :
667 device=devices_original[index]
668 if "image" not in device and "image name" not in device:
669 if 'size' in device:
670 disk_list.append({'size': device.get('size', default_volume_size)})
671 continue
672 image_dict={}
673 image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img")
674 image_dict['universal_name']=device.get('image name')
675 image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img"
676 image_dict['location']=device.get('image')
677 # image_dict['new_location']=device.get('image location')
678 image_dict['checksum']=device.get('image checksum')
679 image_metadata_dict = device.get('image metadata', None)
680 image_metadata_str = None
681 if image_metadata_dict != None:
682 image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
683 image_dict['metadata']=image_metadata_str
684 image_mano_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error=return_on_error )
685 image_dict["uuid"]=image_mano_id
686 image_vim_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=True, return_on_error=return_on_error)
687
688 #save disk information (image must be based on and size
689 disk_list.append({'image_id': image_vim_id, 'size': device.get('size', default_volume_size)})
690
691 flavor_dict["extended"]["devices"][index]['imageRef']=image_vim_id
692 dev_nb += 1
693 if len(flavor_db)>0:
694 #check that this vim_id exist in VIM, if not create
695 flavor_vim_id=flavor_db[0]["vim_id"]
696 try:
697 vim.get_flavor(flavor_vim_id)
698 continue #flavor exist
699 except vimconn.vimconnException:
700 pass
701 #create flavor at vim
702 logger.debug("nfvo.create_or_use_flavor() adding flavor to VIM %s", vim["name"])
703 try:
704 flavor_vim_id = None
705 flavor_vim_id=vim.get_flavor_id_from_data(flavor_dict)
706 flavor_create="false"
707 except vimconn.vimconnException as e:
708 pass
709 try:
710 if not flavor_vim_id:
711 flavor_vim_id = vim.new_flavor(flavor_dict)
712 rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"flavor","uuid":flavor_vim_id})
713 flavor_created="true"
714 except vimconn.vimconnException as e:
715 if return_on_error:
716 logger.error("Error creating flavor at VIM %s: %s.", vim["name"], str(e))
717 raise
718 logger.warn("Error creating flavor at VIM %s: %s.", vim["name"], str(e))
719 flavor_vim_id = None
720 continue
721 #if reach here the flavor has been create or exist
722 if len(flavor_db)==0:
723 #add new vim_id at datacenters_flavors
724 extended_devices_yaml = None
725 if len(disk_list) > 0:
726 extended_devices = dict()
727 extended_devices['disks'] = disk_list
728 extended_devices_yaml = yaml.safe_dump(extended_devices,default_flow_style=True,width=256)
729 mydb.new_row('datacenters_flavors',
730 {'datacenter_vim_id': datacenter_vim_id, 'flavor_id': flavor_mano_id, 'vim_id': flavor_vim_id,
731 'created': flavor_created, 'extended': extended_devices_yaml})
732 elif flavor_db[0]["vim_id"]!=flavor_vim_id:
733 #modify existing vim_id at datacenters_flavors
734 mydb.update_rows('datacenters_flavors', UPDATE={'vim_id':flavor_vim_id},
735 WHERE={'datacenter_vim_id': datacenter_vim_id, 'flavor_id': flavor_mano_id})
736
737 return flavor_vim_id if only_create_at_vim else flavor_mano_id
738
739
740 def get_str(obj, field, length):
741 """
742 Obtain the str value,
743 :param obj:
744 :param length:
745 :return:
746 """
747 value = obj.get(field)
748 if value is not None:
749 value = str(value)[:length]
750 return value
751
752 def _lookfor_or_create_image(db_image, mydb, descriptor):
753 """
754 fill image content at db_image dictionary. Check if the image with this image and checksum exist
755 :param db_image: dictionary to insert data
756 :param mydb: database connector
757 :param descriptor: yang descriptor
758 :return: uuid if the image exist at DB, or None if a new image must be created with the data filled at db_image
759 """
760
761 db_image["name"] = get_str(descriptor, "image", 255)
762 db_image["checksum"] = get_str(descriptor, "image-checksum", 32)
763 if not db_image["checksum"]: # Ensure that if empty string, None is stored
764 db_image["checksum"] = None
765 if db_image["name"].startswith("/"):
766 db_image["location"] = db_image["name"]
767 existing_images = mydb.get_rows(FROM="images", WHERE={'location': db_image["location"]})
768 else:
769 db_image["universal_name"] = db_image["name"]
770 existing_images = mydb.get_rows(FROM="images", WHERE={'universal_name': db_image['universal_name'],
771 'checksum': db_image['checksum']})
772 if existing_images:
773 return existing_images[0]["uuid"]
774 else:
775 image_uuid = str(uuid4())
776 db_image["uuid"] = image_uuid
777 return None
778
779 def new_vnfd_v3(mydb, tenant_id, vnf_descriptor):
780 """
781 Parses an OSM IM vnfd_catalog and insert at DB
782 :param mydb:
783 :param tenant_id:
784 :param vnf_descriptor:
785 :return: The list of cretated vnf ids
786 """
787 try:
788 myvnfd = vnfd_catalog.vnfd()
789 try:
790 pybindJSONDecoder.load_ietf_json(vnf_descriptor, None, None, obj=myvnfd)
791 except Exception as e:
792 raise NfvoException("Invalid yang descriptor format " + str(e), HTTP_Bad_Request)
793 db_vnfs = []
794 db_nets = []
795 db_vms = []
796 db_vms_index = 0
797 db_interfaces = []
798 db_images = []
799 db_flavors = []
800 uuid_list = []
801 vnfd_uuid_list = []
802 for rift_vnfd in myvnfd.vnfd_catalog.vnfd.itervalues():
803 vnfd = rift_vnfd.get()
804
805 # table vnf
806 vnf_uuid = str(uuid4())
807 uuid_list.append(vnf_uuid)
808 vnfd_uuid_list.append(vnf_uuid)
809 db_vnf = {
810 "uuid": vnf_uuid,
811 "osm_id": get_str(vnfd, "id", 255),
812 "name": get_str(vnfd, "name", 255),
813 "description": get_str(vnfd, "description", 255),
814 "tenant_id": tenant_id,
815 "vendor": get_str(vnfd, "vendor", 255),
816 "short_name": get_str(vnfd, "short-name", 255),
817 "descriptor": str(vnf_descriptor)[:60000]
818 }
819
820 # table nets (internal-vld)
821 net_id2uuid = {} # for mapping interface with network
822 for vld in vnfd.get("internal-vld").itervalues():
823 net_uuid = str(uuid4())
824 uuid_list.append(net_uuid)
825 db_net = {
826 "name": get_str(vld, "name", 255),
827 "vnf_id": vnf_uuid,
828 "uuid": net_uuid,
829 "description": get_str(vld, "description", 255),
830 "type": "bridge", # TODO adjust depending on connection point type
831 }
832 net_id2uuid[vld.get("id")] = net_uuid
833 db_nets.append(db_net)
834
835 # table vms (vdus)
836 vdu_id2uuid = {}
837 vdu_id2db_table_index = {}
838 for vdu in vnfd.get("vdu").itervalues():
839 vm_uuid = str(uuid4())
840 uuid_list.append(vm_uuid)
841 db_vm = {
842 "uuid": vm_uuid,
843 "osm_id": get_str(vdu, "id", 255),
844 "name": get_str(vdu, "name", 255),
845 "description": get_str(vdu, "description", 255),
846 "vnf_id": vnf_uuid,
847 }
848 vdu_id2uuid[db_vm["osm_id"]] = vm_uuid
849 vdu_id2db_table_index[db_vm["osm_id"]] = db_vms_index
850 if vdu.get("count"):
851 db_vm["count"] = int(vdu["count"])
852
853 # table image
854 image_present = False
855 if vdu.get("image"):
856 image_present = True
857 db_image = {}
858 image_uuid = _lookfor_or_create_image(db_image, mydb, vdu)
859 if not image_uuid:
860 image_uuid = db_image["uuid"]
861 db_images.append(db_image)
862 db_vm["image_id"] = image_uuid
863
864 # volumes
865 devices = []
866 if vdu.get("volumes"):
867 for volume_key in sorted(vdu["volumes"]):
868 volume = vdu["volumes"][volume_key]
869 if not image_present:
870 # Convert the first volume to vnfc.image
871 image_present = True
872 db_image = {}
873 image_uuid = _lookfor_or_create_image(db_image, mydb, volume)
874 if not image_uuid:
875 image_uuid = db_image["uuid"]
876 db_images.append(db_image)
877 db_vm["image_id"] = image_uuid
878 else:
879 # Add Openmano devices
880 device = {}
881 device["type"] = str(volume.get("device-type"))
882 if volume.get("size"):
883 device["size"] = int(volume["size"])
884 if volume.get("image"):
885 device["image name"] = str(volume["image"])
886 if volume.get("image-checksum"):
887 device["image checksum"] = str(volume["image-checksum"])
888 devices.append(device)
889
890 # table flavors
891 db_flavor = {
892 "name": get_str(vdu, "name", 250) + "-flv",
893 "vcpus": int(vdu["vm-flavor"].get("vcpu-count", 1)),
894 "ram": int(vdu["vm-flavor"].get("memory-mb", 1)),
895 "disk": int(vdu["vm-flavor"].get("storage-gb", 1)),
896 }
897 # EPA TODO revise
898 extended = {}
899 numa = {}
900 if devices:
901 extended["devices"] = devices
902 if vdu.get("guest-epa"): # TODO or dedicated_int:
903 epa_vcpu_set = False
904 if vdu["guest-epa"].get("numa-node-policy"): # TODO or dedicated_int:
905 numa_node_policy = vdu["guest-epa"].get("numa-node-policy")
906 if numa_node_policy.get("node"):
907 numa_node = numa_node_policy.node[0]
908 if numa_node.get("num-cores"):
909 numa["cores"] = numa_node["num-cores"]
910 epa_vcpu_set = True
911 if numa_node.get("paired-threads"):
912 if numa_node["paired-threads"].get("num-paired-threads"):
913 numa["paired-threads"] = numa_node["paired-threads"]["num-paired-threads"]
914 epa_vcpu_set = True
915 if len(numa_node["paired-threads"].get("paired-thread-ids")) > 0:
916 numa["paired-threads-id"] = []
917 for pair in numa_node["paired-threads"]["paired-thread-ids"].itervalues:
918 numa["paired-threads-id"].append(
919 (str(pair["thread-a"]), str(pair["thread-b"]))
920 )
921 if numa_node.get("num-threads"):
922 numa["threads"] = numa_node["num-threads"]
923 epa_vcpu_set = True
924 if numa_node.get("memory-mb"):
925 numa["memory"] = max(int(numa_node["memory-mb"] / 1024), 1)
926 if vdu["guest-epa"].get("mempage-size"):
927 if vdu["guest-epa"]["mempage-size"] != "SMALL":
928 numa["memory"] = max(int(db_flavor["ram"] / 1024), 1)
929 if vdu["guest-epa"].get("cpu-pinning-policy") and not epa_vcpu_set:
930 if vdu["guest-epa"]["cpu-pinning-policy"] == "DEDICATED":
931 if vdu["guest-epa"].get("cpu-thread-pinning-policy") and \
932 vdu["guest-epa"]["cpu-thread-pinning-policy"] != "PREFER":
933 numa["cores"] = max(db_flavor["vcpus"], 1)
934 else:
935 numa["threads"] = max(db_flavor["vcpus"], 1)
936 if numa:
937 extended["numas"] = [numa]
938 if extended:
939 extended_text = yaml.safe_dump(extended, default_flow_style=True, width=256)
940 db_flavor["extended"] = extended_text
941 # look if flavor exist
942
943 temp_flavor_dict = {'disk': db_flavor.get('disk', 1),
944 'ram': db_flavor.get('ram'),
945 'vcpus': db_flavor.get('vcpus'),
946 'extended': db_flavor.get('extended')
947 }
948 existing_flavors = mydb.get_rows(FROM="flavors", WHERE=temp_flavor_dict)
949 if existing_flavors:
950 flavor_uuid = existing_flavors[0]["uuid"]
951 else:
952 flavor_uuid = str(uuid4())
953 uuid_list.append(flavor_uuid)
954 db_flavor["uuid"] = flavor_uuid
955 db_flavors.append(db_flavor)
956 db_vm["flavor_id"] = flavor_uuid
957
958 # cloud-init
959 boot_data = {}
960 if vdu.get("cloud-init"):
961 boot_data["user-data"] = str(vdu["cloud-init"])
962 elif vdu.get("cloud-init-file"):
963 # TODO Where this file content is present???
964 # boot_data["user-data"] = rift_vnfd.files[vdu["cloud-init-file"]]
965 boot_data["user-data"] = str(vdu["cloud-init-file"])
966
967 if vdu.get("supplemental-boot-data"):
968 if vdu["supplemental-boot-data"].get('boot-data-drive'):
969 boot_data['boot-data-drive'] = True
970 if vdu["supplemental-boot-data"].get('config-file'):
971 om_cfgfile_list = list()
972 for custom_config_file in vdu["supplemental-boot-data"]['config-file'].itervalues():
973 # TODO Where this file content is present???
974 cfg_source = str(custom_config_file["source"])
975 om_cfgfile_list.append({"dest": custom_config_file["dest"],
976 "content": cfg_source})
977 boot_data['config-files'] = om_cfgfile_list
978 if boot_data:
979 db_vm["boot_data"] = yaml.safe_dump(boot_data, default_flow_style=True, width=256)
980
981 db_vms.append(db_vm)
982 db_vms_index += 1
983
984 # table interfaces (internal/external interfaces)
985 cp_name2iface_uuid = {}
986 cp_name2vm_uuid = {}
987 # for iface in chain(vdu.get("internal-interface").itervalues(), vdu.get("external-interface").itervalues()):
988 for iface in vdu.get("interface").itervalues():
989 iface_uuid = str(uuid4())
990 uuid_list.append(iface_uuid)
991 db_interface = {
992 "uuid": iface_uuid,
993 "internal_name": get_str(iface, "name", 255),
994 "vm_id": vm_uuid,
995 }
996 if iface.get("virtual-interface").get("vpci"):
997 db_interface["vpci"] = get_str(iface.get("virtual-interface"), "vpci", 12)
998
999 if iface.get("virtual-interface").get("bandwidth"):
1000 bps = int(iface.get("virtual-interface").get("bandwidth"))
1001 db_interface["bw"] = bps/1000
1002
1003 if iface.get("virtual-interface").get("type") == "OM-MGMT":
1004 db_interface["type"] = "mgmt"
1005 elif iface.get("virtual-interface").get("type") in ("VIRTIO", "E1000"):
1006 db_interface["type"] = "bridge"
1007 db_interface["model"] = get_str(iface.get("virtual-interface"), "type", 12)
1008 elif iface.get("virtual-interface").get("type") in ("SR-IOV", "PCI-PASSTHROUGH"):
1009 db_interface["type"] = "data"
1010 db_interface["model"] = get_str(iface.get("virtual-interface"), "type", 12)
1011 else:
1012 raise ValueError("Interface type {} not supported".format(iface.get("virtual-interface").get("type")))
1013
1014 if iface.get("external-connection-point-ref"):
1015 try:
1016 cp = vnfd.get("connection-point")[iface.get("external-connection-point-ref")]
1017 db_interface["external_name"] = get_str(cp, "name", 255)
1018 cp_name2iface_uuid[db_interface["external_name"]] = iface_uuid
1019 cp_name2vm_uuid[db_interface["external_name"]] = vm_uuid
1020 # TODO add port-security-enable
1021 # if cp.get("port-security-enabled") == False:
1022 # elif cp.get("port-security-enabled") == True:
1023 except KeyError:
1024 raise KeyError(
1025 "Error wrong reference at vnfd['{vnf}'] vdu['{vdu}']:internal-interface['{iface}']:"
1026 "vnfd-connection-point-ref '{cp}' is not present at connection-point".format(
1027 vnf=vnfd["id"], vdu=vdu["id"], iface=iface["name"],
1028 cp=iface.get("vnfd-connection-point-ref"))
1029 )
1030 elif iface.get("internal-connection-point-ref"):
1031 try:
1032 for vld in vnfd.get("internal-vld").itervalues():
1033 for cp in vld.get("internal-connection-point").itervalues():
1034 if cp.get("id-ref") == iface.get("internal-connection-point-ref"):
1035 db_interface["net_id"] = net_id2uuid[vld.get("id")]
1036 break
1037 except KeyError:
1038 raise KeyError(
1039 "Error at vnfd['{vnf}'] vdu['{vdu}']:internal-interface['{iface}']:"
1040 "vdu-internal-connection-point-ref '{cp}' is not referenced by any internal-vld".format(
1041 vnf=vnfd["id"], vdu=vdu["id"], iface=iface["name"],
1042 cp=iface.get("vdu-internal-connection-point-ref"))
1043 )
1044 if iface.get("position") is not None:
1045 db_interface["created_at"] = int(iface.get("position")) - 1000
1046 db_interfaces.append(db_interface)
1047
1048 # VNF affinity and antiaffinity
1049 for pg in vnfd.get("placement-groups").itervalues():
1050 pg_name = get_str(pg, "name", 255)
1051 for vdu in pg.get("member-vdus").itervalues():
1052 vdu_id = get_str(vdu, "member-vdu-ref", 255)
1053 if vdu_id not in vdu_id2db_table_index:
1054 raise KeyError(
1055 "Error at 'vnfd'['{vnf}']:'placement-groups'['{pg}']:'member-vdus':'{vdu}' references a non existing vdu".format(
1056 vnf=vnfd["id"], pg=pg_name, vdu=vdu_id))
1057 db_vms[vdu_id2db_table_index[vdu_id]]["availability_zone"] = pg_name
1058 # TODO consider the case of isolation and not colocation
1059 # if pg.get("strategy") == "ISOLATION":
1060
1061 # VNF mgmt configuration
1062 mgmt_access = {}
1063 if vnfd["mgmt-interface"].get("vdu-id"):
1064 if vnfd["mgmt-interface"]["vdu-id"] not in vdu_id2uuid:
1065 raise KeyError(
1066 "Error at vnfd['{vnf}']:'mgmt-interface':'vdu-id':{vdu} reference a non existing vdu".format(
1067 vnf=vnfd["id"], vdu=vnfd["mgmt-interface"]["vdu-id"]))
1068 mgmt_access["vm_id"] = vdu_id2uuid[vnfd["mgmt-interface"]["vdu-id"]]
1069 if vnfd["mgmt-interface"].get("ip-address"):
1070 mgmt_access["ip-address"] = str(vnfd["mgmt-interface"].get("ip-address"))
1071 if vnfd["mgmt-interface"].get("cp"):
1072 if vnfd["mgmt-interface"]["cp"] not in cp_name2iface_uuid:
1073 raise KeyError(
1074 "Error at vnfd['{vnf}']:'mgmt-interface':'cp':{cp} reference a non existing connection-point".
1075 format(vnf=vnfd["id"], cp=vnfd["mgmt-interface"]["cp"]))
1076 mgmt_access["vm_id"] = cp_name2vm_uuid[vnfd["mgmt-interface"]["cp"]]
1077 mgmt_access["interface_id"] = cp_name2iface_uuid[vnfd["mgmt-interface"]["cp"]]
1078 default_user = get_str(vnfd.get("vnf-configuration", {}).get("config-access", {}).get("ssh-access", {}),
1079 "default-user", 64)
1080
1081 if default_user:
1082 mgmt_access["default_user"] = default_user
1083 required = get_str(vnfd.get("vnf-configuration", {}).get("config-access", {}).get("ssh-access", {}),
1084 "required", 6)
1085 if required:
1086 mgmt_access["required"] = required
1087
1088 if mgmt_access:
1089 db_vnf["mgmt_access"] = yaml.safe_dump(mgmt_access, default_flow_style=True, width=256)
1090
1091
1092
1093 db_vnfs.append(db_vnf)
1094 db_tables=[
1095 {"vnfs": db_vnfs},
1096 {"nets": db_nets},
1097 {"images": db_images},
1098 {"flavors": db_flavors},
1099 {"vms": db_vms},
1100 {"interfaces": db_interfaces},
1101 ]
1102
1103 logger.debug("create_vnf Deployment done vnfDict: %s",
1104 yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
1105 mydb.new_rows(db_tables, uuid_list)
1106 return vnfd_uuid_list
1107 except Exception as e:
1108 logger.error("Exception {}".format(e))
1109 raise # NfvoException("Exception {}".format(e), HTTP_Bad_Request)
1110
1111
1112 def new_vnf(mydb, tenant_id, vnf_descriptor):
1113 global global_config
1114
1115 # Step 1. Check the VNF descriptor
1116 check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=1)
1117 # Step 2. Check tenant exist
1118 vims = {}
1119 if tenant_id != "any":
1120 check_tenant(mydb, tenant_id)
1121 if "tenant_id" in vnf_descriptor["vnf"]:
1122 if vnf_descriptor["vnf"]["tenant_id"] != tenant_id:
1123 raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id),
1124 HTTP_Unauthorized)
1125 else:
1126 vnf_descriptor['vnf']['tenant_id'] = tenant_id
1127 # Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter
1128 if global_config["auto_push_VNF_to_VIMs"]:
1129 vims = get_vim(mydb, tenant_id)
1130
1131 # Step 4. Review the descriptor and add missing fields
1132 #print vnf_descriptor
1133 #logger.debug("Refactoring VNF descriptor with fields: description, public (default: true)")
1134 vnf_name = vnf_descriptor['vnf']['name']
1135 vnf_descriptor['vnf']['description'] = vnf_descriptor['vnf'].get("description", vnf_name)
1136 if "physical" in vnf_descriptor['vnf']:
1137 del vnf_descriptor['vnf']['physical']
1138 #print vnf_descriptor
1139
1140 # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM
1141 logger.debug('BEGIN creation of VNF "%s"' % vnf_name)
1142 logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC'])))
1143
1144 #For each VNFC, we add it to the VNFCDict and we create a flavor.
1145 VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database
1146 rollback_list = [] # It will contain the new images created in mano. It is used for rollback
1147 try:
1148 logger.debug("Creating additional disk images and new flavors in the VIM for each VNFC")
1149 for vnfc in vnf_descriptor['vnf']['VNFC']:
1150 VNFCitem={}
1151 VNFCitem["name"] = vnfc['name']
1152 VNFCitem["availability_zone"] = vnfc.get('availability_zone')
1153 VNFCitem["description"] = vnfc.get("description", 'VM %s of the VNF %s' %(vnfc['name'],vnf_name))
1154
1155 #print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"])
1156
1157 myflavorDict = {}
1158 myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists
1159 myflavorDict["description"] = VNFCitem["description"]
1160 myflavorDict["ram"] = vnfc.get("ram", 0)
1161 myflavorDict["vcpus"] = vnfc.get("vcpus", 0)
1162 myflavorDict["disk"] = vnfc.get("disk", 1)
1163 myflavorDict["extended"] = {}
1164
1165 devices = vnfc.get("devices")
1166 if devices != None:
1167 myflavorDict["extended"]["devices"] = devices
1168
1169 # TODO:
1170 # Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table
1171 # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host
1172
1173 # Previous code has been commented
1174 #if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" :
1175 # myflavorDict["flavor"]['extended']['processor_ranking'] = 200
1176 #elif vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-2697 v2 @ 2.70GHz" :
1177 # myflavorDict["flavor"]['extended']['processor_ranking'] = 300
1178 #else:
1179 # result2, message = rollback(myvim, myvimURL, myvim_tenant, flavorList, imageList)
1180 # if result2:
1181 # print "Error creating flavor: unknown processor model. Rollback successful."
1182 # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback successful."
1183 # else:
1184 # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message
1185 myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done
1186
1187 if 'numas' in vnfc and len(vnfc['numas'])>0:
1188 myflavorDict['extended']['numas'] = vnfc['numas']
1189
1190 #print myflavorDict
1191
1192 # Step 6.2 New flavors are created in the VIM
1193 flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list)
1194
1195 #print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id)
1196 VNFCitem["flavor_id"] = flavor_id
1197 VNFCDict[vnfc['name']] = VNFCitem
1198
1199 logger.debug("Creating new images in the VIM for each VNFC")
1200 # Step 6.3 New images are created in the VIM
1201 #For each VNFC, we must create the appropriate image.
1202 #This "for" loop might be integrated with the previous one
1203 #In case this integration is made, the VNFCDict might become a VNFClist.
1204 for vnfc in vnf_descriptor['vnf']['VNFC']:
1205 #print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description'])
1206 image_dict={}
1207 image_dict['name']=vnfc.get('image name',vnf_name+"-"+vnfc['name']+"-img")
1208 image_dict['universal_name']=vnfc.get('image name')
1209 image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description'])
1210 image_dict['location']=vnfc.get('VNFC image')
1211 #image_dict['new_location']=vnfc.get('image location')
1212 image_dict['checksum']=vnfc.get('image checksum')
1213 image_metadata_dict = vnfc.get('image metadata', None)
1214 image_metadata_str = None
1215 if image_metadata_dict is not None:
1216 image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
1217 image_dict['metadata']=image_metadata_str
1218 #print "create_or_use_image", mydb, vims, image_dict, rollback_list
1219 image_id = create_or_use_image(mydb, vims, image_dict, rollback_list)
1220 #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id)
1221 VNFCDict[vnfc['name']]["image_id"] = image_id
1222 VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image')
1223 VNFCDict[vnfc['name']]["count"] = vnfc.get('count', 1)
1224 if vnfc.get("boot-data"):
1225 VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256)
1226
1227
1228 # Step 7. Storing the VNF descriptor in the repository
1229 if "descriptor" not in vnf_descriptor["vnf"]:
1230 vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False)
1231
1232 # Step 8. Adding the VNF to the NFVO DB
1233 vnf_id = mydb.new_vnf_as_a_whole(tenant_id,vnf_name,vnf_descriptor,VNFCDict)
1234 return vnf_id
1235 except (db_base_Exception, vimconn.vimconnException, KeyError) as e:
1236 _, message = rollback(mydb, vims, rollback_list)
1237 if isinstance(e, db_base_Exception):
1238 error_text = "Exception at database"
1239 elif isinstance(e, KeyError):
1240 error_text = "KeyError exception "
1241 e.http_code = HTTP_Internal_Server_Error
1242 else:
1243 error_text = "Exception at VIM"
1244 error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
1245 #logger.error("start_scenario %s", error_text)
1246 raise NfvoException(error_text, e.http_code)
1247
1248
1249 def new_vnf_v02(mydb, tenant_id, vnf_descriptor):
1250 global global_config
1251
1252 # Step 1. Check the VNF descriptor
1253 check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=2)
1254 # Step 2. Check tenant exist
1255 vims = {}
1256 if tenant_id != "any":
1257 check_tenant(mydb, tenant_id)
1258 if "tenant_id" in vnf_descriptor["vnf"]:
1259 if vnf_descriptor["vnf"]["tenant_id"] != tenant_id:
1260 raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id),
1261 HTTP_Unauthorized)
1262 else:
1263 vnf_descriptor['vnf']['tenant_id'] = tenant_id
1264 # Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter
1265 if global_config["auto_push_VNF_to_VIMs"]:
1266 vims = get_vim(mydb, tenant_id)
1267
1268 # Step 4. Review the descriptor and add missing fields
1269 #print vnf_descriptor
1270 #logger.debug("Refactoring VNF descriptor with fields: description, public (default: true)")
1271 vnf_name = vnf_descriptor['vnf']['name']
1272 vnf_descriptor['vnf']['description'] = vnf_descriptor['vnf'].get("description", vnf_name)
1273 if "physical" in vnf_descriptor['vnf']:
1274 del vnf_descriptor['vnf']['physical']
1275 #print vnf_descriptor
1276
1277 # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM
1278 logger.debug('BEGIN creation of VNF "%s"' % vnf_name)
1279 logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC'])))
1280
1281 #For each VNFC, we add it to the VNFCDict and we create a flavor.
1282 VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database
1283 rollback_list = [] # It will contain the new images created in mano. It is used for rollback
1284 try:
1285 logger.debug("Creating additional disk images and new flavors in the VIM for each VNFC")
1286 for vnfc in vnf_descriptor['vnf']['VNFC']:
1287 VNFCitem={}
1288 VNFCitem["name"] = vnfc['name']
1289 VNFCitem["description"] = vnfc.get("description", 'VM %s of the VNF %s' %(vnfc['name'],vnf_name))
1290
1291 #print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"])
1292
1293 myflavorDict = {}
1294 myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists
1295 myflavorDict["description"] = VNFCitem["description"]
1296 myflavorDict["ram"] = vnfc.get("ram", 0)
1297 myflavorDict["vcpus"] = vnfc.get("vcpus", 0)
1298 myflavorDict["disk"] = vnfc.get("disk", 1)
1299 myflavorDict["extended"] = {}
1300
1301 devices = vnfc.get("devices")
1302 if devices != None:
1303 myflavorDict["extended"]["devices"] = devices
1304
1305 # TODO:
1306 # Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table
1307 # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host
1308
1309 # Previous code has been commented
1310 #if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" :
1311 # myflavorDict["flavor"]['extended']['processor_ranking'] = 200
1312 #elif vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-2697 v2 @ 2.70GHz" :
1313 # myflavorDict["flavor"]['extended']['processor_ranking'] = 300
1314 #else:
1315 # result2, message = rollback(myvim, myvimURL, myvim_tenant, flavorList, imageList)
1316 # if result2:
1317 # print "Error creating flavor: unknown processor model. Rollback successful."
1318 # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback successful."
1319 # else:
1320 # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message
1321 myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done
1322
1323 if 'numas' in vnfc and len(vnfc['numas'])>0:
1324 myflavorDict['extended']['numas'] = vnfc['numas']
1325
1326 #print myflavorDict
1327
1328 # Step 6.2 New flavors are created in the VIM
1329 flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list)
1330
1331 #print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id)
1332 VNFCitem["flavor_id"] = flavor_id
1333 VNFCDict[vnfc['name']] = VNFCitem
1334
1335 logger.debug("Creating new images in the VIM for each VNFC")
1336 # Step 6.3 New images are created in the VIM
1337 #For each VNFC, we must create the appropriate image.
1338 #This "for" loop might be integrated with the previous one
1339 #In case this integration is made, the VNFCDict might become a VNFClist.
1340 for vnfc in vnf_descriptor['vnf']['VNFC']:
1341 #print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description'])
1342 image_dict={}
1343 image_dict['name']=vnfc.get('image name',vnf_name+"-"+vnfc['name']+"-img")
1344 image_dict['universal_name']=vnfc.get('image name')
1345 image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description'])
1346 image_dict['location']=vnfc.get('VNFC image')
1347 #image_dict['new_location']=vnfc.get('image location')
1348 image_dict['checksum']=vnfc.get('image checksum')
1349 image_metadata_dict = vnfc.get('image metadata', None)
1350 image_metadata_str = None
1351 if image_metadata_dict is not None:
1352 image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
1353 image_dict['metadata']=image_metadata_str
1354 #print "create_or_use_image", mydb, vims, image_dict, rollback_list
1355 image_id = create_or_use_image(mydb, vims, image_dict, rollback_list)
1356 #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id)
1357 VNFCDict[vnfc['name']]["image_id"] = image_id
1358 VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image')
1359 VNFCDict[vnfc['name']]["count"] = vnfc.get('count', 1)
1360 if vnfc.get("boot-data"):
1361 VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256)
1362
1363 # Step 7. Storing the VNF descriptor in the repository
1364 if "descriptor" not in vnf_descriptor["vnf"]:
1365 vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False)
1366
1367 # Step 8. Adding the VNF to the NFVO DB
1368 vnf_id = mydb.new_vnf_as_a_whole2(tenant_id,vnf_name,vnf_descriptor,VNFCDict)
1369 return vnf_id
1370 except (db_base_Exception, vimconn.vimconnException, KeyError) as e:
1371 _, message = rollback(mydb, vims, rollback_list)
1372 if isinstance(e, db_base_Exception):
1373 error_text = "Exception at database"
1374 elif isinstance(e, KeyError):
1375 error_text = "KeyError exception "
1376 e.http_code = HTTP_Internal_Server_Error
1377 else:
1378 error_text = "Exception at VIM"
1379 error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
1380 #logger.error("start_scenario %s", error_text)
1381 raise NfvoException(error_text, e.http_code)
1382
1383
1384 def get_vnf_id(mydb, tenant_id, vnf_id):
1385 #check valid tenant_id
1386 check_tenant(mydb, tenant_id)
1387 #obtain data
1388 where_or = {}
1389 if tenant_id != "any":
1390 where_or["tenant_id"] = tenant_id
1391 where_or["public"] = True
1392 vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND")
1393
1394 vnf_id = vnf["uuid"]
1395 filter_keys = ('uuid', 'name', 'description', 'public', "tenant_id", "osm_id", "created_at")
1396 filtered_content = dict( (k,v) for k,v in vnf.iteritems() if k in filter_keys )
1397 #change_keys_http2db(filtered_content, http2db_vnf, reverse=True)
1398 data={'vnf' : filtered_content}
1399 #GET VM
1400 content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id',
1401 SELECT=('vms.uuid as uuid', 'vms.osm_id as osm_id', 'vms.name as name', 'vms.description as description',
1402 'boot_data'),
1403 WHERE={'vnfs.uuid': vnf_id} )
1404 if len(content)==0:
1405 raise NfvoException("vnf '{}' not found".format(vnf_id), HTTP_Not_Found)
1406 # change boot_data into boot-data
1407 for vm in content:
1408 if vm.get("boot_data"):
1409 vm["boot-data"] = yaml.safe_load(vm["boot_data"])
1410 del vm["boot_data"]
1411
1412 data['vnf']['VNFC'] = content
1413 #TODO: GET all the information from a VNFC and include it in the output.
1414
1415 #GET NET
1416 content = mydb.get_rows(FROM='vnfs join nets on vnfs.uuid=nets.vnf_id',
1417 SELECT=('nets.uuid as uuid','nets.name as name','nets.description as description', 'nets.type as type', 'nets.multipoint as multipoint'),
1418 WHERE={'vnfs.uuid': vnf_id} )
1419 data['vnf']['nets'] = content
1420
1421 #GET ip-profile for each net
1422 for net in data['vnf']['nets']:
1423 ipprofiles = mydb.get_rows(FROM='ip_profiles',
1424 SELECT=('ip_version','subnet_address','gateway_address','dns_address','dhcp_enabled','dhcp_start_address','dhcp_count'),
1425 WHERE={'net_id': net["uuid"]} )
1426 if len(ipprofiles)==1:
1427 net["ip_profile"] = ipprofiles[0]
1428 elif len(ipprofiles)>1:
1429 raise NfvoException("More than one ip-profile found with this criteria: net_id='{}'".format(net['uuid']), HTTP_Bad_Request)
1430
1431
1432 #TODO: For each net, GET its elements and relevant info per element (VNFC, iface, ip_address) and include them in the output.
1433
1434 #GET External Interfaces
1435 content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces on vms.uuid=interfaces.vm_id',\
1436 SELECT=('interfaces.uuid as uuid','interfaces.external_name as external_name', 'vms.name as vm_name', 'interfaces.vm_id as vm_id', \
1437 'interfaces.internal_name as internal_name', 'interfaces.type as type', 'interfaces.vpci as vpci','interfaces.bw as bw'),\
1438 WHERE={'vnfs.uuid': vnf_id},
1439 WHERE_NOT={'interfaces.external_name': None} )
1440 #print content
1441 data['vnf']['external-connections'] = content
1442
1443 return data
1444
1445
1446 def delete_vnf(mydb,tenant_id,vnf_id,datacenter=None,vim_tenant=None):
1447 # Check tenant exist
1448 if tenant_id != "any":
1449 check_tenant(mydb, tenant_id)
1450 # Get the URL of the VIM from the nfvo_tenant and the datacenter
1451 vims = get_vim(mydb, tenant_id)
1452 else:
1453 vims={}
1454
1455 # Checking if it is a valid uuid and, if not, getting the uuid assuming that the name was provided"
1456 where_or = {}
1457 if tenant_id != "any":
1458 where_or["tenant_id"] = tenant_id
1459 where_or["public"] = True
1460 vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND")
1461 vnf_id = vnf["uuid"]
1462
1463 # "Getting the list of flavors and tenants of the VNF"
1464 flavorList = get_flavorlist(mydb, vnf_id)
1465 if len(flavorList)==0:
1466 logger.warn("delete_vnf error. No flavors found for the VNF id '%s'", vnf_id)
1467
1468 imageList = get_imagelist(mydb, vnf_id)
1469 if len(imageList)==0:
1470 logger.warn( "delete_vnf error. No images found for the VNF id '%s'", vnf_id)
1471
1472 deleted = mydb.delete_row_by_id('vnfs', vnf_id)
1473 if deleted == 0:
1474 raise NfvoException("vnf '{}' not found".format(vnf_id), HTTP_Not_Found)
1475
1476 undeletedItems = []
1477 for flavor in flavorList:
1478 #check if flavor is used by other vnf
1479 try:
1480 c = mydb.get_rows(FROM='vms', WHERE={'flavor_id':flavor} )
1481 if len(c) > 0:
1482 logger.debug("Flavor '%s' not deleted because it is being used by another VNF", flavor)
1483 continue
1484 #flavor not used, must be deleted
1485 #delelte at VIM
1486 c = mydb.get_rows(FROM='datacenters_flavors', WHERE={'flavor_id':flavor})
1487 for flavor_vim in c:
1488 if flavor_vim["datacenter_vim_id"] not in vims: # TODO change to datacenter_tenant_id
1489 continue
1490 if flavor_vim['created']=='false': #skip this flavor because not created by openmano
1491 continue
1492 myvim=vims[ flavor_vim["datacenter_id"] ]
1493 try:
1494 myvim.delete_flavor(flavor_vim["vim_id"])
1495 except vimconn.vimconnNotFoundException as e:
1496 logger.warn("VIM flavor %s not exist at datacenter %s", flavor_vim["vim_id"], flavor_vim["datacenter_id"] )
1497 except vimconn.vimconnException as e:
1498 logger.error("Not possible to delete VIM flavor %s from datacenter %s: %s %s",
1499 flavor_vim["vim_id"], flavor_vim["datacenter_id"], type(e).__name__, str(e))
1500 undeletedItems.append("flavor {} from VIM {}".format(flavor_vim["vim_id"], flavor_vim["datacenter_id"] ))
1501 #delete flavor from Database, using table flavors and with cascade foreign key also at datacenters_flavors
1502 mydb.delete_row_by_id('flavors', flavor)
1503 except db_base_Exception as e:
1504 logger.error("delete_vnf_error. Not possible to get flavor details and delete '%s'. %s", flavor, str(e))
1505 undeletedItems.append("flavor %s" % flavor)
1506
1507
1508 for image in imageList:
1509 try:
1510 #check if image is used by other vnf
1511 c = mydb.get_rows(FROM='vms', WHERE={'image_id':image} )
1512 if len(c) > 0:
1513 logger.debug("Image '%s' not deleted because it is being used by another VNF", image)
1514 continue
1515 #image not used, must be deleted
1516 #delelte at VIM
1517 c = mydb.get_rows(FROM='datacenters_images', WHERE={'image_id':image})
1518 for image_vim in c:
1519 if image_vim["datacenter_vim_id"] not in vims: # TODO change to datacenter_tenant_id
1520 continue
1521 if image_vim['created']=='false': #skip this image because not created by openmano
1522 continue
1523 myvim=vims[ image_vim["datacenter_id"] ]
1524 try:
1525 myvim.delete_image(image_vim["vim_id"])
1526 except vimconn.vimconnNotFoundException as e:
1527 logger.warn("VIM image %s not exist at datacenter %s", image_vim["vim_id"], image_vim["datacenter_id"] )
1528 except vimconn.vimconnException as e:
1529 logger.error("Not possible to delete VIM image %s from datacenter %s: %s %s",
1530 image_vim["vim_id"], image_vim["datacenter_id"], type(e).__name__, str(e))
1531 undeletedItems.append("image {} from VIM {}".format(image_vim["vim_id"], image_vim["datacenter_id"] ))
1532 #delete image from Database, using table images and with cascade foreign key also at datacenters_images
1533 mydb.delete_row_by_id('images', image)
1534 except db_base_Exception as e:
1535 logger.error("delete_vnf_error. Not possible to get image details and delete '%s'. %s", image, str(e))
1536 undeletedItems.append("image %s" % image)
1537
1538 return vnf_id + " " + vnf["name"]
1539 #if undeletedItems:
1540 # return "delete_vnf. Undeleted: %s" %(undeletedItems)
1541
1542
1543 def get_hosts_info(mydb, nfvo_tenant_id, datacenter_name=None):
1544 result, vims = get_vim(mydb, nfvo_tenant_id, None, datacenter_name)
1545 if result < 0:
1546 return result, vims
1547 elif result == 0:
1548 return -HTTP_Not_Found, "datacenter '%s' not found" % datacenter_name
1549 myvim = vims.values()[0]
1550 result,servers = myvim.get_hosts_info()
1551 if result < 0:
1552 return result, servers
1553 topology = {'name':myvim['name'] , 'servers': servers}
1554 return result, topology
1555
1556
1557 def get_hosts(mydb, nfvo_tenant_id):
1558 vims = get_vim(mydb, nfvo_tenant_id)
1559 if len(vims) == 0:
1560 raise NfvoException("No datacenter found for tenant '{}'".format(str(nfvo_tenant_id)), HTTP_Not_Found)
1561 elif len(vims)>1:
1562 #print "nfvo.datacenter_action() error. Several datacenters found"
1563 raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
1564 myvim = vims.values()[0]
1565 try:
1566 hosts = myvim.get_hosts()
1567 logger.debug('VIM hosts response: '+ yaml.safe_dump(hosts, indent=4, default_flow_style=False))
1568
1569 datacenter = {'Datacenters': [ {'name':myvim['name'],'servers':[]} ] }
1570 for host in hosts:
1571 server={'name':host['name'], 'vms':[]}
1572 for vm in host['instances']:
1573 #get internal name and model
1574 try:
1575 c = mydb.get_rows(SELECT=('name',), FROM='instance_vms as iv join vms on iv.vm_id=vms.uuid',\
1576 WHERE={'vim_vm_id':vm['id']} )
1577 if len(c) == 0:
1578 logger.warn("nfvo.get_hosts virtual machine at VIM '{}' not found at tidnfvo".format(vm['id']))
1579 continue
1580 server['vms'].append( {'name':vm['name'] , 'model':c[0]['name']} )
1581
1582 except db_base_Exception as e:
1583 logger.warn("nfvo.get_hosts virtual machine at VIM '{}' error {}".format(vm['id'], str(e)))
1584 datacenter['Datacenters'][0]['servers'].append(server)
1585 #return -400, "en construccion"
1586
1587 #print 'datacenters '+ json.dumps(datacenter, indent=4)
1588 return datacenter
1589 except vimconn.vimconnException as e:
1590 raise NfvoException("Not possible to get_host_list from VIM: {}".format(str(e)), e.http_code)
1591
1592
1593 def new_scenario(mydb, tenant_id, topo):
1594
1595 # result, vims = get_vim(mydb, tenant_id)
1596 # if result < 0:
1597 # return result, vims
1598 #1: parse input
1599 if tenant_id != "any":
1600 check_tenant(mydb, tenant_id)
1601 if "tenant_id" in topo:
1602 if topo["tenant_id"] != tenant_id:
1603 raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(topo["tenant_id"], tenant_id),
1604 HTTP_Unauthorized)
1605 else:
1606 tenant_id=None
1607
1608 #1.1: get VNFs and external_networks (other_nets).
1609 vnfs={}
1610 other_nets={} #external_networks, bridge_networks and data_networkds
1611 nodes = topo['topology']['nodes']
1612 for k in nodes.keys():
1613 if nodes[k]['type'] == 'VNF':
1614 vnfs[k] = nodes[k]
1615 vnfs[k]['ifaces'] = {}
1616 elif nodes[k]['type'] == 'other_network' or nodes[k]['type'] == 'external_network':
1617 other_nets[k] = nodes[k]
1618 other_nets[k]['external']=True
1619 elif nodes[k]['type'] == 'network':
1620 other_nets[k] = nodes[k]
1621 other_nets[k]['external']=False
1622
1623
1624 #1.2: Check that VNF are present at database table vnfs. Insert uuid, description and external interfaces
1625 for name,vnf in vnfs.items():
1626 where={}
1627 where_or={"tenant_id": tenant_id, 'public': "true"}
1628 error_text = ""
1629 error_pos = "'topology':'nodes':'" + name + "'"
1630 if 'vnf_id' in vnf:
1631 error_text += " 'vnf_id' " + vnf['vnf_id']
1632 where['uuid'] = vnf['vnf_id']
1633 if 'VNF model' in vnf:
1634 error_text += " 'VNF model' " + vnf['VNF model']
1635 where['name'] = vnf['VNF model']
1636 if len(where) == 0:
1637 raise NfvoException("Descriptor need a 'vnf_id' or 'VNF model' field at " + error_pos, HTTP_Bad_Request)
1638
1639 vnf_db = mydb.get_rows(SELECT=('uuid','name','description'),
1640 FROM='vnfs',
1641 WHERE=where,
1642 WHERE_OR=where_or,
1643 WHERE_AND_OR="AND")
1644 if len(vnf_db)==0:
1645 raise NfvoException("unknown" + error_text + " at " + error_pos, HTTP_Not_Found)
1646 elif len(vnf_db)>1:
1647 raise NfvoException("more than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", HTTP_Conflict)
1648 vnf['uuid']=vnf_db[0]['uuid']
1649 vnf['description']=vnf_db[0]['description']
1650 #get external interfaces
1651 ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'),
1652 FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
1653 WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name':None} )
1654 for ext_iface in ext_ifaces:
1655 vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']}
1656
1657 #1.4 get list of connections
1658 conections = topo['topology']['connections']
1659 conections_list = []
1660 conections_list_name = []
1661 for k in conections.keys():
1662 if type(conections[k]['nodes'])==dict: #dict with node:iface pairs
1663 ifaces_list = conections[k]['nodes'].items()
1664 elif type(conections[k]['nodes'])==list: #list with dictionary
1665 ifaces_list=[]
1666 conection_pair_list = map(lambda x: x.items(), conections[k]['nodes'] )
1667 for k2 in conection_pair_list:
1668 ifaces_list += k2
1669
1670 con_type = conections[k].get("type", "link")
1671 if con_type != "link":
1672 if k in other_nets:
1673 raise NfvoException("Format error. Reapeted network name at 'topology':'connections':'{}'".format(str(k)), HTTP_Bad_Request)
1674 other_nets[k] = {'external': False}
1675 if conections[k].get("graph"):
1676 other_nets[k]["graph"] = conections[k]["graph"]
1677 ifaces_list.append( (k, None) )
1678
1679
1680 if con_type == "external_network":
1681 other_nets[k]['external'] = True
1682 if conections[k].get("model"):
1683 other_nets[k]["model"] = conections[k]["model"]
1684 else:
1685 other_nets[k]["model"] = k
1686 if con_type == "dataplane_net" or con_type == "bridge_net":
1687 other_nets[k]["model"] = con_type
1688
1689 conections_list_name.append(k)
1690 conections_list.append(set(ifaces_list)) #from list to set to operate as a set (this conversion removes elements that are repeated in a list)
1691 #print set(ifaces_list)
1692 #check valid VNF and iface names
1693 for iface in ifaces_list:
1694 if iface[0] not in vnfs and iface[0] not in other_nets :
1695 raise NfvoException("format error. Invalid VNF name at 'topology':'connections':'{}':'nodes':'{}'".format(
1696 str(k), iface[0]), HTTP_Not_Found)
1697 if iface[0] in vnfs and iface[1] not in vnfs[ iface[0] ]['ifaces']:
1698 raise NfvoException("format error. Invalid interface name at 'topology':'connections':'{}':'nodes':'{}':'{}'".format(
1699 str(k), iface[0], iface[1]), HTTP_Not_Found)
1700
1701 #1.5 unify connections from the pair list to a consolidated list
1702 index=0
1703 while index < len(conections_list):
1704 index2 = index+1
1705 while index2 < len(conections_list):
1706 if len(conections_list[index] & conections_list[index2])>0: #common interface, join nets
1707 conections_list[index] |= conections_list[index2]
1708 del conections_list[index2]
1709 del conections_list_name[index2]
1710 else:
1711 index2 += 1
1712 conections_list[index] = list(conections_list[index]) # from set to list again
1713 index += 1
1714 #for k in conections_list:
1715 # print k
1716
1717
1718
1719 #1.6 Delete non external nets
1720 # for k in other_nets.keys():
1721 # if other_nets[k]['model']=='bridge' or other_nets[k]['model']=='dataplane_net' or other_nets[k]['model']=='bridge_net':
1722 # for con in conections_list:
1723 # delete_indexes=[]
1724 # for index in range(0,len(con)):
1725 # if con[index][0] == k: delete_indexes.insert(0,index) #order from higher to lower
1726 # for index in delete_indexes:
1727 # del con[index]
1728 # del other_nets[k]
1729 #1.7: Check external_ports are present at database table datacenter_nets
1730 for k,net in other_nets.items():
1731 error_pos = "'topology':'nodes':'" + k + "'"
1732 if net['external']==False:
1733 if 'name' not in net:
1734 net['name']=k
1735 if 'model' not in net:
1736 raise NfvoException("needed a 'model' at " + error_pos, HTTP_Bad_Request)
1737 if net['model']=='bridge_net':
1738 net['type']='bridge';
1739 elif net['model']=='dataplane_net':
1740 net['type']='data';
1741 else:
1742 raise NfvoException("unknown 'model' '"+ net['model'] +"' at " + error_pos, HTTP_Not_Found)
1743 else: #external
1744 #IF we do not want to check that external network exist at datacenter
1745 pass
1746 #ELSE
1747 # error_text = ""
1748 # WHERE_={}
1749 # if 'net_id' in net:
1750 # error_text += " 'net_id' " + net['net_id']
1751 # WHERE_['uuid'] = net['net_id']
1752 # if 'model' in net:
1753 # error_text += " 'model' " + net['model']
1754 # WHERE_['name'] = net['model']
1755 # if len(WHERE_) == 0:
1756 # return -HTTP_Bad_Request, "needed a 'net_id' or 'model' at " + error_pos
1757 # r,net_db = mydb.get_table(SELECT=('uuid','name','description','type','shared'),
1758 # FROM='datacenter_nets', WHERE=WHERE_ )
1759 # if r<0:
1760 # print "nfvo.new_scenario Error getting datacenter_nets",r,net_db
1761 # elif r==0:
1762 # print "nfvo.new_scenario Error" +error_text+ " is not present at database"
1763 # return -HTTP_Bad_Request, "unknown " +error_text+ " at " + error_pos
1764 # elif r>1:
1765 # print "nfvo.new_scenario Error more than one external_network for " +error_text+ " is present at database"
1766 # return -HTTP_Bad_Request, "more than one external_network for " +error_text+ "at "+ error_pos + " Concrete with 'net_id'"
1767 # other_nets[k].update(net_db[0])
1768 #ENDIF
1769 net_list={}
1770 net_nb=0 #Number of nets
1771 for con in conections_list:
1772 #check if this is connected to a external net
1773 other_net_index=-1
1774 #print
1775 #print "con", con
1776 for index in range(0,len(con)):
1777 #check if this is connected to a external net
1778 for net_key in other_nets.keys():
1779 if con[index][0]==net_key:
1780 if other_net_index>=0:
1781 error_text="There is some interface connected both to net '%s' and net '%s'" % (con[other_net_index][0], net_key)
1782 #print "nfvo.new_scenario " + error_text
1783 raise NfvoException(error_text, HTTP_Bad_Request)
1784 else:
1785 other_net_index = index
1786 net_target = net_key
1787 break
1788 #print "other_net_index", other_net_index
1789 try:
1790 if other_net_index>=0:
1791 del con[other_net_index]
1792 #IF we do not want to check that external network exist at datacenter
1793 if other_nets[net_target]['external'] :
1794 if "name" not in other_nets[net_target]:
1795 other_nets[net_target]['name'] = other_nets[net_target]['model']
1796 if other_nets[net_target]["type"] == "external_network":
1797 if vnfs[ con[0][0] ]['ifaces'][ con[0][1] ]["type"] == "data":
1798 other_nets[net_target]["type"] = "data"
1799 else:
1800 other_nets[net_target]["type"] = "bridge"
1801 #ELSE
1802 # if other_nets[net_target]['external'] :
1803 # type_='data' if len(con)>1 else 'ptp' #an external net is connected to a external port, so it is ptp if only one connection is done to this net
1804 # if type_=='data' and other_nets[net_target]['type']=="ptp":
1805 # error_text = "Error connecting %d nodes on a not multipoint net %s" % (len(con), net_target)
1806 # print "nfvo.new_scenario " + error_text
1807 # return -HTTP_Bad_Request, error_text
1808 #ENDIF
1809 for iface in con:
1810 vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target
1811 else:
1812 #create a net
1813 net_type_bridge=False
1814 net_type_data=False
1815 net_target = "__-__net"+str(net_nb)
1816 net_list[net_target] = {'name': conections_list_name[net_nb], #"net-"+str(net_nb),
1817 'description':"net-%s in scenario %s" %(net_nb,topo['name']),
1818 'external':False}
1819 for iface in con:
1820 vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target
1821 iface_type = vnfs[ iface[0] ]['ifaces'][ iface[1] ]['type']
1822 if iface_type=='mgmt' or iface_type=='bridge':
1823 net_type_bridge = True
1824 else:
1825 net_type_data = True
1826 if net_type_bridge and net_type_data:
1827 error_text = "Error connection interfaces of bridge type with data type. Firs node %s, iface %s" % (iface[0], iface[1])
1828 #print "nfvo.new_scenario " + error_text
1829 raise NfvoException(error_text, HTTP_Bad_Request)
1830 elif net_type_bridge:
1831 type_='bridge'
1832 else:
1833 type_='data' if len(con)>2 else 'ptp'
1834 net_list[net_target]['type'] = type_
1835 net_nb+=1
1836 except Exception:
1837 error_text = "Error connection node %s : %s does not match any VNF or interface" % (iface[0], iface[1])
1838 #print "nfvo.new_scenario " + error_text
1839 #raise e
1840 raise NfvoException(error_text, HTTP_Bad_Request)
1841
1842 #1.8: Connect to management net all not already connected interfaces of type 'mgmt'
1843 #1.8.1 obtain management net
1844 mgmt_net = mydb.get_rows(SELECT=('uuid','name','description','type','shared'),
1845 FROM='datacenter_nets', WHERE={'name':'mgmt'} )
1846 #1.8.2 check all interfaces from all vnfs
1847 if len(mgmt_net)>0:
1848 add_mgmt_net = False
1849 for vnf in vnfs.values():
1850 for iface in vnf['ifaces'].values():
1851 if iface['type']=='mgmt' and 'net_key' not in iface:
1852 #iface not connected
1853 iface['net_key'] = 'mgmt'
1854 add_mgmt_net = True
1855 if add_mgmt_net and 'mgmt' not in net_list:
1856 net_list['mgmt']=mgmt_net[0]
1857 net_list['mgmt']['external']=True
1858 net_list['mgmt']['graph']={'visible':False}
1859
1860 net_list.update(other_nets)
1861 #print
1862 #print 'net_list', net_list
1863 #print
1864 #print 'vnfs', vnfs
1865 #print
1866
1867 #2: insert scenario. filling tables scenarios,sce_vnfs,sce_interfaces,sce_nets
1868 c = mydb.new_scenario( { 'vnfs':vnfs, 'nets':net_list,
1869 'tenant_id':tenant_id, 'name':topo['name'],
1870 'description':topo.get('description',topo['name']),
1871 'public': topo.get('public', False)
1872 })
1873
1874 return c
1875
1876
1877 def new_scenario_v02(mydb, tenant_id, scenario_dict, version):
1878 """ This creates a new scenario for version 0.2 and 0.3"""
1879 scenario = scenario_dict["scenario"]
1880 if tenant_id != "any":
1881 check_tenant(mydb, tenant_id)
1882 if "tenant_id" in scenario:
1883 if scenario["tenant_id"] != tenant_id:
1884 # print "nfvo.new_scenario_v02() tenant '%s' not found" % tenant_id
1885 raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(
1886 scenario["tenant_id"], tenant_id), HTTP_Unauthorized)
1887 else:
1888 tenant_id=None
1889
1890 # 1: Check that VNF are present at database table vnfs and update content into scenario dict
1891 for name,vnf in scenario["vnfs"].iteritems():
1892 where={}
1893 where_or={"tenant_id": tenant_id, 'public': "true"}
1894 error_text = ""
1895 error_pos = "'scenario':'vnfs':'" + name + "'"
1896 if 'vnf_id' in vnf:
1897 error_text += " 'vnf_id' " + vnf['vnf_id']
1898 where['uuid'] = vnf['vnf_id']
1899 if 'vnf_name' in vnf:
1900 error_text += " 'vnf_name' " + vnf['vnf_name']
1901 where['name'] = vnf['vnf_name']
1902 if len(where) == 0:
1903 raise NfvoException("Needed a 'vnf_id' or 'vnf_name' at " + error_pos, HTTP_Bad_Request)
1904 vnf_db = mydb.get_rows(SELECT=('uuid', 'name', 'description'),
1905 FROM='vnfs',
1906 WHERE=where,
1907 WHERE_OR=where_or,
1908 WHERE_AND_OR="AND")
1909 if len(vnf_db) == 0:
1910 raise NfvoException("Unknown" + error_text + " at " + error_pos, HTTP_Not_Found)
1911 elif len(vnf_db) > 1:
1912 raise NfvoException("More than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", HTTP_Conflict)
1913 vnf['uuid'] = vnf_db[0]['uuid']
1914 vnf['description'] = vnf_db[0]['description']
1915 vnf['ifaces'] = {}
1916 # get external interfaces
1917 ext_ifaces = mydb.get_rows(SELECT=('external_name as name', 'i.uuid as iface_uuid', 'i.type as type'),
1918 FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
1919 WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name': None} )
1920 for ext_iface in ext_ifaces:
1921 vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type': ext_iface['type']}
1922 # TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly
1923
1924 # 2: Insert net_key and ip_address at every vnf interface
1925 for net_name, net in scenario["networks"].items():
1926 net_type_bridge = False
1927 net_type_data = False
1928 for iface_dict in net["interfaces"]:
1929 if version == "0.2":
1930 temp_dict = iface_dict
1931 ip_address = None
1932 elif version == "0.3":
1933 temp_dict = {iface_dict["vnf"] : iface_dict["vnf_interface"]}
1934 ip_address = iface_dict.get('ip_address', None)
1935 for vnf, iface in temp_dict.items():
1936 if vnf not in scenario["vnfs"]:
1937 error_text = "Error at 'networks':'{}':'interfaces' VNF '{}' not match any VNF at 'vnfs'".format(
1938 net_name, vnf)
1939 # logger.debug("nfvo.new_scenario_v02 " + error_text)
1940 raise NfvoException(error_text, HTTP_Not_Found)
1941 if iface not in scenario["vnfs"][vnf]['ifaces']:
1942 error_text = "Error at 'networks':'{}':'interfaces':'{}' interface not match any VNF interface"\
1943 .format(net_name, iface)
1944 # logger.debug("nfvo.new_scenario_v02 " + error_text)
1945 raise NfvoException(error_text, HTTP_Bad_Request)
1946 if "net_key" in scenario["vnfs"][vnf]['ifaces'][iface]:
1947 error_text = "Error at 'networks':'{}':'interfaces':'{}' interface already connected at network"\
1948 "'{}'".format(net_name, iface,scenario["vnfs"][vnf]['ifaces'][iface]['net_key'])
1949 # logger.debug("nfvo.new_scenario_v02 " + error_text)
1950 raise NfvoException(error_text, HTTP_Bad_Request)
1951 scenario["vnfs"][vnf]['ifaces'][ iface ]['net_key'] = net_name
1952 scenario["vnfs"][vnf]['ifaces'][iface]['ip_address'] = ip_address
1953 iface_type = scenario["vnfs"][vnf]['ifaces'][iface]['type']
1954 if iface_type == 'mgmt' or iface_type == 'bridge':
1955 net_type_bridge = True
1956 else:
1957 net_type_data = True
1958
1959 if net_type_bridge and net_type_data:
1960 error_text = "Error connection interfaces of 'bridge' type and 'data' type at 'networks':'{}':'interfaces'"\
1961 .format(net_name)
1962 # logger.debug("nfvo.new_scenario " + error_text)
1963 raise NfvoException(error_text, HTTP_Bad_Request)
1964 elif net_type_bridge:
1965 type_ = 'bridge'
1966 else:
1967 type_ = 'data' if len(net["interfaces"]) > 2 else 'ptp'
1968
1969 if net.get("implementation"): # for v0.3
1970 if type_ == "bridge" and net["implementation"] == "underlay":
1971 error_text = "Error connecting interfaces of data type to a network declared as 'underlay' at "\
1972 "'network':'{}'".format(net_name)
1973 # logger.debug(error_text)
1974 raise NfvoException(error_text, HTTP_Bad_Request)
1975 elif type_ != "bridge" and net["implementation"] == "overlay":
1976 error_text = "Error connecting interfaces of data type to a network declared as 'overlay' at "\
1977 "'network':'{}'".format(net_name)
1978 # logger.debug(error_text)
1979 raise NfvoException(error_text, HTTP_Bad_Request)
1980 net.pop("implementation")
1981 if "type" in net and version == "0.3": # for v0.3
1982 if type_ == "data" and net["type"] == "e-line":
1983 error_text = "Error connecting more than 2 interfaces of data type to a network declared as type "\
1984 "'e-line' at 'network':'{}'".format(net_name)
1985 # logger.debug(error_text)
1986 raise NfvoException(error_text, HTTP_Bad_Request)
1987 elif type_ == "ptp" and net["type"] == "e-lan":
1988 type_ = "data"
1989
1990 net['type'] = type_
1991 net['name'] = net_name
1992 net['external'] = net.get('external', False)
1993
1994 # 3: insert at database
1995 scenario["nets"] = scenario["networks"]
1996 scenario['tenant_id'] = tenant_id
1997 scenario_id = mydb.new_scenario(scenario)
1998 return scenario_id
1999
2000
2001 def new_nsd_v3(mydb, tenant_id, nsd_descriptor):
2002 """
2003 Parses an OSM IM nsd_catalog and insert at DB
2004 :param mydb:
2005 :param tenant_id:
2006 :param nsd_descriptor:
2007 :return: The list of cretated NSD ids
2008 """
2009 try:
2010 mynsd = nsd_catalog.nsd()
2011 try:
2012 pybindJSONDecoder.load_ietf_json(nsd_descriptor, None, None, obj=mynsd)
2013 except Exception as e:
2014 raise NfvoException("Invalid yang descriptor format " + str(e), HTTP_Bad_Request)
2015 db_scenarios = []
2016 db_sce_nets = []
2017 db_sce_vnfs = []
2018 db_sce_interfaces = []
2019 db_ip_profiles = []
2020 db_ip_profiles_index = 0
2021 uuid_list = []
2022 nsd_uuid_list = []
2023 for rift_nsd in mynsd.nsd_catalog.nsd.itervalues():
2024 nsd = rift_nsd.get()
2025
2026 # table sceanrios
2027 scenario_uuid = str(uuid4())
2028 uuid_list.append(scenario_uuid)
2029 nsd_uuid_list.append(scenario_uuid)
2030 db_scenario = {
2031 "uuid": scenario_uuid,
2032 "osm_id": get_str(nsd, "id", 255),
2033 "name": get_str(nsd, "name", 255),
2034 "description": get_str(nsd, "description", 255),
2035 "tenant_id": tenant_id,
2036 "vendor": get_str(nsd, "vendor", 255),
2037 "short_name": get_str(nsd, "short-name", 255),
2038 "descriptor": str(nsd_descriptor)[:60000],
2039 }
2040 db_scenarios.append(db_scenario)
2041
2042 # table sce_vnfs (constituent-vnfd)
2043 vnf_index2scevnf_uuid = {}
2044 vnf_index2vnf_uuid = {}
2045 for vnf in nsd.get("constituent-vnfd").itervalues():
2046 existing_vnf = mydb.get_rows(FROM="vnfs", WHERE={'osm_id': str(vnf["vnfd-id-ref"])[:255],
2047 'tenant_id': tenant_id})
2048 if not existing_vnf:
2049 raise KeyError("Error at 'nsd[{}]':'constituent-vnfd':'vnfd-id-ref':'{}' references a "
2050 "non existing VNFD in the catalog".format(str(nsd["id"]),
2051 str(vnf["vnfd-id-ref"])[:255]))
2052 sce_vnf_uuid = str(uuid4())
2053 uuid_list.append(sce_vnf_uuid)
2054 db_sce_vnf = {
2055 "uuid": sce_vnf_uuid,
2056 "scenario_id": scenario_uuid,
2057 "name": existing_vnf[0]["name"][:200] + "." + get_str(vnf, "member-vnf-index", 5),
2058 "vnf_id": existing_vnf[0]["uuid"],
2059 "member_vnf_index": int(vnf["member-vnf-index"]),
2060 # TODO 'start-by-default': True
2061 }
2062 vnf_index2scevnf_uuid[int(vnf['member-vnf-index'])] = sce_vnf_uuid
2063 vnf_index2vnf_uuid[int(vnf['member-vnf-index'])] = existing_vnf[0]["uuid"]
2064 db_sce_vnfs.append(db_sce_vnf)
2065
2066 # table ip_profiles (ip-profiles)
2067 ip_profile_name2db_table_index = {}
2068 for ip_profile in nsd.get("ip-profiles").itervalues():
2069 db_ip_profile = {
2070 "ip_version": str(ip_profile["ip-profile-params"].get("ip-version", "ipv4")),
2071 "subnet_address": str(ip_profile["ip-profile-params"].get("subnet-address")),
2072 "gateway_address": str(ip_profile["ip-profile-params"].get("gateway-address")),
2073 "dhcp_enabled": str(ip_profile["ip-profile-params"]["dhcp-params"].get("enabled", True)),
2074 "dhcp_start_address": str(ip_profile["ip-profile-params"]["dhcp-params"].get("start-address")),
2075 "dhcp_count": str(ip_profile["ip-profile-params"]["dhcp-params"].get("count")),
2076 }
2077 dns_list = []
2078 for dns in ip_profile["ip-profile-params"]["dns-server"].itervalues():
2079 dns_list.append(str(dns.get("address")))
2080 db_ip_profile["dns_address"] = ";".join(dns_list)
2081 if ip_profile["ip-profile-params"].get('security-group'):
2082 db_ip_profile["security_group"] = ip_profile["ip-profile-params"]['security-group']
2083 ip_profile_name2db_table_index[str(ip_profile["name"])] = db_ip_profiles_index
2084 db_ip_profiles_index += 1
2085 db_ip_profiles.append(db_ip_profile)
2086
2087 # table sce_nets (internal-vld)
2088 for vld in nsd.get("vld").itervalues():
2089 sce_net_uuid = str(uuid4())
2090 uuid_list.append(sce_net_uuid)
2091 db_sce_net = {
2092 "uuid": sce_net_uuid,
2093 "name": get_str(vld, "name", 255),
2094 "scenario_id": scenario_uuid,
2095 # "type": #TODO
2096 "multipoint": not vld.get("type") == "ELINE",
2097 # "external": #TODO
2098 "description": get_str(vld, "description", 255),
2099 }
2100 # guess type of network
2101 if vld.get("mgmt-network"):
2102 db_sce_net["type"] = "bridge"
2103 db_sce_net["external"] = True
2104 elif vld.get("provider-network").get("overlay-type") == "VLAN":
2105 db_sce_net["type"] = "data"
2106 else:
2107 db_sce_net["type"] = "bridge"
2108 db_sce_nets.append(db_sce_net)
2109
2110 # ip-profile, link db_ip_profile with db_sce_net
2111 if vld.get("ip-profile-ref"):
2112 ip_profile_name = vld.get("ip-profile-ref")
2113 if ip_profile_name not in ip_profile_name2db_table_index:
2114 raise KeyError("Error at 'nsd[{}]':'vld[{}]':'ip-profile-ref':'{}' references a non existing "
2115 "'ip_profiles'".format(
2116 str(nsd["id"]), str(vld["id"]), str(vld["ip-profile-ref"])))
2117 db_ip_profiles[ip_profile_name2db_table_index[ip_profile_name]]["sce_net_id"] = sce_net_uuid
2118
2119 # table sce_interfaces (vld:vnfd-connection-point-ref)
2120 for iface in vld.get("vnfd-connection-point-ref").itervalues():
2121 vnf_index = int(iface['member-vnf-index-ref'])
2122 # check correct parameters
2123 if vnf_index not in vnf_index2vnf_uuid:
2124 raise KeyError("Error at 'nsd[{}]':'vld[{}]':'vnfd-connection-point-ref':'member-vnf-index-ref'"
2125 ":'{}' references a non existing index at 'nsd':'constituent-vnfd'".format(
2126 str(nsd["id"]), str(vld["id"]), str(iface["member-vnf-index-ref"])))
2127
2128 existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid',),
2129 FROM="interfaces as i join vms on i.vm_id=vms.uuid",
2130 WHERE={'vnf_id': vnf_index2vnf_uuid[vnf_index],
2131 'external_name': get_str(iface, "vnfd-connection-point-ref",
2132 255)})
2133 if not existing_ifaces:
2134 raise KeyError("Error at 'nsd[{}]':'vld[{}]':'vnfd-connection-point-ref':'vnfd-connection-point"
2135 "-ref':'{}' references a non existing interface at VNFD '{}'".format(
2136 str(nsd["id"]), str(vld["id"]), str(iface["vnfd-connection-point-ref"]),
2137 str(iface.get("vnfd-id-ref"))[:255]))
2138
2139 interface_uuid = existing_ifaces[0]["uuid"]
2140 sce_interface_uuid = str(uuid4())
2141 uuid_list.append(sce_net_uuid)
2142 db_sce_interface = {
2143 "uuid": sce_interface_uuid,
2144 "sce_vnf_id": vnf_index2scevnf_uuid[vnf_index],
2145 "sce_net_id": sce_net_uuid,
2146 "interface_id": interface_uuid,
2147 # "ip_address": #TODO
2148 }
2149 db_sce_interfaces.append(db_sce_interface)
2150
2151 db_tables = [
2152 {"scenarios": db_scenarios},
2153 {"sce_nets": db_sce_nets},
2154 {"ip_profiles": db_ip_profiles},
2155 {"sce_vnfs": db_sce_vnfs},
2156 {"sce_interfaces": db_sce_interfaces},
2157 ]
2158
2159 logger.debug("create_vnf Deployment done vnfDict: %s",
2160 yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
2161 mydb.new_rows(db_tables, uuid_list)
2162 return nsd_uuid_list
2163 except Exception as e:
2164 logger.error("Exception {}".format(e))
2165 raise # NfvoException("Exception {}".format(e), HTTP_Bad_Request)
2166
2167
2168 def edit_scenario(mydb, tenant_id, scenario_id, data):
2169 data["uuid"] = scenario_id
2170 data["tenant_id"] = tenant_id
2171 c = mydb.edit_scenario( data )
2172 return c
2173
2174
2175 def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instance_scenario_description, datacenter=None,vim_tenant=None, startvms=True):
2176 #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
2177 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter, vim_tenant=vim_tenant)
2178 vims = {datacenter_id: myvim}
2179 myvim_tenant = myvim['tenant_id']
2180 datacenter_name = myvim['name']
2181
2182 rollbackList=[]
2183 try:
2184 #print "Checking that the scenario_id exists and getting the scenario dictionary"
2185 scenarioDict = mydb.get_scenario(scenario_id, tenant_id, datacenter_id=datacenter_id)
2186 scenarioDict['datacenter2tenant'] = { datacenter_id: myvim['config']['datacenter_tenant_id'] }
2187 scenarioDict['datacenter_id'] = datacenter_id
2188 #print '================scenarioDict======================='
2189 #print json.dumps(scenarioDict, indent=4)
2190 #print 'BEGIN launching instance scenario "%s" based on "%s"' % (instance_scenario_name,scenarioDict['name'])
2191
2192 logger.debug("start_scenario Scenario %s: consisting of %d VNF(s)", scenarioDict['name'],len(scenarioDict['vnfs']))
2193 #print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)
2194
2195 auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id
2196 auxNetDict['scenario'] = {}
2197
2198 logger.debug("start_scenario 1. Creating new nets (sce_nets) in the VIM")
2199 for sce_net in scenarioDict['nets']:
2200 #print "Net name: %s. Description: %s" % (sce_net["name"], sce_net["description"])
2201
2202 myNetName = "%s.%s" % (instance_scenario_name, sce_net['name'])
2203 myNetName = myNetName[0:255] #limit length
2204 myNetType = sce_net['type']
2205 myNetDict = {}
2206 myNetDict["name"] = myNetName
2207 myNetDict["type"] = myNetType
2208 myNetDict["tenant_id"] = myvim_tenant
2209 myNetIPProfile = sce_net.get('ip_profile', None)
2210 #TODO:
2211 #We should use the dictionary as input parameter for new_network
2212 #print myNetDict
2213 if not sce_net["external"]:
2214 network_id = myvim.new_network(myNetName, myNetType, myNetIPProfile)
2215 #print "New VIM network created for scenario %s. Network id: %s" % (scenarioDict['name'],network_id)
2216 sce_net['vim_id'] = network_id
2217 auxNetDict['scenario'][sce_net['uuid']] = network_id
2218 rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id})
2219 sce_net["created"] = True
2220 else:
2221 if sce_net['vim_id'] == None:
2222 error_text = "Error, datacenter '%s' does not have external network '%s'." % (datacenter_name, sce_net['name'])
2223 _, message = rollback(mydb, vims, rollbackList)
2224 logger.error("nfvo.start_scenario: %s", error_text)
2225 raise NfvoException(error_text, HTTP_Bad_Request)
2226 logger.debug("Using existent VIM network for scenario %s. Network id %s", scenarioDict['name'],sce_net['vim_id'])
2227 auxNetDict['scenario'][sce_net['uuid']] = sce_net['vim_id']
2228
2229 logger.debug("start_scenario 2. Creating new nets (vnf internal nets) in the VIM")
2230 #For each vnf net, we create it and we add it to instanceNetlist.
2231
2232 for sce_vnf in scenarioDict['vnfs']:
2233 for net in sce_vnf['nets']:
2234 #print "Net name: %s. Description: %s" % (net["name"], net["description"])
2235
2236 myNetName = "%s.%s" % (instance_scenario_name,net['name'])
2237 myNetName = myNetName[0:255] #limit length
2238 myNetType = net['type']
2239 myNetDict = {}
2240 myNetDict["name"] = myNetName
2241 myNetDict["type"] = myNetType
2242 myNetDict["tenant_id"] = myvim_tenant
2243 myNetIPProfile = net.get('ip_profile', None)
2244 #print myNetDict
2245 #TODO:
2246 #We should use the dictionary as input parameter for new_network
2247 network_id = myvim.new_network(myNetName, myNetType, myNetIPProfile)
2248 #print "VIM network id for scenario %s: %s" % (scenarioDict['name'],network_id)
2249 net['vim_id'] = network_id
2250 if sce_vnf['uuid'] not in auxNetDict:
2251 auxNetDict[sce_vnf['uuid']] = {}
2252 auxNetDict[sce_vnf['uuid']][net['uuid']] = network_id
2253 rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id})
2254 net["created"] = True
2255
2256 #print "auxNetDict:"
2257 #print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False)
2258
2259 logger.debug("start_scenario 3. Creating new vm instances in the VIM")
2260 #myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
2261 i = 0
2262 for sce_vnf in scenarioDict['vnfs']:
2263 vnf_availability_zones = []
2264 for vm in sce_vnf['vms']:
2265 vm_av = vm.get('availability_zone')
2266 if vm_av and vm_av not in vnf_availability_zones:
2267 vnf_availability_zones.append(vm_av)
2268
2269 # check if there is enough availability zones available at vim level.
2270 if myvims[datacenter_id].availability_zone and vnf_availability_zones:
2271 if len(vnf_availability_zones) > len(myvims[datacenter_id].availability_zone):
2272 raise NfvoException('No enough availability zones at VIM for this deployment', HTTP_Bad_Request)
2273
2274 for vm in sce_vnf['vms']:
2275 i += 1
2276 myVMDict = {}
2277 #myVMDict['name'] = "%s-%s-%s" % (scenarioDict['name'],sce_vnf['name'], vm['name'])
2278 myVMDict['name'] = "{}.{}.{}".format(instance_scenario_name,sce_vnf['name'],chr(96+i))
2279 #myVMDict['description'] = vm['description']
2280 myVMDict['description'] = myVMDict['name'][0:99]
2281 if not startvms:
2282 myVMDict['start'] = "no"
2283 myVMDict['name'] = myVMDict['name'][0:255] #limit name length
2284 #print "VM name: %s. Description: %s" % (myVMDict['name'], myVMDict['name'])
2285
2286 #create image at vim in case it not exist
2287 image_dict = mydb.get_table_by_uuid_name("images", vm['image_id'])
2288 image_id = create_or_use_image(mydb, vims, image_dict, [], True)
2289 vm['vim_image_id'] = image_id
2290
2291 #create flavor at vim in case it not exist
2292 flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id'])
2293 if flavor_dict['extended']!=None:
2294 flavor_dict['extended']= yaml.load(flavor_dict['extended'])
2295 flavor_id = create_or_use_flavor(mydb, vims, flavor_dict, [], True)
2296 vm['vim_flavor_id'] = flavor_id
2297
2298
2299 myVMDict['imageRef'] = vm['vim_image_id']
2300 myVMDict['flavorRef'] = vm['vim_flavor_id']
2301 myVMDict['networks'] = []
2302 for iface in vm['interfaces']:
2303 netDict = {}
2304 if iface['type']=="data":
2305 netDict['type'] = iface['model']
2306 elif "model" in iface and iface["model"]!=None:
2307 netDict['model']=iface['model']
2308 #TODO in future, remove this because mac_address will not be set, and the type of PV,VF is obtained from iterface table model
2309 #discover type of interface looking at flavor
2310 for numa in flavor_dict.get('extended',{}).get('numas',[]):
2311 for flavor_iface in numa.get('interfaces',[]):
2312 if flavor_iface.get('name') == iface['internal_name']:
2313 if flavor_iface['dedicated'] == 'yes':
2314 netDict['type']="PF" #passthrough
2315 elif flavor_iface['dedicated'] == 'no':
2316 netDict['type']="VF" #siov
2317 elif flavor_iface['dedicated'] == 'yes:sriov':
2318 netDict['type']="VFnotShared" #sriov but only one sriov on the PF
2319 netDict["mac_address"] = flavor_iface.get("mac_address")
2320 break;
2321 netDict["use"]=iface['type']
2322 if netDict["use"]=="data" and not netDict.get("type"):
2323 #print "netDict", netDict
2324 #print "iface", iface
2325 e_text = "Cannot determine the interface type PF or VF of VNF '%s' VM '%s' iface '%s'" %(sce_vnf['name'], vm['name'], iface['internal_name'])
2326 if flavor_dict.get('extended')==None:
2327 raise NfvoException(e_text + "After database migration some information is not available. \
2328 Try to delete and create the scenarios and VNFs again", HTTP_Conflict)
2329 else:
2330 raise NfvoException(e_text, HTTP_Internal_Server_Error)
2331 if netDict["use"]=="mgmt" or netDict["use"]=="bridge":
2332 netDict["type"]="virtual"
2333 if "vpci" in iface and iface["vpci"] is not None:
2334 netDict['vpci'] = iface['vpci']
2335 if "mac" in iface and iface["mac"] is not None:
2336 netDict['mac_address'] = iface['mac']
2337 if "port-security" in iface and iface["port-security"] is not None:
2338 netDict['port_security'] = iface['port-security']
2339 if "floating-ip" in iface and iface["floating-ip"] is not None:
2340 netDict['floating_ip'] = iface['floating-ip']
2341 netDict['name'] = iface['internal_name']
2342 if iface['net_id'] is None:
2343 for vnf_iface in sce_vnf["interfaces"]:
2344 #print iface
2345 #print vnf_iface
2346 if vnf_iface['interface_id']==iface['uuid']:
2347 netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ]
2348 break
2349 else:
2350 netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ]
2351 #skip bridge ifaces not connected to any net
2352 #if 'net_id' not in netDict or netDict['net_id']==None:
2353 # continue
2354 myVMDict['networks'].append(netDict)
2355 #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
2356 #print myVMDict['name']
2357 #print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False)
2358 #print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False)
2359 #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
2360
2361 if 'availability_zone' in myVMDict:
2362 av_index = vnf_availability_zones.index(myVMDict['availability_zone'])
2363 else:
2364 av_index = None
2365
2366 vm_id = myvim.new_vminstance(myVMDict['name'], myVMDict['description'], myVMDict.get('start', None),
2367 myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'],
2368 availability_zone_index=av_index,
2369 availability_zone_list=vnf_availability_zones)
2370 #print "VIM vm instance id (server id) for scenario %s: %s" % (scenarioDict['name'],vm_id)
2371 vm['vim_id'] = vm_id
2372 rollbackList.append({'what':'vm','where':'vim','vim_id':datacenter_id,'uuid':vm_id})
2373 #put interface uuid back to scenario[vnfs][vms[[interfaces]
2374 for net in myVMDict['networks']:
2375 if "vim_id" in net:
2376 for iface in vm['interfaces']:
2377 if net["name"]==iface["internal_name"]:
2378 iface["vim_id"]=net["vim_id"]
2379 break
2380
2381 logger.debug("start scenario Deployment done")
2382 #print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)
2383 #r,c = mydb.new_instance_scenario_as_a_whole(nfvo_tenant,scenarioDict['name'],scenarioDict)
2384 instance_id = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_scenario_name, instance_scenario_description, scenarioDict)
2385 return mydb.get_instance_scenario(instance_id)
2386
2387 except (db_base_Exception, vimconn.vimconnException) as e:
2388 _, message = rollback(mydb, vims, rollbackList)
2389 if isinstance(e, db_base_Exception):
2390 error_text = "Exception at database"
2391 else:
2392 error_text = "Exception at VIM"
2393 error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
2394 #logger.error("start_scenario %s", error_text)
2395 raise NfvoException(error_text, e.http_code)
2396
2397 def unify_cloud_config(cloud_config_preserve, cloud_config):
2398 """ join the cloud config information into cloud_config_preserve.
2399 In case of conflict cloud_config_preserve preserves
2400 None is allowed
2401 """
2402 if not cloud_config_preserve and not cloud_config:
2403 return None
2404
2405 new_cloud_config = {"key-pairs":[], "users":[]}
2406 # key-pairs
2407 if cloud_config_preserve:
2408 for key in cloud_config_preserve.get("key-pairs", () ):
2409 if key not in new_cloud_config["key-pairs"]:
2410 new_cloud_config["key-pairs"].append(key)
2411 if cloud_config:
2412 for key in cloud_config.get("key-pairs", () ):
2413 if key not in new_cloud_config["key-pairs"]:
2414 new_cloud_config["key-pairs"].append(key)
2415 if not new_cloud_config["key-pairs"]:
2416 del new_cloud_config["key-pairs"]
2417
2418 # users
2419 if cloud_config:
2420 new_cloud_config["users"] += cloud_config.get("users", () )
2421 if cloud_config_preserve:
2422 new_cloud_config["users"] += cloud_config_preserve.get("users", () )
2423 index_to_delete = []
2424 users = new_cloud_config.get("users", [])
2425 for index0 in range(0,len(users)):
2426 if index0 in index_to_delete:
2427 continue
2428 for index1 in range(index0+1,len(users)):
2429 if index1 in index_to_delete:
2430 continue
2431 if users[index0]["name"] == users[index1]["name"]:
2432 index_to_delete.append(index1)
2433 for key in users[index1].get("key-pairs",()):
2434 if "key-pairs" not in users[index0]:
2435 users[index0]["key-pairs"] = [key]
2436 elif key not in users[index0]["key-pairs"]:
2437 users[index0]["key-pairs"].append(key)
2438 index_to_delete.sort(reverse=True)
2439 for index in index_to_delete:
2440 del users[index]
2441 if not new_cloud_config["users"]:
2442 del new_cloud_config["users"]
2443
2444 #boot-data-drive
2445 if cloud_config and cloud_config.get("boot-data-drive") != None:
2446 new_cloud_config["boot-data-drive"] = cloud_config["boot-data-drive"]
2447 if cloud_config_preserve and cloud_config_preserve.get("boot-data-drive") != None:
2448 new_cloud_config["boot-data-drive"] = cloud_config_preserve["boot-data-drive"]
2449
2450 # user-data
2451 new_cloud_config["user-data"] = []
2452 if cloud_config and cloud_config.get("user-data"):
2453 if isinstance(cloud_config["user-data"], list):
2454 new_cloud_config["user-data"] += cloud_config["user-data"]
2455 else:
2456 new_cloud_config["user-data"].append(cloud_config["user-data"])
2457 if cloud_config_preserve and cloud_config_preserve.get("user-data"):
2458 if isinstance(cloud_config_preserve["user-data"], list):
2459 new_cloud_config["user-data"] += cloud_config_preserve["user-data"]
2460 else:
2461 new_cloud_config["user-data"].append(cloud_config_preserve["user-data"])
2462 if not new_cloud_config["user-data"]:
2463 del new_cloud_config["user-data"]
2464
2465 # config files
2466 new_cloud_config["config-files"] = []
2467 if cloud_config and cloud_config.get("config-files") != None:
2468 new_cloud_config["config-files"] += cloud_config["config-files"]
2469 if cloud_config_preserve:
2470 for file in cloud_config_preserve.get("config-files", ()):
2471 for index in range(0, len(new_cloud_config["config-files"])):
2472 if new_cloud_config["config-files"][index]["dest"] == file["dest"]:
2473 new_cloud_config["config-files"][index] = file
2474 break
2475 else:
2476 new_cloud_config["config-files"].append(file)
2477 if not new_cloud_config["config-files"]:
2478 del new_cloud_config["config-files"]
2479 return new_cloud_config
2480
2481
2482 def get_vim_thread(mydb, tenant_id, datacenter_id_name=None, datacenter_tenant_id=None):
2483 datacenter_id = None
2484 datacenter_name = None
2485 thread = None
2486 try:
2487 if datacenter_tenant_id:
2488 thread_id = datacenter_tenant_id
2489 thread = vim_threads["running"].get(datacenter_tenant_id)
2490 else:
2491 where_={"td.nfvo_tenant_id": tenant_id}
2492 if datacenter_id_name:
2493 if utils.check_valid_uuid(datacenter_id_name):
2494 datacenter_id = datacenter_id_name
2495 where_["dt.datacenter_id"] = datacenter_id
2496 else:
2497 datacenter_name = datacenter_id_name
2498 where_["d.name"] = datacenter_name
2499 if datacenter_tenant_id:
2500 where_["dt.uuid"] = datacenter_tenant_id
2501 datacenters = mydb.get_rows(
2502 SELECT=("dt.uuid as datacenter_tenant_id",),
2503 FROM="datacenter_tenants as dt join tenants_datacenters as td on dt.uuid=td.datacenter_tenant_id "
2504 "join datacenters as d on d.uuid=dt.datacenter_id",
2505 WHERE=where_)
2506 if len(datacenters) > 1:
2507 raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
2508 elif datacenters:
2509 thread_id = datacenters[0]["datacenter_tenant_id"]
2510 thread = vim_threads["running"].get(thread_id)
2511 if not thread:
2512 raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found)
2513 return thread_id, thread
2514 except db_base_Exception as e:
2515 raise NfvoException("{} {}".format(type(e).__name__ , str(e)), e.http_code)
2516
2517
2518 def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter):
2519 datacenter_id = None
2520 datacenter_name = None
2521 if datacenter_id_name:
2522 if utils.check_valid_uuid(datacenter_id_name):
2523 datacenter_id = datacenter_id_name
2524 else:
2525 datacenter_name = datacenter_id_name
2526 vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, **extra_filter)
2527 if len(vims) == 0:
2528 raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found)
2529 elif len(vims)>1:
2530 #print "nfvo.datacenter_action() error. Several datacenters found"
2531 raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
2532 return vims.keys()[0], vims.values()[0]
2533
2534
2535 def update(d, u):
2536 '''Takes dict d and updates it with the values in dict u.'''
2537 '''It merges all depth levels'''
2538 for k, v in u.iteritems():
2539 if isinstance(v, collections.Mapping):
2540 r = update(d.get(k, {}), v)
2541 d[k] = r
2542 else:
2543 d[k] = u[k]
2544 return d
2545
2546 def create_instance(mydb, tenant_id, instance_dict):
2547 # print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
2548 # logger.debug("Creating instance...")
2549 scenario = instance_dict["scenario"]
2550
2551 # find main datacenter
2552 myvims = {}
2553 myvim_threads_id = {}
2554 datacenter = instance_dict.get("datacenter")
2555 default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
2556 myvims[default_datacenter_id] = vim
2557 myvim_threads_id[default_datacenter_id], _ = get_vim_thread(mydb, tenant_id, default_datacenter_id)
2558 tenant = mydb.get_rows_by_id('nfvo_tenants', tenant_id)
2559 # myvim_tenant = myvim['tenant_id']
2560
2561 rollbackList=[]
2562
2563 # print "Checking that the scenario exists and getting the scenario dictionary"
2564 scenarioDict = mydb.get_scenario(scenario, tenant_id, datacenter_vim_id=myvim_threads_id[default_datacenter_id],
2565 datacenter_id=default_datacenter_id)
2566
2567 # logger.debug(">>>>>> Dictionaries before merging")
2568 # logger.debug(">>>>>> InstanceDict:\n{}".format(yaml.safe_dump(instance_dict,default_flow_style=False, width=256)))
2569 # logger.debug(">>>>>> ScenarioDict:\n{}".format(yaml.safe_dump(scenarioDict,default_flow_style=False, width=256)))
2570
2571 db_instance_vnfs = []
2572 db_instance_vms = []
2573 db_instance_interfaces = []
2574 db_ip_profiles = []
2575 db_vim_actions = []
2576 uuid_list = []
2577 task_index = 0
2578 instance_name = instance_dict["name"]
2579 instance_uuid = str(uuid4())
2580 uuid_list.append(instance_uuid)
2581 db_instance_scenario = {
2582 "uuid": instance_uuid,
2583 "name": instance_name,
2584 "tenant_id": tenant_id,
2585 "scenario_id": scenarioDict['uuid'],
2586 "datacenter_id": default_datacenter_id,
2587 # filled bellow 'datacenter_tenant_id'
2588 "description": instance_dict.get("description"),
2589 }
2590 if scenarioDict.get("cloud-config"):
2591 db_instance_scenario["cloud_config"] = yaml.safe_dump(scenarioDict["cloud-config"],
2592 default_flow_style=True, width=256)
2593 instance_action_id = get_task_id()
2594 db_instance_action = {
2595 "uuid": instance_action_id, # same uuid for the instance and the action on create
2596 "tenant_id": tenant_id,
2597 "instance_id": instance_uuid,
2598 "description": "CREATE",
2599 }
2600
2601 # Auxiliary dictionaries from x to y
2602 vnf_net2instance = {}
2603 sce_net2instance = {}
2604 net2task_id = {'scenario': {}}
2605
2606 # logger.debug("Creating instance from scenario-dict:\n%s",
2607 # yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False))
2608 try:
2609 # 0 check correct parameters
2610 for net_name, net_instance_desc in instance_dict.get("networks", {}).iteritems():
2611 found = False
2612 for scenario_net in scenarioDict['nets']:
2613 if net_name == scenario_net["name"]:
2614 found = True
2615 break
2616 if not found:
2617 raise NfvoException("Invalid scenario network name '{}' at instance:networks".format(net_name),
2618 HTTP_Bad_Request)
2619 if "sites" not in net_instance_desc:
2620 net_instance_desc["sites"] = [ {} ]
2621 site_without_datacenter_field = False
2622 for site in net_instance_desc["sites"]:
2623 if site.get("datacenter"):
2624 if site["datacenter"] not in myvims:
2625 # Add this datacenter to myvims
2626 d, v = get_datacenter_by_name_uuid(mydb, tenant_id, site["datacenter"])
2627 myvims[d] = v
2628 myvim_threads_id[d], _ = get_vim_thread(mydb, tenant_id, site["datacenter"])
2629 site["datacenter"] = d # change name to id
2630 else:
2631 if site_without_datacenter_field:
2632 raise NfvoException("Found more than one entries without datacenter field at "
2633 "instance:networks:{}:sites".format(net_name), HTTP_Bad_Request)
2634 site_without_datacenter_field = True
2635 site["datacenter"] = default_datacenter_id # change name to id
2636
2637 for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).iteritems():
2638 found = False
2639 for scenario_vnf in scenarioDict['vnfs']:
2640 if vnf_name == scenario_vnf['name']:
2641 found = True
2642 break
2643 if not found:
2644 raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_instance_desc), HTTP_Bad_Request)
2645 if "datacenter" in vnf_instance_desc:
2646 # Add this datacenter to myvims
2647 if vnf_instance_desc["datacenter"] not in myvims:
2648 d, v = get_datacenter_by_name_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"])
2649 myvims[d] = v
2650 myvim_threads_id[d], _ = get_vim_thread(mydb, tenant_id, vnf_instance_desc["datacenter"])
2651 scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"]
2652
2653 # 0.1 parse cloud-config parameters
2654 cloud_config = unify_cloud_config(instance_dict.get("cloud-config"), scenarioDict.get("cloud-config"))
2655 # We add the RO key to cloud_config
2656 if tenant[0].get('RO_pub_key'):
2657 RO_key = {"key-pairs": [tenant[0]['RO_pub_key']]}
2658 cloud_config = unify_cloud_config(cloud_config, RO_key)
2659
2660 # 0.2 merge instance information into scenario
2661 # Ideally, the operation should be as simple as: update(scenarioDict,instance_dict)
2662 # However, this is not possible yet.
2663 for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems():
2664 for scenario_net in scenarioDict['nets']:
2665 if net_name == scenario_net["name"]:
2666 if 'ip-profile' in net_instance_desc:
2667 # translate from input format to database format
2668 ipprofile_in = net_instance_desc['ip-profile']
2669 ipprofile_db = {}
2670 ipprofile_db['subnet_address'] = ipprofile_in.get('subnet-address')
2671 ipprofile_db['ip_version'] = ipprofile_in.get('ip-version', 'IPv4')
2672 ipprofile_db['gateway_address'] = ipprofile_in.get('gateway-address')
2673 ipprofile_db['dns_address'] = ipprofile_in.get('dns-address')
2674 if isinstance(ipprofile_db['dns_address'], (list, tuple)):
2675 ipprofile_db['dns_address'] = ";".join(ipprofile_db['dns_address'])
2676 if 'dhcp' in ipprofile_in:
2677 ipprofile_db['dhcp_start_address'] = ipprofile_in['dhcp'].get('start-address')
2678 ipprofile_db['dhcp_enabled'] = ipprofile_in['dhcp'].get('enabled', True)
2679 ipprofile_db['dhcp_count'] = ipprofile_in['dhcp'].get('count' )
2680 if 'ip_profile' not in scenario_net:
2681 scenario_net['ip_profile'] = ipprofile_db
2682 else:
2683 update(scenario_net['ip_profile'], ipprofile_db)
2684 for interface in net_instance_desc.get('interfaces', () ):
2685 if 'ip_address' in interface:
2686 for vnf in scenarioDict['vnfs']:
2687 if interface['vnf'] == vnf['name']:
2688 for vnf_interface in vnf['interfaces']:
2689 if interface['vnf_interface'] == vnf_interface['external_name']:
2690 vnf_interface['ip_address']=interface['ip_address']
2691
2692 # logger.debug(">>>>>>>> Merged dictionary")
2693 # logger.debug("Creating instance scenario-dict MERGED:\n%s",
2694 # yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False))
2695
2696 # 1. Creating new nets (sce_nets) in the VIM"
2697 db_instance_nets = []
2698 for sce_net in scenarioDict['nets']:
2699 descriptor_net = instance_dict.get("networks", {}).get(sce_net["name"], {})
2700 net_name = descriptor_net.get("vim-network-name")
2701 sce_net2instance[sce_net['uuid']] = {}
2702 net2task_id['scenario'][sce_net['uuid']] = {}
2703
2704 sites = descriptor_net.get("sites", [ {} ])
2705 for site in sites:
2706 if site.get("datacenter"):
2707 vim = myvims[ site["datacenter"] ]
2708 datacenter_id = site["datacenter"]
2709 myvim_thread_id = myvim_threads_id[ site["datacenter"] ]
2710 else:
2711 vim = myvims[ default_datacenter_id ]
2712 datacenter_id = default_datacenter_id
2713 myvim_thread_id = myvim_threads_id[default_datacenter_id]
2714 net_type = sce_net['type']
2715 lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} # 'shared': True
2716
2717 if not net_name:
2718 if sce_net["external"]:
2719 net_name = sce_net["name"]
2720 else:
2721 net_name = "{}.{}".format(instance_name, sce_net["name"])
2722 net_name = net_name[:255] # limit length
2723
2724 if "netmap-use" in site or "netmap-create" in site:
2725 create_network = False
2726 lookfor_network = False
2727 if "netmap-use" in site:
2728 lookfor_network = True
2729 if utils.check_valid_uuid(site["netmap-use"]):
2730 filter_text = "scenario id '%s'" % site["netmap-use"]
2731 lookfor_filter["id"] = site["netmap-use"]
2732 else:
2733 filter_text = "scenario name '%s'" % site["netmap-use"]
2734 lookfor_filter["name"] = site["netmap-use"]
2735 if "netmap-create" in site:
2736 create_network = True
2737 net_vim_name = net_name
2738 if site["netmap-create"]:
2739 net_vim_name = site["netmap-create"]
2740 elif sce_net["external"]:
2741 if sce_net['vim_id'] != None:
2742 # there is a netmap at datacenter_nets database # TODO REVISE!!!!
2743 create_network = False
2744 lookfor_network = True
2745 lookfor_filter["id"] = sce_net['vim_id']
2746 filter_text = "vim_id '{}' datacenter_netmap name '{}'. Try to reload vims with "\
2747 "datacenter-net-update".format(sce_net['vim_id'], sce_net["name"])
2748 # look for network at datacenter and return error
2749 else:
2750 # There is not a netmap, look at datacenter for a net with this name and create if not found
2751 create_network = True
2752 lookfor_network = True
2753 lookfor_filter["name"] = sce_net["name"]
2754 net_vim_name = sce_net["name"]
2755 filter_text = "scenario name '%s'" % sce_net["name"]
2756 else:
2757 net_vim_name = net_name
2758 create_network = True
2759 lookfor_network = False
2760
2761 if lookfor_network and create_network:
2762 # TODO create two tasks FIND + CREATE with their relationship
2763 task_action = "FIND_CREATE"
2764 task_params = (lookfor_filter, (net_vim_name, net_type, sce_net.get('ip_profile', None)))
2765 elif lookfor_network:
2766 task_action = "FIND"
2767 task_params = (lookfor_filter,)
2768 elif create_network:
2769 task_action = "CREATE"
2770 task_params = (net_vim_name, net_type, sce_net.get('ip_profile', None))
2771
2772 # fill database content
2773 net_uuid = str(uuid4())
2774 uuid_list.append(net_uuid)
2775 sce_net2instance[sce_net['uuid']][datacenter_id] = net_uuid
2776 db_net = {
2777 "uuid": net_uuid,
2778 'vim_net_id': None,
2779 "instance_scenario_id": instance_uuid,
2780 "sce_net_id": sce_net["uuid"],
2781 "created": create_network,
2782 'datacenter_id': datacenter_id,
2783 'datacenter_tenant_id': myvim_thread_id,
2784 'status': 'BUILD' if create_network else "ACTIVE"
2785 }
2786 db_instance_nets.append(db_net)
2787 db_vim_action = {
2788 "instance_action_id": instance_action_id,
2789 "status": "SCHEDULED",
2790 "task_index": task_index,
2791 "datacenter_vim_id": myvim_thread_id,
2792 "action": task_action,
2793 "item": "instance_nets",
2794 "item_id": net_uuid,
2795 "extra": yaml.safe_dump({"params": task_params}, default_flow_style=True, width=256)
2796 }
2797 net2task_id['scenario'][sce_net['uuid']][datacenter_id] = task_index
2798 task_index += 1
2799 db_vim_actions.append(db_vim_action)
2800
2801 if 'ip_profile' in sce_net:
2802 db_ip_profile={
2803 'instance_net_id': net_uuid,
2804 'ip_version': sce_net['ip_profile']['ip_version'],
2805 'subnet_address': sce_net['ip_profile']['subnet_address'],
2806 'gateway_address': sce_net['ip_profile']['gateway_address'],
2807 'dns_address': sce_net['ip_profile']['dns_address'],
2808 'dhcp_enabled': sce_net['ip_profile']['dhcp_enabled'],
2809 'dhcp_start_address': sce_net['ip_profile']['dhcp_start_address'],
2810 'dhcp_count': sce_net['ip_profile']['dhcp_count'],
2811 }
2812 db_ip_profiles.append(db_ip_profile)
2813
2814 # 2. Creating new nets (vnf internal nets) in the VIM"
2815 # For each vnf net, we create it and we add it to instanceNetlist.
2816 for sce_vnf in scenarioDict['vnfs']:
2817 for net in sce_vnf['nets']:
2818 if sce_vnf.get("datacenter"):
2819 datacenter_id = sce_vnf["datacenter"]
2820 myvim_thread_id = myvim_threads_id[sce_vnf["datacenter"]]
2821 else:
2822 datacenter_id = default_datacenter_id
2823 myvim_thread_id = myvim_threads_id[default_datacenter_id]
2824 descriptor_net = instance_dict.get("vnfs", {}).get(sce_vnf["name"], {})
2825 net_name = descriptor_net.get("name")
2826 if not net_name:
2827 net_name = "{}.{}".format(instance_name, net["name"])
2828 net_name = net_name[:255] # limit length
2829 net_type = net['type']
2830
2831 if sce_vnf['uuid'] not in vnf_net2instance:
2832 vnf_net2instance[sce_vnf['uuid']] = {}
2833 if sce_vnf['uuid'] not in net2task_id:
2834 net2task_id[sce_vnf['uuid']] = {}
2835 net2task_id[sce_vnf['uuid']][net['uuid']] = task_index
2836
2837 # fill database content
2838 net_uuid = str(uuid4())
2839 uuid_list.append(net_uuid)
2840 vnf_net2instance[sce_vnf['uuid']][net['uuid']] = net_uuid
2841 db_net = {
2842 "uuid": net_uuid,
2843 'vim_net_id': None,
2844 "instance_scenario_id": instance_uuid,
2845 "net_id": net["uuid"],
2846 "created": True,
2847 'datacenter_id': datacenter_id,
2848 'datacenter_tenant_id': myvim_thread_id,
2849 }
2850 db_instance_nets.append(db_net)
2851
2852 db_vim_action = {
2853 "instance_action_id": instance_action_id,
2854 "task_index": task_index,
2855 "datacenter_vim_id": myvim_thread_id,
2856 "status": "SCHEDULED",
2857 "action": "CREATE",
2858 "item": "instance_nets",
2859 "item_id": net_uuid,
2860 "extra": yaml.safe_dump({"params": (net_name, net_type, net.get('ip_profile',None))},
2861 default_flow_style=True, width=256)
2862 }
2863 task_index += 1
2864 db_vim_actions.append(db_vim_action)
2865
2866 if 'ip_profile' in net:
2867 db_ip_profile = {
2868 'instance_net_id': net_uuid,
2869 'ip_version': net['ip_profile']['ip_version'],
2870 'subnet_address': net['ip_profile']['subnet_address'],
2871 'gateway_address': net['ip_profile']['gateway_address'],
2872 'dns_address': net['ip_profile']['dns_address'],
2873 'dhcp_enabled': net['ip_profile']['dhcp_enabled'],
2874 'dhcp_start_address': net['ip_profile']['dhcp_start_address'],
2875 'dhcp_count': net['ip_profile']['dhcp_count'],
2876 }
2877 db_ip_profiles.append(db_ip_profile)
2878
2879 # print "vnf_net2instance:"
2880 # print yaml.safe_dump(vnf_net2instance, indent=4, default_flow_style=False)
2881
2882 # 3. Creating new vm instances in the VIM
2883 # myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
2884 sce_vnf_list = sorted(scenarioDict['vnfs'], key=lambda k: k['name'])
2885 for sce_vnf in sce_vnf_list:
2886 vnf_availability_zones = []
2887 for vm in sce_vnf['vms']:
2888 vm_av = vm.get('availability_zone')
2889 if vm_av and vm_av not in vnf_availability_zones:
2890 vnf_availability_zones.append(vm_av)
2891
2892 # check if there is enough availability zones available at vim level.
2893 if myvims[datacenter_id].availability_zone and vnf_availability_zones:
2894 if len(vnf_availability_zones) > len(myvims[datacenter_id].availability_zone):
2895 raise NfvoException('No enough availability zones at VIM for this deployment', HTTP_Bad_Request)
2896
2897 if sce_vnf.get("datacenter"):
2898 vim = myvims[ sce_vnf["datacenter"] ]
2899 myvim_thread_id = myvim_threads_id[ sce_vnf["datacenter"] ]
2900 datacenter_id = sce_vnf["datacenter"]
2901 else:
2902 vim = myvims[ default_datacenter_id ]
2903 myvim_thread_id = myvim_threads_id[ default_datacenter_id ]
2904 datacenter_id = default_datacenter_id
2905 sce_vnf["datacenter_id"] = datacenter_id
2906 i = 0
2907
2908 vnf_uuid = str(uuid4())
2909 uuid_list.append(vnf_uuid)
2910 db_instance_vnf = {
2911 'uuid': vnf_uuid,
2912 'instance_scenario_id': instance_uuid,
2913 'vnf_id': sce_vnf['vnf_id'],
2914 'sce_vnf_id': sce_vnf['uuid'],
2915 'datacenter_id': datacenter_id,
2916 'datacenter_tenant_id': myvim_thread_id,
2917 }
2918 db_instance_vnfs.append(db_instance_vnf)
2919
2920 for vm in sce_vnf['vms']:
2921 myVMDict = {}
2922 myVMDict['name'] = "{}.{}.{}".format(instance_name[:64], sce_vnf['name'][:64], vm["name"][:64])
2923 myVMDict['description'] = myVMDict['name'][0:99]
2924 # if not startvms:
2925 # myVMDict['start'] = "no"
2926 myVMDict['name'] = myVMDict['name'][0:255] # limit name length
2927 #create image at vim in case it not exist
2928 image_dict = mydb.get_table_by_uuid_name("images", vm['image_id'])
2929 image_id = create_or_use_image(mydb, {datacenter_id: vim}, image_dict, [], True)
2930 vm['vim_image_id'] = image_id
2931
2932 # create flavor at vim in case it not exist
2933 flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id'])
2934 if flavor_dict['extended']!=None:
2935 flavor_dict['extended'] = yaml.load(flavor_dict['extended'])
2936 flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True)
2937
2938 # Obtain information for additional disks
2939 extended_flavor_dict = mydb.get_rows(FROM='datacenters_flavors', SELECT=('extended',), WHERE={'vim_id': flavor_id})
2940 if not extended_flavor_dict:
2941 raise NfvoException("flavor '{}' not found".format(flavor_id), HTTP_Not_Found)
2942 return
2943
2944 # extended_flavor_dict_yaml = yaml.load(extended_flavor_dict[0])
2945 myVMDict['disks'] = None
2946 extended_info = extended_flavor_dict[0]['extended']
2947 if extended_info != None:
2948 extended_flavor_dict_yaml = yaml.load(extended_info)
2949 if 'disks' in extended_flavor_dict_yaml:
2950 myVMDict['disks'] = extended_flavor_dict_yaml['disks']
2951
2952 vm['vim_flavor_id'] = flavor_id
2953 myVMDict['imageRef'] = vm['vim_image_id']
2954 myVMDict['flavorRef'] = vm['vim_flavor_id']
2955 myVMDict['availability_zone'] = vm.get('availability_zone')
2956 myVMDict['networks'] = []
2957 task_depends_on = []
2958 # TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true
2959 db_vm_ifaces = []
2960 for iface in vm['interfaces']:
2961 netDict = {}
2962 if iface['type']=="data":
2963 netDict['type'] = iface['model']
2964 elif "model" in iface and iface["model"]!=None:
2965 netDict['model']=iface['model']
2966 # TODO in future, remove this because mac_address will not be set, and the type of PV,VF
2967 # is obtained from iterface table model
2968 # discover type of interface looking at flavor
2969 for numa in flavor_dict.get('extended',{}).get('numas',[]):
2970 for flavor_iface in numa.get('interfaces',[]):
2971 if flavor_iface.get('name') == iface['internal_name']:
2972 if flavor_iface['dedicated'] == 'yes':
2973 netDict['type']="PF" #passthrough
2974 elif flavor_iface['dedicated'] == 'no':
2975 netDict['type']="VF" #siov
2976 elif flavor_iface['dedicated'] == 'yes:sriov':
2977 netDict['type']="VFnotShared" #sriov but only one sriov on the PF
2978 netDict["mac_address"] = flavor_iface.get("mac_address")
2979 break;
2980 netDict["use"]=iface['type']
2981 if netDict["use"]=="data" and not netDict.get("type"):
2982 #print "netDict", netDict
2983 #print "iface", iface
2984 e_text = "Cannot determine the interface type PF or VF of VNF '%s' VM '%s' iface '%s'" %(sce_vnf['name'], vm['name'], iface['internal_name'])
2985 if flavor_dict.get('extended')==None:
2986 raise NfvoException(e_text + "After database migration some information is not available. \
2987 Try to delete and create the scenarios and VNFs again", HTTP_Conflict)
2988 else:
2989 raise NfvoException(e_text, HTTP_Internal_Server_Error)
2990 if netDict["use"]=="mgmt" or netDict["use"]=="bridge":
2991 netDict["type"]="virtual"
2992 if "vpci" in iface and iface["vpci"] is not None:
2993 netDict['vpci'] = iface['vpci']
2994 if "mac" in iface and iface["mac"] is not None:
2995 netDict['mac_address'] = iface['mac']
2996 if "port-security" in iface and iface["port-security"] is not None:
2997 netDict['port_security'] = iface['port-security']
2998 if "floating-ip" in iface and iface["floating-ip"] is not None:
2999 netDict['floating_ip'] = iface['floating-ip']
3000 netDict['name'] = iface['internal_name']
3001 if iface['net_id'] is None:
3002 for vnf_iface in sce_vnf["interfaces"]:
3003 # print iface
3004 # print vnf_iface
3005 if vnf_iface['interface_id']==iface['uuid']:
3006 netDict['net_id'] = "TASK-{}".format(net2task_id['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id])
3007 instance_net_id = sce_net2instance[ vnf_iface['sce_net_id'] ][datacenter_id]
3008 task_depends_on.append(net2task_id['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id])
3009 break
3010 else:
3011 netDict['net_id'] = "TASK-{}".format(net2task_id[ sce_vnf['uuid'] ][ iface['net_id'] ])
3012 instance_net_id = vnf_net2instance[ sce_vnf['uuid'] ][ iface['net_id'] ]
3013 task_depends_on.append(net2task_id[sce_vnf['uuid'] ][ iface['net_id']])
3014 # skip bridge ifaces not connected to any net
3015 if 'net_id' not in netDict or netDict['net_id']==None:
3016 continue
3017 myVMDict['networks'].append(netDict)
3018 db_vm_iface={
3019 # "uuid"
3020 # 'instance_vm_id': instance_vm_uuid,
3021 "instance_net_id": instance_net_id,
3022 'interface_id': iface['uuid'],
3023 # 'vim_interface_id': ,
3024 'type': 'external' if iface['external_name'] is not None else 'internal',
3025 'ip_address': iface.get('ip_address'),
3026 'floating_ip': int(iface.get('floating-ip', False)),
3027 'port_security': int(iface.get('port-security', True))
3028 }
3029 db_vm_ifaces.append(db_vm_iface)
3030 # print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
3031 # print myVMDict['name']
3032 # print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False)
3033 # print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False)
3034 # print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
3035 if vm.get("boot_data"):
3036 cloud_config_vm = unify_cloud_config(vm["boot_data"], cloud_config)
3037 else:
3038 cloud_config_vm = cloud_config
3039 if myVMDict.get('availability_zone'):
3040 av_index = vnf_availability_zones.index(myVMDict['availability_zone'])
3041 else:
3042 av_index = None
3043 for vm_index in range(0, vm.get('count', 1)):
3044 vm_index_name = ""
3045 if vm.get('count', 1) > 1:
3046 vm_index_name += "." + chr(97 + vm_index)
3047 task_params = (myVMDict['name']+vm_index_name, myVMDict['description'], myVMDict.get('start', None),
3048 myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'], cloud_config_vm,
3049 myVMDict['disks'], av_index, vnf_availability_zones)
3050 # put interface uuid back to scenario[vnfs][vms[[interfaces]
3051 for net in myVMDict['networks']:
3052 if "vim_id" in net:
3053 for iface in vm['interfaces']:
3054 if net["name"]==iface["internal_name"]:
3055 iface["vim_id"]=net["vim_id"]
3056 break
3057 vm_uuid = str(uuid4())
3058 uuid_list.append(vm_uuid)
3059 db_vm = {
3060 "uuid": vm_uuid,
3061 'instance_vnf_id': vnf_uuid,
3062 #TODO delete "vim_vm_id": vm_id,
3063 "vm_id": vm["uuid"],
3064 # "status":
3065 }
3066 db_instance_vms.append(db_vm)
3067
3068 iface_index = 0
3069 for db_vm_iface in db_vm_ifaces:
3070 iface_uuid = str(uuid4())
3071 uuid_list.append(iface_uuid)
3072 db_vm_iface_instance = {
3073 "uuid": iface_uuid,
3074 "instance_vm_id": vm_uuid
3075 }
3076 db_vm_iface_instance.update(db_vm_iface)
3077 if db_vm_iface_instance.get("ip_address"): # increment ip_address
3078 ip = db_vm_iface_instance.get("ip_address")
3079 i = ip.rfind(".")
3080 if i > 0:
3081 try:
3082 i += 1
3083 ip = ip[i:] + str(int(ip[:i]) +1)
3084 db_vm_iface_instance["ip_address"] = ip
3085 except:
3086 db_vm_iface_instance["ip_address"] = None
3087 db_instance_interfaces.append(db_vm_iface_instance)
3088 myVMDict['networks'][iface_index]["uuid"] = iface_uuid
3089 iface_index += 1
3090
3091 db_vim_action = {
3092 "instance_action_id": instance_action_id,
3093 "task_index": task_index,
3094 "datacenter_vim_id": myvim_thread_id,
3095 "action": "CREATE",
3096 "status": "SCHEDULED",
3097 "item": "instance_vms",
3098 "item_id": vm_uuid,
3099 "extra": yaml.safe_dump({"params": task_params, "depends_on": task_depends_on},
3100 default_flow_style=True, width=256)
3101 }
3102 task_index += 1
3103 db_vim_actions.append(db_vim_action)
3104
3105 scenarioDict["datacenter2tenant"] = myvim_threads_id
3106
3107 db_instance_action["number_tasks"] = task_index
3108 db_instance_scenario['datacenter_tenant_id'] = myvim_threads_id[default_datacenter_id]
3109 db_instance_scenario['datacenter_id'] = default_datacenter_id
3110 db_tables=[
3111 {"instance_scenarios": db_instance_scenario},
3112 {"instance_vnfs": db_instance_vnfs},
3113 {"instance_nets": db_instance_nets},
3114 {"ip_profiles": db_ip_profiles},
3115 {"instance_vms": db_instance_vms},
3116 {"instance_interfaces": db_instance_interfaces},
3117 {"instance_actions": db_instance_action},
3118 {"vim_actions": db_vim_actions}
3119 ]
3120
3121 logger.debug("create_instance done DB tables: %s",
3122 yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
3123 mydb.new_rows(db_tables, uuid_list)
3124 for myvim_thread_id in myvim_threads_id.values():
3125 vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions)
3126
3127 returned_instance = mydb.get_instance_scenario(instance_uuid)
3128 returned_instance["action_id"] = instance_action_id
3129 return returned_instance
3130 except (NfvoException, vimconn.vimconnException, db_base_Exception) as e:
3131 message = rollback(mydb, myvims, rollbackList)
3132 if isinstance(e, db_base_Exception):
3133 error_text = "database Exception"
3134 elif isinstance(e, vimconn.vimconnException):
3135 error_text = "VIM Exception"
3136 else:
3137 error_text = "Exception"
3138 error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
3139 # logger.error("create_instance: %s", error_text)
3140 raise NfvoException(error_text, e.http_code)
3141
3142
3143 def delete_instance(mydb, tenant_id, instance_id):
3144 # print "Checking that the instance_id exists and getting the instance dictionary"
3145 instanceDict = mydb.get_instance_scenario(instance_id, tenant_id)
3146 # print yaml.safe_dump(instanceDict, indent=4, default_flow_style=False)
3147 tenant_id = instanceDict["tenant_id"]
3148 # print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
3149
3150 # 1. Delete from Database
3151 message = mydb.delete_instance_scenario(instance_id, tenant_id)
3152
3153 # 2. delete from VIM
3154 error_msg = ""
3155 myvims = {}
3156 myvim_threads = {}
3157 vimthread_affected = {}
3158
3159 task_index = 0
3160 instance_action_id = get_task_id()
3161 db_vim_actions = []
3162 db_instance_action = {
3163 "uuid": instance_action_id, # same uuid for the instance and the action on create
3164 "tenant_id": tenant_id,
3165 "instance_id": instance_id,
3166 "description": "DELETE",
3167 # "number_tasks": 0 # filled bellow
3168 }
3169
3170 # 2.1 deleting VMs
3171 # vm_fail_list=[]
3172 for sce_vnf in instanceDict['vnfs']:
3173 datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
3174 vimthread_affected[sce_vnf["datacenter_tenant_id"]] = None
3175 if datacenter_key not in myvims:
3176 try:
3177 _,myvim_thread = get_vim_thread(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
3178 except NfvoException as e:
3179 logger.error(str(e))
3180 myvim_thread = None
3181 myvim_threads[datacenter_key] = myvim_thread
3182 vims = get_vim(mydb, tenant_id, datacenter_id=sce_vnf["datacenter_id"],
3183 datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
3184 if len(vims) == 0:
3185 logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"],
3186 sce_vnf["datacenter_tenant_id"]))
3187 myvims[datacenter_key] = None
3188 else:
3189 myvims[datacenter_key] = vims.values()[0]
3190 myvim = myvims[datacenter_key]
3191 myvim_thread = myvim_threads[datacenter_key]
3192 for vm in sce_vnf['vms']:
3193 if not myvim:
3194 error_msg += "\n VM id={} cannot be deleted because datacenter={} not found".format(vm['vim_vm_id'], sce_vnf["datacenter_id"])
3195 continue
3196 try:
3197 db_vim_action = {
3198 "instance_action_id": instance_action_id,
3199 "task_index": task_index,
3200 "datacenter_vim_id": sce_vnf["datacenter_tenant_id"],
3201 "action": "DELETE",
3202 "status": "SCHEDULED",
3203 "item": "instance_vms",
3204 "item_id": vm["uuid"],
3205 "extra": yaml.safe_dump({"params": vm["interfaces"]},
3206 default_flow_style=True, width=256)
3207 }
3208 task_index += 1
3209 db_vim_actions.append(db_vim_action)
3210
3211 except vimconn.vimconnNotFoundException as e:
3212 error_msg+="\n VM VIM_id={} not found at datacenter={}".format(vm['vim_vm_id'], sce_vnf["datacenter_id"])
3213 logger.warn("VM instance '%s'uuid '%s', VIM id '%s', from VNF_id '%s' not found",
3214 vm['name'], vm['uuid'], vm['vim_vm_id'], sce_vnf['vnf_id'])
3215 except vimconn.vimconnException as e:
3216 error_msg+="\n VM VIM_id={} at datacenter={} Error: {} {}".format(vm['vim_vm_id'], sce_vnf["datacenter_id"], e.http_code, str(e))
3217 logger.error("Error %d deleting VM instance '%s'uuid '%s', VIM_id '%s', from VNF_id '%s': %s",
3218 e.http_code, vm['name'], vm['uuid'], vm['vim_vm_id'], sce_vnf['vnf_id'], str(e))
3219
3220 # 2.2 deleting NETS
3221 # net_fail_list=[]
3222 for net in instanceDict['nets']:
3223 # TODO if not net['created']:
3224 # TODO continue #skip not created nets
3225
3226 vimthread_affected[net["datacenter_tenant_id"]] = None
3227 datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
3228 if datacenter_key not in myvims:
3229 try:
3230 _,myvim_thread = get_vim_thread(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
3231 except NfvoException as e:
3232 logger.error(str(e))
3233 myvim_thread = None
3234 myvim_threads[datacenter_key] = myvim_thread
3235 vims = get_vim(mydb, tenant_id, datacenter_id=net["datacenter_id"],
3236 datacenter_tenant_id=net["datacenter_tenant_id"])
3237 if len(vims) == 0:
3238 logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
3239 myvims[datacenter_key] = None
3240 else:
3241 myvims[datacenter_key] = vims.values()[0]
3242 myvim = myvims[datacenter_key]
3243 myvim_thread = myvim_threads[datacenter_key]
3244
3245 if not myvim:
3246 error_msg += "\n Net VIM_id={} cannot be deleted because datacenter={} not found".format(net['vim_net_id'], net["datacenter_id"])
3247 continue
3248 try:
3249 db_vim_action = {
3250 "instance_action_id": instance_action_id,
3251 "task_index": task_index,
3252 "datacenter_vim_id": net["datacenter_tenant_id"],
3253 "action": "DELETE",
3254 "status": "SCHEDULED",
3255 "item": "instance_nets",
3256 "item_id": net["uuid"],
3257 "extra": yaml.safe_dump({"params": (net['vim_net_id'], net['sdn_net_id'])},
3258 default_flow_style=True, width=256)
3259 }
3260 task_index += 1
3261 db_vim_actions.append(db_vim_action)
3262
3263 except vimconn.vimconnNotFoundException as e:
3264 error_msg += "\n NET VIM_id={} not found at datacenter={}".format(net['vim_net_id'], net["datacenter_id"])
3265 logger.warn("NET '%s', VIM_id '%s', from VNF_net_id '%s' not found",
3266 net['uuid'], net['vim_net_id'], str(net['vnf_net_id']))
3267 except vimconn.vimconnException as e:
3268 error_msg += "\n NET VIM_id={} at datacenter={} Error: {} {}".format(net['vim_net_id'],
3269 net["datacenter_id"],
3270 e.http_code, str(e))
3271 logger.error("Error %d deleting NET '%s', VIM_id '%s', from VNF_net_id '%s': %s",
3272 e.http_code, net['uuid'], net['vim_net_id'], str(net['vnf_net_id']), str(e))
3273
3274 db_instance_action["number_tasks"] = task_index
3275 db_tables = [
3276 {"instance_actions": db_instance_action},
3277 {"vim_actions": db_vim_actions}
3278 ]
3279
3280 logger.debug("delete_instance done DB tables: %s",
3281 yaml.safe_dump(db_tables, indent=4, default_flow_style=False))
3282 mydb.new_rows(db_tables, ())
3283 for myvim_thread_id in vimthread_affected.keys():
3284 vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions)
3285
3286 if len(error_msg) > 0:
3287 return 'action_id={} instance {} deleted but some elements could not be deleted, or already deleted '\
3288 '(error: 404) from VIM: {}'.format(instance_action_id, message, error_msg)
3289 else:
3290 return "action_id={} instance {} deleted".format(instance_action_id, message)
3291
3292
3293 def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenant=None):
3294 '''Refreshes a scenario instance. It modifies instanceDict'''
3295 '''Returns:
3296 - result: <0 if there is any unexpected error, n>=0 if no errors where n is the number of vms and nets that couldn't be updated in the database
3297 - error_msg
3298 '''
3299 # # Assumption: nfvo_tenant and instance_id were checked before entering into this function
3300 # #print "nfvo.refresh_instance begins"
3301 # #print json.dumps(instanceDict, indent=4)
3302 #
3303 # #print "Getting the VIM URL and the VIM tenant_id"
3304 # myvims={}
3305 #
3306 # # 1. Getting VIM vm and net list
3307 # vms_updated = [] #List of VM instance uuids in openmano that were updated
3308 # vms_notupdated=[]
3309 # vm_list = {}
3310 # for sce_vnf in instanceDict['vnfs']:
3311 # datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
3312 # if datacenter_key not in vm_list:
3313 # vm_list[datacenter_key] = []
3314 # if datacenter_key not in myvims:
3315 # vims = get_vim(mydb, nfvo_tenant, datacenter_id=sce_vnf["datacenter_id"],
3316 # datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
3317 # if len(vims) == 0:
3318 # logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]))
3319 # myvims[datacenter_key] = None
3320 # else:
3321 # myvims[datacenter_key] = vims.values()[0]
3322 # for vm in sce_vnf['vms']:
3323 # vm_list[datacenter_key].append(vm['vim_vm_id'])
3324 # vms_notupdated.append(vm["uuid"])
3325 #
3326 # nets_updated = [] #List of VM instance uuids in openmano that were updated
3327 # nets_notupdated=[]
3328 # net_list = {}
3329 # for net in instanceDict['nets']:
3330 # datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
3331 # if datacenter_key not in net_list:
3332 # net_list[datacenter_key] = []
3333 # if datacenter_key not in myvims:
3334 # vims = get_vim(mydb, nfvo_tenant, datacenter_id=net["datacenter_id"],
3335 # datacenter_tenant_id=net["datacenter_tenant_id"])
3336 # if len(vims) == 0:
3337 # logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
3338 # myvims[datacenter_key] = None
3339 # else:
3340 # myvims[datacenter_key] = vims.values()[0]
3341 #
3342 # net_list[datacenter_key].append(net['vim_net_id'])
3343 # nets_notupdated.append(net["uuid"])
3344 #
3345 # # 1. Getting the status of all VMs
3346 # vm_dict={}
3347 # for datacenter_key in myvims:
3348 # if not vm_list.get(datacenter_key):
3349 # continue
3350 # failed = True
3351 # failed_message=""
3352 # if not myvims[datacenter_key]:
3353 # failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
3354 # else:
3355 # try:
3356 # vm_dict.update(myvims[datacenter_key].refresh_vms_status(vm_list[datacenter_key]) )
3357 # failed = False
3358 # except vimconn.vimconnException as e:
3359 # logger.error("VIM exception %s %s", type(e).__name__, str(e))
3360 # failed_message = str(e)
3361 # if failed:
3362 # for vm in vm_list[datacenter_key]:
3363 # vm_dict[vm] = {'status': "VIM_ERROR", 'error_msg': failed_message}
3364 #
3365 # # 2. Update the status of VMs in the instanceDict, while collects the VMs whose status changed
3366 # for sce_vnf in instanceDict['vnfs']:
3367 # for vm in sce_vnf['vms']:
3368 # vm_id = vm['vim_vm_id']
3369 # interfaces = vm_dict[vm_id].pop('interfaces', [])
3370 # #2.0 look if contain manamgement interface, and if not change status from ACTIVE:NoMgmtIP to ACTIVE
3371 # has_mgmt_iface = False
3372 # for iface in vm["interfaces"]:
3373 # if iface["type"]=="mgmt":
3374 # has_mgmt_iface = True
3375 # if vm_dict[vm_id]['status'] == "ACTIVE:NoMgmtIP" and not has_mgmt_iface:
3376 # vm_dict[vm_id]['status'] = "ACTIVE"
3377 # if vm_dict[vm_id].get('error_msg') and len(vm_dict[vm_id]['error_msg']) >= 1024:
3378 # vm_dict[vm_id]['error_msg'] = vm_dict[vm_id]['error_msg'][:516] + " ... " + vm_dict[vm_id]['error_msg'][-500:]
3379 # if vm['status'] != vm_dict[vm_id]['status'] or vm.get('error_msg')!=vm_dict[vm_id].get('error_msg') or vm.get('vim_info')!=vm_dict[vm_id].get('vim_info'):
3380 # vm['status'] = vm_dict[vm_id]['status']
3381 # vm['error_msg'] = vm_dict[vm_id].get('error_msg')
3382 # vm['vim_info'] = vm_dict[vm_id].get('vim_info')
3383 # # 2.1. Update in openmano DB the VMs whose status changed
3384 # try:
3385 # updates = mydb.update_rows('instance_vms', UPDATE=vm_dict[vm_id], WHERE={'uuid':vm["uuid"]})
3386 # vms_notupdated.remove(vm["uuid"])
3387 # if updates>0:
3388 # vms_updated.append(vm["uuid"])
3389 # except db_base_Exception as e:
3390 # logger.error("nfvo.refresh_instance error database update: %s", str(e))
3391 # # 2.2. Update in openmano DB the interface VMs
3392 # for interface in interfaces:
3393 # #translate from vim_net_id to instance_net_id
3394 # network_id_list=[]
3395 # for net in instanceDict['nets']:
3396 # if net["vim_net_id"] == interface["vim_net_id"]:
3397 # network_id_list.append(net["uuid"])
3398 # if not network_id_list:
3399 # continue
3400 # del interface["vim_net_id"]
3401 # try:
3402 # for network_id in network_id_list:
3403 # mydb.update_rows('instance_interfaces', UPDATE=interface, WHERE={'instance_vm_id':vm["uuid"], "instance_net_id":network_id})
3404 # except db_base_Exception as e:
3405 # logger.error( "nfvo.refresh_instance error with vm=%s, interface_net_id=%s", vm["uuid"], network_id)
3406 #
3407 # # 3. Getting the status of all nets
3408 # net_dict = {}
3409 # for datacenter_key in myvims:
3410 # if not net_list.get(datacenter_key):
3411 # continue
3412 # failed = True
3413 # failed_message = ""
3414 # if not myvims[datacenter_key]:
3415 # failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
3416 # else:
3417 # try:
3418 # net_dict.update(myvims[datacenter_key].refresh_nets_status(net_list[datacenter_key]) )
3419 # failed = False
3420 # except vimconn.vimconnException as e:
3421 # logger.error("VIM exception %s %s", type(e).__name__, str(e))
3422 # failed_message = str(e)
3423 # if failed:
3424 # for net in net_list[datacenter_key]:
3425 # net_dict[net] = {'status': "VIM_ERROR", 'error_msg': failed_message}
3426 #
3427 # # 4. Update the status of nets in the instanceDict, while collects the nets whose status changed
3428 # # TODO: update nets inside a vnf
3429 # for net in instanceDict['nets']:
3430 # net_id = net['vim_net_id']
3431 # if net_dict[net_id].get('error_msg') and len(net_dict[net_id]['error_msg']) >= 1024:
3432 # net_dict[net_id]['error_msg'] = net_dict[net_id]['error_msg'][:516] + " ... " + net_dict[vm_id]['error_msg'][-500:]
3433 # if net['status'] != net_dict[net_id]['status'] or net.get('error_msg')!=net_dict[net_id].get('error_msg') or net.get('vim_info')!=net_dict[net_id].get('vim_info'):
3434 # net['status'] = net_dict[net_id]['status']
3435 # net['error_msg'] = net_dict[net_id].get('error_msg')
3436 # net['vim_info'] = net_dict[net_id].get('vim_info')
3437 # # 5.1. Update in openmano DB the nets whose status changed
3438 # try:
3439 # updated = mydb.update_rows('instance_nets', UPDATE=net_dict[net_id], WHERE={'uuid':net["uuid"]})
3440 # nets_notupdated.remove(net["uuid"])
3441 # if updated>0:
3442 # nets_updated.append(net["uuid"])
3443 # except db_base_Exception as e:
3444 # logger.error("nfvo.refresh_instance error database update: %s", str(e))
3445 #
3446 # # Returns appropriate output
3447 # #print "nfvo.refresh_instance finishes"
3448 # logger.debug("VMs updated in the database: %s; nets updated in the database %s; VMs not updated: %s; nets not updated: %s",
3449 # str(vms_updated), str(nets_updated), str(vms_notupdated), str(nets_notupdated))
3450 instance_id = instanceDict['uuid']
3451 # if len(vms_notupdated)+len(nets_notupdated)>0:
3452 # error_msg = "VMs not updated: " + str(vms_notupdated) + "; nets not updated: " + str(nets_notupdated)
3453 # return len(vms_notupdated)+len(nets_notupdated), 'Scenario instance ' + instance_id + ' refreshed but some elements could not be updated in the database: ' + error_msg
3454
3455 return 0, 'Scenario instance ' + instance_id + ' refreshed.'
3456
3457 def instance_action(mydb,nfvo_tenant,instance_id, action_dict):
3458 #print "Checking that the instance_id exists and getting the instance dictionary"
3459 instanceDict = mydb.get_instance_scenario(instance_id, nfvo_tenant)
3460 #print yaml.safe_dump(instanceDict, indent=4, default_flow_style=False)
3461
3462 #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
3463 vims = get_vim(mydb, nfvo_tenant, instanceDict['datacenter_id'])
3464 if len(vims) == 0:
3465 raise NfvoException("datacenter '{}' not found".format(str(instanceDict['datacenter_id'])), HTTP_Not_Found)
3466 myvim = vims.values()[0]
3467
3468 if action_dict.get("create-vdu"):
3469 for vdu in action_dict["create-vdu"]:
3470 vdu_id = vdu.get("vdu-id")
3471 vdu_count = vdu.get("count", 1)
3472 # get from database TODO
3473 # insert tasks TODO
3474 pass
3475
3476 input_vnfs = action_dict.pop("vnfs", [])
3477 input_vms = action_dict.pop("vms", [])
3478 action_over_all = True if len(input_vnfs)==0 and len (input_vms)==0 else False
3479 vm_result = {}
3480 vm_error = 0
3481 vm_ok = 0
3482 for sce_vnf in instanceDict['vnfs']:
3483 for vm in sce_vnf['vms']:
3484 if not action_over_all:
3485 if sce_vnf['uuid'] not in input_vnfs and sce_vnf['vnf_name'] not in input_vnfs and \
3486 vm['uuid'] not in input_vms and vm['name'] not in input_vms:
3487 continue
3488 try:
3489 if "add_public_key" in action_dict:
3490 mgmt_access = {}
3491 if sce_vnf.get('mgmt_access'):
3492 mgmt_access = yaml.load(sce_vnf['mgmt_access'])
3493 ssh_access = mgmt_access['config-access']['ssh-access']
3494 tenant = mydb.get_rows_by_id('nfvo_tenants', nfvo_tenant)
3495 try:
3496 if ssh_access['required'] and ssh_access['default-user']:
3497 if 'ip_address' in vm:
3498 mgmt_ip = vm['ip_address'].split(';')
3499 password = mgmt_access['config-access'].get('password')
3500 priv_RO_key = decrypt_key(tenant[0]['encrypted_RO_priv_key'], tenant[0]['uuid'])
3501 myvim.inject_user_key(mgmt_ip[0], ssh_access['default-user'],
3502 action_dict['add_public_key'],
3503 password=password, ro_key=priv_RO_key)
3504 else:
3505 raise NfvoException("Unable to inject ssh key in vm: {} - Aborting".format(vm['uuid']),
3506 HTTP_Internal_Server_Error)
3507 except KeyError:
3508 raise NfvoException("Unable to inject ssh key in vm: {} - Aborting".format(vm['uuid']),
3509 HTTP_Internal_Server_Error)
3510 else:
3511 raise NfvoException("Unable to inject ssh key in vm: {} - Aborting".format(vm['uuid']),
3512 HTTP_Internal_Server_Error)
3513 else:
3514 data = myvim.action_vminstance(vm['vim_vm_id'], action_dict)
3515 if "console" in action_dict:
3516 if not global_config["http_console_proxy"]:
3517 vm_result[ vm['uuid'] ] = {"vim_result": 200,
3518 "description": "{protocol}//{ip}:{port}/{suffix}".format(
3519 protocol=data["protocol"],
3520 ip = data["server"],
3521 port = data["port"],
3522 suffix = data["suffix"]),
3523 "name":vm['name']
3524 }
3525 vm_ok +=1
3526 elif data["server"]=="127.0.0.1" or data["server"]=="localhost":
3527 vm_result[ vm['uuid'] ] = {"vim_result": -HTTP_Unauthorized,
3528 "description": "this console is only reachable by local interface",
3529 "name":vm['name']
3530 }
3531 vm_error+=1
3532 else:
3533 #print "console data", data
3534 try:
3535 console_thread = create_or_use_console_proxy_thread(data["server"], data["port"])
3536 vm_result[ vm['uuid'] ] = {"vim_result": 200,
3537 "description": "{protocol}//{ip}:{port}/{suffix}".format(
3538 protocol=data["protocol"],
3539 ip = global_config["http_console_host"],
3540 port = console_thread.port,
3541 suffix = data["suffix"]),
3542 "name":vm['name']
3543 }
3544 vm_ok +=1
3545 except NfvoException as e:
3546 vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)}
3547 vm_error+=1
3548
3549 else:
3550 vm_result[ vm['uuid'] ] = {"vim_result": 200, "description": "ok", "name":vm['name']}
3551 vm_ok +=1
3552 except vimconn.vimconnException as e:
3553 vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)}
3554 vm_error+=1
3555
3556 if vm_ok==0: #all goes wrong
3557 return vm_result
3558 else:
3559 return vm_result
3560
3561 def instance_action_get(mydb, nfvo_tenant, instance_id, action_id):
3562 filter={}
3563 if nfvo_tenant and nfvo_tenant != "any":
3564 filter["tenant_id"] = nfvo_tenant
3565 if instance_id and instance_id != "any":
3566 filter["instance_id"] = instance_id
3567 if action_id:
3568 filter["uuid"] = action_id
3569 rows = mydb.get_rows(FROM="instance_actions", WHERE=filter)
3570 if not rows and action_id:
3571 raise NfvoException("Not found any action with this criteria", HTTP_Not_Found)
3572 return {"ations": rows}
3573
3574
3575 def create_or_use_console_proxy_thread(console_server, console_port):
3576 #look for a non-used port
3577 console_thread_key = console_server + ":" + str(console_port)
3578 if console_thread_key in global_config["console_thread"]:
3579 #global_config["console_thread"][console_thread_key].start_timeout()
3580 return global_config["console_thread"][console_thread_key]
3581
3582 for port in global_config["console_port_iterator"]():
3583 #print "create_or_use_console_proxy_thread() port:", port
3584 if port in global_config["console_ports"]:
3585 continue
3586 try:
3587 clithread = cli.ConsoleProxyThread(global_config['http_host'], port, console_server, console_port)
3588 clithread.start()
3589 global_config["console_thread"][console_thread_key] = clithread
3590 global_config["console_ports"][port] = console_thread_key
3591 return clithread
3592 except cli.ConsoleProxyExceptionPortUsed as e:
3593 #port used, try with onoher
3594 continue
3595 except cli.ConsoleProxyException as e:
3596 raise NfvoException(str(e), HTTP_Bad_Request)
3597 raise NfvoException("Not found any free 'http_console_ports'", HTTP_Conflict)
3598
3599
3600 def check_tenant(mydb, tenant_id):
3601 '''check that tenant exists at database'''
3602 tenant = mydb.get_rows(FROM='nfvo_tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id})
3603 if not tenant:
3604 raise NfvoException("tenant '{}' not found".format(tenant_id), HTTP_Not_Found)
3605 return
3606
3607 def new_tenant(mydb, tenant_dict):
3608
3609 tenant_uuid = str(uuid4())
3610 tenant_dict['uuid'] = tenant_uuid
3611 try:
3612 pub_key, priv_key = create_RO_keypair(tenant_uuid)
3613 tenant_dict['RO_pub_key'] = pub_key
3614 tenant_dict['encrypted_RO_priv_key'] = priv_key
3615 mydb.new_row("nfvo_tenants", tenant_dict)
3616 except db_base_Exception as e:
3617 raise NfvoException("Error creating the new tenant: {} ".format(tenant_dict['name']) + str(e), HTTP_Internal_Server_Error)
3618 return tenant_uuid
3619
3620 def delete_tenant(mydb, tenant):
3621 #get nfvo_tenant info
3622
3623 tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant, 'tenant')
3624 mydb.delete_row_by_id("nfvo_tenants", tenant_dict['uuid'])
3625 return tenant_dict['uuid'] + " " + tenant_dict["name"]
3626
3627
3628 def new_datacenter(mydb, datacenter_descriptor):
3629 if "config" in datacenter_descriptor:
3630 datacenter_descriptor["config"]=yaml.safe_dump(datacenter_descriptor["config"],default_flow_style=True,width=256)
3631 #Check that datacenter-type is correct
3632 datacenter_type = datacenter_descriptor.get("type", "openvim");
3633 module_info = None
3634 try:
3635 module = "vimconn_" + datacenter_type
3636 pkg = __import__("osm_ro." + module)
3637 vim_conn = getattr(pkg, module)
3638 # module_info = imp.find_module(module, [__file__[:__file__.rfind("/")]])
3639 except (IOError, ImportError):
3640 # if module_info and module_info[0]:
3641 # file.close(module_info[0])
3642 raise NfvoException("Incorrect datacenter type '{}'. Plugin '{}'.py not installed".format(datacenter_type, module), HTTP_Bad_Request)
3643
3644 datacenter_id = mydb.new_row("datacenters", datacenter_descriptor, add_uuid=True)
3645 return datacenter_id
3646
3647
3648 def edit_datacenter(mydb, datacenter_id_name, datacenter_descriptor):
3649 # obtain data, check that only one exist
3650 datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id_name)
3651
3652 # edit data
3653 datacenter_id = datacenter['uuid']
3654 where={'uuid': datacenter['uuid']}
3655 remove_port_mapping = False
3656 if "config" in datacenter_descriptor:
3657 if datacenter_descriptor['config'] != None:
3658 try:
3659 new_config_dict = datacenter_descriptor["config"]
3660 #delete null fields
3661 to_delete=[]
3662 for k in new_config_dict:
3663 if new_config_dict[k] == None:
3664 to_delete.append(k)
3665 if k == 'sdn-controller':
3666 remove_port_mapping = True
3667
3668 config_text = datacenter.get("config")
3669 if not config_text:
3670 config_text = '{}'
3671 config_dict = yaml.load(config_text)
3672 config_dict.update(new_config_dict)
3673 #delete null fields
3674 for k in to_delete:
3675 del config_dict[k]
3676 except Exception as e:
3677 raise NfvoException("Bad format at datacenter:config " + str(e), HTTP_Bad_Request)
3678 if config_dict:
3679 datacenter_descriptor["config"] = yaml.safe_dump(config_dict, default_flow_style=True, width=256)
3680 else:
3681 datacenter_descriptor["config"] = None
3682 if remove_port_mapping:
3683 try:
3684 datacenter_sdn_port_mapping_delete(mydb, None, datacenter_id)
3685 except ovimException as e:
3686 logger.error("Error deleting datacenter-port-mapping " + str(e))
3687
3688 mydb.update_rows('datacenters', datacenter_descriptor, where)
3689 return datacenter_id
3690
3691
3692 def delete_datacenter(mydb, datacenter):
3693 #get nfvo_tenant info
3694 datacenter_dict = mydb.get_table_by_uuid_name('datacenters', datacenter, 'datacenter')
3695 mydb.delete_row_by_id("datacenters", datacenter_dict['uuid'])
3696 try:
3697 datacenter_sdn_port_mapping_delete(mydb, None, datacenter_dict['uuid'])
3698 except ovimException as e:
3699 logger.error("Error deleting datacenter-port-mapping " + str(e))
3700 return datacenter_dict['uuid'] + " " + datacenter_dict['name']
3701
3702
3703 def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None, config=None):
3704 #get datacenter info
3705 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter, vim_user=vim_username, vim_passwd=vim_password)
3706 datacenter_name = myvim["name"]
3707
3708 create_vim_tenant = True if not vim_tenant_id and not vim_tenant_name else False
3709
3710 # get nfvo_tenant info
3711 tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', nfvo_tenant)
3712 if vim_tenant_name==None:
3713 vim_tenant_name=tenant_dict['name']
3714
3715 #check that this association does not exist before
3716 tenants_datacenter_dict={"nfvo_tenant_id":tenant_dict['uuid'], "datacenter_id":datacenter_id }
3717 tenants_datacenters = mydb.get_rows(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict)
3718 if len(tenants_datacenters)>0:
3719 raise NfvoException("datacenter '{}' and tenant'{}' are already attached".format(datacenter_id, tenant_dict['uuid']), HTTP_Conflict)
3720
3721 vim_tenant_id_exist_atdb=False
3722 if not create_vim_tenant:
3723 where_={"datacenter_id": datacenter_id}
3724 if vim_tenant_id!=None:
3725 where_["vim_tenant_id"] = vim_tenant_id
3726 if vim_tenant_name!=None:
3727 where_["vim_tenant_name"] = vim_tenant_name
3728 #check if vim_tenant_id is already at database
3729 datacenter_tenants_dict = mydb.get_rows(FROM='datacenter_tenants', WHERE=where_)
3730 if len(datacenter_tenants_dict)>=1:
3731 datacenter_tenants_dict = datacenter_tenants_dict[0]
3732 vim_tenant_id_exist_atdb=True
3733 #TODO check if a field has changed and edit entry at datacenter_tenants at DB
3734 else: #result=0
3735 datacenter_tenants_dict = {}
3736 #insert at table datacenter_tenants
3737 else: #if vim_tenant_id==None:
3738 #create tenant at VIM if not provided
3739 try:
3740 vim_tenant_id = myvim.new_tenant(vim_tenant_name, "created by openmano for datacenter "+datacenter_name)
3741 except vimconn.vimconnException as e:
3742 raise NfvoException("Not possible to create vim_tenant {} at VIM: {}".format(vim_tenant_id, str(e)), HTTP_Internal_Server_Error)
3743 datacenter_tenants_dict = {}
3744 datacenter_tenants_dict["created"]="true"
3745
3746 #fill datacenter_tenants table
3747 if not vim_tenant_id_exist_atdb:
3748 datacenter_tenants_dict["vim_tenant_id"] = vim_tenant_id
3749 datacenter_tenants_dict["vim_tenant_name"] = vim_tenant_name
3750 datacenter_tenants_dict["user"] = vim_username
3751 datacenter_tenants_dict["passwd"] = vim_password
3752 datacenter_tenants_dict["datacenter_id"] = datacenter_id
3753 if config:
3754 datacenter_tenants_dict["config"] = yaml.safe_dump(config, default_flow_style=True, width=256)
3755 id_ = mydb.new_row('datacenter_tenants', datacenter_tenants_dict, add_uuid=True)
3756 datacenter_tenants_dict["uuid"] = id_
3757
3758 #fill tenants_datacenters table
3759 datacenter_tenant_id = datacenter_tenants_dict["uuid"]
3760 tenants_datacenter_dict["datacenter_tenant_id"] = datacenter_tenant_id
3761 mydb.new_row('tenants_datacenters', tenants_datacenter_dict)
3762 # create thread
3763 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_dict['uuid'], datacenter_id) # reload data
3764 thread_name = get_non_used_vim_name(datacenter_name, datacenter_id, tenant_dict['name'], tenant_dict['uuid'])
3765 new_thread = vim_thread.vim_thread(myvim, task_lock, thread_name, datacenter_name, datacenter_tenant_id,
3766 db=db, db_lock=db_lock, ovim=ovim)
3767 new_thread.start()
3768 thread_id = datacenter_tenants_dict["uuid"]
3769 vim_threads["running"][thread_id] = new_thread
3770 return datacenter_id
3771
3772
3773 def edit_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=None, vim_tenant_name=None,
3774 vim_username=None, vim_password=None, config=None):
3775 #Obtain the data of this datacenter_tenant_id
3776 vim_data = mydb.get_rows(
3777 SELECT=("datacenter_tenants.vim_tenant_name", "datacenter_tenants.vim_tenant_id", "datacenter_tenants.user",
3778 "datacenter_tenants.passwd", "datacenter_tenants.config"),
3779 FROM="datacenter_tenants JOIN tenants_datacenters ON datacenter_tenants.uuid=tenants_datacenters.datacenter_tenant_id",
3780 WHERE={"tenants_datacenters.nfvo_tenant_id": nfvo_tenant,
3781 "tenants_datacenters.datacenter_id": datacenter_id})
3782
3783 logger.debug(str(vim_data))
3784 if len(vim_data) < 1:
3785 raise NfvoException("Datacenter {} is not attached for tenant {}".format(datacenter_id, nfvo_tenant), HTTP_Conflict)
3786
3787 v = vim_data[0]
3788 if v['config']:
3789 v['config'] = yaml.load(v['config'])
3790
3791 if vim_tenant_id:
3792 v['vim_tenant_id'] = vim_tenant_id
3793 if vim_tenant_name:
3794 v['vim_tenant_name'] = vim_tenant_name
3795 if vim_username:
3796 v['user'] = vim_username
3797 if vim_password:
3798 v['passwd'] = vim_password
3799 if config:
3800 if not v['config']:
3801 v['config'] = {}
3802 v['config'].update(config)
3803
3804 logger.debug(str(v))
3805 deassociate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=v['vim_tenant_id'])
3806 associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=v['vim_tenant_id'], vim_tenant_name=v['vim_tenant_name'],
3807 vim_username=v['user'], vim_password=v['passwd'], config=v['config'])
3808
3809 return datacenter_id
3810
3811 def deassociate_datacenter_to_tenant(mydb, tenant_id, datacenter, vim_tenant_id=None):
3812 #get datacenter info
3813 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
3814
3815 #get nfvo_tenant info
3816 if not tenant_id or tenant_id=="any":
3817 tenant_uuid = None
3818 else:
3819 tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant_id)
3820 tenant_uuid = tenant_dict['uuid']
3821
3822 #check that this association exist before
3823 tenants_datacenter_dict={"datacenter_id":datacenter_id }
3824 if tenant_uuid:
3825 tenants_datacenter_dict["nfvo_tenant_id"] = tenant_uuid
3826 tenant_datacenter_list = mydb.get_rows(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict)
3827 if len(tenant_datacenter_list)==0 and tenant_uuid:
3828 raise NfvoException("datacenter '{}' and tenant '{}' are not attached".format(datacenter_id, tenant_dict['uuid']), HTTP_Not_Found)
3829
3830 #delete this association
3831 mydb.delete_row(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict)
3832
3833 #get vim_tenant info and deletes
3834 warning=''
3835 for tenant_datacenter_item in tenant_datacenter_list:
3836 vim_tenant_dict = mydb.get_table_by_uuid_name('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id'])
3837 #try to delete vim:tenant
3838 try:
3839 mydb.delete_row_by_id('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id'])
3840 if vim_tenant_dict['created']=='true':
3841 #delete tenant at VIM if created by NFVO
3842 try:
3843 myvim.delete_tenant(vim_tenant_dict['vim_tenant_id'])
3844 except vimconn.vimconnException as e:
3845 warning = "Not possible to delete vim_tenant_id {} from VIM: {} ".format(vim_tenant_dict['vim_tenant_id'], str(e))
3846 logger.warn(warning)
3847 except db_base_Exception as e:
3848 logger.error("Cannot delete datacenter_tenants " + str(e))
3849 pass # the error will be caused because dependencies, vim_tenant can not be deleted
3850 thread_id = tenant_datacenter_item["datacenter_tenant_id"]
3851 thread = vim_threads["running"][thread_id]
3852 thread.insert_task("exit")
3853 vim_threads["deleting"][thread_id] = thread
3854 return "datacenter {} detached. {}".format(datacenter_id, warning)
3855
3856
3857 def datacenter_action(mydb, tenant_id, datacenter, action_dict):
3858 #DEPRECATED
3859 #get datacenter info
3860 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
3861
3862 if 'net-update' in action_dict:
3863 try:
3864 nets = myvim.get_network_list(filter_dict={'shared': True, 'admin_state_up': True, 'status': 'ACTIVE'})
3865 #print content
3866 except vimconn.vimconnException as e:
3867 #logger.error("nfvo.datacenter_action() Not possible to get_network_list from VIM: %s ", str(e))
3868 raise NfvoException(str(e), HTTP_Internal_Server_Error)
3869 #update nets Change from VIM format to NFVO format
3870 net_list=[]
3871 for net in nets:
3872 net_nfvo={'datacenter_id': datacenter_id}
3873 net_nfvo['name'] = net['name']
3874 #net_nfvo['description']= net['name']
3875 net_nfvo['vim_net_id'] = net['id']
3876 net_nfvo['type'] = net['type'][0:6] #change from ('ptp','data','bridge_data','bridge_man') to ('bridge','data','ptp')
3877 net_nfvo['shared'] = net['shared']
3878 net_nfvo['multipoint'] = False if net['type']=='ptp' else True
3879 net_list.append(net_nfvo)
3880 inserted, deleted = mydb.update_datacenter_nets(datacenter_id, net_list)
3881 logger.info("Inserted %d nets, deleted %d old nets", inserted, deleted)
3882 return inserted
3883 elif 'net-edit' in action_dict:
3884 net = action_dict['net-edit'].pop('net')
3885 what = 'vim_net_id' if utils.check_valid_uuid(net) else 'name'
3886 result = mydb.update_rows('datacenter_nets', action_dict['net-edit'],
3887 WHERE={'datacenter_id':datacenter_id, what: net})
3888 return result
3889 elif 'net-delete' in action_dict:
3890 net = action_dict['net-deelte'].get('net')
3891 what = 'vim_net_id' if utils.check_valid_uuid(net) else 'name'
3892 result = mydb.delete_row(FROM='datacenter_nets',
3893 WHERE={'datacenter_id':datacenter_id, what: net})
3894 return result
3895
3896 else:
3897 raise NfvoException("Unknown action " + str(action_dict), HTTP_Bad_Request)
3898
3899
3900 def datacenter_edit_netmap(mydb, tenant_id, datacenter, netmap, action_dict):
3901 #get datacenter info
3902 datacenter_id, _ = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
3903
3904 what = 'uuid' if utils.check_valid_uuid(netmap) else 'name'
3905 result = mydb.update_rows('datacenter_nets', action_dict['netmap'],
3906 WHERE={'datacenter_id':datacenter_id, what: netmap})
3907 return result
3908
3909
3910 def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None):
3911 #get datacenter info
3912 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
3913 filter_dict={}
3914 if action_dict:
3915 action_dict = action_dict["netmap"]
3916 if 'vim_id' in action_dict:
3917 filter_dict["id"] = action_dict['vim_id']
3918 if 'vim_name' in action_dict:
3919 filter_dict["name"] = action_dict['vim_name']
3920 else:
3921 filter_dict["shared"] = True
3922
3923 try:
3924 vim_nets = myvim.get_network_list(filter_dict=filter_dict)
3925 except vimconn.vimconnException as e:
3926 #logger.error("nfvo.datacenter_new_netmap() Not possible to get_network_list from VIM: %s ", str(e))
3927 raise NfvoException(str(e), HTTP_Internal_Server_Error)
3928 if len(vim_nets)>1 and action_dict:
3929 raise NfvoException("more than two networks found, specify with vim_id", HTTP_Conflict)
3930 elif len(vim_nets)==0: # and action_dict:
3931 raise NfvoException("Not found a network at VIM with " + str(filter_dict), HTTP_Not_Found)
3932 net_list=[]
3933 for net in vim_nets:
3934 net_nfvo={'datacenter_id': datacenter_id}
3935 if action_dict and "name" in action_dict:
3936 net_nfvo['name'] = action_dict['name']
3937 else:
3938 net_nfvo['name'] = net['name']
3939 #net_nfvo['description']= net['name']
3940 net_nfvo['vim_net_id'] = net['id']
3941 net_nfvo['type'] = net['type'][0:6] #change from ('ptp','data','bridge_data','bridge_man') to ('bridge','data','ptp')
3942 net_nfvo['shared'] = net['shared']
3943 net_nfvo['multipoint'] = False if net['type']=='ptp' else True
3944 try:
3945 net_id = mydb.new_row("datacenter_nets", net_nfvo, add_uuid=True)
3946 net_nfvo["status"] = "OK"
3947 net_nfvo["uuid"] = net_id
3948 except db_base_Exception as e:
3949 if action_dict:
3950 raise
3951 else:
3952 net_nfvo["status"] = "FAIL: " + str(e)
3953 net_list.append(net_nfvo)
3954 return net_list
3955
3956 def get_sdn_net_id(mydb, tenant_id, datacenter, network_id):
3957 # obtain all network data
3958 try:
3959 if utils.check_valid_uuid(network_id):
3960 filter_dict = {"id": network_id}
3961 else:
3962 filter_dict = {"name": network_id}
3963
3964 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
3965 network = myvim.get_network_list(filter_dict=filter_dict)
3966 except vimconn.vimconnException as e:
3967 raise NfvoException("Not possible to get_sdn_net_id from VIM: {}".format(str(e)), e.http_code)
3968
3969 # ensure the network is defined
3970 if len(network) == 0:
3971 raise NfvoException("Network {} is not present in the system".format(network_id),
3972 HTTP_Bad_Request)
3973
3974 # ensure there is only one network with the provided name
3975 if len(network) > 1:
3976 raise NfvoException("Multiple networks present in vim identified by {}".format(network_id), HTTP_Bad_Request)
3977
3978 # ensure it is a dataplane network
3979 if network[0]['type'] != 'data':
3980 return None
3981
3982 # ensure we use the id
3983 network_id = network[0]['id']
3984
3985 # search in dabase mano_db in table instance nets for the sdn_net_id that corresponds to the vim_net_id==network_id
3986 # and with instance_scenario_id==NULL
3987 #search_dict = {'vim_net_id': network_id, 'instance_scenario_id': None}
3988 search_dict = {'vim_net_id': network_id}
3989
3990 try:
3991 #sdn_network_id = mydb.get_rows(SELECT=('sdn_net_id',), FROM='instance_nets', WHERE=search_dict)[0]['sdn_net_id']
3992 result = mydb.get_rows(SELECT=('sdn_net_id',), FROM='instance_nets', WHERE=search_dict)
3993 except db_base_Exception as e:
3994 raise NfvoException("db_base_Exception obtaining SDN network to associated to vim network {}".format(
3995 network_id) + str(e), HTTP_Internal_Server_Error)
3996
3997 sdn_net_counter = 0
3998 for net in result:
3999 if net['sdn_net_id'] != None:
4000 sdn_net_counter+=1
4001 sdn_net_id = net['sdn_net_id']
4002
4003 if sdn_net_counter == 0:
4004 return None
4005 elif sdn_net_counter == 1:
4006 return sdn_net_id
4007 else:
4008 raise NfvoException("More than one SDN network is associated to vim network {}".format(
4009 network_id), HTTP_Internal_Server_Error)
4010
4011 def get_sdn_controller_id(mydb, datacenter):
4012 # Obtain sdn controller id
4013 config = mydb.get_rows(SELECT=('config',), FROM='datacenters', WHERE={'uuid': datacenter})[0].get('config', '{}')
4014 if not config:
4015 return None
4016
4017 return yaml.load(config).get('sdn-controller')
4018
4019 def vim_net_sdn_attach(mydb, tenant_id, datacenter, network_id, descriptor):
4020 try:
4021 sdn_network_id = get_sdn_net_id(mydb, tenant_id, datacenter, network_id)
4022 if not sdn_network_id:
4023 raise NfvoException("No SDN network is associated to vim-network {}".format(network_id), HTTP_Internal_Server_Error)
4024
4025 #Obtain sdn controller id
4026 controller_id = get_sdn_controller_id(mydb, datacenter)
4027 if not controller_id:
4028 raise NfvoException("No SDN controller is set for datacenter {}".format(datacenter), HTTP_Internal_Server_Error)
4029
4030 #Obtain sdn controller info
4031 sdn_controller = ovim.show_of_controller(controller_id)
4032
4033 port_data = {
4034 'name': 'external_port',
4035 'net_id': sdn_network_id,
4036 'ofc_id': controller_id,
4037 'switch_dpid': sdn_controller['dpid'],
4038 'switch_port': descriptor['port']
4039 }
4040
4041 if 'vlan' in descriptor:
4042 port_data['vlan'] = descriptor['vlan']
4043 if 'mac' in descriptor:
4044 port_data['mac'] = descriptor['mac']
4045
4046 result = ovim.new_port(port_data)
4047 except ovimException as e:
4048 raise NfvoException("ovimException attaching SDN network {} to vim network {}".format(
4049 sdn_network_id, network_id) + str(e), HTTP_Internal_Server_Error)
4050 except db_base_Exception as e:
4051 raise NfvoException("db_base_Exception attaching SDN network to vim network {}".format(
4052 network_id) + str(e), HTTP_Internal_Server_Error)
4053
4054 return 'Port uuid: '+ result
4055
4056 def vim_net_sdn_detach(mydb, tenant_id, datacenter, network_id, port_id=None):
4057 if port_id:
4058 filter = {'uuid': port_id}
4059 else:
4060 sdn_network_id = get_sdn_net_id(mydb, tenant_id, datacenter, network_id)
4061 if not sdn_network_id:
4062 raise NfvoException("No SDN network is associated to vim-network {}".format(network_id),
4063 HTTP_Internal_Server_Error)
4064 #in case no port_id is specified only ports marked as 'external_port' will be detached
4065 filter = {'name': 'external_port', 'net_id': sdn_network_id}
4066
4067 try:
4068 port_list = ovim.get_ports(columns={'uuid'}, filter=filter)
4069 except ovimException as e:
4070 raise NfvoException("ovimException obtaining external ports for net {}. ".format(network_id) + str(e),
4071 HTTP_Internal_Server_Error)
4072
4073 if len(port_list) == 0:
4074 raise NfvoException("No ports attached to the network {} were found with the requested criteria".format(network_id),
4075 HTTP_Bad_Request)
4076
4077 port_uuid_list = []
4078 for port in port_list:
4079 try:
4080 port_uuid_list.append(port['uuid'])
4081 ovim.delete_port(port['uuid'])
4082 except ovimException as e:
4083 raise NfvoException("ovimException deleting port {} for net {}. ".format(port['uuid'], network_id) + str(e), HTTP_Internal_Server_Error)
4084
4085 return 'Detached ports uuid: {}'.format(','.join(port_uuid_list))
4086
4087 def vim_action_get(mydb, tenant_id, datacenter, item, name):
4088 #get datacenter info
4089 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
4090 filter_dict={}
4091 if name:
4092 if utils.check_valid_uuid(name):
4093 filter_dict["id"] = name
4094 else:
4095 filter_dict["name"] = name
4096 try:
4097 if item=="networks":
4098 #filter_dict['tenant_id'] = myvim['tenant_id']
4099 content = myvim.get_network_list(filter_dict=filter_dict)
4100
4101 if len(content) == 0:
4102 raise NfvoException("Network {} is not present in the system. ".format(name),
4103 HTTP_Bad_Request)
4104
4105 #Update the networks with the attached ports
4106 for net in content:
4107 sdn_network_id = get_sdn_net_id(mydb, tenant_id, datacenter, net['id'])
4108 if sdn_network_id != None:
4109 try:
4110 #port_list = ovim.get_ports(columns={'uuid', 'switch_port', 'vlan'}, filter={'name': 'external_port', 'net_id': sdn_network_id})
4111 port_list = ovim.get_ports(columns={'uuid', 'switch_port', 'vlan','name'}, filter={'net_id': sdn_network_id})
4112 except ovimException as e:
4113 raise NfvoException("ovimException obtaining external ports for net {}. ".format(network_id) + str(e), HTTP_Internal_Server_Error)
4114 #Remove field name and if port name is external_port save it as 'type'
4115 for port in port_list:
4116 if port['name'] == 'external_port':
4117 port['type'] = "External"
4118 del port['name']
4119 net['sdn_network_id'] = sdn_network_id
4120 net['sdn_attached_ports'] = port_list
4121
4122 elif item=="tenants":
4123 content = myvim.get_tenant_list(filter_dict=filter_dict)
4124 elif item == "images":
4125
4126 content = myvim.get_image_list(filter_dict=filter_dict)
4127 else:
4128 raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
4129 logger.debug("vim_action response %s", content) #update nets Change from VIM format to NFVO format
4130 if name and len(content)==1:
4131 return {item[:-1]: content[0]}
4132 elif name and len(content)==0:
4133 raise NfvoException("No {} found with ".format(item[:-1]) + " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), filter_dict.iteritems())),
4134 datacenter)
4135 else:
4136 return {item: content}
4137 except vimconn.vimconnException as e:
4138 print "vim_action Not possible to get_%s_list from VIM: %s " % (item, str(e))
4139 raise NfvoException("Not possible to get_{}_list from VIM: {}".format(item, str(e)), e.http_code)
4140
4141
4142 def vim_action_delete(mydb, tenant_id, datacenter, item, name):
4143 #get datacenter info
4144 if tenant_id == "any":
4145 tenant_id=None
4146
4147 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
4148 #get uuid name
4149 content = vim_action_get(mydb, tenant_id, datacenter, item, name)
4150 logger.debug("vim_action_delete vim response: " + str(content))
4151 items = content.values()[0]
4152 if type(items)==list and len(items)==0:
4153 raise NfvoException("Not found " + item, HTTP_Not_Found)
4154 elif type(items)==list and len(items)>1:
4155 raise NfvoException("Found more than one {} with this name. Use uuid.".format(item), HTTP_Not_Found)
4156 else: # it is a dict
4157 item_id = items["id"]
4158 item_name = str(items.get("name"))
4159
4160 try:
4161 if item=="networks":
4162 # If there is a SDN network associated to the vim-network, proceed to clear the relationship and delete it
4163 sdn_network_id = get_sdn_net_id(mydb, tenant_id, datacenter, item_id)
4164 if sdn_network_id != None:
4165 #Delete any port attachment to this network
4166 try:
4167 port_list = ovim.get_ports(columns={'uuid'}, filter={'net_id': sdn_network_id})
4168 except ovimException as e:
4169 raise NfvoException(
4170 "ovimException obtaining external ports for net {}. ".format(network_id) + str(e),
4171 HTTP_Internal_Server_Error)
4172
4173 # By calling one by one all ports to be detached we ensure that not only the external_ports get detached
4174 for port in port_list:
4175 vim_net_sdn_detach(mydb, tenant_id, datacenter, item_id, port['uuid'])
4176
4177 #Delete from 'instance_nets' the correspondence between the vim-net-id and the sdn-net-id
4178 try:
4179 mydb.delete_row(FROM='instance_nets', WHERE={'instance_scenario_id': None, 'sdn_net_id': sdn_network_id, 'vim_net_id': item_id})
4180 except db_base_Exception as e:
4181 raise NfvoException("Error deleting correspondence for VIM/SDN dataplane networks{}: ".format(correspondence) +
4182 str(e), HTTP_Internal_Server_Error)
4183
4184 #Delete the SDN network
4185 try:
4186 ovim.delete_network(sdn_network_id)
4187 except ovimException as e:
4188 logger.error("ovimException deleting SDN network={} ".format(sdn_network_id) + str(e), exc_info=True)
4189 raise NfvoException("ovimException deleting SDN network={} ".format(sdn_network_id) + str(e),
4190 HTTP_Internal_Server_Error)
4191
4192 content = myvim.delete_network(item_id)
4193 elif item=="tenants":
4194 content = myvim.delete_tenant(item_id)
4195 elif item == "images":
4196 content = myvim.delete_image(item_id)
4197 else:
4198 raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
4199 except vimconn.vimconnException as e:
4200 #logger.error( "vim_action Not possible to delete_{} {}from VIM: {} ".format(item, name, str(e)))
4201 raise NfvoException("Not possible to delete_{} {} from VIM: {}".format(item, name, str(e)), e.http_code)
4202
4203 return "{} {} {} deleted".format(item[:-1], item_id,item_name)
4204
4205
4206 def vim_action_create(mydb, tenant_id, datacenter, item, descriptor):
4207 #get datacenter info
4208 logger.debug("vim_action_create descriptor %s", str(descriptor))
4209 if tenant_id == "any":
4210 tenant_id=None
4211 datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
4212 try:
4213 if item=="networks":
4214 net = descriptor["network"]
4215 net_name = net.pop("name")
4216 net_type = net.pop("type", "bridge")
4217 net_public = net.pop("shared", False)
4218 net_ipprofile = net.pop("ip_profile", None)
4219 net_vlan = net.pop("vlan", None)
4220 content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, vlan=net_vlan) #, **net)
4221
4222 #If the datacenter has a SDN controller defined and the network is of dataplane type, then create the sdn network
4223 if get_sdn_controller_id(mydb, datacenter) != None and (net_type == 'data' or net_type == 'ptp'):
4224 try:
4225 sdn_network = {}
4226 sdn_network['vlan'] = net_vlan
4227 sdn_network['type'] = net_type
4228 sdn_network['name'] = net_name
4229 ovim_content = ovim.new_network(sdn_network)
4230 except ovimException as e:
4231 self.logger.error("ovimException creating SDN network={} ".format(
4232 sdn_network) + str(e), exc_info=True)
4233 raise NfvoException("ovimException creating SDN network={} ".format(sdn_network) + str(e),
4234 HTTP_Internal_Server_Error)
4235
4236 # Save entry in in dabase mano_db in table instance_nets to stablish a dictionary vim_net_id <->sdn_net_id
4237 # use instance_scenario_id=None to distinguish from real instaces of nets
4238 correspondence = {'instance_scenario_id': None, 'sdn_net_id': ovim_content, 'vim_net_id': content}
4239 #obtain datacenter_tenant_id
4240 correspondence['datacenter_tenant_id'] = mydb.get_rows(SELECT=('uuid',), FROM='datacenter_tenants', WHERE={'datacenter_id': datacenter})[0]['uuid']
4241
4242 try:
4243 mydb.new_row('instance_nets', correspondence, add_uuid=True)
4244 except db_base_Exception as e:
4245 raise NfvoException("Error saving correspondence for VIM/SDN dataplane networks{}: ".format(correspondence) +
4246 str(e), HTTP_Internal_Server_Error)
4247 elif item=="tenants":
4248 tenant = descriptor["tenant"]
4249 content = myvim.new_tenant(tenant["name"], tenant.get("description"))
4250 else:
4251 raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
4252 except vimconn.vimconnException as e:
4253 raise NfvoException("Not possible to create {} at VIM: {}".format(item, str(e)), e.http_code)
4254
4255 return vim_action_get(mydb, tenant_id, datacenter, item, content)
4256
4257 def sdn_controller_create(mydb, tenant_id, sdn_controller):
4258 data = ovim.new_of_controller(sdn_controller)
4259 logger.debug('New SDN controller created with uuid {}'.format(data))
4260 return data
4261
4262 def sdn_controller_update(mydb, tenant_id, controller_id, sdn_controller):
4263 data = ovim.edit_of_controller(controller_id, sdn_controller)
4264 msg = 'SDN controller {} updated'.format(data)
4265 logger.debug(msg)
4266 return msg
4267
4268 def sdn_controller_list(mydb, tenant_id, controller_id=None):
4269 if controller_id == None:
4270 data = ovim.get_of_controllers()
4271 else:
4272 data = ovim.show_of_controller(controller_id)
4273
4274 msg = 'SDN controller list:\n {}'.format(data)
4275 logger.debug(msg)
4276 return data
4277
4278 def sdn_controller_delete(mydb, tenant_id, controller_id):
4279 select_ = ('uuid', 'config')
4280 datacenters = mydb.get_rows(FROM='datacenters', SELECT=select_)
4281 for datacenter in datacenters:
4282 if datacenter['config']:
4283 config = yaml.load(datacenter['config'])
4284 if 'sdn-controller' in config and config['sdn-controller'] == controller_id:
4285 raise NfvoException("SDN controller {} is in use by datacenter {}".format(controller_id, datacenter['uuid']), HTTP_Conflict)
4286
4287 data = ovim.delete_of_controller(controller_id)
4288 msg = 'SDN controller {} deleted'.format(data)
4289 logger.debug(msg)
4290 return msg
4291
4292 def datacenter_sdn_port_mapping_set(mydb, tenant_id, datacenter_id, sdn_port_mapping):
4293 controller = mydb.get_rows(FROM="datacenters", SELECT=("config",), WHERE={"uuid":datacenter_id})
4294 if len(controller) < 1:
4295 raise NfvoException("Datacenter {} not present in the database".format(datacenter_id), HTTP_Not_Found)
4296
4297 try:
4298 sdn_controller_id = yaml.load(controller[0]["config"])["sdn-controller"]
4299 except:
4300 raise NfvoException("The datacenter {} has not an SDN controller associated".format(datacenter_id), HTTP_Bad_Request)
4301
4302 sdn_controller = ovim.show_of_controller(sdn_controller_id)
4303 switch_dpid = sdn_controller["dpid"]
4304
4305 maps = list()
4306 for compute_node in sdn_port_mapping:
4307 #element = {"ofc_id": sdn_controller_id, "region": datacenter_id, "switch_dpid": switch_dpid}
4308 element = dict()
4309 element["compute_node"] = compute_node["compute_node"]
4310 for port in compute_node["ports"]:
4311 element["pci"] = port.get("pci")
4312 element["switch_port"] = port.get("switch_port")
4313 element["switch_mac"] = port.get("switch_mac")
4314 if not element["pci"] or not (element["switch_port"] or element["switch_mac"]):
4315 raise NfvoException ("The mapping must contain the 'pci' and at least one of the elements 'switch_port'"
4316 " or 'switch_mac'", HTTP_Bad_Request)
4317 maps.append(dict(element))
4318
4319 return ovim.set_of_port_mapping(maps, ofc_id=sdn_controller_id, switch_dpid=switch_dpid, region=datacenter_id)
4320
4321 def datacenter_sdn_port_mapping_list(mydb, tenant_id, datacenter_id):
4322 maps = ovim.get_of_port_mappings(db_filter={"region": datacenter_id})
4323
4324 result = {
4325 "sdn-controller": None,
4326 "datacenter-id": datacenter_id,
4327 "dpid": None,
4328 "ports_mapping": list()
4329 }
4330
4331 datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id)
4332 if datacenter['config']:
4333 config = yaml.load(datacenter['config'])
4334 if 'sdn-controller' in config:
4335 controller_id = config['sdn-controller']
4336 sdn_controller = sdn_controller_list(mydb, tenant_id, controller_id)
4337 result["sdn-controller"] = controller_id
4338 result["dpid"] = sdn_controller["dpid"]
4339
4340 if result["sdn-controller"] == None:
4341 raise NfvoException("SDN controller is not defined for datacenter {}".format(datacenter_id), HTTP_Bad_Request)
4342 if result["dpid"] == None:
4343 raise NfvoException("It was not possible to determine DPID for SDN controller {}".format(result["sdn-controller"]),
4344 HTTP_Internal_Server_Error)
4345
4346 if len(maps) == 0:
4347 return result
4348
4349 ports_correspondence_dict = dict()
4350 for link in maps:
4351 if result["sdn-controller"] != link["ofc_id"]:
4352 raise NfvoException("The sdn-controller specified for different port mappings differ", HTTP_Internal_Server_Error)
4353 if result["dpid"] != link["switch_dpid"]:
4354 raise NfvoException("The dpid specified for different port mappings differ", HTTP_Internal_Server_Error)
4355 element = dict()
4356 element["pci"] = link["pci"]
4357 if link["switch_port"]:
4358 element["switch_port"] = link["switch_port"]
4359 if link["switch_mac"]:
4360 element["switch_mac"] = link["switch_mac"]
4361
4362 if not link["compute_node"] in ports_correspondence_dict:
4363 content = dict()
4364 content["compute_node"] = link["compute_node"]
4365 content["ports"] = list()
4366 ports_correspondence_dict[link["compute_node"]] = content
4367
4368 ports_correspondence_dict[link["compute_node"]]["ports"].append(element)
4369
4370 for key in sorted(ports_correspondence_dict):
4371 result["ports_mapping"].append(ports_correspondence_dict[key])
4372
4373 return result
4374
4375 def datacenter_sdn_port_mapping_delete(mydb, tenant_id, datacenter_id):
4376 return ovim.clear_of_port_mapping(db_filter={"region":datacenter_id})
4377
4378 def create_RO_keypair(tenant_id):
4379 """
4380 Creates a public / private keys for a RO tenant and returns their values
4381 Params:
4382 tenant_id: ID of the tenant
4383 Return:
4384 public_key: Public key for the RO tenant
4385 private_key: Encrypted private key for RO tenant
4386 """
4387
4388 bits = 2048
4389 key = RSA.generate(bits)
4390 try:
4391 public_key = key.publickey().exportKey('OpenSSH')
4392 if isinstance(public_key, ValueError):
4393 raise NfvoException("Unable to create public key: {}".format(public_key), HTTP_Internal_Server_Error)
4394 private_key = key.exportKey(passphrase=tenant_id, pkcs=8)
4395 except (ValueError, NameError) as e:
4396 raise NfvoException("Unable to create private key: {}".format(e), HTTP_Internal_Server_Error)
4397 return public_key, private_key
4398
4399 def decrypt_key (key, tenant_id):
4400 """
4401 Decrypts an encrypted RSA key
4402 Params:
4403 key: Private key to be decrypted
4404 tenant_id: ID of the tenant
4405 Return:
4406 unencrypted_key: Unencrypted private key for RO tenant
4407 """
4408 try:
4409 key = RSA.importKey(key,tenant_id)
4410 unencrypted_key = key.exportKey('PEM')
4411 if isinstance(unencrypted_key, ValueError):
4412 raise NfvoException("Unable to decrypt the private key: {}".format(unencrypted_key), HTTP_Internal_Server_Error)
4413 except ValueError as e:
4414 raise NfvoException("Unable to decrypt the private key: {}".format(e), HTTP_Internal_Server_Error)
4415 return unencrypted_key