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 test_vmware_version_vcenter(self): """ Is the Vmware version at 5.1?""" server = VIServer() server.connect(CREDS.get('Vcenter', 'server'), CREDS.get('Vcenter', 'user'), CREDS.get('Vcenter', 'pass')) api = server.get_api_version() self.assertEqual('5.1', api) server.disconnect()
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 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 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 vConnect(VIHost, VIUser, VIPassword): """Verbindungs Funktion zum Server Baut eine Verbindung mit VCS Server auf und speichert die Verbindungsinformationen in der VISerever variable des Typs "VIServer". """ logger.info("Connecting to vSphere: " + VIHost) VirtualServerInstance = VIServer() VirtualServerInstance.connect(VIHost, VIUser, VIPassword) if VirtualServerInstance: logger.info("Connected to vSphere: " + VIHost) logger.info(VirtualServerInstance.get_api_type() + " API " + VirtualServerInstance.get_api_version()) return VirtualServerInstance else: logger.error("Connection to the vSphere failed.") sys.exit(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)
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)
def main(): if len(sys.argv) <> 3: print ("Usage:") print (sys.argv[0], "<username> <password") username = sys.argv[1] password = sys.argv[2] vcenter = "ecnshmw1001.sh.cn.ao.ericsson.se" server = VIServer() server.connect( vcenter, username, password ) print ("Login .....") type = server.get_api_type() version = server.get_api_version() print ("You are now connecting with {0} with API version {1}".format(type, version)) select(server) server.disconnect()
'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())
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 hstnme.startswith(lnxrls[k]['role']):
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') #Get virtual machine status vm1 = server.get_vm_by_name('rhel5.3_prod')
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)
logger.debug( 'No command line password received, requesting password from user') password = getpass.getpass( prompt='Enter password for vCenter %s for user %s: ' % (server, username)) # 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() # Setting up vars datacenters = None clusters = None hosts = None datastores = None vms = None try: # Getting datacenters logger.debug('Getting datastores')
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()
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) if resource_pool_mor is None:
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 hstnme.startswith(lnxrls[k]['role']):
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') #Get virtual machine status vm1 = server.get_vm_by_name('rhel5.3_prod')
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": host = prop.Val elif prop.Name == "guest.toolsVersion": vmToolsVersion = prop.Val
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() sys.exit()
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 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)
#!/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()
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() # 通过名称获取vm的实例
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!")
'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):
# Asking Users password for server if password is None: 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)
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)
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() sys.exit()
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)
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)
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('================================================================================') print_verbose('Trying to find IP for VM %s' % vmname)
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