def main(): args = GetArgs() try: vmnames = args.vm si = None if args.password: password = args.password else: password = getpass.getpass(prompt="Enter password for host {} and user {}: ".format(args.host, args.user)) try: if args.cert_check_skip: context = ssl._create_unverified_context() si = SmartConnect(host=args.host, user=args.user, pwd=password, port=int(args.port), sslContext=context) else: si = SmartConnect(host=args.host, user=args.user, pwd=password, port=int(args.port)) except IOError as e: pass if not si: print('Could not connect to the specified host using specified username and password') return -1 atexit.register(Disconnect, si) content = si.RetrieveContent() # Get vCenter date and time for use as baseline when querying for counters vchtime = si.CurrentTime() # Get all the performance counters perf_dict = {} perfList = content.perfManager.perfCounter for counter in perfList: counter_full = "{}.{}.{}".format(counter.groupInfo.key, counter.nameInfo.key, counter.rollupType) perf_dict[counter_full] = counter.key retProps = GetProperties(content, [vim.VirtualMachine], ['name', 'runtime.powerState'], vim.VirtualMachine) #Find VM supplied as arg and use Managed Object Reference (moref) for the PrintVmInfo for vm in retProps: if (vm['name'] in vmnames) and (vm['runtime.powerState'] == "poweredOn"): PrintVmInfo(vm['moref'], content, vchtime, args.interval, perf_dict) elif vm['name'] in vmnames: print('ERROR: Problem connecting to Virtual Machine. {} is likely powered off or suspended'.format(vm['name'])) except vmodl.MethodFault as e: print('Caught vmodl fault : ' + e.msg) return -1 except Exception as e: print('Caught exception : ' + str(e)) return -1 return 0
def main(): global content, hosts, hostPgDict host, user, password = GetArgs() serviceInstance = SmartConnect(host=host, user=user, pwd=password, port=443) atexit.register(Disconnect, serviceInstance) content = serviceInstance.RetrieveContent() #Disconnect(serviceInstance) hosts = GetVMHosts(content) perfManager = content.perfManager vchtime = serviceInstance.CurrentTime() print('Hosts is %s \n ' % (hosts)) for host in hosts: print('Host is %s \n' % (host)) print(' -------- Start of config stuff ---------- \n') #print('nw vnic test is %s \n' % (host.config.network.vnic)) for v in host.config.network.vnic: print('vnic is %s \n' % (v)) print('vnic spec is %s \n' % (v.spec)) print('vnic device is %s \n' % (v.device)) print('vnic description is %s \n' % (v.portgroup)) print('vnic mac is %s \n' % (v.spec.mac)) print('vnic mtu is %s \n' % (v.spec.mtu)) if v.spec.ip: print('Address is %s \n' % (v.spec.ip.ipAddress)) for p in host.config.network.pnic: print('pnic is %s \n' % (p)) print('pnic device is %s \n' % (p.device)) print('pnic mac is %s \n' % (p.mac)) print('pnic spec is %s \n' % (p.spec)) if p.spec.ip: print('pnic ip is %s \n' % (p.spec.ip)) print('Address is %s \n' % (p.spec.ip.ipAddress)) if p.linkSpeed: print('pnic linkSpeed is %s \n' % (p.linkSpeed)) print('pnic linkSpeed speed is is %s \n' % (p.linkSpeed.speedMb)) print('pnic linkSpeed duplex is is %s \n' % (p.linkSpeed.duplex)) #print('nw pnic test is %s \n' % (host.config.network.pnic.spec)) #print('nw pnic test is %s \n' % (host.config.network.pnic.mac)) #print('nw pnic test is %s \n' % (host.config.network.pnic.device)) print(' -------- End of config stuff ---------- \n') vms = GetVMs(content) """
def getData(host, user, password, port, log): # make a connection try: conn = SmartConnect( host=host, user=user, pwd=password, port=port, sslContext=ssl._create_unverified_context()) if not conn: log.warn('Could not connect to host %s \n' % (host)) else: content = conn.RetrieveContent() vchtime = conn.CurrentTime() # Get VMs vm_view = content.viewManager.CreateContainerView( content.rootFolder, [vim.VirtualMachine], True) vms = [vm for vm in vm_view.view] log.debug(' in getData - vms is %s \n' % (vms)) vm_view.Destroy() # Get datastores datastore_view = content.viewManager.CreateContainerView( content.rootFolder, [vim.Datastore], True) datastores = [] for datastore in datastore_view.view: datastore.RefreshDatastore() datastores.append(datastore) log.debug(' in getData - datastores is %s \n' % (datastores)) datastore_view.Destroy() # Get hosts host_view = content.viewManager.CreateContainerView( content.rootFolder, [vim.HostSystem], True) hosts = [host for host in host_view.view] log.debug(' in getData - hosts is %s \n' % (hosts)) host_view.Destroy() perfManager = content.perfManager vpm = vim.PerformanceManager return vchtime, hosts, vms, datastores, perfManager, vpm except: log.warn('Failed to get data from host %s\n' % (host)) # Note: from daemons use a shutdown hook to do this, not the atexit atexit.register(Disconnect, conn)
def main(): s = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2) s.verify_mode = ssl.CERT_NONE si = SmartConnect(host="your_host", user="******", pwd="password", sslContext=s) print(si.CurrentTime()) content = si.RetrieveContent() container = content.rootFolder # starting point to look into viewType = [vim.VirtualMachine] # object types to look for recursive = True # whether we should look into it recursively containerView = content.viewManager.CreateContainerView( container, viewType, recursive) children = containerView.view exportxls(children) for child in children: print_vm_info(child)
def main(): global content, hosts, hostPgDict host, user, password = GetArgs() serviceInstance = SmartConnect(host=host, user=user, pwd=password, port=443) atexit.register(Disconnect, serviceInstance) content = serviceInstance.RetrieveContent() #Disconnect(serviceInstance) hosts = GetVMHosts(content) perfManager = content.perfManager vchtime = serviceInstance.CurrentTime() # Get all the performance counters perf_dict = {} perfList = content.perfManager.perfCounter for counter in perfList: counter_full = "{}.{}.{}".format(counter.groupInfo.key, counter.nameInfo.key, counter.rollupType) perf_dict[counter_full] = counter.key #print( 'perf_dict is %s \n\n' % (perf_dict)) #print('-------perf Dict --------') #pprint.pprint(perf_dict) interval = 20 print('Hosts is %s \n ' % (hosts)) for host in hosts: print('Host is %s \n' % (host)) """ statInt = interval * 3 # There are 3 20s samples in each minute statSysUpTime = BuildQuery(perfManager, vchtime, (StatCheck(perf_dict, 'sys.uptime.latest')), "", host, interval) #statSysUpTime = BuildQuery(perfManager, vchtime, (StatCheck(perf_dict, 'sys.uptime.latest')), "", host, 0) sysUpTime = (float(sum(statSysUpTime[0].value[0].value)) / statInt) #sysUpTime = float(sum(statSysUpTime[0].value[0].value)) print(' sysUpTime is %s \n' % (sysUpTime)) statCpuUsage = BuildQuery(perfManager, vchtime, (StatCheck(perf_dict, 'cpu.usage.average')), "", host, interval) cpuUsage = ((float(sum(statCpuUsage[0].value[0].value)) / statInt) / 100) print(' cpuUsage is %s \n' % (cpuUsage)) statMemoryActive = BuildQuery(perfManager, vchtime, (StatCheck(perf_dict, 'mem.active.average')), "", host, interval) MemoryActive = ((float(sum(statMemoryActive[0].value[0].value)) / statInt) / 100) print(' MemoryActive is %s \n' % (MemoryActive)) """ print(' -------- Start of config stuff ---------- \n') #print('nw vnic test is %s \n' % (host.config.network.vnic)) for v in host.config.network.vnic: print('vnic is %s \n' % (v)) print('vnic device is %s \n' % (v.device)) print('vnic mac is %s \n' % (v.mac)) print('vnic mtu is %s \n' % (v.spec.mtu)) for p in host.config.network.pnic: print('pnic is %s \n' % (p)) print('pnic device is %s \n' % (p.device)) print('pnic mac is %s \n' % (p.mac)) #print('pnic ipAddress is %s \n' % (p.spec.ip.ipAddress)) print('pnic spec is %s \n' % (p.spec)) if p.spec.ip: print('pnic ip is %s \n' % (p.spec.ip)) print('Address is %s \n' % (p.spec.ip.ipAddress)) print('pnic linkSpeed is %s \n' % (p.linkSpeed)) #print('nw pnic test is %s \n' % (host.config.network.pnic.spec)) #print('nw pnic test is %s \n' % (host.config.network.pnic.mac)) #print('nw pnic test is %s \n' % (host.config.network.pnic.device)) #print('osVendor is %s \n' % (host.summary.config.product.vendor)) #print('osProduct is %s \n' % (host.summary.config.product.fullName)) #print('hwVendor is %s \n' % (host.summary.hardware.vendor)) #print('hwProduct is %s \n' % (host.summary.hardware.model)) #print('memorySize is %s \n' % (host.summary.hardware.memorySize)) #print('cpuMhz is %s \n' % (host.summary.hardware.cpuMhz)) #print('cpuModel is %s \n' % (host.summary.hardware.cpuModel)) #print('numCpuCores is %s \n' % (host.summary.hardware.numCpuCores)) #print('numCpuPkgs is %s \n' % (host.summary.hardware.numCpuPkgs)) #print('numCpuThreads is %s \n' % (host.summary.hardware.numCpuThreads)) #print('numNics is %s \n' % (host.summary.hardware.numNics)) #print('esxiHostName is %s \n' % (host.summary.config.name)) #print('vmotionState is %s \n' % (host.summary.config.vmotionEnabled)) print(' -------- End of config stuff ---------- \n') vms = GetVMs(content) """
def collect_esxi_data(host, user, pwd, ssl, es): #now = datetime.datetime.now() global dict_list global printVM global printDatastore global printHost try: collection_time = datetime.now(pytz.utc).replace(microsecond=0) today = time.strftime("%Y-%m-%d %H:%M") si = SmartConnect(host=host, user=user, pwd=pwd, sslContext=ssl) print('Collecting Information at :', today) content = si.RetrieveContent() #disconnect the connection when program exists #atexit.register(Disconnect, si) #atexit.register(endit) # Get vCenter date and time for use as baseline when querying for counters vchtime = si.CurrentTime() perf_dict = create_perf_dictionary(content) container = content.rootFolder # starting point to look into viewType = [vim.VirtualMachine] # object types to look for recursive = True # whether we should look into it recursively containerView = content.viewManager.CreateContainerView( container, viewType, recursive) children = containerView.view c1 = 0 for child in children: print_vm_info(child) c1 += 1 c2 = 0 if printVM: vmProps = get_properties(content, [vim.VirtualMachine], ['name', 'runtime.powerState'], vim.VirtualMachine) for vm in vmProps: if vm['runtime.powerState'] == "poweredOn": #print("VM Name in Power ON : ",vm["name"]) vm_moref = vm['moref'] guest, cpu, mem = vm_core(vm_moref) #core information #vmGuest1.append(guest) vmNumCPU.append(cpu) s = re.findall(r"[-+]?\d*\.\d+|\d+", mem) if "GB" in mem: memKBytes = float(s[0]) * 131072 elif "MB" in mem: memKBytes = float(s[0]) * 1024 elif "KB" in mem: memKBytes = float(s[0]) else: memKBytes = float(s[0]) * 0.00097656 vmMemory.append(memKBytes) status, state = vm_status(vm_moref) #status information #print("State : ", state) vmStatus.append(status) #print("State in P on:", state) vmState.append(1) CPUready = vm_cpu_ready(vm_moref, content, vchtime, perf_dict) vmCPUready.append(CPUready) CPUusage = vm_cpu_usage(vm_moref, content, vchtime, perf_dict) vmCPUusage.append(CPUusage) MEMactive = vm_mem_active(vm_moref, content, vchtime, perf_dict) vmMEMactive.append(MEMactive) MEMshared = vm_mem_shared(vm_moref, content, vchtime, perf_dict) vmMEMshared.append(MEMshared) MEMballoon = vm_mem_balloon(vm_moref, content, vchtime, perf_dict) vmMEMballoon.append(MEMballoon) DS_readIO, DS_writeIO, DS_finalIO = vm_ds_io( vm_moref, content, vchtime, perf_dict) vmDS_readIO.append(DS_readIO) vmDS_writeIO.append(DS_writeIO) vmDS_finalIO.append(DS_finalIO) DS_readLatency, DS_writeLatency, totalLatency = vm_ds_latency( vm_moref, content, vchtime, perf_dict) vmDS_readLatency.append(DS_readLatency) vmDS_writeLatency.append(DS_writeLatency) vmDS_totalLatency.append(totalLatency) NetUsageRx, NetUsageTx, NetUsageTotal = vm_net_usage( vm_moref, content, vchtime, perf_dict) vm_NetUsageRx.append(NetUsageRx) vm_NetUsageTx.append(NetUsageTx) vm_NetUsageTotal.append(NetUsageTotal) #break c2 += 1 else: #print("VM Name in Power OFF : ",vm["name"]) vm_moref = vm['moref'] guest, cpu, mem = vm_core(vm_moref) #core information #vmGuest1.append(guest) vmNumCPU.append(cpu) s = re.findall(r"[-+]?\d*\.\d+|\d+", mem) if "GB" in mem: memKBytes = float(s[0]) * 131072 elif "MB" in mem: memKBytes = float(s[0]) * 1024 elif "KB" in mem: memKBytes = float(s[0]) else: memKBytes = float(s[0]) * 0.00097656 vmMemory.append(memKBytes) status, state = vm_status(vm_moref) #status information vmStatus.append(status) #print("State in P off:", state) vmState.append(0) #CPUready = vm_cpu_ready(vm_moref, content, vchtime, perf_dict) vmCPUready.append(0) #CPUusage = vm_cpu_usage(vm_moref, content, vchtime, perf_dict) vmCPUusage.append(0) #MEMactive = vm_mem_active(vm_moref, content, vchtime, perf_dict) vmMEMactive.append(0) #MEMshared = vm_mem_shared(vm_moref, content, vchtime, perf_dict) vmMEMshared.append(0) #MEMballoon = vm_mem_balloon(vm_moref, content, vchtime, perf_dict) vmMEMballoon.append(0) #DS_readIO , DS_writeIO, DS_finalIO = vm_ds_io(vm_moref, content, vchtime, perf_dict) vmDS_readIO.append(0) vmDS_writeIO.append(0) vmDS_finalIO.append(0) #DS_readLatency,DS_writeLatency, totalLatency = vm_ds_latency(vm_moref, content, vchtime, perf_dict) vmDS_readLatency.append(0) vmDS_writeLatency.append(0) vmDS_totalLatency.append(0) #NetUsageRx,NetUsageTx, NetUsageTotal = vm_net_usage(vm_moref, content, vchtime, perf_dict) vm_NetUsageRx.append(0) vm_NetUsageTx.append(0) vm_NetUsageTotal.append(0) d = {} #print("VM state list" , vmState) header = [ "@Timestamp", "vmName", "vmTemplate", "vmPath", "vmDSlocation", "vmGuest", "vmInstanceUUID", "vmBioUUID", "vmIP", "VMwareTools", "vmNumCPU", "vmMemory", "vmStatus", "vmState", "vmCPUready", "vmCPUusage", "vmMEMactive", "vmMEMshared", "vmMEMballoon", "vmDS_readIO", "vmDS_writeIO", "vmDS_finalIO", "vmDS_readLatency", "vmDS_writeLatency", "vmDS_totalLatency", "vm_NetUsageRx", "vm_NetUsageTx", "vm_NetUsageTotal" ] #for i in range(0,len(vmState)): # if vmState[i] == "poweredOn" : # vmState[i] = 1 # else : # vmState[i] = 0 for i in range(0, len(vmName)): VMLogger.info( "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}" .format(collection_time, vmName[i], vmTemplate[i], vmPath[i], vmDSlocation[i], vmGuest[i], vmInstanceUUID[i], vmBioUUID[i], vmIP[i], VMwareTools[i], vmNumCPU[i], vmMemory[i], vmStatus[i], vmState[i], vmCPUready[i], vmCPUusage[i], vmMEMactive[i], vmMEMshared[i], vmMEMballoon[i], vmDS_readIO[i], vmDS_writeIO[i], vmDS_finalIO[i], vmDS_readLatency[i], vmDS_writeLatency[i], vmDS_totalLatency[i], vm_NetUsageRx[i], vm_NetUsageTx[i], vm_NetUsageTotal[i])) d["@Timestamp"] = collection_time d["vmName"] = vmName[i] d["vmTemplate"] = vmTemplate[i] d["vmGuest"] = vmGuest[i] d["vmInstanceUUID"] = vmInstanceUUID[i] d["vmBioUUID"] = vmBioUUID[i] d["vmIP"] = vmIP[i] d["VMwareTools"] = VMwareTools[i] #d["vmGuest1"] = vmGuest1 d["vmNumCPU"] = vmNumCPU[i] d["vmMemory"] = vmMemory[i] d["vmStatus"] = vmStatus[i] d["vmState"] = vmState[i] d["vmCPUready"] = vmCPUready[i] d["vmCPUusage"] = vmCPUusage[i] d["vmMEMactive"] = vmMEMactive[i] d["vmMEMshared"] = vmMEMshared[i] d["vmMEMballoon"] = vmMEMballoon[i] d["vmDS_readIO"] = vmDS_readIO[i] d["vmDS_writeIO"] = vmDS_writeIO[i] d["vmDS_finalIO"] = vmDS_finalIO[i] d["vmDS_readLatency"] = vmDS_readLatency[i] d["vmDS_writeLatency"] = vmDS_writeLatency[i] d["vmDS_totalLatency"] = vmDS_totalLatency[i] d["vm_NetUsageRx"] = vm_NetUsageRx[i] d["vm_NetUsageTx"] = vm_NetUsageTx[i] d["vm_NetUsageTotal"] = vm_NetUsageTotal[i] es.index(index="vm-index", doc_type="log", body=d) #dict_list.append(d) if printHost: hostProps = get_properties(content, [vim.HostSystem], ['name'], vim.HostSystem) hostNameLIST, hostModelLIST, hostCPULIST, hostCPUcoresLIST, hostnumThreadsLIST, hostMEMsizeLIST, hostCPUusageLIST, hostMEMusageLIST = ( [] for i in range(8)) for host in hostProps: #print("For Host :") #print("---------------------------------------------------------") host_moref = host['moref'] hostName, hostModel, hostCPU, hostCPUcores, hostnumThreads, hostMEMsize = host_core( host_moref) hostNameLIST.append(hostName) hostModelLIST.append(hostModel) hostCPULIST.append(hostCPU) hostCPUcoresLIST.append(hostCPUcores) hostnumThreadsLIST.append(hostnumThreads) hostMEMsizeLIST.append(hostMEMsize) hostCPUusage = host_cpu_usage(host_moref) hostCPUusageLIST.append(hostCPUusage) hostMEMusage = host_mem_usage(host_moref) hostMEMusageLIST.append(hostMEMusage) #print("Connected to VMware vCenter Server !") #print("hostNameLIST \n" , hostNameLIST) #print("hostModelLIST \n" , hostModelLIST) #print("hostCPULIST \n" , hostCPULIST) #print("hostnumThreadsLIST \n", hostnumThreadsLIST) #print("hostMEMsizeLIST \n" , hostMEMsizeLIST) #print("hostCPUusageLIST",hostCPUusageLIST) #print("hostMEMusageLIST\n",hostMEMusageLIST) printHost = False dh = {} for i in range(0, len(hostNameLIST)): dh["hostname"] = hostNameLIST[i] dh["host_model"] = hostModelLIST[i] dh["host_CPU"] = hostCPULIST[i] dh["host_CPU_core"] = hostCPUcoresLIST[i] dh["host_CPU_thread"] = hostnumThreadsLIST[i] dh["host_mem_size"] = hostMEMsizeLIST[i] dh["host_MEM_usage"] = hostMEMusageLIST[i] dh["host_CPU_usage"] = hostCPUusageLIST[i] HOSTlogger.info("{},{},{},{},{},{},{},{},{}".format( collection_time, hostNameLIST[i], hostModelLIST[i], hostCPULIST[i], hostCPUcoresLIST[i], hostnumThreadsLIST[i], hostMEMsizeLIST[i], hostMEMusageLIST[i], hostCPUusageLIST[i])) es.index(index="host-index", doc_type="log", body=dh) if printDatastore: dsProps = get_properties(content, [vim.Datastore], ['name'], vim.Datastore) dd = {} for datastore in dsProps: ds_moref = datastore['moref'] ds_status(ds_moref) datastore_name = datastore["name"] datastore_capacity, datastore_free, datastore_used_pct, datastore_uncommited_space = ds_space( ds_moref) datastore_name_lst.append(datastore_name) datastore_capacity_lst.append(datastore_capacity) datastore_free_lst.append(datastore_free) datastore_used_pct_lst.append(datastore_used_pct) datastore_uncommited_space_lst.append( datastore_uncommited_space) for i in range(0, len(datastore_name_lst)): dd["ds_name"] = datastore_name_lst[i] dd["ds_capacity"] = datastore_capacity_lst[i] dd["ds_free"] = datastore_free_lst[i] dd["ds_used_pct"] = datastore_used_pct_lst[i] dd["ds_uncommitted_space"] = datastore_uncommited_space_lst[i] DSlogger.info("{},{},{},{},{},{}".format( collection_time, datastore_name_lst[i], datastore_capacity_lst[i], datastore_free_lst[i], datastore_used_pct_lst[i], datastore_uncommited_space_lst[i])) es.index(index="datastore-index", doc_type="log", body=dd) if os.path.exists("/home/akhilesh/Desktop/vcenter_perfdic.txt"): os.remove('/home/akhilesh/Desktop/vcenter_perfdic.txt') if os.path.exists('/home/akhilesh/Desktop/host_perfdic.txt'): os.remove('/home/akhilesh/Desktop/host_perfdic.txt') Disconnect(si) endit() except IOError as e: print("I/O error({0}): {1}".format(e.errno, e.strerror))
vault = Vault(pswd) # Get login info from configuration file for NSX API. data = vault.load(open('login.yaml').read()) nsxhostname, nsxusr, nsxpw = data['NSX']['hostname'], data['NSX'][ 'username'], data['NSX']['password'] vchostname, vcusr, vcpw = data['vCenter']['hostname'], data['vCenter'][ 'username'], data['vCenter']['password'] s = ssl.SSLContext(ssl.PROTOCOL_TLSv1) s.verify_mode = ssl.CERT_NONE c = SmartConnect(host=vchostname, user=vcusr, pwd=vcpw, sslContext=s) print("Executed at System Time: " + str(c.CurrentTime())) datacenter = c.content.rootFolder.childEntity[0] vms = datacenter.vmFolder.childEntity # Build the MOID map. # VM methods - vCenter moidmap = {} for i in vms: moidmap[i.name] = str(i).split(":")[1][:-1] ## Core-NSX Methods # Security Tag Methods
def main(): args = viconfig.GetArgs() try: #vmnames = form['vmname'].value vmnames = ['LMC', 'Reach'] si = None print(args) if hasattr(ssl, "_create_unverified_context"): context = ssl._create_unverified_context() ssl._create_default_https_context = ssl._create_unverified_context if args['password']: password = args['password'] else: password = getpass.getpass( prompt="Enter password for host {} and user {}: ".format( args['host'], args['user'])) # try: si = SmartConnect(host=args['host'], user=args['user'], pwd=password, port=int(args['port'])) # except IOError as e: # pass # if not si: # print('Could not connect to the specified host using specified username and password') # return -1 atexit.register(Disconnect, si) content = si.RetrieveContent() # Get vCenter date and time for use as baseline when querying for counters vchtime = si.CurrentTime() # Get all the performance counters perf_dict = {} perfList = content.perfManager.perfCounter for counter in perfList: counter_full = "{}.{}.{}".format(counter.groupInfo.key, counter.nameInfo.key, counter.rollupType) perf_dict[counter_full] = counter.key retProps = GetProperties(content, [vim.VirtualMachine], ['name', 'runtime.powerState'], vim.VirtualMachine) #Find VM supplied as arg and use Managed Object Reference (moref) for the PrintVmInfo for vm in retProps: #object_dump (vm) print(vm['name'] + " => " + vm['runtime.powerState']) if (vm['name'] in vmnames) and (vm['runtime.powerState'] == "poweredOn"): PrintVmInfo(vm['moref'], content, vchtime, int(form['vminterval']), perf_dict) elif vm['name'] in vmnames: print( 'ERROR: Problem connecting to Virtual Machine. {} is likely powered off or suspended' .format(vm['name'])) except vmodl.MethodFault as e: print('Caught vmodl fault : ' + e.msg) return -1 except Exception as e: print('Caught exception : ' + str(e)) return -1 return 0
class vCenter(object): def __init__(self, server, username, password, disable_ssl_verification): self.server = server self.username = username self.password = password self.disable_ssl_verification = disable_ssl_verification self.serviceInstance = None try: if disable_ssl_verification: self.serviceInstance = SmartConnectNoSSL(host=self.server, user=self.username, pwd=self.password) else: self.serviceInstance = SmartConnect(host=self.server, user=self.username, pwd=self.password) atexit.register(Disconnect, self.serviceInstance) except IOError as e: print(e) pass if not self.serviceInstance: raise SystemExit("Unable to connect to host with supplied info.") self.pbm_content = vsadmin.tools.vsanStoragePolicy.PbmConnect( self.serviceInstance._stub, self.disable_ssl_verification) self.pm = self.pbm_content.profileManager self.lastnetworkinfokey = self.get_customfield_key('LastNetworkInfo') self.vchtime = self.serviceInstance.CurrentTime() apiVersion = vsadmin.tools.vsanapiutils.GetLatestVmodlVersion( self.server) vcMos = vsadmin.tools.vsanapiutils.GetVsanVcMos( self.serviceInstance._stub, version=apiVersion) self.vsanPerfSystem = vcMos['vsan-performance-manager'] # Get all the performance counters self.perf_dict = {} perfList = self.serviceInstance.content.perfManager.perfCounter for counter in perfList: counter_full = "{}.{}.{}".format(counter.groupInfo.key, counter.nameInfo.key, counter.rollupType) self.perf_dict[counter_full] = counter.key def get_metric_with_instance(self, content, vm, vchtime, interval): perfManager = content.perfManager startTime = vchtime - timedelta(minutes=(interval + 1)) endTime = vchtime - timedelta(minutes=1) metricId = perfManager.QueryAvailablePerfMetric( vm, startTime, endTime, interval) return metricId def get_virtualdisk_scsi(self, vm, virtualdisk): controllerID = virtualdisk.controllerKey unitNumber = virtualdisk.unitNumber vm_hardware = vm.config.hardware for vm_hardware_device in vm_hardware.device: if vm_hardware_device.key == controllerID: busNumber = vm_hardware_device.busNumber return "scsi{}:{}".format(busNumber, unitNumber) def build_vsan_perf_query(self, content, vchtime, counterId, instance, vm, interval): perfManager = content.perfManager metricId = vim.PerformanceManager.MetricId(counterId=counterId, instance=instance) startTime = vchtime - timedelta(minutes=(interval + 1)) endTime = vchtime - timedelta(minutes=1) spec = vim.cluster.VsanPerfQuerySpec(interval=20, endTime=endTime, entityRefId=entity, labels=labels, startTime=startTime) query = vim.PerformanceManager.QuerySpec(intervalId=20, entity=vm, metricId=[metricId], startTime=startTime, endTime=endTime) perfResults = perfManager.QueryPerf(querySpec=[query]) if perfResults: return perfResults else: print("ERROR: Performance results empty." "TIP: Check time drift on source and vCenter server") print("Troubleshooting info:") print("vCenter/host date and time: {}".format(vchtime)) print("Start perf counter time : {}".format(startTime)) print("End perf counter time : {}".format(endTime)) print(query) sys.exit(1) def build_perf_query(self, content, vchtime, counterId, instance, vm, interval): perfManager = content.perfManager metricId = vim.PerformanceManager.MetricId(counterId=counterId, instance=instance) startTime = vchtime - timedelta(minutes=(interval + 1)) endTime = vchtime - timedelta(minutes=1) query = vim.PerformanceManager.QuerySpec(intervalId=20, entity=vm, metricId=[metricId], startTime=startTime, endTime=endTime) perfResults = perfManager.QueryPerf(querySpec=[query]) if perfResults: return perfResults else: print("ERROR: Performance results empty." "TIP: Check time drift on source and vCenter server") print("Troubleshooting info:") print("vCenter/host date and time: {}".format(vchtime)) print("Start perf counter time : {}".format(startTime)) print("End perf counter time : {}".format(endTime)) print(query) sys.exit(1) def stat_check(self, perf_dict, counter_name): counter_key = perf_dict[counter_name] return counter_key def print_folder_tree(self, vm): entity = vm folder_tree = [] while entity.parent.name != 'vm': if isinstance(entity.parent, vim.Folder): folder_tree = [entity.parent.name] + folder_tree entity = entity.parent folder_tree = "/" + "/".join(folder_tree) return folder_tree @staticmethod def get_moref(obj): return str(obj).split(":")[1].strip("'") def get_customfield_key(self, name): customFieldsManager = self.serviceInstance.RetrieveContent( ).customFieldsManager customfield = next( (item for item in customFieldsManager.field if item.name == name), None) if customfield is not None: return customfield.key else: return None def print_vm_info(self, vm, interval=20, verbose=False): statInt = interval * 3 # There are 3 20s samples in each minute summary = vm.summary disk_list = [] vm_hardware = vm.config.hardware for each_vm_hardware in vm_hardware.device: if (each_vm_hardware.key >= 2000) and (each_vm_hardware.key < 3000): if summary.runtime.powerState == "poweredOn" and verbose: # VirtualDisk Average IO statVirtualdiskIORead = self.build_perf_query( self.serviceInstance.content, self.vchtime, self.stat_check( self.perf_dict, 'virtualDisk.numberReadAveraged.average'), self.get_virtualdisk_scsi(vm, each_vm_hardware), vm, statInt) VirtualdiskIORead = ( float(sum(statVirtualdiskIORead[0].value[0].value)) / statInt) statVirtualdiskIOWrite = self.build_perf_query( self.serviceInstance.content, self.vchtime, self.stat_check( self.perf_dict, 'virtualDisk.numberWriteAveraged.average'), self.get_virtualdisk_scsi(vm, each_vm_hardware), vm, statInt) VirtualdiskIOWrite = ( float(sum(statVirtualdiskIOWrite[0].value[0].value)) / statInt) # VirtualDisk Average Latency statVirtualdiskLatRead = self.build_perf_query( self.serviceInstance.content, self.vchtime, self.stat_check( self.perf_dict, 'virtualDisk.totalReadLatency.average'), self.get_virtualdisk_scsi(vm, each_vm_hardware), vm, statInt) VirtualdiskLatRead = ( float(sum(statVirtualdiskLatRead[0].value[0].value)) / statInt) VirtualdiskLatRead = "{:.0f}".format( VirtualdiskLatRead ) if VirtualdiskLatRead < 25 else "{}{:.0f}{}".format( bcolors.FAIL, VirtualdiskLatRead, bcolors.ENDC) statVirtualdiskLatWrite = self.build_perf_query( self.serviceInstance.content, self.vchtime, self.stat_check( self.perf_dict, 'virtualDisk.totalWriteLatency.average'), self.get_virtualdisk_scsi(vm, each_vm_hardware), vm, statInt) VirtualdiskLatWrite = ( float(sum(statVirtualdiskLatWrite[0].value[0].value)) / statInt) VirtualdiskLatWrite = "{:.0f}".format( VirtualdiskLatWrite ) if VirtualdiskLatWrite < 25 else "{}{:.0f}{}".format( bcolors.FAIL, VirtualdiskLatWrite, bcolors.ENDC) if each_vm_hardware.backing.datastore.summary.type != 'vsan': # Datastore Average IO statDatastoreIORead = self.build_perf_query( self.serviceInstance.content, self.vchtime, self.stat_check( self.perf_dict, 'datastore.numberReadAveraged.average'), each_vm_hardware.backing.datastore.info.vmfs.uuid, vm, statInt) DatastoreIORead = ( float(sum(statDatastoreIORead[0].value[0].value)) / statInt) statDatastoreIOWrite = self.build_perf_query( self.serviceInstance.content, self.vchtime, self.stat_check( self.perf_dict, 'datastore.numberWriteAveraged.average'), each_vm_hardware.backing.datastore.info.vmfs.uuid, vm, statInt) DatastoreIOWrite = (float( sum(statDatastoreIOWrite[0].value[0].value)) / statInt) # Datastore Average Latency statDatastoreLatRead = self.build_perf_query( self.serviceInstance.content, self.vchtime, self.stat_check( self.perf_dict, 'datastore.totalReadLatency.average'), each_vm_hardware.backing.datastore.info.vmfs.uuid, vm, statInt) DatastoreLatRead = (float( sum(statDatastoreLatRead[0].value[0].value)) / statInt) DatastoreLatRead = "{:.0f}".format( DatastoreLatRead ) if DatastoreLatRead < 25 else "{}{:.0f}{}".format( bcolors.FAIL, DatastoreLatRead, bcolors.ENDC) statDatastoreLatWrite = self.build_perf_query( self.serviceInstance.content, self.vchtime, self.stat_check( self.perf_dict, 'datastore.totalWriteLatency.average'), each_vm_hardware.backing.datastore.info.vmfs.uuid, vm, statInt) DatastoreLatWrite = (float( sum(statDatastoreLatWrite[0].value[0].value)) / statInt) DatastoreLatWrite = "{:.0f}".format( DatastoreLatWrite ) if DatastoreLatWrite < 25 else "{}{:.0f}{}".format( bcolors.FAIL, DatastoreLatWrite, bcolors.ENDC) disk_list.append( 'Name: {} \r\n' ' Size: {:.1f} GB \r\n' ' Thin: {} \r\n' ' File: {}\r\n' ' VirtualDisk: IORead-{:.0f}, IOWrite-{:.0f}, Latency Read-{} ms, Latency Write-{} ms \r\n' ' Datastore: IORead-{:.0f}, IOWrite-{:.0f}, Latency Read-{} ms, Latency Write-{} ms' .format( each_vm_hardware.deviceInfo.label, each_vm_hardware.capacityInKB / 1024 / 1024, each_vm_hardware.backing.thinProvisioned, each_vm_hardware.backing.fileName, VirtualdiskIORead, VirtualdiskIOWrite, VirtualdiskLatRead, VirtualdiskLatWrite, DatastoreIORead, DatastoreIOWrite, DatastoreLatRead, DatastoreLatWrite)) else: pmObjectType = pbm.ServerObjectRef.ObjectType( "virtualDiskId") pmRef = pbm.ServerObjectRef(key="{}:{}".format( vm._moId, each_vm_hardware.key), objectType=pmObjectType) profiles = vsadmin.tools.vsanStoragePolicy.GetStorageProfiles( self.pm, pmRef) storagePolicy = vsadmin.tools.vsanStoragePolicy.ShowStorageProfile( profiles=profiles, verbose=True) disk_list.append( 'Name: {} \r\n' ' Size: {:.1f} GB \r\n' ' Thin: {} \r\n' ' File: {} \r\n' ' Storage Policy: {}' ' VirtualDisk: IORead-{:.0f}, IOWrite-{:.0f}, Latency Read-{} ms, Latency Write-{} ms \r\n' .format( each_vm_hardware.deviceInfo.label, each_vm_hardware.capacityInKB / 1024 / 1024, each_vm_hardware.backing.thinProvisioned, each_vm_hardware.backing.fileName, storagePolicy, VirtualdiskIORead, VirtualdiskIOWrite, VirtualdiskLatRead, VirtualdiskLatWrite)) # Memory Balloon statMemoryBalloon = self.build_perf_query( self.serviceInstance.content, self.vchtime, (self.stat_check(self.perf_dict, 'mem.vmmemctl.average')), "", vm, statInt) memoryBalloon = (float( sum(statMemoryBalloon[0].value[0].value) / 1024) / statInt) memoryBalloon = "{:.1f}".format( memoryBalloon ) if memoryBalloon <= 0 else "{}{:.1f}{}".format( bcolors.WARNING, memoryBalloon, bcolors.ENDC) # Memory Swapped statMemorySwapped = self.build_perf_query( self.serviceInstance.content, self.vchtime, (self.stat_check(self.perf_dict, 'mem.swapped.average')), "", vm, statInt) memorySwapped = (float( sum(statMemorySwapped[0].value[0].value) / 1024) / statInt) memorySwapped = "{:.1f}".format( memorySwapped ) if memorySwapped <= 0 else "{}{:.1f}{}".format( bcolors.FAIL, memorySwapped, bcolors.ENDC) memory = "{} MB ({:.1f} GB) [Ballooned: {} MB, Swapped: {} MB]".format( summary.config.memorySizeMB, (float(summary.config.memorySizeMB) / 1024), memoryBalloon, memorySwapped) else: if each_vm_hardware.backing.datastore.summary.type != 'vsan': disk_list.append( 'Name: {} \r\n' ' Size: {:.1f} GB \r\n' ' Thin: {} \r\n' ' File: {}'.format( each_vm_hardware.deviceInfo.label, each_vm_hardware.capacityInKB / 1024 / 1024, each_vm_hardware.backing.thinProvisioned, each_vm_hardware.backing.fileName)) else: pmObjectType = pbm.ServerObjectRef.ObjectType( "virtualDiskId") pmRef = pbm.ServerObjectRef(key="{}:{}".format( vm._moId, each_vm_hardware.key), objectType=pmObjectType) profiles = vsadmin.tools.vsanStoragePolicy.GetStorageProfiles( self.pm, pmRef) storagePolicy = vsadmin.tools.vsanStoragePolicy.ShowStorageProfile( profiles=profiles, verbose=False) disk_list.append( 'Name: {} \r\n' ' Size: {:.1f} GB \r\n' ' Thin: {} \r\n' ' File: {} \r\n' ' Storage Policy: {}'.format( each_vm_hardware.deviceInfo.label, each_vm_hardware.capacityInKB / 1024 / 1024, each_vm_hardware.backing.thinProvisioned, each_vm_hardware.backing.fileName, storagePolicy)) memory = "{} MB ({:.1f} GB)".format( summary.config.memorySizeMB, (float(summary.config.memorySizeMB) / 1024)) guestToolsRunningStatus = "{}{}{}".format( bcolors.OKGREEN, "Running", bcolors.ENDC ) if vm.guest.toolsRunningStatus == "guestToolsRunning" else "{}{}{}".format( bcolors.FAIL, "Not running", bcolors.ENDC) guestToolsStatus = "{}{}{}".format( bcolors.OKGREEN, "OK", bcolors.ENDC ) if vm.guest.toolsStatus == "toolsOk" else "{}{}{}".format( bcolors.FAIL, "Need Attention", bcolors.ENDC) guestToolsVersionStatus = "{}{}{}".format( bcolors.OKGREEN, "Current", bcolors.ENDC ) if vm.guest.toolsVersionStatus == "guestToolsCurrent" else "{}{}{}".format( bcolors.WARNING, "Need upgrade", bcolors.ENDC) guestToolsVersion = vm.guest.toolsVersion powerStatus = "{}{}{}".format( bcolors.OKGREEN, summary.runtime.powerState, bcolors.ENDC ) if summary.runtime.powerState == "poweredOn" else "{}{}{}".format( bcolors.FAIL, summary.runtime.powerState, bcolors.ENDC) print("UUID : {}".format(summary.config.instanceUuid)) print("Name : {}".format(summary.config.name)) print("VMRC : vmrc://{}:443/?moid={}".format( self.server, self.get_moref(vm))) print("Guest : {}".format(summary.config.guestFullName)) print("State : {}".format(powerStatus)) print( "Guest Tools Status : Status: {} | Version Status: {} | Version: {} | Health: {}" .format(guestToolsRunningStatus, guestToolsVersionStatus, guestToolsVersion, guestToolsStatus)) print("Cluster : {}".format( summary.runtime.host.parent.name)) print("Host : {}".format(summary.runtime.host.name)) print("Folder : {}".format(self.print_folder_tree(vm))) print("Number of vCPUs : {}".format(summary.config.numCpu)) print("Memory : {}".format(memory)) print("VM .vmx Path : {}".format(summary.config.vmPathName)) vmxDatastoreName = re.match(r'\[(.*)\]', summary.config.vmPathName).group(1) vmxDatastore = self.find_datastore_by_name(vmxDatastoreName) if vmxDatastore.summary.type == 'vsan': pmObjectType = pbm.ServerObjectRef.ObjectType("virtualMachine") pmRef = pbm.ServerObjectRef(key=vm._moId, objectType=pmObjectType) profiles = vsadmin.tools.vsanStoragePolicy.GetStorageProfiles( self.pm, pmRef) storagePolicy = vsadmin.tools.vsanStoragePolicy.ShowStorageProfile( profiles=profiles, verbose=verbose) print(" Storage Policy: {}".format( storagePolicy)) print("Virtual Disks :") if len(disk_list) > 0: first = True for each_disk in disk_list: if first: first = False else: print("") print(" {}".format(each_disk)) if vm.guest.net != []: print("Network : ") for card in vm.guest.net: print(" Name: {}".format(card.network)) if card.deviceConfigId != -1: hwdevice = next((item for item in vm.config.hardware.device if item.key == card.deviceConfigId), None) print(" Connected: {}".format( hwdevice.connectable.connected)) print(" Mac: {}".format(card.macAddress)) if card.ipConfig is not None: for ips in card.ipConfig.ipAddress: print(" IP: {}".format( ips.ipAddress)) print("") if vm.guest.ipStack != []: for gateway in vm.guest.ipStack[0].ipRouteConfig.ipRoute: if gateway.network == '0.0.0.0': print(" Default GW: {}".format( gateway.gateway.ipAddress)) print("") print("Guest Hostname : {}".format( vm.guest.ipStack[0].dnsConfig.hostName)) print("DNS :") for dns in vm.guest.ipStack[0].dnsConfig.ipAddress: print(" Address: {}".format(dns)) print(" Search Domain: {}".format( vm.guest.ipStack[0].dnsConfig.domainName)) customfields = next((item for item in summary.customValue if item.key == self.lastnetworkinfokey), None) if customfields is not None and customfields.value != "": print("Last Network Info : {}".format(customfields.value)) if summary.runtime.question is not None: print("Question : {}".format(summary.runtime.question.text)) annotation = summary.config.annotation if annotation is not None and annotation != "": print("Notes : {}".format(annotation)) # print(self.vsanPerfSystem.VsanPerfGetSupportedEntityTypes()) # metrics = self.get_metric_with_instance(self.serviceInstance.content, vm, self.vchtime, interval) # for metric in metrics: # print("ID: {}, Instance: {}".format(self.perf_dict.keys()[self.perf_dict.values().index(metric.counterId)], metric.instance)) def get_all_objs(self, vimtype, folder=None, recurse=True): if not folder: folder = self.serviceInstance.content.rootFolder obj = {} container = self.serviceInstance.content.viewManager.CreateContainerView( folder, vimtype, recurse) for managed_object_ref in container.view: obj.update({managed_object_ref: managed_object_ref.name}) return obj def find_object_by_name(self, name, obj_type, folder=None, recurse=True): if not isinstance(obj_type, list): obj_type = [obj_type] objects = self.get_all_objs(obj_type, folder=folder, recurse=recurse) for obj in objects: if obj.name == name: return obj return None def find_datastore_by_name(self, datastore_name): return self.find_object_by_name(datastore_name, [vim.Datastore]) def search_vm_by_name(self, name, name_contain=False): content = self.serviceInstance.content root_folder = content.rootFolder # entity_stack = root_folder.childEntity objView = content.viewManager.CreateContainerView( root_folder, [vim.VirtualMachine], True) vmList = objView.view objView.Destroy() obj = [] for vm in vmList: if not name_contain: if (vm.name == name): obj.append(vm) return obj else: if re.match(".*%s.*" % name, vm.name): obj.append(vm) return obj def search_vm_by_ip(self, ip, custom_fields=False): obj = [] content = self.serviceInstance.content root_folder = content.rootFolder if not NetworkCheck.checkIP(ip): print("IP address {} is invalid.".format(ip)) return obj search_obj = content.searchIndex.FindByIp(None, ip, True) if search_obj: obj.append(search_obj) return obj elif custom_fields: objView = content.viewManager.CreateContainerView( root_folder, [vim.VirtualMachine], True) vmList = objView.view for vm in vmList: summary = vm.summary customfields = next((item for item in summary.customValue if item.key == self.lastnetworkinfokey), None) if customfields is not None and customfields.value != "": if ip in customfields.value: if vm not in obj: obj.append(vm) return obj def search_vm_by_mac(self, mac): obj = [] if not NetworkCheck.checkMAC(mac): print("MAC address {} is invalid.".format(mac)) return obj content = self.serviceInstance.content root_folder = content.rootFolder objView = content.viewManager.CreateContainerView( root_folder, [vim.VirtualMachine], True) vmList = objView.view objView.Destroy() for vm in vmList: vm_hardware = vm.config.hardware for each_vm_hardware in vm_hardware.device: if (each_vm_hardware.key >= 4000) and (each_vm_hardware.key < 5000): if re.search('.*{}.*'.format(mac), each_vm_hardware.macAddress): obj.append(vm) break return obj def search_vm_by_hostname(self, hostname): obj = [] search_obj = self.serviceInstance.content.searchIndex.FindByDnsName( None, hostname, True) if search_obj: obj.append(search_obj) return obj def search_vm_by_task(self, task): content = self.serviceInstance.content root_folder = content.rootFolder objView = content.viewManager.CreateContainerView( root_folder, [vim.VirtualMachine], True) vmList = objView.view objView.Destroy() obj = [] for vm in vmList: if vm.summary.config.annotation and vm.summary.config.annotation != "": if re.search('.*{}.*'.format(task), vm.summary.config.annotation): obj.append(vm) return obj
def main(): global content, hosts, hostPgDict host, user, password = GetArgs() #host = '10.0.0.125' #user = '******' #password = '******' serviceInstance = SmartConnect(host=host, user=user, pwd=password, port=443) atexit.register(Disconnect, serviceInstance) content = serviceInstance.RetrieveContent() vchtime = serviceInstance.CurrentTime() hosts = GetVMHosts(content) perfManager = content.perfManager #print(' ------------ End of perfManager--------------') perfCounters = perfManager.perfCounter #print(' perfCounter is %s \n' % (perfCounters)) # Get all the performance counters perf_dict = {} perfList = perfManager.perfCounter for counter in perfList: counter_full = "{}.{}.{}".format(counter.groupInfo.key, counter.nameInfo.key, counter.rollupType) perf_dict[counter_full] = counter.key #print( 'perf_dict is %s \n\n' % (perf_dict)) #print('-------perf Dict --------') #pprint.pprint(perf_dict) interval = 20 print('Hosts is %s \n ' % (hosts)) for host in hosts: #if host.name == 'swiesxi6.steinwall.lan': #print('Host Perf provide summary is %s \n' % (perfManager.QueryPerfProviderSummary(host))) print('Host is %s name is %s \n' % (host, host.name)) # Note that BuildQuery will return a list so need to use sum function statSysUpTimeMaxSample = BuildQueryMaxSample( perfManager, (StatCheck(perf_dict, 'sys.uptime.latest')), "", host, interval) statSysUpTimeVchtime = BuildQueryVchtime( perfManager, vchtime, (StatCheck(perf_dict, 'sys.uptime.latest')), "", host, interval) if statSysUpTimeMaxSample and statSysUpTimeVchtime: #print('statSysUpTime is %s \n' % (statSysUpTime)) sysUpTimeMaxSample = float( sum(statSysUpTimeMaxSample[0].value[0].value)) sysUpTimeVchtime = float( sum(statSysUpTimeVchtime[0].value[0].value)) print(' sysUpTimeMaxSample is %s and sysUpTimeVchtime is %s \n' % (sysUpTimeMaxSample, sysUpTimeVchtime)) statCpuUsageVchtime = BuildQueryVchtime( perfManager, vchtime, (StatCheck(perf_dict, 'cpu.usage.average')), "", host, interval) statCpuUsageMaxSample = BuildQueryMaxSample( perfManager, (StatCheck(perf_dict, 'cpu.usage.average')), "", host, interval) if statCpuUsageMaxSample and statCpuUsageVchtime: cpuUsageMaxSample = ( float(sum(statCpuUsageMaxSample[0].value[0].value)) / 100) cpuUsageVchtime = ( float(sum(statCpuUsageVchtime[0].value[0].value)) / 100) print(' cpuUsageMaxSample is %s and cpuUsageVchtime is %s \n' % (cpuUsageMaxSample, cpuUsageVchtime)) statMemoryActiveVchtime = BuildQueryVchtime( perfManager, vchtime, (StatCheck(perf_dict, 'mem.active.maximum')), "", host, interval) statMemoryActiveMaxSample = BuildQueryMaxSample( perfManager, (StatCheck(perf_dict, 'mem.active.maximum')), "", host, interval) if statMemoryActiveMaxSample and statMemoryActiveVchtime: MemoryActiveMaxSample = ( float(sum(statMemoryActiveMaxSample[0].value[0].value)) * 1024) MemoryActiveVchtime = ( float(sum(statMemoryActiveVchtime[0].value[0].value)) * 1024) print( ' MemoryActiveMaxSample is %s and MemoryActiveVchtime is %s \n' % (MemoryActiveMaxSample, MemoryActiveVchtime)) vms = GetVMs(content) print(' ---------Virtual Machines-----------') for vm in vms: #print('VM is %s name is %s \n' % (vm, vm.name)) #print('VM runtime.powerState is %s \n' % (vm.runtime.powerState)) #print('VM summary.overallStatus is %s \n' % (vm.summary.overallStatus)) #print('VM Perf provide summary is %s \n' % (perfManager.QueryPerfProviderSummary(vm))) #if vm.runtime.powerState == 'poweredOn' and vm.name == 'SWIDVM33': if vm.runtime.powerState == 'poweredOn' and 'SWIDVM3' in vm.name: print('VM is %s name is %s \n' % (vm, vm.name)) print('VM runtime.powerState is %s \n' % (vm.runtime.powerState)) print('VM summary.overallStatus is %s \n' % (vm.summary.overallStatus)) statSysUpTimeVchtime = BuildQueryVchtime( perfManager, vchtime, (StatCheck(perf_dict, 'sys.uptime.latest')), "", vm, interval) statSysUpTimeMaxSample = BuildQueryMaxSample( perfManager, (StatCheck(perf_dict, 'sys.uptime.latest')), "", vm, interval) if statSysUpTimeMaxSample and statSysUpTimeVchtime: sysUpTimeMaxSample = float( sum(statSysUpTimeMaxSample[0].value[0].value)) sysUpTimeVchtime = float( sum(statSysUpTimeVchtime[0].value[0].value)) print( ' sysUpTimeMaxSample is %s and sysUpTimeVchtime is %s \n' % (sysUpTimeMaxSample, sysUpTimeVchtime)) statCpuUsageVchtime = BuildQueryVchtime( perfManager, vchtime, (StatCheck(perf_dict, 'cpu.usagemhz.average')), "", vm, interval) statCpuUsageMaxSample = BuildQueryMaxSample( perfManager, (StatCheck(perf_dict, 'cpu.usagemhz.average')), "", vm, interval) if statCpuUsageMaxSample and statCpuUsageVchtime: cpuUsageMaxSample = ( float(sum(statCpuUsageMaxSample[0].value[0].value)) * 1000000) cpuUsageVchtime = ( float(sum(statCpuUsageVchtime[0].value[0].value)) * 1000000) print(' cpuUsageMaxSample is %s and cpuUsagVchtime is %s \n' % (cpuUsageMaxSample, cpuUsageVchtime)) statCpuUsageAvgVchtime = BuildQueryVchtime( perfManager, vchtime, (StatCheck(perf_dict, 'cpu.usage.average')), "", vm, interval) statCpuUsageAvgMaxSample = BuildQueryMaxSample( perfManager, (StatCheck(perf_dict, 'cpu.usage.average')), "", vm, interval) if statCpuUsageAvgMaxSample and statCpuUsageAvgVchtime: cpuUsageAvgMaxSample = ( float(sum(statCpuUsageAvgMaxSample[0].value[0].value)) / 100) cpuUsageAvgVchtime = ( float(sum(statCpuUsageAvgVchtime[0].value[0].value)) / 100) print( ' cpuUsageAvgMaxSample is %s and cpuUsageAvgVchtime is %s \n' % (cpuUsageAvgMaxSample, cpuUsageAvgVchtime)) statMemUsageVchtime = BuildQueryVchtime( perfManager, vchtime, (StatCheck(perf_dict, 'mem.usage.minimum')), "", vm, interval) statMemUsageMaxSample = BuildQueryMaxSample( perfManager, (StatCheck(perf_dict, 'mem.usage.minimum')), "", vm, interval) if statMemUsageMaxSample and statMemUsageVchtime: #print(' statMemUsage is %s \n' % (statMemUsage)) memUsageMaxSample = ( float(sum(statMemUsageMaxSample[0].value[0].value)) / 100) memUsageVchtime = ( float(sum(statMemUsageVchtime[0].value[0].value)) / 100) print(' memUsageMaxSample is %s and memUsageVchtime is %s \n' % (memUsageMaxSample, memUsageVchtime)) statMemConsumedVchtime = BuildQueryVchtime( perfManager, vchtime, (StatCheck(perf_dict, 'mem.consumed.minimum')), "", vm, interval) statMemConsumedMaxSample = BuildQueryMaxSample( perfManager, (StatCheck(perf_dict, 'mem.consumed.minimum')), "", vm, interval) if statMemConsumedMaxSample and statMemConsumedVchtime: memConsumedMaxSample = ( float(sum(statMemConsumedMaxSample[0].value[0].value)) * 1024) memConsumedVchtime = ( float(sum(statMemConsumedVchtime[0].value[0].value)) * 1024) print( ' memConsumedMaxSample is %s and memConsumedVchtime is %s \n' % (memConsumedMaxSample, memConsumedVchtime)) datastores = GetDatastores(content) """
# VMware vSphere Python SDK, pyvmomi # Simple script to get vCenter server product details # Written By Sai Krishna # Email : [email protected] from pyVim.connect import SmartConnect, Disconnect import ssl s = ssl.SSLContext(ssl.PROTOCOL_SSLv23) # For VC 6.5/6.0 s=ssl.SSLContext(ssl.PROTOCOL_TLSv1) s.verify_mode = ssl.CERT_NONE si = SmartConnect(host=input("Enter IP or FQDN of ESXi or VCSA : "), user=input("Enter User : "******"Enter The Password : "******"Time On VC :") print(si.CurrentTime()) print("*"*36) print("Product Name:", aboutInfo.fullName) print("Product Build:", aboutInfo.build) print("Product Unique Id:", aboutInfo.instanceUuid) print("Product Version:", aboutInfo.version) print("Product Base OS:", aboutInfo.osType) print("Product vendor:", aboutInfo.vendor) Disconnect(si)
def main(): # config file parsing parser = argparse.ArgumentParser() parser.add_argument("-c", "--config", help="Specify config file", metavar="FILE") parser.add_argument("-d", "--datastore", help="Get metrics for datastores instead of vms", action='store_true') args, remaining_argv = parser.parse_known_args() config = YamlConfig(args.config, defaults) # list of vm properties we are using and which we get via property collector later # see: http://goo.gl/fjTEpW for all properties. # once for vms and once for datastores ... and some other stuff, which differs for the two cases if args.datastore == False: my_properties = [ "runtime.powerState", "runtime.host", "config.annotation", "config.name", "config.instanceUuid", "config.guestId", "summary.config.vmPathName" ] my_name = "vm" my_obj_type = vim.VirtualMachine else: my_properties = [ "summary.accessible", "summary.capacity", "summary.freeSpace", "summary.maintenanceMode", "summary.name", "summary.type", "summary.url", "overallStatus" ] my_name = "datastore" my_obj_type = vim.Datastore # set default log level if not defined in config file if config.get('main').get('log'): logger.setLevel( logging.getLevelName(config.get('main').get('log').upper())) else: logger.setLevel('INFO') FORMAT = '[%(asctime)s] [%(levelname)s] %(message)s' logging.basicConfig(stream=sys.stdout, format=FORMAT) # check for insecure ssl option si = None context = None if config.get('main').get('ignore_ssl') and \ hasattr(ssl, "_create_unverified_context"): context = ssl._create_unverified_context() # connect to vcenter try: si = SmartConnect(host=config.get('main').get('host'), user=config.get('main').get('user'), pwd=config.get('main').get('password'), port=int(config.get('main').get('port')), sslContext=context) atexit.register(Disconnect, si) except IOError as e: logging.error("Could not connect to vcenter." + e) if not si: raise SystemExit("Unable to connect to host with supplied info.") content = si.RetrieveContent() perfManager = content.perfManager # get the datacenter info datacenter = si.content.rootFolder.childEntity[0] datacentername = datacenter.name logging.debug('datacenter name: ' + datacentername) # create a list of vim.VirtualMachine / vim.Datastore objects so that we can query them for statistics container = content.rootFolder viewType = [my_obj_type] recursive = True # initialize some variables counterInfo = {} gauge = {} # time intervall to average vcenter data across in seconds interval = int(config.get('main').get('interval')) # compile a regex for trying to filter out openstack generated vms - they all have the "name:" field set openstack_match_regex = re.compile("^name:") # compile a regex for stripping out not required parts of hostnames etc. to have shorter label names (for better grafana display) if config.get('main').get('shorter_names_regex'): shorter_names_regex = re.compile( config.get('main').get('shorter_names_regex')) else: shorter_names_regex = re.compile('') logging.debug("name shortening regex: " + str(config.get('main').get('shorter_names_regex'))) # compile a regex for matching the vcenter_node name, so that we can deal only with the matching node or bb with this vcenter-exporter if config.get('main').get('host_match_regex'): host_match_regex = re.compile( config.get('main').get('host_match_regex')) else: host_match_regex = re.compile('') logging.debug("vcenter_node name (host) regex: " + str(config.get('main').get('host_match_regex'))) # compile a regex for matching the vmware_name against machines we do not want to collect metrics for (canary, blackbox vms etc.) if config.get('main').get('ignore_match_regex'): ignore_match_regex = re.compile( config.get('main').get('ignore_match_regex')) else: ignore_match_regex = re.compile( 'this_string_will_definitely_not_match_any_vmware_name') logging.debug("vmware name ignore regex: " + str(config.get('main').get('ignore_match_regex'))) # create a mapping from performance stats to their counterIDs # counterInfo: [performance stat => counterId] # performance stat example: cpu.usagemhz.LATEST # counterId example: 6 # level defines the amounts of metrics available and its default setting in the vcenter here is 1 counterids = perfManager.QueryPerfCounterByLevel(level=4) # start up the http server to expose the prometheus metrics start_http_server(int(config.get('main').get('listen_port'))) if args.datastore == False: logging.debug('list of all available metrics and their counterids') # loop over all counterids and build their full name and a dict relating it to the ids for c in counterids: fullName = c.groupInfo.key + "." + c.nameInfo.key + "." + c.rollupType logging.debug(fullName + ': ' + str(c.key)) counterInfo[fullName] = c.key # define a dict of vm gauges for the counter ids gauge['vcenter_' + fullName.replace('.', '_')] = Gauge( 'vcenter_' + fullName.replace('.', '_'), 'vcenter_' + fullName.replace('.', '_'), [ 'vmware_name', 'project_id', 'vcenter_name', 'vcenter_node', 'instance_uuid', 'guest_id', 'datastore', 'metric_detail' ]) # in case we have a configured set of metrics to handle, use those - otherwise use all we can get selected_metrics = config.get('main').get('vm_metrics') if selected_metrics: counterIDs = [ counterInfo[i] for i in selected_metrics if i in counterInfo ] else: counterIDs = [i.key for i in counterids] else: # define the gauges - they have to be defined by hand for the datastores, as there is no clear pattern behind gauge['vcenter_datastore_accessible'] = Gauge( 'vcenter_datastore_accessible', 'vcenter_datastore_accessible', ['datastore_name', 'datastore_type', 'datastore_url']) gauge['vcenter_datastore_capacity'] = Gauge( 'vcenter_datastore_capacity', 'vcenter_datastore_capacity', ['datastore_name', 'datastore_type', 'datastore_url']) gauge['vcenter_datastore_freespace'] = Gauge( 'vcenter_datastore_freespace', 'vcenter_datastore_freespace', ['datastore_name', 'datastore_type', 'datastore_url']) gauge['vcenter_datastore_maintenancemode'] = Gauge( 'vcenter_datastore_maintenancemode', 'vcenter_datastore_maintenancemode', ['datastore_name', 'datastore_type', 'datastore_url']) gauge['vcenter_datastore_overallstatus'] = Gauge( 'vcenter_datastore_overallstatus', 'vcenter_datastore_overallstatus', ['datastore_name', 'datastore_type', 'datastore_url']) # infinite loop for getting the metrics while True: logging.debug('====> total loop start: %s' % datetime.now()) # get the start time of the loop to be able to fill it to intervall exactly at the end loop_start_time = int(time.time()) # first the vm metric case if args.datastore == False: # get all the data regarding vcenter hosts hostView = content.viewManager.CreateContainerView( container, [vim.HostSystem], recursive) hostssystems = hostView.view # build a dict to lookup the hostname by its id later hostsystemsdict = {} for host in hostssystems: hostsystemsdict[host] = host.name logging.debug( 'list of all available vcenter nodes and their internal id') logging.debug(hostsystemsdict) # collect the properties we are interested in view = get_container_view(si, obj_type=[my_obj_type]) my_data = collect_properties(si, view_ref=view, obj_type=my_obj_type, path_set=my_properties, include_mors=True) my_count = 0 # define the time range in seconds the metric data from the vcenter should be averaged across # all based on vcenter time vchtime = si.CurrentTime() startTime = vchtime - timedelta(seconds=(interval + 60)) endTime = vchtime - timedelta(seconds=60) # loop over all vmware machines for item in my_data: try: if args.datastore == False: # only consider machines which have an annotation, are powered on, match our regex for the host system and are not in the ignore list if (item["runtime.powerState"] == "poweredOn" and openstack_match_regex.match( item["config.annotation"]) and host_match_regex.match( hostsystemsdict[item["runtime.host"]]) ) and not ignore_match_regex.match( item["config.name"]): logging.debug('current vm processed - ' + item["config.name"]) logging.debug('==> running on vcenter node: ' + hostsystemsdict[item["runtime.host"]]) # split the multi-line annotation into a dict per property (name, project-id, ...) annotation_lines = item["config.annotation"].split( '\n') # rename flavor: to flavor_, so that it does not break the split on : below annotation_lines = [ w.replace('flavor:', 'flavor_') for w in annotation_lines ] # the filter is for filtering out empty lines annotations = dict( s.split(':', 1) for s in filter(None, annotation_lines)) # datastore name datastore = item["summary.config.vmPathName"].split( '[', 1)[1].split(']')[0] # get a list of metricids for this vm in preparation for the stats query metricIDs = [ vim.PerformanceManager.MetricId(counterId=i, instance="*") for i in counterIDs ] # query spec for the metric stats query, the intervalId is the default one logging.debug( '==> vim.PerformanceManager.QuerySpec start: %s' % datetime.now()) spec = vim.PerformanceManager.QuerySpec( maxSample=1, entity=item["obj"], metricId=metricIDs, intervalId=20, startTime=startTime, endTime=endTime) logging.debug( '==> vim.PerformanceManager.QuerySpec end: %s' % datetime.now()) # get metric stats from vcenter logging.debug('==> perfManager.QueryStats start: %s' % datetime.now()) result = perfManager.QueryStats(querySpec=[spec]) logging.debug('==> perfManager.QueryStats end: %s' % datetime.now()) # loop over the metrics logging.debug('==> gauge loop start: %s' % datetime.now()) for val in result[0].value: # send gauges to prometheus exporter: metricname and value with # labels: vm name, project id, vcenter name, vcneter # node, instance uuid and metric detail (for instance a partition # for io or an interface for net metrics) - we update the gauge # only if the value is not -1 which means the vcenter has no value if val.value[0] != -1: if val.id.instance == '': metric_detail = 'total' else: metric_detail = val.id.instance gauge['vcenter_' + counterInfo.keys()[counterInfo.values( ).index(val.id.counterId)].replace( '.', '_')].labels( annotations['name'], annotations['projectid'], datacentername, shorter_names_regex.sub( '', hostsystemsdict[ item["runtime.host"]]), item["config.instanceUuid"], item["config.guestId"], datastore, metric_detail).set(val.value[0]) logging.debug('==> gauge loop end: %s' % datetime.now()) # alternatively the datastore metric case else: logging.debug('current datastore processed - ' + item["summary.name"]) logging.debug('==> accessible: ' + str(item["summary.accessible"])) # convert strings to numbers, so that we can generate a prometheus metric from them if item["summary.accessible"] == True: number_accessible = 1 else: number_accessible = 0 logging.debug('==> capacity: ' + str(item["summary.capacity"])) logging.debug('==> freeSpace: ' + str(item["summary.freeSpace"])) logging.debug('==> maintenanceMode: ' + str(item["summary.maintenanceMode"])) # convert strings to numbers, so that we can generate a prometheus metric from them if item["summary.maintenanceMode"] == "normal": number_maintenanceMode = 0 else: # fallback to note if we do not yet catch a value number_maintenanceMode = -1 logging.info( 'unexpected maintenanceMode for datastore ' + item["summary.name"]) logging.debug('==> type: ' + str(item["summary.type"])) logging.debug('==> url: ' + str(item["summary.url"])) logging.debug('==> overallStatus: ' + str(item["overallStatus"])) # convert strings to numbers, so that we can generate a prometheus metric from them if item["overallStatus"] == "green": number_overallStatus = 0 elif item["overallStatus"] == "yellow": number_overallStatus = 1 elif item["overallStatus"] == "red": number_overallStatus = 2 else: # fallback to note if we do not yet catch a value number_overallStatus = -1 logging.info( 'unexpected overallStatus for datastore ' + item["summary.name"]) # set the gauges for the datastore properties logging.debug('==> gauge start: %s' % datetime.now()) gauge['vcenter_datastore_accessible'].labels( item["summary.name"], item["summary.type"], item["summary.url"]).set(number_accessible) gauge['vcenter_datastore_capacity'].labels( item["summary.name"], item["summary.type"], item["summary.url"]).set(item["summary.capacity"]) gauge['vcenter_datastore_freespace'].labels( item["summary.name"], item["summary.type"], item["summary.url"]).set(item["summary.freeSpace"]) gauge['vcenter_datastore_maintenancemode'].labels( item["summary.name"], item["summary.type"], item["summary.url"]).set(number_maintenanceMode) gauge['vcenter_datastore_overallstatus'].labels( item["summary.name"], item["summary.type"], item["summary.url"]).set(number_overallStatus) logging.debug('==> gauge end: %s' % datetime.now()) my_count += 1 except IndexError: logging.info('a ' + my_name + ' disappeared during processing') loop_end_time = int(time.time()) logging.info('number of ' + my_name + 's we got metrics for: ' + str(my_count) + ' - actual runtime: ' + str(loop_end_time - loop_start_time) + 's') # this is the time we sleep to fill the loop runtime until it reaches "interval" # the 0.9 makes sure we have some overlap to the last interval to avoid gaps in # metrics coverage (i.e. we get the metrics quicker than the averaging time) loop_sleep_time = 0.9 * interval - (loop_end_time - loop_start_time) if loop_sleep_time < 0: logging.warn( 'getting the metrics takes around ' + str(interval) + ' seconds or longer - please increase the interval setting') loop_sleep_time = 0 logging.debug('====> loop end before sleep: %s' % datetime.now()) time.sleep(int(loop_sleep_time)) logging.debug('====> total loop end: %s' % datetime.now())
class VSphereClient(object): """ Wrapper for Vsphere """ def __init__(self, admin_user, admin_password, auth_host, auth_port=443): self.admin_user = admin_user self.admin_password = admin_password self.auth_host = auth_host self.auth_port = auth_port self._vsphere_connection = None self._vsphere_content = None self._perfManager = None def set_configuration(self, admin_user, admin_password, auth_host, auth_port=443): self.admin_user = admin_user self.admin_password = admin_password self.auth_host = auth_host self.auth_port = auth_port def __repr__(self): return "<VSphereClient host='%s:%d' [%s] user='******' password='******'>" % \ (self.auth_host, self.auth_port, "On" if self._vsphere_connection is not None else "Off", self.admin_user, "*" * len(self.admin_password)) def __del__(self): self.close() def connect(self, reconnect=False, insecure=True): """ Create new authenticated VSphere client """ if self._vsphere_connection is None or reconnect: LOG.info('Connecting to vSphere server on %s:%s' % (self.auth_host, self.auth_port)) kwargs = {'host': self.auth_host, 'port': self.auth_port, 'user': self.admin_user, 'pwd': self.admin_password} vmomi_versions = sorted(pyVmomi_version.versionMap.keys()) LOG.debug("PyVmomi versions: %s", vmomi_versions) if insecure and ("vim25/6.5" in vmomi_versions or "vim25/6.0" in vmomi_versions): try: import ssl kwargs['sslContext'] = ssl._create_unverified_context() except (ImportError, AttributeError): # on python older than 2.7.9 ssl does not have this function pass try: self._vsphere_connection = SmartConnect(**kwargs) self._vsphere_content = self._vsphere_connection.RetrieveContent() self._perf_manager = self._vsphere_content.perfManager except (ConnectionError, vim.fault.InvalidLogin) as exc: raise VSphereException("Failed connecting to %s:%s using user %s: %s" % (self.auth_host, self.auth_port, self.admin_user, exc)) def close(self): if self._vsphere_connection: del self._vsphere_connection self._vsphere_connection = None @property @reconnect_on_fault def session_key(self): """ :return: The current session key. A unique identifier of the current connection. """ if self._vsphere_content is not None and self._vsphere_connection is not None: # perform simple operation to check connectivity. self._vsphere_connection.CurrentTime() if not self._vsphere_content.sessionManager.currentSession: raise VSphereReconnectException("Can't get session key, session might be off") return self._vsphere_content.sessionManager.currentSession.key @reconnect_on_fault def _list_objects(self, object_type, folder=None): if folder is None: folder = self._vsphere_content.rootFolder objview = self._vsphere_content.viewManager.CreateContainerView(folder, [object_type], True) objects = objview.view objview.Destroy() return objects @reconnect_on_fault def _get_obj(self, vim_type, name): """ Get the vsphere object associated with a given text name :param vim_type: List of pyVmomi types. :type vim_type: vim.* :param name: The name of the desired object. :type name: str. """ obj = None container = self._vsphere_content.viewManager.CreateContainerView(self._vsphere_content.rootFolder, vim_type, True) for item in container.view: if item.name == name: obj = item break if obj is None: LOG.debug("Could not find %s ", name) return obj def get_obj(self, vim_type, name): return self._get_obj(vim_type, name) def list_vms(self): return self._list_objects(vim.VirtualMachine) def list_hosts(self): return self._list_objects(vim.HostSystem) def list_users(self): user_list = [] for dom in self.domains: # skipping host users tmp_list = self._vsphere_content.userDirectory.RetrieveUserGroups( domain=dom, searchStr="", exactMatch=False, findUsers=True, findGroups=True) user_list.extend(tmp_list) return user_list # ----------------------------------------- # Property-Collector based API (used for deployment) # TODO: consider using only this API # ----------------------------------------- @reconnect_on_fault def _get_objects(self, object_type, properties): view = get_container_view(self._vsphere_connection, obj_type=[object_type]) objects = collect_properties(self._vsphere_connection, view_ref=view, obj_type=object_type, path_set=properties, include_mors=True) for obj in objects: obj['moid'] = obj['obj']._moId del obj['obj'] return objects def collect_roles(self): return self._vsphere_content.authorizationManager.roleList @property def roles(self): return self.collect_roles() def collect_domains(self): return self._vsphere_content.userDirectory.domainList[1:] @property def domains(self): """ Return all domains except host domain :return: List of domains except host domain. """ return self.collect_domains() @reconnect_on_fault def _get_obj_by_moid(self, obj_type, moid): obj = obj_type(moid) obj._stub = self._vsphere_connection._stub return obj def get_vm(self, vm_moid): """ Get VM by moid. """ return self._get_obj_by_moid(vim.VirtualMachine, vm_moid) def get_host(self, host_moid): """ Get host by moid. """ return self._get_obj_by_moid(vim.HostSystem, host_moid) def get_host_by_name(self, host_name): """ Get host by name. """ return self.get_obj([vim.HostSystem], host_name) @reconnect_on_fault def wait_for_task(self, task, action_name, hide_result=False, update_status_callback=None): if update_status_callback is None: def dummy_callback(task): pass update_status_callback = dummy_callback LOG.info('Waiting for %s to complete.', action_name) last_state = (None, None) while task.info.state in [vim.TaskInfo.State.running, vim.TaskInfo.State.queued]: if task.info.state == "canceled": try: task.CancelTask() except Exception as exc: LOG.warn("Error canceling task '%s': %s", action_name, exc) LOG.warn('%s was canceled!', action_name) return None elif last_state != (task.info.state, task.info.progress): LOG.info("Task '%s' state: %s (progress: %s%%)", action_name, task.info.state, task.info.progress or 0) last_state = (task.info.state, task.info.progress) try: update_status_callback(task) except Exception: LOG.exception("Error while calling %s task update status callback", action_name) do_sleep(1) if task.info.state == vim.TaskInfo.State.success: try: update_status_callback(task) except Exception: LOG.exception("Error while calling %s task update status callback", action_name) if task.info.result is not None and not hide_result: LOG.info('%s completed successfully, result: %s', action_name, task.info.result) else: LOG.info('%s completed successfully.', action_name) else: LOG.error('%s did not complete successfully: %s', action_name, task.info.error) raise VSphereTaskFailed(action_name, task.info.error) # may not always be applicable, but can't hurt. return task
class BareosVADPWrapper(object): ''' VADP specific class. ''' def __init__(self): self.si = None self.si_last_keepalive = None self.vm = None self.create_snap_task = None self.create_snap_result = None self.file_to_backup = None self.files_to_backup = None self.disk_devices = None self.disk_device_to_backup = None self.cbt_json_local_file_path = None self.dumper_process = None self.changed_disk_areas_json = None self.restore_objects_by_diskpath = {} self.restore_objects_by_objectname = {} self.options = None self.skip_disk_modes = [ 'independent_nonpersistent', 'independent_persistent' ] def connect_vmware(self, context): # this prevents from repeating on second call if self.si: bareosfd.DebugMessage( context, 100, "connect_vmware(): connection to server %s already exists\n" % (self.options['vcserver'])) return True bareosfd.DebugMessage( context, 100, "connect_vmware(): connecting server %s\n" % (self.options['vcserver'])) try: self.si = SmartConnect(host=self.options['vcserver'], user=self.options['vcuser'], pwd=self.options['vcpass'], port=443) self.si_last_keepalive = int(time.time()) except IOError: pass if not self.si: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "Cannot connect to host %s with user %s and password\n" % (self.options['vcserver'], self.options['vcuser'])) return False bareosfd.DebugMessage( context, 100, ("Successfully connected to VSphere API on host %s with" " user %s\n") % (self.options['vcserver'], self.options['vcuser'])) return True def cleanup(self): Disconnect(self.si) # the Disconnect Method does not close the tcp connection # is that so intentionally? # However, explicitly closing it works like this: self.si._stub.DropConnections() self.si = None self.log = None def keepalive(self): # FIXME: prevent from vSphere API timeout, needed until pyvmomi fixes # https://github.com/vmware/pyvmomi/issues/239 # otherwise idle timeout occurs after 20 minutes (1200s), # so call CurrentTime() every 15min (900s) to keep alive if int(time.time()) - self.si_last_keepalive > 900: self.si.CurrentTime() self.si_last_keepalive = int(time.time()) def prepare_vm_backup(self, context): ''' prepare VM backup: - get vm details - take snapshot - get disk devices ''' if 'uuid' in self.options: vmname = self.options['uuid'] if not self.get_vm_details_by_uuid(context): bareosfd.DebugMessage( context, 100, "Error getting details for VM %s\n" % (vmname)) return bRCs['bRC_Error'] else: vmname = self.options['vmname'] if not self.get_vm_details_dc_folder_vmname(context): bareosfd.DebugMessage( context, 100, "Error getting details for VM %s\n" % (vmname)) return bRCs['bRC_Error'] bareosfd.DebugMessage( context, 100, "Successfully got details for VM %s\n" % (vmname)) # check if the VM supports CBT and that CBT is enabled if not self.vm.capability.changeTrackingSupported: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "Error VM %s does not support CBT\n" % (vmname)) return bRCs['bRC_Error'] if not self.vm.config.changeTrackingEnabled: bareosfd.JobMessage(context, bJobMessageType['M_FATAL'], "Error VM %s is not CBT enabled\n" % (vmname)) return bRCs['bRC_Error'] bareosfd.DebugMessage(context, 100, "Creating Snapshot on VM %s\n" % (vmname)) if not self.create_vm_snapshot(context): bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "Error creating snapshot on VM %s\n" % (vmname)) return bRCs['bRC_Error'] bareosfd.DebugMessage( context, 100, "Successfully created snapshot on VM %s\n" % (vmname)) bareosfd.DebugMessage( context, 100, "Getting Disk Devices on VM %s from snapshot\n" % (vmname)) self.get_vm_snap_disk_devices(context) if not self.disk_devices: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "Error getting Disk Devices on VM %s from snapshot\n" % (vmname)) return bRCs['bRC_Error'] return bRCs['bRC_OK'] def prepare_vm_restore(self, context): ''' prepare VM restore: - get vm details - ensure vm is powered off - get disk devices ''' if 'uuid' in self.options: vmname = self.options['uuid'] if not self.get_vm_details_by_uuid(context): bareosfd.DebugMessage( context, 100, "Error getting details for VM %s\n" % (vmname)) return bRCs['bRC_Error'] else: vmname = self.options['vmname'] if not self.get_vm_details_dc_folder_vmname(context): bareosfd.DebugMessage( context, 100, "Error getting details for VM %s\n" % (vmname)) return bRCs['bRC_Error'] bareosfd.DebugMessage( context, 100, "Successfully got details for VM %s\n" % (vmname)) vm_power_state = self.vm.summary.runtime.powerState if vm_power_state != 'poweredOff': bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "Error VM %s must be poweredOff for restore, but is %s\n" % (vmname, vm_power_state)) return bRCs['bRC_Error'] if self.vm.snapshot is not None: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "Error VM %s must not have any snapshots before restore\n" % (vmname)) return bRCs['bRC_Error'] bareosfd.DebugMessage(context, 100, "Getting Disk Devices on VM %s\n" % (vmname)) self.get_vm_disk_devices(context) if not self.disk_devices: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "Error getting Disk Devices on VM %s\n" % (vmname)) return bRCs['bRC_Error'] # make sure backed up disks match VM disks if not self.check_vm_disks_match(context): return bRCs['bRC_Error'] return bRCs['bRC_OK'] def get_vm_details_dc_folder_vmname(self, context): ''' Get details of VM given by plugin options dc, folder, vmname and save result in self.vm Returns True on success, False otherwise ''' content = self.si.content dcView = content.viewManager.CreateContainerView( content.rootFolder, [vim.Datacenter], False) vmListWithFolder = {} dcList = dcView.view dcView.Destroy() for dc in dcList: if dc.name == self.options['dc']: folder = '' self._get_dcftree(vmListWithFolder, folder, dc.vmFolder) if self.options['folder'].endswith('/'): vm_path = "%s%s" % (self.options['folder'], self.options['vmname']) else: vm_path = "%s/%s" % (self.options['folder'], self.options['vmname']) if vm_path not in vmListWithFolder: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "No VM with Folder/Name %s found in DC %s\n" % (vm_path, self.options['dc'])) return False self.vm = vmListWithFolder[vm_path] return True def get_vm_details_by_uuid(self, context): ''' Get details of VM given by plugin options uuid and save result in self.vm Returns True on success, False otherwise ''' search_index = self.si.content.searchIndex self.vm = search_index.FindByUuid(None, self.options['uuid'], True, True) if self.vm is None: return False else: return True def _get_dcftree(self, dcf, folder, vm_folder): ''' Recursive function to get VMs with folder names ''' for vm_or_folder in vm_folder.childEntity: if isinstance(vm_or_folder, vim.VirtualMachine): dcf[folder + '/' + vm_or_folder.name] = vm_or_folder elif isinstance(vm_or_folder, vim.Folder): self._get_dcftree(dcf, folder + '/' + vm_or_folder.name, vm_or_folder) def create_vm_snapshot(self, context): ''' Creates a snapshot ''' try: self.create_snap_task = self.vm.CreateSnapshot_Task( name='BareosTmpSnap', description='Description for BareosTmpSnap', memory=False, quiesce=True) except vmodl.MethodFault as e: bareosfd.JobMessage(context, bJobMessageType['M_FATAL'], "Failed to create snapshot %s\n" % (e.msg)) return False self.vmomi_WaitForTasks([self.create_snap_task]) self.create_snap_result = self.create_snap_task.info.result self.create_snap_tstamp = time.time() return True def remove_vm_snapshot(self, context): ''' Removes the snapshot taken before ''' if not self.create_snap_result: bareosfd.JobMessage( context, bJobMessageType['M_WARNING'], "No snapshot was taken, skipping snapshot removal\n") return False try: rmsnap_task = \ self.create_snap_result.RemoveSnapshot_Task( removeChildren=True) except vmodl.MethodFault as e: bareosfd.JobMessage(context, bJobMessageType['M_WARNING'], "Failed to remove snapshot %s\n" % (e.msg)) return False self.vmomi_WaitForTasks([rmsnap_task]) return True def get_vm_snap_disk_devices(self, context): ''' Get the disk devices from the created snapshot Assumption: Snapshot successfully created ''' self.get_disk_devices(context, self.create_snap_result.config.hardware.device) def get_vm_disk_devices(self, context): ''' Get the disk devices from vm ''' self.get_disk_devices(context, self.vm.config.hardware.device) def get_disk_devices(self, context, devicespec): ''' Get disk devices from a devicespec ''' self.disk_devices = [] for hw_device in devicespec: if type(hw_device) == vim.vm.device.VirtualDisk: if hw_device.backing.diskMode in self.skip_disk_modes: bareosfd.JobMessage( context, bJobMessageType['M_INFO'], "Skipping Disk %s because mode is %s\n" % (self.get_vm_disk_root_filename( hw_device.backing), hw_device.backing.diskMode)) continue self.disk_devices.append({ 'deviceKey': hw_device.key, 'fileName': hw_device.backing.fileName, 'fileNameRoot': self.get_vm_disk_root_filename(hw_device.backing), 'changeId': hw_device.backing.changeId }) def get_vm_disk_root_filename(self, disk_device_backing): ''' Get the disk name from the ende of the parents chain When snapshots exist, the original disk filename is needed. If no snapshots exist, the disk has no parent and the filename is the same. ''' actual_backing = disk_device_backing while actual_backing.parent: actual_backing = actual_backing.parent return actual_backing.fileName def get_vm_disk_cbt(self, context): ''' Get CBT Information ''' cbt_changeId = '*' if self.disk_device_to_backup[ 'fileNameRoot'] in self.restore_objects_by_diskpath: if len(self.restore_objects_by_diskpath[ self.disk_device_to_backup['fileNameRoot']]) > 1: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], "ERROR: more then one CBT info for Diff/Inc exists\n") return False cbt_changeId = self.restore_objects_by_diskpath[ self.disk_device_to_backup['fileNameRoot']][0]['data'][ 'DiskParams']['changeId'] bareosfd.DebugMessage( context, 100, "get_vm_disk_cbt(): using changeId %s from restore object\n" % (cbt_changeId)) self.changed_disk_areas = self.vm.QueryChangedDiskAreas( snapshot=self.create_snap_result, deviceKey=self.disk_device_to_backup['deviceKey'], startOffset=0, changeId=cbt_changeId) self.cbt2json(context) return True def check_vm_disks_match(self, context): ''' Check if the backed up disks match selecte VM disks ''' backed_up_disks = set(self.restore_objects_by_diskpath.keys()) vm_disks = set( [disk_dev['fileNameRoot'] for disk_dev in self.disk_devices]) if backed_up_disks == vm_disks: bareosfd.DebugMessage( context, 100, "check_vm_disks_match(): OK, VM disks match backed up disks\n") return True bareosfd.JobMessage(context, bJobMessageType['M_WARNING'], "VM Disks: %s\n" % (', '.join(vm_disks))) bareosfd.JobMessage( context, bJobMessageType['M_WARNING'], "Backed up Disks: %s\n" % (', '.join(backed_up_disks))) bareosfd.JobMessage(context, bJobMessageType['M_FATAL'], "ERROR: VM disks not matching backed up disks\n") return False def cbt2json(self, context): ''' Convert CBT data into json serializable structure and return it as json string ''' # the order of keys in JSON data must be preserved for # bareos_vadp_dumper to work properly, this is done # by using the OrderedDict type cbt_data = OrderedDict() cbt_data['ConnParams'] = {} cbt_data['ConnParams']['VmMoRef'] = 'moref=' + self.vm._moId cbt_data['ConnParams']['VsphereHostName'] = self.options['vcserver'] cbt_data['ConnParams']['VsphereUsername'] = self.options['vcuser'] cbt_data['ConnParams']['VspherePassword'] = self.options['vcpass'] cbt_data['ConnParams'][ 'VsphereSnapshotMoRef'] = self.create_snap_result._moId # disk params for bareos_vadp_dumper cbt_data['DiskParams'] = {} cbt_data['DiskParams']['diskPath'] = self.disk_device_to_backup[ 'fileName'] cbt_data['DiskParams']['diskPathRoot'] = self.disk_device_to_backup[ 'fileNameRoot'] cbt_data['DiskParams']['changeId'] = self.disk_device_to_backup[ 'changeId'] # cbt data for bareos_vadp_dumper cbt_data['DiskChangeInfo'] = {} cbt_data['DiskChangeInfo'][ 'startOffset'] = self.changed_disk_areas.startOffset cbt_data['DiskChangeInfo']['length'] = self.changed_disk_areas.length cbt_data['DiskChangeInfo']['changedArea'] = [] for extent in self.changed_disk_areas.changedArea: cbt_data['DiskChangeInfo']['changedArea'].append({ 'start': extent.start, 'length': extent.length }) self.changed_disk_areas_json = json.dumps(cbt_data) self.writeStringToFile(context, '/var/tmp' + self.file_to_backup, self.changed_disk_areas_json) def json2cbt(self, cbt_json_string): ''' Convert JSON string from restore object to ordered dict to preserve the key order required for bareos_vadp_dumper to work properly return OrderedDict ''' # the order of keys in JSON data must be preserved for # bareos_vadp_dumper to work properly cbt_data = OrderedDict() cbt_keys_ordered = ['ConnParams', 'DiskParams', 'DiskChangeInfo'] cbt_data_tmp = json.loads(cbt_json_string) for cbt_key in cbt_keys_ordered: cbt_data[cbt_key] = cbt_data_tmp[cbt_key] return cbt_data def dumpJSONfile(self, context, filename, data): """ Write a Python data structure in JSON format to the given file. Note: obsolete, no longer used because order of keys in JSON string must be preserved """ bareosfd.DebugMessage( context, 100, "dumpJSONfile(): writing JSON data to file %s\n" % (filename)) try: out = open(filename, 'w') json.dump(data, out) out.close() bareosfd.DebugMessage( context, 100, "dumpJSONfile(): successfully wrote JSON data to file %s\n" % (filename)) except IOError as io_error: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], ("dumpJSONFile(): failed to write JSON data to file %s," " reason: %s\n") % (filename, io_error.strerror)) def writeStringToFile(self, context, filename, data_string): """ Write a String to the given file. """ bareosfd.DebugMessage( context, 100, "writeStringToFile(): writing String to file %s\n" % (filename)) # ensure the directory for writing the file exists self.mkdir(os.path.dirname(filename)) try: out = open(filename, 'w') out.write(data_string) out.close() bareosfd.DebugMessage( context, 100, "saveStringTofile(): successfully wrote String to file %s\n" % (filename)) except IOError as io_error: bareosfd.JobMessage( context, bJobMessageType['M_FATAL'], ("writeStingToFile(): failed to write String to file %s," " reason: %s\n") % (filename, io_error.strerror)) # the following path must be passed to bareos_vadp_dumper as parameter self.cbt_json_local_file_path = filename def vmomi_WaitForTasks(self, tasks): """ Given the service instance si and tasks, it returns after all the tasks are complete """ si = self.si pc = si.content.propertyCollector taskList = [str(task) for task in tasks] # Create filter objSpecs = [ vmodl.query.PropertyCollector.ObjectSpec(obj=task) for task in tasks ] propSpec = vmodl.query.PropertyCollector.PropertySpec(type=vim.Task, pathSet=[], all=True) filterSpec = vmodl.query.PropertyCollector.FilterSpec() filterSpec.objectSet = objSpecs filterSpec.propSet = [propSpec] pcfilter = pc.CreateFilter(filterSpec, True) try: version, state = None, None # Loop looking for updates till the state moves to a completed # state. while len(taskList): update = pc.WaitForUpdates(version) for filterSet in update.filterSet: for objSet in filterSet.objectSet: task = objSet.obj for change in objSet.changeSet: if change.name == 'info': state = change.val.state elif change.name == 'info.state': state = change.val else: continue if not str(task) in taskList: continue if state == vim.TaskInfo.State.success: # Remove task from taskList taskList.remove(str(task)) elif state == vim.TaskInfo.State.error: raise task.info.error # Move to next version version = update.version finally: if pcfilter: pcfilter.Destroy() def start_dumper(self, context, cmd): """ Start bareos_vadp_dumper Parameters - cmd: must be "dump" or "restore" """ bareos_vadp_dumper_bin = 'bareos_vadp_dumper_wrapper.sh' # options for bareos_vadp_dumper: # -S: cleanup on start # -D: cleanup on disconnect # -M: save metadata # -R: restore metadata bareos_vadp_dumper_opts = {} bareos_vadp_dumper_opts['dump'] = '-S -D -M' bareos_vadp_dumper_opts['restore'] = '-S -D -R' bareos_vadp_dumper_command = '%s %s %s "%s"' % ( bareos_vadp_dumper_bin, bareos_vadp_dumper_opts[cmd], cmd, self.cbt_json_local_file_path) bareos_vadp_dumper_command_args = shlex.split( bareos_vadp_dumper_command) log_path = '/var/log/bareos' stderr_log_fd = tempfile.NamedTemporaryFile(dir=log_path, delete=False) bareos_vadp_dumper_process = None bareos_vadp_dumper_logfile = None try: if cmd == 'dump': # backup bareos_vadp_dumper_process = subprocess.Popen( bareos_vadp_dumper_command_args, bufsize=-1, stdin=open("/dev/null"), stdout=subprocess.PIPE, stderr=stderr_log_fd, close_fds=True) else: # restore bareos_vadp_dumper_process = subprocess.Popen( bareos_vadp_dumper_command_args, bufsize=-1, stdin=subprocess.PIPE, stdout=open("/dev/null"), stderr=stderr_log_fd, close_fds=True) # rename the stderr log file to one containing the PID bareos_vadp_dumper_logfile = '%s/bareos_vadp_dumper.%s.log' \ % (log_path, bareos_vadp_dumper_process.pid) os.rename(stderr_log_fd.name, bareos_vadp_dumper_logfile) bareosfd.DebugMessage( context, 100, "start_bareos_vadp_dumper(): started %s, log stderr to %s\n" % (bareos_vadp_dumper_command, bareos_vadp_dumper_logfile)) except: # kill children if they arent done if bareos_vadp_dumper_process: bareosfd.JobMessage( context, bJobMessageType['M_WARNING'], "Failed to start %s\n" % (bareos_vadp_dumper_command)) if (bareos_vadp_dumper_process is not None and bareos_vadp_dumper_process.returncode is None): bareosfd.JobMessage( context, bJobMessageType['M_WARNING'], "Killing probably stuck %s PID %s with signal 9\n" % (bareos_vadp_dumper_command, bareos_vadp_dumper_process.pid)) os.kill(bareos_vadp_dumper_process.pid, 9) try: if bareos_vadp_dumper_process is not None: bareosfd.DebugMessage( context, 100, "Waiting for command %s PID %s to terminate\n" % (bareos_vadp_dumper_command, bareos_vadp_dumper_process.pid)) os.waitpid(bareos_vadp_dumper_process.pid, 0) bareosfd.DebugMessage( context, 100, "Command %s PID %s terminated\n" % (bareos_vadp_dumper_command, bareos_vadp_dumper_process.pid)) except: pass raise else: raise # bareos_vadp_dumper should be running now, set the process object # for further processing self.dumper_process = bareos_vadp_dumper_process return True def end_dumper(self, context): """ Wait for bareos_vadp_dumper to terminate """ bareos_vadp_dumper_returncode = None # Wait up to 120s for bareos_vadp_dumper to terminate, # if still running, send SIGTERM and wait up to 60s. # This handles cancelled jobs properly and prevents # from infinite loop if something unexpected goes wrong. timeout = 120 start_time = int(time.time()) sent_sigterm = False while self.dumper_process.poll() is None: if int(time.time()) - start_time > timeout: bareosfd.DebugMessage( context, 100, "Timeout wait for bareos_vadp_dumper PID %s to terminate\n" % (self.dumper_process.pid)) if not sent_sigterm: bareosfd.DebugMessage( context, 100, "sending SIGTERM to bareos_vadp_dumper PID %s\n" % (self.dumper_process.pid)) os.kill(self.dumper_process.pid, signal.SIGTERM) sent_sigterm = True timeout = 60 start_time = int(time.time()) continue else: bareosfd.DebugMessage( context, 100, "Giving up to wait for bareos_vadp_dumper PID %s to terminate\n" % (self.dumper_process.pid)) break bareosfd.DebugMessage( context, 100, "Waiting for bareos_vadp_dumper PID %s to terminate\n" % (self.dumper_process.pid)) time.sleep(1) bareos_vadp_dumper_returncode = self.dumper_process.returncode self.dumper_process = None return bareos_vadp_dumper_returncode # helper functions ############ def mkdir(self, directory_name): """ Utility Function for creating directories, works like mkdir -p """ try: os.stat(directory_name) except OSError: os.makedirs(directory_name)
class VCenter(object): """ """ def __init__(self): self._connection = None self._logged_in = False self._user = None self._host = None self._passwd = None self._full_name = None self._name = "" self._version = None self._os = None def connect(self, host, user, passwd): try: self._connection = SmartConnect(host=host, user=user, pwd=passwd) except vim.fault.InvalidLogin: logging.warning("Cannot connect to specified host \ using given username and password.") # TODO: Raise login exception except (vim.fault.HostConnectFault, ssl.SSLError) as exc: if '[SSL: CERTIFICATE_VERIFY_FAILED' in str(exc): try: default_context = ssl._create_default_https_context ssl._create_default_https_context = ssl._create_unverified_context self._connection = SmartConnect(host=host, user=user, pwd=passwd) ssl._create_default_https_context = default_context except Exception as exc1: raise Exception(exc1) else: logging.error("Cannot connect to host, due to an error.", exc_info=True) # TODO: Raise login exception if self._connection: atexit.register(Disconnect, self._connection) self._logged_in = True self._host = host self._user = user self._passwd = base64.b64encode(passwd) self.session_keeper() vmpie.set_vcenter(self) def is_connected(self): if self._logged_in: if not self._connection.content.sessionManager.currentSession: logging.debug("Session has expired. Renewing session.") self.connect(self._host, self._user, self._passwd) if self._connection: logging.debug("Renewed session successfully.") else: logging.debug( "Session renewal failed. True connecting again.") # Raise login exception return True return False def _session_keeper_worker(self): while True: try: self._ping() except: pass finally: time.sleep(consts.SESSION_KEEPER_TIMEOUT) def session_keeper(self): self._life_keeper_thread = Thread(target=self._session_keeper_worker, args=()) self._life_keeper_thread.daemon = True self._life_keeper_thread.start() def _ping(self): return self._connection.CurrentTime() def disconnect(self): self._connection.content.sessionManager.Logout() def get_vm(self, vm_name): return virtual_machine.VirtualMachine(vm_name) def get_all_vms(self): container_view = self._connection.content.viewManager.CreateContainerView( self._connection.content.rootFolder, [vim.VirtualMachine], True) children = container_view.view vms = [] for vm in children: vms.append(virtual_machine.VirtualMachine(vm.name, _pyVmomiVM=vm)) return vms def get_folder(self, folder_name): return folder.Folder(folder_name) def get_vms_by_folder(self, folder_name): return folder.Folder(folder_name).vms def backup(self): folders = utils._create_folder_tree() vm_paths = utils._get_all_vm_paths() def __str__(self): return '<VCenter: {vc_name}>'.format( vc_name=self._connection.content.about.fullName) def __repr__(self): return '<VCenter: {vc_name}>'.format( vc_name=self._connection.content.about.fullName)
def collect_esxi_data(host, user, pwd, ssl): now = datetime.datetime.now() try: si = SmartConnect(host=host, user=user, pwd=pwd, sslContext=ssl) print('Collecting Information at : ', str(now)) content = si.RetrieveContent() #disconnect the connection when program exists #atexit.register(Disconnect, si) #atexit.register(endit) # Get vCenter date and time for use as baseline when querying for counters vchtime = si.CurrentTime() perf_dict = create_perf_dictionary(content) container = content.rootFolder # starting point to look into viewType = [vim.VirtualMachine] # object types to look for recursive = True # whether we should look into it recursively containerView = content.viewManager.CreateContainerView( container, viewType, recursive) children = containerView.view c1 = 0 for child in children: print_vm_info(child) c1 += 1 c2 = 0 if printVM: vmProps = get_properties(content, [vim.VirtualMachine], ['name', 'runtime.powerState'], vim.VirtualMachine) for vm in vmProps: if vm['runtime.powerState'] == "poweredOn": #print("VM Name : ",vm["name"]) vm_moref = vm['moref'] guest, cpu, mem = vm_core(vm_moref) #core information vmGuest1.append(guest) vmNumCPU.append(cpu) s = re.findall(r"[-+]?\d*\.\d+|\d+", mem) if "GB" in mem: memKBytes = float(s[0]) * 131072 elif "MB" in mem: memKBytes = float(s[0]) * 1024 elif "KB" in mem: memKBytes = float(s[0]) else: memKBytes = float(s[0]) * 0.00097656 vmMemory.append(memKBytes) status, state = vm_status(vm_moref) #status information vmStatus.append(status) vmState.append(state) CPUready = vm_cpu_ready(vm_moref, content, vchtime, perf_dict) vmCPUready.append(CPUready) CPUusage = vm_cpu_usage(vm_moref, content, vchtime, perf_dict) vmCPUusage.append(CPUusage) MEMactive = vm_mem_active(vm_moref, content, vchtime, perf_dict) vmMEMactive.append(MEMactive) MEMshared = vm_mem_shared(vm_moref, content, vchtime, perf_dict) vmMEMshared.append(MEMshared) MEMballoon = vm_mem_balloon(vm_moref, content, vchtime, perf_dict) vmMEMballoon.append(MEMballoon) DS_readIO, DS_writeIO, DS_finalIO = vm_ds_io( vm_moref, content, vchtime, perf_dict) vmDS_readIO.append(DS_readIO) vmDS_writeIO.append(DS_writeIO) vmDS_finalIO.append(DS_finalIO) DS_readLatency, DS_writeLatency, totalLatency = vm_ds_latency( vm_moref, content, vchtime, perf_dict) vmDS_readLatency.append(DS_readLatency) vmDS_writeLatency.append(DS_writeLatency) vmDS_totalLatency.append(totalLatency) NetUsageRx, NetUsageTx, NetUsageTotal = vm_net_usage( vm_moref, content, vchtime, perf_dict) vm_NetUsageRx.append(NetUsageRx) vm_NetUsageTx.append(NetUsageTx) vm_NetUsageTotal.append(NetUsageTotal) #break c2 += 1 for i in range(0, c2): VMLogger.info( "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}" .format(collection_time, vmName[i], vmTemplate[i], vmPath[i], vmDSlocation[i], vmGuest[i], vmInstanceUUID[i], vmBioUUID[i], vmIP[i], VMwareTools[i], vmGuest1[i], vmNumCPU[i], vmMemory[i], vmStatus[i], vmState[i], vmCPUready[i], vmCPUusage[i], vmMEMactive[i], vmMEMshared[i], vmMEMballoon[i], vmDS_readIO[i], vmDS_writeIO[i], vmDS_finalIO[i], vmDS_readLatency[i], vmDS_writeLatency[i], vmDS_totalLatency[i], vm_NetUsageRx[i], vm_NetUsageTx[i], vm_NetUsageTotal[i])) with open('vmlog.log') as f: reader = csv.DictReader(f) helpers.bulk(es, reader, index='vm-index', doc_type='log') Disconnect(si) endit() except IOError as e: print("I/O error({0}): {1}".format(e.errno, e.strerror))
def main(): args = GetArgs() try: # disable SSL verification if requested context = None if args.insecure: context = ssl._create_unverified_context() entity = args.entity if args.counter != 'core' and args.counter != 'status': warning = float(args.warning) critical = float(args.critical) si = None if args.password: password = args.password else: password = getpass.getpass(prompt="Enter password for host {} and user {}: ".format(args.host, args.user)) # Set stderr to log /dev/null instead of the screen to prevent warnings contaminating output # NOTE: This is only in place until a more suitable method to deal with the latest certificate warnings f = open('/dev/null', "w") # f = open('c:\\temp\\dummy', "w") original_stderr = sys.stderr sys.stderr = f try: si = SmartConnect(host=args.host, user=args.user, pwd=password, port=int(args.port), sslContext=context) except SSLError as e: print('Could not verify SSL certificate, use -i / --insecure to skip checking') return -1 except IOError: pass finally: sys.stderr = original_stderr if not si: print('Could not connect to the specified host using specified username and password') return -1 atexit.register(Disconnect, si) content = si.RetrieveContent() # Get vCenter date and time for use as baseline when querying for counters vchtime = si.CurrentTime() perf_dict = create_perf_dictionary(content) if args.type == 'vm': #Find VM supplied as arg and use Managed Object Reference (moref) for the PrintVmInfo vmProps = get_properties(content, [vim.VirtualMachine], ['name', 'runtime.powerState'], vim.VirtualMachine) for vm in vmProps: if (vm['name'] == entity) and (vm['runtime.powerState'] == "poweredOn"): vm_moref = vm['moref'] if args.counter == 'core': vm_core(vm_moref) elif args.counter == 'status': vm_status(vm_moref) elif args.counter == 'cpu.ready': vm_cpu_ready(vm_moref, content, vchtime, perf_dict, warning, critical) elif args.counter == 'cpu.usage': vm_cpu_usage(vm_moref, content, vchtime, perf_dict, warning, critical) elif args.counter == 'mem.active': vm_mem_active(vm_moref, content, vchtime, perf_dict, warning, critical) elif args.counter == 'mem.shared': vm_mem_shared(vm_moref, content, vchtime, perf_dict, warning, critical) elif args.counter == 'mem.balloon': vm_mem_balloon(vm_moref, content, vchtime, perf_dict, warning, critical) elif args.counter == 'datastore.io': vm_ds_io(vm_moref, content, vchtime, perf_dict, warning, critical) elif args.counter == 'datastore.latency': vm_ds_latency(vm_moref, content, vchtime, perf_dict, warning, critical) elif args.counter == 'network.usage': vm_net_usage(vm_moref, content, vchtime, perf_dict, warning, critical) else: print('ERROR: No supported counter found') exit(STATE_UNKNOWN) elif (vm['name'] == entity) and ((vm['runtime.powerState'] == "poweredOff") or (vm['runtime.powerState'] == "suspended")): vm_moref = vm['moref'] if args.counter == 'core': vm_core(vm_moref) elif args.counter == 'status': vm_status(vm_moref) else: print('ERROR: Virtual Machine is powered off') exit(STATE_UNKNOWN) elif args.type == 'host': hostProps = get_properties(content, [vim.HostSystem], ['name'], vim.HostSystem) for host in hostProps: if host['name'] == entity: host_moref = host['moref'] if args.counter == 'core': host_core(host_moref) elif args.counter == 'cpu.usage': host_cpu_usage(host_moref, warning, critical) elif args.counter == 'mem.usage': host_mem_usage(host_moref, warning, critical) else: print('ERROR: No supported counter found') exit(STATE_UNKNOWN) elif args.type == 'datastore': dsProps = get_properties(content, [vim.Datastore], ['name'], vim.Datastore) for datastore in dsProps: if datastore['name'] == entity: ds_moref = datastore['moref'] if args.counter == 'status': ds_status(ds_moref) elif args.counter == 'space': ds_space(ds_moref, warning, critical) else: print('ERROR: No supported counter found') exit(STATE_UNKNOWN) elif args.type == 'cluster': clProps = get_properties(content, [vim.ClusterComputeResource], ['name'], vim.ClusterComputeResource) for cluster in clProps: if cluster['name'] == entity: cl_moref = cluster['moref'] if args.counter == 'status': cl_status(cl_moref) else: print('ERROR: No supported counter found') exit(STATE_UNKNOWN) else: print('ERROR: No supported Entity type provided') except vmodl.MethodFault as e: print("Caught vmodl fault : " + e.msg) return -1 except Exception as e: print("Caught exception : " + str(e)) return -1 return 0
#To check the Cert Type of VC try: c = SmartConnect(host="192.168.0.51", user="******", pwd="VMware123!") print('Valid Certificate') except: c = SmartConnect(host="192.168.0.51", user="******", pwd="VMware123!", sslContext=s) print('Invalid or Untrusted Certificate') #To Check Time On VC print("Time On VC :") print(c.CurrentTime()) print("*" * 36) #Code for Extension List print("The List Of Extensions") extension = c.content.extensionManager.extensionList j = 1 for i in extension: print("{} : {}".format(j, i.key)) j += 1 print("*" * 36) Disconnect(c)
def main(): global disk_type global esxi_version global esxi_build global esxi_info_stat print("Script Version : 3.0") logger.info("Script Version : 3.0") e = None try: args = parser.parse_args() except Exception as e: logger.error("Could not read arguments :") logger.error(str(e)) print("Could not read arguments :") print(str(e)) return -1 #set_log_level_from_verbose(args) try: #vmnames = args.vm #vmnames = args.vm.split(",") vmnames = args.vm.lower().split(",") #vmnames = map(lambda x:x.lower(),vmnames) si = None disk_types = ['ssd', 'non_ssd'] if args.disk_type.lower() not in disk_types: print('Disk Type (', args.disk_type.lower(), ') not valid!.', 'Valid options are : ssd OR non-ssd') logger.error( "Disk Type ( {} ) not valid!. Valid options are : ssd OR non-ssd" .format(args.disk_type.lower())) return -1 else: disk_type = args.disk_type.lower() logger.info('vmnames : {}'.format(vmnames)) logger.info("disk_type : {}".format(disk_type)) if args.password: password = args.password else: try: password = getpass.getpass( prompt="Enter password for host {} and user {}: ".format( args.host, args.user)) except Exception as e: print("Could not read password") logger.error("Could not read password") print(str(e)) return -1 try: #logger.info("cert_check_skip : {}".format(args.cert_check_skip)) if args.cert_check_skip: context = ssl._create_unverified_context() logger.info("context :") logger.info(context) si = SmartConnect(host=args.host, user=args.user, pwd=password, port=int(args.port), sslContext=context) else: si = SmartConnect(host=args.host, user=args.user, pwd=password, port=int(args.port)) logger.info("si:") logger.info(si) si_attrs = si.__dict__ logger.info("si_attrs: {}".format(si_attrs)) except IOError as e: print("IOError.") print(str(e)) logger.error("IOError.") logger.error(str(e)) return -1 except Exception as e: e = sys.exc_info() print(str(e)) print("Other Exceptions:") logger.error(str(e)) return -1 if not si: print( 'Could not connect to the specified host using specified username and password' ) logger.error( 'Could not connect to the specified host using specified username and password' ) return -1 else: print("Connected.") logger.info("Connected.") atexit.register(Disconnect, si) content = si.RetrieveContent() logger.info("content: {} \n".format(content)) # Get vCenter date and time for use as baseline when querying for counters vchtime = si.CurrentTime() logger.info("vchtime: {}".format(vchtime)) retESXIProps = esxi_info(content, [vim.HostSystem], ['hyperthreading'], vchtime) logger.debug("retESXIProps: {}".format(retESXIProps)) #esx_global.csv esxi_info_stat = 0 esxi_version = content.about.version esxi_build = content.about.build esxi_update = "." esxi_ht_bp = "False" f = open(esx_global_output, "a") f.write("{}, {}, {}, {}, {}, {}, {}, {}, {}\n".format( esxi_version, esxi_build, esxi_update, retESXIProps['esxi_cpus'], retESXIProps['esxi_cores'], retESXIProps['esxi_threads'], retESXIProps['CPUhyperThreadingActive'], retESXIProps['CPUhyperThreadingConfig'], esxi_ht_bp)) f.close() retProps = GetProperties(content, [vim.VirtualMachine], ['name', 'runtime.powerState'], vim.VirtualMachine) logger.debug("retProps: {}".format(retProps)) # Find VM supplied as arg and use Managed Object Reference (moref) for the PrintVmInfo vmcount = 0 allvmlist = [] for vm in retProps: # retval = PrintVmInfotmp(vm['moref'], content, vchtime) # print(retval) # print("Total CPU Allocated : {0} , Memory Allocated : {1}".format(allocatedCPU, allocatedMEM)) allvmlist.append(vm['name']) if (vm['name'].lower() in vmnames) and (vm['runtime.powerState'] == "poweredOn"): logger.info("VM {} found in {} and powered on".format( vm['name'], args.host)) esxi_info_stat += 1 PrintVmInfo(args, vm['moref'], content, vchtime, retESXIProps) vmcount = vmcount + 1 elif (vm['name'].lower() in vmnames) and (vm['runtime.powerState'] != "poweredOn"): print( 'ERROR: Problem connecting to Virtual Machine. {} is likely powered off or suspended' .format(vm['name'])) logger.error( 'ERROR: Problem connecting to Virtual Machine. {} is likely powered off or suspended' .format(vm['name'])) vmcount = vmcount + 1 logger("VM {} found in {} and powered off".format( vm['name'], args.host)) return -1 allvmlist_lower = map(lambda x: x.lower(), allvmlist) for currvm in vmnames: if currvm.lower() not in allvmlist_lower: logger.error('vm : {} not found on vmware host {}'.format( currvm, args.host)) print('vm : {} not found on vmware host {}'.format( currvm, args.host)) return -1 if vmcount == 0: logger.error( 'vm : {} not found on vmware host {}. Please check vm name. VM Name is case sensitive' .format(currvm, args.host)) print( 'vm : {} not found on vmware host {}. Please check vm name. VM Name is case sensitive' .format(currvm, args.host)) return -1 Disconnect print(' ') print( 'Note : Please send following 3 files generated in current folder to delphix professional services team' ) print(' 1) logs/esx_global.csv') print(' 2) logs/vm_stats.csv') print(' 3) logs/chk_esxi_settings.txt') print(' ') log_file_handler.close() if not args.debug: if path.exists(debug_logfile): os.remove(debug_logfile) except vmodl.MethodFault as e: print('Caught vmodl fault: ' + e.msg) logger.error("Caught vmodl fault : {}".format(e.msg)) return -1 except Exception as e: print('Caught exception: ' + str(e)) logger.error("Caught exception: {}".format(e)) return -1 return 0
def scanVM(): interval = cfg.vspehre['interval'] try: while True: si = None try: if cfg.vspehre['skipSSL']: context = ssl._create_unverified_context() si = SmartConnect(host=cfg.vspehre['host'], user=cfg.vspehre['user'], pwd=cfg.vspehre['password'], port=int("443"), sslContext=context) else: si = SmartConnect(host=cfg.vspehre['host'], user=cfg.vspehre['user'], pwd=cfg.vspehre['password'], port=int("443")) except IOError as e: pass if not si: print(strs.connError) return -1 atexit.register(Disconnect, si) content = si.RetrieveContent() # Get vCenter date and time for use as baseline when querying vchtime = si.CurrentTime() # Get all the performance counters perf_dict = {} perfList = content.perfManager.perfCounter for counter in perfList: counter_full = "{}.{}.{}".format(counter.groupInfo.key, counter.nameInfo.key, counter.rollupType) perf_dict[counter_full] = counter.key retProps = GetProperties( content, [vim.VirtualMachine], ['name', 'runtime.powerState', 'runtime.connectionState'], vim.VirtualMachine) for vm in retProps: if (vm['runtime.powerState'] == "poweredOn") \ and \ (vm['runtime.connectionState'] != "disconnected"): print('*' * 20) print('[x] ' + vm['name']) getVMPerf(vm['moref'], content, vchtime, int(interval), perf_dict) else: print( strs.vmError.format(fore.LIGHT_BLUE, back.RED, style.BOLD, vm['name'], style.RESET)) # time.sleep(2) except vmodl.MethodFault as e: print('Caught vmodl fault : ' + e.msg) return -1 except Exception as e: print('Caught exception : ' + str(e)) # return -1 return 0