def VirtualMachine_List(VIServer, VirtualMachineList): """ Listet Virtuelle Maschienen """ logger.info("Listing found Virtual Machines using provided information") logger.info("Virtual Machine count is " + str(len(VirtualMachineList))) for VirtualMachineEntry in range(len(VirtualMachineList)): VirtualMachine = VIServer.get_vm_by_path(VirtualMachineList[VirtualMachineEntry]) logger.info("("+ str(VirtualMachineEntry+1) +"/"+ str(len(VirtualMachineList)) +") " + VirtualMachine.get_property("name"))
def revert(datastore): #vmsphear username and password server = VIServer() server.connect("101.91.1.21", "root", "Vsphear_root_password") vm1 = server.get_vm_by_path(datastore) print "Cuurrent Status", vm1.get_status() print "Reverting VM:", datastore vm1.revert_to_snapshot() print "Vm reverted"
def revert(datastore): #vmsphear username and password server = VIServer() server.connect("101.91.1.21", "root", "Vsphear_root_password") vm1 = server.get_vm_by_path(datastore) print "Cuurrent Status",vm1.get_status() print "Reverting VM:", datastore vm1.revert_to_snapshot() print "Vm reverted"
def VirtualMachine_PowerOff(VIServer, VirtualMachineList): """VMs Power Off Funktion Faehrt VMs mit dem Befehl "Power Off" asyncron runter. """ for VirtualMachineEntry in VirtualMachineList: VirtualMachine = VIServer.get_vm_by_path(VirtualMachineEntry) if VirtualMachine.is_powered_on(): try: logger.info("Sending Power-Off signal to " + VirtualMachine.get_property("name")) VirtualMachine.power_off(sync_run=False) except: logger.critical("Power-Off signal failed on " + VirtualMachine.get_property("name"))
def VirtualMachine_Start(VIServer, VirtualMachineList): """VMs Start Funktion Faehrt die OS auf den VMs asyncron hoch. Wenn die VMWare Tools nich installiert sind, werden die VMs ignoriert und dieser vorfall gelogt. """ for VirtualMachineEntry in VirtualMachineList: VirtualMachine = VIServer.get_vm_by_path(VirtualMachineEntry) if VirtualMachine.is_powered_off(): try: logger.info("Sending Power-On signal to " + VirtualMachine.get_property("name")) VirtualMachine.power_on() except: logger.error(VirtualMachine.get_property("name") + " could not be turned on")
def VirtualMachine_Shutdown(VIServer, VirtualMachineList): """VMs Shutdown Funktion Faehrt die OS auf den VMs asyncron runter. Wenn die VMWare Tools nich installiert sind, werden die VMs mit dem Befehl "Power Off" heruntergefahren. """ for VirtualMachineEntry in VirtualMachineList: VirtualMachine = VIServer.get_vm_by_path(VirtualMachineEntry) if VirtualMachine.is_powered_on(): try: logger.info("Sending Guest Shutdown signal to " + VirtualMachine.get_property("name")) VirtualMachine.shutdown_guest() except: logger.error("Problem with VMWare Tools on " + VirtualMachine.get_property("name")) logger.warn("Switching to Power-Off sequence on " + VirtualMachine.get_property("name")) VirtualMachine.power_off(sync_run=False)
def start_vm(vcenter_fqdn): server = VIServer() vcenter_state = False end_time = time.time()+600 while time.time() < end_time: try: server.connect(vcenter_fqdn, "login", "password") vm = server.get_vm_by_path("[datastore1] DHCP-server/DHCP-server.vmx") #vm.power_on() vcenter_state = True print vm.get_status() return except: print ("Waiting for vCenter vm to boot...") time.sleep(10) if not vcenter_state: print "Time out waiting for vCenter vm to boot." kill_vpn()
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 revert_and_start(): try: for host in get_hosts(): server = VIServer() server.connect(host.ip, host.user, host.pwd) for vm_path in host.vms: try: vm = server.get_vm_by_path(vm_path.strip()) vm.revert_to_snapshot() if not vm.is_powered_on(): vm.power_on() except Exception, e: print "[ERROR] Error happened when revert and start test lab %s" % vm_path print e server.disconnect() except Exception, e: print "[ERROR] Error happened when prepare test enviroment(revert and start test labs)." print e
class vSphere: hostname = "" username = "" password = "" def __init__(self, vm_path): self.vm_path = vm_path def __enter__(self): self.server = VIServer() self.server.connect(self.hostname, self.username, self.password) print "DBG connect" vm = self.server.get_vm_by_path(self.vm_path) return vm def __exit__(self, type, value, traceback): try: self.server.disconnect() print "DBG disconnect" except VIException as e: print "DBG problem in disconnection. Fault is: %s" % e.fault pass
def get_vms(): """ Output example: VM_NAME SO MYVM01 Microsoft Windows Server 2003 Standard (32-bit) """ server = VIServer() vmlist = {} for Env in vCenter.keys(): try: server.connect(vCenter[Env]['host'], vCenter[Env]['user'], vCenter[Env]['pass']) except: print "[x] Error connecting to vCernter server. " return 1 vm_list = server.get_registered_vms() for disk_path in vm_list: vm = server.get_vm_by_path(disk_path) print( '%s %s' % (vm.get_property('name'), vm.get_property('guest_full_name')))
class vSphere: def __init__(self, vm_path, sdk_host, sdk_user, sdk_domain, sdk_passwd): self.vm_path = vm_path self.sdk_host = sdk_host self.sdk_user = sdk_domain + "\\" + sdk_user self.sdk_passwd = sdk_passwd def __enter__(self): self.server = VIServer() self.server.connect(self.sdk_host, self.sdk_user, self.sdk_passwd) if config.verbose: logging.debug("connected to vSphere") vm = self.server.get_vm_by_path(self.vm_path) return vm def __exit__(self, type, value, traceback): try: self.server.disconnect() if config.verbose: logging.debug("disconnected from vSphere") except VIException as e: logging.debug("Problem in disconnection. Fault is: %s" % e.fault) pass
class VMWare(): def __init__(self, server, username, password): self.server = server self.username = username self.password = password self.sserver = VIServer() self.sserver.connect(self.server, self.username, self.password) #GETS ALL SHARED VMS def getRegistered(self): isConnected(self.sserver) return self.sserver.get_registered_vms(None, None, None, None) #SPECIFIC VM GETTER #NOT RECOMMENDED def getByName(self, name): try: isConnected(self.sserver) return self.sserver.get_vm_by_name(name) except: return None #RECOMMENDED - Get from getRegistered method def getByPath(self, path): try: isConnected(self.sserver) return self.sserver.get_vm_by_path(path) except: return None #PROPERTIES AND VARIABLES #TODO: check this works for windows!? def getEnvVar(self, name): try: isConnected(self.sserver) machine = self.sserver.get_vm_by_name(name) return machine.get_environment_variables() except: return None def getStatus(self, name): try: isConnected(self.sserver) machine = self.sserver.get_vm_by_path(name) return machine.get_status() except: return None def getInfo(self, name): try: isConnected(self.sserver) machine = self.sserver.get_vm_by_path(name) x = machine.get_properties() stat = machine.get_status() ip = "" if "ip_address" in x: ip = x["ip_address"] ret = { "ip": ip, "status": stat, "memory": x["memory_mb"], "guest_full_name": x["guest_full_name"] } print ret #print x return ret except Exception as e: print e return None #POWER SETTINGS def machineOn(self, name): isConnected(self.sserver) machine = self.sserver.get_vm_by_path(name) machine.power_on() def machineOff(self, name): isConnected(self.sserver) machine = self.sserver.get_vm_by_path(name) machine.power_off() def reset(self, name): isConnected(self.sserver) machien = self.sserver.get_vm_by_path(name) machine.reset() #Snapshots def getSnapshots(self, name): isConnected(self.sserver) machine = self.sserver.get_vm_by_path(name) arr = [] for snapshot in machine.get_snapshots(): name = snapshot.get_name() desc = snapshot.get_description() create = snapshot.get_create_time() state = snapshot.get_state() path = snapshot.get_path() arr.append({ "name": name, "desc": desc, "create": create, "state": state, "path": path #"parent": parent, #"children": children }) return json.dumps(arr) def createSnapShot(self, name, snap, desc): isConnected(self.sserver) machine = self.sserver.get_vm_by_path(name) machine.create_snapshot(snap, description=desc) return "OK" def deleteSnapShot(self, name, snap): isConnected(self.sserver) machine = self.sserver.get_vm_by_path(name) machine.delete_snapshot_by_path(snap) return "OK" def revertSnapShot(self, name, snap): isConnected(self.sserver) machine = self.sserver.get_vm_by_path(name) machine.revert_to_path(snap) return "OK"
from pysphere import VIServer server=VIServer() server.connect(XXXXXXXX","root","********") vms=server.get_registered_vms() vms def get all hostnames(System_name) for vm in vms: vms=server.get_registered_vms() if System_name in vm: vm1=server.get_vm_by_path(vm) print vm1.get_property('hostname') mvas-omu-app1a smsc-sfe4 smsc-sfe3 smsc-cdrpp2 smsc-cdrpp1 smsc-sfe1 mvas-omu-db1a smsc-sem1 mvas-omu-db1b smsc-sem2 smsc-mre1
# create server object server = VIServer() # connect to server server.connect(host, username, password) # get registered vms vm_list = server.get_registered_vms() # list for storing vm dictionaries vm_obj_list = [] # get attributes for each vm for vm in vm_list: # get our attributes vm_attr = server.get_vm_by_path(vm) vm_name = vm_attr.get_property('name') vm_ipv4 = vm_attr.get_property('ip_address', from_cache=False) # create our connection string vm_cmd = connectionstring + str(vm_ipv4) # save to dict vm_obj = { 'cmd': vm_cmd, 'name': vm_name } # add to list vm_obj_list.append(vm_obj) # close connection server.disconnect()
#!/usr/bin/env python from pysphere import VIServer server = VIServer() server.connect("192.168.1.1", '*****@*****.**', 'Password') vmpathlist = server.get_registered_vms() print vmpathlist for path in vmpathlist: vm = server.get_vm_by_path(path) print vm.get_properties(False)
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()
# all the snaps we created in the first place. for vmsnapobj in qs: snapvms[vmsnapobj] = [] snapvmfails[vmsnapobj] = [] snapvmskips[vmsnapobj] = [] try: server.connect(vmsnapobj.hostname, vmsnapobj.username, vmsnapobj.get_password()) except: log.warn("VMware login failed to %s", vmsnapobj.hostname) # TODO: This should generate an alert. continue # There's no point to even consider VMs that are paused or powered off. vmlist = server.get_registered_vms(status='poweredOn') for vm in vmlist: vmobj = server.get_vm_by_path(vm) if doesVMDependOnDataStore(vmobj, vmsnapobj.datastore): try: if canSnapshotVM(vmobj): if not doesVMSnapshotByNameExists( vmobj, vmsnapname): # have we already created a snapshot of the VM for this volume # iteration? can happen if the VM uses two datasets (a and b) # where both datasets are mapped to the same ZFS volume in FreeNAS. vmobj.create_snapshot( vmsnapname, description=vmsnapdescription, memory=False) else: log.debug( "Not creating snapshot %s for VM %s because it "
pass else: # Handle target environment that doesn't support HTTPS verification ssl._create_default_https_context = _create_unverified_https_context from pysphere import VIServer server = VIServer() HOST = "172.17.11.74" LOGIN = "******" PASSWORD = "******" server.connect(HOST, LOGIN, PASSWORD) oc = [] oc.append(server._retrieve_properties_traversal(obj_type='VirtualMachine')) power = [] machines = server.get_registered_vms() for machine in server.get_registered_vms(): power.append(server.get_vm_by_path(machine).get_status()) zindex = -1 for elem in oc: for b in elem: s = (b) zindex = zindex + 1 print "vmrc://" + LOGIN + ":" + PASSWORD + "@" + HOST + ":443/?moid=" + s.Obj, machines[zindex], power[zindex] server.disconnect()
#!/usr/bin/env python from pysphere import VIServer server = VIServer() server.connect("my.esx.host.example.org", "username", "secret") vm = server.get_vm_by_path("[datastore] path/to/file.vmx") vm.wait_for_tools() vm.login_in_guest("Administrator", "secret") vm.get_screenshot("vm_screenshot.png", overwrite=True) server.disconnect()
from pysphere import VIServer import ssl ssl._create_default_https_context = ssl._create_unverified_context server = VIServer() server.connect("192.168.15.245", "root", "1111111") vm = server.get_vm_by_path( "[datastore1] Coordinator-1-16/Coordinator-1-16.vmx") vm.login_in_guest("root", "aaaaaa") vm.send_file("E:\\server_1_16\\server_1_16\\abn_05fa.dst", r"/mnt/abn_05fa.dst") print vm.get_status()
guest.shutdown_guest() elif cmd == 'reset': guest.reset(sync_run=False) elif cmd == 'hard': guest.terminate_process() else: print 'Unrecognized Command!' if len(sys.argv) == 1: print ''' commandline : esxpy.py 'GuestName' 'option' The available options are: 'REBOOT', 'ON', 'OFF', 'SHUTDOWN', 'RESET', or 'HARD' (which terminates the process of a stuck VM). If no option is given the status of the Guest is returned. Currently available VM's are: ''' for i in server.get_registered_vms(): print '\t' + i #print server.get_registered_vms() sys.exit(0) guest = server.get_vm_by_path(sys.argv[1]) print "The guest's current state is: \n %s\n" % guest_status() if sys.argv[2:]: guest_power(sys.argv[2].lower())
def getVMdata(configFilePath, host, user, password, vmListFile): if (host is None and user is None and password is None): OPTION_CHAR = '=' options = {} if os.path.exists(configFilePath): content = open(configFilePath) for line in content: if OPTION_CHAR in line: option, value = line.split(OPTION_CHAR, 1) option = option.strip() value = value.strip() if value.startswith('"') and value.endswith('"'): value = value[1:-1] options[option] = value HOST = options['HOST'] USER = options['USER'] PASSWORD = options['PASSWORD'] else: print "Must supply valid ESX configuration file." sys.exit(1) else: HOST = host USER = user PASSWORD = password try: server = VIServer() server.connect(HOST, USER, PASSWORD) if vmListFile is None: vmlist = server.get_registered_vms() else: if os.path.exists(vmListFile): fileptr = open(vmListFile) content = fileptr.read() vmlist = content.split(",") metric = [] vmMetrics = { 'disk.write': 131079, 'disk.read': 131078, 'disk.usage': 131073, 'cpu.usage': 1, 'mem.usage': 65537 } for vms in vmlist: vms = vms.strip() start = vms.find(']') + 2 end = vms.find('/', start) vmName = vms[start:end] pm = server.get_performance_manager() vm = server.get_vm_by_path(vms) mor = vm._mor for key, value in vmMetrics.iteritems(): entitystats = pm.get_entity_statistic(mor, key) for i in entitystats: dict_result = dict( (name, getattr(i, name)) for name in dir(i)) metric_name = vmName + '.' + dict_result[ 'group'] + '.' + dict_result['counter'] group = dict_result['group'] timeTuple = dict_result['time'] ts = time.mktime(timeTuple.timetuple()) maxValue = getMaxValue(group) if dict_result['unit'] == 'percent': mvalue = float(dict_result['value']) / 100 else: mvalue = dict_result['value'] metric.append({ "metric_name": metric_name, "value": mvalue, "unit": dict_result['unit'], "server": vmName, "maxValue": maxValue, "time_stamp": ts }) return metric except Exception as e: print e sys.exit(1)
for vmsnapobj in qs: snapvms[vmsnapobj] = [] snapvmfails[vmsnapobj] = [] snapvmskips[vmsnapobj] = [] try: server.connect(vmsnapobj.hostname, vmsnapobj.username, vmsnapobj.get_password()) except: log.warn("VMware login failed to %s", vmsnapobj.hostname) # TODO: This should generate an alert. continue # There's no point to even consider VMs that are paused or powered off. vmlist = server.get_registered_vms(status='poweredOn') for vm in vmlist: vmobj = server.get_vm_by_path(vm) if doesVMDependOnDataStore(vmobj, vmsnapobj.datastore): try: if canSnapshotVM(vmobj): if not doesVMSnapshotByNameExists(vmobj, vmsnapname): # have we already created a snapshot of the VM for this volume # iteration? can happen if the VM uses two datasets (a and b) # where both datasets are mapped to the same ZFS volume in FreeNAS. vmobj.create_snapshot(vmsnapname, description=vmsnapdescription, memory=False) else: log.debug("Not creating snapshot %s for VM %s because it " "already exists", vmsnapname, vm) else: # TODO:
#!/usr/bin/env python # -*- coding:utf-8 -*- import ssl from pysphere import VIServer ssl._create_default_https_context = ssl._create_unverified_context server = VIServer() server.connect("192.168.5.30","root","12345678") vmlist = ['[Data1] file forward 1.60/file forward 1.60.vmx','[Data1] drupa_test_nginx_1.15/drupa_test_nginx_1.15.vmx', '[Data1] druapl_test_web/druapl_test_web.vmx', '[Data1] drupal_test_web_1.17/drupal_test_web_1.17.vmx', '[Data1] drupal_test_mysql_1.18/drupal_test_mysql_1.18.vmx', '[Data1] win 2008 1.62w/win 2008 1.62w.vmx', '[Data1] win 2008 1.61w/win 2008 1.61w.vmx'] for vm_name in vmlist: vm = server.get_vm_by_path(vm_name) vm.power_on() server.connect("192.168.5.31","root","12345678") vmlist = ['[datastore1 (4)] to Nagra-5.251/to Nagra-5.251.vmx'] vm = server.get_vm_by_path('[datastore1 (4)] to Nagra-5.251/to Nagra-5.251.vmx') vm.power_on() server.connect("192.168.5.32","root","12345678") vmlist = ['[datastore1 (6)] 5.143bianyi server/5.143bianyi server.vmx', '[datastore1 (6)] linuxAS5.5/linuxAS5.5.vmx', '[datastore1 (6)] linuxas5.5 --9.176/linuxas5.5 --9.176.vmx', '[datastore1 (6)] linuxAS5.5--5.169/linuxAS5.5--5.169.vmx'] for vm_name in vmlist: vm = server.get_vm_by_path(vm_name) vm.power_on() server.connect("192.168.5.33","root","12345678") vmlist = ['[datastore1 (18)] SVN ubuntu13.10-5.146/SVN ubuntu13.10-5.146.vmx]'] for vm_name in vmlist: vm = server.get_vm_by_path(vm_name) vm.power_on()
HOST = "virtualcenter.com" USER = "******" PASSWORD = "******" DATASTORE_NAME = "datastore1" #WHERE THE DISK WILL BE CREATED AT DISK_SIZE_IN_MB = 500 VM_PATH = "[datastore1] path/to/the/config/file.vmx" UNIT_NUMBER = 1 from pysphere import VIServer, VITask from pysphere.resources import VimService_services as VI s = VIServer() s.connect(HOST, USER, PASSWORD) vm = s.get_vm_by_path(VM_PATH) request = VI.ReconfigVM_TaskRequestMsg() _this = request.new__this(vm._mor) _this.set_attribute_type(vm._mor.get_attribute_type()) request.set_element__this(_this) spec = request.new_spec() dc = spec.new_deviceChange() dc.Operation = "add" dc.FileOperation = "create" hd = VI.ns0.VirtualDisk_Def("hd").pyclass() hd.Key = -100 hd.UnitNumber = UNIT_NUMBER
class Stack(SimpleStack): state_translation = { "POWERED ON": "STARTED", "POWERED OFF": "STOPPED", "SUSPENDED": "PAUSED" } def __init__(self, poolinfo): self.connection = False self.poolinfo = poolinfo self.format_for = Formatter() self.connect() def libvirt_connect(self): self.libvirt_connection = libvirt.open( "esx://%s@%s/" % (self.poolinfo.get("username"), self.poolinfo.get("api_server"))) def connect(self): self.connection = VIServer() self.connection.connect(self.poolinfo.get("api_server"), self.poolinfo.get("username"), self.poolinfo.get("password")) return def pool_info(self): return (self.format_for.pool(0, 0, self.poolinfo.get("api_server"))) def guest_list(self): return [{ "id": self.connection.get_vm_by_path(path).properties.name } for path in self.connection.get_registered_vms( cluster=self.poolinfo.get('cluster'))] def guest_info(self, guest_id): vm = self._vm_ref(guest_id) return self._vm_info(vm) def guest_shutdown(self, guest_id, force=False): vm = self._vm_ref(guest_id) if force: return vm.power_off() else: return vm.shutdown_guest() def guest_start(self, guest_id): vm = self._vm_ref(guest_id) return vm.power_on() def guest_reboot(self, guest_id, force=False): vm = self._vm_ref(guest_id) if force: return vm.reset() else: return vm.reboot_guest() def guest_suspend(self, guest_id): vm = self._vm_ref(guest_id) return vm.suspend() def guest_resume(self, guest_id): return self.guest_start(guest_id) def guest_update(self, guest_id, guestdata): vm = self._vm_ref(guest_id) vmware.update_vm(self.connection, vm, guestdata) return self._vm_info(self._vm_ref(guest_id)) def guest_delete(self, guest_id): vm = self._vm_ref(guest_id) vmware.delete_vm(self.connection, vm) def media_mount(self, guest_id, media_data): vm = self._vm_ref(guest_id) vmware.update_vm(self.connection, vm, {"iso": media_data}) def media_info(self, guest_id): vm = self._vm_ref(guest_id) media = vmware.get_cd(vm) if media.connectable.connected: return {"name": media.backing.fileName} else: return {"name": None} def network_interface_list(self, guest_id): vm = self._vm_ref(guest_id) vifs = vmware.get_network_interfaces(vm) return [self._network_interface_info(n) for n in vifs] def network_interface_info(self, guest_id, network_interface_id): vm = self._vm_ref(guest_id) vifs = vmware.get_network_interfaces(vm) for vif in vifs: if vif.macAddress == network_interface_id: return self._network_interface_info(vif) entity_info = "%s - on Guest %s" % (network_interface_id, guest_id) raise EntityNotFound("NetworkInterface", entity_info) def snapshot_list(self, guest_id): vm = self._vm_ref(guest_id) snaps = [self._snapshot_info(s) for s in vm.get_snapshots()] return snaps def snapshot_create(self, guest_id, snapshot_name=None): if not snapshot_name: snapshot_name = str(datetime.datetime.now()) vm = self._vm_ref(guest_id) snap = vmware.create_snapshot(self.connection, vm, snapshot_name) return self._snapshot_info(snap) def snapshot_info(self, guest_id, snapshot_id): vm = self._vm_ref(guest_id) snap = vmware.get_snapshot(vm, snapshot_id) if snap: return self._snapshot_info(snap) else: raise EntityNotFound("Snapshot", snapshot_id) def snapshot_revert(self, guest_id, snapshot_id): vm = self._vm_ref(guest_id) snap = vmware.get_snapshot(vm, snapshot_id) vmware.revert_to_snapshot(self.connection, vm, snap) def snapshot_delete(self, guest_id, snapshot_id): vm = self._vm_ref(guest_id) snap = vmware.get_snapshot(vm, snapshot_id) vmware.delete_snapshot(self.connection, vm, snap) def tag_list(self, guest_id): vm = self._vm_ref(guest_id) return vmware.get_tags(vm) def tag_create(self, guest_id, tag_name): vm = self._vm_ref(guest_id) tags = vmware.create_tag(tag_name, vm) vmware.update_vm(self.connection, vm, {"tags": tags}) return tags def tag_delete(self, guest_id, tag_name): vm = self._vm_ref(guest_id) tags = vmware.delete_tag(tag_name, vm) vmware.update_vm(self.connection, vm, {"tags": tags}) return tags def _vm_ref(self, vm_id): regex = r'[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}' if re.match(regex, vm_id, re.I): return vmware.get_vm_by_uuid(self.connection, vm_id) else: return self.connection.get_vm_by_name(vm_id) def _vm_info(self, vm): vm_info = vm.get_properties() return (self.format_for.guest( vm.properties.config.uuid, vm_info.get('name'), vm_info.get('num_cpu'), vm_info.get('memory_mb'), vmware.get_disk_size(vm) / (1024 * 1024), vmware.get_vmi_driver(vm) is not None, vm.properties.guest.toolsStatus == "toolsOk", None, self.state_translation[vm.get_status()], None)) def _network_interface_info(self, vif): return (self.format_for.network_interface(vif.macAddress, vif.unitNumber, vif.macAddress, '', '', '', vif.backing.network.name)) def _snapshot_info(self, snapshot): return (self.format_for.snapshot(snapshot.get_description(), snapshot.get_name(), snapshot.get_state(), snapshot.get_path(), snapshot.get_create_time()))
guest.shutdown_guest() elif cmd == "reset": guest.reset(sync_run=False) elif cmd == "hard": guest.terminate_process() else: print "Unrecognized Command!" if len(sys.argv) == 1: print """ commandline : esxpy.py 'GuestName' 'option' The available options are: 'REBOOT', 'ON', 'OFF', 'SHUTDOWN', 'RESET', or 'HARD' (which terminates the process of a stuck VM). If no option is given the status of the Guest is returned. Currently available VM's are: """ for i in server.get_registered_vms(): print "\t" + i # print server.get_registered_vms() sys.exit(0) guest = server.get_vm_by_path(sys.argv[1]) print "The guest's current state is: \n %s\n" % guest_status() if sys.argv[2:]: guest_power(sys.argv[2].lower())
snapshot_name="base" host="vcenter.example.com" login="******" password="******" pre_name="VDS" ##################################### import datetime import sys from pysphere import VIServer server = VIServer() print "connect" server.connect(host, login, password) print "get vm" vmlist = server.get_registered_vms() for vmpath in vmlist: vm = server.get_vm_by_path(vmpath) name = vm.get_property('name') if name.find(pre_name) != -1 and name.find("-"+pre_name) == -1: print "create snapshot " + snapshot_name + " for " + vm.get_property('name') + ": " + str(datetime.datetime.now())[0:19] vm.create_snapshot(snapshot_name, memory = True, quiesce = True, sync_run = False) print "end " + str(datetime.datetime.now())[0:19] server.disconnect()
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!")
''' Created on Apr 13, 2015 @author: tim.huang ¡easy_install pysphere or pip install ¡VU pysphere ''' from pysphere import VIServer if __name__ == '__main__': server = VIServer() server.connect("10.90.1.16", "root", "xxxxxxx") vms = server.get_registered_vms() for serverpath in vms: print serverpath vm = server.get_vm_by_path(serverpath) vm.get_properties() vm.get_property("hostname") vm = server.get_vm_by_path(vms[0]) print vm.get_property("mac_address") print vm.get_property("ip_address") print vm.get_property("name") print vm.get_resource_pool_name() #vm = server.get_vm_by_path("[datastore1] s1/s1.vmx") vm.power_on()
vmPropPath = "" host = "" for prop in propset.PropSet: if prop.Name == "name": host = prop.Val elif prop.Name == "guest.toolsVersion": vmToolsVersion = prop.Val elif prop.Name == "config.files.vmPathName": vmPropPath = prop.Val if not serverVMToolVersion.has_key(host): serverVMToolVersion[host] = vmToolsVersion for vms in vmlist: print vms vm = server.get_vm_by_path(vms) vmGuestFullName = vm.get_property('guest_full_name') if not re.search('Microsoft', vmGuestFullName, re.IGNORECASE): vmStatus = vm.get_status() print "VM STATUS: " + vmStatus guestID = vm.get_property('guest_id') print "VM GUEST ID: " + guestID vmPath = vm.get_property('path') print "VM PATH: " + vmPath vmName = vm.get_property('name') print "VM NAME: " + vmName print "VM GUEST FULL NAME: " + vmGuestFullName vmHostname = vm.get_property('hostname') print "VM HOSTNAME: " + str(vmHostname) vmCPU = vm.get_property('num_cpu') print "VM NUMBER CPU: " + str(vmCPU)
# 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) vm = find_vm(vmname) if vm: ip = find_ip(vm,ipv6) if ip: print '%s : %s' % (vmname,ip) else:
class Stack(SimpleStack): state_translation = {"POWERED ON": "STARTED", "POWERED OFF": "STOPPED", "SUSPENDED": "PAUSED"} def __init__(self, poolinfo): self.connection = False self.poolinfo = poolinfo self.format_for = Formatter() self.connect() def libvirt_connect(self): self.libvirt_connection = libvirt.open( "esx://%s@%s/" % (self.poolinfo.get("username"), self.poolinfo.get("api_server")) ) def connect(self): self.connection = VIServer() self.connection.connect( self.poolinfo.get("api_server"), self.poolinfo.get("username"), self.poolinfo.get("password") ) return def pool_info(self): return self.format_for.pool(0, 0, self.poolinfo.get("api_server")) def guest_list(self): return [ {"id": self.connection.get_vm_by_path(path).properties.name} for path in self.connection.get_registered_vms(cluster=self.poolinfo.get("cluster")) ] def guest_info(self, guest_id): vm = self._vm_ref(guest_id) return self._vm_info(vm) def guest_shutdown(self, guest_id, force=False): vm = self._vm_ref(guest_id) if force: return vm.power_off() else: return vm.shutdown_guest() def guest_start(self, guest_id): vm = self._vm_ref(guest_id) return vm.power_on() def guest_reboot(self, guest_id, force=False): vm = self._vm_ref(guest_id) if force: return vm.reset() else: return vm.reboot_guest() def guest_suspend(self, guest_id): vm = self._vm_ref(guest_id) return vm.suspend() def guest_resume(self, guest_id): return self.guest_start(guest_id) def guest_update(self, guest_id, guestdata): vm = self._vm_ref(guest_id) vmware.update_vm(self.connection, vm, guestdata) return self._vm_info(self._vm_ref(guest_id)) def guest_delete(self, guest_id): vm = self._vm_ref(guest_id) vmware.delete_vm(self.connection, vm) def media_mount(self, guest_id, media_data): vm = self._vm_ref(guest_id) vmware.update_vm(self.connection, vm, {"iso": media_data}) def media_info(self, guest_id): vm = self._vm_ref(guest_id) media = vmware.get_cd(vm) if media.connectable.connected: return {"name": media.backing.fileName} else: return {"name": None} def network_interface_list(self, guest_id): vm = self._vm_ref(guest_id) vifs = vmware.get_network_interfaces(vm) return [self._network_interface_info(n) for n in vifs] def network_interface_info(self, guest_id, network_interface_id): vm = self._vm_ref(guest_id) vifs = vmware.get_network_interfaces(vm) for vif in vifs: if vif.macAddress == network_interface_id: return self._network_interface_info(vif) entity_info = "%s - on Guest %s" % (network_interface_id, guest_id) raise EntityNotFound("NetworkInterface", entity_info) def snapshot_list(self, guest_id): vm = self._vm_ref(guest_id) snaps = [self._snapshot_info(s) for s in vm.get_snapshots()] return snaps def snapshot_create(self, guest_id, snapshot_name=None): if not snapshot_name: snapshot_name = str(datetime.datetime.now()) vm = self._vm_ref(guest_id) snap = vmware.create_snapshot(self.connection, vm, snapshot_name) return self._snapshot_info(snap) def snapshot_info(self, guest_id, snapshot_id): vm = self._vm_ref(guest_id) snap = vmware.get_snapshot(vm, snapshot_id) if snap: return self._snapshot_info(snap) else: raise EntityNotFound("Snapshot", snapshot_id) def snapshot_revert(self, guest_id, snapshot_id): vm = self._vm_ref(guest_id) snap = vmware.get_snapshot(vm, snapshot_id) vmware.revert_to_snapshot(self.connection, vm, snap) def snapshot_delete(self, guest_id, snapshot_id): vm = self._vm_ref(guest_id) snap = vmware.get_snapshot(vm, snapshot_id) vmware.delete_snapshot(self.connection, vm, snap) def tag_list(self, guest_id): vm = self._vm_ref(guest_id) return vmware.get_tags(vm) def tag_create(self, guest_id, tag_name): vm = self._vm_ref(guest_id) tags = vmware.create_tag(tag_name, vm) vmware.update_vm(self.connection, vm, {"tags": tags}) return tags def tag_delete(self, guest_id, tag_name): vm = self._vm_ref(guest_id) tags = vmware.delete_tag(tag_name, vm) vmware.update_vm(self.connection, vm, {"tags": tags}) return tags def _vm_ref(self, vm_id): regex = r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}" if re.match(regex, vm_id, re.I): return vmware.get_vm_by_uuid(self.connection, vm_id) else: return self.connection.get_vm_by_name(vm_id) def _vm_info(self, vm): vm_info = vm.get_properties() return self.format_for.guest( vm.properties.config.uuid, vm_info.get("name"), vm_info.get("num_cpu"), vm_info.get("memory_mb"), vmware.get_disk_size(vm) / (1024 * 1024), vmware.get_vmi_driver(vm) is not None, vm.properties.guest.toolsStatus == "toolsOk", None, self.state_translation[vm.get_status()], None, ) def _network_interface_info(self, vif): return self.format_for.network_interface( vif.macAddress, vif.unitNumber, vif.macAddress, "", "", "", vif.backing.network.name ) def _snapshot_info(self, snapshot): return self.format_for.snapshot( snapshot.get_description(), snapshot.get_name(), snapshot.get_state(), snapshot.get_path(), snapshot.get_create_time(), )
def getVMdata(configFilePath, host, user, password, vmListFile): if (host is None and user is None and password is None): OPTION_CHAR = '=' options = {} if os.path.exists(configFilePath): content = open(configFilePath) for line in content: if OPTION_CHAR in line: option, value = line.split(OPTION_CHAR, 1) option = option.strip() value = value.strip() if value.startswith('"') and value.endswith('"'): value = value[1:-1] options[option] = value HOST = options['HOST'] USER = options['USER'] PASSWORD = options['PASSWORD'] else: print "Must supply valid ESX configuration file." sys.exit(1) else: HOST = host USER = user PASSWORD = password try: server = VIServer() server.connect(HOST, USER, PASSWORD) if vmListFile is None: vmlist = server.get_registered_vms() else: if os.path.exists(vmListFile): fileptr = open(vmListFile) content = fileptr.read() vmlist = content.split(",") metric = [] vmMetrics = {'disk.write': 131079, 'disk.read': 131078, 'disk.usage': 131073, 'cpu.usage': 1, 'mem.usage': 65537} for vms in vmlist: vms = vms.strip() start = vms.find(']') + 2 end = vms.find('/', start) vmName = vms[start:end] pm = server.get_performance_manager() vm = server.get_vm_by_path(vms) mor = vm._mor for key, value in vmMetrics.iteritems(): entitystats = pm.get_entity_statistic(mor, key) for i in entitystats: dict_result = dict((name, getattr(i, name)) for name in dir(i)) metric_name = vmName+'.'+dict_result['group']+'.'+dict_result['counter'] group = dict_result['group'] timeTuple = dict_result['time'] ts = time.mktime(timeTuple.timetuple()) maxValue = getMaxValue(group) if dict_result['unit'] == 'percent': mvalue = float(dict_result['value'])/100 else: mvalue = dict_result['value'] metric.append({"metric_name": metric_name, "value": mvalue, "unit":dict_result['unit'], "server":vmName, "maxValue":maxValue,"time_stamp":ts}) return metric except Exception as e: print e sys.exit(1)
class Report: """Class report. Generate a dictionnary with the VMs and these properties""" def __init__(self, config): self.login = config['user'] self.password = config['password'] self.vcenter = config['vcenter'] self.server = VIServer() def connect(self): """Connect to the hypervisor""" self.server.connect(self.vcenter, self.login, self.password) def disconnect(self): """Close the connection with the hypervisor""" if self.server: self.server.disconnect() def generate_report(self): """Generate the report of the actual connection""" report = [] # Create the report vms_list = self.server.get_registered_vms() for vm_path in vms_list: virtual_machine = self.server.get_vm_by_path(vm_path) if str(virtual_machine.__class__) != "pysphere.vi_virtual_machine.VIVirtualMachine": continue if re.match(r'rhel', virtual_machine.get_property('guest_id')): vm_infos = { 'name': virtual_machine.get_property('name'), 'ip': virtual_machine.get_property('ip_address'), 'os': virtual_machine.get_property('guest_id') } try: status = virtual_machine.get_status() except Exception, e: print "Couldn't do it: %s" % e vm_infos['powered'] = 'none' report.append(vm_infos) continue if status == "POWERED ON": vm_infos['powered'] = 'on' # Get version in ssh ssh = subprocess.Popen([ "ssh", "-i ~/.ssh/id_rsa", "%s" % vm_infos['name'], "cat /etc/redhat-release"], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE ) release = ssh.stdout.readlines() if release == []: error = ssh.stderr.readlines() vm_infos['release'] = "error: " + error else: regex = re.compile("release (\d.*).+\(\D*(\d*)\)") r = regex.search(release[0]) release = r.groups() if release[1].strip(): vm_infos['release'] = release[0] + "." + release[1] else: vm_infos['release'] = release[0] else: vm_infos['powered'] = 'off' report.append(vm_infos) return report
else: # Handle target environment that doesn't support HTTPS verification ssl._create_default_https_context = _create_unverified_https_context from pysphere import VIServer server = VIServer() HOST = "172.17.11.74" LOGIN = "******" PASSWORD = "******" server.connect(HOST, LOGIN, PASSWORD) oc = [] oc.append(server._retrieve_properties_traversal(obj_type='VirtualMachine')) power = [] machines = server.get_registered_vms() for machine in server.get_registered_vms(): power.append(server.get_vm_by_path(machine).get_status()) zindex = -1 for elem in oc: for b in elem: s = (b) zindex = zindex + 1 print "vmrc://" + LOGIN + ":" + PASSWORD + "@" + HOST + ":443/?moid=" + s.Obj, machines[ zindex], power[zindex] server.disconnect()
www_user = '******' www_pass = '******' def printlog(text): fileToBeWriten = "/home/dimi/prog/exsi/exsi_reboot.txt" fichierWrite = open(fileToBeWriten,'a') fichierWrite.write(text) fichierWrite.write('\n') fichierWrite.close() server = VIServer() server.connect(exsi_ip, exsi_user, exsi_pass) vms = server.get_registered_vms() vm = server.get_vm_by_path(vms[0]) ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) try: ssh.connect(www_ip, username=www_user, password=www_pass) except: printlog(time.asctime()) printlog('----------------------------') printlog('ssh down, trying to reboot www vm') vm.power_off() vm.power_on() printlog(vm.get_property('name',from_cache=False)) printlog(vm.get_status())
USER = "******" PASSWORD = "******" VMDK_FILE = "[datastore1] vm-test-name/test.vmdk" AddDisk = 5 CAPACITY_IN_KB = AddDisk * 1024 * 1024 DESTINATION_VM = "[datastore1-data] vm-test-name/vm-test-name.vmx" UNIT_NUMBER = 2 # this is the scsi number 0, 1, 2 - would normally be 1 for a second disk from pysphere import VIServer, VITask from pysphere.resources import VimService_services as VI s = VIServer() s.connect(HOST, USER, PASSWORD) vm = s.get_vm_by_path(DESTINATION_VM) print(vm) print("capapcity = %s" % CAPACITY_IN_KB) request = VI.ReconfigVM_TaskRequestMsg() _this = request.new__this(vm._mor) _this.set_attribute_type(vm._mor.get_attribute_type()) request.set_element__this(_this) spec = request.new_spec() dc = spec.new_deviceChange() dc.Operation = "add" hd = VI.ns0.VirtualDisk_Def("hd").pyclass()
class Report: """Class report. Generate a dictionnary with the VMs and these properties""" def __init__(self, config): self.login = config['user'] self.password = config['password'] self.vcenter = config['vcenter'] self.server = VIServer() def connect(self): """Connect to the hypervisor""" self.server.connect(self.vcenter, self.login, self.password) def disconnect(self): """Close the connection with the hypervisor""" if self.server: self.server.disconnect() def generate_report(self): """Generate the report of the actual connection""" report = [] # Create the report vms_list = self.server.get_registered_vms() for vm_path in vms_list: virtual_machine = self.server.get_vm_by_path(vm_path) if str(virtual_machine.__class__ ) != "pysphere.vi_virtual_machine.VIVirtualMachine": continue if re.match(r'rhel', virtual_machine.get_property('guest_id')): vm_infos = { 'name': virtual_machine.get_property('name'), 'ip': virtual_machine.get_property('ip_address'), 'os': virtual_machine.get_property('guest_id') } try: status = virtual_machine.get_status() except Exception, e: print "Couldn't do it: %s" % e vm_infos['powered'] = 'none' report.append(vm_infos) continue if status == "POWERED ON": vm_infos['powered'] = 'on' # Get version in ssh ssh = subprocess.Popen([ "ssh", "-i ~/.ssh/id_rsa", "%s" % vm_infos['name'], "cat /etc/redhat-release" ], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE) release = ssh.stdout.readlines() if release == []: error = ssh.stderr.readlines() vm_infos['release'] = "error: " + error else: regex = re.compile("release (\d.*).+\(\D*(\d*)\)") r = regex.search(release[0]) release = r.groups() if release[1].strip(): vm_infos['release'] = release[0] + "." + release[1] else: vm_infos['release'] = release[0] else: vm_infos['powered'] = 'off' report.append(vm_infos) return report
#!/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()
server = VIServer() qs = VMWarePlugin.objects.filter(filesystem=fs) vmsnapname = str(uuid.uuid4()) vmsnapdescription = str(datetime.now()).split('.')[0] + " FreeNAS Created Snapshot" snapvms = [] snapvmfails = [] for obj in qs: try: server.connect(obj.hostname, obj.username, obj.get_password()) except: log.warn("VMware login failed to %s", obj.hostname) continue vmlist = server.get_registered_vms(status='poweredOn') for vm in vmlist: if vm.startswith("[%s]" % obj.datastore): vm1 = server.get_vm_by_path(vm) try: vm1.create_snapshot(vmsnapname, description=vmsnapdescription, memory=False) except: log.warn("Snapshot of VM %s failed", vm1) snapvmfails.append(vm) snapvms.append(vm1) if snapvmfails: try: with LockFile(VMWARE_FAILS) as lock: with open(VMWARE_FAILS, 'rb') as f: fails = pickle.load(f) except: fails = {} fails[snapname] = [str(vm) for vm in snapvmfails]
# 获取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的实例 vm1 = server_obj.get_vm_by_name() # 下面就可以获取vm的具体信息 print vm1.get_status() # 返回的状态信息会更快 print vm1.get_status(basic_status=True) # 判断虚拟机状态的方法 # print vm1.is_powered_off() # print vm1.is_powered_on() # 。。。。。。。。
raise Exception("No ESX specified") if OPER == None: if not sys.argv[ARG] in OPERS: raise Exception("Not a known operation <" + sys.argv[ARG] + ">") OPER = sys.argv[ARG] continue APPLYTO = sys.argv[ARG:len(sys.argv)] break if ESX == None: Usage("Missing ESX argument") sys.exit(1) if OPER == None: Usage("Missing OPER argument") sys.exit(1) operate(ESX, FILTER, OPER, APPLYTO) exit(0) ################################################################################ # Main: exit(0) vm = server.get_vm_by_path("[datastore] path/to/file.vmx") #vm.power_on()
argc = len(argvs) if (argc != 7): print "Usage : python tst.py --vcenter=<vCenter IP> --vuser=<user> --vpass=<password> \ --name=<VM name> --var=<var> --val=<val>" sys.exit(1) # connect to vCenter server = VIServer() #server.connect(opt_vcenter, opt_vuser, opt_vpass, trace_file="debug.txt") server.connect(opt_vcenter, opt_vuser, opt_vpass) #path_to_vm = "[%s] %/%s.vmx" % (datastore_name, opt_name, opt_name) path_to_vm = "[%s] %s/%s.vmx" % (DATASTORE_NAME, opt_name, opt_name) vm = server.get_vm_by_path(path_to_vm) #disk.locking = "FALSE" #disk.EnableUUID = "TRUE" #settings = { 'disk.locking': 'FALSE' } #settings = { 'disk.EnableUUID': 'TRUE' } settings = {opt_var: opt_val} #print settings vm.set_extra_config(settings) server.disconnect()