import MySQLdb as mdb
import uuid as myUuid
-import utils as af
+from . import utils as af
import json
#import yaml
import time
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:
None
'''
if type(data) is dict:
- for k in data.keys():
+ 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:
None
'''
if type(data) is dict:
- for k in data.keys():
+ 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:
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("'","_")
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 +\
- " 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.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:
#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']
- 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_
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 "
- 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:
- 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 + ")"
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:
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
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,\
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
def delete_nulls(var):
if type(var) is dict:
- for k in var.keys():
+ 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]
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:
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:
- 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 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}
#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:
# 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
-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
-from db_base import db_base_Exception
+from .db_base import db_base_Exception
-import nfvo_db
+from . import nfvo_db
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()
- 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"] = {}
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
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
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
# 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 = {
# 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 = {
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"]))
)
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"],
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 = {
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"]:
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)
- 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}]':"
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
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
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))
vnfs={}
other_nets={} #external_networks, bridge_networks and data_networkds
nodes = topo['topology']['nodes']
- for k in nodes.keys():
+ for k in list(nodes.keys()):
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
- for name,vnf in vnfs.items():
+ for name,vnf in list(vnfs.items()):
where={}
where_or={"tenant_id": tenant_id, 'public': "true"}
error_text = ""
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
- ifaces_list = conections[k]['nodes'].items()
+ ifaces_list = list(conections[k]['nodes'].items())
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
# 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:
#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)
#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'
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 = ""
# 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"]:
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)
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
# 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:
# 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")),
"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'):
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 = {
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:
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'''
- for k, v in u.iteritems():
+ for k, v in u.items():
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
- 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"]:
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']:
# 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:
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)
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']:
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]
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:
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 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:
- 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)
#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:
__author__="Alfonso Tierno, Gerardo Garcia, Pablo Montes"
__date__ ="$28-aug-2014 10:05:01$"
-import db_base
+from . import db_base
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 = {}
- 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'])
#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'])
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"]
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'],
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
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
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
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]
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'''
#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):
#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:
None
'''
if type(data) is dict:
- for k in data.keys():
+ 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 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:
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:
None
'''
if type(data) is dict:
- for k in data.keys():
+ 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:
import threading
import time
-import Queue
+import queue
import logging
-import vimconn
+from . import vimconn
import yaml
-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"
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"""
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]
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))
try:
self.task_queue.put(task, False)
return None
- except Queue.Full:
+ except queue.Full:
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:
- for iface in interfaces.values():
+ for iface in list(interfaces.values()):
if iface.get("sdn_port_id"):
try:
with self.db_lock:
import logging
import paramiko
import socket
-import StringIO
+import io
import yaml
import sys
from email.mime.multipart import MIMEMultipart
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())
__author__ = "Saboor Ahmad"
__date__ = "10-Apr-2017"
-import vimconn
+from . import vimconn
import yaml
import logging
import netaddr
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
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)
__author__ = "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C."
__date__ = "$22-sep-2017 23:59:59$"
-import vimconn
+from . import vimconn
import json
import logging
import netaddr
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
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):
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):
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:
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 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
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
#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:
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 "\
#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):
#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):
#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):
__author__="Alfonso Tierno, Gerardo Garcia"
__date__ ="$26-aug-2014 11:09:29$"
-import vimconn
+from . import vimconn
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
-from urllib import quote
+from urllib.parse import quote
'''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 "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):
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:
'''
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)
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)
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)
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:
- print "new_vminstancefromJSON Exception: ", e.args
+ print("new_vminstancefromJSON Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
- print vim_response
+ print(vim_response)
#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)
- 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 "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:
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={}
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])
- 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 '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:
- 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={}
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])
- 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:
- 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:
- 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)
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])
- 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 '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:
- 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']:
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])
- 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:
- 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:
- 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']
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])
- 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 '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)
'''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])
- print vim_response
+ print(vim_response)
#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)
- 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 "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:
'''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:
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
+ print(vim_response)
#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)
- 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 "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:
'''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:
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])
- print vim_response
+ print(vim_response)
#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)
- 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 "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:
- 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)
- print text
+ print(text)
return -vim_response.status_code,text
"""
from progressbar import Percentage, Bar, ETA, FileTransferSpeed, ProgressBar
-import vimconn
+from . import vimconn
import os
import traceback
import itertools
import json
import time
import uuid
-import httplib
+import http.client
import hashlib
import socket
import struct
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'
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)
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']
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>
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():
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()]
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:
: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
"""
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:
# 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:
- 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))
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)
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
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(),
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):
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):
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 "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("-")
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
Args : None
Return : None
"""
- print '\b.',
+ print('\b.', end=' ')
sys.stdout.flush()
def start_progressbar(self):
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__)
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
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"
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
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"])
##
import argparse
-from converter import OVFConverter , get_version
+from .converter import OVFConverter , get_version
def execute_cli():
from pyvcloud import Http
import logging
-import vimconn
+from . import vimconn
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
verify=vca.verify,
logger=vca.logger)
if response.status_code == requests.codes.ok:
- print response.content
+ print(response.content)
return response.content
return None
vm_table.add_row(entry)
- print vm_table
+ print(vm_table)
def print_org(org_dict=None):
entry = [k, org_dict[k]]
org_table.add_row(entry)
- print org_table
+ print(org_table)
def print_vm_list(vm_dict=None):
entry.append(vm_dict[k]['memoryMB'])
entry.append(vm_dict[k]['status'])
vm_table.add_row(entry)
- print vm_table
+ print(vm_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
pass
return
try:
vdcs_dict = {}
- if org_dict.has_key('vdcs'):
+ if 'vdcs' in org_dict:
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)
- print vdc_table
+ print(vdc_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
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)
- print network_table
+ print(network_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
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'])
entry = [k, catalogs_dict[k]]
catalog_table.add_row(entry)
- print catalog_table
+ print(catalog_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
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])
- print network_table
+ print(network_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
try:
for element in generic_dict:
- table = PrettyTable(element.keys())
- entry = [element.values()]
+ table = PrettyTable(list(element.keys()))
+ entry = [list(element.values())]
table.add_row(entry[0])
- print table
+ print(table)
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:
- print("Can't find vapp by given name {}".format(namespace.vapp_name))
+ print(("Can't find vapp by given name {}".format(namespace.vapp_name)))
return
- 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)
- print vm_info_dict
+ print(vm_info_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 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,
vim.name,
- vim.tenant_name))
+ vim.tenant_name)))
return
my_org_net = myorg['networks']
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):
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)))
else:
- 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:
- print ("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid))
+ print(("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid)))
else:
- print ("Failed create a new vdc {}".format(namespace.vdc_name))
+ print(("Failed create a new vdc {}".format(namespace.vdc_name)))
else:
return None
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:
- 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)))
return False
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):
- 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:
- 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:
- print("Failed boot {} image".format(image_name))
- print(vimconError.message)
+ print(("Failed boot {} image".format(image_name)))
+ print((vimconError.message))
except:
- print("Failed boot {} image".format(image_name))
+ print(("Failed boot {} image".format(image_name)))
return False
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 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 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 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:
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)
from pyvcloud import Http
import logging
-import vimconn
+from . import vimconn
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
verify=vca.verify,
logger=vca.logger)
if response.status_code == requests.codes.ok:
- print response.content
+ print(response.content)
return response.content
return None
vm_table.add_row(entry)
- print vm_table
+ print(vm_table)
def print_org(org_dict=None):
entry = [k, org_dict[k]]
org_table.add_row(entry)
- print org_table
+ print(org_table)
def print_vm_list(vm_dict=None):
entry.append(vm_dict[k]['memoryMB'])
entry.append(vm_dict[k]['status'])
vm_table.add_row(entry)
- print vm_table
+ print(vm_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
pass
return
try:
vdcs_dict = {}
- if org_dict.has_key('vdcs'):
+ if 'vdcs' in org_dict:
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)
- print vdc_table
+ print(vdc_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
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)
- print network_table
+ print(network_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
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'])
entry = [k, catalogs_dict[k]]
catalog_table.add_row(entry)
- print catalog_table
+ print(catalog_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
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])
- print network_table
+ print(network_table)
except KeyError:
logger.error("wrong key {}".format(KeyError.message))
logger.logger.debug(traceback.format_exc())
try:
for element in generic_dict:
- table = PrettyTable(element.keys())
- entry = [element.values()]
+ table = PrettyTable(list(element.keys()))
+ entry = [list(element.values())]
table.add_row(entry[0])
- print table
+ print(table)
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:
- print("Can't find vapp by given name {}".format(namespace.vapp_name))
+ print(("Can't find vapp by given name {}".format(namespace.vapp_name)))
return
- 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)
- print vm_info_dict
+ print(vm_info_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 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,
vim.name,
- vim.tenant_name))
+ vim.tenant_name)))
return
my_org_net = myorg['networks']
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):
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)))
else:
- 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:
- print ("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid))
+ print(("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid)))
else:
- print ("Failed create a new vdc {}".format(namespace.vdc_name))
+ print(("Failed create a new vdc {}".format(namespace.vdc_name)))
else:
return None
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:
- 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)))
return False
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):
- 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:
- 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:
- print("Failed boot {} image".format(image_name))
- print(vimconError.message)
+ print(("Failed boot {} image".format(image_name)))
+ print((vimconError.message))
except:
- print("Failed boot {} image".format(image_name))
+ print(("Failed boot {} image".format(image_name)))
return False
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 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 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 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:
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)
projects / osm / RO.git / commitdiff