def connect_host(host, user, pswd): server = VIServer() try: server.connect(host, user, pswd) LOG.info("Connected to %s %s", server.get_server_type(), host) return server except: print "unable to connect to host: " + host + " error message: "
def conexion_viserver(self): self.logger.debug(self) esxi = VIServer() esxi.connect(self.creds['ip'], self.creds['user'], self.creds['pw'], trace_file=self.config.logpysphere) self.logger.debug("Conectado a %s %s", esxi.get_server_type(), esxi.get_api_version()) return esxi
def esxi_version(self): server_obj = VIServer() try: server_obj.connect(self.host_ip, self.user, self.password) servertype, version = server_obj.get_server_type(),server_obj.get_api_version() server_obj.disconnect() return servertype, version except Exception as e: print e
def setupConnection(host, user, password): server = VIServer() try: server.connect(host, user, password) print "Host: " + host print "Version: " + server.get_server_type() + " " + server.get_api_version() + "\n" return server except Exception, err: print "Cannot connect to host: "+host+" error message: " +err.message sys.exit(2)
def setupConnection(host, user, password): server = VIServer() try: server.connect(host, user, password) print "[+] Host: " + host + " Version: " + server.get_server_type() + " " + server.get_api_version() + "\n" closeConnection(server) return True except Exception, err: print "[-] Cannot connect to host: "+host+" error message: " +err.message return None
def setupConnection(host, user, password): server = VIServer() try: server.connect(host, user, password) print "Host: " + host print "Version: " + server.get_server_type( ) + " " + server.get_api_version() + "\n" return server except Exception, err: print "Cannot connect to host: " + host + " error message: " + err.message sys.exit(2)
def setupConnection(host, user, password): server = VIServer() try: server.connect(host, user, password) print "[+] Host: " + host + " Version: " + server.get_server_type( ) + " " + server.get_api_version() + "\n" closeConnection(server) return True except Exception, err: print "[-] Cannot connect to host: " + host + " error message: " + err.message return None
class ESXiHostClass: def __init__(self, host, user, passwd): self._connection = VIServer() logger.info("%s:connecting to '%s' as '%s'", __name__, host, user) try: ssl._create_default_https_context = ssl._create_unverified_context self._connection.connect(host, user, passwd) logger.debug("%s:host reports '%s V.%s'", __name__, self._connection.get_server_type(), self._connection.get_api_version()) self.host_config, n, n, n = self._get_host_config() except Exception, err: logger.critical("%s:%s", __name__, err) quit(2)
def esxi_version(self): m = Info_log(time.strftime('%Y-%m-%d', time.localtime(time.time()))) log = m.log() server_obj = VIServer() try: server_obj.connect(self.host_ip, self.user, self.password) servertype, version = server_obj.get_server_type( ), server_obj.get_api_version() server_obj.disconnect() return servertype, version, self.flag except Exception as e: server_obj.disconnect() log.info(e)
def setupConnection(host, user, password, release): global Found global Fails try: server = VIServer() server.connect(host, user, password) print "[+] Password Found: " +password print "[+] Host: " + host + " Version: " + server.get_server_type() + " " + server.get_api_version() + "\n" closeConnection(server) Found = True except Exception, err: if 'read_nonblocking' in str(err): Fails += 1 time.sleep(5) connect(host, user, password, False) elif 'synchronize with original prompt' in str(err): time.sleep(1) connect(host, user, password, False)
class VMRUNNer: def __init__(self, hostname, username, password): self.server = VIServer() self.server.connect(hostname, username, password) def get_vm(self, vm_path_name): self.vm = self.server.get_vm_by_path(vm_path_name) return self.vm def list_vms(self): vmlist = self.server.get_registered_vms() for vm in vmlist: print vm return vmlist def get_vmserver_version(self): type = self.server.get_server_type() version = self.server.get_api_version() print 'Server Type: ' + type print 'Server API Version: ' + version
def setupConnection(host, user, password, release): global Found global Fails try: server = VIServer() server.connect(host, user, password) print "[+] Password Found: " + password print "[+] Host: " + host + " Version: " + server.get_server_type( ) + " " + server.get_api_version() + "\n" closeConnection(server) Found = True except Exception, err: if 'read_nonblocking' in str(err): Fails += 1 time.sleep(5) connect(host, user, password, False) elif 'synchronize with original prompt' in str(err): time.sleep(1) connect(host, user, password, False)
""" """ Install: pip install pysphere """ from pysphere import VIServer server = VIServer() server.connect("serverip","adminuser","pass") #Get server characteristics print server.get_server_type() print server.get_api_version() print server.get_clusters() print server._get_resource_pools #Get all the hosts print server.get_hosts() #Get VM`s in Prod resource pool which are in poweredon state vmachines = server.get_registered_vms() vmachines = server.get_registered_vms(resource_pool='Prod', status='poweredOn')
try: print(" Env: %s, vSphere Server: %s" % (s.upper(), urls[s]['suffix'])) except Exception, e: continue try: server = VIServer() server.connect(r"%s" % urls[s]['suffix'], urls[s]['user'], urls[s]['pswrd']) except Exception, e: print(Fore.RED + Style.BRIGHT + " %s" % str(e)) print try: print(Fore.GREEN + Style.BRIGHT + " Server Type: %s" % server.get_server_type()) print(Fore.GREEN + Style.BRIGHT + " API Version: %s" % server.get_api_version()) except Exception, e: print(Fore.RED + Style.BRIGHT + " %s" % str(e)) print try: lstvms = server.get_registered_vms() except Exception, e: print(Fore.RED + Style.BRIGHT + " %s" % str(e)) print for k in lnxrls: hstlst = [] for v in lstvms:
class VMWareSystem(MgmtSystemAPIBase): """Client to Vsphere API This class piggy backs off pysphere. Benefits of pysphere: - Don't need intimate knowledge w/ vsphere api itself. Detriments of pysphere: - Response often are not detailed enough. """ _stats_available = { 'num_vm': lambda self: len(self.list_vm()), 'num_host': lambda self: len(self.list_host()), 'num_cluster': lambda self: len(self.list_cluster()), 'num_template': lambda self: len(self.list_template()), 'num_datastore': lambda self: len(self.list_datastore()), } def __init__(self, hostname, username, password, **kwargs): self.api = VIServer() self.api.connect(hostname, username, password) def _get_vm(self, vm_name=None): if vm_name is None: raise Exception('Could not find a VM named %s.' % vm_name) else: try: vm = self.api.get_vm_by_name(vm_name) return vm except VIException as ex: raise Exception(ex) def does_vm_exist(self, name): try: self._get_vm(name) return True except Exception: return False def _get_resource_pool(self, resource_pool_name=None): rps = self.api.get_resource_pools() for mor, path in rps.iteritems(): if re.match('.*%s' % resource_pool_name, path): return mor # Just pick the first return rps.keys()[0] def get_ip_address(self, vm_name): vm = self._get_vm(vm_name) maxwait = 600 net_info = None waitcount = 0 while net_info is None: if waitcount > maxwait: break net_info = vm.get_property('net', False) waitcount += 5 time.sleep(5) if net_info: ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' for ip in net_info[0]['ip_addresses']: if re.match(ipv4_re, ip) and ip != '127.0.0.1': return ip return None def _get_list_vms(self, get_template=False): template_or_vm_list = [] props = self.api._retrieve_properties_traversal( property_names=['name', 'config.template'], from_node=None, obj_type=MORTypes.VirtualMachine) for prop in props: vm = None template = None for elem in prop.PropSet: if elem.Name == "name": vm = elem.Val elif elem.Name == "config.template": template = elem.Val if vm is None or template is None: continue if template == bool(get_template): template_or_vm_list.append(vm) return template_or_vm_list def start_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): return True else: vm.power_on() ack = vm.get_status() if ack == 'POWERED ON': return True return False def stop_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): return True else: vm.power_off() ack = vm.get_status() if ack == 'POWERED OFF': return True return False def delete_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): self.stop_vm(vm_name) # When pysphere moves up to 0.1.8, we can just do: # vm.destroy() request = VI.Destroy_TaskRequestMsg() _this = request.new__this(vm._mor) _this.set_attribute_type(vm._mor.get_attribute_type()) request.set_element__this(_this) rtn = self.api._proxy.Destroy_Task(request)._returnval task = VITask(rtn, self.api) status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR]) if status == task.STATE_SUCCESS: return True else: return False def create_vm(self, vm_name): raise NotImplementedError( 'This function has not yet been implemented.') def restart_vm(self, vm_name): if not self.stop_vm(vm_name): return False else: return self.start_vm(vm_name) def list_vm(self): return self._get_list_vms() def list_template(self): return self._get_list_vms(get_template=True) def list_flavor(self): raise NotImplementedError( 'This function is not supported on this platform.') def list_host(self): return self.api.get_hosts() def list_datastore(self): return self.api.get_datastores() def list_cluster(self): return self.api.get_clusters() def info(self): return '%s %s' % (self.api.get_server_type(), self.api.get_api_version()) def disconnect(self): self.api.disconnect() def vm_status(self, vm_name): state = self._get_vm(vm_name).get_status() print "vm " + vm_name + " status is " + state return state def is_vm_running(self, vm_name): state = self.vm_status(vm_name) return "POWERED ON" == state def is_vm_stopped(self, vm_name): state = self.vm_status(vm_name) return "POWERED OFF" == state def is_vm_suspended(self, vm_name): state = self.vm_status(vm_name) return "SUSPENDED" == state def suspend_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): raise Exception('Could not suspend %s because it\'s not running.' % vm_name) else: vm.suspend() return self.is_vm_suspended(vm_name) def clone_vm(self): raise NotImplementedError('clone_vm not implemented.') def deploy_template(self, template, *args, **kwargs): if 'resourcepool' not in kwargs: kwargs['resourcepool'] = None vm = self._get_vm(template) if vm: vm.clone(kwargs['vm_name'], sync_run=True, resourcepool=self._get_resource_pool( kwargs['resourcepool'])) return kwargs['vm_name'] else: raise Exception('Could not clone %s' % template)
# Asking Users password for server if password is None: logger.debug('No command line password received, requesting plain text password from user.') password = getpass.getpass(prompt='Enter password for vCenter %s for user %s: ' % (server,username)) logger.debug(password) # Connecting to server logger.info('Connecting to server %s with username %s' % (server,username)) con = VIServer() try: logger.debug('Trying to connect with provided credentials') con.connect(server,username,password) logger.info('Connected to server %s' % server) logger.debug('Server type: %s' % con.get_server_type()) logger.debug('API version: %s' % con.get_api_version()) except VIException as ins: logger.error(ins) logger.debug('Loggin error. Program will exit now.') sys.exit() try: # Getting VM object vm = find_vm(vmname, con) if vm: logger.info('Successfully found %s in %s' % (vm.get_property('name'), vm.get_property('path'))) else: logger.error("Could not find %s, please verify VM's name and try again." % vm) con.disconnect()
class EsxiController(object): def __init__(self, servername=None, password=None, username='******'): # Initialize viserver self.vi_server = VIServer() # Specify excluding VMs' preffix self.p = re.compile('xx|yy', re.I) self.class_name = self.__class__.__name__ self.servername = servername self.username = username self.password = password self.vmlist = [] self.vmstatusdict = {} self.inUse_vmstatusdict = {} self.vmfullnamelist = {} self.inUse_vmfullnamelist = {} self.vmdict = {} self.inUseDict = {} def connect(self): logging.debug('connecting to %s' % self.servername) try: self.vi_server.connect(self.servername, self.username, self.password, trace_file='/tmp/esxi_debug.txt') except BaseException as e: logging.debug('Can not connect to %s: %s' % (self.servername, e)) # sys.exit(1) else: if self.vi_server.is_connected(): logging.debug('connected to %s successfully' % self.servername) logging.debug('Currently server version is: %s %s' % (self.vi_server.get_server_type(), self.vi_server.get_api_version())) def disconnect(self): self.vi_server.disconnect() logging.debug('To disconnect from server %s\n' % self.servername) def get_vmlist(self): self.vmlist = self.vi_server.get_registered_vms() return self.vmlist def get_vmstatus(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) vminfo = vm.get_properties(from_cache=False) vmstatus = vm.get_status() vmname = vminfo['name'] self.vmstatusdict[vmname] = vmstatus return self.vmstatusdict def get_inuse_vmstatus(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) vminfo = vm.get_properties(from_cache=False) vmstatus = vm.get_status() vmname = vminfo['name'] in_use_vm = self.p.match(vmname) if in_use_vm is not None: self.inUse_vmstatusdict[vmname] = vmstatus return self.inUse_vmstatusdict def get_vmnamelist(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) vminfo = vm.get_properties(from_cache=False) vmname = vminfo['name'] vmfullnameinfo = vminfo['guest_full_name'] self.vmfullnamelist[vmname] = vmfullnameinfo return self.vmfullnamelist def get_inuse_vmnamelist(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) vminfo = vm.get_properties(from_cache=False) vmname = vminfo['name'] vmfullnameinfo = vminfo['guest_full_name'] in_use_vm = self.p.match(vmname) if in_use_vm is not None: self.inUse_vmfullnamelist[vmname] = vmfullnameinfo return self.inUse_vmfullnamelist def get_inuse_vmdict(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) vminfo = vm.get_properties(from_cache=False) vmname = vminfo['name'] vmpath = vminfo['path'] in_use_vm = self.p.match(vmname) if in_use_vm is not None: self.vmdict[vmname] = vmpath return self.vmdict def power_off_all(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) if not vm.is_powered_off(): logging.debug('%s is powered on, now doing power off' % vmPath) vm.power_off() def power_on_all(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) if not vm.is_powered_on(): logging.debug('%s is powered off, now doing power on' % vmPath) vm.power_on() def power_on_in_use(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) vminfo = vm.get_properties(from_cache=False) vmname = vminfo['name'] vmpath = vminfo['path'] in_use_vm = self.p.match(vmname) if in_use_vm is not None and not vm.is_powered_on(): logging.debug('%s is powered off, now doing power on' % vmname) vm.power_on() def power_off_in_use(self): for vmPath in self.get_vmlist(): vm = self.vi_server.get_vm_by_path(vmPath) vminfo = vm.get_properties(from_cache=False) vmname = vminfo['name'] vmpath = vminfo['path'] in_use_vm = self.p.match(vmname) if in_use_vm is not None and not vm.is_powered_off(): logging.debug('%s is powered on, now doing power off' % vmname) vm.power_off()
class VCenterManagement: server_ip = '' user_name = '' password = '' connect_flag = False server = None #vm_list = [] #def __init__(self): #Use the given args to connect the esxi server you want #@ip[string]: ESXi server's IP address #@name[string]: the username used to login the ESXi server #@pwd[string]: the password used to login the ESXi server def connect_server(self, ip, name, pwd): self.server_ip = ip self.user_name = name self.password = pwd self.server = VIServer() self.server.connect(self.server_ip, self.user_name, self.password) self.connect_flag = self.server.is_connected() if self.connect_flag: return True return False #To get all the definition registered vms from the connected server #@param[string]: can be set as ALL, POWER_ON, POWER_OFF, SUSPENDED #According to the param, returns a list of VM Paths. You might also filter by datacenter, #cluster, or resource pool by providing their name or MORs. #if cluster is set, datacenter is ignored, and if resource pool is set #both, datacenter and cluster are ignored. def get_registered_vms(self, param, status=None, datacenter=None, cluster=None, resource_pool=None): if param not in ['ALL', 'POWER_ON', 'POWER_OFF', 'SUSPENDED']: print "Get VMs error: param can only be set as ALL, POWER_ON, POWER_OFF, or SUSPENDED." return None if self.connect_flag == False: print "Get VMs error: Server not connected." return None if param == 'ALL': return self.server.get_registered_vms(datacenter, cluster, resource_pool) elif param == 'POWER_ON': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOn') elif param == 'POWER_OFF': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOff') elif param == 'SUSPENDED': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='suspended') else: return None #Disconnect to the Server def disconnect(self): if self.connect_flag == True: self.server = self.server.disconnect() self.connect_flag == False #To keep session alive def keep_session_alive(self): assert self.server.keep_session_alive() #To get the server type def get_server_type(self): return self.server.get_server_type() #To get performance manager def get_performance_manager(self): return self.server.get_performance_manager() #To get the all the server's hosts def get_all_hosts(self): """ Returns a dictionary of the existing hosts keys are their names and values their ManagedObjectReference object. """ return self.server.get_hosts() #To get all datastores def get_all_datastores(self): """ Returns a dictionary of the existing datastores. Keys are ManagedObjectReference and values datastore names. """ return self.server.get_datastores() #To get all clusters def get_all_clusters(self): """ Returns a dictionary of the existing clusters. Keys are their ManagedObjectReference objects and values their names. """ return self.server.get_clusters() #To get all datacenters def get_all_datacenters(self): """ Returns a dictionary of the existing datacenters. keys are their ManagedObjectReference objects and values their names. """ return self.server.get_datacenters() #To get all resource pools def get_all_resource_pools(self): """ Returns a dictionary of the existing ResourcePools. keys are their ManagedObjectReference objects and values their full path names. """ return self.server.get_resource_pools() #To get hosts by name def get_hosts_by_name(self, from_mor): """ Returns a dictionary of the existing ResourcePools. keys are their ManagedObjectReference objects and values their full path names. @from_mor: if given, retrieves the hosts contained within the specified managed entity. """ try: hosts_dic = self.server.get_hosts(from_mor) except: print "Get hosts error!" return None return hosts_dic def get_vm_by_name(self, vm_name): try: vm = self.server.get_vm_by_name(vm_name) except: print "Get vm error!" return None return vm def power_on_vm(self, vm_name): try: vm = self.get_vm_by_name(vm_name) if (vm.is_powered_off()): vm.power_on() print "vm " + vm_name + " power on success." else: print "vm " + vm_name + "is already power on" return False except: print "Power on vm " + vm_name + "error" return False return True def power_off_vm(self, vm_name): try: vm = self.get_vm_by_name(vm_name) if (vm.is_powered_on()): vm.power_off() print "vm " + vm_name + " power off success." else: print "vm " + vm_name + "is already power off" return False except: print "Power off vm " + vm_name + " error" return False return True
class VMWareSystem(MgmtSystemAPIBase): """Client to Vsphere API This class piggy backs off pysphere. Benefits of pysphere: - Don't need intimate knowledge w/ vsphere api itself. Detriments of pysphere: - Response often are not detailed enough. """ def __init__(self, hostname, username, password, **kwargs): self.api = VIServer() self.api.connect(hostname, username, password) def _get_vm(self, vm_name=None): if vm_name is None: raise Exception('Could not find a VM named %s.' % vm_name) else: try: vm = self.api.get_vm_by_name(vm_name) return vm except VIException as ex: raise Exception(ex) def _get_resource_pool(self, resource_pool_name=None): rps = self.api.get_resource_pools() for mor, path in rps.iteritems(): if re.match('.*%s' % resource_pool_name, path): return mor # Just pick the first return rps.keys()[0] def _find_ip(self, vm): maxwait = 600 net_info = None waitcount = 0 while net_info is None: if waitcount > maxwait: break net_info = vm.get_property('net', False) waitcount += 5 time.sleep(5) if net_info: ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' for ip in net_info[0]['ip_addresses']: if re.match(ipv4_re, ip) and ip != '127.0.0.1': return ip return None def start_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): return True else: vm.power_on() ack = vm.get_status() if ack == 'POWERED ON': return True return False def stop_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): return True else: vm.power_off() ack = vm.get_status() if ack == 'POWERED OFF': return True return False def delete_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): self.stop_vm(vm_name) # When pysphere moves up to 0.1.8, we can just do: # vm.destroy() request = VI.Destroy_TaskRequestMsg() _this = request.new__this(vm._mor) _this.set_attribute_type(vm._mor.get_attribute_type()) request.set_element__this(_this) rtn = self.api._proxy.Destroy_Task(request)._returnval task = VITask(rtn, self.api) status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR]) if status == task.STATE_SUCCESS: return True else: return False def create_vm(self, vm_name): raise NotImplementedError('This function has not yet been implemented.') def restart_vm(self, vm_name): if not self.stop_vm(vm_name): return False else: return self.start_vm(vm_name) def list_vm(self, **kwargs): vm_list = self.api.get_registered_vms(**kwargs) # The vms come back in an unhelpful format, so run them through a regex # Example vm name: '[datastore] vmname/vmname.vmx' def vm_name_generator(): for vm in vm_list: match = re.match(r'\[.*\] (.*)/\1\..*', vm) if match: yield match.group(1) # Unroll the VM name generator, and sort it to be more user-friendly return sorted(list(vm_name_generator())) def info(self): return '%s %s' % (self.api.get_server_type(), self.api.get_api_version()) def disconnect(self): self.api.disconnect() def vm_status(self, vm_name): state = self._get_vm(vm_name).get_status() print "vm " + vm_name + " status is " + state return state def is_vm_running(self, vm_name): state = self.vm_status(vm_name) return "POWERED ON" == state def is_vm_stopped(self, vm_name): state = self.vm_status(vm_name) return "POWERED OFF" == state def is_vm_suspended(self, vm_name): state = self.vm_status(vm_name) return "SUSPENDED" == state def suspend_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): raise Exception('Could not suspend %s because it\'s not running.' % vm_name) else: vm.suspend() return self.is_vm_suspended(vm_name) def clone_vm(self, source_name, vm_name, resourcepool=None): vm = self._get_vm(source_name) if vm: clone = vm.clone(vm_name, sync_run=True, resourcepool=self._get_resource_pool(resourcepool)) return self._find_ip(clone) else: raise Exception('Could not clone %s' % source_name)
import pysphere from pysphere import VIServer host_ip = "200.200.173.45" username = "******" passwd = "admin123." server_obj = VIServer() server_obj.connect(host=host_ip,user=username,password=passwd) # 可以连接esxi主机,也可以连接vcenter # 获取连接的对象类型 print server_obj.get_server_type() # 获取esxi的版本信息 print server_obj.get_api_version() # 获取vcenter下的虚拟机的列表,可以带很多的参数,具体看方法的帮助 vm_list = server_obj.get_registered_vms() # 关闭连接 server_obj.disconnect() # 获取虚拟机的状态信息 # 通过路径获取vm的实例 vm1 = server_obj.get_vm_by_path()
class VMWareSystem(MgmtSystemAPIBase): """Client to Vsphere API This class piggy backs off pysphere. Benefits of pysphere: - Don't need intimate knowledge w/ vsphere api itself. Detriments of pysphere: - Response often are not detailed enough. """ def __init__(self, hostname, username, password, **kwargs): self.api = VIServer() self.api.connect(hostname, username, password) def _get_vm(self, vm_name=None): if vm_name is None: raise Exception('Could not find a VM named %s.' % vm_name) else: try: vm = self.api.get_vm_by_name(vm_name) return vm except VIException as ex: raise Exception(ex) def _get_resource_pool(self, resource_pool_name=None): rps = self.api.get_resource_pools() for mor, path in rps.iteritems(): if re.match('.*%s' % resource_pool_name, path): return mor # Just pick the first return rps.keys()[0] def _find_ip(self, vm): maxwait = 600 net_info = None waitcount = 0 while net_info is None: if waitcount > maxwait: break net_info = vm.get_property('net', False) waitcount += 5 time.sleep(5) if net_info: ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' for ip in net_info[0]['ip_addresses']: if re.match(ipv4_re, ip) and ip != '127.0.0.1': return ip return None def start_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): return True else: vm.power_on() ack = vm.get_status() if ack == 'POWERED ON': return True return False def stop_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): return True else: vm.power_off() ack = vm.get_status() if ack == 'POWERED OFF': return True return False def delete_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): self.stop_vm(vm_name) # When pysphere moves up to 0.1.8, we can just do: # vm.destroy() request = VI.Destroy_TaskRequestMsg() _this = request.new__this(vm._mor) _this.set_attribute_type(vm._mor.get_attribute_type()) request.set_element__this(_this) rtn = self.api._proxy.Destroy_Task(request)._returnval task = VITask(rtn, self.api) status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR]) if status == task.STATE_SUCCESS: return True else: return False def create_vm(self, vm_name): raise NotImplementedError( 'This function has not yet been implemented.') def restart_vm(self, vm_name): if not self.stop_vm(vm_name): return False else: return self.start_vm(vm_name) def list_vm(self, **kwargs): vm_list = self.api.get_registered_vms(**kwargs) # The vms come back in an unhelpful format, so run them through a regex # Example vm name: '[datastore] vmname/vmname.vmx' def vm_name_generator(): for vm in vm_list: match = re.match(r'\[.*\] (.*)/\1\..*', vm) if match: yield match.group(1) # Unroll the VM name generator, and sort it to be more user-friendly return sorted(list(vm_name_generator())) def info(self): return '%s %s' % (self.api.get_server_type(), self.api.get_api_version()) def disconnect(self): self.api.disconnect() def vm_status(self, vm_name): state = self._get_vm(vm_name).get_status() print "vm " + vm_name + " status is " + state return state def is_vm_running(self, vm_name): state = self.vm_status(vm_name) return "POWERED ON" == state def is_vm_stopped(self, vm_name): state = self.vm_status(vm_name) return "POWERED OFF" == state def is_vm_suspended(self, vm_name): state = self.vm_status(vm_name) return "SUSPENDED" == state def suspend_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): raise Exception('Could not suspend %s because it\'s not running.' % vm_name) else: vm.suspend() return self.is_vm_suspended(vm_name) def clone_vm(self, source_name, vm_name, resourcepool=None): vm = self._get_vm(source_name) if vm: clone = vm.clone( vm_name, sync_run=True, resourcepool=self._get_resource_pool(resourcepool)) return self._find_ip(clone) else: raise Exception('Could not clone %s' % source_name)
# Asking Users password for server if password is None: logger.debug("No command line password received, requesting plain text password from user.") password = getpass.getpass(prompt="Enter password for vCenter %s for user %s: " % (server, username)) logger.debug(password) # Connecting to server logger.info("Connecting to server %s with username %s" % (server, username)) con = VIServer() try: logger.debug("Trying to connect with provided credentials") con.connect(server, username, password) logger.info("Connected to server %s" % server) logger.debug("Server type: %s" % con.get_server_type()) logger.debug("API version: %s" % con.get_api_version()) except VIException as ins: logger.error(ins) logger.debug("Loggin error. Program will exit now.") sys.exit() try: # Getting VM object vm = find_vm(vmname, con) if vm: logger.info("Successfully found %s in %s" % (vm.get_property("name"), vm.get_property("path"))) else: logger.error("Could not find %s, please verify VM's name and try again." % vm) con.disconnect()
'verbose': False # optional, defaults to False } vmindex = {} server = VIServer() default_context = ssl._create_default_https_context try: ssl._create_default_https_context = ssl._create_unverified_context server.connect(esxurl, esxiserver['username'], esxiserver['password']) finally: ##DO NOT DO the following line or else you'll get "ssl.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed" error ##ssl._create_default_https_context = default_context print "vserver: AFTER CONNECTION - [{}] [{}]".format(server.get_server_type(), server.get_api_version()) def initargs(): """ initialize variables with command-line arguments """ parser = argparse.ArgumentParser(description='input -f [file]') parser.add_argument('-s', '--shutdown', \ help='Shutdown ESX host', \ action='store_true') parser.add_argument('-o', '--on', \ help='Start Machines') arg = parser.parse_args() return arg def poweronvm(vmpath):
class ESXi_Server: server_ip = '' user_name = '' password = '' connect_flag = False server = None #vm_list = [] #def __init__(self): #Use the given args to connect the esxi server you want #@ip[string]: ESXi server's IP address #@name[string]: the username used to login the ESXi server #@pwd[string]: the password used to login the ESXi server def connect_server(self, ip, name, pwd): self.server_ip = ip self.user_name = name self.password = pwd self.server = VIServer() self.server.connect(self.server_ip, self.user_name, self.password) self.connect_flag = self.server.is_connected() if self.connect_flag: return True return False #To get all the definition registered vms from the connected server #@param[string]: can be set as ALL, POWER_ON, POWER_OFF, SUSPENDED #According to the param, returns a list of VM Paths. You might also filter by datacenter, #cluster, or resource pool by providing their name or MORs. #if cluster is set, datacenter is ignored, and if resource pool is set #both, datacenter and cluster are ignored. def get_registered_vms(self, param, status=None, datacenter=None, cluster=None, resource_pool=None): if param not in ['ALL', 'POWER_ON', 'POWER_OFF', 'SUSPENDED']: print "Get VMs error: param can only be set as ALL, POWER_ON, POWER_OFF, or SUSPENDED." return None if self.connect_flag == False: print "Get VMs error: Server not connected." return None if param == 'ALL': return self.server.get_registered_vms(datacenter, cluster, resource_pool) elif param == 'POWER_ON': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOn') elif param == 'POWER_OFF': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOff') elif param == 'SUSPENDED': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='suspended') else: return None #Disconnect to the Server def disconnect(self): if self.connect_flag == True: self.server = self.server.disconnect() self.connect_flag == False #To keep session alive def keep_session_alive(self): assert self.server.keep_session_alive() #To get the server type def get_server_type(self): return self.server.get_server_type() #To get performance manager def get_performance_manager(self): return self.server.get_performance_manager() #To get the all the server's hosts def get_all_hosts(self): """ Returns a dictionary of the existing hosts keys are their names and values their ManagedObjectReference object. """ return self.server.get_hosts() #To get all datastores def get_all_datastores(self): """ Returns a dictionary of the existing datastores. Keys are ManagedObjectReference and values datastore names. """ return self.server.get_datastores() #To get all clusters def get_all_clusters(self): """ Returns a dictionary of the existing clusters. Keys are their ManagedObjectReference objects and values their names. """ return self.server.get_clusters() #To get all datacenters def get_all_datacenters(self): """ Returns a dictionary of the existing datacenters. keys are their ManagedObjectReference objects and values their names. """ return self.server.get_datacenters() #To get all resource pools def get_all_resource_pools(self): """ Returns a dictionary of the existing ResourcePools. keys are their ManagedObjectReference objects and values their full path names. """ return self.server.get_resource_pools() #To get hosts by name def get_hosts_by_name(self, from_mor): """ Returns a dictionary of the existing ResourcePools. keys are their ManagedObjectReference objects and values their full path names. @from_mor: if given, retrieves the hosts contained within the specified managed entity. """ try: hosts_dic = self.server.get_hosts(from_mor) except: print "Get hosts error!" return None return hosts_dic
""" Install: pip install pysphere """ from pysphere import VIServer server = VIServer() server.connect("serverip", "adminuser", "pass") #Get server characteristics print server.get_server_type() print server.get_api_version() print server.get_clusters() print server._get_resource_pools #Get all the hosts print server.get_hosts() #Get VM`s in Prod resource pool which are in poweredon state vmachines = server.get_registered_vms() vmachines = server.get_registered_vms(resource_pool='Prod', status='poweredOn')
logger.debug( 'No command line password received, requesting password from user') password = getpass.getpass( prompt='Enter password for vCenter %s for user %s: ' % (servervctr, username)) # Connecting to server logger.info('Connecting to server %s with username %s' % (servervctr, username)) server = VIServer() try: logger.debug('Trying to connect with provided credentials') server.connect(servervctr, username, password) logger.info('Connected to server %s' % servervctr) logger.debug('Server type: %s' % server.get_server_type()) logger.debug('API version: %s' % server.get_api_version()) except VIException as ins: logger.error(ins) logger.debug('Loggin error. Program will exit now.') sys.exit() if dcname is None: logger.error('No datacenter name. Progam will exit now.') sys.exit() # Setting up properties logger.debug('Getting properties to query') properties = create_vm_props() logger.debug('First set of properties: %s' % properties)
class VMWareSystem(MgmtSystemAPIBase): """Client to Vsphere API This class piggy backs off pysphere. Benefits of pysphere: - Don't need intimate knowledge w/ vsphere api itself. Detriments of pysphere: - Response often are not detailed enough. Args: hostname: The hostname of the system. username: The username to connect with. password: The password to connect with. Returns: A :py:class:`VMWareSystem` object. """ _api = None _stats_available = { 'num_vm': lambda self: len(self.list_vm()), 'num_host': lambda self: len(self.list_host()), 'num_cluster': lambda self: len(self.list_cluster()), 'num_template': lambda self: len(self.list_template()), 'num_datastore': lambda self: len(self.list_datastore()), } def __init__(self, hostname, username, password, **kwargs): self.hostname = hostname self.username = username self.password = password self.api = VIServer() @property def api(self): # wrap calls to the API with a keepalive check, reconnect if needed try: keepalive = self._api.keep_session_alive() if not keepalive: logger.debug('The connection to %s "%s" timed out' % (type(self).__name__, self.hostname)) except VIException as ex: if ex.fault == "Not Connected": # set this to trigger a connection below keepalive = None else: raise if not keepalive: self._connect() return self._api @api.setter def api(self, api): # Allow for changing the api object via public setter self._api = api def _connect(self): # Since self.api calls _connect, connect via self._api to prevent implosion logger.debug('Connecting to %s "%s"' % (type(self).__name__, self.hostname)) self._api.connect(self.hostname, self.username, self.password) def _get_vm(self, vm_name=None): """ Returns a vm from the VI object. Args: vm_name: The name of the VM. Returns: a pysphere object. """ if vm_name is None: raise Exception('Could not find a VM named %s.' % vm_name) else: try: vm = self.api.get_vm_by_name(vm_name) return vm except VIException as ex: raise Exception(ex) def does_vm_exist(self, name): """ Checks if a vm exists or not. Args: name: The name of the requested vm. Returns: A boolean, ``True`` if the vm exists, ``False`` if not. """ try: self._get_vm(name) return True except Exception: return False def _get_resource_pool(self, resource_pool_name=None): """ Returns a resource pool MOR for a specified name. Args: resource_pool_name: The name of the resource pool. Returns: The MOR of the resource pool. """ rps = self.api.get_resource_pools() for mor, path in rps.iteritems(): if re.match('.*%s' % resource_pool_name, path): return mor # Just pick the first return rps.keys()[0] def get_ip_address(self, vm_name): """ Returns the first IP address for the selected VM. Args: vm_name: The name of the vm to obtain the IP for. Returns: A string containing the first found IP that isn't the loopback device. """ vm = self._get_vm(vm_name) try: net_info, tc = wait_for(vm.get_property, ['net', False], fail_condition=None, delay=5, num_sec=600, message="get_ip_address from vsphere") except TimedOutError: net_info = None if net_info: ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' for ip in net_info[0]['ip_addresses']: if re.match(ipv4_re, ip) and ip != '127.0.0.1': return ip return None def _get_list_vms(self, get_template=False): """ Obtains a list of all VMs on the system. Optional flag to obtain template names too. Args: get_template: A boolean describing if it should return template names also. Returns: A list of VMs. """ template_or_vm_list = [] props = self.api._retrieve_properties_traversal(property_names=['name', 'config.template'], from_node=None, obj_type=MORTypes.VirtualMachine) for prop in props: vm = None template = None for elem in prop.PropSet: if elem.Name == "name": vm = elem.Val elif elem.Name == "config.template": template = elem.Val if vm is None or template is None: continue if template == bool(get_template): template_or_vm_list.append(vm) return template_or_vm_list def start_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): return True else: vm.power_on() ack = vm.get_status() if ack == 'POWERED ON': return True return False def stop_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): return True else: vm.power_off() ack = vm.get_status() if ack == 'POWERED OFF': return True return False def delete_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): self.stop_vm(vm_name) # When pysphere moves up to 0.1.8, we can just do: # vm.destroy() request = VI.Destroy_TaskRequestMsg() _this = request.new__this(vm._mor) _this.set_attribute_type(vm._mor.get_attribute_type()) request.set_element__this(_this) rtn = self.api._proxy.Destroy_Task(request)._returnval task = VITask(rtn, self.api) status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR]) if status == task.STATE_SUCCESS: return True else: return False def create_vm(self, vm_name): raise NotImplementedError('This function has not yet been implemented.') def restart_vm(self, vm_name): if not self.stop_vm(vm_name): return False else: return self.start_vm(vm_name) def list_vm(self): return self._get_list_vms() def list_template(self): return self._get_list_vms(get_template=True) def list_flavor(self): raise NotImplementedError('This function is not supported on this platform.') def list_host(self): return self.api.get_hosts() def list_datastore(self): return self.api.get_datastores() def list_cluster(self): return self.api.get_clusters() def info(self): return '%s %s' % (self.api.get_server_type(), self.api.get_api_version()) def disconnect(self): self.api.disconnect() def vm_status(self, vm_name): state = self._get_vm(vm_name).get_status() print "vm " + vm_name + " status is " + state return state def is_vm_running(self, vm_name): state = self.vm_status(vm_name) return "POWERED ON" == state def is_vm_stopped(self, vm_name): state = self.vm_status(vm_name) return "POWERED OFF" == state def is_vm_suspended(self, vm_name): state = self.vm_status(vm_name) return "SUSPENDED" == state def suspend_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): raise Exception('Could not suspend %s because it\'s not running.' % vm_name) else: vm.suspend() return self.is_vm_suspended(vm_name) def clone_vm(self): raise NotImplementedError('clone_vm not implemented.') def deploy_template(self, template, *args, **kwargs): if 'resourcepool' not in kwargs: kwargs['resourcepool'] = None vm = self._get_vm(template) if vm: vm.clone(kwargs['vm_name'], sync_run=True, resourcepool=self._get_resource_pool(kwargs['resourcepool'])) return kwargs['vm_name'] else: raise Exception('Could not clone %s' % template) def remove_host_from_cluster(self, hostname): req = VI.DisconnectHost_TaskRequestMsg() mor = (key for key, value in self.api.get_hosts().items() if value == hostname).next() sys = VIMor(mor, 'HostSystem') _this = req.new__this(sys) _this.set_attribute_type(sys.get_attribute_type()) req.set_element__this(_this) task_mor = self.api._proxy.DisconnectHost_Task(req)._returnval t = VITask(task_mor, self.api) wait_for(lambda: 'success' in t.get_state()) self._destroy_host(hostname) def _destroy_host(self, hostname): req = VI.Destroy_TaskRequestMsg() mor = (key for key, value in self.api.get_hosts().items() if value == hostname).next() sys = VIMor(mor, 'HostSystem') _this = req.new__this(sys) _this.set_attribute_type(sys.get_attribute_type()) req.set_element__this(_this) task_mor = self.api._proxy.Destroy_Task(req)._returnval t = VITask(task_mor, self.api) wait_for(lambda: 'success' in t.get_state())
#!/usr/bin/python import os from pysphere import VIServer server = VIServer() server.connect("172.16.1.215", "root", "password", trace_file="debug.txt") print "Server Type : "+server.get_server_type() print "Server API version : "+server.get_api_version() vmlist = server.get_registered_vms() print "List of registered VM's :", vmlist vm1 = server.get_vm_by_path(vmlist[0]) print "Current status", vm1.get_status(basic_status=True) print "Is the VM powering ON? :", vm1.is_powering_on() print "Is the VM powering OFF? :", vm1.is_powering_off() properties = vm1.get_properties() #print properties print "Guest ID of the VM :", vm1.get_property('guest_id') if vm1.get_status(basic_status=True) !="POWERED ON": print "Powering on the VM :", vm1.power_on() else: print "VM is already POWERED ON" print "Current status", vm1.get_status(basic_status=True) server.disconnect()
result.fetch_row()[0] db = MySQLdb.connect(host="localhost", user="******", passwd="", db="servers") cur = db.cursor() property_names = ['name', 'guest.toolsVersion', 'config.files.vmPathName'] serverVMToolVersion = {} count = 0 clusters = {'10.127.209.21': 1, '10.95.209.21': 2, '10.64.211.139': 3} for ip in clusters: print ip server = VIServer() server.connect(ip, "nys\dnovicoff", "pitIfu12345") serverType = server.get_server_type() print serverType serverAPI = server.get_api_version() print serverAPI vmlist = server.get_registered_vms() properties = server._retrieve_properties_traversal( property_names=property_names, obj_type="VirtualMachine") for propset in properties: vmToolsVersion = "" vmPropPath = "" host = "" for prop in propset.PropSet: if prop.Name == "name":
class ESXi_Server: server_ip = '' user_name = '' password = '' connect_flag = False server = None # vm_list = [] # Use the given args to connect the esxi server you want # @ip[string]: ESXi server's IP address # @name[string]: the username used to login the ESXi server # @pwd[string]: the password used to login the ESXi server def connect_server(self, ip, name, pwd): self.server_ip = ip self.user_name = name self.password = pwd self.server = VIServer() self.server.connect(self.server_ip, self.user_name, self.password) self.connect_flag = self.server.is_connected() if self.connect_flag: return True return False # To get all the definition registered vms from the connected server # @param[string]: can be set as ALL, POWER_ON, POWER_OFF, SUSPENDED # According to the param, returns a list of VM Paths. You might also filter by datacenter, # cluster, or resource pool by providing their name or MORs. # if cluster is set, datacenter is ignored, and if resource pool is set # both, datacenter and cluster are ignored. def get_registered_vms(self, param, status=None, datacenter=None, cluster=None, resource_pool=None): if param not in ['ALL', 'POWERED ON', 'POWERED OFF', 'SUSPENDED']: LOG.debug( "Get VMs error: param can only be set as ALL, POWERED ON,\ POWERED OFF, or SUSPENDED.") return None if not self.connect_flag: LOG.info("Get VMs error: Server not connected.") return None if param == 'ALL': return self.server.get_registered_vms(datacenter, cluster, resource_pool) elif param == 'POWERED ON': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOn') elif param == 'POWERED OFF': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOff') elif param == 'SUSPENDED': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='suspended') else: return None # Disconnect to the Server def disconnect(self): if self.connect_flag: self.server = self.server.disconnect() self.connect_flag = False # To keep session alive def keep_session_alive(self): return self.server.keep_session_alive() # To get the server type def get_server_type(self): return self.server.get_server_type() # To get performance manager def get_performance_manager(self): return self.server.get_performance_manager() # To get the all the server's hosts def get_all_hosts(self): """ Returns a dictionary of the existing hosts keys are their names and values their ManagedObjectReference object. """ return self.server.get_hosts() # To get all datastores def get_all_datastores(self): """ Returns a dictionary of the existing datastores. Keys are ManagedObjectReference and values datastore names. """ return self.server.get_datastores() # To get all clusters def get_all_clusters(self): """ Returns a dictionary of the existing clusters. Keys are their ManagedObjectReference objects and values their names. """ return self.server.get_clusters() # To get all datacenters def get_all_datacenters(self): """ Returns a dictionary of the existing datacenters. keys are their ManagedObjectReference objects and values their names. """ return self.server.get_datacenters() # To get all resource pools def get_all_resource_pools(self): """ Returns a dictionary of the existing ResourcePools. keys are their ManagedObjectReference objects and values their full path names. """ return self.server.get_resource_pools() # To get hosts by name def get_hosts_by_name(self, from_mor): """ Returns a dictionary of the existing ResourcePools. keys are their ManagedObjectReference objects and values their full path names. @from_mor: if given, retrieves the hosts contained within the specified managed entity. """ try: hosts_dic = self.server.get_hosts(from_mor) except: LOG.error("Get hosts error!") return None return hosts_dic def run_vm_by_name(self, name): """ Run vm by name. """ try: vm = self.server.get_vm_by_name(name) status = vm.get_status() if status == 'POWERED ON': pass elif status == 'POWERED OFF': try: vm.power_on() except: LOG.error("Run vm error!") pass else: pass except: LOG.error("Get vm status error when runing vm!") pass def stop_vm_by_name(self, name): """ Run vm by name. """ try: vm = self.server.get_vm_by_name(name) status = vm.get_status() if status == 'POWERED OFF': pass elif status == 'POWERED ON': try: vm.power_off() except: LOG.error("Stop vm error!") pass else: pass except: LOG.error("Get vm status error when stopping vm!") pass def get_vm_status_by_name(self, name): """ Get vm status by nam """ try: vm = self.server.get_vm_by_name(name) status = vm.get_status() LOG.info("Get VM status is %s" % status) return status except: LOG.info("Get VM status error!") return None
class EsxiServer: server_ip = '' user_name = '' password = '' connect_flag = False server = None def opearte_guest_power(self, src_vm_name, operate): """" |##desc: 操作客户机电源(重启、关机、开机),这种模式不需要vmtools,就是强制操作电源,不走操作系统 ,可能损坏数据 |##:param: >vm1.power_on() >vm1.reset() >vm1.suspend() #since pysphere 0.1.5 >vm1.power_off() |##:return: None |##@author: jhuang |##@time:12/12/2017 """ ovm = self.server.get_vm_by_name(src_vm_name) if operate == 'power_on': ovm.power_on() return True elif operate == 'reset': ovm.reset() return True elif operate == 'suspend': ovm.suspend() return True elif operate == 'power_off': ovm.power_off() return True else: print "Operate guest error: operate can noly be set as power_on, reset, suspend, power_off" return False def clone(self, src_vm_name, dest_vm_name, datacenter=None, sync_run=True, folder=None, resourcepool=None, datastore=None, host=None, power_on=True, template=False, snapshot=None, linked=False): """ |##desc: 克隆虚拟机 |##:param: None |##:return: None |##@author: jhuang |##@time:12/12/2017 """ # get_vm_by_name 在包含2个数据中心的情况下,需要指定参数 datacenter 其中的限定条件为datacenter # vm1 = server.get_vm_by_path("[DataStore1] Ubantu/Ubantu-10.vmx") 通过路径方法获取对象 logger.debug(src_vm_name) logger.debug(datacenter) ovm = self.server.get_vm_by_name(src_vm_name, datacenter) new_vm = ovm.clone(dest_vm_name) def create_snapshot(self, src_vm_name, snapShotName): """ |##desc: 创建快照 |##:param: None |##:return: None |##@author: jhuang |##@time:12/12/2017 """ ovm = self.server.get_vm_by_name(src_vm_name) ovm.create_snapshot(snapShotName) def set_ssl_no_verify(self): ssl._create_default_https_context = ssl._create_unverified_context # Use the given args to connect the esxi server you want # @ip[string]: ESXi server's IP address # @name[string]: the username used to login the ESXi server # @pwd[string]: the password used to login the ESXi server def connect_server(self, ip, name, pwd, ssl_no_verify=True): logger.debug(ip) logger.debug(name) logger.debug(pwd) self.server_ip = ip self.user_name = name self.password = pwd self.server = VIServer() if ssl_no_verify: self.set_ssl_no_verify() self.server.connect(self.server_ip, self.user_name, self.password) self.connect_flag = self.server.is_connected() if self.connect_flag: return True return False # To get all the definition registered vms from the connected server # @param[string]: can be set as ALL, POWER_ON, POWER_OFF, SUSPENDED # According to the param, returns a list of VM Paths. You might also filter by datacenter, # cluster, or resource pool by providing their name or MORs. # if cluster is set, datacenter is ignored, and if resource pool is set # both, datacenter and cluster are ignored. def get_registered_vms(self, param='ALL', status=None, datacenter=None, cluster=None, resource_pool=None): """ 获取注册的主机 (虚拟机) :param param1: this is a first param :param param2: this is a second param :returns: this is a description of what is returned :raises keyError: raises an exception @author: jhuang @time:28/02/2018 """ if param not in ['ALL', 'POWER_ON', 'POWER_OFF', 'SUSPENDED']: print "Get VMs error: param can only be set as ALL, POWER_ON, POWER_OFF, or SUSPENDED." return None if self.connect_flag == False: print "Get VMs error: Server not connected." return None if param == 'ALL': return self.server.get_registered_vms(datacenter, cluster, resource_pool) elif param == 'POWER_ON': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOn') elif param == 'POWER_OFF': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOff') elif param == 'SUSPENDED': return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='suspended') else: return None # Disconnect to the Server def disconnect(self): if self.connect_flag is True: self.server = self.server.disconnect() self.connect_flag == False # To keep session alive def keep_session_alive(self): assert self.server.keep_session_alive() # To get the server type def get_server_type(self): return self.server.get_server_type() # To get performance manager def get_performance_manager(self): return self.server.get_performance_manager() # To get the all the server's hosts def get_all_hosts(self): """ 获取所有主机(这个是宿主机) Returns a dictionary of the existing hosts keys are their names and values their ManagedObjectReference object. """ return self.server.get_hosts() # To get all datastores def get_all_datastores(self): """ 获取存储列表 Returns a dictionary of the existing datastores. Keys are ManagedObjectReference and values datastore names. """ return self.server.get_datastores() # To get all clusters def get_all_clusters(self): """ 获取所有集群列表 Returns a dictionary of the existing clusters. Keys are their ManagedObjectReference objects and values their names. """ return self.server.get_clusters() # To get all datacenters def get_all_datacenters(self): """ 获取数据中心列表 Returns a dictionary of the existing datacenters. keys are their ManagedObjectReference objects and values their names. """ return self.server.get_datacenters() # To get all resource pools def get_all_resource_pools(self): """ Returns a dictionary of the existing ResourcePools. keys are their ManagedObjectReference objects and values their full path names. """ return self.server.get_resource_pools() # To get hosts by name def get_hosts_by_name(self, from_mor): """ Returns a dictionary of the existing ResourcePools. keys are their ManagedObjectReference objects and values their full path names. @from_mor: if given, retrieves the hosts contained within the specified managed entity. """ try: hosts_dic = self.server.get_hosts(from_mor) except: print "Get hosts error!" return None return hosts_dic
def main(options): global host_vms LOGGER.debug("Options: {0}".format(options)) LOGGER.debug("Args: {0}".format(args)) #check for senseful inputs if not options.vcServer or not options.satServer: LOGGER.error("You need to specify at least Satellite and vCenter hostnames!") exit(1) #get Satellite and vCenter credentials if options.dryrun: LOGGER.info("I'm only doing a simulation, I promise!") (satUsername, satPassword) = get_credentials("Satellite", options.satAuthfile) (vcUsername, vcPassword) = get_credentials("Virtualization", options.vcAuthfile) #connect to vCenter myVC = VIServer() myVC.connect(options.vcServer, vcUsername, vcPassword) #connect to Satellite satellite_url = "http://{0}/rpc/api".format(options.satServer) mySat = xmlrpclib.Server(satellite_url, verbose=options.debug) key = mySat.auth.login(satUsername, satPassword) check_if_api_is_supported(mySat) #print information about host LOGGER.info("Connected to " + options.vcServer + " (" + myVC.get_server_type() + "), version " + myVC.get_api_version() + ".") #get list of all ESXi hosts by datacenter LOGGER.info("Searching for ESXi hosts by datacenter...") esxiHosts = myVC.get_hosts() datacenters = myVC.get_datacenters() for dc in datacenters: tempHosts = myVC.get_hosts(from_mor=dc).values() hosts_by_dc[datacenters.get(dc)] = (tempHosts) LOGGER.debug("Hosts by DC: " + str(hosts_by_dc)) #get list of all ESXi hosts by cluster LOGGER.info("Searching for ESXi hosts by cluster...") clusters = myVC.get_clusters() for cluster in clusters: tempHosts = myVC.get_hosts(from_mor=cluster).values() hosts_by_cluster[clusters.get(cluster)] = (tempHosts) LOGGER.debug("Hosts by cluster: " + str(hosts_by_cluster)) #get list of all VMs by ESXi host for dc in datacenters: for host in hosts_by_dc[datacenters.get(dc)]: LOGGER.debug("Found ESXi host '" + host + "'") host_vms[host]=[] LOGGER.debug("Added hosts to dict: " + str(host_vms)) #get list of all Linux VMs managed by Satellite satlist = mySat.system.listSystems(key) target_vms=[] LOGGER.info("Digging through list of systems managed by Satellite...") for system in satlist: LOGGER.debug("Found system '" + system["name"] + "'") #get custom keys thisKeys = mySat.system.getCustomValues(key, system["id"]) #add virt_vmname if given if "SYSTEM_VIRT_VMNAME" in thisKeys and thisKeys["SYSTEM_VIRT_VMNAME"] != "": target_vms.append(thisKeys["SYSTEM_VIRT_VMNAME"]) else: target_vms.append(system) LOGGER.debug("VM names: " + str(target_vms)) #get list of all VMs and assign to host dicts LOGGER.info("Getting list of all VMs and assign them to host arrays - grab some coffee.") vmlist = myVC.get_registered_vms() counter=0 hit=0 for vm in vmlist: #get VM and its properties thisVM = myVC.get_vm_by_path(vm) #only add if in target_vms if thisVM.properties.name in target_vms: LOGGER.debug("Found VM managed by Satellite: '" + thisVM.properties.name + "'") host_vms[thisVM.properties.runtime.host.name].append(thisVM.properties.name) else: LOGGER.debug("'" + thisVM.properties.name + "' dropped as it is not managed by Satellite") LOGGER.debug("Current array for host '" + thisVM.properties.runtime.host.name + "': " + str(host_vms[thisVM.properties.runtime.host.name])) #show progress if hit == 9: LOGGER.info("Checked " + str(counter+1) + " of " + str(len(vmlist)) + " VMs so far...") hit=0 else: hit=(hit+1) counter=(counter+1) LOGGER.debug("Added VMs to host dicts: " + str(host_vms)) #get list of all Linux VMs managed by Satellite satlist = mySat.system.listSystems(key) LOGGER.info("Updating relevant system custom info keys...") for system in satlist: LOGGER.debug("Found system '" + system["name"] + "'") #get custom keys thisKeys = mySat.system.getCustomValues(key, system["id"]) #update key if exists if "SYSTEM_VIRT_HOST" in thisKeys and thisKeys["SYSTEM_VIRT_HOST"] != "": #get ESXi host running VM if "SYSTEM_VIRT_VMNAME" in thisKeys and thisKeys["SYSTEM_VIRT_VMNAME"] != "": this_ESXi = get_ESXi_host_by_vm(thisKeys["SYSTEM_VIRT_VMNAME"]) else: this_ESXi = get_ESXi_host_by_vm(system["name"]) #get cluster if applicable this_cluster = get_cluster_by_ESXi_host(this_ESXi) #update custom key if this_cluster != "": #cluster this_value = "vpx://" + options.vcServer + "/" + get_datacenter_by_ESXi_host(this_ESXi) + "/" + this_cluster + "/" + this_ESXi else: #no cluster this_value = "vpx://" + options.vcServer + "/" + get_datacenter_by_ESXi_host(this_ESXi) + "/" + this_ESXi if options.vcVerify == False: this_value = this_value + "?no_verify=1" if options.dryrun: if this_ESXi != "": LOGGER.info("I'd like to set SYSTEM_VIRT_HOST='" + this_value + "' for system '" + system["name"] + "' (ID " + str(system["id"]) + ")") else: LOGGER.error("No valid virt host entry for system '" + system["name"] + "' (ID " + str(system["id"]) + ") found!") else: #update customkey if not null if this_ESXi != "": if mySat.system.setCustomValues(key, system["id"], {"SYSTEM_VIRT_HOST": this_value}): LOGGER.info("Updated virtual host entry for system '" + system["name"] + "' (ID " + str(system["id"]) + ").") else: LOGGER.error("No valid virt host entry for system '" + system["name"] + "' (ID " + str(system["id"]) + ") found!")
resource_pool = args.resource_pool[0] server = args.server[0] template = args.template[0] username = args.username[0] verbose = args.verbose maxwait = args.maxwait[0] # Asking Users password for server password = getpass.getpass(prompt="Enter password for vCenter %s for user %s: " % (server, username)) # Connecting to server print_verbose("Connecting to server %s with username %s" % (server, username)) con = VIServer() con.connect(server, username, password) print_verbose("Connected to server %s" % server) print_verbose("Server type: %s" % con.get_server_type()) print_verbose("API version: %s" % con.get_api_version()) # Verify the template exists print_verbose("Finding template %s" % template) template_vm = find_vm(template) if template_vm is None: print "ERROR: %s not found" % template sys.exit(1) print_verbose("Template %s found" % template) # Verify the target Resource Pool exists resource_pool_mor = None if resource_pool is not None: print_verbose("Finding resource pool %s" % resource_pool) resource_pool_mor = find_resource_pool(resource_pool)
else: return "", addrs[0] else: print "ERROR --> 2 arguments required, vserver and hostname!" if options.hostname: hostname = options.hostname if verbose: print "--> Hostname: " + hostname else: print "" print " [Datastore] Hostname " print "=====================================" if vserver.get_server_type(): vmlist = vserver.get_registered_vms() for v in vmlist: w = v.split("/") print w[0] else: print "vserver EMPTY - Connection Failed" exit(1) print "=====================================" print "SELECT --> An existing host from above or enter a new hostname to clone..." if py3: hostname = input("--> Enter your hostname: ") else: hostname = raw_input("--> Enter your hostname: ")
class VMWareSystem(MgmtSystemAPIBase): """Client to Vsphere API This class piggy backs off pysphere. Benefits of pysphere: - Don't need intimate knowledge w/ vsphere api itself. Detriments of pysphere: - Response often are not detailed enough. """ _stats_available = { 'num_vm': lambda self: len(self.list_vm()), 'num_host': lambda self: len(self.list_host()), 'num_cluster': lambda self: len(self.list_cluster()), 'num_template': lambda self: len(self.list_template()), 'num_datastore': lambda self: len(self.list_datastore()), } def __init__(self, hostname, username, password, **kwargs): self.api = VIServer() self.api.connect(hostname, username, password) def _get_vm(self, vm_name=None): if vm_name is None: raise Exception('Could not find a VM named %s.' % vm_name) else: try: vm = self.api.get_vm_by_name(vm_name) return vm except VIException as ex: raise Exception(ex) def does_vm_exist(self, name): try: self._get_vm(name) return True except Exception: return False def _get_resource_pool(self, resource_pool_name=None): rps = self.api.get_resource_pools() for mor, path in rps.iteritems(): if re.match('.*%s' % resource_pool_name, path): return mor # Just pick the first return rps.keys()[0] def get_ip_address(self, vm_name): vm = self._get_vm(vm_name) maxwait = 600 net_info = None waitcount = 0 while net_info is None: if waitcount > maxwait: break net_info = vm.get_property('net', False) waitcount += 5 time.sleep(5) if net_info: ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' for ip in net_info[0]['ip_addresses']: if re.match(ipv4_re, ip) and ip != '127.0.0.1': return ip return None def _get_list_vms(self, get_template=False): template_or_vm_list = [] props = self.api._retrieve_properties_traversal(property_names=['name', 'config.template'], from_node=None, obj_type=MORTypes.VirtualMachine) for prop in props: vm = None template = None for elem in prop.PropSet: if elem.Name == "name": vm = elem.Val elif elem.Name == "config.template": template = elem.Val if vm is None or template is None: continue if template == bool(get_template): template_or_vm_list.append(vm) return template_or_vm_list def start_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): return True else: vm.power_on() ack = vm.get_status() if ack == 'POWERED ON': return True return False def stop_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): return True else: vm.power_off() ack = vm.get_status() if ack == 'POWERED OFF': return True return False def delete_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_on(): self.stop_vm(vm_name) # When pysphere moves up to 0.1.8, we can just do: # vm.destroy() request = VI.Destroy_TaskRequestMsg() _this = request.new__this(vm._mor) _this.set_attribute_type(vm._mor.get_attribute_type()) request.set_element__this(_this) rtn = self.api._proxy.Destroy_Task(request)._returnval task = VITask(rtn, self.api) status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR]) if status == task.STATE_SUCCESS: return True else: return False def create_vm(self, vm_name): raise NotImplementedError('This function has not yet been implemented.') def restart_vm(self, vm_name): if not self.stop_vm(vm_name): return False else: return self.start_vm(vm_name) def list_vm(self): return self._get_list_vms() def list_template(self): return self._get_list_vms(get_template=True) def list_flavor(self): raise NotImplementedError('This function is not supported on this platform.') def list_host(self): return self.api.get_hosts() def list_datastore(self): return self.api.get_datastores() def list_cluster(self): return self.api.get_clusters() def info(self): return '%s %s' % (self.api.get_server_type(), self.api.get_api_version()) def disconnect(self): self.api.disconnect() def vm_status(self, vm_name): state = self._get_vm(vm_name).get_status() print "vm " + vm_name + " status is " + state return state def is_vm_running(self, vm_name): state = self.vm_status(vm_name) return "POWERED ON" == state def is_vm_stopped(self, vm_name): state = self.vm_status(vm_name) return "POWERED OFF" == state def is_vm_suspended(self, vm_name): state = self.vm_status(vm_name) return "SUSPENDED" == state def suspend_vm(self, vm_name): vm = self._get_vm(vm_name) if vm.is_powered_off(): raise Exception('Could not suspend %s because it\'s not running.' % vm_name) else: vm.suspend() return self.is_vm_suspended(vm_name) def clone_vm(self): raise NotImplementedError('clone_vm not implemented.') def deploy_template(self, template, *args, **kwargs): if 'resourcepool' not in kwargs: kwargs['resourcepool'] = None vm = self._get_vm(template) if vm: vm.clone(kwargs['vm_name'], sync_run=True, resourcepool=self._get_resource_pool(kwargs['resourcepool'])) return kwargs['vm_name'] else: raise Exception('Could not clone %s' % template)
for s in envs: try: print(" Env: %s, vSphere Server: %s" %(s.upper(), urls[s]['suffix'])) except Exception, e: continue try: server = VIServer() server.connect(r"%s" %urls[s]['suffix'], urls[s]['user'], urls[s]['pswrd']) except Exception, e: print(Fore.RED + Style.BRIGHT + " %s" %str(e)) print try: print(Fore.GREEN + Style.BRIGHT + " Server Type: %s" %server.get_server_type()) print(Fore.GREEN + Style.BRIGHT + " API Version: %s" %server.get_api_version()) except Exception, e: print(Fore.RED + Style.BRIGHT + " %s" %str(e)) print try: lstvms = server.get_registered_vms() except Exception, e: print(Fore.RED + Style.BRIGHT + " %s" %str(e)) print for k in lnxrls: hstlst = [] for v in lstvms: hstnme = v.split()[1].split('/')[0].lower()
if args.vmname: vmname = args.vmname[0] server = args.server[0] username = args.username[0] verbose = args.verbose password = args.password[0] # Asking Users password for server #password=getpass.getpass(prompt='Enter password for vCenter %s for user %s: ' % (server,username)) # Connecting to server print_verbose('Connecting to server %s with username %s' % (server,username)) con = VIServer() con.connect(server,username,password) print_verbose('Connected to server %s' % server) print_verbose('Server type: %s' % con.get_server_type()) print_verbose('API version: %s' % con.get_api_version()) if allvms: vms = con.get_registered_vms(None, None, None, 'poweredOn', None) for vmpath in vms: print_verbose('================================================================================') vm = con.get_vm_by_path(vmpath) vmname = vm.get_property('name') ip = find_ip(vm,ipv6) if ip: print '%s : %s' % (vmname,ip) else: print 'ERROR: IP for VM %s not found' % vmname else: print_verbose('================================================================================')
def getserver_type_api(): """Display's the server type(vCenter or ESX) and also the VMWare API version""" s = VIServer() print 'Server Type: ', s.get_server_type() print 'API Version: ', s.get_api_version()