v0.4.48 multisite implementation

Change-Id: I98b0d2f6e9b20691c0b9dfd424212d4a27572ec7
Signed-off-by: tierno <alfonso.tiernosepulveda@telefonica.com>

diff --git a/database_utils/migrate_mano_db.sh b/database_utils/migrate_mano_db.sh
index 00d6721..b98a39b 100755 (executable)
--- a/database_utils/migrate_mano_db.sh
+++ b/database_utils/migrate_mano_db.sh
@@ -603,7 +603,7 @@ function upgrade_to_13(){
     echo "ALTER TABLE instance_scenarios ADD COLUMN cloud_config MEDIUMTEXT NULL DEFAULT NULL AFTER modified_at;"  | $DBCMD || ! echo "ERROR. Aborted!" || exit -1
     echo "INSERT INTO schema_version (version_int, version, openmano_ver, comments, date) VALUES (13, '0.13', '0.4.47', 'insert cloud-config at scenarios,instance_scenarios', '2016-08-30');" | $DBCMD || ! echo "ERROR. Aborted!" || exit -1
 }
-function downgrade_from_12(){
+function downgrade_from_13(){
     echo "    downgrade database from version 0.13 to version 0.12"
     echo "      remove cloud_config at 'scenarios', 'instance_scenarios'"
     echo "ALTER TABLE scenarios DROP COLUMN cloud_config;"  | $DBCMD || ! echo "ERROR. Aborted!" || exit -1

diff --git a/instance-scenarios/examples/instance-creation-complex2.yaml b/instance-scenarios/examples/instance-creation-complex2.yaml
new file mode 100644 (file)
index 0000000..e4ebb04
--- /dev/null
+++ b/instance-scenarios/examples/instance-creation-complex2.yaml
@@ -0,0 +1,55 @@
+##
+# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
+# This file is part of openmano
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: nfvlabs@tid.es
+##
+---
+schema_version:  "0.1"
+instance:
+  name:          complex2-instance
+  description:   Example of multisite deployment
+  datacenter:    TEST-dc           #needed a default datacenter
+  scenario:      complex2
+  vnfs: 
+    VNF2vms:                        # vnf name in the scenario
+      datacenter: TEST-dc           #by default is datacenter above
+    VNF3:
+      datacenter: openstack
+  networks: 
+    dataconn1:
+      sites:
+      -   datacenter: openstack 
+          netmap-create: null
+          netmap-use: net-corpA
+      -   datacenter: TEST-dc 
+          netmap-use: data_net
+    dataconn2:
+      sites:
+      -   datacenter: openstack 
+          netmap-create: null
+          netmap-use: net-corpA
+      -   datacenter: TEST-dc 
+          netmap-create: datacon
+    default:
+      sites:
+      -   datacenter: openstack 
+          netmap-use: default
+      -   datacenter: TEST-dc 
+          netmap-use: default
+
+

diff --git a/nfvo.py b/nfvo.py
index ecfe03e..59c2dca 100644 (file)
--- a/nfvo.py
+++ b/nfvo.py
@@ -92,10 +92,9 @@ def get_imagelist(mydb, vnf_id, nfvo_tenant=None):
 
 def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, vim_tenant=None):
     '''Obtain a dictionary of VIM (datacenter) classes with some of the input parameters
-    return result, content:
-        <0, error_text upon error
-        NUMBER, dictionary with datacenter_id: vim_class with these keys: 
+    return dictionary with {datacenter_id: vim_class, ... }. vim_class contain: 
             'nfvo_tenant_id','datacenter_id','vim_tenant_id','vim_url','vim_url_admin','datacenter_name','type','user','passwd'
+        raise exception upon error
     '''
     WHERE_dict={}
     if nfvo_tenant     is not None:  WHERE_dict['nfvo_tenant_id'] = nfvo_tenant
@@ -1337,60 +1336,88 @@ def unify_cloud_config(cloud_config):
     for index in index_to_delete:
         del users[index]
 
-def create_instance(mydb, tenant_id, instance_dict):
-    #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
-    logger.debug("Creating instance...")
-    scenario = instance_dict["scenario"]
+def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None):
     datacenter_id = None
-    datacenter_name=None
-    datacenter = instance_dict.get("datacenter")
-    if datacenter:
-        if utils.check_valid_uuid(datacenter): 
-            datacenter_id = datacenter
+    datacenter_name = None
+    if datacenter_id_name:
+        if utils.check_valid_uuid(datacenter_id_name): 
+            datacenter_id = datacenter_id_name
         else:
-            datacenter_name = datacenter
+            datacenter_name = datacenter_id_name
     vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, vim_tenant=None)
     if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(str(datacenter)), HTTP_Not_Found)
+        raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found)
     elif len(vims)>1:
         #print "nfvo.datacenter_action() error. Several datacenters found"
         raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
-    myvim = vims.values()[0]
+    return vims.keys()[0], vims.values()[0]
+
+def create_instance(mydb, tenant_id, instance_dict):
+    #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
+    logger.debug("Creating instance...")
+    scenario = instance_dict["scenario"]
+    
+    #find main datacenter
+    myvims = {}
+    datacenter = instance_dict.get("datacenter")
+    default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
+    myvims[default_datacenter_id] = vim
     #myvim_tenant = myvim['tenant_id']
-    datacenter_id = myvim['id']
-    datacenter_name = myvim['name']
-    datacenter_tenant_id = myvim['config']['datacenter_tenant_id']
+#    default_datacenter_name = vim['name']
+    default_datacenter_tenant_id = vim['config']['datacenter_tenant_id']    #TODO revisar
     rollbackList=[]
     
     #print "Checking that the scenario exists and getting the scenario dictionary"
-    scenarioDict = mydb.get_scenario(scenario, tenant_id, datacenter_id)
-    scenarioDict['datacenter_tenant_id'] = datacenter_tenant_id
-    scenarioDict['datacenter_id'] = datacenter_id
+    scenarioDict = mydb.get_scenario(scenario, tenant_id, default_datacenter_id)
+    scenarioDict['datacenter_tenant_id'] = default_datacenter_tenant_id
+    scenarioDict['datacenter_id'] = default_datacenter_id
    
     auxNetDict = {}   #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id
     auxNetDict['scenario'] = {}
     
-    #print "scenario dict: ",yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) 
+    print "scenario dict: ",yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)  #TODO quitar 
     instance_name = instance_dict["name"]
     instance_description = instance_dict.get("description")
     try:
     #0 check correct parameters
-        for descriptor_net in instance_dict.get("networks",{}).keys():
+        for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems():
             found=False
             for scenario_net in scenarioDict['nets']:
-                if descriptor_net == scenario_net["name"]:
+                if net_name == scenario_net["name"]:
                     found = True
                     break
             if not found:
-                raise NfvoException("Invalid scenario network name '{}' at instance:networks".format(descriptor_net), HTTP_Bad_Request)
-        for descriptor_vnf in instance_dict.get("vnfs",{}).keys():
+                raise NfvoException("Invalid scenario network name '{}' at instance:networks".format(net_name), HTTP_Bad_Request)
+            if "sites" not in net_instance_desc:
+                net_instance_desc["sites"] = [ {} ]
+            site_without_datacenter_field = False
+            for site in net_instance_desc["sites"]:
+                if site.get("datacenter"):
+                    if site["datacenter"] not in myvims:
+                        #Add this datacenter to myvims
+                        d, v = get_datacenter_by_name_uuid(mydb, tenant_id, site["datacenter"])
+                        myvims[d] = v
+                        site["datacenter"]  = d #change name to id
+                else:
+                    if site_without_datacenter_field:
+                        raise NfvoException("Found more than one entries without datacenter field at instance:networks:{}:sites".format(net_name), HTTP_Bad_Request)
+                    site_without_datacenter_field = True
+                    site["datacenter"]  = default_datacenter_id #change name to id
+                    
+        for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).iteritems():
             found=False
             for scenario_vnf in scenarioDict['vnfs']:
-                if descriptor_vnf == scenario_vnf['name']:
+                if vnf_name == scenario_vnf['name']:
                     found = True
                     break
             if not found:
-                raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(descriptor_vnf), HTTP_Bad_Request)
+                raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_instance_desc), HTTP_Bad_Request)
+            if "datacenter" in vnf_instance_desc:
+            #Add this datacenter to myvims
+                if vnf_instance_desc["datacenter"] not in myvims:
+                    d, v = get_datacenter_by_name_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"])
+                    myvims[d] = v
+                    scenario_vnf["datacenter"] = d #change name to id
     #0.1 parse cloud-config parameters
         cloud_config = scenarioDict.get("cloud-config", {})
         if instance_dict.get("cloud-config"):
@@ -1403,81 +1430,100 @@ def create_instance(mydb, tenant_id, instance_dict):
         
     #1. Creating new nets (sce_nets) in the VIM"
         for sce_net in scenarioDict['nets']:
+            sce_net["vim_id_sites"]={}
             descriptor_net =  instance_dict.get("networks",{}).get(sce_net["name"],{})
-            net_name = descriptor_net.get("name")
-            net_type = sce_net['type']
-            lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True
-            if sce_net["external"]:
-                if not net_name:
-                    net_name = sce_net["name"] 
-                if "netmap-use" in descriptor_net or "netmap-create" in descriptor_net:
-                    create_network = False
-                    lookfor_network = False
-                    if "netmap-use" in descriptor_net:
+            net_name = descriptor_net.get("vim-network-name")
+            auxNetDict['scenario'][sce_net['uuid']] = {}
+
+            sites = descriptor_net.get("sites", [ {} ])
+            for site in sites:
+                if site.get("datacenter"):
+                    vim = myvims[ site["datacenter"] ]
+                    datacenter_id = site["datacenter"]
+                else:
+                    vim = myvims[ default_datacenter_id ]
+                    datacenter_id = default_datacenter_id
+                
+                net_type = sce_net['type']
+                lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True
+                if sce_net["external"]:
+                    if not net_name:
+                        net_name = sce_net["name"] 
+                    if "netmap-use" in site or "netmap-create" in site:
+                        create_network = False
+                        lookfor_network = False
+                        if "netmap-use" in site:
+                            lookfor_network = True
+                            if utils.check_valid_uuid(site["netmap-use"]):
+                                filter_text = "scenario id '%s'" % site["netmap-use"]
+                                lookfor_filter["id"] = site["netmap-use"]
+                            else: 
+                                filter_text = "scenario name '%s'" % site["netmap-use"]
+                                lookfor_filter["name"] = site["netmap-use"]
+                        if "netmap-create" in site:
+                            create_network = True
+                            net_vim_name = net_name
+                            if site["netmap-create"]:
+                                net_vim_name = site["netmap-create"]
+                            
+                    elif sce_net['vim_id'] != None:
+                        #there is a netmap at datacenter_nets database   #TODO REVISE!!!!
+                        create_network = False
                         lookfor_network = True
-                        if utils.check_valid_uuid(descriptor_net["netmap-use"]):
-                            filter_text = "scenario id '%s'" % descriptor_net["netmap-use"]
-                            lookfor_filter["id"] = descriptor_net["netmap-use"]
-                        else: 
-                            filter_text = "scenario name '%s'" % descriptor_net["netmap-use"]
-                            lookfor_filter["name"] = descriptor_net["netmap-use"]
-                    if "netmap-create" in descriptor_net:
+                        lookfor_filter["id"] = sce_net['vim_id']
+                        filter_text = "vim_id '%s' datacenter_netmap name '%s'. Try to reload vims with datacenter-net-update" % (sce_net['vim_id'], sce_net["name"])
+                        #look for network at datacenter and return error
+                    else:
+                        #There is not a netmap, look at datacenter for a net with this name and create if not found
                         create_network = True
-                        net_vim_name = net_name
-                        if descriptor_net["netmap-create"]:
-                            net_vim_name= descriptor_net["netmap-create"]
-                        
-                elif sce_net['vim_id'] != None:
-                    #there is a netmap at datacenter_nets database
-                    create_network = False
-                    lookfor_network = True
-                    lookfor_filter["id"] = sce_net['vim_id']
-                    filter_text = "vim_id '%s' datacenter_netmap name '%s'. Try to reload vims with datacenter-net-update" % (sce_net['vim_id'], sce_net["name"])
-                    #look for network at datacenter and return error
+                        lookfor_network = True
+                        lookfor_filter["name"] = sce_net["name"]
+                        net_vim_name = sce_net["name"]
+                        filter_text = "scenario name '%s'" % sce_net["name"]
                 else:
-                    #There is not a netmap, look at datacenter for a net with this name and create if not found
+                    if not net_name:
+                        net_name = "%s.%s" %(instance_name, sce_net["name"])
+                        net_name = net_name[:255]     #limit length
+                    net_vim_name = net_name
                     create_network = True
-                    lookfor_network = True
-                    lookfor_filter["name"] = sce_net["name"]
-                    net_vim_name = sce_net["name"]
-                    filter_text = "scenario name '%s'" % sce_net["name"]
-            else:
-                if not net_name:
-                    net_name = "%s.%s" %(instance_name, sce_net["name"])
-                    net_name = net_name[:255]     #limit length
-                net_vim_name = net_name
-                create_network = True
-                lookfor_network = False
-                
-            if lookfor_network:
-                vim_nets = myvim.get_network_list(filter_dict=lookfor_filter)
-                if len(vim_nets) > 1:
-                    raise NfvoException("More than one candidate VIM network found for " + filter_text, HTTP_Bad_Request )
-                elif len(vim_nets) == 0:
-                    if not create_network:
-                        raise NfvoException("No candidate VIM network found for " + filter_text, HTTP_Bad_Request )
-                else:
-                    sce_net['vim_id'] = vim_nets[0]['id']
-                    auxNetDict['scenario'][sce_net['uuid']] = vim_nets[0]['id']
-                    create_network = False
-            if create_network:
-                #if network is not external
-                network_id = myvim.new_network(net_vim_name, net_type)
-                sce_net['vim_id'] = network_id
-                auxNetDict['scenario'][sce_net['uuid']] = network_id
-                rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id})
+                    lookfor_network = False
+                    
+                if lookfor_network:
+                    vim_nets = vim.get_network_list(filter_dict=lookfor_filter)
+                    if len(vim_nets) > 1:
+                        raise NfvoException("More than one candidate VIM network found for " + filter_text, HTTP_Bad_Request )
+                    elif len(vim_nets) == 0:
+                        if not create_network:
+                            raise NfvoException("No candidate VIM network found for " + filter_text, HTTP_Bad_Request )
+                    else:
+                        sce_net["vim_id_sites"][datacenter_id] = vim_nets[0]['id']
+                        
+                        auxNetDict['scenario'][sce_net['uuid']][datacenter_id] = vim_nets[0]['id']
+                        create_network = False
+                if create_network:
+                    #if network is not external
+                    network_id = vim.new_network(net_vim_name, net_type)
+                    sce_net["vim_id_sites"][datacenter_id] = network_id
+                    auxNetDict['scenario'][sce_net['uuid']][datacenter_id] = network_id
+                    rollbackList.append({'what':'network', 'where':'vim', 'vim_id':datacenter_id, 'uuid':network_id})
         
     #2. Creating new nets (vnf internal nets) in the VIM"
         #For each vnf net, we create it and we add it to instanceNetlist.
         for sce_vnf in scenarioDict['vnfs']:
             for net in sce_vnf['nets']:
+                if sce_vnf.get("datacenter"):
+                    vim = myvims[ sce_vnf["datacenter"] ]
+                    datacenter_id = sce_vnf["datacenter"]
+                else:
+                    vim = myvims[ default_datacenter_id ]
+                    datacenter_id = default_datacenter_id
                 descriptor_net =  instance_dict.get("vnfs",{}).get(sce_vnf["name"],{})
                 net_name = descriptor_net.get("name")
                 if not net_name:
                     net_name = "%s.%s" %(instance_name, net["name"])
                     net_name = net_name[:255]     #limit length
                 net_type = net['type']
-                network_id = myvim.new_network(net_name, net_type)
+                network_id = vim.new_network(net_name, net_type)
                 net['vim_id'] = network_id
                 if sce_vnf['uuid'] not in auxNetDict:
                     auxNetDict[sce_vnf['uuid']] = {}
@@ -1490,6 +1536,14 @@ def create_instance(mydb, tenant_id, instance_dict):
     #3. Creating new vm instances in the VIM
         #myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
         for sce_vnf in scenarioDict['vnfs']:
+            if sce_vnf.get("datacenter"):
+                vim = myvims[ sce_vnf["datacenter"] ]
+                datacenter_id = sce_vnf["datacenter"]
+            else:
+                vim = myvims[ default_datacenter_id ]
+                datacenter_id = default_datacenter_id
+            sce_vnf["datacenter_id"] =  datacenter_id
+            sce_vnf["datacenter_tenant_id"] = vim['config']['datacenter_tenant_id']
             i = 0
             for vm in sce_vnf['vms']:
                 i += 1
@@ -1501,14 +1555,14 @@ def create_instance(mydb, tenant_id, instance_dict):
                 myVMDict['name'] = myVMDict['name'][0:255] #limit name length
                 #create image at vim in case it not exist
                 image_dict = mydb.get_table_by_uuid_name("images", vm['image_id'])
-                image_id = create_or_use_image(mydb, vims, image_dict, [], True)                
+                image_id = create_or_use_image(mydb, {datacenter_id: vim}, image_dict, [], True)                
                 vm['vim_image_id'] = image_id
                     
                 #create flavor at vim in case it not exist
                 flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id'])
                 if flavor_dict['extended']!=None:
                     flavor_dict['extended']= yaml.load(flavor_dict['extended'])
-                flavor_id = create_or_use_flavor(mydb, vims, flavor_dict, rollbackList, True)                
+                flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True)                
                 vm['vim_flavor_id'] = flavor_id
                 
                 myVMDict['imageRef'] = vm['vim_image_id']
@@ -1556,7 +1610,7 @@ def create_instance(mydb, tenant_id, instance_dict):
                             #print iface
                             #print vnf_iface
                             if vnf_iface['interface_id']==iface['uuid']:
-                                netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ]
+                                netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id]
                                 break
                     else:
                         netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ]
@@ -1569,7 +1623,7 @@ def create_instance(mydb, tenant_id, instance_dict):
                 #print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False)
                 #print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False)
                 #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
-                vm_id = myvim.new_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None),
+                vm_id = vim.new_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None),
                         myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks'], cloud_config = cloud_config)
                 vm['vim_id'] = vm_id
                 rollbackList.append({'what':'vm','where':'vim','vim_id':datacenter_id,'uuid':vm_id})
@@ -1581,12 +1635,12 @@ def create_instance(mydb, tenant_id, instance_dict):
                                 iface["vim_id"]=net["vim_id"]
                                 break
         logger.debug("create_instance Deployment done")
-        #print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)
+        print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)
         #r,c = mydb.new_instance_scenario_as_a_whole(nfvo_tenant,scenarioDict['name'],scenarioDict)
         instance_id = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_name, instance_description, scenarioDict)
         return mydb.get_instance_scenario(instance_id)
     except (NfvoException, vimconn.vimconnException,db_base_Exception)  as e:
-        message = rollback(mydb, vims, rollbackList)
+        message = rollback(mydb, myvims, rollbackList)
         if isinstance(e, db_base_Exception):
             error_text = "database Exception"
         elif isinstance(e, vimconn.vimconnException):
@@ -1655,7 +1709,7 @@ def delete_instance(mydb, tenant_id, instance_id):
         except vimconn.vimconnNotFoundException as e:
             error_msg+="\n    NET id={} not found at VIM".format(net['vim_net_id'])
             logger.warn("NET '%s', VIM id '%s', from VNF_id '%s' not found",
-                net['uuid'], vm['vim_net_id'], sce_vnf['vnf_id'])
+                net['uuid'], net['vim_net_id'], sce_vnf['vnf_id'])
         except vimconn.vimconnException as e:
             error_msg+="\n    Error: " + e.http_code + " Net id=" + net['vim_vm_id']
             logger.error("Error %d deleting NET '%s', VIM id '%s', from VNF_id '%s': %s",
@@ -2202,12 +2256,12 @@ def vim_action_get(mydb, tenant_id, datacenter, item, name):
             content = myvim.get_tenant_list(filter_dict=filter_dict)
         else:
             raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
-        logger.debug("vim_action response ", content) #update nets Change from VIM format to NFVO format
+        logger.debug("vim_action response %s", content) #update nets Change from VIM format to NFVO format
         if name and len(content)==1:
             return {item[:-1]: content[0]}
         elif name and len(content)==0:
             raise NfvoException("No {} found with ".format(item[:-1]) + " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), filter_dict.iteritems())),
-                 -HTTP_Not_Found)
+                 datacenter)
         else:
             return {item: content}
     except vimconn.vimconnException as e:

diff --git a/nfvo_db.py b/nfvo_db.py
index 6e6b494..09da2a9 100644 (file)
--- a/nfvo_db.py
+++ b/nfvo_db.py
@@ -505,21 +505,30 @@ class nfvo_db(db_base.db_base):
                     net_scene2instance={}
                     #instance_nets   #nets interVNF
                     for net in scenarioDict['nets']:
-                        INSERT_={'vim_net_id': net['vim_id'], 'external': net['external'], 'instance_scenario_id':instance_uuid } #,  'type': net['type']
-                        INSERT_['datacenter_id'] = net.get('datacenter_id', datacenter_id) 
-                        INSERT_['datacenter_tenant_id'] = net.get('datacenter_tenant_id', datacenter_tenant_id)
-                        if net.get("uuid"):
-                            INSERT_['sce_net_id'] = net['uuid']
-                        created_time += 0.00001
-                        instance_net_uuid =  self._new_row_internal('instance_nets', INSERT_, True, instance_uuid, created_time)
-                        net_scene2instance[ net['uuid'] ] = instance_net_uuid
-                        net['uuid'] = instance_net_uuid  #overwrite scnario uuid by instance uuid
+                        net_scene2instance[ net['uuid'] ] ={}
+                        datacenter_site_id = net.get('datacenter_id', datacenter_id)
+                        if not "vim_id_sites" in net:
+                            net["vim_id_sites"] ={datacenter_site_id: net['vim_id']}
+                        sce_net_id = net.get("uuid")
+                        
+                        for datacenter_site_id,vim_id in net["vim_id_sites"].iteritems():
+                            INSERT_={'vim_net_id': vim_id, 'external': net['external'], 'instance_scenario_id':instance_uuid } #,  'type': net['type']
+                            INSERT_['datacenter_id'] = datacenter_site_id 
+                            INSERT_['datacenter_tenant_id'] = net.get('datacenter_tenant_id', datacenter_tenant_id) #TODO revise
+                            if sce_net_id:
+                                INSERT_['sce_net_id'] = sce_net_id
+                            created_time += 0.00001
+                            instance_net_uuid =  self._new_row_internal('instance_nets', INSERT_, True, instance_uuid, created_time)
+                            net_scene2instance[ sce_net_id ][datacenter_site_id] = instance_net_uuid
+                            net['uuid'] = instance_net_uuid  #overwrite scnario uuid by instance uuid
                     
                     #instance_vnfs
                     for vnf in scenarioDict['vnfs']:
+                        datacenter_site_id = vnf.get('datacenter_id', datacenter_id)
+                        datacenter_site_tenant_id = vnf.get('datacenter_tenant_id', datacenter_id)
                         INSERT_={'instance_scenario_id': instance_uuid,  'vnf_id': vnf['vnf_id']  }
-                        INSERT_['datacenter_id'] = vnf.get('datacenter_id', datacenter_id) 
-                        INSERT_['datacenter_tenant_id'] = vnf.get('datacenter_tenant_id', datacenter_tenant_id)
+                        INSERT_['datacenter_id'] = datacenter_site_id 
+                        INSERT_['datacenter_tenant_id'] = datacenter_site_tenant_id #TODO revise
                         if vnf.get("uuid"):
                             INSERT_['sce_vnf_id'] = vnf['uuid']
                         created_time += 0.00001
@@ -528,14 +537,15 @@ class nfvo_db(db_base.db_base):
                         
                         #instance_nets   #nets intraVNF
                         for net in vnf['nets']:
+                            net_scene2instance[ net['uuid'] ] = {}
                             INSERT_={'vim_net_id': net['vim_id'], 'external': 'false', 'instance_scenario_id':instance_uuid  } #,  'type': net['type']
-                            INSERT_['datacenter_id'] = net.get('datacenter_id', datacenter_id) 
-                            INSERT_['datacenter_tenant_id'] = net.get('datacenter_tenant_id', datacenter_tenant_id)
+                            INSERT_['datacenter_id'] = net.get('datacenter_id', datacenter_site_id) 
+                            INSERT_['datacenter_tenant_id'] = net.get('datacenter_tenant_id', datacenter_site_tenant_id)
                             if net.get("uuid"):
                                 INSERT_['net_id'] = net['uuid']
                             created_time += 0.00001
                             instance_net_uuid =  self._new_row_internal('instance_nets', INSERT_, True, instance_uuid, created_time)
-                            net_scene2instance[ net['uuid'] ] = instance_net_uuid
+                            net_scene2instance[ net['uuid'] ][datacenter_site_id] = instance_net_uuid
                             net['uuid'] = instance_net_uuid  #overwrite scnario uuid by instance uuid
                         
                         #instance_vms
@@ -557,7 +567,7 @@ class nfvo_db(db_base.db_base):
                                 if net_id is None:
                                     continue
                                 interface_type='external' if interface['external_name'] is not None else 'internal'
-                                INSERT_={'instance_vm_id': instance_vm_uuid,  'instance_net_id': net_scene2instance[net_id],
+                                INSERT_={'instance_vm_id': instance_vm_uuid,  'instance_net_id': net_scene2instance[net_id][datacenter_site_id],
                                     'interface_id': interface['uuid'], 'vim_interface_id': interface.get('vim_id'), 'type':  interface_type  }
                                 #created_time += 0.00001
                                 interface_uuid =  self._new_row_internal('instance_interfaces', INSERT_, True, instance_uuid) #, created_time)

diff --git a/openmano b/openmano
index 7c3c5ac..9697bbc 100755 (executable)
--- a/openmano
+++ b/openmano
@@ -480,6 +480,8 @@ def scenario_deploy(args):
     args.file = None
     args.netmap_use = None
     args.netmap_create = None
+    args.keypair = None
+    args.keypair_auto = None
     return instance_create(args)
 
 #     #print "scenario-deploy",args
@@ -594,7 +596,9 @@ def instance_create(args):
                 net_datacenter = net_tuple[1].strip()
                 if net_scenario not in myInstance["instance"]["networks"]:
                     myInstance["instance"]["networks"][net_scenario] = {} 
-                myInstance["instance"]["networks"][net_scenario]["netmap-use"] = net_datacenter
+                if "sites" not in myInstance["instance"]["networks"][net_scenario]:
+                    myInstance["instance"]["networks"][net_scenario]["sites"] = [ {} ]
+                myInstance["instance"]["networks"][net_scenario]["sites"][0]["netmap-use"] = net_datacenter
     if args.netmap_create:
         if "networks" not in myInstance["instance"]:
             myInstance["instance"]["networks"] = {}
@@ -613,7 +617,9 @@ def instance_create(args):
                     return
                 if net_scenario not in myInstance["instance"]["networks"]:
                     myInstance["instance"]["networks"][net_scenario] = {} 
-                myInstance["instance"]["networks"][net_scenario]["netmap-create"] = net_datacenter
+                if "sites" not in myInstance["instance"]["networks"][net_scenario]:
+                    myInstance["instance"]["networks"][net_scenario]["sites"] = [ {} ]
+                myInstance["instance"]["networks"][net_scenario]["sites"][0]["netmap-create"] = net_datacenter
     if args.keypair:
         if "cloud-config" not in myInstance["instance"]:
             myInstance["instance"]["cloud-config"] = {}

diff --git a/openmano_schemas.py b/openmano_schemas.py
index 4f5edfe..5eeee4d 100644 (file)
--- a/openmano_schemas.py
+++ b/openmano_schemas.py
@@ -973,12 +973,32 @@ instance_scenario_create_schema_v01 = {
                                         }
                                     }
                                 },
-                                "netmap-create": {"oneOf":[name_schema,{"type": "null"}]}, #datacenter network to use. Null if must be created as an internal net
-                                "netmap-use": name_schema,
-                                #"name": name_schema, #override network name
                                 "ip-profile": ip_profile_schema,
-                                #"datacenter": name_schema,
-                                "vim-network-name": name_schema
+                                #if the network connects VNFs deployed at different sites, you must specify one entry per site that this network connect to 
+                                "sites": {
+                                    "type":"array",
+                                    "minLength":1,
+                                    "items":{
+                                        "type":"object",
+                                        "properties":{
+                                            # By default for an scenario 'external' network openmano looks for an existing VIM network to map this external scenario network,
+                                            # for other networks openamno creates at VIM
+                                            # Use netmap-create to force to create an external scenario network  
+                                            "netmap-create": {"oneOf":[name_schema,{"type": "null"}]}, #datacenter network to use. Null if must be created as an internal net
+                                            #netmap-use:   Indicates an existing VIM network that must be used for this scenario network. 
+                                            #Can use both the VIM network name (if it is not ambiguous) or the VIM net UUID
+                                            #If both 'netmap-create' and 'netmap-use'are supplied, netmap-use precedes, but if fails openmano follows the netmap-create
+                                            #In oder words, it is the same as 'try to map to the VIM network (netmap-use) if exist, and if not create the network (netmap-create)
+                                            "netmap-use": name_schema, # 
+                                            "vim-network-name": name_schema, #override network name
+                                            #"ip-profile": ip_profile_schema,
+                                            "datacenter": name_schema,                                        
+                                        }
+                                    }
+                                },
+                                
+
+
                             }
                         }
                     },

diff --git a/openmanod.py b/openmanod.py
index d4094ff..422e3ed 100755 (executable)
--- a/openmanod.py
+++ b/openmanod.py
@@ -33,7 +33,7 @@ It loads the configuration file and launches the http_server thread that will li
 '''
 __author__="Alfonso Tierno, Gerardo Garcia, Pablo Montes"
 __date__ ="$26-aug-2014 11:09:29$"
-__version__="0.4.47-r486"
+__version__="0.4.48-r490"
 version_date="Aug 2016"
 database_version="0.13"      #expected database schema version
 

diff --git a/scenarios/examples/complex.yaml b/scenarios/examples/complex.yaml
index 07ee6cb..00bfce9 100644 (file)
--- a/scenarios/examples/complex.yaml
+++ b/scenarios/examples/complex.yaml
@@ -59,6 +59,7 @@ scenario:
       - node2:   control
       - node3:   control
     default:
+      external:  true
       interfaces: 
       - node1:   mgmt
       - node2:   mgmt

diff --git a/vimconn_openvim.py b/vimconn_openvim.py
index d0549ad..ac02678 100644 (file)
--- a/vimconn_openvim.py
+++ b/vimconn_openvim.py
@@ -35,6 +35,7 @@ import logging
 from openmano_schemas import id_schema, name_schema, nameshort_schema, description_schema, \
                             vlan1000_schema, integer0_schema
 from jsonschema import validate as js_v, exceptions as js_e
+from urllib import quote
 
 '''contain the openvim virtual machine status to openmano status'''
 vmStatus2manoFormat={'ACTIVE':'ACTIVE',
@@ -346,7 +347,7 @@ class vimconnector(vimconn.vimconnector):
         if self.tenant:
             return self.tenant
 
-        url = self.url+'/tenants?name='+ self.tenant_name
+        url = self.url+'/tenants?name='+ quote(self.tenant_name)
         self.logger.info("Getting VIM tenant_id GET %s", url)
         vim_response = requests.get(url, headers = self.headers_req)
         self._check_http_request_response(vim_response)
@@ -690,7 +691,7 @@ class vimconnector(vimconn.vimconnector):
         '''Get the image id from image path in the VIM database'''
         try:
             self._get_my_tenant()
-            url=self.url + '/' + self.tenant + '/images?path='+path
+            url=self.url + '/' + self.tenant + '/images?path='+quote(path)
             self.logger.info("Getting images GET %s", url)
             vim_response = requests.get(url)
             self._check_http_request_response(vim_response)
@@ -898,7 +899,7 @@ class vimconnector(vimconn.vimconnector):
                 #get interfaces info
                 try:
                     management_ip = False
-                    url2 = self.url+'/ports?device_id='+ vm_id
+                    url2 = self.url+'/ports?device_id='+ quote(vm_id)
                     self.logger.info("Getting PORTS GET %s", url2)
                     vim_response2 = requests.get(url2, headers = self.headers_req)
                     self._check_http_request_response(vim_response2)