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("'",""),"'}"