def get_handler(self): ''' return the handler of the virt_driver ''' if self._hypervisor_handler: return self._hypervisor_handler old = signal.signal(signal.SIGALRM, self.timeout_handler) signal.alarm(4) # connetctions timeout set to 4 secs try: if self.hostname is None: url = DEFAULT_HV self._hypervisor_handler = libvirt.open(url) else: url = "{0}{1}{2}".format('qemu+tls://', self.hostname, '/system') self._hypervisor_handler = libvirt.openAuth(url, self._auth, 0) except Exception as error: log.debug("Can not connect to url: %s, error: %s. Retrying...", url, error) signal.alarm(4) try: url = "{0}{1}{2}".format('qemu+tcp://', self.hostname, '/system') self._hypervisor_handler = libvirt.openAuth(url, self._auth, 0) except Exception as error: log.error("Can not connect to url: %s, error: %s ", url, error) return None finally: signal.alarm(0) signal.signal(signal.SIGALRM, old) if not self._hypervisor_handler: return None return self._hypervisor_handler
def _get_root_handler(self): """ Return the root handler of libvirt """ if self._hypervisor_root_handler: return self._hypervisor_root_handler if self.hostname is None: hostname = "localhost" else: hostname = self.hostname url = "{0}{1}{2}".format('qemu+tls://', hostname, '/system') old = signal.signal(signal.SIGALRM, self.timeout_handler) signal.alarm(4) # connetctions timeout set to 4 secs try: self._hypervisor_root_handler = libvirt.openAuth(url, self._auth, 0) except Exception as error: log.debug("Can not connect to %s, error: %s. Retrying...", url, error) url = "{0}{1}{2}".format('qemu+tcp://', hostname, '/system') signal.alarm(4) try: self._hypervisor_root_handler = libvirt.openAuth(url, self._auth, 0) except Exception as error: log.error("Can not connect to url:%s, error: %s", url, error) return None finally: signal.alarm(0) signal.signal(signal.SIGALRM, old) if self._hypervisor_root_handler: return self._hypervisor_root_handler return None
def __init__(self, host, login, passwd, conn): self.login = login self.host = host self.passwd = passwd self.conn = conn if self.conn == CONN_TCP: def creds(credentials, user_data): for credential in credentials: if credential[0] == libvirt.VIR_CRED_AUTHNAME: credential[4] = self.login if len(credential[4]) == 0: credential[4] = credential[3] elif credential[0] == libvirt.VIR_CRED_PASSPHRASE: credential[4] = self.passwd else: return -1 return 0 flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] auth = [flags, creds, None] uri = 'qemu+tcp://%s/system' % self.host try: self.wvm = libvirt.openAuth(uri, auth, 0) except libvirtError: raise libvirtError('Connection Failed') if self.conn == CONN_SSH: uri = 'qemu+ssh://%s@%s/system' % (self.login, self.host) try: self.wvm = libvirt.open(uri) except libvirtError as err: raise err.message if self.conn == CONN_TLS: def creds(credentials, user_data): for credential in credentials: if credential[0] == libvirt.VIR_CRED_AUTHNAME: credential[4] = self.login if len(credential[4]) == 0: credential[4] = credential[3] elif credential[0] == libvirt.VIR_CRED_PASSPHRASE: credential[4] = self.passwd else: return -1 return 0 flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] auth = [flags, creds, None] uri = 'qemu+tls://%s@%s/system' % (self.login, self.host) try: self.wvm = libvirt.openAuth(uri, auth, 0) except libvirtError: raise libvirtError('Connection Failed')
def __init__(self, uri, key=None, secret=None): """ :param uri: Hypervisor URI (e.g. vbox:///session, qemu:///system, etc.). :type uri: ``str`` :param key: the username for a remote libvirtd server :type key: ``str`` :param secret: the password for a remote libvirtd server :type key: ``str`` """ if not have_libvirt: raise RuntimeError('Libvirt driver requires \'libvirt\' Python ' + 'package') self._uri = uri self._key = key self._secret = secret if uri is not None and '+tcp' in self._uri: if key is None and secret is None: raise RuntimeError('The remote Libvirt instance requires ' + 'authentication, please set \'key\' and ' + '\'secret\' parameters') auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], self._cred_callback, None] self.connection = libvirt.openAuth(uri, auth, 0) else: self.connection = libvirt.open(uri) if uri is None: self._uri = self.connection.getInfo()
def hypervisor_connecting_test(uri, auth_tls, username, password, logger, expected_result): """ connect remote server """ ret = 0 try: if auth_tls == 'none': conn = libvirt.open(uri) elif auth_tls == 'sasl': user_data = [username, password] auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_credentials, user_data] conn = libvirt.openAuth(uri, auth, 0) except libvirtError as e: logger.error("API error message: %s, error code is %s" % (e.message, e.get_error_code())) ret = 1 conn.close() if ret == 0 and expected_result == 'success': logger.info("tls authentication success") return 0 elif ret == 1 and expected_result == 'fail': logger.info("tls authentication failed, but that is expected") return 0 elif ret == 0 and expected_result == 'fail': logger.error("tls authentication success, but we hope the reverse") return 1 elif ret == 1 and expected_result == 'success': logger.error("tls authentication failed") return 1 return 0
def _openVirConn(self): """Open a libvirt connection, and return the virConnect object. This method also ensures that the libvirt event is running.""" def requestCredentials(creds, unused): for cred in creds: if cred[0] == libvirt.VIR_CRED_AUTHNAME: cred[4] = "root" elif cred[0] == libvirt.VIR_CRED_PASSPHRASE: cred[4] = self.password else: return -1 return 0 # ensure an event loop is running if Host.eventThread is None: xenrt.TEC().logverbose("Starting libvirt event loop") libvirt.virEventRegisterDefaultImpl() Host.eventThread = thread.start_new_thread(Host.virEventLoop, ()) # make the connection to the libvirt daemon on the guest xenrt.TEC().logverbose("Connecting to libvirt daemon for %s" % self) uri = self._getVirURL() auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], requestCredentials, None] virConn = libvirt.openAuth(uri, auth, 0) # if necessary, check that the version of libvirt that's on the guest is recent enough if self.LIBVIRT_REMOTE_DAEMON and virConn.getLibVersion( ) < LIBVIRT_GUEST_MIN_VERSION: raise xenrt.XRTError( "libvirt version on the guest (%d) is not recent enough (need >= %d)" % (virConn.getLibVersion(), LIBVIRT_GUEST_MIN_VERSION)) return virConn
def create_snapshot(virtURI, hostUsername, hostPassword, vmName, name, comment, remove=False): #create/remove snapshot #authentificate global LIBVIRT_USERNAME global LIBVIRT_PASSWORD LIBVIRT_USERNAME = hostUsername LIBVIRT_PASSWORD = hostPassword LOGGER.debug("Creating snapshot with user '" + hostUsername + "'...") auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], get_libvirt_credentials, None] conn = libvirt.openAuth(virtURI, auth, 0) if conn == None: LOGGER.error("Unable to establish connection to hypervisor!") #sys.exit(1) return False try: targetVM = conn.lookupByName(vmName) if remove: #remove snapshot targetSnap = targetVM.snapshotLookupByName(name, 0) return targetSnap.delete(0) else: #create snapshot snapXML = "<domainsnapshot><name>" + name + "</name><description>" + comment + "</description></domainsnapshot>" return targetVM.snapshotCreateXML(snapXML, 0) except Exception,e: #Snapshot 'Before maintenance' already exists if remove: LOGGER.error("Unable to remove snapshot: '" + str(e) + "'") else: LOGGER.error("Unable to create snapshot: '" + str(e) + "'") return False
def __connect_tcp(self): """ 同时支持libvirt远程tcp认证和不认证连接 (但测试下来tcp认证远程连接有问题,目前还没有明确解决方案,#### todo) """ uri = 'qemu+tcp://%s/system' % self.host try: self.connection = libvirt.open(uri) self.last_error = None except libvirtError as e: if 'authentication failed' in str(e): flags = [ libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE ] auth = [flags, self.__libvirt_auth_credentials_callback, None] try: self.connection = libvirt.openAuth(uri, auth, 0) self.last_error = None except libvirtError as err: self.last_error = 'Connection Failed: ' + str(err) self.connection = None else: self.last_error = 'Connection Failed: ' + str(e) self.connection = None
def libvirt_conn(host): """ Function for connect to libvirt host. Create exceptions and return if not connnected. """ if host.conn_type == 'tcp': def creds(credentials, user_data): for credential in credentials: if credential[0] == libvirt.VIR_CRED_AUTHNAME: credential[4] = host.login if len(credential[4]) == 0: credential[4] = credential[3] elif credential[0] == libvirt.VIR_CRED_PASSPHRASE: credential[4] = host.passwd else: return -1 return 0 flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] auth = [flags, creds, None] uri = 'qemu+tcp://%s/system' % host.ipaddr if host.conn_type == 'ssh': uri = 'qemu+ssh://%s@%s:%s/system' % (host.login, host.ipaddr, host.ssh_port) try: if host.conn_type == 'tcp': conn = libvirt.openAuth(uri, auth, 0) if host.conn_type == 'ssh': conn = libvirt.open(uri) return conn except libvirt.libvirtError as e: return {'error': e.message}
def open(self, authcb, cbdata): if self._magic_uri: self._magic_uri.validate() # Mirror the set of libvirt.c virConnectCredTypeDefault valid_auth_options = [ libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_ECHOPROMPT, libvirt.VIR_CRED_REALM, libvirt.VIR_CRED_PASSPHRASE, libvirt.VIR_CRED_NOECHOPROMPT, libvirt.VIR_CRED_EXTERNAL, ] open_flags = 0 conn = libvirt.openAuth(self._open_uri, [valid_auth_options, authcb, cbdata], open_flags) if self._magic_uri: self._magic_uri.overwrite_conn_functions(conn) self._libvirtconn = conn if not self._open_uri: self._uri = self._libvirtconn.getURI() self._uriobj = URI(self._uri)
def get_connection(self): """ Get connection with libvirt using QEMU driver and system context :return conn: connection with libvirt :rtype conn: libvirt connection """ creds = self.args.credentials if 'username' in creds: auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], creds['username'], None] conn = libvirt.openAuth(creds['qemu_instance'], auth, 0) else: conn = libvirt.open(creds['qemu_instance']) if conn is None: LOG.error('Failed to open connection to %s', creds['qemu_instance']) LOG.warn('check PAWS documentation %s' % LIBVIRT_AUTH_HELP) raise SystemExit(1) LOG.debug("connected successfully to %s" % creds['qemu_instance']) 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 _global_connect(self): """Set the single connection handle.""" try: self.auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], self._auth_callback, None] return libvirt.openAuth(self.dsn, self.auth, 0) except libvirt.libvirtError as libvex: raise CuckooCriticalError("libvirt returned an exception on connection: %s" % libvex)
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 __init__(self, host): """ Return connection object. """ self.login = host.login self.host = host.ipaddr self.passwd = host.passwd self.type = host.conn_type self.port = host.ssh_port if self.type == 'tcp': def creds(credentials, user_data): for credential in credentials: if credential[0] == libvirt.VIR_CRED_AUTHNAME: credential[4] = self.login if len(credential[4]) == 0: credential[4] = credential[3] elif credential[0] == libvirt.VIR_CRED_PASSPHRASE: credential[4] = self.passwd else: return -1 return 0 flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] auth = [flags, creds, None] uri = 'qemu+tcp://%s/system' % self.host self.conn = libvirt.openAuth(uri, auth, 0) if self.type == 'ssh': uri = 'qemu+ssh://%s@%s:%s/system' % (self.login, self.host, self.port) self.conn = libvirt.open(uri)
def get_domxml(self): def auth_cb(cred, _): for c in cred: if c[0] == libvirt.VIR_CRED_AUTHNAME: c[4] = self.user elif c[0] == libvirt.VIR_CRED_PASSPHRASE: c[4] = self._password else: return -1 return 0 cred_info = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], auth_cb, None] if self._uri.startswith('ssh://'): uri = "esx://%s@%s/" % (quote(self.user), self.server) if self.insecure: uri += '?no_verify=1' else: uri = self._uri conn = libvirt.openAuth(uri, cred_info) domxml = conn.lookupByName(self._vm_name).XMLDesc() logging.debug('Fetched domxml: \n%s', domxml) return domxml
def get_conn(uri='', username='', password=''): """ get connection object from libvirt module """ user_data = [username, password] auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_credentials, user_data] conn = libvirt.openAuth(uri, auth, 0) return conn
def list_networks(): auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], authcb, None] uri = "qemu:///system" conn = libvirt.openAuth(uri, auth, 0) networks = conn.listNetworks() conn.close() return networks
async def get_conn(hub, connection=None, username=None, password=None): ''' Detects what type of dom this node is and attempts to connect to the correct hypervisor via libvirt. :param connection: libvirt connection URI, overriding defaults :param username: username to connect with, overriding defaults :param password: password to connect with, overriding defaults ''' conn_str = connection or hub.OPT['virt']['uri'] try: auth_types = [ libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT, libvirt.VIR_CRED_ECHOPROMPT, libvirt.VIR_CRED_PASSPHRASE, libvirt.VIR_CRED_EXTERNAL ] conn = libvirt.openAuth( conn_str, [auth_types, __get_request_auth(hub, username, password), None], 0) except Exception: # pylint: disable=broad-except raise Exception( 'Sorry, failed to open a connection to the hypervisor software at {0}' .format(conn_str)) return conn
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 authHelper(self, username, password): with TestLibvirtConnAuth.tempxmlfile(self.connXML) as fname: magic = 142857 def authCB(creds, opaque): if opaque != magic: return -1 for cred in creds: if (cred[0] == libvirt.VIR_CRED_AUTHNAME and username is not None): cred[4] = username return 0 elif (cred[0] == libvirt.VIR_CRED_PASSPHRASE and password is not None): cred[4] = password return 0 return -1 return 0 auth = [[ libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_ECHOPROMPT, libvirt.VIR_CRED_REALM, libvirt.VIR_CRED_PASSPHRASE, libvirt.VIR_CRED_NOECHOPROMPT, libvirt.VIR_CRED_EXTERNAL ], authCB, magic] return libvirt.openAuth("test://" + fname, auth, 0)
def connect(self): conn = None if self.conn_status is False: return False if self.host_protocol == 'libssh2': self.auth = [[ libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE ], self.request_cred, None] if self.host_url == None: conn = libvirt.open("qemu:///system") else: url = "{}://{}/?sshauth=password".format( VIRT_CONN_LIBSSH2, self.host_url) conn = libvirt.openAuth(url, self.auth, 0) elif self.host_protocol == 'ssh': if self.host_url == None: conn = libvirt.open("qemu:///system") else: url = "{}://{}@{}/system?socket=/var/run/libvirt/libvirt-sock&keyfile={}".format( VIRT_CONN_SSH, self.host_username, self.host_url, self.host_key) conn = libvirt.open(url) elif self.host_protocol == 'qemu': conn = libvirt.open("qemu:///system") if conn == None: logging.error('Connection to hypervisor failed!') return False else: logging.info('Connection succesfull.') self.conn = conn
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 _virt_event(self, uri): auth = [[ libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_ECHOPROMPT, libvirt.VIR_CRED_REALM, libvirt.VIR_CRED_PASSPHRASE, libvirt.VIR_CRED_NOECHOPROMPT, libvirt.VIR_CRED_EXTERNAL ], InstancemonitorManager._connect_auth_cb, None] flags = libvirt.VIR_CONNECT_RO # Run a background thread with the event loop self._vir_event_loop_native_start() event_callback_handlers = { libvirt.VIR_DOMAIN_EVENT_ID_LIFECYCLE: self._my_domain_event_callback, libvirt.VIR_DOMAIN_EVENT_ID_REBOOT: self._my_domain_event_reboot_callback, libvirt.VIR_DOMAIN_EVENT_ID_RTC_CHANGE: self._my_domain_event_rtc_change_callback, libvirt.VIR_DOMAIN_EVENT_ID_IO_ERROR: self._my_domain_event_io_error_callback, libvirt.VIR_DOMAIN_EVENT_ID_WATCHDOG: self._my_domain_event_watchdog_callback, libvirt.VIR_DOMAIN_EVENT_ID_GRAPHICS: self._my_domain_event_graphics_callback, libvirt.VIR_DOMAIN_EVENT_ID_DISK_CHANGE: self._my_domain_event_disk_change_callback, libvirt.VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON: self._my_domain_event_io_error_reason_callback, libvirt.VIR_DOMAIN_EVENT_ID_CONTROL_ERROR: self._my_domain_event_generic_callback } # Connect to libvirt - If be disconnected, reprocess. self.running = True while self.running: vc = libvirt.openAuth(uri, auth, flags) # Event callback settings callback_ids = [] for event, callback in event_callback_handlers.items(): cid = vc.domainEventRegisterAny(None, event, callback, None) callback_ids.append(cid) # Connection monitoring. vc.setKeepAlive(5, 3) while vc.isAlive() == 1 and self.running: eventlet.greenthread.sleep(1) # If connection between libvirtd was lost, # clear callback connection. LOG.warning("Libvirt Connection Closed Unexpectedly.") for cid in callback_ids: try: vc.domainEventDeregisterAny(cid) except Exception: pass vc.close() del vc time.sleep(3)
def openAuth(self, uri, auth, flags = 0): try: self.conn = libvirt.openAuth(uri, auth, flags) return self.conn except libvirt.libvirtError, e: message = e.get_error_message() code = e.get_error_code() raise exception.LibvirtAPI(message, code)
def connect(self): auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], self.request_cred, None] conn = libvirt.openAuth(self.uri, auth, 0) if conn == None: print("cannot connect") return 0 return conn
def open(uri, passwordcb): valid_auth_options = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] authcb = auth_cb authcb_data = passwordcb conn = libvirt.openAuth(uri, [valid_auth_options, auth_cb, (authcb_data, valid_auth_options)], 0) return conn
def get_libvirt_connection(name, libvirt_url='qemu:///system'): if name not in LIBVIRT_CONNECTIONS: auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], auth_callback, None] LIBVIRT_CONNECTIONS[name] = libvirt.openAuth(libvirt_url, auth) return LIBVIRT_CONNECTIONS[name]
def check_network(network_name): auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], authcb, None] uri = "qemu:///system" conn = libvirt.openAuth(uri, auth, 0) nw = conn.networkLookupByName(network_name) if nw.destroy() != 0: return 1 nw.create() return 0
def vm_conn(host_ip, creds): try: flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] auth = [flags, creds, None] uri = 'qemu+tcp://' + host_ip + '/system' conn = libvirt.openAuth(uri, auth, 0) return conn except: print "Not connected"
def delete_network(network_name): auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], authcb, None] uri = "qemu:///system" conn = libvirt.openAuth(uri, auth, 0) nw = conn.networkLookupByName(network_name) if check_network(network_name) == 0: nw.destroy() nw.undefine() return 0
def _connect(uri, read_only): auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], 'root', None] if read_only: return libvirt.openReadOnly(uri) else: return libvirt.openAuth(uri, auth, 0)
def open_connection(uri): open_flags = 0 valid_auth_options = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE, libvirt.VIR_CRED_EXTERNAL] authcb = do_creds authcb_data = None return libvirt.openAuth(uri, [valid_auth_options, authcb, authcb_data], open_flags)
def vm_conn(): try: flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] auth = [flags, creds, None] uri = 'qemu+tcp://' + kvm_host.ipaddr + '/system' conn = libvirt.openAuth(uri, auth, 0) return conn except libvirt.libvirtError as e: add_error(e) return "error"
def get_libvirt_connection(name, libvirt_url='qemu://system'): if name not in LIBVIRT_CONNECTIONS: auth = [ [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], auth_callback, None ] LIBVIRT_CONNECTIONS[name] = libvirt.openAuth(libvirt_url, auth) return LIBVIRT_CONNECTIONS[name]
def multiple_thread_block_on_domain_create(params): """ spawn multiple threads to create guest simultaneously check the return status of calling create API """ logger = params['logger'] guestos = params.get('guestos') arch = params.get('guestarch') num = params.get('guestnum') xmlstr = params['xml'] logger.info("the os of guest is %s" % guestos) logger.info("the arch of guest is %s" % arch) logger.info("the number of guest we are going to install is %s" % num) hypervisor = utils.get_hypervisor() uri = params['uri'] auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_credentials, None] conn = libvirt.openAuth(uri, auth, 0) logger.info("the type of hypervisor is %s" % hypervisor) logger.debug("the uri to connect is %s" % uri) envfile = os.path.join(HOME_PATH, 'global.cfg') envparser = env_parser.Envparser(envfile) ostree = envparser.get_value("guest", guestos + "_" + arch) ks = envparser.get_value("guest", guestos + "_" + arch + "_http_ks") # download vmlinuz and initrd.img vmlinuzpath = os.path.join(ostree, 'isolinux/vmlinuz') initrdpath = os.path.join(ostree, 'isolinux/initrd.img') urllib.urlretrieve(vmlinuzpath, '/var/lib/libvirt/boot/vmlinuz') urllib.urlretrieve(initrdpath, '/var/lib/libvirt/boot/initrd.img') name = "guest" start_num = num.split('-')[0] end_num = num.split('-')[1] thread_pid = [] for i in range(int(start_num), int(end_num)): guestname = name + str(i) thr = guest_install(guestname, guestos, arch, ks, conn, xmlstr, logger) thread_pid.append(thr) for id in thread_pid: id.start() for id in thread_pid: id.join() conn.close() return 0
def __connect(self): """This function establishes a connection to the hypervisor.""" #create weirdo auth dict auth = [ [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], self.retrieve_credentials, None ] #authenticate self.SESSION = libvirt.openAuth(self.URI, auth, 0) if self.SESSION == None: raise SessionException("Unable to establish connection to hypervisor!")
def power_control_virsh(poweraddr, machine, power_change, password): login = poweraddr.split('@') user.append(login[0]) test.append(password) uri = ("esx://%s?no_verify=1") % login[1] auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_cred, None] conn = libvirt.openAuth(uri, auth, 0) data = conn.lookupByName(machine) if power_change == 'on': data.create() if power_change == 'off': data.destroy()
def __connect_tls(self): flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] auth = [flags, self.__libvirt_auth_credentials_callback, None] uri = 'qemu+tls://%s@%s/system' % (self.login, self.host) try: self.connection = libvirt.openAuth(uri, auth, 0) self.last_error = None except libvirtError as e: self.last_error = 'Connection Failed: ' + str(e) self.connection = None
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 __connect_tcp(self): flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE] auth = [flags, self.__libvirt_auth_credentials_callback, None] uri = '%s+tcp://%s%s' % (self.hypervisor, self.host, self.path) try: self.connection = libvirt.openAuth(uri, auth, 0) self.last_error = None except libvirtError as e: self.last_error = 'Connection Failed: ' + str(e) self.connection = None
def hypervisor_connecting_test(uri, auth_unix_ro, auth_unix_rw, logger): """connect to hypervisor""" logger.info("connect to hypervisor") orginal_user = os.geteuid() testing_user_id = getpwnam(TESTING_USER)[2] logger.info("the testing_user id is %d" % testing_user_id) logger.info("set euid to %d" % testing_user_id) os.seteuid(testing_user_id) try: if auth_unix_ro == 'none': conn = libvirt.openReadOnly(uri) elif auth_unix_ro == 'sasl': user_data = [TESTING_USER, TESTING_USER] auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_credentials, user_data] conn = libvirt.openAuth(uri, auth, 0) if auth_unix_rw == 'none': conn = libvirt.open(uri) elif auth_unix_rw == 'sasl': user_data = [TESTING_USER, TESTING_USER] auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_credentials, user_data] conn = libvirt.openAuth(uri, auth, 0) conn.close() except libvirtError as e: logger.error("API error message: %s, error code is %s" % (e.message, e.get_error_code())) logger.info("set euid back to %d" % orginal_user) os.seteuid(orginal_user) conn.close() return 1 logger.info("set euid back to %d" % orginal_user) os.seteuid(orginal_user) return 0
def hypervisor_connecting_test(uri, auth_tls, username, password, logger, expected_result): """ connect remote server """ ret = 0 try: if auth_tls == "none": conn = libvirt.open(uri) elif auth_tls == "sasl": user_data = [username, password] auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_credentials, user_data] conn = libvirt.openAuth(uri, auth, 0) except libvirtError, e: logger.error("API error message: %s, error code is %s" % (e.message, e.get_error_code())) ret = 1
def connect_libvirt(self): """ connect to the libvirt according to parameters in configuration """ if self.need_auth: auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], self.libvirt_credential_callback, None] self.libvirt_connection = libvirt.openAuth(self.local_libvirt_uri, auth, 0) else: self.libvirt_connection = libvirt.open(self.local_libvirt_uri) if self.libvirt_connection == None: self.log.error("unable to connect libvirt") sys.exit(-42) self.log.info("connected to libvirt uri %s" % self.local_libvirt_uri)
def connections(self): '''Return an iterator over connections to cluster hosts.''' for uri in self.hosts: try: auth = [ [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], self.authCallback, uri] yield libvirt.openAuth(uri, auth, 0) except libvirt.libvirtError, detail: print >>sys.stderr, 'ERROR: %s: %s' % ( uri, detail.get_error_message()) continue
def libvirt_connect(self): open_flags = 0 valid_auth_options = [ libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT ] authcb = None authcb_data = None uri = "hyperv://%s@%s/?transport=http" % ( self.hostinfo.get("username"), self.hostinfo.get("api_server") ) self.connection = libvirt.openAuth( uri, [valid_auth_options, authcb, authcb_data], open_flags )
def _get_connection(self): # TODO(termie): maybe lazy load after initial check for permissions # TODO(termie): check whether we can be disconnected if FLAGS.fake_libvirt: conn = fakevirt.FakeVirtConnection.instance() else: auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], 'root', None] conn = libvirt.openAuth('qemu:///system', auth, 0) if conn == None: logging.error('Failed to open connection to the hypervisor') sys.exit(1) return conn
def virtual_machine(cmd_args): auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], request_cred, None] try: conn = libvirt.openAuth(cmd_args.connection, auth, 0) except libvirt.libvirtError as e: raise RuntimeError("Failed to open connection:\n%s", str(e)) try: dom = conn.lookupByName(cmd_args.name) except libvirt.libvirtError: raise RuntimeError("Virtual machine %s not found", cmd_args.name) snapshots = dom.snapshotListNames() if SNAP_NAME in snapshots: try: snap = dom.snapshotLookupByName(SNAP_NAME) snap.delete() except libvirt.libvirtError as e: raise RuntimeError("Failed to delete snapshot:\n %s", str(e)) # start the VM try: dom.create() except libvirt.libvirtError as e: raise RuntimeError("Failed to start virtual machine:%s", str(e)) # wait for virtual machine to boot and create snapshot time.sleep(120) with ssh_connection(cmd_args): try: snap_xml = "<domainsnapshot><name>%s</name></domainsnapshot>" % SNAP_NAME dom.snapshotCreateXML(snap_xml) except libvirt.libvirtError as e: raise RuntimeError("Failed to create snapshot:\n%s.", str(e)) yield dom # stop the VM try: dom.destroy() except libvirt.libvirtError as e: raise RuntimeError("Failed to stop virtual machine:%s", str(e)) # remove the snapshot try: snap = dom.snapshotLookupByName(SNAP_NAME) snap.delete() except libvirt.libvirtError as e: raise RuntimeError("Failed to delete snapshot:\n %s", str(e))
def _connect(self): url = self._get_url() self.logger.info("Using libvirt url: %s", url if url else '""') try: if self.config.password: auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], libvirt_cred_request, self.config] v = libvirt.openAuth(url, auth, libvirt.VIR_CONNECT_RO) else: v = libvirt.openReadOnly(url) except libvirt.libvirtError as e: self.logger.exception("Error in libvirt backend") raise VirtError(str(e)) v.domainEventRegister(self._callback, None) v.setKeepAlive(5, 3) return v