def run(self, params, args): nodes = self.newdb.getNodesfromNames(args, preload = ['vm_defs']) (terminate, action) = self.fillParams( [ ('terminate', 'n'), ('action', 'poweroff'), ]) terminate = self.str2bool(terminate) if len(nodes) < 1: self.abort('must supply host') plugins = self.loadPlugins() for node in nodes: if not terminate: # # the name of the physical host that will boot # this VM host # if not node.vm_defs: self.abort("host %s is not a virtual host" % node.name) if not node.vm_defs.physNode: self.abort("host %s does not have a physical host" % node.name) # get the physical node that houses this VM physhost = node.vm_defs.physNode.name import rocks.vmconstant hipervisor = libvirt.open(rocks.vmconstant.connectionURL % physhost) libvirt.registerErrorHandler(handler, 'context') try: domU = hipervisor.lookupByName(node.name) if(action == 'poweroff'): domU.destroy() domU.undefine() elif(action == 'shutdown'): domU.shutdown() domU.undefine() elif(action == 'reset'): domU.reset(0) elif(action == 'reboot'): domU.reboot(0) except libvirt.libvirtError, m: pass if terminate: # # run the terminate plugins to deallocate the host resources # for plugin in plugins: syslog.syslog(syslog.LOG_INFO, 'run %s' % plugin) plugin.run(node)
def run(self, params, args): nodes = self.newdb.getNodesfromNames(args, preload=['vm_defs']) (terminate, action) = self.fillParams([ ('terminate', 'n'), ('action', 'poweroff'), ]) terminate = self.str2bool(terminate) if len(nodes) < 1: self.abort('must supply host') plugins = self.loadPlugins() for node in nodes: if not terminate: # # the name of the physical host that will boot # this VM host # if not node.vm_defs: self.abort("host %s is not a virtual host" % node.name) if not node.vm_defs.physNode: self.abort("host %s does not have a physical host" % node.name) # get the physical node that houses this VM physhost = node.vm_defs.physNode.name import rocks.vmconstant hipervisor = libvirt.open(rocks.vmconstant.connectionURL % physhost) libvirt.registerErrorHandler(handler, 'context') try: domU = hipervisor.lookupByName(node.name) if (action == 'poweroff'): domU.destroy() domU.undefine() elif (action == 'shutdown'): domU.shutdown() domU.undefine() elif (action == 'reset'): domU.reset(0) elif (action == 'reboot'): domU.reboot(0) except libvirt.libvirtError, m: pass if terminate: # # run the terminate plugins to deallocate the host resources # for plugin in plugins: syslog.syslog(syslog.LOG_INFO, 'run %s' % plugin) plugin.run(node)
def __init__(self, username, password, port, address, domain_name, libvirt_uri, libvirt_sasl_username=None, libvirt_sasl_password=None): super(VirtualBMC, self).__init__({username: password}, port=port, address=address) self.domain_name = domain_name self._conn_args = { 'uri': libvirt_uri, 'sasl_username': libvirt_sasl_username, 'sasl_password': libvirt_sasl_password } self._domain = None self._state = None self._stream = None self._run_console = False self._sol_thread = None libvirt.virEventRegisterDefaultImpl() libvirt.registerErrorHandler(error_handler, None)
def main(args): parser = argparse.ArgumentParser() parser.add_argument('--libvirt-url', dest='libvirturl', default="qemu:///system", help='Set libvirt connection url - default is "qemu:///system"') parser.add_argument('cluster_description_file', type=argparse.FileType('r'), help='File with cluster description') args = parser.parse_args() libvirt.registerErrorHandler(suppress_some_messages, None) with action("Connecting to libvirt at {}".format(args.libvirturl)): conn = libvirt.open(args.libvirturl) with action("Load cluster description from {}".format(args.cluster_description_file.name)): cluster = load_cluster_description(args.cluster_description_file.read()) images_path = cluster.attrs['images_path'] print "Will store images to", images_path cluster.fuel_vm.boot_network = False launch_vm(conn, cluster.fuel_vm, cluster.nets, images_path) wait_fuel_installed(cluster.fuel_vm) for vm_name, vm in cluster.vms.items(): launch_vm(conn, vm, cluster.nets, images_path) return 0
def main(): parser = argparse.ArgumentParser( prog='virshbmc', description='Pretend to be a BMC and proxy to virsh', formatter_class=argparse.ArgumentDefaultsHelpFormatter ) parser.add_argument('--port', dest='port', type=int, default=623, help='(UDP) port to listen on') parser.add_argument('--connect', dest='hypervisor', default='qemu:///system', help='The hypervisor to connect to') parser.add_argument('--domain', dest='domain', required=True, help='The name of the domain to manage') args = parser.parse_args() libvirt.virEventRegisterDefaultImpl() libvirt.registerErrorHandler(error_handler, None) mybmc = LibvirtBmc({'admin': 'password'}, hypervisor=args.hypervisor, domain=args.domain, port=args.port) mybmc.listen()
def test(self): self.mox.StubOutWithMock(libvirt, 'registerErrorHandler') libvirt.registerErrorHandler(mox.IgnoreArg(), None) self.mox.ReplayAll() utils._clearLibvirtError()
def __virtual__(): ''' Apply this module as the hyper module if the minion is a kvm hypervisor ''' if 'virtual' not in __grains__: return False if __grains__['virtual'] != 'physical': return False if __grains__['kernel'] != 'Linux': return False if not os.path.exists('/proc/modules'): return False try: if 'kvm_' not in salt.utils.fopen('/proc/modules').read(): return False except IOError: return False if not HAS_LIBVIRT: return False #Libvirt is very noisy. This will quiet it down def quiet_errors(ignored, err): log.debug(err[2]) libvirt.registerErrorHandler(quiet_errors, None) try: libvirt_conn = libvirt.open('qemu:///system') libvirt_conn.close() return 'hyper' except libvirt.libvirtError: return False
def main(): # Ignore text error from libvirt libvirt.registerErrorHandler(lambda: 1, None) parser = argparse.ArgumentParser( description='Provide functions to create and manage VMs on KVM.', prog='vm') parser.add_argument('--version', action='version', version=Configuration.VERSION) parser.add_argument('-v', '--verbose', action='store_true') parser.add_argument( '--fork', default=4, type=int, help='set how many tasks launch parallelly') add_subparsers(parser) args = parser.parse_args() if args.verbose: logger.setLevel(logging.DEBUG) Resources(Configuration.RESOURCE_CONFIG) if hasattr(args, 'func'): getattr(args, 'func')(args) else: parser.print_help() sys.exit(0)
def __init__(self, config): self.conn = None self.uri = config.get('main', 'libvirt-hypervisor-uri') self.logger = logging.getLogger('mom.libvirtInterface') libvirt.registerErrorHandler(self._error_handler, None) self._connect() self._setStatsFields()
def register(): ctx = 'just some information' libvirt.registerErrorHandler(error_handler, ctx) conn = libvirt.open('qemu://system') conn.close() exit(0)
def libvirt_worker_loop(loop, start_websockets_server, hypervisors): def _err_handler(self, ctxt, err): print("Error from libvirt : %s", err[2]) print("[{}] entering libvirt_worker_loop".format( threading.get_ident())) prctl.set_name('libvirt_loop') asyncio.set_event_loop(loop) libvirtaio.virEventRegisterAsyncIOImpl() libvirt.registerErrorHandler(_err_handler, '_virt_event') for id_, h in hypervisors.items(): monitor_tasks.append( loop.create_task(h['monitor_instance'].watchdog_loop())) loop.run_until_complete(start_websockets_server) try: loop.run_until_complete(asyncio.gather(*monitor_tasks)) except asyncio.CancelledError: loop.stop() finally: loop.run_until_complete(loop.shutdown_asyncgens()) loop.close()
def get_libvirt_connection(name): auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], auth_callback, None] libvirt_url = config.get('libvirt_url', 'qemu:///system') libvirt.registerErrorHandler(f=libvirt_callback, ctx=None) return libvirt.openAuth(libvirt_url, auth)
def __init__(self, config): self.conn = None self.uri = config.get('main', 'libvirt-hypervisor-uri') self.interval = config.getint('main', 'guest-monitor-interval') self.logger = logging.getLogger('mom.libvirtInterface') libvirt.registerErrorHandler(self._error_handler, None) self._connect() self._setStatsFields()
def register_libvirt_error_handler(): """ Ignore libvirt error reporting, we just use exceptions """ def libvirt_callback(userdata, err): ignore = userdata ignore = err libvirt.registerErrorHandler(f=libvirt_callback, ctx=None)
def _clearLibvirtError(): """Disable libvirt error messages. _clearLibvirtError is a helper function to withoutLibvirtError, designed to make mocks and testing easy. It simply registers NOOP error handler for libvirt. """ libvirt.registerErrorHandler((lambda ctx, err: 1), None)
def __init__(self, logger, config, registerEvents=True): super(Libvirtd, self).__init__(logger, config) self.changedCallback = None self.registerEvents = registerEvents self._host_uuid = None self._host_name = None self.eventLoopThread = None libvirt.registerErrorHandler(lambda ctx, error: None, None)
def main(): module = AnsibleModule(argument_spec=dict( pool=dict(required=True), name=dict(aliases=['vol'], required=True), state=dict(choices=all_states, default='present'), uri=dict(default='qemu:///system'), capacity=dict(aliases=['size']), allocation=dict(choices=['thin', 'fat'], default='thin'), ), supports_check_mode=True) result = dict(changed=False, message='') if not installed_libvirt_py: module.fail_json(msg="'libvirt' python library is missing on host.") libvirt.registerErrorHandler(eh_dummy, 'ctx') # apply dummy error handler # connect to libvirt host conn = libvirt.open(module.params['uri']) if not module.check_mode else \ libvirt.openReadOnly(module.params['uri']) if not conn: module.fail_json(msg="connection to libvirt failed.") pool_handle = None disk_handle = None # look for volume try: pool_handle = conn.storagePoolLookupByName(module.params['pool']) disk_handle = pool_handle.storageVolLookupByName(module.params['name']) except libvirt.libvirtError as e: if e.get_error_code() == libvirt.VIR_ERR_NO_STORAGE_POOL: module.fail_json(msg="no such pool", debug=(e.get_error_code(), str(e))) elif e.get_error_code() != libvirt.VIR_ERR_NO_STORAGE_VOL: module.fail_json(msg=str(e), debug=e.get_error_code()) # apply state if not disk_handle and module.params['state'] == 'present': result['changed'] = True # determine capacity first if not 'capacity' in module.params: module.fail_json(msg="you should define a capacity") capacity = get_capacity(module.params['capacity']) if not capacity: module.fail_json(msg="invalid capacity format") if not module.check_mode: define_vol(pool_handle, module.params['name'], capacity, thin=(module.params['allocation'] == 'thin')) elif disk_handle and module.params['state'] == 'absent': result['changed'] = True if not module.check_mode: undefine_vol(disk_handle) module.exit_json(**result)
def __init__(self, vm_name): """Get config and setup logging.""" self.config = config.setup() self.log = logging.getLogger(__name__) def _error_handler(self, err): msg = "Ignoring Libvirt error %s)" % err pass # Prevent libvirt errors from reaching the console libvirt.registerErrorHandler(_error_handler, None)
def close(self): libvirt.registerErrorHandler(None, None) if self._xs: self._xs.close() self._xs = None if self._libvirt_conn: self._libvirt_conn.close() self._libvirt_conn = None self._xc = None # and pray it will get garbage-collected
def main(): args = parser.parse_args() if args.debug: LOG.setLevel(logging.DEBUG) nova_config = [] if args.nova_config: nova_config = [args.nova_config] config.parse_args([], default_config_files=nova_config) if args.mysql_connection: config.CONF.set_override('connection', args.mysql_connection, 'database') ctx = context.get_admin_context() instance = objects.instance.Instance.get_by_uuid(ctx, args.instance) compute_node = objects.compute_node.ComputeNode.get_by_host_and_nodename( ctx, instance.host, instance.node) if args.action not in ALLOWED_ACTIONS: raise Exception("Allowed action are: %s" % ', '.join(ALLOWED_ACTIONS)) action = 'do_{}'.format(args.action) eval(action)(instance, compute_node) instance = objects.instance.Instance.get_by_uuid(ctx, args.instance) compute_node = objects.compute_node.ComputeNode.get_by_host_and_nodename( ctx, instance.host, instance.node) print_status(instance, compute_node, "Current status:") raw_input("Press ENTER to continue") # NOTE(aostapenko) handling libvirt verbosity def _error_handler(ctx, err): pass libvirt.registerErrorHandler(_error_handler, None) libvirt.virEventRegisterDefaultImpl() libvirt_host = host.Host('qemu:///system') domain = libvirt_host.get_domain(instance) total_pcpus = libvirt_host.get_connection().getInfo()[2] vcpu_pcpu_map = calculate_vcpu_pcpu_map(instance, compute_node, total_pcpus) current_vcpu_pcpu_map = get_vcpu_pcpu_map_from_domain(domain) print("Current libvirt pinnings:") print_vcpu_pcpu_data(current_vcpu_pcpu_map) print("Proposed libvirt pinnings, based on current pinning data from DB:") print_vcpu_pcpu_data(vcpu_pcpu_map) if (raw_input("Write 'apply' to apply proposed pinnings to domain: ") == 'apply'): apply_to_domain(domain, vcpu_pcpu_map) print("Changes were applied to domain") else: print("Changes were NOT applied to domain") print("Current libvirt pinnings:") current_vcpu_pcpu_map = get_vcpu_pcpu_map_from_domain(domain) print_vcpu_pcpu_data(current_vcpu_pcpu_map)
def setup_libvirt(): import libvirt # Check libvirt version assert (libvirt.getVersion() >= 9008) # 0.9.8 # Squash redundant reporting of libvirt errors to stderr. This modifies # global state, since the Python bindings don't provide a way to do this # per-connection. libvirt.registerErrorHandler(lambda _ctx, _error: None, None)
def setup_libvirt(): import libvirt # Check libvirt version assert(libvirt.getVersion() >= 9008) # 0.9.8 # Squash redundant reporting of libvirt errors to stderr. This modifies # global state, since the Python bindings don't provide a way to do this # per-connection. libvirt.registerErrorHandler(lambda _ctx, _error: None, None)
def libvirt_connect(url): def _error_handler(_, err): pytest.fail("!!! {}".format(err[2]), pytrace=False) libvirt.registerErrorHandler(_error_handler, ctx=None) virt = libvirt.open(url) if not virt: pytest.fail("Could not establish libvirt connection") return virt
def disable_libvirt_error_logging(): def libvirt_errorhandler(userdata, error): # A libvirt error handler to ignore annoying messages in stderr pass # Filter functions are enable only in production env if cherrypy.config.get('environment') != 'production': return # Register the error handler to hide libvirt error in stderr libvirt.registerErrorHandler(f=libvirt_errorhandler, ctx=None)
def disable_screen_error_logging(): def libvirt_errorhandler(userdata, error): # A libvirt error handler to ignore annoying messages in stderr pass # Register the error handler to hide libvirt error in stderr libvirt.registerErrorHandler(f=libvirt_errorhandler, ctx=None) # Disable cherrypy screen logging, in order to log errors on kimchi # file without displaying them on screen cherrypy.log.screen = False
def main(self): """Main method. Set the URI, error handler, and executes event loop processing. """ uri = CONF.libvirt.connection_uri LOG.debug("Using uri:" + uri) # set error handler & do event loop libvirt.registerErrorHandler(self._err_handler, '_virt_event') self._virt_event(uri)
def main(): module = AnsibleModule( argument_spec=dict( name=dict(aliases=['net'], required=True), state=dict(choices=all_states, default='present'), uri=dict(default='qemu:///system'), autostart=dict( type='bool', default=True), # FIXME: change is not implemented yet xml=dict(), ), supports_check_mode=True) result = dict(changed=False, message='') if not installed_libvirt_py: module.fail_json(msg="'libvirt' python library is missing on host.") libvirt.registerErrorHandler(eh_dummy, 'ctx') # apply dummy error handler # connect to libvirt host conn = libvirt.open(module.params['uri']) if not module.check_mode else \ libvirt.openReadOnly(module.params['uri']) if not conn: module.fail_json(msg="connection to libvirt failed.") net_handle = None # look for network try: net_handle = conn.networkLookupByName(module.params['name']) except libvirt.libvirtError as e: if e.get_error_code() != libvirt.VIR_ERR_NO_NETWORK: module.fail_json(msg=str(e), debug=(e.get_error_code(), str(e))) # apply state if not net_handle and module.params['state'] == 'present': result['changed'] = True if not 'xml' in module.params or not module.params['xml']: module.fail_json(msg="you should define a xml") if not module.check_mode: define_net(conn, module.params['name'], module.params['xml'], module.params['autostart']) elif net_handle and module.params['state'] == 'absent': result['changed'] = True if not module.check_mode: undefine_net(net_handle) elif module.params['state'] == 'leases': if not net_handle: module.fail_json(msg="net does not exist") result['changed'] = False result['leases'] = net_handle.DHCPLeases() module.exit_json(**result)
def __init__(self, uri=None): """Creates a read only connection to libvirt""" self.conn = libvirt.openReadOnly(uri) if self.conn is None: raise LibvirtConnectionError( "Failed to open connection to the hypervisor: " + str(uri)) # We set this because when libvirt errors are raised, they are still # printed to console (stderr) even if you catch them. # This is a problem with libvirt API. # See https://stackoverflow.com/questions/45541725/avoiding-console-prints-by-libvirt-qemu-python-apis libvirt.registerErrorHandler(f=self.libvirt_callback, ctx=None)
def main(args): ended = False libvirt.registerErrorHandler(lambda x, y: None, None) VirtuiConfig.loadconfig('~/.virtui.conf') _change_terminal_title(VirtuiConfig.general('virtui_terminal_title')) conn = Connection(VirtuiConfig.general('LIBVIRT_URI')) while not ended: domain = select_domain(conn) if domain == None: ended = True break manage_domain(domain)
def _set_libvirt_error_handler(): """ Ignore libvirt error reporting, we just use exceptions """ import libvirt def libvirt_callback(userdata, err): ignore = userdata ignore = err ctx = None libvirt.registerErrorHandler(libvirt_callback, ctx)
def get_libvirt_connection(name): if name not in LIBVIRT_CONNECTIONS: auth = [ [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], auth_callback, None ] libvirt_url = config.get('libvirt_url', 'qemu:///system') libvirt.registerErrorHandler(f=libvirt_callback, ctx=None) LIBVIRT_CONNECTIONS[name] = libvirt.openAuth(libvirt_url, auth) return LIBVIRT_CONNECTIONS[name]
def run(self): loop.virEventLoopPureRegister() libvirt.registerErrorHandler(error_handler, self) while True: try: with self._conn as conn: conn.registerCloseCallback(connection_close_callback, self) conn.domainEventRegister(lifecycle_callback, self) loop.virEventLoopPureRun() except Exception as e: error(e) sleep(5)
def _create_connection(): libvirt.registerErrorHandler(_error_handler, ctx=None) url = self.get_virt_url() if not url: raise error.ConnError("[libvirt] No connection url supplied") virt = libvirt.open(url) if not virt: raise error.ConnError("[libvirt] Could not connect " "to {}".format(url)) return virt
def __init__(self, logger, registerEvents=True): self.changedCallback = None self.logger = logger self.virt = None # Log libvirt errors libvirt.registerErrorHandler(lambda ctx, error: None, None) #self.logger.exception(error), None) try: self.virt = libvirt.openReadOnly("") # Register listener for domain changes if we are not in oneshot mode if registerEvents: self.virt.domainEventRegister(self.changed, None) event.virtType = self.virt.getType() except libvirt.libvirtError, e: raise VirtError(str(e))
def connect(self): """ Connect to the hypervisor. """ if self.connected is False: try: libvirt.registerErrorHandler(self.handler, 'context') self.connection = libvirt.open(self.uri) except libvirt.libvirtError: self.connected = False return None else: self.connected = True return self.connection
def __init__(self, logger, config, dest, terminate_event=None, interval=None, oneshot=False, registerEvents=True): super(Libvirtd, self).__init__(logger, config, dest, terminate_event=terminate_event, interval=interval, oneshot=oneshot) self.changedCallback = None self.registerEvents = registerEvents self._host_capabilities_xml = None self._host_socket_count = None self._host_uuid = None self._host_name = None self.eventLoopThread = None libvirt.registerErrorHandler(lambda ctx, error: None, None)
def main(): libvirt.virEventRegisterDefaultImpl() libvirt.registerErrorHandler(handleLibvirtLibraryError, None) worker = threading.Thread(target=work) worker.setDaemon(True) worker.start() eventLoop = threading.Thread(target=virEventLoopNativeRun) eventLoop.setDaemon(True) eventLoop.start() while True: time.sleep(1)
def initialize(self): # prepare libvirt libvirt.registerErrorHandler(self._native_libvirt_error_handler, None) libvirt.virEventRegisterDefaultImpl() # start native listening thread self._native_event_queue = native_queue.Queue() self._event_thread = native_threading.Thread( target=self._native_thread) self._event_thread.setDaemon(True) self._event_thread.start() # prepare dispatching greenthread eventlet.spawn_n(self._dispatch_event)
def __init__(self): """Get config and setup loggings.""" self.config = config.setup() self.log = logging.getLogger(__name__) #This block gets interface and interface type from config file self._lookupInterfaces() #And this one does the same for disks. self._lookupDisks() self.search_headers = self.config.get('VM', 'search_headers', 'name,uuid') self.headers = self.search_headers.split(',') def _error_handler(self, err): msg = "Ignoring Libvirt error %s)" % err pass # Prevent libvirt errors from reaching the console libvirt.registerErrorHandler(_error_handler, None)
def register_libvirt_error_handler(): """ Ignore libvirt error reporting, we just use exceptions """ def libvirt_callback(userdata, err): ignore = userdata ignore = err def libxml2_callback(userdata, err): ignore = userdata logging.debug("libxml2 callback error: %s", err) libvirt.registerErrorHandler(f=libvirt_callback, ctx=None) import libxml2 libxml2.registerErrorHandler(f=libxml2_callback, ctx=None)
def init_vmm_connection(self): if self._libvirt_conn is not None: # Already initialized return if self._offline_mode: # Do not initialize in offline mode return if 'xen.lowlevel.xs' in sys.modules: self._xs = xen.lowlevel.xs.xs() self._libvirt_conn = libvirt.open(defaults['libvirt_uri']) if self._libvirt_conn == None: raise QubesException("Failed connect to libvirt driver") libvirt.registerErrorHandler(self._libvirt_error_handler, None) atexit.register(self._libvirt_conn.close)
def run(self, params, args): if not len(args): self.abort('must supply at least one host') for node in self.newdb.getNodesfromNames(args, preload=['vm_defs', 'vm_defs.disks']): self.runPlugins(node) vmnodeid = None mem = None cpus = None macs = None disks = None # # get the name of the physical node that hosts # this VM # if node.vm_defs and node.vm_defs.physNode: # # try to undefine the domain in libvirt # libvirt.registerErrorHandler(handler, 'context') try: hipervisor = libvirt.open(rocks.vmconstant.connectionURL \ % node.vm_defs.physNode.name) dom = hipervisor.lookupByName(node.name) dom.undefine() except libvirt.libvirtError, m: if 'unable to connect' in str(m): # connection problem just report it do not fail print "Warning (libvirt): ", m # the domain was not defined, no big deal pass # # now remove the relevant rows in the database for # this VM # if node.vm_defs: s = self.newdb.getSession() s.delete(node.vm_defs) for disk in node.vm_defs.disks: s.delete(disk)
def init_vmm_connection(self): '''Initialise connection This method is automatically called when getting''' if self._libvirt_conn is not None: # Already initialized return if self._offline_mode: # Do not initialize in offline mode raise qubes.exc.QubesException( 'VMM operations disabled in offline mode') if 'xen.lowlevel.xs' in sys.modules: self._xs = xen.lowlevel.xs.xs() if 'xen.lowlevel.xc' in sys.modules: self._xc = xen.lowlevel.xc.xc() self._libvirt_conn = VirConnectWrapper( qubes.config.defaults['libvirt_uri']) libvirt.registerErrorHandler(self._libvirt_error_handler, None)
def __init__(self): self.lock = threading.RLock() try: # try to use libvirt import libvirt libvirt.virInitialize() globals()["libvirt"] = libvirt # register an ErrorCallback def errHandler(ctx, error): # log.debug("backend error: %s" % (error,)) pass libvirt.registerErrorHandler(errHandler, None) self.con = libvirt.open(None) log.info("backend connected to libvirt") except: log.error("could not connect to xen backend!") raise