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
