def libvirt_domain_get_mac(vm_title): mac = None conn = libvirt.openReadOnly(None) doms = conn.listAllDomains() for dom in doms: try: dom0 = conn.lookupByName(dom.name()) # Annoyiingly, libvirt prints its own error message here except libvirt.libvirtError: print("Domain %s is not running" % name) ctx = libvirt_domain_get_context(dom0) if libvirt_domain_get_val(ctx, "/domain/title") == vm_title: return libvirt_domain_get_val(ctx, "/domain/devices/interface/mac/@address") conn = libvirt.openReadOnly('qemu:///system') doms = conn.listAllDomains() for dom in doms: try: dom0 = conn.lookupByName(dom.name()) # Annoyiingly, libvirt prints its own error message here except libvirt.libvirtError: print("Domain %s is not running" % name) ctx = libvirt_domain_get_context(dom0) if libvirt_domain_get_val(ctx, "/domain/name") == vm_title: return libvirt_domain_get_val(ctx, "/domain/devices/interface/mac/@address") return mac
def libvirt_domain_get_mac(vm_title): mac = None conn = libvirt.openReadOnly(None) doms = conn.listAllDomains() for dom in doms: try: dom0 = conn.lookupByName(dom.name()) # Annoyiingly, libvirt prints its own error message here except libvirt.libvirtError: print("Domain %s is not running" % name) ctx = libvirt_domain_get_context(dom0) if libvirt_domain_get_val(ctx, "/domain/title") == vm_title: return libvirt_domain_get_val( ctx, "/domain/devices/interface/mac/@address") conn = libvirt.openReadOnly('qemu:///system') doms = conn.listAllDomains() for dom in doms: try: dom0 = conn.lookupByName(dom.name()) # Annoyiingly, libvirt prints its own error message here except libvirt.libvirtError: print("Domain %s is not running" % name) ctx = libvirt_domain_get_context(dom0) if libvirt_domain_get_val(ctx, "/domain/name") == vm_title: return libvirt_domain_get_val( ctx, "/domain/devices/interface/mac/@address") return mac
def init_state(self): """Initialize a dict for storing the state of the local manager. :param config: A config dictionary. :type config: dict(str: *) :return: A dictionary, initial state of the local manager. :rtype: dict """ vir_connection = libvirt.openReadOnly(None) if vir_connection is None: message = 'Failed to open a connection to the hypervisor' LOG.critical(message) raise OSError(message) physical_cpu_mhz_total = int( common.physical_cpu_mhz_total(vir_connection) * CONF.host_cpu_usable_by_vms) return {'previous_time': 0., 'vir_connection': vir_connection, 'db': db_utils.init_db(), 'physical_cpu_mhz_total': physical_cpu_mhz_total, 'hostname': vir_connection.getHostname(), 'hashed_username': sha1(CONF.os_admin_user).hexdigest(), 'hashed_password': sha1(CONF.os_admin_password).hexdigest()}
def getConnection(self, readOnly = False): if not self._connection or self.readOnly != readOnly: if self._connection: self._connection.close() self._connection = None error = None uri = self.node.getURI() try: if readOnly: self._connection = libvirt.openReadOnly(uri) else: self._connection = libvirt.open(uri) #endif except libvirt.libvirtError, e: error = unicode(e) #endtry if not self._connection and not error: error = u"Failed to open connection to the hypervisor" #endif if error: logging.error("libvirt: %s" % error) if self._connection: self._connection.close() self._connection = None raise CantConnectException(error) #endif self.readOnly = readOnly return self._connection
def _is_host_domain(fail_on_error=False): """ This function returns true if this system is currently a host domain. Simply having virtualization enabled is sufficient. We can figure out if Xen/Qemu is running by checking for the type """ if vdsm_enabled: # since vdsm is enabled, lets move further and # see what we get return True if not libvirt: # No libvirt, dont bother with the rest return False try: conn = libvirt.openReadOnly(None) except libvirt.libvirtError: # libvirtd is not running sys.stderr.write( utf8_encode( _("Warning: Could not retrieve virtualization information!\n\tlibvirtd service needs to be running.\n" ))) if fail_on_error: sys.exit(1) return False if conn and conn.getType() in ['Xen', 'QEMU']: return True return False
def add_hyp_to_receive_events(self, hyp_id): d_hyp_parameters = get_hyp_hostname_user_port_from_id(hyp_id) hostname = d_hyp_parameters['hostname'] user = d_hyp_parameters.get('user', 'root') port = d_hyp_parameters.get('port', 22) uri = hostname_to_uri(hostname, user=user, port=port) conn_ok = False try: self.hyps_conn[hyp_id] = libvirt.openReadOnly(uri) logs.status.debug( '####################connection to {} ready in events thread'. format(hyp_id)) update_uri_hyp(hyp_id, uri) conn_ok = True except Exception as e: logs.status.error( 'libvirt connection read only in events thread in hypervisor: {}' .format(hyp_id)) logs.status.error(e) if conn_ok is True: self.events_ids[hyp_id] = self.register_events( self.hyps_conn[hyp_id]) self.hyps[hyp_id] = hostname
def discoverInterfaces(): # TODO: Actually, may need to try a variety of uri combinations uri = 'qemu+ssh://stack@kiwi-os-compute-01/system' conn = libvirt.openReadOnly(uri) if conn == None: print 'Failed to open connection to the hypervisor' return try: networks = conn.listAllNetworks() interfaces = conn.listAllInterfaces() domains = conn.listAllDomains() dom0 = conn.lookupByName("Domain-0") except: print 'Failed to find the main domain' sys.exit(1) print "Domain 0: id %d running %s" % (dom0.ID(), dom0.OSType()) print dom0.info() pass
def get_inventory(self): ''' Construct the inventory ''' inventory = dict(_meta=dict(hostvars=dict())) conn = libvirt.openReadOnly(self.libvirt_uri) if conn is None: print "Failed to open connection to %s" % self.libvirt_uri sys.exit(1) domains = conn.listAllDomains() if domains is None: print "Failed to list domains for connection %s" % self.libvirt_uri sys.exit(1) for domain in domains: hostvars = dict(libvirt_name=domain.name(), libvirt_id=domain.ID(), libvirt_uuid=domain.UUIDString()) domain_name = domain.name() # TODO: add support for guests that are not in a running state state, _ = domain.state() # 2 is the state for a running guest if state != 1: continue hostvars['libvirt_status'] = 'running' root = ET.fromstring(domain.XMLDesc()) ansible_ns = {'ansible': 'https://github.com/ansible/ansible'} for tag_elem in root.findall('./metadata/ansible:tags/ansible:tag', ansible_ns): tag = tag_elem.text _push(inventory, "tag_%s" % tag, domain_name) _push(hostvars, 'libvirt_tags', tag) # TODO: support more than one network interface, also support # interface types other than 'network' interface = root.find("./devices/interface[@type='network']") if interface is not None: source_elem = interface.find('source') mac_elem = interface.find('mac') if source_elem is not None and \ mac_elem is not None: # Adding this to disable pylint check specifically # ignoring libvirt-python versions that # do not include DHCPLeases # This is needed until we upgrade the build bot to # RHEL7 (>= 1.2.6 libvirt) # pylint: disable=no-member dhcp_leases = conn.networkLookupByName(source_elem.get('network')) \ .DHCPLeases(mac_elem.get('address')) if len(dhcp_leases) > 0: ip_address = dhcp_leases[0]['ipaddr'] hostvars['ansible_ssh_host'] = ip_address hostvars['libvirt_ip_address'] = ip_address inventory['_meta']['hostvars'][domain_name] = hostvars return inventory
def new_libvirt_connection(conf): if not libvirt: raise ImportError("python-libvirt module is missing") uri = (conf.libvirt_uri or LIBVIRT_PER_TYPE_URIS.get(conf.libvirt_type, 'qemu:///system')) LOG.debug('Connecting to libvirt: %s', uri) return libvirt.openReadOnly(uri)
def add_hyp_to_receive_events(self, hyp_id): d_hyp_parameters = get_hyp_hostname_user_port_from_id(hyp_id) hostname = d_hyp_parameters['hostname'] user = d_hyp_parameters.get('user', 'root') port = d_hyp_parameters.get('port', 22) uri = hostname_to_uri(hostname, user=user, port=port) conn_ok = False try: self.hyps_conn[hyp_id] = libvirt.openReadOnly(uri) logs.status.debug( '####################connection to {} ready in events thread'. format(hyp_id)) update_uri_hyp(hyp_id, uri) conn_ok = True except Exception as e: logs.status.error( 'libvirt connection read only in events thread in hypervisor: {}' .format(hyp_id)) logs.status.error(e) if conn_ok is True: for i in range(NUM_TRY_REGISTER_EVENTS): #try 5 try: self.events_ids[hyp_id] = self.register_events( self.hyps_conn[hyp_id]) self.hyps[hyp_id] = hostname break except libvirt.libvirtError as e: logs.status.error( f'Error when register_events, wait {SLEEP_BETWEEN_TRY_REGISTER_EVENTS}, try {i+1} of {NUM_TRY_REGISTER_EVENTS}' ) logs.status.error(e) time.sleep(SLEEP_BETWEEN_TRY_REGISTER_EVENTS)
def find_libvirt(env_name): """Look for environments qemu images and counting space they occupy on file system using by libvirt API :param env_name: fuel-devops environment name :type: env_name: string :return: sum of images sizes in Mbytes :rtype: int """ conn = libvirt.openReadOnly('qemu:///system') if conn is None: raise RuntimeError('Failed to open connection to the hypervisor') list_domains = conn.listDefinedDomains() r_dom=re.compile(env_name) summ = 0 if filter(r_dom.match, list_domains): for domain in list_domains: if env_name in domain: # getting configuration of libvirt domain in xml format # result is identical to output ``virsh dumpxml domain`` raw_xml = conn.lookupByName(domain).XMLDesc(0) xml = minidom.parseString(raw_xml) sourceFiles = xml.getElementsByTagName('source') for sourceFile in sourceFiles: if sourceFile.getAttribute('file'): summ += os.path.getsize(sourceFile.getAttribute('file')) # return used disc space in Mbytes conn.close() return summ/1024/1024 else: conn.close() raise RuntimeError("Libvirt domains are not exist")
def meter(self): """ Returns a list of (UUID, timestamp, virmem-attr) tuples, one for each instance running on a specific host. """ virmem = [] try: # dict of (uuid: (pid, instance-name)) elements inst_ids = self._get_inst_ids() # list of (uuid, timestamp, virmem [in bytes], virmem usage [in # pct of total]) tuples virmem = [(uuid, datetime.now(), mem_info.vms, float(mem_info.vms) / self.psutil_smem.total * 100) for (uuid, mem_info) \ in [(k, psutil.Process(v[0]).get_memory_info()) \ for k, v in inst_ids.iteritems()]] except: # Warning! Fails silently... logger.exception('Inst_VIRMEM_Usage: ' 'Connection to hypervisor failed; reset.') self.conn = libvirt.openReadOnly(_LIBVIRT_SOCKET_URL) finally: return virmem
def init_host(self): """ 获取本地主机名; """ local_host = '' context = xdrs.context.get_admin_context() self.vms_api = vms.API() try: vms_metadata = self.vms_api.get_all_vms_metadata(context) except exception.VmMetadataNotFound: msg = _('vm metadata not found') raise webob.exc.HTTPBadRequest(explanation=msg) if vms_metadata is None: vir_connection = libvirt.openReadOnly(local_host) vms_current = self._get_current_vms(vir_connection) for vm_uuid in vms_current: vm_create_values = { 'host_id': local_host, 'vm_id': vm_uuid, 'vm_state': 'vm_normal' } vm_metadata = self.conductor_api.create_vm_metadata(context, vm_create_values)
def init_state(self): """ Initialize a dict for storing the state of the local manager. :param config: A config dictionary. :type config: dict(str: *) :return: A dictionary containing the initial state of the local manager. :rtype: dict """ vir_connection = libvirt.openReadOnly(None) if vir_connection is None: message = 'Failed to open a connection to the hypervisor' LOG.critical(message) raise OSError(message) physical_cpu_mhz_total = int( common.physical_cpu_mhz_total(vir_connection) * CONF.host_cpu_usable_by_vms) return {'previous_time': 0., 'vir_connection': vir_connection, 'db': db_utils.init_db(), 'physical_cpu_mhz_total': physical_cpu_mhz_total, 'hostname': vir_connection.getHostname(), 'hashed_username': sha1(CONF.os_admin_user).hexdigest(), 'hashed_password': sha1(CONF.os_admin_password).hexdigest()}
def createConnection(): conn = libvirt.openReadOnly(None) if conn == None: print 'Failed to open connection to QEMU/KVM' else: print '----Connection is created successfully----' return conn
def __enter__(self): try: if self.sasl_username and self.sasl_password: def request_cred(credentials, user_data): for credential in credentials: if credential[0] == libvirt.VIR_CRED_AUTHNAME: credential[4] = self.sasl_username elif credential[0] == libvirt.VIR_CRED_PASSPHRASE: credential[4] = self.sasl_password return 0 auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_cred, None] flags = libvirt.VIR_CONNECT_RO if self.readonly else 0 self.conn = libvirt.openAuth(self.uri, auth, flags) elif self.readonly: self.conn = libvirt.openReadOnly(self.uri) else: self.conn = libvirt.open(self.uri) return self.conn except libvirt.libvirtError as e: raise exception.LibvirtConnectionOpenError(uri=self.uri, error=e)
def connection(self): if not self.__conn: if libvirt and os.path.exists(LIBVIRT_RO_SOCK_NAME): try: self.__conn = libvirt.openReadOnly(None) except: self.__conn = None self.log( "error in openReadOnly(None): {}".format( process_tools.get_except_info()), logging_tools.LOG_LEVEL_CRITICAL) else: if os.getuid(): self.log( "not running as root ({:d} != 0)".format( os.getuid()), logging_tools.LOG_LEVEL_ERROR) else: if not self.__missing_logged: self.__missing_logged = True self.log( "no libvirt defined or socket {} not found".format( LIBVIRT_RO_SOCK_NAME), logging_tools.LOG_LEVEL_ERROR) self.__conn = None return self.__conn
def init_state(): """ Initialize a dict for storing the state of the data collector. """ """ @@@@注:这里可以放在xdrs-host的初始化过程中来实现,并写入数据表HostInitData; 这里的操作就是对这个数据表进行数据的初始化操作; 其实这个系统有个瓶颈,就是若干数据库访问量过大,根据云平台集群规模和所建立的 虚拟机数量的大小,可能同时会有大量的数据表更新等操作访问数据库。 db.update_host(hostname, int(host_cpu_mhz * host_cpu_usable_by_vms), physical_cpus, host_ram) """ hosts_api = hosts.API() vir_connection = libvirt.openReadOnly(None) hostname = vir_connection.getHostname() """ 获取本地主机总的CPU MHZ和RAM数据; """ host_cpu_mhz, host_ram = get_host_characteristics(vir_connection) """ 通过libvirt获取物理CPU的数目; """ physical_cpus = physical_cpu_count(vir_connection) """ 主机中可以分配给虚拟机使用的cpu个数占总体cpu的百分比(阈值); """ host_cpu_usable_by_vms = float(CONF.host_cpu_usable_by_vms) local_cpu_mhz = int(host_cpu_mhz * host_cpu_usable_by_vms) host_cpu_overload_threshold = float(CONF.host_cpu_overload_threshold) * \ host_cpu_usable_by_vms physical_core_mhz = host_cpu_mhz / physical_cpus host_id = 2 """在系统初始化的过程中随机生成;""" init_data = { 'host_name': hostname, 'host_id': host_id, 'local_cpu_mhz': local_cpu_mhz, 'physical_cpus': physical_cpus, 'host_ram': host_ram, 'previous_time': 0., 'previous_cpu_time': dict(), 'previous_cpu_mhz': dict(), 'previous_host_cpu_time_total': 0., 'previous_host_cpu_time_busy': 0., 'previous_overload': -1, 'host_cpu_overload_threshold': host_cpu_overload_threshold, 'physical_cpu_mhz': host_cpu_mhz, 'physical_core_mhz': physical_core_mhz } try: host_init_data = hosts_api.create_host_init_data(init_data) except exception.HostInitDataNotFound: msg = _('host init data not found') raise webob.exc.HTTPBadRequest(explanation=msg) """
def _delete_network_vm(args): """ Deletes a libvirt network Parameters ----------- args : dict as the one returned by argparse.ArgumentParser().parse_args() expected key : net : the IP of the vNIC to be used. Returns ------- int The return value provided by the kvm storage pool create call, 0 on success, 1 otherwise. """ libvirtConn = libvirt.openReadOnly(None) if libvirtConn is None: print('Cannot contact hypervisor', file=sys.stderr) return 1 net = None try: net = libvirtConn.networkLookupByName(args.network_name) except libvirt.libvirtError: print('Cannot find network named [%s]' % args.network_name, file=sys.stderr) return 1 print('Network found:\n') print(xml.dom.minidom.parseString(net.XMLDesc()).toprettyxml(indent=" ", newl='')) print('') if input('Really destroy this network ?').strip().lower() in ('y', 'yes'): return oci_utils.kvm.virt.delete_virtual_network(network_name=args.network_name) return 1
def checkanyrunningvm(hostip): import libvirt #print "\nLooking for any running vms on "+hostip+"\n-----------------------------------\n" found = False if not checkhoststatus(hostip): print "\nHost is down\n" return False try: conn = libvirt.openReadOnly('qemu+ssh://root@' + hostip + '/system') domains = [] ids = conn.listDomainsID() for id in ids: domains.append(conn.lookupByID(id)) names = conn.listDefinedDomains() for name in names: domains.append(conn.lookupByName(name)) for dom in domains: print "Checking " + str(dom.name()) if (dom.info()[0] != 5): #print dom.name()+" is not off. Please check" found = True dom = None ids = None names = None domains = None conn.close() except: import sys, traceback found = True etype, value, tb = sys.exc_info() msg = ''.join(traceback.format_exception(etype, value, tb, 10)) print "Some Error Occured\n" + msg return found
def openReadOnly(): """Open a read-only libvirt connection to the qemu hypervisor. Returns: A read-only libvirt.virConnect connection to qemu. """ return libvirt.openReadOnly('qemu:///system')
def movealldeadvms(hostip): import libvirt, commands print "\nMoving all dead vms of this host " + hostip + "\n-----------------------------------\n" if not checkhoststatus(hostip): print "\nHost is down\n" return if (checkanyrunningvm(hostip)): print "All the vms on this host are not Off" return try: conn = libvirt.openReadOnly('qemu+ssh://root@' + hostip + '/system') domains = [] host1 = db(db.host.status == 1).select()[0] ids = conn.listDomainsID() for id in ids: domains.append(conn.lookupByID(id)) names = conn.listDefinedDomains() for name in names: domains.append(conn.lookupByName(name)) for dom in domains: print "Moving " + str(dom.name()) + " to " + host1.name migrateoffdomain(dom.name(), host1.id) print "All the vms moved Successfully. Host is empty" print commands.getstatusoutput("ssh root@" + hostip + " virsh list --all") domains = None names = None ids = None conn.close() except: import sys, traceback etype, value, tb = sys.exc_info() msg = ''.join(traceback.format_exception(etype, value, tb, 10)) print "Some Error Occured\n" + msg return
def virshlist(*states): libvirt_states = { "running": libvirt.VIR_DOMAIN_RUNNING, "shutoff": libvirt.VIR_DOMAIN_SHUTOFF, "shutdown": libvirt.VIR_DOMAIN_SHUTDOWN, "paused": libvirt.VIR_DOMAIN_PAUSED, "nostate": libvirt.VIR_DOMAIN_NOSTATE, "blocked": libvirt.VIR_DOMAIN_BLOCKED, "crashed": libvirt.VIR_DOMAIN_CRASHED, } searchstates = list(libvirt_states[state] for state in states) conn = libvirt.openReadOnly(driver) if conn == None: print "Failed to open connection to the hypervisor" sys.exit(3) alldomains = map(conn.lookupByID, conn.listDomainsID()) alldomains += map(conn.lookupByName, conn.listDefinedDomains()) domains = [] for domain in alldomains: if domain.info()[0] in searchstates: domains.append(domain.name()) conn.close() return domains
def __init__(self, **args): Machine.__init__(self, **args) self.run_dir = os.path.join(self.test_dir, "run") self._image_image = os.path.join(self.run_dir, "%s.qcow2" % (self.image)) self._image_additional_iso = os.path.join(self.run_dir, "%s.iso" % (self.image)) self._images_dir = os.path.join(self.test_data, "images") self._image_original = os.path.join(self._images_dir, "%s.qcow2" % (self.image)) self._iso_original = os.path.join(self._images_dir, "%s.iso" % (self.image)) self._checksum_original = os.path.join(self._images_dir, "%s-checksum" % (self.image)) self._fixed_mac_flavors = self._get_fixed_mac_flavors() self._network_description = etree.parse(open("./guest/network-cockpit.xml")) # it is ESSENTIAL to register the default implementation of the event loop before opening a connection # otherwise messages may be delayed or lost libvirt.virEventRegisterDefaultImpl() self.virt_connection = libvirt.open("qemu:///session") self.event_handler = VirtEventHandler(libvirt_connection=self.virt_connection, verbose=self.verbose) # network names are currently hardcoded into network-cockpit.xml self.network_name = self._read_network_name() self.system_connection = libvirt.openReadOnly("qemu:///system") self.dhcp_net = self.system_connection.networkLookupByName(self.network_name) # we can't see the network itself as non-root, create it using vm-prep as root # Unique identifiers for hostnet config self._hostnet = 8 # init variables needed for running a vm self._cleanup()
def virshdomstate(domain): libvirt_states={ libvirt.VIR_DOMAIN_RUNNING : 'running', libvirt.VIR_DOMAIN_SHUTOFF : 'shut off', libvirt.VIR_DOMAIN_SHUTDOWN : 'shut down', libvirt.VIR_DOMAIN_PAUSED : 'paused', libvirt.VIR_DOMAIN_NOSTATE : 'no state', libvirt.VIR_DOMAIN_BLOCKED : 'blocked', libvirt.VIR_DOMAIN_CRASHED : 'crashed', } conn = libvirt.openReadOnly('qemu:///system') if conn == None: print 'Failed to open connection to the hypervisor' sys.exit(3) try: dom = (conn.lookupByName (domain)) except libvirt.libvirtError: return None state = libvirt_states[dom.info()[0]] conn.close() return state
def old_list_all(): try: import libvirt,commands,string vmlist = [] notreachable = "Error connecting " hosts = db(db.host.id >=0).select() for host in hosts: domains=[] #will contain the domain information of all the available domains vdomains=[] ip = host.ip try: #Establish a read only remote connection to libvirtd #find out all domains running and not running #Since it might result in an error add an exception handler conn = libvirt.openReadOnly('qemu+ssh://root@'+ip+'/system') ids = conn.listDomainsID() for id in ids: domains.append(conn.lookupByID(id)) names = conn.listDefinedDomains() for name in names: domains.append(conn.lookupByName(name)) for dom in domains: vdomains.append(dom) for dom in vdomains: intstate = dom.info()[0] if(intstate==0): state="No_State" elif(intstate==1):state="Running" elif(intstate==2):state="Blocked" elif(intstate==3):state="Paused" elif(intstate==4):state="Being_Shut_Down" elif(intstate==5):state="Off" elif(intstate==6):state="Crashed" else: state="Unknown" name = dom.name() vm = db(db.vm.name == name).select() if len(vm)==1: vm = vm[0] if vm.hostid == host.id: hostid = vm.hostid ram = vm.RAM sport = vm.sport hostip = ip vmid = vm.id owner = db(db.auth_user.id == vm.userid).select(db.auth_user.username)[0].username element = {'name':name,'RAM':ram,'hostip':hostip,'owner':owner,'sport':sport,'state':state, 'id':vmid} vmlist.append(element) dom="" conn.close() except:notreachable = notreachable+ip+' ' #if notreachable == "Error connecting ": # response.flash = "All hosts active" #else: # response.flash = notreachable return dict(vmlist=vmlist,flash=response.flash) except: import sys, traceback etype, value, tb = sys.exc_info() msg = ''.join(traceback.format_exception(etype, value, tb, 10)) session.flash=msg redirect(URL(c='default', f='error'))
def virshlist(*states): libvirt_states={ 'running' : libvirt.VIR_DOMAIN_RUNNING, 'shutoff' : libvirt.VIR_DOMAIN_SHUTOFF, 'shutdown' : libvirt.VIR_DOMAIN_SHUTDOWN, 'paused' : libvirt.VIR_DOMAIN_PAUSED, 'nostate' : libvirt.VIR_DOMAIN_NOSTATE, 'blocked' : libvirt.VIR_DOMAIN_BLOCKED, 'crashed' : libvirt.VIR_DOMAIN_CRASHED, } searchstates = list(libvirt_states[state] for state in states) conn = libvirt.openReadOnly('qemu:///system') if conn == None: print 'Failed to open connection to the hypervisor' sys.exit(3) alldomains = map(conn.lookupByID, conn.listDomainsID()) alldomains += map(conn.lookupByName, conn.listDefinedDomains()) domains = [] for domain in alldomains: if domain.info()[0] in searchstates: domains.append(domain.name()) conn.close() return domains
def settings(): try: import libvirt vmname=request.args[0] prelim_checks(vmname) vminfo = db(db.vm.name == vmname).select()[0] hostip=db(db.host.id==vminfo.hostid).select()[0].ip conn = libvirt.openReadOnly('qemu+ssh://root@'+hostip+'/system') dom = conn.lookupByName(vmname) state=vminfotostate(dom.info()[0]) data={'name':vmname,'hdd':vminfo.HDD,'ram':vminfo.RAM,'vcpus':vminfo.vCPU,'status':state,'hostip':vminfo.hostid.ip,'port':vminfo.sport,'ostype':vminfo.templateid.ostype} users=[] vmid=db(db.vm.name==vmname).select(db.vm.id)[0]['id'] uids=db(db.vmaccpermissions.vmid==vmid).select(db.vmaccpermissions.userid) for uid in uids: uid=uid['userid'] users.append(db(db.auth_user.id==uid).select(db.auth_user.username)[0]['username']) dom="" conn.close() return dict(data=data,users=users) except: import sys, traceback etype, value, tb = sys.exc_info() msg = ''.join(traceback.format_exception(etype, value, tb, 10)) session.flash=msg redirect(URL(c='default', f='error'))
def unique_domain(domain, host=[]): if len(host) > 0: for h in host: conn = libvirt.openReadOnly("qemu+ssh://" + h + "/system") if domain_defined(conn, domain): conn.close() return False conn.close() else: conn = libvirt.openReadOnly(None) defined = domain_defined(conn, domain) conn.close() return not defined return True
def libvirt_memory(self): logger.debug('Collecting memory metrics') try: conn = libvirt.openReadOnly() if conn is None: raise Exception('Failed to open connection to the hypervisor') points = [] for id in conn.listDomainsID(): dom = conn.lookupByID(id) points.append({ "measurement": "libvirt_memory", "tags": { "project_uuid": self.nova_metadata(dom)['project']['uuid'], "project_name": self.nova_metadata(dom)['project']['name'], "instance_uuid": dom.UUIDString(), "libvirt_name": dom.name(), "libvirt_domid": dom.ID() }, "time": self.now(), "fields": { "actual": dom.memoryStats()['actual'], "rss": dom.memoryStats()['rss'] } }) logger.debug('Sending %s memory points to influxdb' % len(points)) self.influxdbclient.write_points(points) return points except Exception, e: logger.error("error: %s" % e)
def __enter__(self) -> 'ROLibvirtConnection': """ Set up the connection to libvirt; this will raise its own exception should the connection not be possible. """ self.conn = lv.openReadOnly(self.qemu) return self
def libvirt_block(self): logger.debug('Collecting block device metrics') try: conn = libvirt.openReadOnly() if conn is None: raise Exception('Failed to open connection to the hypervisor') points = [] for id in conn.listDomainsID(): dom = conn.lookupByID(id) for dev in self.domain_xml(dom).findall("devices/disk/target"): devname = dev.get("dev") stats = dom.blockStats(devname) points.append({ "measurement": "libvirt_block", "tags": { "project_uuid": self.nova_metadata(dom)['project']['uuid'], "project_name": self.nova_metadata(dom)['project']['name'], "instance_uuid": dom.UUIDString(), "libvirt_name": dom.name(), "libvirt_domid": dom.ID() }, "time": self.now(), "fields": { "read_ops": stats[0], "read_bytes": stats[1], "write_ops": stats[2], "write_bytes": stats[3], "errors": stats[4] } }) logger.debug('Sending %s block device points to influxdb' % len(points)) self.influxdbclient.write_points(points) return points except Exception, e: logger.error("error: %s" % e)
def add_orphan_vm(vm_name, host_id): host_details = db.host[host_id] host_ip = host_details.host_ip.private_ip connection_object = libvirt.openReadOnly("qemu+ssh://root@" + host_ip + "/system") domain = connection_object.lookupByName(vm_name) vm_state = domain.info()[0] vm_status = vm_state_map[vm_state] # Parse domain XML to get information about VM root = etree.fromstring(domain.XMLDesc(0)) ram_elem = root.xpath('memory')[0] ram_in_kb = int(ram_elem.text) ram_in_mb = int(round(int(ram_in_kb) / (1024), 0)) cpu_elem = root.xpath('vcpu')[0] cpu = int(cpu_elem.text) vnc_elem = root.xpath("devices/graphics[@type='vnc']")[0] vnc_port = vnc_elem.attrib['port'] mac_elem = root.xpath("devices/interface[@type='network']/mac")[0] mac_address = mac_elem.attrib['address'] ip_addr = db.private_ip_pool(mac_addr=mac_address) ip_address = None if ip_addr: ip_address = ip_addr['id'] template_elem = root.xpath("devices/disk[@type='file']/source")[0] template_file = template_elem.attrib['file'] command = "qemu-img info " + template_file + " | grep 'virtual size'" ret = execute_remote_cmd( host_ip, 'root', command) # Returns e.g. virtual size: 40G (42949672960 bytes) hdd = int(ret[ret.index(':') + 1:ret.index('G ')].strip()) security_domain_row = db.security_domain(vlan=ip_addr['vlan']) db.vm_data.insert( vm_name=vm_name, vm_identity=(vm_name), RAM=ram_in_mb, HDD=hdd, extra_HDD=0, vCPU=cpu, host_id=host_id, template_id=1, #TBD datastore_id=1, #TBD owner_id=SYSTEM_USER, requester_id=SYSTEM_USER, private_ip=ip_address, vnc_port=vnc_port, purpose='Added by System', security_domain=security_domain_row['id'], status=vm_status) return
def view_snapshots(): vm_name=request.args[0] prelim_checks(vm_name) import libvirt from lxml import etree #for parsing xml trees from StringIO import StringIO host = db(db.vm.name == vm_name).select() ip = host[0].hostid.ip conn = libvirt.openReadOnly('qemu+ssh://root@'+ip+'/system') dom = conn.lookupByName(vm_name) snapshots=dom.snapshotListNames(0) snap_info=[] for snap in snapshots: snapinstance = dom.snapshotLookupByName(snap,0) tree = etree.parse(StringIO(snapinstance.getXMLDesc(0))) snap_info.append(dict(name=tree.findtext("name"),state=tree.findtext("state"),parent=tree.findtext("parent/name"),time=tree.findtext("creationTime"),status=tree.findtext("state"))) #snapshot['name']=tree.findtext("name") #snapshot['state']=tree.findtext("state") #snapshot['parent']=tree.findtext("parent/name") #snapshot['created']=tree.findtext("creationTime") for snap_name in snap_info: status=True for snap_parent in snap_info: if (snap_name['name']==snap_parent['parent']) : status=False if (status==False) : snap_name['canDelete']=False else : snap_name['canDelete']=True return dict(snapshots=snap_info)
def __get_libvirt_connection(self): " get libvirt connection" conn = libvirt.openReadOnly(None) if conn is None: return -1 else: return conn
def nimo_main(nimo_mode): init_nimo() # Start and run libvirt default event loop implementation nimo_virt_api.startVirEventLoop() # In 'greenthread' nimo mode, not safe to call this, # but it is safe here as green thread are not yet spawned. # Lets log all native threads, before spawning green thread nimo_utils.log_native_threads() # In 'greenthread' nimo mode, not safe to use LOG, # but it is safe here as green thread are not yet spawned. LOG.info("Connecting to hypervisor using connection uri=%s", cfg.CONF.libvirt.uri) conn = libvirt.openReadOnly(cfg.CONF.libvirt.uri) if conn is None: LOG.error('Failed to open connection to uri=%s' % cfg.CONF.libvirt.uri) exit(1) # Register a callback to receive notifications of domain lifecycle events # occurring on a connection conn.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_LIFECYCLE, nimo_callbacks.domain_lifecycle_event_callback, { 'prog': __file__, 'name': __name__ }) conn.setKeepAlive(5, 3) dispatcher_thread = None dispatcher_thread_type = nimo_mode while conn.isAlive() == 1: # Create dispatcher thread to read queue and dispatch events dispatcher_thread = nimo_dispatcher.Dispatcher.create( dispatcher_thread_type, nimo_event_processor.wait_and_dispatch_queued_events, nimo_callbacks.event_queued_notify_recv, nimo_callbacks.event_q) # TODO(jay): Implement sighandlers, when nimo mode = 'nativethread' LOG.debug("Main-thread waiting forever " "on Dispatcher thread to finish") dispatcher_thread.join() # This should be safe as green thread is dead LOG.error("Dispatcher thread exited.") # at this point, spin back up a dispatcher thread or exit process eventlet.sleep(1) else: # If connection with hypervisor breaks, exit. # TODO(jay): Ideally, terminate all threads and recall this main(). LOG.error("connection to Host is broken. Exiting") exit(1)
def get_host_cpu_siblings(): """Return core to sibling mapping of the host CPUs {core_0: [sibling_a, sibling_b, ...], core_1: [sibling_a, sibling_b, ...], ...} libvirt's getCapabilities() is called to get details about the host then a list of siblings per CPU is extracted and formatted to single level list """ siblings = {} conn = libvirt.openReadOnly('qemu:///system') capxml = ET.fromstring(conn.getCapabilities()) cpu_cells = capxml.findall('./host/topology/cells/cell/cpus') for cell in cpu_cells: cpus = cell.findall('cpu') for cpu in cpus: cpu_id = int(cpu.get('id')) sib = cpu.get('siblings') _siblings = get_siblings_list(sib) siblings.update({cpu_id: _siblings}) return siblings
def collect(self): if libvirt is None: self.log.error('Unable to import libvirt') return {} conn = libvirt.openReadOnly(self.config['uri']) for dom in [conn.lookupByID(n) for n in conn.listDomainsID()]: name = dom.name() # CPU stats vcpus = dom.getCPUStats(True, 0) totalcpu = 0 idx = 0 for vcpu in vcpus: cputime = vcpu['cpu_time'] self.report_cpu_metric('cpu.%s.time' % idx, cputime, name) idx += 1 totalcpu += cputime self.report_cpu_metric('cpu.total.time', totalcpu, name) # Disk stats disks = self.get_disk_devices(dom) accum = {} for stat in self.blockStats.keys(): accum[stat] = 0 for disk in disks: stats = dom.blockStats(disk) for stat in self.blockStats.keys(): idx = self.blockStats[stat] val = stats[idx] accum[stat] += val self.publish('block.%s.%s' % (disk, stat), val, instance=name) for stat in self.blockStats.keys(): self.publish('block.total.%s' % stat, accum[stat], instance=name) # Network stats vifs = self.get_network_devices(dom) accum = {} for stat in self.vifStats.keys(): accum[stat] = 0 for vif in vifs: stats = dom.interfaceStats(vif) for stat in self.vifStats.keys(): idx = self.vifStats[stat] val = stats[idx] accum[stat] += val self.publish('net.%s.%s' % (vif, stat), val, instance=name) for stat in self.vifStats.keys(): self.publish('net.total.%s' % stat, accum[stat], instance=name) # Memory stats mem = dom.memoryStats() self.publish('memory.nominal', mem['actual'] * 1024, instance=name) self.publish('memory.rss', mem['rss'] * 1024, instance=name)
def _create_network_vm(args): """ Creates a libvirt network Parameters ----------- args : dict as the one returned by argparse.ArgumentParser().parse_args() Returns ------- int The return value provided by the kvm storage pool create call, 0 on success, 1 otherwise. """ # check network name unicity conn = libvirt.openReadOnly(None) _vnets = [] if conn: _vnets = [n.name() for n in conn.listAllNetworks() if n.name() == args.network_name] conn.close() else: print('Cannot contact hypervisor', file=sys.stderr) return 1 if len(_vnets) != 0: print("Network with name [%s] already exists" % args.network_name, file=sys.stderr) return 1 return oci_utils.kvm.virt.create_virtual_network(network=args.net, network_name=args.network_name, ip_bridge=args.ip_bridge, ip_prefix=args.ip_prefix, ip_start=args.ip_start, ip_end=args.ip_end)
def init_state(config): """ Initialize a dict for storing the state of the local manager. :param config: A config dictionary. :type config: dict(str: *) :return: A dictionary containing the initial state of the local manager. :rtype: dict """ vir_connection = libvirt.openReadOnly(None) if vir_connection is None: message = 'Failed to open a connection to the hypervisor' raise OSError(message) """ physical_cpu_mhz_total:通过libvirt获取所有CPU核频率之和(MHz); host_cpu_usable_by_vms:主机中可以分配给虚拟机使用的cpu个数占总体cpu的百分比(阈值); """ physical_cpu_mhz_total = int( _physical_cpu_mhz_total(vir_connection) * float(CONF.host_cpu_usable_by_vms)) return {'previous_time': 0., 'vir_connection': vir_connection, 'db': init_db(config['sql_connection']), 'physical_cpu_mhz_total': physical_cpu_mhz_total, 'hostname': vir_connection.getHostname(), 'hashed_username': sha1(config['os_admin_user']).hexdigest(), 'hashed_password': sha1(config['os_admin_password']).hexdigest()}
def init_state(self): """ Initialize a dict for storing the state of the data collector.""" vir_connection = libvirt.openReadOnly(None) if vir_connection is None: message = 'Failed to open a connection to the hypervisor' LOG.critical(message) raise OSError(message) hostname = vir_connection.getHostname() host_cpu_mhz, host_ram = self.get_host_characteristics(vir_connection) physical_cpus = common.physical_cpu_count(vir_connection) host_cpu_usable_by_vms = CONF.host_cpu_usable_by_vms db = db_utils.init_db() db.update_host(hostname, int(host_cpu_mhz * host_cpu_usable_by_vms), physical_cpus, host_ram) return {'previous_time': 0., 'previous_cpu_time': dict(), 'previous_cpu_mhz': dict(), 'previous_host_cpu_time_total': 0., 'previous_host_cpu_time_busy': 0., 'previous_overload': -1, 'vir_connection': vir_connection, 'hostname': hostname, 'host_cpu_overload_threshold': CONF.collector.host_cpu_overload_threshold * \ host_cpu_usable_by_vms, 'physical_cpus': physical_cpus, 'physical_cpu_mhz': host_cpu_mhz, 'physical_core_mhz': host_cpu_mhz / physical_cpus, 'db': db}
def main(): hosts = sys.argv hosts.pop(0) for h in hosts: if h == "-v" or h == "--verbose": VERBOSE = True continue uri = "qemu+ssh://%s/system" % h try: conn = libvirt.openReadOnly(uri) except libvirt.libvirtError as e: print("ERROR connecting to %s: %s" % (uri, e.message)) continue # some code examples imply that older versions # returned None instead of raising an exception if conn is None: print("ERROR connecting to %s: %s" % (uri, e.message)) continue host_info = get_host_info(conn) doms = get_domains(conn) image_paths = [] for d in doms: image_paths.extend(d['disk_files']) df = get_disk_free(image_paths, h) host_info['df_bytes'] = df ts = int(time.time()) foo = { 'type': 'host', 'name': host_info['hostname'], 'data': host_info, 'updated_ts': ts } print to_json(foo) with open("host_%s.json" % host_info['hostname'], 'w') as fh: fh.write(to_json(foo)) for d in doms: #print("{host},{name},{ID},{state},{UUID}".format(host=h, name=d['name'], ID=d['ID'], UUID=d['UUID'], state=d['state'])) foo = { 'type': 'guest', 'name': d['name'], 'uuid': d['UUID'], 'data': d, 'host': host_info['hostname'], 'updated_ts': ts } print to_json(foo) with open( "host_%s_guest_%s.json" % (host_info['hostname'], d['name']), 'w') as fh: fh.write(to_json(foo))
def init_state(): """ Initialize a dict for storing the state of the data collector. """ """ @@@@注:这里可以放在xdrs-host的初始化过程中来实现,并写入数据表HostInitData; 这里的操作就是对这个数据表进行数据的初始化操作; 其实这个系统有个瓶颈,就是若干数据库访问量过大,根据云平台集群规模和所建立的 虚拟机数量的大小,可能同时会有大量的数据表更新等操作访问数据库。 db.update_host(hostname, int(host_cpu_mhz * host_cpu_usable_by_vms), physical_cpus, host_ram) """ hosts_api = hosts.API() vir_connection = libvirt.openReadOnly(None) hostname = vir_connection.getHostname() """ 获取本地主机总的CPU MHZ和RAM数据; """ host_cpu_mhz, host_ram = get_host_characteristics(vir_connection) """ 通过libvirt获取物理CPU的数目; """ physical_cpus = physical_cpu_count(vir_connection) """ 主机中可以分配给虚拟机使用的cpu个数占总体cpu的百分比(阈值); """ host_cpu_usable_by_vms = float(CONF.host_cpu_usable_by_vms) local_cpu_mhz = int(host_cpu_mhz * host_cpu_usable_by_vms) host_cpu_overload_threshold = float(CONF.host_cpu_overload_threshold) * host_cpu_usable_by_vms physical_core_mhz = host_cpu_mhz / physical_cpus host_id = 2 """在系统初始化的过程中随机生成;""" init_data = { "host_name": hostname, "host_id": host_id, "local_cpu_mhz": local_cpu_mhz, "physical_cpus": physical_cpus, "host_ram": host_ram, "previous_time": 0.0, "previous_cpu_time": dict(), "previous_cpu_mhz": dict(), "previous_host_cpu_time_total": 0.0, "previous_host_cpu_time_busy": 0.0, "previous_overload": -1, "host_cpu_overload_threshold": host_cpu_overload_threshold, "physical_cpu_mhz": host_cpu_mhz, "physical_core_mhz": physical_core_mhz, } try: host_init_data = hosts_api.create_host_init_data(init_data) except exception.HostInitDataNotFound: msg = _("host init data not found") raise webob.exc.HTTPBadRequest(explanation=msg) """
def main(): conn = libvirt.openReadOnly(None) if not conn: print('Failed to open connection to qemu:///system') exit(1) domainIDs = conn.listDomainsID() if domainIDs == None: print('Failed to get a list of domain IDs') exit(1) domain_info = {} for domainID in domainIDs: domain = conn.lookupByID(domainID) name = domain.name() domain_info[name] = {} vcpu_list = get_cpus(conn, domainID, "/domain/cputune/vcpupin") domain_info[name]['vcpus'] = vcpu_list emu_list = get_cpus(conn, domainID, "/domain/cputune/emulatorpin") domain_info[name]['emulator'] = emu_list cpu_layout = get_cpu_layout() for item, value in domain_info.iteritems(): print(item) print(value)
async def on_watchdog_timer(self): """connection watchdog timer within main asyncio loop """ #~ print("on_watchdog_timer",self.name) if not self.vc or self.vc.isAlive() != 1: #connect/reconnect if self.vc: #cleanup previous connection for cid in self.callback_ids: try: self.vc.domainEventDeregisterAny(cid) except Exception: pass self.vc.close() del self.vc self.vc = libvirt.openReadOnly(self.uri) self.data.update_hv_info(self.id_, self.vc) for event, callback in self.event_callback_handlers.items(): cid = self.vc.domainEventRegisterAny(None, event, callback, None) self.callback_ids.append(cid) # Connection monitoring. self.vc.setKeepAlive(5, 3) else: # ~ print('all is ok') pass
def add_orphan_vm(vm_name, host_id): """ Add Orphan VM information to database. VM information is retrieved from the VM definition XML. 'System User' is added as owner of the VM. """ host_details = db.host[host_id] host_ip = host_details.host_ip.private_ip connection_object = libvirt.openReadOnly("qemu+ssh://root@" + host_ip + "/system") domain = connection_object.lookupByName(vm_name) vm_state = domain.info()[0] vm_status = vm_state_map[vm_state] # Parse domain XML to get information about VM root = etree.fromstring(domain.XMLDesc(0)) ram_elem = root.xpath('memory')[0] ram_in_kb = int(ram_elem.text) ram_in_mb = int(round(int(ram_in_kb)/(1024),0)) cpu_elem = root.xpath('vcpu')[0] cpu = int(cpu_elem.text) vnc_elem = root.xpath("devices/graphics[@type='vnc']")[0] vnc_port = vnc_elem.attrib['port'] mac_elem = root.xpath("devices/interface[@type='network']/mac")[0] mac_address = mac_elem.attrib['address'] ip_addr = db.private_ip_pool(mac_addr = mac_address) ip_address = None if ip_addr: ip_address = ip_addr['id'] template_elem = root.xpath("devices/disk[@type='file']/source")[0] template_file = template_elem.attrib['file'] command = "qemu-img info " + template_file + " | grep 'virtual size'" ret = execute_remote_cmd(host_ip, 'root', command) # Returns e.g. virtual size: 40G (42949672960 bytes) hdd = int(ret[ret.index(':')+1:ret.index('G ')].strip()) security_domain_row = db.security_domain(vlan=ip_addr['vlan']) db.vm_data.insert( vm_name = vm_name, vm_identity = (vm_name), RAM = ram_in_mb, HDD = hdd, extra_HDD = 0, vCPU = cpu, host_id = host_id, template_id = 1, #TBD datastore_id = 1, #TBD owner_id = SYSTEM_USER, requester_id = SYSTEM_USER, private_ip = ip_address, vnc_port = vnc_port, purpose = 'Added by System', security_domain = security_domain_row['id'], status = vm_status) return
def virshdomstate(domain): libvirt_states = { libvirt.VIR_DOMAIN_RUNNING: "running", libvirt.VIR_DOMAIN_SHUTOFF: "shut off", libvirt.VIR_DOMAIN_SHUTDOWN: "shut down", libvirt.VIR_DOMAIN_PAUSED: "paused", libvirt.VIR_DOMAIN_NOSTATE: "no state", libvirt.VIR_DOMAIN_BLOCKED: "blocked", libvirt.VIR_DOMAIN_CRASHED: "crashed", } conn = libvirt.openReadOnly(driver) if conn == None: print "Failed to open connection to the hypervisor" sys.exit(3) try: dom = conn.lookupByName(domain) except libvirt.libvirtError: return None state = libvirt_states[dom.info()[0]] conn.close() return state
def _try_open(self): flags = 0 vmm = self._open_dev_conn(self.get_uri()) if vmm: return vmm if self.readOnly: logging.info("Caller requested read only connection") flags = libvirt.VIR_CONNECT_RO if virtinst.support.support_openauth(): vmm = libvirt.openAuth(self.get_uri(), [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE, libvirt.VIR_CRED_EXTERNAL], self._do_creds, None], flags) else: if flags: vmm = libvirt.openReadOnly(self.get_uri()) else: vmm = libvirt.open(self.get_uri()) return vmm
def scan_attached_devices(self): devices = [] vm_ids = {} conn = libvirt.openReadOnly('qemu:///system') domains = [] self.macs_map = self._get_vfs_macs() domains_names = conn.listDefinedDomains() defined_domains = map(conn.lookupByName, domains_names) domains_ids = conn.listDomainsID() running_domains = map(conn.lookupByID, domains_ids) for domain in defined_domains: [state, maxmem, mem, ncpu, cputime] = domain.info() if state in (libvirt.VIR_DOMAIN_PAUSED, libvirt.VIR_DOMAIN_SHUTDOWN, libvirt.VIR_DOMAIN_SHUTOFF): domains.append(domain) domains += running_domains for domain in domains: raw_xml = domain.XMLDesc(0) tree = etree.XML(raw_xml) hostdevs = tree.xpath("devices/hostdev/source/address") vm_id = tree.find('uuid').text for dev in self._get_attached_hostdevs(hostdevs): devices.append(dev) vm_ids[dev[0]] = vm_id return devices, vm_ids
def run(self): args = self._prepare_args() log.info("Running virt-install.") log.info("virt-install %s", args) try: execWithRedirect("virt-install", args, raise_err=True) except subprocess.CalledProcessError as e: raise InstallError("Problem starting virtual install: %s" % e) conn = libvirt.openReadOnly(None) dom = conn.lookupByName(self._virt_name) # TODO: If vnc has been passed, we should look up the port and print that # for the user at this point while dom.isActive() and not self._log_check(): sys.stdout.write(".") sys.stdout.flush() sleep(10) print() if self._log_check(): log.info("Installation error detected. See logfile.") else: log.info("Install finished. Or at least virt shut down.")
def waitForAction(self, domid, timeout=None, events=None): libvirt.virEventRegisterDefaultImpl() rocon = libvirt.openReadOnly() run = {'state': True, 'timeout': False} def timecb(timerid, opaque): run['state'] = False run['timeout'] = True def callback(con, domain, event, detail, opaque): if domain.UUIDString() == domid: if events is not None and event in events: run['state'] = False return True if timeout: libvirt.virEventAddTimeout(timeout, timecb, None) rocon.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_LIFECYCLE, callback, rocon) while run['state']: libvirt.virEventRunDefaultImpl() if run['timeout']: raise TimeoutError("Failed to wait for state")
def __enter__(self): try: if self.sasl_username and self.sasl_password: def request_cred(credentials, user_data): for credential in credentials: if credential[0] == libvirt.VIR_CRED_AUTHNAME: credential[4] = self.sasl_username elif credential[0] == libvirt.VIR_CRED_PASSPHRASE: credential[4] = self.sasl_password return 0 auth = [[ libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE ], request_cred, None] flags = libvirt.VIR_CONNECT_RO if self.readonly else 0 self.conn = libvirt.openAuth(self.uri, auth, flags) elif self.readonly: self.conn = libvirt.openReadOnly(self.uri) else: self.conn = libvirt.open(self.uri) return self.conn except libvirt.libvirtError as e: raise exception.LibvirtConnectionOpenError(uri=self.uri, error=e)
def main(): logging.basicConfig(level=logging.INFO) parser = argparse.ArgumentParser() parser.add_argument('-p', '--port', type=int, default=1024) parser.add_argument('-c', '--connect', dest='libvirt_connection_string', default='qemu:///system') parser.add_argument('--enable-xheaders', default=False, action='store_true') parser.add_argument('--load-edited-domain-xml', default=False, action='store_true', help='Use this flag to make changes to Domain XML to be reflected immediately (opposed ' + 'to requiring a restart of the domain)') parser.add_argument('--plugin', action='append', help='Load this plugin. This simply imports the module. ' + 'See example for more details') args = parser.parse_args() if args.plugin: for plugin in args.plugin: __import__(plugin) application = tornado.web.Application( handlers.routes, machine_resolver=utils.machine_resolver.LibvirtMachineResolver( libvirt.openReadOnly(args.libvirt_connection_string), args.load_edited_domain_xml) ) http_server = tornado.httpserver.HTTPServer(application) http_server.xheaders = args.enable_xheaders http_server.listen(args.port) tornado.ioloop.IOLoop.instance().start()