def get_context_menu_items(self,node_id,node_type,_dc=None,menu_combo=None):
try:
self.authenticate()
result=self.getUserOps(node_id,node_type,menu_combo)
except Exception, ex:
print_traceback()
return dict(success=False,msg=to_str(ex).replace("'",""))
def remove_vm_config_file(self,dom_id,node_id):
self.authenticate()
try:
self.node_service.remove_vm_config_file(session['auth'], dom_id,node_id)
except Exception, ex:
print_traceback()
return dict(success=False,msg=to_str(ex).replace("'", " "))
def get_nw_address_space_map(self,_dc=None):
try:
self.authenticate()
result = self.network_service.get_nw_address_space_map()
except Exception, ex:
print_traceback()
return {'success':False,'msg':to_str(ex).replace("'","")}
def nw_address_changed(self, ip_value,_dc=None):
try:
self.authenticate()
result = self.network_service.nw_address_changed(ip_value)
except Exception, ex:
print_traceback()
return {'success':False,'msg':to_str(ex).replace("'","")}
def get_nw_nat_fwding_map(self,node_id,_dc=None):
try:
self.authenticate()
result = self.network_service.get_nw_nat_fwding_map(session['auth'],node_id)
except Exception, ex:
print_traceback()
return {'success':False,'msg':to_str(ex).replace("'","")}
def get_nw_defns(self,site_id=None, op_level=None, group_id=None, node_id=None, _dc=None):
try:
self.authenticate()
result = self.network_service.get_nw_defns(session['auth'],site_id,group_id, node_id, op_level)
except Exception, ex:
print_traceback()
return {'success':False,'msg':to_str(ex).replace("'","")}
def get_server_def_list(self,site_id, group_id, def_id):
try:
server_def_list=[]
node_defns = self.sync_manager.get_node_defns(def_id, to_unicode(constants.NETWORK))
if node_defns:
for eachdefn in node_defns:
temp_dic={}
if eachdefn:
node = DBSession.query(ManagedNode).filter_by(id=eachdefn.server_id).first()
temp_dic['id']=eachdefn.server_id
if node:
temp_dic['name']=node.hostname
else:
temp_dic['name']=None
temp_dic['status']=eachdefn.status
if eachdefn.details:
temp_dic['details']=eachdefn.details
else:
temp_dic['details']=None
server_def_list.append(temp_dic)
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
def get_sp_list(self, site_id, def_id=None, _dc=None):
result = None
try:
result = self.manager.get_sp_list(site_id, def_id, session['auth'])
except Exception, ex:
print_traceback()
return dict(success=False, msg=to_str(ex).replace("'",""))
def associate_defns(self, site_id, group_id, def_type, def_ids, auth, op_level=None):
error_desc=""
site = self.manager.getSite(site_id)
group=self.manager.getGroup(auth,group_id)
group_list = self.manager.getGroupList(auth, site_id)
def_id_list = def_ids.split(",")
for def_id in def_id_list:
new_sd = DBSession.query(StorageDef).filter_by(id=def_id).first()
node = None
try:
associate=True
self.sync_manager.add_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.ATTACH, "ADD_STORAGE_DEF", self.storage_manager, self.manager, op_level, associate)
#matching disks on association of storage.
vm_disks = self.manager.get_vm_disks_from_pool(auth, group_id)
storage_disks = DBSession.query(StorageDisks).filter_by(storage_id=def_id)
if storage_disks:
for eachdisk in storage_disks:
self.manager.matching_disk_on_discover_storage(vm_disks, eachdisk.id)
except Exception, ex:
error_desc = to_str(ex)
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
#if we get any exception while adding/ sync definition then are removing the definition.
add_mode=True
try:
self.sync_manager.remove_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.DETACH, "REMOVE_STORAGE_DEF", self.storage_manager, self.manager, add_mode, group_list, op_level)
except Exception, ex1:
print_traceback()
LOGGER.error(to_str(ex1).replace("'",""))
raise Exception(to_str(ex1))
if error_desc:
raise Exception(error_desc)
def has_admin_role(self):
try:
self.authenticate()
return dict(success=True,result=session['is_admin'])
except Exception, ex:
print_traceback()
return dict(success=False,msg=to_str(ex).replace("'",""))
def get_platforms(self,**kw):
try:
self.authenticate()
result = self.node_service.get_platforms()
except Exception, ex:
print_traceback()
raise ex
def remove_group(self,group_id):
self.authenticate()
try:
self.node_service.remove_group(session['auth'],group_id)
except Exception , ex:
print_traceback()
return "{success:false,msg:'",to_str(ex).replace("'",""),"'}"
def get_edit_network_details(self,nw_id):
try:
self.authenticate()
result = self.network_service.get_edit_network_details(nw_id)
except Exception, ex:
print_traceback()
return {'success':False,'msg':to_str(ex).replace("'","")}
def associate_nw_defns(self, def_ids, def_type, site_id=None, op_level=None, group_id=None, node_id=None):
self.authenticate()
try:
self.network_service.associate_nw_defns(site_id, group_id, node_id, def_type, def_ids, session['auth'], op_level)
except Exception, ex:
print_traceback()
return "{success: false,msg:'" + to_str(ex).replace("'","").replace("\n","") + "'}"
def remove_vm(self,dom_id,node_id,date=None,time=None,force="False"):
self.authenticate()
try:
self.tc.vm_remove_action(session['auth'],dom_id,node_id,eval(force),date,time)
except Exception, ex:
print_traceback()
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
def is_storage_allocated(self, storage_id):
try:
result = None
result = self.storage_service.is_storage_allocated(storage_id)
except Exception, ex:
print_traceback()
return {'success':False,'msg':to_str(ex).replace("'","")}
def get_platform(self,node_id,type,**kw):
try:
self.authenticate()
result = self.node_service.get_platform(session['auth'],node_id,type)
except Exception, ex:
print_traceback()
return {'success':'false','msg':to_str(ex).replace("'","")}
def get_vmdevice_map(self,platform):
try:
result=[]
dic = {"hda": "hda",
"hdb": "hdb",
"hdc": "hdc",
"hdc:cdrom": "hdc:cdrom",
"hdd": "hdd"
}
if platform=='xen':
dic['xvda']='xvda'
dic['xvdb']='xvdb'
dic['xvdc']='xvdc'
if platform=='kvm':
dic['vda']='vda'
dic['vdb']='vdb'
dic['vdc']='vdc'
dic['vdd']='vdd'
for key in dic.keys():
result.append(dict(id=dic[key],value=key))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
def get_vm_status(self,image_id, _dc=None):
try:
self.authenticate()
result = self.image_service.get_vm_status(image_id)
except Exception, ex:
print_traceback()
return dict(success=False,msg=to_str(ex).replace("'", " "))
def save_appliance_info(self, dom_id, node_id, action=None, **kw):
try:
self.authenticate()
result = self.appliance_service.save_appliance_info(session["auth"], dom_id, node_id, action, kw)
except Exception, ex:
print_traceback()
return dict(success=False, msg=to_str(ex).replace("'", ""))
def get_template_version_info(self,image_id, _dc=None):
try:
self.authenticate()
result = self.image_service.get_template_version_info(session['auth'],image_id)
except Exception, ex:
print_traceback()
return dict(success=False,msg=to_str(ex).replace("'", " "))
def get_imagegrp_summary_info(self,grp_id, _dc=None):
try:
self.authenticate()
result = self.image_service.get_imagegrp_summary_info(grp_id)
except Exception, ex:
print_traceback()
return dict(success=False,msg=to_str(ex).replace("'", " "))
def get_ref_disk_format_map(self,format_type):
print "-----",format_type
try:
result=[]
if format_type=="disk_image":
dic= { "Raw": "raw",
"dir-gzipped-chunks" : "dir-gzipped-chunks",
".bz2": "bzip",
".gz" : "gzip",
".zip": "zip",
".tar": "tar",
".tar.gzip": "tar_gzip",
".tar.bz2" : "tar_bzip",
}
for key in dic.keys():
result.append(dict(id=dic[key],value=key))
elif format_type=="disk_content":
dic1={
# ".bz2": "bzip", (Need to add to provision.sh)
# ".gz" : "gzip", (Need to add to provision.sh)
".zip": "zip",
".tar": "tar",
".tar.gzip": "tar_gzip",
".tar.bz2" : "tar_bzip",
"directory":"dir"
}
for key in dic1.keys():
result.append(dict(id=dic1[key],value=key))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
def get_command(self,auth,node_id,dom_id,cmd):
command=None
try:
command=tg.config.get(cmd)
info={}
value_map={}
if cmd in [constants.VNC,constants.TIGHTVNC]:
host=pylons.request.headers['Host']
if host.find(":") != -1:
(address,port)=host.split(':')
else:
address = host
info=self.manager.get_vnc_info(auth, node_id, dom_id, address)
value_map[constants.APPLET_IP] = info["hostname"]
value_map[constants.PORT] = info["port"]
if command is not None:
if type(command) in [types.StringType,types.UnicodeType]:
template_str = string.Template(command)
command = to_str(template_str.safe_substitute(value_map))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: "'Command not found'"}"
def server_action(self, node_id, action,date=None,time=None):
self.authenticate()
try:
self.tc.server_action(session['auth'], node_id, action, date,time)
except Exception, ex:
print_traceback()
return "{success: false,msg:'"+to_str(ex).replace("'","").replace("\n","")+"'}"
def add_storage_def(self,auth, site_id, group_id, node_id, type, opts, op_level=None, sp_ids=None, scan_result=None):
new_sd = self.get_valid_sd(type,opts, op_level)
site = self.manager.getSite(site_id)
group=self.manager.getGroup(auth,group_id)
node = None
group_list = self.manager.getGroupList(auth, site_id)
try:
sdlist = self.storage_manager.get_sds(site_id, group_id)
for sd in sdlist:
if new_sd.name==sd.name:
raise Exception("Storage share with same name already exists.")
errs=[]
errs = self.update_storage_def(auth, new_sd, None, None, None, site, group, op_level, True, sp_ids, errs, scan_result)
if errs:
if len(errs) > 0:
add_mode=True
self.sync_manager.remove_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.DETACH, "REMOVE_STORAGE_DEF", self.storage_manager, self.manager, add_mode, group_list, op_level)
return {'success':False,'msg':to_str(errs).replace("'","")}
except Exception, ex:
print_traceback()
err_desc = to_str(ex).replace("'","")
err_desc = err_desc.strip()
LOGGER.error(err_desc)
try:
add_mode=True
defn_temp = self.storage_manager.get_sd(new_sd.id, None, None, None)
if defn_temp:
self.sync_manager.remove_defn(defn_temp, site, group, node, auth, to_unicode(constants.STORAGE), constants.DETACH, "REMOVE_STORAGE_DEF", self.storage_manager, self.manager, add_mode, group_list, op_level)
except Exception, ex1:
print_traceback()
LOGGER.error(to_str(ex1).replace("'",""))
raise Exception(to_str(ex1))
def get_vm_config(self,domId,nodeId,_dc=None):
self.authenticate()
try:
result=self.node_service.get_vm_config(session['auth'],domId,nodeId)
except Exception, e:
print_traceback()
return dict(success=False,msg='Error:'+to_str(e).replace("'", " "))
def get_storage_types(self,**kw):
try:
self.authenticate()
result = self.storage_service.get_storage_types()
except Exception, ex:
print_traceback()
return {'success':False,'msg':to_str(ex).replace("'","")}
def clone_image(self,auth, image_id, image_name, group_id):
""" clone image """
try:
self.image_store.clone_image(auth,group_id, image_id, image_name)
except Exception , ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
def transfer_image(self,auth, image_id,source_group_id,dest_group_id):
""" transfer image """
try:
self.image_store.transfer_image(auth,image_id,source_group_id,dest_group_id)
except Exception , ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
def get_server_storage_def_list(self,
def_id,
defType,
site_id=None,
group_id=None,
_dc=None):
try:
result = None
self.authenticate()
result = self.storage_service.get_server_def_list(
site_id, group_id, def_id)
except Exception, ex:
print_traceback()
return {'success': False, 'msg': to_str(ex).replace("'", "")}
def associate_defns(self,
def_ids,
def_type,
site_id=None,
op_level=None,
group_id=None):
self.authenticate()
try:
self.tc.associate_defns_task(session['auth'], site_id, group_id,
def_type, def_ids, op_level)
except Exception, ex:
print_traceback()
return "{success: false,msg:'" + to_str(ex).replace(
"'", "").replace("\n", "") + "'}"
def save_user_det(self, userid, username, fname, lname, displayname,
password, email, vm_licenses, status):
try:
result = None
self.authenticate()
if session['auth'].is_admin() == False:
return dict(success=False, msg=constants.NO_PRIVILEGE)
result = self.user_info.save_user_det(session['userid'], userid,
username, fname, lname,
displayname, password, email,
vm_licenses, status)
except Exception, ex:
print_traceback()
return {'success': False, 'msg': to_str(ex).replace("'", "")}
def edit_save_custom_search(self,
name,
desc,
condition,
max_count=200,
_dc=None):
try:
self.authenticate()
info = self.dashboard_service.edit_save_custom_search(
session['auth'], name, desc, condition, max_count)
return dict(success=True, info=info)
except Exception, ex:
print_traceback()
return dict(success=False, msg=to_str(ex).replace("'", " "))
def updatesave_op_det(self, opid, opname, desc, entid, context_disp,
dispname, icon):
try:
result = None
self.authenticate()
if session['auth'].is_admin() == False:
return dict(success=False, msg=constants.NO_PRIVILEGE)
result = self.user_info.updatesave_op_det(session['userid'], opid,
opname, desc, entid,
context_disp, dispname,
icon)
except Exception, ex:
print_traceback()
return {'success': False, 'msg': to_str(ex).replace("'", "")}
def associate_defns(self,
site_id,
group_id,
def_type,
def_ids,
auth,
op_level=None):
error_desc = ""
site = self.manager.getSite(site_id)
group = self.manager.getGroup(auth, group_id)
group_list = self.manager.getGroupList(auth, site_id)
def_id_list = def_ids.split(",")
for def_id in def_id_list:
new_sd = DBSession.query(StorageDef).filter_by(id=def_id).first()
node = None
try:
associate = True
self.sync_manager.add_defn(new_sd, site, group, node, auth,
to_unicode(constants.STORAGE),
constants.ATTACH, "ADD_STORAGE_DEF",
self.storage_manager, self.manager,
op_level, associate)
#matching disks on association of storage.
vm_disks = self.manager.get_vm_disks_from_pool(auth, group_id)
storage_disks = DBSession.query(StorageDisks).filter_by(
storage_id=def_id)
if storage_disks:
for eachdisk in storage_disks:
self.manager.matching_disk_on_discover_storage(
vm_disks, eachdisk.id)
except Exception, ex:
error_desc = to_str(ex)
print_traceback()
LOGGER.error(to_str(ex).replace("'", ""))
#if we get any exception while adding/ sync definition then are removing the definition.
add_mode = True
try:
self.sync_manager.remove_defn(
new_sd, site, group, node, auth,
to_unicode(constants.STORAGE), constants.DETACH,
"REMOVE_STORAGE_DEF", self.storage_manager,
self.manager, add_mode, group_list, op_level)
except Exception, ex1:
print_traceback()
LOGGER.error(to_str(ex1).replace("'", ""))
raise Exception(to_str(ex1))
if error_desc:
raise Exception(error_desc)
def get_disks_type_map(self, option, mode):
try:
if mode in [
"edit_image_settings", "provision_image", "provision_vm"
]:
if option == "CREATE_DISK":
value_map = self.get_disk_type_map()
elif option == "USE_DEVICE":
value_map = self.get_disk_type_map_4_existing_disk()
elif option == "USE_ISO":
value_map = self.get_disk_type_map_4_iso()
elif option == "USE_REF_DISK":
value_map = self.get_disk_type_map_4_ref_disk()
else:
value_map = self.get_disk_type_map_4_vm_config()
result = []
# if option=="USE_REF_DISK":
# dic={ "File (VBD)": "file*VBD",
# "Logical Volume" : "phy*LVM",
# "Select Existing Device": "phy*",
# "QCOW": "tap:qcow*qcow2",
# "VMDK": "tap:vmdk*vmdk"
# }
# elif option=="CREATE_DISK":
# dic={ "File (VBD)": "file*VBD",
# "QCOW": "tap:qcow*qcow2",
# "VMDK": "tap:vmdk*vmdk",
# "Logical Volume" : "phy*LVM"
# }
# elif option=="USE_ISO":
# dic={ "Select ISO ": "file*ISO"}
# elif option=="USE_DEVICE":
# dic={"Select Existing Device": "phy*"}
# else:
# dic={ "File (VBD)": "file",
# "QCOW": "tap:qcow",
# "VMDK": "tap:vmdk",
# "Physical Device" : "phy"
# }
for key in value_map.keys():
(type, disk_type) = value_map[key]
result.append(dict(id=type, value=_(key), disk_type=disk_type))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ""))
return "{success: false,msg: '", to_str(ex).replace("'", ""), "'}"
def remove_storage_def(self,
storage_id,
site_id=None,
op_level=None,
group_id=None):
try:
result = None
self.authenticate()
#result = self.storage_service.remove_storage_def(session['auth'],storage_id,site_id,group_id, op_level)
self.tc.remove_storage_def_task(session['auth'], storage_id,
site_id, group_id, op_level)
result = "{success: true,msg: 'Task Submitted.'}"
except Exception, ex:
print_traceback()
return {'success': False, 'msg': to_str(ex).replace("'", "")}
def get_ssh_info(self,node_id,client_platform):
result = []
try:
self.authenticate()
host=pylons.request.headers['Host']
if host.find(":") != -1:
(address,port)=host.split(':')
else:
address = host
#(address,port)=host.split(':')
result = self.node_service.get_ssh_info(session['auth'],node_id,address,client_platform)
except Exception, ex:
print_traceback()
return dict(success=False,msg=to_str(ex).replace("'", " "))
def get_disks_options_map(self):
try:
result = []
dic = {
"Create New Disk": "CREATE_DISK",
"Use Physical Device": "USE_DEVICE",
"Use ISO File": "USE_ISO",
"Clone Reference Disk": "USE_REF_DISK",
}
for key in dic.keys():
result.append(dict(id=dic[key], value=_(key)))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ""))
return "{success: false,msg: '", to_str(ex).replace("'", ""), "'}"
def get_device_mode_map(self):
try:
result = []
dic = {
"Read-Only": "r",
"Read-Write": "w",
"Read-ForceWrite": "w!"
}
for key in dic.keys():
result.append(dict(id=dic[key], value=key))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ""))
return "{success: false,msg: '", to_str(ex).replace("'", ""), "'}"
def get_appliance_packages(self):
try:
result = []
packages = self.appliance_store.get_all_packages()
packages.sort()
counter = 0
for package in packages:
counter += 1
result.append(dict(id=counter, name=package, value=package))
return result
except Exception, e:
print_traceback()
LOGGER.error(to_str(e).replace("'", ""))
raise e
def get_appliance_archs(self):
try:
result = []
archs = self.appliance_store.get_all_archs()
archs.sort()
counter = 0
for arch in archs:
counter += 1
result.append(dict(id=counter, name=arch, value=arch))
return result
except Exception, e:
print_traceback()
LOGGER.error(to_str(e).replace("'", ""))
raise e
def get_miscellaneous_configs(self,
image_id=None,
dom_id=None,
node_id=None,
group_id=None,
action=None,
_dc=None):
try:
self.authenticate()
result = self.vm_service.get_miscellaneous_configs(
session['auth'], image_id, dom_id, node_id, group_id, action)
return result
except Exception, e:
print_traceback()
return dict(success=False,
msg='Error:' + to_str(e).replace("'", " "))
def save_vm(self,
dom_id,
node_id,
directory,
filenames,
date=None,
time=None):
self.authenticate()
try:
file = os.path.join(directory, filenames)
self.tc.save_vm(session['auth'], dom_id, node_id, \
file, directory,date,time)
except Exception, ex:
print_traceback()
return "{success: false,msg:'" + to_str(ex).replace(
"'", "").replace("\n", "") + "'}"
def edit_storage_def(self, auth, storage_id, site_id, groupId, type,
op_level, sp_ids, opts):
try:
site = self.manager.getSite(site_id)
group = self.manager.getGroup(auth, groupId)
#new_sd = self.get_valid_sd(type,opts)
new_name = opts.get("name")
new_desc = opts.get("description")
self.update_storage_def(auth, None, new_name, new_desc, storage_id,
site, group, op_level, False, sp_ids)
self.SaveScanResult(storage_id, site_id)
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ""))
return "{success: false,msg: '", to_str(ex).replace(
"'", "").strip(), "'}"
def get_appliance_providers(self):
try:
result = []
feeds = self.appliance_store.get_appliance_feeds()
counter = 0
for feed_name in feeds:
counter += 1
result.append(dict(id=counter, name=feed_name,
value=feed_name))
return result
except Exception, e:
print_traceback()
LOGGER.error(to_str(e).replace("'", ""))
raise e
def nw_address_changed(self, ip_value):
# value = get_value(widget)
result={}
try:
if ip_value:
x = IP(ip_value)
start = x[len(x)/2]
end = x[-1]
range = "%s-%s" % (start.strNormal(), end.strNormal())
result["range"]=range
else:
result["range"]=""
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
raise ex
def get_storage_types(self):
try:
storage_type_list = []
storage_dic = {
"Network File Storage (NFS)": constants.NFS,
"Internet SCSI (iSCSI)": constants.iSCSI,
"ATA Over Ethernet (AOE)": constants.AOE,
}
for storage_values in storage_dic.keys():
storage_dic_temp = {}
storage_dic_temp["name"] = storage_values
storage_dic_temp["value"] = storage_dic[storage_values]
storage_type_list.append(storage_dic_temp)
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ""))
return "{success: false,msg: '", to_str(ex).replace("'", ""), "'}"
def edit_storage_def(self,
storage_id,
type,
site_id=None,
group_id=None,
op_level=None,
sp_ids=None,
kw=None):
try:
result = None
self.authenticate()
result = self.storage_service.edit_storage_def(
session['auth'], storage_id, site_id, group_id, type, op_level,
sp_ids, kw)
except Exception, ex:
print_traceback()
return {'success': False, 'msg': to_str(ex).replace("'", "")}
def get_disks(self,
image_id=None,
mode=None,
dom_id=None,
node_id=None,
group_id=None,
action=None,
_dc=None):
result = None
self.authenticate()
try:
result = self.vm_service.get_disks(session['auth'], image_id, mode,
dom_id, node_id, group_id,
action)
except Exception, e:
print_traceback()
return dict(success=False, msg=to_str(e))
def list_dir_contents(self, node_id=None, directory=None, _dc=None):
result = None
self.authenticate()
try:
result = self.node_service.get_dir_contents(
session['auth'], node_id, directory)
except Exception, ex:
print_traceback()
x = to_str(ex)
err = ''
if x.startswith('[Errno 2] No such file or directory:'):
err = 'NoDirectory'
return {
'success': 'false',
'msg': to_str(ex).replace("'", ""),
'err': err
}
def add_storage_def(self,
type,
site_id=None,
op_level=None,
group_id=None,
node_id=None,
sp_ids=None,
opts=None):
try:
result = None
self.authenticate()
#result = self.storage_service.add_storage_def(session['auth'],site_id,group_id,node_id,type,opts,op_level,sp_ids, added_manually)
self.tc.add_storage_def_task(session['auth'], site_id, group_id,
node_id, type, opts, op_level, sp_ids)
result = "{success: true,msg: 'Task Submitted.'}"
except Exception, ex:
print_traceback()
return {'success': False, 'msg': to_str(ex).replace("'", "")}
def get_dc_storage_def_list(self, auth, site_id, group_id):
storage_list = []
try:
if site_id == 'data_center':
site = self.manager.getSiteByGroupId(group_id)
if site:
site_id = site.id
defn_list = self.storage_manager.getSiteDefListToAssociate(
site_id, group_id, to_unicode(constants.STORAGE))
if defn_list:
for s_def in defn_list:
temp_sd_dic = {}
#check None here to avoid None exception
if s_def:
total = 0.00
if s_def.get_stats():
#total = s_def.get_stats().get("TOTAL")
objStats = s_def.get_stats()
if objStats:
total = objStats.total_size
definition = self.get_defn(s_def)
temp_sd_dic['stats'] = "" #s_def.stats
temp_sd_dic['name'] = s_def.name
temp_sd_dic[
'connection_props'] = s_def.connection_props
temp_sd_dic['type'] = s_def.type
temp_sd_dic['id'] = s_def.id
temp_sd_dic['creds'] = s_def.creds
temp_sd_dic['creds_required'] = s_def.creds_required
temp_sd_dic['size'] = total
temp_sd_dic['definition'] = definition
temp_sd_dic['description'] = s_def.description
temp_sd_dic['status'] = s_def.status
temp_sd_dic['scope'] = s_def.scope
storage_list.append(temp_sd_dic)
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ""))
return dict(success=False,
msg=to_str(ex).replace("'", ""),
rows=storage_list)
def associate_nw_defns(self, site_id, group_id, node_id, def_type, def_ids, auth, op_level=None):
site = self.manager.getSite(site_id)
group = self.manager.getGroup(auth,group_id)
def_id_list = def_ids.split(",")
for def_id in def_id_list:
defn = self.nw_manager.get_defn(def_id)
node = DBSession.query(ManagedNode).filter_by(id=node_id).first()
try:
#associate=True
self.sync_manager.add_defn(defn, site, group, node, auth, to_unicode(constants.NETWORK), constants.ATTACH, "ADD_NETWORK_DEF", self.nw_manager, self.manager, op_level, None)
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
#if we get any exception while adding/ sync definition then are removing the definition.
add_mode=True
group_list = self.manager.getGroupList(auth, site_id)
self.sync_manager.remove_defn(defn, site, group, node, auth, to_unicode(constants.NETWORK), constants.DETACH, "REMOVE_NETWORK_DEF", self.nw_manager, self.manager, add_mode, group_list, op_level)
return {'success':False,'msg':to_str(ex).replace("'","")}
def get_used_ports_info(self):
try:
nc = NodeCache().get_cache()
print nc
result = []
for n, c in nc.iteritems():
res = "\n\n Server : '%s'" %n
for p, d in c['ports'].iteritems():
res += "\n\t Port : '%s' , Time : '%s'" %(p, d)
result.append(res)
return highlight("\n".join(result), PythonLexer(), HtmlFormatter(
full=False,
# style="native",
noclasses=True,
))
except Exception, ex:
print_traceback()
return "<html>Error getting Ports information.</html>"
def get_nw_nat_fwding_map(self,auth,node_id ):
result=[]
try:
nw_nat_fwding_map = {"Any interface" : "ANY",}
managed_node=NodeService().get_managed_node(auth,node_id)
if managed_node is not None:
nics = managed_node.get_nic_info()
if nics:
for nic in nics.itervalues():
nic_name = nic["name"]
nw_nat_fwding_map[nic_name] = nic_name
for key in nw_nat_fwding_map.keys():
result.append(dict(name=key,value=nw_nat_fwding_map.get(key)))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
raise ex
def get_server_storage_def_list(self, auth, node_id):
storage_list = []
try:
defn_list = self.sync_manager.get_server_defns(
node_id, to_unicode(constants.STORAGE))
if defn_list:
for item in defn_list:
temp_sd_dic = {}
s_def = self.storage_manager.get_defn(item[0])
#check None here to avoid None exception
if s_def:
total = 0.0
if s_def.get_stats():
#total = s_def.get_stats().get("TOTAL")
objStats = s_def.get_stats()
if objStats:
total = objStats.total_size
definition = self.get_defn(s_def)
temp_sd_dic['stats'] = "" #s_def.stats
temp_sd_dic['name'] = s_def.name
temp_sd_dic[
'connection_props'] = s_def.connection_props
temp_sd_dic['type'] = s_def.type
temp_sd_dic['id'] = s_def.id
temp_sd_dic['creds'] = s_def.creds
temp_sd_dic['creds_required'] = s_def.creds_required
temp_sd_dic['size'] = total
temp_sd_dic['definition'] = definition
temp_sd_dic['description'] = s_def.description
#temp_sd_dic['status']=s_def.status
temp_sd_dic['scope'] = s_def.scope
#temp_sd_dic['associated']=associated
storage_list.append(temp_sd_dic)
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ""))
raise ex
def vm_config_settings(self,
image_id,
config,
mode,
node_id=None,
group_id=None,
dom_id=None,
vm_name=None,
date=None,
time=None,
_dc=None):
self.authenticate()
try:
if (not mode == 'PROVISION_VM') and '-' in vm_name:
return dict(
success=False,
msg='VM name can not contain special character "-"')
if mode == 'PROVISION_VM':
from convirt.core.utils.utils import get_remain_vm_licenses, vm_batch_provision_check
vm_list = vm_batch_provision_check(vm_name, config)
if get_remain_vm_licenses(
session['auth'].user.user_name) < len(vm_list):
return dict(success=False,
msg='VM licenses are not enough')
for vm in vm_list:
self.tc.config_settings(session['auth'], image_id, vm['vm_config'], \
mode, node_id, group_id, dom_id, vm['vm_name'],date,time)
result = None
elif mode == 'EDIT_VM_INFO':
self.tc.config_settings(session['auth'], image_id, config, \
mode, node_id, group_id, dom_id, vm_name,date,time)
result = None
else:
result = self.node_service.vm_config_settings(session['auth'],\
image_id,config,mode,node_id,group_id,\
dom_id,vm_name)
except Exception, e:
print_traceback()
return dict(success=False,
msg='Error:' + to_str(e).replace("'", " "))
def get_target_image_groups(self,auth,nodeId):
try:
manager = Basic.getGridManager()
managed_node = manager.getNode(auth,nodeId)
result=[]
if managed_node is None:
raise Exception('Cannot find the Managed Node.')
result=[]
image_groups = self.image_store.get_image_groups(auth)
for image_group in image_groups.itervalues():
count = 0
images = self.get_group_images(auth,image_group.id)
for image in images.itervalues():
if managed_node.is_image_compatible(image):
count=count+1
break
if count > 0:
result.append(dict(name=image_group.get_name(),id=image_group.get_id()))
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
