Signed-off-by: Marco Ceppi <marco.ceppi@canonical.com>
17 files changed:
import MySQLdb as mdb
import uuid as myUuid
import MySQLdb as mdb
import uuid as myUuid
+from . import utils as af
import json
#import yaml
import time
import json
#import yaml
import time
It enters recursively in the dict var finding this kind of variables
'''
if type(var) is dict:
It enters recursively in the dict var finding this kind of variables
'''
if type(var) is dict:
- for k,v in var.items():
+ for k,v in list(var.items()):
if type(v) is datetime.datetime:
var[k]= v.strftime('%Y-%m-%dT%H:%M:%S')
elif type(v) is dict or type(v) is list or type(v) is tuple:
if type(v) is datetime.datetime:
var[k]= v.strftime('%Y-%m-%dT%H:%M:%S')
elif type(v) is dict or type(v) is list or type(v) is tuple:
None
'''
if type(data) is dict:
None
'''
if type(data) is dict:
+ for k in list(data.keys()):
if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
_convert_bandwidth(data[k], reverse, logger)
if "bandwidth" in data:
if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
_convert_bandwidth(data[k], reverse, logger)
if "bandwidth" in data:
None
'''
if type(data) is dict:
None
'''
if type(data) is dict:
+ for k in list(data.keys()):
if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
_convert_str2boolean(data[k], items)
if k in items:
if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
_convert_str2boolean(data[k], items)
if k in items:
def __remove_quotes(self, data):
'''remove single quotes ' of any string content of data dictionary'''
def __remove_quotes(self, data):
'''remove single quotes ' of any string content of data dictionary'''
- for k,v in data.items():
+ for k,v in list(data.items()):
if type(v) == str:
if "'" in v:
data[k] = data[k].replace("'","_")
if type(v) == str:
if "'" in v:
data[k] = data[k].replace("'","_")
Return: the number of updated rows, exception if error
'''
#gettting uuid
Return: the number of updated rows, exception if error
'''
#gettting uuid
- values = ",".join(map(self.__tuple2db_format_set, UPDATE.iteritems() ))
+ values = ",".join(map(self.__tuple2db_format_set, iter(UPDATE.items()) ))
if modified_time:
values += ",modified_at={:f}".format(modified_time)
cmd= "UPDATE " + table +" SET " + values +\
if modified_time:
values += ",modified_at={:f}".format(modified_time)
cmd= "UPDATE " + table +" SET " + values +\
- " WHERE " + " and ".join(map(self.__tuple2db_format_where, WHERE.iteritems() ))
+ " WHERE " + " and ".join(map(self.__tuple2db_format_where, iter(WHERE.items()) ))
self.logger.debug(cmd)
self.cur.execute(cmd)
return self.cur.rowcount
self.logger.debug(cmd)
self.cur.execute(cmd)
return self.cur.rowcount
self.cur.execute(cmd)
#insertion
cmd= "INSERT INTO " + table +" SET " + \
self.cur.execute(cmd)
#insertion
cmd= "INSERT INTO " + table +" SET " + \
- ",".join(map(self.__tuple2db_format_set, INSERT.iteritems() ))
+ ",".join(map(self.__tuple2db_format_set, iter(INSERT.items()) ))
if created_time:
cmd += ",created_at=%f" % created_time
if confidential_data:
if created_time:
cmd += ",created_at=%f" % created_time
if confidential_data:
#print 'from_', from_
if 'WHERE' in sql_dict and len(sql_dict['WHERE']) > 0:
w=sql_dict['WHERE']
#print 'from_', from_
if 'WHERE' in sql_dict and len(sql_dict['WHERE']) > 0:
w=sql_dict['WHERE']
- where_ = "WHERE " + " AND ".join(map(self.__tuple2db_format_where, w.iteritems()))
+ where_ = "WHERE " + " AND ".join(map(self.__tuple2db_format_where, iter(w.items())))
else: where_ = ""
if 'WHERE_NOT' in sql_dict and len(sql_dict['WHERE_NOT']) > 0:
w=sql_dict['WHERE_NOT']
else: where_ = ""
if 'WHERE_NOT' in sql_dict and len(sql_dict['WHERE_NOT']) > 0:
w=sql_dict['WHERE_NOT']
- where_2 = " AND ".join(map(self.__tuple2db_format_where_not, w.iteritems()))
+ where_2 = " AND ".join(map(self.__tuple2db_format_where_not, iter(w.items())))
if len(where_)==0: where_ = "WHERE " + where_2
else: where_ = where_ + " AND " + where_2
#print 'where_', where_
if len(where_)==0: where_ = "WHERE " + where_2
else: where_ = where_ + " AND " + where_2
#print 'where_', where_
where_or = ""
w=sql_dict.get('WHERE')
if w:
where_or = ""
w=sql_dict.get('WHERE')
if w:
- where_and = " AND ".join(map(self.__tuple2db_format_where, w.iteritems() ))
+ where_and = " AND ".join(map(self.__tuple2db_format_where, iter(w.items()) ))
w=sql_dict.get('WHERE_NOT')
if w:
if where_and: where_and += " AND "
w=sql_dict.get('WHERE_NOT')
if w:
if where_and: where_and += " AND "
- where_and += " AND ".join(map(self.__tuple2db_format_where_not, w.iteritems() ) )
+ where_and += " AND ".join(map(self.__tuple2db_format_where_not, iter(w.items()) ) )
w=sql_dict.get('WHERE_OR')
if w:
w=sql_dict.get('WHERE_OR')
if w:
- where_or = " OR ".join(map(self.__tuple2db_format_where, w.iteritems() ))
+ where_or = " OR ".join(map(self.__tuple2db_format_where, iter(w.items()) ))
if where_and and where_or:
if sql_dict.get("WHERE_AND_OR") == "AND":
where_ = "WHERE " + where_and + " AND (" + where_or + ")"
if where_and and where_or:
if sql_dict.get("WHERE_AND_OR") == "AND":
where_ = "WHERE " + where_and + " AND (" + where_or + ")"
what = 'uuid' if af.check_valid_uuid(uuid_name) else 'name'
cmd = " SELECT * FROM {} WHERE {}='{}'".format(table, what, uuid_name)
if WHERE_OR:
what = 'uuid' if af.check_valid_uuid(uuid_name) else 'name'
cmd = " SELECT * FROM {} WHERE {}='{}'".format(table, what, uuid_name)
if WHERE_OR:
- where_or = " OR ".join(map(self.__tuple2db_format_where, WHERE_OR.iteritems() ))
+ where_or = " OR ".join(map(self.__tuple2db_format_where, iter(WHERE_OR.items()) ))
if WHERE_AND_OR == "AND":
cmd += " AND (" + where_or + ")"
else:
if WHERE_AND_OR == "AND":
cmd += " AND (" + where_or + ")"
else:
rows = self.cur.fetchall()
return self.cur.rowcount, rows
except (mdb.Error, AttributeError) as e:
rows = self.cur.fetchall()
return self.cur.rowcount, rows
except (mdb.Error, AttributeError) as e:
- print "nfvo_db.get_uuid DB Exception %d: %s" % (e.args[0], e.args[1])
+ print("nfvo_db.get_uuid DB Exception %d: %s" % (e.args[0], e.args[1]))
r,c = self._format_error(e)
if r!=-HTTP_Request_Timeout or retry_==1: return r,c
r,c = self._format_error(e)
if r!=-HTTP_Request_Timeout or retry_==1: return r,c
import logging
from jsonschema import validate as js_v, exceptions as js_e
import logging
from jsonschema import validate as js_v, exceptions as js_e
-from openmano_schemas import vnfd_schema_v01, vnfd_schema_v02, \
+from .openmano_schemas import vnfd_schema_v01, vnfd_schema_v02, \
nsd_schema_v01, nsd_schema_v02, nsd_schema_v03, scenario_edit_schema, \
scenario_action_schema, instance_scenario_action_schema, instance_scenario_create_schema_v01, \
tenant_schema, tenant_edit_schema,\
nsd_schema_v01, nsd_schema_v02, nsd_schema_v03, scenario_edit_schema, \
scenario_action_schema, instance_scenario_action_schema, instance_scenario_create_schema_v01, \
tenant_schema, tenant_edit_schema,\
object_schema, netmap_new_schema, netmap_edit_schema, sdn_controller_schema, sdn_controller_edit_schema, \
sdn_port_mapping_schema, sdn_external_port_schema
object_schema, netmap_new_schema, netmap_edit_schema, sdn_controller_schema, sdn_controller_edit_schema, \
sdn_port_mapping_schema, sdn_external_port_schema
-import nfvo
-import utils
-from db_base import db_base_Exception
+from . import nfvo
+from . import utils
+from .db_base import db_base_Exception
from functools import wraps
global mydb
from functools import wraps
global mydb
def delete_nulls(var):
if type(var) is dict:
def delete_nulls(var):
if type(var) is dict:
+ for k in list(var.keys()):
if var[k] is None: del var[k]
elif type(var[k]) is dict or type(var[k]) is list or type(var[k]) is tuple:
if delete_nulls(var[k]): del var[k]
if var[k] is None: del var[k]
elif type(var[k]) is dict or type(var[k]) is list or type(var[k]) is tuple:
if delete_nulls(var[k]): del var[k]
It enters recursively in the dict var finding this kind of variables
'''
if type(var) is dict:
It enters recursively in the dict var finding this kind of variables
'''
if type(var) is dict:
- for k,v in var.items():
+ for k,v in list(var.items()):
if type(v) is float and k in ("created_at", "modified_at"):
var[k] = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(v) )
elif type(v) is dict or type(v) is list or type(v) is tuple:
if type(v) is float and k in ("created_at", "modified_at"):
var[k] = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(v) )
elif type(v) is dict or type(v) is list or type(v) is tuple:
change_keys_http2db(d, http_db, reverse)
elif type(data) is dict or type(data) is bottle.FormsDict:
if reverse:
change_keys_http2db(d, http_db, reverse)
elif type(data) is dict or type(data) is bottle.FormsDict:
if reverse:
- for k,v in http_db.items():
+ for k,v in list(http_db.items()):
if v in data: data[k]=data.pop(v)
else:
if v in data: data[k]=data.pop(v)
else:
- for k,v in http_db.items():
+ for k,v in list(http_db.items()):
if k in data: data[v]=data.pop(k)
def format_out(data):
if k in data: data[v]=data.pop(k)
def format_out(data):
if netmap_id and len(netmaps)==1:
data={'netmap' : netmaps[0]}
elif netmap_id and len(netmaps)==0:
if netmap_id and len(netmaps)==1:
data={'netmap' : netmaps[0]}
elif netmap_id and len(netmaps)==0:
- bottle.abort(HTTP_Not_Found, "No netmap found with " + " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), where_.iteritems())) )
+ bottle.abort(HTTP_Not_Found, "No netmap found with " + " and ".join([str(x[0])+": "+str(x[1]) for x in iter(where_.items())]) )
return
else:
data={'netmaps' : netmaps}
return
else:
data={'netmaps' : netmaps}
#change_keys_http2db(content, http2db_tenant, reverse=True)
deleted = mydb.delete_row(FROM='datacenter_nets', WHERE= where_)
if deleted == 0 and netmap_id:
#change_keys_http2db(content, http2db_tenant, reverse=True)
deleted = mydb.delete_row(FROM='datacenter_nets', WHERE= where_)
if deleted == 0 and netmap_id:
- bottle.abort(HTTP_Not_Found, "No netmap found with " + " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), where_.iteritems())) )
+ bottle.abort(HTTP_Not_Found, "No netmap found with " + " and ".join([str(x[0])+": "+str(x[1]) for x in iter(where_.items())]) )
if netmap_id:
return format_out({"result": "netmap %s deleted" % netmap_id})
else:
if netmap_id:
return format_out({"result": "netmap %s deleted" % netmap_id})
else:
# import imp
# import json
import yaml
# import imp
# import json
import yaml
-import utils
-import vim_thread
-from db_base import HTTP_Unauthorized, HTTP_Bad_Request, HTTP_Internal_Server_Error, HTTP_Not_Found,\
+from . import utils
+from . import vim_thread
+from .db_base import HTTP_Unauthorized, HTTP_Bad_Request, HTTP_Internal_Server_Error, HTTP_Not_Found,\
HTTP_Conflict, HTTP_Method_Not_Allowed
HTTP_Conflict, HTTP_Method_Not_Allowed
-import console_proxy_thread as cli
-import vimconn
+from . import console_proxy_thread as cli
+from . import vimconn
import logging
import collections
from uuid import uuid4
import logging
import collections
from uuid import uuid4
-from db_base import db_base_Exception
+from .db_base import db_base_Exception
from threading import Lock
import time as t
from lib_osm_openvim import ovim as ovim_module
from threading import Lock
import time as t
from lib_osm_openvim import ovim as ovim_module
global ovim, global_config
if ovim:
ovim.stop_service()
global ovim, global_config
if ovim:
ovim.stop_service()
- for thread_id,thread in vim_threads["running"].items():
+ for thread_id,thread in list(vim_threads["running"].items()):
thread.insert_task("exit")
vim_threads["deleting"][thread_id] = thread
vim_threads["running"] = {}
thread.insert_task("exit")
vim_threads["deleting"][thread_id] = thread
vim_threads["running"] = {}
image_mano_id = mydb.new_row('images', temp_image_dict, add_uuid=True)
rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id})
#create image at every vim
image_mano_id = mydb.new_row('images', temp_image_dict, add_uuid=True)
rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id})
#create image at every vim
- for vim_id,vim in vims.iteritems():
+ for vim_id,vim in vims.items():
datacenter_vim_id = vim["config"]["datacenter_tenant_id"]
image_created="false"
#look at database
datacenter_vim_id = vim["config"]["datacenter_tenant_id"]
image_created="false"
#look at database
if 'uuid' in flavor_dict:
del flavor_dict['uuid']
flavor_vim_id=None
if 'uuid' in flavor_dict:
del flavor_dict['uuid']
flavor_vim_id=None
- for vim_id,vim in vims.items():
+ for vim_id,vim in list(vims.items()):
datacenter_vim_id = vim["config"]["datacenter_tenant_id"]
flavor_created="false"
#look at database
datacenter_vim_id = vim["config"]["datacenter_tenant_id"]
flavor_created="false"
#look at database
vnfd_descriptor_list = vnfd_catalog_descriptor.get("vnfd")
if not vnfd_descriptor_list:
vnfd_descriptor_list = vnfd_catalog_descriptor.get("vnfd:vnfd")
vnfd_descriptor_list = vnfd_catalog_descriptor.get("vnfd")
if not vnfd_descriptor_list:
vnfd_descriptor_list = vnfd_catalog_descriptor.get("vnfd:vnfd")
- for vnfd_yang in myvnfd.vnfd_catalog.vnfd.itervalues():
+ for vnfd_yang in myvnfd.vnfd_catalog.vnfd.values():
vnfd = vnfd_yang.get()
# table vnf
vnfd = vnfd_yang.get()
# table vnf
# table nets (internal-vld)
net_id2uuid = {} # for mapping interface with network
# table nets (internal-vld)
net_id2uuid = {} # for mapping interface with network
- for vld in vnfd.get("internal-vld").itervalues():
+ for vld in vnfd.get("internal-vld").values():
net_uuid = str(uuid4())
uuid_list.append(net_uuid)
db_net = {
net_uuid = str(uuid4())
uuid_list.append(net_uuid)
db_net = {
# table vms (vdus)
vdu_id2uuid = {}
vdu_id2db_table_index = {}
# table vms (vdus)
vdu_id2uuid = {}
vdu_id2db_table_index = {}
- for vdu in vnfd.get("vdu").itervalues():
+ for vdu in vnfd.get("vdu").values():
vm_uuid = str(uuid4())
uuid_list.append(vm_uuid)
db_vm = {
vm_uuid = str(uuid4())
uuid_list.append(vm_uuid)
db_vm = {
epa_vcpu_set = True
if len(numa_node["paired-threads"].get("paired-thread-ids")):
numa["paired-threads-id"] = []
epa_vcpu_set = True
if len(numa_node["paired-threads"].get("paired-thread-ids")):
numa["paired-threads-id"] = []
- for pair in numa_node["paired-threads"]["paired-thread-ids"].itervalues():
+ for pair in numa_node["paired-threads"]["paired-thread-ids"].values():
numa["paired-threads-id"].append(
(str(pair["thread-a"]), str(pair["thread-b"]))
)
numa["paired-threads-id"].append(
(str(pair["thread-a"]), str(pair["thread-b"]))
)
boot_data['boot-data-drive'] = True
if vdu["supplemental-boot-data"].get('config-file'):
om_cfgfile_list = list()
boot_data['boot-data-drive'] = True
if vdu["supplemental-boot-data"].get('config-file'):
om_cfgfile_list = list()
- for custom_config_file in vdu["supplemental-boot-data"]['config-file'].itervalues():
+ for custom_config_file in vdu["supplemental-boot-data"]['config-file'].values():
# TODO Where this file content is present???
cfg_source = str(custom_config_file["source"])
om_cfgfile_list.append({"dest": custom_config_file["dest"],
# TODO Where this file content is present???
cfg_source = str(custom_config_file["source"])
om_cfgfile_list.append({"dest": custom_config_file["dest"],
cp_name2iface_uuid = {}
cp_name2vm_uuid = {}
# for iface in chain(vdu.get("internal-interface").itervalues(), vdu.get("external-interface").itervalues()):
cp_name2iface_uuid = {}
cp_name2vm_uuid = {}
# for iface in chain(vdu.get("internal-interface").itervalues(), vdu.get("external-interface").itervalues()):
- for iface in vdu.get("interface").itervalues():
+ for iface in vdu.get("interface").values():
iface_uuid = str(uuid4())
uuid_list.append(iface_uuid)
db_interface = {
iface_uuid = str(uuid4())
uuid_list.append(iface_uuid)
db_interface = {
HTTP_Bad_Request)
elif iface.get("internal-connection-point-ref"):
try:
HTTP_Bad_Request)
elif iface.get("internal-connection-point-ref"):
try:
- for vld in vnfd.get("internal-vld").itervalues():
- for cp in vld.get("internal-connection-point").itervalues():
+ for vld in vnfd.get("internal-vld").values():
+ for cp in vld.get("internal-connection-point").values():
if cp.get("id-ref") == iface.get("internal-connection-point-ref"):
db_interface["net_id"] = net_id2uuid[vld.get("id")]
for cp_descriptor in vnfd_descriptor["connection-point"]:
if cp.get("id-ref") == iface.get("internal-connection-point-ref"):
db_interface["net_id"] = net_id2uuid[vld.get("id")]
for cp_descriptor in vnfd_descriptor["connection-point"]:
db_interfaces.append(db_interface)
# VNF affinity and antiaffinity
db_interfaces.append(db_interface)
# VNF affinity and antiaffinity
- for pg in vnfd.get("placement-groups").itervalues():
+ for pg in vnfd.get("placement-groups").values():
pg_name = get_str(pg, "name", 255)
pg_name = get_str(pg, "name", 255)
- for vdu in pg.get("member-vdus").itervalues():
+ for vdu in pg.get("member-vdus").values():
vdu_id = get_str(vdu, "member-vdu-ref", 255)
if vdu_id not in vdu_id2db_table_index:
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'placement-groups[{pg}]':"
vdu_id = get_str(vdu, "member-vdu-ref", 255)
if vdu_id not in vdu_id2db_table_index:
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'placement-groups[{pg}]':"
vnf_id = vnf["uuid"]
filter_keys = ('uuid', 'name', 'description', 'public', "tenant_id", "osm_id", "created_at")
vnf_id = vnf["uuid"]
filter_keys = ('uuid', 'name', 'description', 'public', "tenant_id", "osm_id", "created_at")
- filtered_content = dict( (k,v) for k,v in vnf.iteritems() if k in filter_keys )
+ filtered_content = dict( (k,v) for k,v in vnf.items() if k in filter_keys )
#change_keys_http2db(filtered_content, http2db_vnf, reverse=True)
data={'vnf' : filtered_content}
#GET VM
#change_keys_http2db(filtered_content, http2db_vnf, reverse=True)
data={'vnf' : filtered_content}
#GET VM
return result, vims
elif result == 0:
return -HTTP_Not_Found, "datacenter '%s' not found" % datacenter_name
return result, vims
elif result == 0:
return -HTTP_Not_Found, "datacenter '%s' not found" % datacenter_name
- myvim = vims.values()[0]
+ myvim = list(vims.values())[0]
result,servers = myvim.get_hosts_info()
if result < 0:
return result, servers
result,servers = myvim.get_hosts_info()
if result < 0:
return result, servers
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)
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]
+ myvim = list(vims.values())[0]
try:
hosts = myvim.get_hosts()
logger.debug('VIM hosts response: '+ yaml.safe_dump(hosts, indent=4, default_flow_style=False))
try:
hosts = myvim.get_hosts()
logger.debug('VIM hosts response: '+ yaml.safe_dump(hosts, indent=4, default_flow_style=False))
vnfs={}
other_nets={} #external_networks, bridge_networks and data_networkds
nodes = topo['topology']['nodes']
vnfs={}
other_nets={} #external_networks, bridge_networks and data_networkds
nodes = topo['topology']['nodes']
+ for k in list(nodes.keys()):
if nodes[k]['type'] == 'VNF':
vnfs[k] = nodes[k]
vnfs[k]['ifaces'] = {}
if nodes[k]['type'] == 'VNF':
vnfs[k] = nodes[k]
vnfs[k]['ifaces'] = {}
#1.2: Check that VNF are present at database table vnfs. Insert uuid, description and external interfaces
#1.2: Check that VNF are present at database table vnfs. Insert uuid, description and external interfaces
- for name,vnf in vnfs.items():
+ for name,vnf in list(vnfs.items()):
where={}
where_or={"tenant_id": tenant_id, 'public': "true"}
error_text = ""
where={}
where_or={"tenant_id": tenant_id, 'public': "true"}
error_text = ""
conections = topo['topology']['connections']
conections_list = []
conections_list_name = []
conections = topo['topology']['connections']
conections_list = []
conections_list_name = []
- for k in conections.keys():
+ for k in list(conections.keys()):
if type(conections[k]['nodes'])==dict: #dict with node:iface pairs
if type(conections[k]['nodes'])==dict: #dict with node:iface pairs
- ifaces_list = conections[k]['nodes'].items()
+ ifaces_list = list(conections[k]['nodes'].items())
elif type(conections[k]['nodes'])==list: #list with dictionary
ifaces_list=[]
elif type(conections[k]['nodes'])==list: #list with dictionary
ifaces_list=[]
- conection_pair_list = map(lambda x: x.items(), conections[k]['nodes'] )
+ conection_pair_list = [list(x.items()) for x in conections[k]['nodes']]
for k2 in conection_pair_list:
ifaces_list += k2
for k2 in conection_pair_list:
ifaces_list += k2
# del con[index]
# del other_nets[k]
#1.7: Check external_ports are present at database table datacenter_nets
# del con[index]
# del other_nets[k]
#1.7: Check external_ports are present at database table datacenter_nets
- for k,net in other_nets.items():
+ for k,net in list(other_nets.items()):
error_pos = "'topology':'nodes':'" + k + "'"
if net['external']==False:
if 'name' not in net:
error_pos = "'topology':'nodes':'" + k + "'"
if net['external']==False:
if 'name' not in net:
#print "con", con
for index in range(0,len(con)):
#check if this is connected to a external net
#print "con", con
for index in range(0,len(con)):
#check if this is connected to a external net
- for net_key in other_nets.keys():
+ for net_key in list(other_nets.keys()):
if con[index][0]==net_key:
if other_net_index>=0:
error_text="There is some interface connected both to net '%s' and net '%s'" % (con[other_net_index][0], net_key)
if con[index][0]==net_key:
if other_net_index>=0:
error_text="There is some interface connected both to net '%s' and net '%s'" % (con[other_net_index][0], net_key)
#1.8.2 check all interfaces from all vnfs
if len(mgmt_net)>0:
add_mgmt_net = False
#1.8.2 check all interfaces from all vnfs
if len(mgmt_net)>0:
add_mgmt_net = False
- for vnf in vnfs.values():
- for iface in vnf['ifaces'].values():
+ for vnf in list(vnfs.values()):
+ for iface in list(vnf['ifaces'].values()):
if iface['type']=='mgmt' and 'net_key' not in iface:
#iface not connected
iface['net_key'] = 'mgmt'
if iface['type']=='mgmt' and 'net_key' not in iface:
#iface not connected
iface['net_key'] = 'mgmt'
tenant_id=None
# 1: Check that VNF are present at database table vnfs and update content into scenario dict
tenant_id=None
# 1: Check that VNF are present at database table vnfs and update content into scenario dict
- for name,vnf in scenario["vnfs"].iteritems():
+ for name,vnf in scenario["vnfs"].items():
where={}
where_or={"tenant_id": tenant_id, 'public': "true"}
error_text = ""
where={}
where_or={"tenant_id": tenant_id, 'public': "true"}
error_text = ""
# TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly
# 2: Insert net_key and ip_address at every vnf interface
# TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly
# 2: Insert net_key and ip_address at every vnf interface
- for net_name, net in scenario["networks"].items():
+ for net_name, net in list(scenario["networks"].items()):
net_type_bridge = False
net_type_data = False
for iface_dict in net["interfaces"]:
net_type_bridge = False
net_type_data = False
for iface_dict in net["interfaces"]:
elif version == "0.3":
temp_dict = {iface_dict["vnf"] : iface_dict["vnf_interface"]}
ip_address = iface_dict.get('ip_address', None)
elif version == "0.3":
temp_dict = {iface_dict["vnf"] : iface_dict["vnf_interface"]}
ip_address = iface_dict.get('ip_address', None)
- for vnf, iface in temp_dict.items():
+ for vnf, iface in list(temp_dict.items()):
if vnf not in scenario["vnfs"]:
error_text = "Error at 'networks':'{}':'interfaces' VNF '{}' not match any VNF at 'vnfs'".format(
net_name, vnf)
if vnf not in scenario["vnfs"]:
error_text = "Error at 'networks':'{}':'interfaces' VNF '{}' not match any VNF at 'vnfs'".format(
net_name, vnf)
db_ip_profiles_index = 0
uuid_list = []
nsd_uuid_list = []
db_ip_profiles_index = 0
uuid_list = []
nsd_uuid_list = []
- for nsd_yang in mynsd.nsd_catalog.nsd.itervalues():
+ for nsd_yang in mynsd.nsd_catalog.nsd.values():
nsd = nsd_yang.get()
# table sceanrios
nsd = nsd_yang.get()
# table sceanrios
# table sce_vnfs (constituent-vnfd)
vnf_index2scevnf_uuid = {}
vnf_index2vnf_uuid = {}
# table sce_vnfs (constituent-vnfd)
vnf_index2scevnf_uuid = {}
vnf_index2vnf_uuid = {}
- for vnf in nsd.get("constituent-vnfd").itervalues():
+ for vnf in nsd.get("constituent-vnfd").values():
existing_vnf = mydb.get_rows(FROM="vnfs", WHERE={'osm_id': str(vnf["vnfd-id-ref"])[:255],
'tenant_id': tenant_id})
if not existing_vnf:
existing_vnf = mydb.get_rows(FROM="vnfs", WHERE={'osm_id': str(vnf["vnfd-id-ref"])[:255],
'tenant_id': tenant_id})
if not existing_vnf:
# table ip_profiles (ip-profiles)
ip_profile_name2db_table_index = {}
# table ip_profiles (ip-profiles)
ip_profile_name2db_table_index = {}
- for ip_profile in nsd.get("ip-profiles").itervalues():
+ for ip_profile in nsd.get("ip-profiles").values():
db_ip_profile = {
"ip_version": str(ip_profile["ip-profile-params"].get("ip-version", "ipv4")),
"subnet_address": str(ip_profile["ip-profile-params"].get("subnet-address")),
db_ip_profile = {
"ip_version": str(ip_profile["ip-profile-params"].get("ip-version", "ipv4")),
"subnet_address": str(ip_profile["ip-profile-params"].get("subnet-address")),
"dhcp_count": str(ip_profile["ip-profile-params"]["dhcp-params"].get("count")),
}
dns_list = []
"dhcp_count": str(ip_profile["ip-profile-params"]["dhcp-params"].get("count")),
}
dns_list = []
- for dns in ip_profile["ip-profile-params"]["dns-server"].itervalues():
+ for dns in ip_profile["ip-profile-params"]["dns-server"].values():
dns_list.append(str(dns.get("address")))
db_ip_profile["dns_address"] = ";".join(dns_list)
if ip_profile["ip-profile-params"].get('security-group'):
dns_list.append(str(dns.get("address")))
db_ip_profile["dns_address"] = ";".join(dns_list)
if ip_profile["ip-profile-params"].get('security-group'):
db_ip_profiles.append(db_ip_profile)
# table sce_nets (internal-vld)
db_ip_profiles.append(db_ip_profile)
# table sce_nets (internal-vld)
- for vld in nsd.get("vld").itervalues():
+ for vld in nsd.get("vld").values():
sce_net_uuid = str(uuid4())
uuid_list.append(sce_net_uuid)
db_sce_net = {
sce_net_uuid = str(uuid4())
uuid_list.append(sce_net_uuid)
db_sce_net = {
db_ip_profiles[ip_profile_name2db_table_index[ip_profile_name]]["sce_net_id"] = sce_net_uuid
# table sce_interfaces (vld:vnfd-connection-point-ref)
db_ip_profiles[ip_profile_name2db_table_index[ip_profile_name]]["sce_net_id"] = sce_net_uuid
# table sce_interfaces (vld:vnfd-connection-point-ref)
- for iface in vld.get("vnfd-connection-point-ref").itervalues():
+ for iface in vld.get("vnfd-connection-point-ref").values():
vnf_index = int(iface['member-vnf-index-ref'])
# check correct parameters
if vnf_index not in vnf_index2vnf_uuid:
vnf_index = int(iface['member-vnf-index-ref'])
# check correct parameters
if vnf_index not in vnf_index2vnf_uuid:
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)
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)
- return vims.keys()[0], vims.values()[0]
+ return list(vims.keys())[0], list(vims.values())[0]
def update(d, u):
'''Takes dict d and updates it with the values in dict u.'''
'''It merges all depth levels'''
def update(d, u):
'''Takes dict d and updates it with the values in dict u.'''
'''It merges all depth levels'''
- for k, v in u.iteritems():
if isinstance(v, collections.Mapping):
r = update(d.get(k, {}), v)
d[k] = r
if isinstance(v, collections.Mapping):
r = update(d.get(k, {}), v)
d[k] = r
# yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False))
try:
# 0 check correct parameters
# yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False))
try:
# 0 check correct parameters
- for net_name, net_instance_desc in instance_dict.get("networks", {}).iteritems():
+ for net_name, net_instance_desc in instance_dict.get("networks", {}).items():
found = False
for scenario_net in scenarioDict['nets']:
if net_name == scenario_net["name"]:
found = False
for scenario_net in scenarioDict['nets']:
if net_name == scenario_net["name"]:
site_without_datacenter_field = True
site["datacenter"] = default_datacenter_id # change name to id
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():
+ for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).items():
found = False
for scenario_vnf in scenarioDict['vnfs']:
if vnf_name == scenario_vnf['name']:
found = False
for scenario_vnf in scenarioDict['vnfs']:
if vnf_name == scenario_vnf['name']:
# 0.2 merge instance information into scenario
# Ideally, the operation should be as simple as: update(scenarioDict,instance_dict)
# However, this is not possible yet.
# 0.2 merge instance information into scenario
# Ideally, the operation should be as simple as: update(scenarioDict,instance_dict)
# However, this is not possible yet.
- for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems():
+ for net_name, net_instance_desc in instance_dict.get("networks",{}).items():
for scenario_net in scenarioDict['nets']:
if net_name == scenario_net["name"]:
if 'ip-profile' in net_instance_desc:
for scenario_net in scenarioDict['nets']:
if net_name == scenario_net["name"]:
if 'ip-profile' in net_instance_desc:
logger.debug("create_instance done DB tables: %s",
yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
mydb.new_rows(db_tables, uuid_list)
logger.debug("create_instance done DB tables: %s",
yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
mydb.new_rows(db_tables, uuid_list)
- for myvim_thread_id in myvim_threads_id.values():
+ for myvim_thread_id in list(myvim_threads_id.values()):
vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions)
returned_instance = mydb.get_instance_scenario(instance_uuid)
vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions)
returned_instance = mydb.get_instance_scenario(instance_uuid)
sce_vnf["datacenter_tenant_id"]))
myvims[datacenter_key] = None
else:
sce_vnf["datacenter_tenant_id"]))
myvims[datacenter_key] = None
else:
- myvims[datacenter_key] = vims.values()[0]
+ myvims[datacenter_key] = list(vims.values())[0]
myvim = myvims[datacenter_key]
myvim_thread = myvim_threads[datacenter_key]
for vm in sce_vnf['vms']:
myvim = myvims[datacenter_key]
myvim_thread = myvim_threads[datacenter_key]
for vm in sce_vnf['vms']:
logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
myvims[datacenter_key] = None
else:
logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
myvims[datacenter_key] = None
else:
- myvims[datacenter_key] = vims.values()[0]
+ myvims[datacenter_key] = list(vims.values())[0]
myvim = myvims[datacenter_key]
myvim_thread = myvim_threads[datacenter_key]
myvim = myvims[datacenter_key]
myvim_thread = myvim_threads[datacenter_key]
logger.debug("delete_instance done DB tables: %s",
yaml.safe_dump(db_tables, indent=4, default_flow_style=False))
mydb.new_rows(db_tables, ())
logger.debug("delete_instance done DB tables: %s",
yaml.safe_dump(db_tables, indent=4, default_flow_style=False))
mydb.new_rows(db_tables, ())
- for myvim_thread_id in vimthread_affected.keys():
+ for myvim_thread_id in list(vimthread_affected.keys()):
vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions)
if len(error_msg) > 0:
vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions)
if len(error_msg) > 0:
vims = get_vim(mydb, nfvo_tenant, instanceDict['datacenter_id'])
if len(vims) == 0:
raise NfvoException("datacenter '{}' not found".format(str(instanceDict['datacenter_id'])), HTTP_Not_Found)
vims = get_vim(mydb, nfvo_tenant, instanceDict['datacenter_id'])
if len(vims) == 0:
raise NfvoException("datacenter '{}' not found".format(str(instanceDict['datacenter_id'])), HTTP_Not_Found)
- myvim = vims.values()[0]
+ myvim = list(vims.values())[0]
if action_dict.get("create-vdu"):
for vdu in action_dict["create-vdu"]:
if action_dict.get("create-vdu"):
for vdu in action_dict["create-vdu"]:
if name and len(content)==1:
return {item[:-1]: content[0]}
elif name and len(content)==0:
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())),
+ raise NfvoException("No {} found with ".format(item[:-1]) + " and ".join([str(x[0])+": "+str(x[1]) for x in iter(filter_dict.items())]),
datacenter)
else:
return {item: content}
except vimconn.vimconnException as e:
datacenter)
else:
return {item: content}
except vimconn.vimconnException as e:
- print "vim_action Not possible to get_%s_list from VIM: %s " % (item, str(e))
+ print("vim_action Not possible to get_%s_list from VIM: %s " % (item, str(e)))
raise NfvoException("Not possible to get_{}_list from VIM: {}".format(item, str(e)), e.http_code)
raise NfvoException("Not possible to get_{}_list from VIM: {}".format(item, str(e)), e.http_code)
#get uuid name
content = vim_action_get(mydb, tenant_id, datacenter, item, name)
logger.debug("vim_action_delete vim response: " + str(content))
#get uuid name
content = vim_action_get(mydb, tenant_id, datacenter, item, name)
logger.debug("vim_action_delete vim response: " + str(content))
- items = content.values()[0]
+ items = list(content.values())[0]
if type(items)==list and len(items)==0:
raise NfvoException("Not found " + item, HTTP_Not_Found)
elif type(items)==list and len(items)>1:
if type(items)==list and len(items)==0:
raise NfvoException("Not found " + item, HTTP_Not_Found)
elif type(items)==list and len(items)>1:
__author__="Alfonso Tierno, Gerardo Garcia, Pablo Montes"
__date__ ="$28-aug-2014 10:05:01$"
__author__="Alfonso Tierno, Gerardo Garcia, Pablo Montes"
__date__ ="$28-aug-2014 10:05:01$"
import MySQLdb as mdb
import json
import yaml
import MySQLdb as mdb
import json
import yaml
#print "Adding new vms to the NFVO database"
#For each vm, we must create the appropriate vm in the NFVO database.
vmDict = {}
#print "Adding new vms to the NFVO database"
#For each vm, we must create the appropriate vm in the NFVO database.
vmDict = {}
- for _,vm in VNFCDict.iteritems():
+ for _,vm in VNFCDict.items():
#This code could make the name of the vms grow and grow.
#If we agree to follow this convention, we should check with a regex that the vnfc name is not including yet the vnf name
#vm['name'] = "%s-%s" % (vnf_name,vm['name'])
#This code could make the name of the vms grow and grow.
#If we agree to follow this convention, we should check with a regex that the vnfc name is not including yet the vnf name
#vm['name'] = "%s-%s" % (vnf_name,vm['name'])
#print "Adding new vms to the NFVO database"
#For each vm, we must create the appropriate vm in the NFVO database.
vmDict = {}
#print "Adding new vms to the NFVO database"
#For each vm, we must create the appropriate vm in the NFVO database.
vmDict = {}
- for _,vm in VNFCDict.iteritems():
+ for _,vm in VNFCDict.items():
#This code could make the name of the vms grow and grow.
#If we agree to follow this convention, we should check with a regex that the vnfc name is not including yet the vnf name
#vm['name'] = "%s-%s" % (vnf_name,vm['name'])
#This code could make the name of the vms grow and grow.
#If we agree to follow this convention, we should check with a regex that the vnfc name is not including yet the vnf name
#vm['name'] = "%s-%s" % (vnf_name,vm['name'])
scenario_uuid = self._new_row_internal('scenarios', INSERT_, add_uuid=True, root_uuid=None, created_time=created_time)
#sce_nets
scenario_uuid = self._new_row_internal('scenarios', INSERT_, add_uuid=True, root_uuid=None, created_time=created_time)
#sce_nets
- for net in scenario_dict['nets'].values():
+ for net in list(scenario_dict['nets'].values()):
net_dict={'scenario_id': scenario_uuid}
net_dict["name"] = net["name"]
net_dict["type"] = net["type"]
net_dict={'scenario_id': scenario_uuid}
net_dict["name"] = net["name"]
net_dict["type"] = net["type"]
self._new_row_internal('ip_profiles', myIPProfileDict)
# sce_vnfs
self._new_row_internal('ip_profiles', myIPProfileDict)
# sce_vnfs
- for k, vnf in scenario_dict['vnfs'].items():
+ for k, vnf in list(scenario_dict['vnfs'].items()):
INSERT_ = {'scenario_id': scenario_uuid,
'name': k,
'vnf_id': vnf['uuid'],
INSERT_ = {'scenario_id': scenario_uuid,
'name': k,
'vnf_id': vnf['uuid'],
root_uuid=scenario_uuid, created_time=created_time)
vnf['scn_vnf_uuid']=scn_vnf_uuid
# sce_interfaces
root_uuid=scenario_uuid, created_time=created_time)
vnf['scn_vnf_uuid']=scn_vnf_uuid
# sce_interfaces
- for iface in vnf['ifaces'].values():
+ for iface in list(vnf['ifaces'].values()):
# print 'iface', iface
if 'net_key' not in iface:
continue
# print 'iface', iface
if 'net_key' not in iface:
continue
WHERE_={'tenant_id': tenant_id, 'uuid': scenario_uuid}
item_changed += self._update_rows('scenarios', UPDATE_, WHERE_, modified_time=modified_time)
#sce_nets
WHERE_={'tenant_id': tenant_id, 'uuid': scenario_uuid}
item_changed += self._update_rows('scenarios', UPDATE_, WHERE_, modified_time=modified_time)
#sce_nets
- for node_id, node in nodes.items():
+ for node_id, node in list(nodes.items()):
if "graph" in node:
#node["graph"] = yaml.safe_dump(node["graph"],default_flow_style=True,width=256)
#TODO, must be json because of the GUI, change to yaml
if "graph" in node:
#node["graph"] = yaml.safe_dump(node["graph"],default_flow_style=True,width=256)
#TODO, must be json because of the GUI, change to yaml
with self.con:
self.cur = self.con.cursor()
for table in tables:
with self.con:
self.cur = self.con.cursor()
for table in tables:
- for table_name, row_list in table.items():
+ for table_name, row_list in list(table.items()):
index = 0
if isinstance(row_list, dict):
row_list = (row_list, ) #create a list with the single value
index = 0
if isinstance(row_list, dict):
row_list = (row_list, ) #create a list with the single value
net["vim_id_sites"]["datacenter_site_id"] = {datacenter_site_id: net['vim_id']}
sce_net_id = net.get("uuid")
net["vim_id_sites"]["datacenter_site_id"] = {datacenter_site_id: net['vim_id']}
sce_net_id = net.get("uuid")
- for datacenter_site_id,vim_id in net["vim_id_sites"].iteritems():
+ for datacenter_site_id,vim_id in net["vim_id_sites"].items():
INSERT_={'vim_net_id': vim_id, 'created': net.get('created', False), 'instance_scenario_id':instance_uuid } #, 'type': net['type']
INSERT_['datacenter_id'] = datacenter_site_id
INSERT_['datacenter_tenant_id'] = scenarioDict["datacenter2tenant"][datacenter_site_id]
INSERT_={'vim_net_id': vim_id, 'created': net.get('created', False), 'instance_scenario_id':instance_uuid } #, 'type': net['type']
INSERT_['datacenter_id'] = datacenter_site_id
INSERT_['datacenter_tenant_id'] = scenarioDict["datacenter2tenant"][datacenter_site_id]
if sys.version_info.major == 3:
from urllib.parse import quote
elif sys.version_info.major == 2:
if sys.version_info.major == 3:
from urllib.parse import quote
elif sys.version_info.major == 2:
- from urllib import quote
+ from urllib.parse import quote
class OpenmanoException(Exception):
'''Common Exception for all openmano client exceptions'''
class OpenmanoException(Exception):
'''Common Exception for all openmano client exceptions'''
#print "Input data: ", str(client_data)
return True, client_data
except js_e.ValidationError as exc:
#print "Input data: ", str(client_data)
return True, client_data
except js_e.ValidationError as exc:
- print "validate_in error, jsonschema exception ", exc.message, "at", exc.path
+ print("validate_in error, jsonschema exception ", exc.message, "at", exc.path)
return False, ("validate_in error, jsonschema exception ", exc.message, "at", exc.path)
def remove_extra_items(data, schema):
return False, ("validate_in error, jsonschema exception ", exc.message, "at", exc.path)
def remove_extra_items(data, schema):
#TODO deal with patternProperties
if 'properties' not in schema:
return None
#TODO deal with patternProperties
if 'properties' not in schema:
return None
- for k in data.keys():
- if k not in schema['properties'].keys():
+ for k in list(data.keys()):
+ if k not in list(schema['properties'].keys()):
del data[k]
deleted.append(k)
else:
del data[k]
deleted.append(k)
else:
None
'''
if type(data) is dict:
None
'''
if type(data) is dict:
+ for k in list(data.keys()):
if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
convert_bandwidth(data[k], reverse)
if "bandwidth" in data:
if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
convert_bandwidth(data[k], reverse)
if "bandwidth" in data:
if value % 1000 == 0: data["bandwidth"]=str(value/1000) + " Gbps"
else: data["bandwidth"]=str(value) + " Mbps"
except:
if value % 1000 == 0: data["bandwidth"]=str(value/1000) + " Gbps"
else: data["bandwidth"]=str(value) + " Mbps"
except:
- print "convert_bandwidth exception for type", type(data["bandwidth"]), " data", data["bandwidth"]
+ print("convert_bandwidth exception for type", type(data["bandwidth"]), " data", data["bandwidth"])
return
if type(data) is tuple or type(data) is list:
for k in data:
return
if type(data) is tuple or type(data) is list:
for k in data:
It enters recursively in the dict var finding this kind of variables
'''
if type(var) is dict:
It enters recursively in the dict var finding this kind of variables
'''
if type(var) is dict:
- for k,v in var.items():
+ for k,v in list(var.items()):
if type(v) is datetime.datetime:
var[k]= v.strftime('%Y-%m-%dT%H:%M:%S')
elif type(v) is dict or type(v) is list or type(v) is tuple:
if type(v) is datetime.datetime:
var[k]= v.strftime('%Y-%m-%dT%H:%M:%S')
elif type(v) is dict or type(v) is list or type(v) is tuple:
None
'''
if type(data) is dict:
None
'''
if type(data) is dict:
+ for k in list(data.keys()):
if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
convert_str2boolean(data[k], items)
if k in items:
if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
convert_str2boolean(data[k], items)
if k in items:
import threading
import time
import threading
import time
-from db_base import db_base_Exception
+from .db_base import db_base_Exception
from lib_osm_openvim.ovim import ovimException
__author__ = "Alfonso Tierno, Pablo Montes"
from lib_osm_openvim.ovim import ovimException
__author__ = "Alfonso Tierno, Pablo Montes"
self.db_lock = db_lock
self.task_lock = task_lock
self.db_lock = db_lock
self.task_lock = task_lock
- self.task_queue = Queue.Queue(2000)
+ self.task_queue = queue.Queue(2000)
self.refresh_tasks = []
"""Contains time ordered task list for refreshing the status of VIM VMs and nets"""
self.refresh_tasks = []
"""Contains time ordered task list for refreshing the status of VIM VMs and nets"""
try:
now = time.time()
vim_dict = self.vim.refresh_vms_status(vm_to_refresh_list)
try:
now = time.time()
vim_dict = self.vim.refresh_vms_status(vm_to_refresh_list)
- for vim_id, vim_info in vim_dict.items():
+ for vim_id, vim_info in list(vim_dict.items()):
# look for task
task_need_update = False
task = vm_to_refresh_dict[vim_id]
# look for task
task_need_update = False
task = vm_to_refresh_dict[vim_id]
try:
now = time.time()
vim_dict = self.vim.refresh_nets_status(net_to_refresh_list)
try:
now = time.time()
vim_dict = self.vim.refresh_nets_status(net_to_refresh_list)
- for vim_id, vim_info in vim_dict.items():
+ for vim_id, vim_info in list(vim_dict.items()):
# look for task
task = net_to_refresh_dict[vim_id]
self.logger.debug("get-net net_id=%s result=%s", task["vim_id"], str(vim_info))
# look for task
task = net_to_refresh_dict[vim_id]
self.logger.debug("get-net net_id=%s result=%s", task["vim_id"], str(vim_info))
try:
self.task_queue.put(task, False)
return None
try:
self.task_queue.put(task, False)
return None
raise vimconn.vimconnException(self.name + ": timeout inserting a task")
def del_task(self, task):
raise vimconn.vimconnException(self.name + ": timeout inserting a task")
def del_task(self, task):
vm_vim_id = task["vim_id"]
interfaces = task["extra"].get("interfaces", ())
try:
vm_vim_id = task["vim_id"]
interfaces = task["extra"].get("interfaces", ())
try:
- for iface in interfaces.values():
+ for iface in list(interfaces.values()):
if iface.get("sdn_port_id"):
try:
with self.db_lock:
if iface.get("sdn_port_id"):
try:
with self.db_lock:
import logging
import paramiko
import socket
import logging
import paramiko
import socket
import yaml
import sys
from email.mime.multipart import MIMEMultipart
import yaml
import sys
from email.mime.multipart import MIMEMultipart
client = paramiko.SSHClient()
try:
if ro_key:
client = paramiko.SSHClient()
try:
if ro_key:
- pkey = paramiko.RSAKey.from_private_key(StringIO.StringIO(ro_key))
+ pkey = paramiko.RSAKey.from_private_key(io.StringIO(ro_key))
else:
pkey = None
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
else:
pkey = None
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
__author__ = "Saboor Ahmad"
__date__ = "10-Apr-2017"
__author__ = "Saboor Ahmad"
__date__ = "10-Apr-2017"
import yaml
import logging
import netaddr
import yaml
import logging
import netaddr
pub_subs = pub_split[:3]
subnets = pub_subs + pri_subs
pub_subs = pub_split[:3]
subnets = pub_subs + pri_subs
- return map(str, subnets)
+ return list(map(str, subnets))
def new_network(self, net_name, net_type, ip_profile=None, shared=False, vlan=None):
"""Adds a tenant network to VIM
def new_network(self, net_name, net_type, ip_profile=None, shared=False, vlan=None):
"""Adds a tenant network to VIM
self.logger.debug("Getting flavor id from data")
try:
flavor = None
self.logger.debug("Getting flavor id from data")
try:
flavor = None
- for key, values in self.flavor_info.iteritems():
+ for key, values in self.flavor_info.items():
if (values["ram"], values["cpus"], values["disk"]) == (
flavor_dict["ram"], flavor_dict["vcpus"], flavor_dict["disk"]):
flavor = (key, values)
if (values["ram"], values["cpus"], values["disk"]) == (
flavor_dict["ram"], flavor_dict["vcpus"], flavor_dict["disk"]):
flavor = (key, values)
__author__ = "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C."
__date__ = "$22-sep-2017 23:59:59$"
__author__ = "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C."
__date__ = "$22-sep-2017 23:59:59$"
import json
import logging
import netaddr
import json
import logging
import netaddr
import glanceclient.client as gl1Client
import glanceclient.exc as gl1Exceptions
from cinderclient import client as cClient
import glanceclient.client as gl1Client
import glanceclient.exc as gl1Exceptions
from cinderclient import client as cClient
-from httplib import HTTPException
+from http.client import HTTPException
from neutronclient.neutron import client as neClient
from neutronclient.common import exceptions as neExceptions
from requests.exceptions import ConnectionError
from neutronclient.neutron import client as neClient
from neutronclient.common import exceptions as neExceptions
from requests.exceptions import ConnectionError
else:
project = self.keystone.tenants.create(tenant_name, tenant_description)
return project.id
else:
project = self.keystone.tenants.create(tenant_name, tenant_description)
return project.id
- except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError) as e:
+ except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError) as e:
self._format_exception(e)
def delete_tenant(self, tenant_id):
self._format_exception(e)
def delete_tenant(self, tenant_id):
else:
self.keystone.tenants.delete(tenant_id)
return tenant_id
else:
self.keystone.tenants.delete(tenant_id)
return tenant_id
- except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError) as e:
+ except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError) as e:
self._format_exception(e)
def new_network(self,net_name, net_type, ip_profile=None, shared=False, vlan=None):
self._format_exception(e)
def new_network(self,net_name, net_type, ip_profile=None, shared=False, vlan=None):
new_image_nova.metadata.setdefault('location',image_dict['location'])
metadata_to_load = image_dict.get('metadata')
if metadata_to_load:
new_image_nova.metadata.setdefault('location',image_dict['location'])
metadata_to_load = image_dict.get('metadata')
if metadata_to_load:
- for k,v in yaml.load(metadata_to_load).iteritems():
+ for k,v in yaml.load(metadata_to_load).items():
new_image_nova.metadata.setdefault(k,v)
return new_image.id
except (nvExceptions.Conflict, ksExceptions.ClientException, nvExceptions.ClientException) as e:
new_image_nova.metadata.setdefault(k,v)
return new_image.id
except (nvExceptions.Conflict, ksExceptions.ClientException, nvExceptions.ClientException) as e:
elapsed_time = 0
while keep_waiting and elapsed_time < volume_timeout:
keep_waiting = False
elapsed_time = 0
while keep_waiting and elapsed_time < volume_timeout:
keep_waiting = False
- for volume_id in block_device_mapping.itervalues():
+ for volume_id in block_device_mapping.values():
if self.cinder.volumes.get(volume_id).status != 'available':
keep_waiting = True
if keep_waiting:
if self.cinder.volumes.get(volume_id).status != 'available':
keep_waiting = True
if keep_waiting:
#if we exceeded the timeout rollback
if elapsed_time >= volume_timeout:
#delete the volumes we just created
#if we exceeded the timeout rollback
if elapsed_time >= volume_timeout:
#delete the volumes we just created
- for volume_id in block_device_mapping.itervalues():
+ for volume_id in block_device_mapping.values():
self.cinder.volumes.delete(volume_id)
#delete ports we just created
self.cinder.volumes.delete(volume_id)
#delete ports we just created
except Exception as e:
# delete the volumes we just created
if block_device_mapping:
except Exception as e:
# delete the volumes we just created
if block_device_mapping:
- for volume_id in block_device_mapping.itervalues():
+ for volume_id in block_device_mapping.values():
self.cinder.volumes.delete(volume_id)
# Delete the VM
self.cinder.volumes.delete(volume_id)
# Delete the VM
#find unused VLAN ID
for vlanID_range in self.config.get('dataplane_net_vlan_range'):
try:
#find unused VLAN ID
for vlanID_range in self.config.get('dataplane_net_vlan_range'):
try:
- start_vlanid , end_vlanid = map(int, vlanID_range.replace(" ", "").split("-"))
- for vlanID in xrange(start_vlanid, end_vlanid + 1):
+ start_vlanid , end_vlanid = list(map(int, vlanID_range.replace(" ", "").split("-")))
+ for vlanID in range(start_vlanid, end_vlanid + 1):
if vlanID not in used_vlanIDs:
return vlanID
except Exception as exp:
if vlanID not in used_vlanIDs:
return vlanID
except Exception as exp:
raise vimconn.vimconnConflictException("Invalid dataplane_net_vlan_range {}.You must provide "\
"'dataplane_net_vlan_range' in format [start_ID - end_ID].".format(vlanID_range))
raise vimconn.vimconnConflictException("Invalid dataplane_net_vlan_range {}.You must provide "\
"'dataplane_net_vlan_range' in format [start_ID - end_ID].".format(vlanID_range))
- start_vlanid , end_vlanid = map(int,vlan_range.split("-"))
+ start_vlanid , end_vlanid = list(map(int,vlan_range.split("-")))
if start_vlanid <= 0 :
raise vimconn.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
"Start ID can not be zero. For VLAN "\
if start_vlanid <= 0 :
raise vimconn.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
"Start ID can not be zero. For VLAN "\
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
- print("delete_tenant " + error_text)
+ print(("delete_tenant " + error_text))
return error_value, error_text
def get_hosts_info(self):
return error_value, error_text
def get_hosts_info(self):
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
- print("get_hosts_info " + error_text)
+ print(("get_hosts_info " + error_text))
return error_value, error_text
def get_hosts(self, vim_tenant):
return error_value, error_text
def get_hosts(self, vim_tenant):
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
- print("get_hosts " + error_text)
+ print(("get_hosts " + error_text))
return error_value, error_text
def new_classification(self, name, ctype, definition):
return error_value, error_text
def new_classification(self, name, ctype, definition):
__author__="Alfonso Tierno, Gerardo Garcia"
__date__ ="$26-aug-2014 11:09:29$"
__author__="Alfonso Tierno, Gerardo Garcia"
__date__ ="$26-aug-2014 11:09:29$"
import requests
import json
import yaml
import logging
import requests
import json
import yaml
import logging
-from openmano_schemas import id_schema, name_schema, nameshort_schema, description_schema, \
+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
vlan1000_schema, integer0_schema
from jsonschema import validate as js_v, exceptions as js_e
-from urllib import quote
+from urllib.parse import quote
'''contain the openvim virtual machine status to openmano status'''
vmStatus2manoFormat={'ACTIVE':'ACTIVE',
'''contain the openvim virtual machine status to openmano status'''
vmStatus2manoFormat={'ACTIVE':'ACTIVE',
#print "Input data: ", str(client_data)
return True, client_data
except js_e.ValidationError as exc:
#print "Input data: ", str(client_data)
return True, client_data
except js_e.ValidationError as exc:
- print "validate_in error, jsonschema exception ", exc.message, "at", exc.path
+ print("validate_in error, jsonschema exception ", exc.message, "at", exc.path)
return False, ("validate_in error, jsonschema exception ", exc.message, "at", exc.path)
def _remove_extra_items(self, data, schema):
return False, ("validate_in error, jsonschema exception ", exc.message, "at", exc.path)
def _remove_extra_items(self, data, schema):
a= self._remove_extra_items(d, schema['items'])
if a is not None: deleted.append(a)
elif type(data) is dict:
a= self._remove_extra_items(d, schema['items'])
if a is not None: deleted.append(a)
elif type(data) is dict:
- for k in data.keys():
- if 'properties' not in schema or k not in schema['properties'].keys():
+ for k in list(data.keys()):
+ if 'properties' not in schema or k not in list(schema['properties'].keys()):
del data[k]
deleted.append(k)
else:
del data[k]
deleted.append(k)
else:
'''
filterquery=[]
filterquery_text=''
'''
filterquery=[]
filterquery_text=''
- for k,v in filter_dict.iteritems():
+ for k,v in filter_dict.items():
filterquery.append(str(k)+'='+str(v))
if len(filterquery)>0:
filterquery_text='?'+ '&'.join(filterquery)
filterquery.append(str(k)+'='+str(v))
if len(filterquery)>0:
filterquery_text='?'+ '&'.join(filterquery)
del filter_dict["tenant_id"]
filterquery=[]
filterquery_text=''
del filter_dict["tenant_id"]
filterquery=[]
filterquery_text=''
- for k,v in filter_dict.iteritems():
+ for k,v in filter_dict.items():
filterquery.append(str(k)+'='+str(v))
if len(filterquery)>0:
filterquery_text='?'+ '&'.join(filterquery)
filterquery.append(str(k)+'='+str(v))
if len(filterquery)>0:
filterquery_text='?'+ '&'.join(filterquery)
self._get_my_tenant()
filterquery=[]
filterquery_text=''
self._get_my_tenant()
filterquery=[]
filterquery_text=''
- for k,v in filter_dict.iteritems():
+ for k,v in filter_dict.items():
filterquery.append(str(k)+'='+str(v))
if len(filterquery)>0:
filterquery_text='?'+ '&'.join(filterquery)
filterquery.append(str(k)+'='+str(v))
if len(filterquery)>0:
filterquery_text='?'+ '&'.join(filterquery)
self._get_my_tenant()
except Exception as e:
return -vimconn.HTTP_Not_Found, str(e)
self._get_my_tenant()
except Exception as e:
return -vimconn.HTTP_Not_Found, str(e)
- print "VIMConnector: Adding a new VM instance from JSON to VIM"
+ print("VIMConnector: Adding a new VM instance from JSON to VIM")
payload_req = vm_data
try:
vim_response = requests.post(self.url+'/'+self.tenant+'/servers', headers = self.headers_req, data=payload_req)
except requests.exceptions.RequestException as e:
payload_req = vm_data
try:
vim_response = requests.post(self.url+'/'+self.tenant+'/servers', headers = self.headers_req, data=payload_req)
except requests.exceptions.RequestException as e:
- print "new_vminstancefromJSON Exception: ", e.args
+ print("new_vminstancefromJSON Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
return -vimconn.HTTP_Not_Found, str(e.args[0])
#print vim_response.status_code
if vim_response.status_code == 200:
#print vim_response.json()
#print vim_response.status_code
if vim_response.status_code == 200:
#print vim_response.json()
#print http_content
if res:
r = self._remove_extra_items(http_content, new_image_response_schema)
#print http_content
if res:
r = self._remove_extra_items(http_content, new_image_response_schema)
- if r is not None: print "Warning: remove extra items ", r
+ if r is not None: print("Warning: remove extra items ", r)
#print http_content
vminstance_id = http_content['server']['id']
#print http_content
vminstance_id = http_content['server']['id']
- print "Tenant image id: ",vminstance_id
+ print("Tenant image id: ",vminstance_id)
return vim_response.status_code,vminstance_id
else: return -vimconn.HTTP_Bad_Request,http_content
else:
return vim_response.status_code,vminstance_id
else: return -vimconn.HTTP_Bad_Request,http_content
else:
and append to the server_dict
'''
if type(server_dict) is not dict:
and append to the server_dict
'''
if type(server_dict) is not dict:
- print 'vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary'
+ print('vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary')
return
RAD={}
occupation={}
return
RAD={}
occupation={}
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_hosts_info Exception: ", e.args
+ print("get_hosts_info Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
+ print("vim get", url, "response:", vim_response.status_code, vim_response.json())
#print vim_response.status_code
#print json.dumps(vim_response.json(), indent=4)
if vim_response.status_code != 200:
#TODO: get error
#print vim_response.status_code
#print json.dumps(vim_response.json(), indent=4)
if vim_response.status_code != 200:
#TODO: get error
- print 'vimconnector.get_hosts_info error getting host list %d %s' %(vim_response.status_code, vim_response.json())
+ print('vimconnector.get_hosts_info error getting host list %d %s' %(vim_response.status_code, vim_response.json()))
return -vim_response.status_code, "Error getting host list"
res,hosts = self._format_in(vim_response, get_hosts_response_schema)
if res==False:
return -vim_response.status_code, "Error getting host list"
res,hosts = self._format_in(vim_response, get_hosts_response_schema)
if res==False:
- print "vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts
+ print("vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts)
return vimconn.HTTP_Internal_Server_Error, hosts
#obtain hosts details
hosts_dict={}
return vimconn.HTTP_Internal_Server_Error, hosts
#obtain hosts details
hosts_dict={}
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_hosts_info Exception: ", e.args
+ print("get_hosts_info Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
+ print("vim get", url, "response:", vim_response.status_code, vim_response.json())
if vim_response.status_code != 200:
if vim_response.status_code != 200:
- print 'vimconnector.get_hosts_info error getting detailed host %d %s' %(vim_response.status_code, vim_response.json())
+ print('vimconnector.get_hosts_info error getting detailed host %d %s' %(vim_response.status_code, vim_response.json()))
continue
res,host_detail = self._format_in(vim_response, get_host_detail_response_schema)
if res==False:
continue
res,host_detail = self._format_in(vim_response, get_host_detail_response_schema)
if res==False:
- print "vimconnector.get_hosts_info error parsing GET HOSTS/%s vim response" % host['id'], host_detail
+ print("vimconnector.get_hosts_info error parsing GET HOSTS/%s vim response" % host['id'], host_detail)
continue
#print 'host id '+host['id'], json.dumps(host_detail, indent=4)
self.host_vim2gui(host_detail, hosts_dict)
continue
#print 'host id '+host['id'], json.dumps(host_detail, indent=4)
self.host_vim2gui(host_detail, hosts_dict)
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_hosts Exception: ", e.args
+ print("get_hosts Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
+ print("vim get", url, "response:", vim_response.status_code, vim_response.json())
#print vim_response.status_code
#print json.dumps(vim_response.json(), indent=4)
if vim_response.status_code != 200:
#TODO: get error
#print vim_response.status_code
#print json.dumps(vim_response.json(), indent=4)
if vim_response.status_code != 200:
#TODO: get error
- print 'vimconnector.get_hosts error getting host list %d %s' %(vim_response.status_code, vim_response.json())
+ print('vimconnector.get_hosts error getting host list %d %s' %(vim_response.status_code, vim_response.json()))
return -vim_response.status_code, "Error getting host list"
res,hosts = self._format_in(vim_response, get_hosts_response_schema)
if res==False:
return -vim_response.status_code, "Error getting host list"
res,hosts = self._format_in(vim_response, get_hosts_response_schema)
if res==False:
- print "vimconnector.get_host error parsing GET HOSTS vim response", hosts
+ print("vimconnector.get_host error parsing GET HOSTS vim response", hosts)
return vimconn.HTTP_Internal_Server_Error, hosts
#obtain instances from hosts
for host in hosts['hosts']:
return vimconn.HTTP_Internal_Server_Error, hosts
#obtain instances from hosts
for host in hosts['hosts']:
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_hosts Exception: ", e.args
+ print("get_hosts Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
+ print("vim get", url, "response:", vim_response.status_code, vim_response.json())
if vim_response.status_code != 200:
if vim_response.status_code != 200:
- print 'vimconnector.get_hosts error getting instances at host %d %s' %(vim_response.status_code, vim_response.json())
+ print('vimconnector.get_hosts error getting instances at host %d %s' %(vim_response.status_code, vim_response.json()))
continue
res,servers = self._format_in(vim_response, get_server_response_schema)
if res==False:
continue
res,servers = self._format_in(vim_response, get_server_response_schema)
if res==False:
- print "vimconnector.get_host error parsing GET SERVERS/%s vim response" % host['id'], servers
+ print("vimconnector.get_host error parsing GET SERVERS/%s vim response" % host['id'], servers)
continue
#print 'host id '+host['id'], json.dumps(host_detail, indent=4)
host['instances'] = servers['servers']
continue
#print 'host id '+host['id'], json.dumps(host_detail, indent=4)
host['instances'] = servers['servers']
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_processor_rankings Exception: ", e.args
+ print("get_processor_rankings Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
+ print("vim get", url, "response:", vim_response.status_code, vim_response.json())
#print vim_response.status_code
#print json.dumps(vim_response.json(), indent=4)
if vim_response.status_code != 200:
#TODO: get error
#print vim_response.status_code
#print json.dumps(vim_response.json(), indent=4)
if vim_response.status_code != 200:
#TODO: get error
- print 'vimconnector.get_processor_rankings error getting processor rankings %d %s' %(vim_response.status_code, vim_response.json())
+ print('vimconnector.get_processor_rankings error getting processor rankings %d %s' %(vim_response.status_code, vim_response.json()))
return -vim_response.status_code, "Error getting processor rankings"
res,rankings = self._format_in(vim_response, get_processor_rankings_response_schema)
return -vim_response.status_code, "Error getting processor rankings"
res,rankings = self._format_in(vim_response, get_processor_rankings_response_schema)
'''Adds a external port to VIM'''
'''Returns the port identifier'''
#TODO change to logging exception code policies
'''Adds a external port to VIM'''
'''Returns the port identifier'''
#TODO change to logging exception code policies
- print "VIMConnector: Adding a new external port"
+ print("VIMConnector: Adding a new external port")
payload_req = port_data
try:
vim_response = requests.post(self.url_admin+'/ports', headers = self.headers_req, data=payload_req)
except requests.exceptions.RequestException as e:
self.logger.error("new_external_port Exception: ", str(e))
return -vimconn.HTTP_Not_Found, str(e.args[0])
payload_req = port_data
try:
vim_response = requests.post(self.url_admin+'/ports', headers = self.headers_req, data=payload_req)
except requests.exceptions.RequestException as e:
self.logger.error("new_external_port Exception: ", str(e))
return -vimconn.HTTP_Not_Found, str(e.args[0])
#print vim_response.status_code
if vim_response.status_code == 200:
#print vim_response.json()
#print vim_response.status_code
if vim_response.status_code == 200:
#print vim_response.json()
#print http_content
if res:
r = self._remove_extra_items(http_content, new_port_response_schema)
#print http_content
if res:
r = self._remove_extra_items(http_content, new_port_response_schema)
- if r is not None: print "Warning: remove extra items ", r
+ if r is not None: print("Warning: remove extra items ", r)
#print http_content
port_id = http_content['port']['id']
#print http_content
port_id = http_content['port']['id']
- print "Port id: ",port_id
+ print("Port id: ",port_id)
return vim_response.status_code,port_id
else: return -vimconn.HTTP_Bad_Request,http_content
else:
return vim_response.status_code,port_id
else: return -vimconn.HTTP_Bad_Request,http_content
else:
'''Adds a external network to VIM (shared)'''
'''Returns the network identifier'''
#TODO change to logging exception code policies
'''Adds a external network to VIM (shared)'''
'''Returns the network identifier'''
#TODO change to logging exception code policies
- print "VIMConnector: Adding external shared network to VIM (type " + net_type + "): "+ net_name
+ print("VIMConnector: Adding external shared network to VIM (type " + net_type + "): "+ net_name)
payload_req = '{"network":{"name": "' + net_name + '","shared":true,"type": "' + net_type + '"}}'
try:
payload_req = '{"network":{"name": "' + net_name + '","shared":true,"type": "' + net_type + '"}}'
try:
except requests.exceptions.RequestException as e:
self.logger.error( "new_external_network Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
except requests.exceptions.RequestException as e:
self.logger.error( "new_external_network Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
#print vim_response.status_code
if vim_response.status_code == 200:
#print vim_response.json()
#print vim_response.status_code
if vim_response.status_code == 200:
#print vim_response.json()
#print http_content
if res:
r = self._remove_extra_items(http_content, new_network_response_schema)
#print http_content
if res:
r = self._remove_extra_items(http_content, new_network_response_schema)
- if r is not None: print "Warning: remove extra items ", r
+ if r is not None: print("Warning: remove extra items ", r)
#print http_content
network_id = http_content['network']['id']
#print http_content
network_id = http_content['network']['id']
- print "Network id: ",network_id
+ print("Network id: ",network_id)
return vim_response.status_code,network_id
else: return -vimconn.HTTP_Bad_Request,http_content
else:
return vim_response.status_code,network_id
else: return -vimconn.HTTP_Bad_Request,http_content
else:
'''Connects a external port to a network'''
'''Returns status code of the VIM response'''
#TODO change to logging exception code policies
'''Connects a external port to a network'''
'''Returns status code of the VIM response'''
#TODO change to logging exception code policies
- print "VIMConnector: Connecting external port to network"
+ print("VIMConnector: Connecting external port to network")
payload_req = '{"port":{"network_id":"' + network_id + '"}}'
if admin:
payload_req = '{"port":{"network_id":"' + network_id + '"}}'
if admin:
try:
vim_response = requests.put(url +'/ports/'+port_id, headers = self.headers_req, data=payload_req)
except requests.exceptions.RequestException as e:
try:
vim_response = requests.put(url +'/ports/'+port_id, headers = self.headers_req, data=payload_req)
except requests.exceptions.RequestException as e:
- print "connect_port_network Exception: ", e.args
+ print("connect_port_network Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
return -vimconn.HTTP_Not_Found, str(e.args[0])
#print vim_response.status_code
if vim_response.status_code == 200:
#print vim_response.json()
#print vim_response.status_code
if vim_response.status_code == 200:
#print vim_response.json()
#print http_content
if res:
r = self._remove_extra_items(http_content, new_port_response_schema)
#print http_content
if res:
r = self._remove_extra_items(http_content, new_port_response_schema)
- if r is not None: print "Warning: remove extra items ", r
+ if r is not None: print("Warning: remove extra items ", r)
#print http_content
port_id = http_content['port']['id']
#print http_content
port_id = http_content['port']['id']
- print "Port id: ",port_id
+ print("Port id: ",port_id)
return vim_response.status_code,port_id
else: return -vimconn.HTTP_Bad_Request,http_content
else:
return vim_response.status_code,port_id
else: return -vimconn.HTTP_Bad_Request,http_content
else:
- print vim_response.text
+ print(vim_response.text)
jsonerror = self._format_jsonerror(vim_response)
text = 'Error in VIM "%s": not possible to connect external port to network. HTTP Response: %d. Error: %s' % (self.url_admin, vim_response.status_code, jsonerror)
jsonerror = self._format_jsonerror(vim_response)
text = 'Error in VIM "%s": not possible to connect external port to network. HTTP Response: %d. Error: %s' % (self.url_admin, vim_response.status_code, jsonerror)
return -vim_response.status_code,text
return -vim_response.status_code,text
"""
from progressbar import Percentage, Bar, ETA, FileTransferSpeed, ProgressBar
"""
from progressbar import Percentage, Bar, ETA, FileTransferSpeed, ProgressBar
import os
import traceback
import itertools
import os
import traceback
import itertools
import json
import time
import uuid
import json
import time
import uuid
import hashlib
import socket
import struct
import hashlib
import socket
import struct
raise vimconn.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
raise vimconn.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
- namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.iteritems() if prefix}
+ namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
vdc_remove_href = lxmlroot_respond.find("xmlns:Link[@rel='remove']",namespaces).attrib['href']
vdc_remove_href = vdc_remove_href + '?recursive=true&force=true'
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
vdc_remove_href = lxmlroot_respond.find("xmlns:Link[@rel='remove']",namespaces).attrib['href']
vdc_remove_href = vdc_remove_href + '?recursive=true&force=true'
raise vimconn.vimconnNotFoundException("Fail to get image {}".format(image_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
raise vimconn.vimconnNotFoundException("Fail to get image {}".format(image_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
- namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.iteritems() if prefix}
+ namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
catalogItems_section = lxmlroot_respond.find("xmlns:CatalogItems",namespaces)
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
catalogItems_section = lxmlroot_respond.find("xmlns:CatalogItems",namespaces)
image_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
image_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
- namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.iteritems() if prefix}
+ namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
catalogitem_remove_href = lxmlroot_respond.find("xmlns:Link[@rel='remove']",namespaces).attrib['href']
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
catalogitem_remove_href = lxmlroot_respond.find("xmlns:Link[@rel='remove']",namespaces).attrib['href']
for catalog in vca.get_catalogs():
if catalog_name != catalog.name:
continue
for catalog in vca.get_catalogs():
if catalog_name != catalog.name:
continue
- link = filter(lambda link: link.get_type() == "application/vnd.vmware.vcloud.media+xml" and
- link.get_rel() == 'add', catalog.get_Link())
+ link = [link for link in catalog.get_Link() if link.get_type() == "application/vnd.vmware.vcloud.media+xml" and
+ link.get_rel() == 'add']
assert len(link) == 1
data = """
<UploadVAppTemplateParams name="%s" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>%s vApp Template</Description></UploadVAppTemplateParams>
assert len(link) == 1
data = """
<UploadVAppTemplateParams name="%s" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>%s vApp Template</Description></UploadVAppTemplateParams>
if response.status_code == requests.codes.ok:
media = mediaType.parseString(response.content, True)
number_of_files = len(media.get_Files().get_File())
if response.status_code == requests.codes.ok:
media = mediaType.parseString(response.content, True)
number_of_files = len(media.get_Files().get_File())
- for index in xrange(0, number_of_files):
- links_list = filter(lambda link: link.get_rel() == 'upload:default',
- media.get_Files().get_File()[index].get_Link())
+ for index in range(0, number_of_files):
+ links_list = [link for link in media.get_Files().get_File()[index].get_Link() if link.get_rel() == 'upload:default']
for link in links_list:
# we skip ovf since it already uploaded.
if 'ovf' in link.get_href():
for link in links_list:
# we skip ovf since it already uploaded.
if 'ovf' in link.get_href():
hrefvmdk = link.get_href()
if progress:
hrefvmdk = link.get_href()
if progress:
- print("Uploading file: {}".format(file_vmdk))
+ print(("Uploading file: {}".format(file_vmdk)))
if progress:
widgets = ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
FileTransferSpeed()]
if progress:
widgets = ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
FileTransferSpeed()]
return None
# UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
try:
return None
# UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
try:
- refs = filter(lambda ref: ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml',
- vdc.ResourceEntities.ResourceEntity)
+ refs = [ref for ref in vdc.ResourceEntities.ResourceEntity if ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
if len(refs) == 1:
return refs[0].href.split("vapp")[1][1:]
except Exception as e:
if len(refs) == 1:
return refs[0].href.split("vapp")[1][1:]
except Exception as e:
:param vapp_uuid:
"""
try:
:param vapp_uuid:
"""
try:
- refs = filter(lambda ref:
- ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml',
- vdc.ResourceEntities.ResourceEntity)
+ refs = [ref for ref in vdc.ResourceEntities.ResourceEntity if ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
for ref in refs:
vappid = ref.href.split("vapp")[1][1:]
# find vapp with respected vapp uuid
for ref in refs:
vappid = ref.href.split("vapp")[1][1:]
# find vapp with respected vapp uuid
- refs = filter(lambda ref: ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml',
- vdc.ResourceEntities.ResourceEntity)
+ refs = [ref for ref in vdc.ResourceEntities.ResourceEntity if ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
for ref in refs:
# we care only about UUID the rest doesn't matter
vappid = ref.href.split("vapp")[1][1:]
for ref in refs:
# we care only about UUID the rest doesn't matter
vappid = ref.href.split("vapp")[1][1:]
- NONE (No IP addressing mode specified.)"""
if primary_netname is not None:
- NONE (No IP addressing mode specified.)"""
if primary_netname is not None:
- nets = filter(lambda n: n.name == interface_net_name, self.vca.get_networks(self.tenant_name))
+ nets = [n for n in self.vca.get_networks(self.tenant_name) if n.name == interface_net_name]
if len(nets) == 1:
self.logger.info("new_vminstance(): Found requested network: {}".format(nets[0].name))
if len(nets) == 1:
self.logger.info("new_vminstance(): Found requested network: {}".format(nets[0].name))
result = self.vca.block_until_completed(power_task)
self.instance_actions_result("resume", result, vapp_name)
elif "shutoff" in action_dict or "shutdown" in action_dict:
result = self.vca.block_until_completed(power_task)
self.instance_actions_result("resume", result, vapp_name)
elif "shutoff" in action_dict or "shutdown" in action_dict:
- action_name , value = action_dict.items()[0]
+ action_name , value = list(action_dict.items())[0]
self.logger.info("action_vminstance: {} vApp: {}".format(action_name, vapp_name))
power_off_task = the_vapp.undeploy(action='powerOff')
result = self.vca.block_until_completed(power_off_task)
self.logger.info("action_vminstance: {} vApp: {}".format(action_name, vapp_name))
power_off_task = the_vapp.undeploy(action='powerOff')
result = self.vca.block_until_completed(power_off_task)
org_dict = self.get_org(self.org_uuid)
if org_dict and 'networks' in org_dict:
org_network_dict = org_dict['networks']
org_dict = self.get_org(self.org_uuid)
if org_dict and 'networks' in org_dict:
org_network_dict = org_dict['networks']
- for net_uuid,net_name in org_network_dict.iteritems():
+ for net_uuid,net_name in org_network_dict.items():
if net_name == network_name:
return net_uuid
if net_name == network_name:
return net_uuid
vm_list_rest_call = ''.join(url_list)
if not (not vca.vcloud_session or not vca.vcloud_session.organization):
vm_list_rest_call = ''.join(url_list)
if not (not vca.vcloud_session or not vca.vcloud_session.organization):
- refs = filter(lambda ref: ref.name == vdc_name and ref.type_ == 'application/vnd.vmware.vcloud.vdc+xml',
- vca.vcloud_session.organization.Link)
+ refs = [ref for ref in vca.vcloud_session.organization.Link if ref.name == vdc_name and ref.type_ == 'application/vnd.vmware.vcloud.vdc+xml']
if len(refs) == 1:
response = Http.get(url=vm_list_rest_call,
headers=vca.vcloud_session.get_vcloud_headers(),
if len(refs) == 1:
response = Http.get(url=vm_list_rest_call,
headers=vca.vcloud_session.get_vcloud_headers(),
return None
try:
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
return None
try:
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
- namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.iteritems() if prefix}
+ namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
for item in lxmlroot_respond.iterfind('xmlns:Item',namespaces):
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
for item in lxmlroot_respond.iterfind('xmlns:Item',namespaces):
try:
#Find but type & max of instance IDs assigned to disks
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
try:
#Find but type & max of instance IDs assigned to disks
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
- namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.iteritems() if prefix}
+ namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
instance_id = 0
for item in lxmlroot_respond.iterfind('xmlns:Item',namespaces):
namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
instance_id = 0
for item in lxmlroot_respond.iterfind('xmlns:Item',namespaces):
catalog = self.get_catalog_obj(image_id, catalogs)
if catalog:
template_name = self.get_catalogbyid(image_id, catalogs)
catalog = self.get_catalog_obj(image_id, catalogs)
if catalog:
template_name = self.get_catalogbyid(image_id, catalogs)
- catalog_items = filter(lambda catalogItemRef: catalogItemRef.get_name() == template_name, catalog.get_CatalogItems().get_CatalogItem())
+ catalog_items = [catalogItemRef for catalogItemRef in catalog.get_CatalogItems().get_CatalogItem() if catalogItemRef.get_name() == template_name]
if len(catalog_items) == 1:
response = Http.get(catalog_items[0].get_href(),
headers=vca.vcloud_session.get_vcloud_headers(),
if len(catalog_items) == 1:
response = Http.get(catalog_items[0].get_href(),
headers=vca.vcloud_session.get_vcloud_headers(),
if "used_vlanIDs" not in self.persistent_info:
self.persistent_info["used_vlanIDs"] = {}
else:
if "used_vlanIDs" not in self.persistent_info:
self.persistent_info["used_vlanIDs"] = {}
else:
- used_ids = self.persistent_info["used_vlanIDs"].values()
+ used_ids = list(self.persistent_info["used_vlanIDs"].values())
for vlanID_range in self.config.get('vlanID_range'):
start_vlanid , end_vlanid = vlanID_range.split("-")
for vlanID_range in self.config.get('vlanID_range'):
start_vlanid , end_vlanid = vlanID_range.split("-")
raise vimconn.vimconnConflictException("Invalid vlan ID range {}".format(
vlanID_range))
raise vimconn.vimconnConflictException("Invalid vlan ID range {}".format(
vlanID_range))
- for id in xrange(int(start_vlanid), int(end_vlanid) + 1):
+ for id in range(int(start_vlanid), int(end_vlanid) + 1):
if id not in used_ids:
vlan_id = id
self.persistent_info["used_vlanIDs"][network_name] = vlan_id
if id not in used_ids:
vlan_id = id
self.persistent_info["used_vlanIDs"][network_name] = vlan_id
Args : None
Return : None
"""
Args : None
Return : None
"""
sys.stdout.flush()
def start_progressbar(self):
sys.stdout.flush()
def start_progressbar(self):
import subprocess
import yaml
from lxml import etree as ET
import subprocess
import yaml
from lxml import etree as ET
-from command_progress import CommandProgressbar
+from .command_progress import CommandProgressbar
#file paths
MODULE_DIR = os.path.dirname(__file__)
#file paths
MODULE_DIR = os.path.dirname(__file__)
root = OVF_tree.getroot()
#Collect namespaces
root = OVF_tree.getroot()
#Collect namespaces
- nsmap = {k:v for k,v in root.nsmap.iteritems() if k}
+ nsmap = {k:v for k,v in root.nsmap.items() if k}
nsmap["xmlns"]= "http://schemas.dmtf.org/ovf/envelope/1"
#Edit OVF template
nsmap["xmlns"]= "http://schemas.dmtf.org/ovf/envelope/1"
#Edit OVF template
if os.path.isfile(self.output_path):
logger.info("Successfully written output OVF at {}".format(self.output_path))
if os.path.isfile(self.output_path):
logger.info("Successfully written output OVF at {}".format(self.output_path))
- print("Output OVF is at : {}".format(self.output_path))
+ print(("Output OVF is at : {}".format(self.output_path)))
return self.output_path
else:
error_msg = "ERROR: Error occurred while creating OVF file"
return self.output_path
else:
error_msg = "ERROR: Error occurred while creating OVF file"
os_info = self.__read_yaml_file(OS_INFO_FILE_PATH)
try:
if self.os_type and os_info:
os_info = self.__read_yaml_file(OS_INFO_FILE_PATH)
try:
if self.os_type and os_info:
- for os_id , os_type in os_info.iteritems():
+ for os_id , os_type in os_info.items():
if self.os_type.lower() == os_type.lower():
osID = os_id
osType = os_type
if self.os_type.lower() == os_type.lower():
osID = os_id
osType = os_type
disk_controller_info = self.__read_yaml_file(DISK_CONTROLLER_INFO_FILE_PATH)
try:
if self.disk_controller and disk_controller_info:
disk_controller_info = self.__read_yaml_file(DISK_CONTROLLER_INFO_FILE_PATH)
try:
if self.disk_controller and disk_controller_info:
- for key , value in disk_controller_info.iteritems():
+ for key , value in disk_controller_info.items():
if self.disk_controller.lower() in key.lower():
disk_controller['controllerName'] = key
disk_controller['resourceType'] = str(value["ResourceType"])
if self.disk_controller.lower() in key.lower():
disk_controller['controllerName'] = key
disk_controller['resourceType'] = str(value["ResourceType"])
-from converter import OVFConverter , get_version
+from .converter import OVFConverter , get_version
from pyvcloud import Http
import logging
from pyvcloud import Http
import logging
import time
import uuid
import urllib3
import requests
import time
import uuid
import urllib3
import requests
-from vimconn_vmware import vimconnector
+from .vimconn_vmware import vimconnector
from requests.packages.urllib3.exceptions import InsecureRequestWarning
from prettytable import PrettyTable
from requests.packages.urllib3.exceptions import InsecureRequestWarning
from prettytable import PrettyTable
verify=vca.verify,
logger=vca.logger)
if response.status_code == requests.codes.ok:
verify=vca.verify,
logger=vca.logger)
if response.status_code == requests.codes.ok:
+ print(response.content)
return response.content
return None
return response.content
return None
def print_org(org_dict=None):
def print_org(org_dict=None):
entry = [k, org_dict[k]]
org_table.add_row(entry)
entry = [k, org_dict[k]]
org_table.add_row(entry)
def print_vm_list(vm_dict=None):
def print_vm_list(vm_dict=None):
entry.append(vm_dict[k]['memoryMB'])
entry.append(vm_dict[k]['status'])
vm_table.add_row(entry)
entry.append(vm_dict[k]['memoryMB'])
entry.append(vm_dict[k]['status'])
vm_table.add_row(entry)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
pass
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
pass
return
try:
vdcs_dict = {}
return
try:
vdcs_dict = {}
- if org_dict.has_key('vdcs'):
vdcs_dict = org_dict['vdcs']
vdc_table = PrettyTable(['vdc uuid', 'vdc name'])
for k in vdcs_dict:
entry = [k, vdcs_dict[k]]
vdc_table.add_row(entry)
vdcs_dict = org_dict['vdcs']
vdc_table = PrettyTable(['vdc uuid', 'vdc name'])
for k in vdcs_dict:
entry = [k, vdcs_dict[k]]
vdc_table.add_row(entry)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
return
try:
network_dict = {}
return
try:
network_dict = {}
- if org_dict.has_key('networks'):
+ if 'networks' in org_dict:
network_dict = org_dict['networks']
network_table = PrettyTable(['network uuid', 'network name'])
for k in network_dict:
entry = [k, network_dict[k]]
network_table.add_row(entry)
network_dict = org_dict['networks']
network_table = PrettyTable(['network uuid', 'network name'])
for k in network_dict:
entry = [k, network_dict[k]]
network_table.add_row(entry)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
print_vdc_list(org_dict=org_dict)
print_network_list(org_dict=org_dict)
print_vdc_list(org_dict=org_dict)
print_network_list(org_dict=org_dict)
- if org_dict.has_key('catalogs'):
+ if 'catalogs' in org_dict:
catalogs_dict = org_dict['catalogs']
catalog_table = PrettyTable(['catalog uuid', 'catalog name'])
catalogs_dict = org_dict['catalogs']
catalog_table = PrettyTable(['catalog uuid', 'catalog name'])
entry = [k, catalogs_dict[k]]
catalog_table.add_row(entry)
entry = [k, catalogs_dict[k]]
catalog_table.add_row(entry)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
def print_network_details(network_dict=None):
try:
def print_network_details(network_dict=None):
try:
- network_table = PrettyTable(network_dict.keys())
- entry = [network_dict.values()]
+ network_table = PrettyTable(list(network_dict.keys()))
+ entry = [list(network_dict.values())]
network_table.add_row(entry[0])
network_table.add_row(entry[0])
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
try:
for element in generic_dict:
try:
for element in generic_dict:
- table = PrettyTable(element.keys())
- entry = [element.values()]
+ table = PrettyTable(list(element.keys()))
+ entry = [list(element.values())]
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
if not namespace.uuid:
vapp_uuid = vim.get_vappid(vdc=namespace.vcdvdc, vapp_name=namespace.vapp_name)
if vapp_uuid is None:
if not namespace.uuid:
vapp_uuid = vim.get_vappid(vdc=namespace.vcdvdc, vapp_name=namespace.vapp_name)
if vapp_uuid is None:
- print("Can't find vapp by given name {}".format(namespace.vapp_name))
+ print(("Can't find vapp by given name {}".format(namespace.vapp_name)))
- print " namespace {}".format(namespace)
+ print(" namespace {}".format(namespace))
if vapp_dict is not None and namespace.osm:
vm_info_dict = vim.get_vminstance(vim_vm_uuid=vapp_uuid)
if vapp_dict is not None and namespace.osm:
vm_info_dict = vim.get_vminstance(vim_vm_uuid=vapp_uuid)
if vapp_dict is not None and namespace.osm != True:
vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vapp_uuid, isuuid=True)
print_vapp(vapp_dict=vapp_dict)
if vapp_dict is not None and namespace.osm != True:
vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vapp_uuid, isuuid=True)
print_vapp(vapp_dict=vapp_dict)
# if request name based we need find UUID
# TODO optimize it or move to external function
if not namespace.uuid:
# if request name based we need find UUID
# TODO optimize it or move to external function
if not namespace.uuid:
- if not myorg.has_key('networks'):
- print("Network {} is undefined in vcloud director for org {} vdc {}".format(namespace.network_name,
+ if 'networks' not in myorg:
+ print(("Network {} is undefined in vcloud director for org {} vdc {}".format(namespace.network_name,
return
my_org_net = myorg['networks']
return
my_org_net = myorg['networks']
network_uuid = network
break
network_uuid = network
break
- print print_network_details(network_dict=vim.get_vcd_network(network_uuid=network_uuid))
+ print(print_network_details(network_dict=vim.get_vcd_network(network_uuid=network_uuid)))
def create_actions(vim=None, action=None, namespace=None):
def create_actions(vim=None, action=None, namespace=None):
logger.debug("Creating a network in vcloud director".format(namespace.network_name))
network_uuid = vim.create_network(namespace.network_name)
if network_uuid is not None:
logger.debug("Creating a network in vcloud director".format(namespace.network_name))
network_uuid = vim.create_network(namespace.network_name)
if network_uuid is not None:
- print ("Crated new network {} and uuid: {}".format(namespace.network_name, network_uuid))
+ print(("Crated new network {} and uuid: {}".format(namespace.network_name, network_uuid)))
- print ("Failed create a new network {}".format(namespace.network_name))
+ print(("Failed create a new network {}".format(namespace.network_name)))
elif action == 'vdc' or namespace.action == 'vdc':
logger.debug("Creating a new vdc in vcloud director.".format(namespace.vdc_name))
vdc_uuid = vim.create_vdc(namespace.vdc_name)
if vdc_uuid is not None:
elif action == 'vdc' or namespace.action == 'vdc':
logger.debug("Creating a new vdc in vcloud director.".format(namespace.vdc_name))
vdc_uuid = vim.create_vdc(namespace.vdc_name)
if vdc_uuid is not None:
- print ("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid))
+ print(("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid)))
- print ("Failed create a new vdc {}".format(namespace.vdc_name))
+ print(("Failed create a new vdc {}".format(namespace.vdc_name)))
try:
catalog_uuid = vim.get_image_id_from_path(path=image_file, progress=True)
if catalog_uuid is not None and validate_uuid4(catalog_uuid):
try:
catalog_uuid = vim.get_image_id_from_path(path=image_file, progress=True)
if catalog_uuid is not None and validate_uuid4(catalog_uuid):
- print("Image uploaded and uuid {}".format(catalog_uuid))
+ print(("Image uploaded and uuid {}".format(catalog_uuid)))
return True
except vimconn.vimconnException as upload_exception:
return True
except vimconn.vimconnException as upload_exception:
- print("Failed uploaded {} image".format(image_file))
- print("Error Reason: {}".format(upload_exception.message))
+ print(("Failed uploaded {} image".format(image_file)))
+ print(("Error Reason: {}".format(upload_exception.message)))
if vim_catalog is None:
return None
if vim_catalog is None:
return None
- print (" Booting {} image id {} ".format(vm_name, vim_catalog))
+ print((" Booting {} image id {} ".format(vm_name, vim_catalog)))
vm_uuid = vim.new_vminstance(name=vm_name, image_id=vim_catalog)
if vm_uuid is not None and validate_uuid4(vm_uuid):
vm_uuid = vim.new_vminstance(name=vm_name, image_id=vim_catalog)
if vm_uuid is not None and validate_uuid4(vm_uuid):
- print("Image booted and vm uuid {}".format(vm_uuid))
+ print(("Image booted and vm uuid {}".format(vm_uuid)))
vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vm_uuid, isuuid=True)
if vapp_dict is not None:
print_vapp(vapp_dict=vapp_dict)
return True
except vimconn.vimconnNotFoundException as notFound:
vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vm_uuid, isuuid=True)
if vapp_dict is not None:
print_vapp(vapp_dict=vapp_dict)
return True
except vimconn.vimconnNotFoundException as notFound:
- print("Failed boot {} image".format(image_name))
- print(notFound.message)
+ print(("Failed boot {} image".format(image_name)))
+ print((notFound.message))
except vimconn.vimconnException as vimconError:
except vimconn.vimconnException as vimconError:
- print("Failed boot {} image".format(image_name))
- print(vimconError.message)
+ print(("Failed boot {} image".format(image_name)))
+ print((vimconError.message))
- print("Failed boot {} image".format(image_name))
+ print(("Failed boot {} image".format(image_name)))
if namespace.vcdvdc is None:
while True:
if namespace.vcdvdc is None:
while True:
- vcduser = input("Enter vcd username: ")
+ vcduser = eval(input("Enter vcd username: "))
if vcduser is not None and len(vcduser) > 0:
break
else:
if vcduser is not None and len(vcduser) > 0:
break
else:
if namespace.vcdpassword is None:
while True:
if namespace.vcdpassword is None:
while True:
- vcdpasword = input("Please enter vcd password: ")
+ vcdpasword = eval(input("Please enter vcd password: "))
if vcdpasword is not None and len(vcdpasword) > 0:
break
else:
if vcdpasword is not None and len(vcdpasword) > 0:
break
else:
if namespace.vcdhost is None:
while True:
if namespace.vcdhost is None:
while True:
- vcdhost = input("Please enter vcd host name or ip: ")
+ vcdhost = eval(input("Please enter vcd host name or ip: "))
if vcdhost is not None and len(vcdhost) > 0:
break
else:
if vcdhost is not None and len(vcdhost) > 0:
break
else:
if namespace.vcdorg is None:
while True:
if namespace.vcdorg is None:
while True:
- vcdorg = input("Please enter vcd organization name: ")
+ vcdorg = eval(input("Please enter vcd organization name: "))
if vcdorg is not None and len(vcdorg) > 0:
break
else:
if vcdorg is not None and len(vcdorg) > 0:
break
else:
namespace = parser.parse_args()
# put command_line args to mapping
namespace = parser.parse_args()
# put command_line args to mapping
- command_line_args = {k: v for k, v in vars(namespace).items() if v}
+ command_line_args = {k: v for k, v in list(vars(namespace).items()) if v}
d = defaults.copy()
d.update(os.environ)
d = defaults.copy()
d.update(os.environ)
from pyvcloud import Http
import logging
from pyvcloud import Http
import logging
import time
import uuid
import urllib3
import requests
import time
import uuid
import urllib3
import requests
-from vimconn_vmware import vimconnector
+from .vimconn_vmware import vimconnector
from requests.packages.urllib3.exceptions import InsecureRequestWarning
from prettytable import PrettyTable
from requests.packages.urllib3.exceptions import InsecureRequestWarning
from prettytable import PrettyTable
verify=vca.verify,
logger=vca.logger)
if response.status_code == requests.codes.ok:
verify=vca.verify,
logger=vca.logger)
if response.status_code == requests.codes.ok:
+ print(response.content)
return response.content
return None
return response.content
return None
def print_org(org_dict=None):
def print_org(org_dict=None):
entry = [k, org_dict[k]]
org_table.add_row(entry)
entry = [k, org_dict[k]]
org_table.add_row(entry)
def print_vm_list(vm_dict=None):
def print_vm_list(vm_dict=None):
entry.append(vm_dict[k]['memoryMB'])
entry.append(vm_dict[k]['status'])
vm_table.add_row(entry)
entry.append(vm_dict[k]['memoryMB'])
entry.append(vm_dict[k]['status'])
vm_table.add_row(entry)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
pass
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
pass
return
try:
vdcs_dict = {}
return
try:
vdcs_dict = {}
- if org_dict.has_key('vdcs'):
vdcs_dict = org_dict['vdcs']
vdc_table = PrettyTable(['vdc uuid', 'vdc name'])
for k in vdcs_dict:
entry = [k, vdcs_dict[k]]
vdc_table.add_row(entry)
vdcs_dict = org_dict['vdcs']
vdc_table = PrettyTable(['vdc uuid', 'vdc name'])
for k in vdcs_dict:
entry = [k, vdcs_dict[k]]
vdc_table.add_row(entry)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
return
try:
network_dict = {}
return
try:
network_dict = {}
- if org_dict.has_key('networks'):
+ if 'networks' in org_dict:
network_dict = org_dict['networks']
network_table = PrettyTable(['network uuid', 'network name'])
for k in network_dict:
entry = [k, network_dict[k]]
network_table.add_row(entry)
network_dict = org_dict['networks']
network_table = PrettyTable(['network uuid', 'network name'])
for k in network_dict:
entry = [k, network_dict[k]]
network_table.add_row(entry)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
print_vdc_list(org_dict=org_dict)
print_network_list(org_dict=org_dict)
print_vdc_list(org_dict=org_dict)
print_network_list(org_dict=org_dict)
- if org_dict.has_key('catalogs'):
+ if 'catalogs' in org_dict:
catalogs_dict = org_dict['catalogs']
catalog_table = PrettyTable(['catalog uuid', 'catalog name'])
catalogs_dict = org_dict['catalogs']
catalog_table = PrettyTable(['catalog uuid', 'catalog name'])
entry = [k, catalogs_dict[k]]
catalog_table.add_row(entry)
entry = [k, catalogs_dict[k]]
catalog_table.add_row(entry)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
def print_network_details(network_dict=None):
try:
def print_network_details(network_dict=None):
try:
- network_table = PrettyTable(network_dict.keys())
- entry = [network_dict.values()]
+ network_table = PrettyTable(list(network_dict.keys()))
+ entry = [list(network_dict.values())]
network_table.add_row(entry[0])
network_table.add_row(entry[0])
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
try:
for element in generic_dict:
try:
for element in generic_dict:
- table = PrettyTable(element.keys())
- entry = [element.values()]
+ table = PrettyTable(list(element.keys()))
+ entry = [list(element.values())]
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
if not namespace.uuid:
vapp_uuid = vim.get_vappid(vdc=namespace.vcdvdc, vapp_name=namespace.vapp_name)
if vapp_uuid is None:
if not namespace.uuid:
vapp_uuid = vim.get_vappid(vdc=namespace.vcdvdc, vapp_name=namespace.vapp_name)
if vapp_uuid is None:
- print("Can't find vapp by given name {}".format(namespace.vapp_name))
+ print(("Can't find vapp by given name {}".format(namespace.vapp_name)))
- print " namespace {}".format(namespace)
+ print(" namespace {}".format(namespace))
if vapp_dict is not None and namespace.osm:
vm_info_dict = vim.get_vminstance(vim_vm_uuid=vapp_uuid)
if vapp_dict is not None and namespace.osm:
vm_info_dict = vim.get_vminstance(vim_vm_uuid=vapp_uuid)
if vapp_dict is not None and namespace.osm != True:
vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vapp_uuid, isuuid=True)
print_vapp(vapp_dict=vapp_dict)
if vapp_dict is not None and namespace.osm != True:
vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vapp_uuid, isuuid=True)
print_vapp(vapp_dict=vapp_dict)
# if request name based we need find UUID
# TODO optimize it or move to external function
if not namespace.uuid:
# if request name based we need find UUID
# TODO optimize it or move to external function
if not namespace.uuid:
- if not myorg.has_key('networks'):
- print("Network {} is undefined in vcloud director for org {} vdc {}".format(namespace.network_name,
+ if 'networks' not in myorg:
+ print(("Network {} is undefined in vcloud director for org {} vdc {}".format(namespace.network_name,
return
my_org_net = myorg['networks']
return
my_org_net = myorg['networks']
network_uuid = network
break
network_uuid = network
break
- print print_network_details(network_dict=vim.get_vcd_network(network_uuid=network_uuid))
+ print(print_network_details(network_dict=vim.get_vcd_network(network_uuid=network_uuid)))
def create_actions(vim=None, action=None, namespace=None):
def create_actions(vim=None, action=None, namespace=None):
logger.debug("Creating a network in vcloud director".format(namespace.network_name))
network_uuid = vim.create_network(namespace.network_name)
if network_uuid is not None:
logger.debug("Creating a network in vcloud director".format(namespace.network_name))
network_uuid = vim.create_network(namespace.network_name)
if network_uuid is not None:
- print ("Crated new network {} and uuid: {}".format(namespace.network_name, network_uuid))
+ print(("Crated new network {} and uuid: {}".format(namespace.network_name, network_uuid)))
- print ("Failed create a new network {}".format(namespace.network_name))
+ print(("Failed create a new network {}".format(namespace.network_name)))
elif action == 'vdc' or namespace.action == 'vdc':
logger.debug("Creating a new vdc in vcloud director.".format(namespace.vdc_name))
vdc_uuid = vim.create_vdc(namespace.vdc_name)
if vdc_uuid is not None:
elif action == 'vdc' or namespace.action == 'vdc':
logger.debug("Creating a new vdc in vcloud director.".format(namespace.vdc_name))
vdc_uuid = vim.create_vdc(namespace.vdc_name)
if vdc_uuid is not None:
- print ("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid))
+ print(("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid)))
- print ("Failed create a new vdc {}".format(namespace.vdc_name))
+ print(("Failed create a new vdc {}".format(namespace.vdc_name)))
try:
catalog_uuid = vim.get_image_id_from_path(path=image_file, progress=True)
if catalog_uuid is not None and validate_uuid4(catalog_uuid):
try:
catalog_uuid = vim.get_image_id_from_path(path=image_file, progress=True)
if catalog_uuid is not None and validate_uuid4(catalog_uuid):
- print("Image uploaded and uuid {}".format(catalog_uuid))
+ print(("Image uploaded and uuid {}".format(catalog_uuid)))
return True
except vimconn.vimconnException as upload_exception:
return True
except vimconn.vimconnException as upload_exception:
- print("Failed uploaded {} image".format(image_file))
- print("Error Reason: {}".format(upload_exception.message))
+ print(("Failed uploaded {} image".format(image_file)))
+ print(("Error Reason: {}".format(upload_exception.message)))
if vim_catalog is None:
return None
if vim_catalog is None:
return None
- print (" Booting {} image id {} ".format(vm_name, vim_catalog))
+ print((" Booting {} image id {} ".format(vm_name, vim_catalog)))
vm_uuid = vim.new_vminstance(name=vm_name, image_id=vim_catalog)
if vm_uuid is not None and validate_uuid4(vm_uuid):
vm_uuid = vim.new_vminstance(name=vm_name, image_id=vim_catalog)
if vm_uuid is not None and validate_uuid4(vm_uuid):
- print("Image booted and vm uuid {}".format(vm_uuid))
+ print(("Image booted and vm uuid {}".format(vm_uuid)))
vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vm_uuid, isuuid=True)
if vapp_dict is not None:
print_vapp(vapp_dict=vapp_dict)
return True
except vimconn.vimconnNotFoundException as notFound:
vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vm_uuid, isuuid=True)
if vapp_dict is not None:
print_vapp(vapp_dict=vapp_dict)
return True
except vimconn.vimconnNotFoundException as notFound:
- print("Failed boot {} image".format(image_name))
- print(notFound.message)
+ print(("Failed boot {} image".format(image_name)))
+ print((notFound.message))
except vimconn.vimconnException as vimconError:
except vimconn.vimconnException as vimconError:
- print("Failed boot {} image".format(image_name))
- print(vimconError.message)
+ print(("Failed boot {} image".format(image_name)))
+ print((vimconError.message))
- print("Failed boot {} image".format(image_name))
+ print(("Failed boot {} image".format(image_name)))
if namespace.vcdvdc is None:
while True:
if namespace.vcdvdc is None:
while True:
- vcduser = input("Enter vcd username: ")
+ vcduser = eval(input("Enter vcd username: "))
if vcduser is not None and len(vcduser) > 0:
break
else:
if vcduser is not None and len(vcduser) > 0:
break
else:
if namespace.vcdpassword is None:
while True:
if namespace.vcdpassword is None:
while True:
- vcdpasword = input("Please enter vcd password: ")
+ vcdpasword = eval(input("Please enter vcd password: "))
if vcdpasword is not None and len(vcdpasword) > 0:
break
else:
if vcdpasword is not None and len(vcdpasword) > 0:
break
else:
if namespace.vcdhost is None:
while True:
if namespace.vcdhost is None:
while True:
- vcdhost = input("Please enter vcd host name or ip: ")
+ vcdhost = eval(input("Please enter vcd host name or ip: "))
if vcdhost is not None and len(vcdhost) > 0:
break
else:
if vcdhost is not None and len(vcdhost) > 0:
break
else:
if namespace.vcdorg is None:
while True:
if namespace.vcdorg is None:
while True:
- vcdorg = input("Please enter vcd organization name: ")
+ vcdorg = eval(input("Please enter vcd organization name: "))
if vcdorg is not None and len(vcdorg) > 0:
break
else:
if vcdorg is not None and len(vcdorg) > 0:
break
else:
namespace = parser.parse_args()
# put command_line args to mapping
namespace = parser.parse_args()
# put command_line args to mapping
- command_line_args = {k: v for k, v in vars(namespace).items() if v}
+ command_line_args = {k: v for k, v in list(vars(namespace).items()) if v}
d = defaults.copy()
d.update(os.environ)
d = defaults.copy()
d.update(os.environ)
projects / osm / RO.git / commitdiff