def retrieve(self, request, *args, **kwargs):
host_ip_r = kwargs['host_ip']
try:
host_serializer = serializers.VMwareHostSerializer(self.queryset.get(host_ip=host_ip_r))
instances_set = models.VMwareInstance.objects.filter(host_ip=host_serializer.data['host_ip'])
instances_count = instances_set.count()
mem_used = 0
vcpus = 0
ecu = 0
for instance in instances_set:
mem_used += int(instance.mem[0:len(instance.mem)-2])
a = int(instance.cpu[0:instance.cpu.find("vcpu")])
vcpus += a
ecu += int(instance.cpu[instance.cpu.find("ecu")-1:instance.cpu.find("ecu")]) * a
host_serializer.data['memory_used'] = str(mem_used/1024) + "GB"
host_serializer.data['vcpus_used'] = vcpus
host_serializer.data['ecus_used'] = ecu
host_serializer.data['instances_count'] = instances_count
server = VIServer()
server.connect(host_serializer.data['host_ip'], 'root', 'P@ssw0rd')
properties = ['capability.maxSupportedVMs',
'capability.maxSupportedVcpus',
'runtime.bootTime',
'runtime.powerState',
'summary.config.product.osType',
'summary.config.product.fullName',
'summary.config.product.licenseProductVersion',
'summary.config.product.licenseProductName',
'summary.config.product.instanceUuid',
'hardware.cpuPowerManagementInfo.hardwareSupport']
results = server._retrieve_properties_traversal(property_names=properties, obj_type=MORTypes.HostSystem)
for result in results:
for p in result.PropSet:
if p.Name == 'hardware.cpuInfo.hz':
value = str(p.Val/(1024*1024*1024)) + " GHz"
elif p.Name == 'hardware.memorySize':
value = str(p.Val/(1024*1024)) + " MB"
elif p.Name == 'config.certificate':
value = str(p.Val)
elif p.Name == 'runtime.bootTime':
value = str(p.Val[0]) + "-" + str(p.Val[1]) + "-" + str(p.Val[2]) + " "
value = value + str(p.Val[3]) + ":" + str(p.Val[4])
else:
value = str(p.Val)
name = p.Name.split('.')[-1]
host_serializer.data[name] = value
return Response(host_serializer.data)
except VMwareHost.DoesNotExist:
raise Http404
class CheckVCenter():
def __init__(self):
self.server = VIServer()
self.STAT_OK=0
self.STAT_WARNING=1
self.STAT_CRITICAL=2
self.vc = sys.argv[1]
self.user = sys.argv[2]
self.password = sys.argv[3]
@staticmethod
def PrintDict(i,status):
for k,v in i.items():
print "VMFS %s lun:%s -----*----*---- usage:%d%%" %(status,k,v)
def Check(self):
self.server.connect(self.vc,self.user,self.password)
Value = self.server.get_datastores()
c = {}
w = {}
n = {}
for k,v in Value.items():
props = self.server._retrieve_properties_traversal(property_names=['name','summary.capacity',
'summary.freeSpace'],
from_node=k,obj_type='Datastore')
for p_set in props:
for p1 in p_set.PropSet:
if p1.Name == "summary.capacity":
DatastoreCapacity = (p1.Val/1073741824)
elif p1.Name == "summary.freeSpace":
DatastoreFreespace = (p1.Val/1073741824)
Percent = (((DatastoreCapacity - DatastoreFreespace) * 100)/DatastoreCapacity)
if Percent > 90 and 'ISO' not in v:
c[v] = Percent
elif Percent > 85 < 90 and 'ISO' not in v:
w[v] = Percent
elif Percent < 85 and 'ISO' not in v:
n[v] = Percent
if dict(c):
CheckVCenter.PrintDict(c,'CRITICAL')
sys.exit(self.STAT_CRITICAL)
elif dict(w):
CheckVCenter.PrintDict(w,'WARNING')
sys.exit(self.STAT_WARNING)
else:
print("All Lun is OK")
sys.exit(self.STAT_OK)
def vi_retrieve_host_objects(host,properties):
s = VIServer()
s.connect(vi_configuration["VI_HOST"], vi_configuration["VI_USER"], vi_configuration["VI_PASS"])
# If we can't find this host in the get_hosts() output then it doesn't exist
# on this vCenter. We catch this with an indexError and return false to be
# detected upstream. Can we do this quicker? Takes ~2s to retrieve the hosts
# on a loaded 4.1 vCenter.
try:
from_host = [k for k,v in s.get_hosts().items() if v == host][0]
result = s._retrieve_properties_traversal(property_names=properties,from_node=from_host,obj_type=MORTypes.HostSystem)[0]
except IndexError:
result = False
s.disconnect()
return result
def get_datastore_info(host_ip,host_name,host_password):
stats_data_list = []
s = VIServer()
s.connect(host_ip, host_name, host_password)
print 'VC connect successful...'
for ds, dsname in s.get_datastores().items():
DatastoreCapacity = 0
DatastoreFreespace = 0
DatastoreUsagePercent = 0
props = s._retrieve_properties_traversal(property_names=['name', 'summary.capacity', 'summary.freeSpace'],
from_node=ds, obj_type="Datastore")
# print props
for prop_set in props:
for prop in prop_set.PropSet:
if prop.Name == "summary.capacity":
DatastoreCapacity = round((prop.Val / 1073741824),2)
elif prop.Name == "summary.freeSpace":
DatastoreFreespace = round((prop.Val / 1073741824),2)
UsedSpace = round((DatastoreCapacity - DatastoreFreespace),2)
DatastoreUsagePercent = round((((DatastoreCapacity - DatastoreFreespace) * 100) / DatastoreCapacity),2)
metricnameZoneDatastoreCapacity = dsname.lower() + 'Capacity'
metricnameZoneDatastoreFreespace = dsname.lower() + 'FreeSpace'
metricnameZoneDatastoreUsagePercent = dsname.lower() + 'UsagePercent'
volumes_dict = {'volumes': dsname.lower(), 'FreeSpace': DatastoreFreespace, 'UsedSpace': UsedSpace,
'capacity': DatastoreCapacity, 'usagePercent': DatastoreUsagePercent}
#pprint.pprint(volumes_dict)
#DebugInfo.objects.create(text_info=volumes_dict)
stats_data_list.append(volumes_dict)
#print 'mVC disconnect successful...'
s.disconnect()
return stats_data_list
def info(self, request, host_ip):
try:
instance_name = request.GET.get('ins_name') or None
if instance_name is None:
content = {'Error!': 'Instance name is None,You must specify instance name'}
return Response(content)
else:
instance_serializer = serializers.VMwareInstanceSerializer(self.queryset.get(instance_name=instance_name))
uptime = instance_serializer.data['up_time']
if uptime.strip() == '':
time_str = " "
else:
time_str = change_time_format(int(uptime))
instance_serializer.data['up_time'] = time_str
server = VIServer()
server.connect(host_ip, 'root', 'P@ssw0rd')
properties = ['name', 'runtime.maxCpuUsage', 'runtime.maxMemoryUsage', 'summary.config.vmPathName',
'runtime.suspendInterval', 'config.instanceUuid', 'config.locationId',
'summary.config.cpuReservation', 'config.guestFullName', 'config.version',
'guest.guestState', 'guest.hostName', 'guest.ipAddress', 'runtime.bootTime',
'runtime.connectionState']
results = server._retrieve_properties_traversal(property_names=properties, obj_type=MORTypes.VirtualMachine)
for result in results:
for p in result.PropSet:
if p.Name == 'name' and p.Val != instance_name:
break
pname = p.Name.split('.')[-1]
if p.Name != 'name':
pvalue = p.Val
instance_serializer.data[pname] = pvalue
if p.Name == 'runtime.bootTime':
v = p.Val
pvalue = str(v[0]) + '-' + str(v[1]) + '-' + str(v[2]) + ' ' + str(v[3]) + ':' + str(v[4])
instance_serializer.data[pname] = pvalue
return Response(instance_serializer.data)
except VMwareInstance.DoesNotExist:
raise Http404
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
"""
_stats_available = {
'num_vm': lambda self: len(self.list_vm()),
'num_host': lambda self: len(self.list_host()),
'num_cluster': lambda self: len(self.list_cluster()),
'num_template': lambda self: len(self.list_template()),
'num_datastore': lambda self: len(self.list_datastore()),
}
def __init__(self, hostname, username, password, **kwargs):
self.api = VIServer()
self.api.connect(hostname, username, password)
def _get_vm(self, vm_name=None):
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def does_vm_exist(self, name):
try:
self._get_vm(name)
return True
except Exception:
return False
def _get_resource_pool(self, resource_pool_name=None):
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def get_ip_address(self, vm_name):
vm = self._get_vm(vm_name)
maxwait = 600
net_info = None
waitcount = 0
while net_info is None:
if waitcount > maxwait:
break
net_info = vm.get_property('net', False)
waitcount += 5
time.sleep(5)
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def _get_list_vms(self, get_template=False):
template_or_vm_list = []
props = self.api._retrieve_properties_traversal(
property_names=['name', 'config.template'],
from_node=None,
obj_type=MORTypes.VirtualMachine)
for prop in props:
vm = None
template = None
for elem in prop.PropSet:
if elem.Name == "name":
vm = elem.Val
elif elem.Name == "config.template":
template = elem.Val
if vm is None or template is None:
continue
if template == bool(get_template):
template_or_vm_list.append(vm)
return template_or_vm_list
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError(
'This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self):
return self._get_list_vms()
def list_template(self):
return self._get_list_vms(get_template=True)
def list_flavor(self):
raise NotImplementedError(
'This function is not supported on this platform.')
def list_host(self):
return self.api.get_hosts()
def list_datastore(self):
return self.api.get_datastores()
def list_cluster(self):
return self.api.get_clusters()
def info(self):
return '%s %s' % (self.api.get_server_type(),
self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' %
vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self):
raise NotImplementedError('clone_vm not implemented.')
def deploy_template(self, template, *args, **kwargs):
if 'resourcepool' not in kwargs:
kwargs['resourcepool'] = None
vm = self._get_vm(template)
if vm:
vm.clone(kwargs['vm_name'],
sync_run=True,
resourcepool=self._get_resource_pool(
kwargs['resourcepool']))
return kwargs['vm_name']
else:
raise Exception('Could not clone %s' % template)
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
"""
_stats_available = {
'num_vm': lambda self: len(self.list_vm()),
'num_host': lambda self: len(self.list_host()),
'num_cluster': lambda self: len(self.list_cluster()),
'num_template': lambda self: len(self.list_template()),
'num_datastore': lambda self: len(self.list_datastore()),
}
def __init__(self, hostname, username, password, **kwargs):
self.api = VIServer()
self.api.connect(hostname, username, password)
def _get_vm(self, vm_name=None):
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def does_vm_exist(self, name):
try:
self._get_vm(name)
return True
except Exception:
return False
def _get_resource_pool(self, resource_pool_name=None):
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def get_ip_address(self, vm_name):
vm = self._get_vm(vm_name)
maxwait = 600
net_info = None
waitcount = 0
while net_info is None:
if waitcount > maxwait:
break
net_info = vm.get_property('net', False)
waitcount += 5
time.sleep(5)
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def _get_list_vms(self, get_template=False):
template_or_vm_list = []
props = self.api._retrieve_properties_traversal(property_names=['name', 'config.template'],
from_node=None,
obj_type=MORTypes.VirtualMachine)
for prop in props:
vm = None
template = None
for elem in prop.PropSet:
if elem.Name == "name":
vm = elem.Val
elif elem.Name == "config.template":
template = elem.Val
if vm is None or template is None:
continue
if template == bool(get_template):
template_or_vm_list.append(vm)
return template_or_vm_list
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError('This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self):
return self._get_list_vms()
def list_template(self):
return self._get_list_vms(get_template=True)
def list_flavor(self):
raise NotImplementedError('This function is not supported on this platform.')
def list_host(self):
return self.api.get_hosts()
def list_datastore(self):
return self.api.get_datastores()
def list_cluster(self):
return self.api.get_clusters()
def info(self):
return '%s %s' % (self.api.get_server_type(), self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' % vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self):
raise NotImplementedError('clone_vm not implemented.')
def deploy_template(self, template, *args, **kwargs):
if 'resourcepool' not in kwargs:
kwargs['resourcepool'] = None
vm = self._get_vm(template)
if vm:
vm.clone(kwargs['vm_name'], sync_run=True,
resourcepool=self._get_resource_pool(kwargs['resourcepool']))
return kwargs['vm_name']
else:
raise Exception('Could not clone %s' % template)
esx_host = vc2
else:
print "ERROR --> Please select a vCenter from list..."
exit(1)
else:
print "--> vCenter: " + esx_host
s = VIServer()
def connect_vsphere():
default_context = ssl._create_default_https_context
ssl._create_default_https_context = ssl._create_unverified_context
s.connect(esx_host, esx_username, esx_password)
connect_vsphere()
props = s._retrieve_properties_traversal(
property_names=['name', 'config.template'],
from_node=None,
obj_type=MORTypes.VirtualMachine)
for p in props:
mor = p.Obj
name = ""
is_template = False
for item in p.PropSet:
if item.Name == "name": name = item.Val
elif item.Name == "config.template": is_template = item.Val
if is_template: print "MOR:", mor, " - Name:", name
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
Args:
hostname: The hostname of the system.
username: The username to connect with.
password: The password to connect with.
Returns: A :py:class:`VMWareSystem` object.
"""
_api = None
_stats_available = {
'num_vm': lambda self: len(self.list_vm()),
'num_host': lambda self: len(self.list_host()),
'num_cluster': lambda self: len(self.list_cluster()),
'num_template': lambda self: len(self.list_template()),
'num_datastore': lambda self: len(self.list_datastore()),
}
def __init__(self, hostname, username, password, **kwargs):
self.hostname = hostname
self.username = username
self.password = password
self.api = VIServer()
@property
def api(self):
# wrap calls to the API with a keepalive check, reconnect if needed
try:
keepalive = self._api.keep_session_alive()
if not keepalive:
logger.debug('The connection to %s "%s" timed out' %
(type(self).__name__, self.hostname))
except VIException as ex:
if ex.fault == "Not Connected":
# set this to trigger a connection below
keepalive = None
else:
raise
if not keepalive:
self._connect()
return self._api
@api.setter
def api(self, api):
# Allow for changing the api object via public setter
self._api = api
def _connect(self):
# Since self.api calls _connect, connect via self._api to prevent implosion
logger.debug('Connecting to %s "%s"' % (type(self).__name__, self.hostname))
self._api.connect(self.hostname, self.username, self.password)
def _get_vm(self, vm_name=None):
""" Returns a vm from the VI object.
Args:
vm_name: The name of the VM.
Returns: a pysphere object.
"""
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def does_vm_exist(self, name):
""" Checks if a vm exists or not.
Args:
name: The name of the requested vm.
Returns: A boolean, ``True`` if the vm exists, ``False`` if not.
"""
try:
self._get_vm(name)
return True
except Exception:
return False
def _get_resource_pool(self, resource_pool_name=None):
""" Returns a resource pool MOR for a specified name.
Args:
resource_pool_name: The name of the resource pool.
Returns: The MOR of the resource pool.
"""
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def get_ip_address(self, vm_name):
""" Returns the first IP address for the selected VM.
Args:
vm_name: The name of the vm to obtain the IP for.
Returns: A string containing the first found IP that isn't the loopback device.
"""
vm = self._get_vm(vm_name)
try:
net_info, tc = wait_for(vm.get_property, ['net', False],
fail_condition=None, delay=5, num_sec=600,
message="get_ip_address from vsphere")
except TimedOutError:
net_info = None
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def _get_list_vms(self, get_template=False):
""" Obtains a list of all VMs on the system.
Optional flag to obtain template names too.
Args:
get_template: A boolean describing if it should return template names also.
Returns: A list of VMs.
"""
template_or_vm_list = []
props = self.api._retrieve_properties_traversal(property_names=['name', 'config.template'],
from_node=None,
obj_type=MORTypes.VirtualMachine)
for prop in props:
vm = None
template = None
for elem in prop.PropSet:
if elem.Name == "name":
vm = elem.Val
elif elem.Name == "config.template":
template = elem.Val
if vm is None or template is None:
continue
if template == bool(get_template):
template_or_vm_list.append(vm)
return template_or_vm_list
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError('This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self):
return self._get_list_vms()
def list_template(self):
return self._get_list_vms(get_template=True)
def list_flavor(self):
raise NotImplementedError('This function is not supported on this platform.')
def list_host(self):
return self.api.get_hosts()
def list_datastore(self):
return self.api.get_datastores()
def list_cluster(self):
return self.api.get_clusters()
def info(self):
return '%s %s' % (self.api.get_server_type(), self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' % vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self):
raise NotImplementedError('clone_vm not implemented.')
def deploy_template(self, template, *args, **kwargs):
if 'resourcepool' not in kwargs:
kwargs['resourcepool'] = None
vm = self._get_vm(template)
if vm:
vm.clone(kwargs['vm_name'], sync_run=True,
resourcepool=self._get_resource_pool(kwargs['resourcepool']))
return kwargs['vm_name']
else:
raise Exception('Could not clone %s' % template)
def remove_host_from_cluster(self, hostname):
req = VI.DisconnectHost_TaskRequestMsg()
mor = (key for key, value in self.api.get_hosts().items() if value == hostname).next()
sys = VIMor(mor, 'HostSystem')
_this = req.new__this(sys)
_this.set_attribute_type(sys.get_attribute_type())
req.set_element__this(_this)
task_mor = self.api._proxy.DisconnectHost_Task(req)._returnval
t = VITask(task_mor, self.api)
wait_for(lambda: 'success' in t.get_state())
self._destroy_host(hostname)
def _destroy_host(self, hostname):
req = VI.Destroy_TaskRequestMsg()
mor = (key for key, value in self.api.get_hosts().items() if value == hostname).next()
sys = VIMor(mor, 'HostSystem')
_this = req.new__this(sys)
_this.set_attribute_type(sys.get_attribute_type())
req.set_element__this(_this)
task_mor = self.api._proxy.Destroy_Task(req)._returnval
t = VITask(task_mor, self.api)
wait_for(lambda: 'success' in t.get_state())
def get_host_info(host_ip,host_name,host_password):
hosts_dict_data = []
server = VIServer()
server.connect(host_ip, host_name, host_password)
#print 'VC connect successful...'
#DebugInfo.objects.create(text_info='VC connect successful...')
for d, hname in server.get_hosts().items():
HostMemoryUsage = 0
HostCpuUsage = 0
HostTotalMemory = 0
HostNumCpuCores = 0
HostMhzPerCore = 0
HostStatus = ''
props = server._retrieve_properties_traversal(property_names=[
'name',
'summary.overallStatus',
'summary.quickStats.overallMemoryUsage',
'summary.quickStats.overallCpuUsage',
'summary.hardware.memorySize',
'summary.hardware.numCpuCores',
'summary.hardware.cpuMhz',
'hardware.biosInfo',
'hardware.systemInfo',
'summary.runtime.healthSystemRuntime.hardwareStatusInfo.cpuStatusInfo',
'summary.runtime.healthSystemRuntime.hardwareStatusInfo.memoryStatusInfo',
'summary.runtime.healthSystemRuntime.hardwareStatusInfo.storageStatusInfo'
], from_node=d, obj_type="HostSystem")
for prop_set in props:
# mor = prop_set.Obj #in case you need it
for prop in prop_set.PropSet:
if prop.Name == "summary.quickStats.overallMemoryUsage":
HostMemoryUsage = prop.Val
elif prop.Name == "summary.quickStats.overallCpuUsage":
HostCpuUsage = prop.Val
elif prop.Name == "summary.hardware.memorySize":
HostTotalMemory = (prop.Val / 1048576)
elif prop.Name == "summary.hardware.numCpuCores":
HostNumCpuCores = prop.Val
elif prop.Name == "summary.hardware.cpuMhz":
HostMhzPerCore = prop.Val
elif prop.Name == "summary.overallStatus":
HostStatus = prop.Val
if HostStatus == "green":
HostStatus = 0
elif HostStatus == "gray":
HostStatus = 1
elif HostStatus == "yellow":
HostStatus = 2
elif HostStatus == "red":
HostStatus = 3
elif prop.Name == "hardware.biosInfo":
HostBiosInfo = prop.Val.__dict__['_biosVersion']
# print HostBiosInfo
elif prop.Name == "hardware.systemInfo":
HostSystemInfo = prop.Val.__dict__
HostType = HostSystemInfo['_model']
elif prop.Name == "summary.runtime.healthSystemRuntime.hardwareStatusInfo.cpuStatusInfo":
HostHealthInfo_cpu = prop.Val.__dict__
for i in HostHealthInfo_cpu['_HostHardwareElementInfo']:
cpu = i.__dict__
cpu1 = cpu['_status'].__dict__
HostCPUHealthInfo = cpu1['_label']
elif prop.Name == "summary.runtime.healthSystemRuntime.hardwareStatusInfo.memoryStatusInfo":
HostHealthInfo_memory = prop.Val.__dict__
for i in HostHealthInfo_memory['_HostHardwareElementInfo']:
mem = i.__dict__
mem1 = mem['_status'].__dict__
# print mem1
HostMemHealthInfo = mem1['_label']
# print HostMemHealthInfo
elif prop.Name == "summary.runtime.healthSystemRuntime.hardwareStatusInfo.storageStatusInfo":
HostHealthInfo_storage = prop.Val.__dict__
HostRunningVMS = len(server.get_registered_vms(d, status='poweredOn'))
HostStoppedVMS = len(server.get_registered_vms(d, status='poweredOff'))
HostTotalVMS = len(server.get_registered_vms(d))
HostCpuTotal = (HostNumCpuCores * HostMhzPerCore)
HostMemoryUsagePercent = round((HostMemoryUsage * 100) / HostTotalMemory,2)
HostCpuUsagePercent = round(((HostCpuUsage * 100) / HostCpuTotal),2)
hosts_dict = {'hostnumber':d, 'hostname': hname.lower(), 'hoststatus': HostStatus, 'hostmemoryusage': HostMemoryUsage,
'hostcpuusage': HostCpuUsage, 'hosttotalmemory': HostTotalMemory, 'hostcputotal': HostCpuTotal,
'hostmemoryusagepercent': HostMemoryUsagePercent, 'hostcpuusagepercent': HostCpuUsagePercent,
'hostrunningvms': HostRunningVMS, 'hoststoppedvms': HostStoppedVMS, 'hosttotalvms': HostTotalVMS,
'hostbiosinfo': HostBiosInfo, 'hosttype': HostType, 'hostcpuhealthinfo': HostCPUHealthInfo}
hosts_dict_data.append(hosts_dict)
server.disconnect()
return hosts_dict_data
def create_vm():
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
# datacentername = "ha-datacenter"
datacentername = opts.datacenter
hostname = opts.hostname
annotation = "My Product Product Virtual Machine"
memorysize = opts.ram
cpucount = opts.cpus
# cd_iso_location =
# "iso/My_Product_2013_02_26_05_15_00.iso"
# # located in the ESX datastore
cd_iso_location = opts.iso
guestosid = "centos64Guest"
# find your os in
# http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html
disksize = (1024 ** 2) * 100 # In Kb: 1024 ** 2 (power) = 1GB; 1GB * 100 = 100GB.
# OPTIONAL PARAMETERS
datastorename = opts.datastore # if None, will use the first datastore available
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
# GET INITIAL PROPERTIES AND OBJECTS
# get datacenter
dcmor = s._get_datacenters()[datacentername]
dcprops = VIProperty(s, dcmor)
# get host folder
hfmor = dcprops.hostFolder._obj
# get computer resources
crmors = s._retrieve_properties_traversal(property_names=['name',
'host'], from_node=hfmor, obj_type='ComputeResource')
# get host
for hosts in s.get_hosts().items():
try:
if hosts.index(hostname) == 1:
hostmor = hosts[0]
except:
pass
# get computer resource of this host
crmor = None
for cr in crmors:
if crmor:
break
for p in cr.PropSet:
# print 'p.Name:', p.Name
if p.Name == "host":
for h in p.Val.get_element_ManagedObjectReference():
if h == hostmor:
crmor = cr.Obj
break
if crmor:
break
crprops = VIProperty(s, crmor)
# get resource pool
rpmor = crprops.resourcePool._obj
# get vmFolder
vmfmor = dcprops.vmFolder._obj
# CREATE VM CONFIGURATION
# get config target
request = VI.QueryConfigTargetRequestMsg()
_this = request.new__this(crprops.environmentBrowser._obj)
_this.set_attribute_type(crprops.environmentBrowser._obj.get_attribute_type())
request.set_element__this(_this)
h = request.new_host(hostmor)
h.set_attribute_type(hostmor.get_attribute_type())
request.set_element_host(h)
config_target = s._proxy.QueryConfigTarget(request)._returnval
# get default devices
request = VI.QueryConfigOptionRequestMsg()
_this = request.new__this(crprops.environmentBrowser._obj)
_this.set_attribute_type(crprops.environmentBrowser._obj.get_attribute_type())
request.set_element__this(_this)
h = request.new_host(hostmor)
h.set_attribute_type(hostmor.get_attribute_type())
request.set_element_host(h)
config_option = s._proxy.QueryConfigOption(request)._returnval
defaul_devs = config_option.DefaultDevice
# get network name
# would be assigned to the last known working network interface.
# in this case, it would be VM Network 2.
network_name = None
for n in config_target.Network:
if n.Network.Accessible:
network_name = n.Network.Name
# can hard-code it as 'VM Network'
# get datastore
# Just verifies that the datastorename mentioned at the top matches with the
# available list of datastores.
ds = None
for d in config_target.Datastore:
if d.Datastore.Accessible and (datastorename and d.Datastore.Name
== datastorename) or (not datastorename):
ds = d.Datastore.Datastore
datastorename = d.Datastore.Name
break
if not ds:
raise Exception("couldn't find datastore")
volume_name = "[%s]" % datastorename
# add parameters to the create vm task
create_vm_request = VI.CreateVM_TaskRequestMsg()
config = create_vm_request.new_config()
vmfiles = config.new_files()
vmfiles.set_element_vmPathName(volume_name)
config.set_element_files(vmfiles)
config.set_element_name(vmname)
config.set_element_annotation(annotation)
config.set_element_memoryMB(memorysize)
config.set_element_numCPUs(cpucount)
config.set_element_guestId(guestosid)
devices = []
# add a scsi controller
disk_ctrl_key = 1
scsi_ctrl_spec = config.new_deviceChange()
scsi_ctrl_spec.set_element_operation('add')
scsi_ctrl = VI.ns0.VirtualLsiLogicController_Def("scsi_ctrl").pyclass()
scsi_ctrl.set_element_busNumber(0)
scsi_ctrl.set_element_key(disk_ctrl_key)
scsi_ctrl.set_element_sharedBus("noSharing")
scsi_ctrl_spec.set_element_device(scsi_ctrl)
devices.append(scsi_ctrl_spec)
# find ide controller
ide_ctlr = None
for dev in defaul_devs:
if dev.typecode.type[1] == "VirtualIDEController":
ide_ctlr = dev
# add a cdrom based on a physical device
if ide_ctlr:
cd_spec = config.new_deviceChange()
cd_spec.set_element_operation('add')
cd_ctrl = VI.ns0.VirtualCdrom_Def("cd_ctrl").pyclass()
cd_device_backing = VI.ns0.VirtualCdromIsoBackingInfo_Def("cd_device_backing").pyclass()
ds_ref = cd_device_backing.new_datastore(ds)
ds_ref.set_attribute_type(ds.get_attribute_type())
cd_device_backing.set_element_datastore(ds_ref)
cd_device_backing.set_element_fileName("%s %s" % (volume_name,
cd_iso_location))
cd_ctrl.set_element_backing(cd_device_backing)
cd_ctrl.set_element_key(20)
cd_ctrl.set_element_controllerKey(ide_ctlr.get_element_key())
cd_ctrl.set_element_unitNumber(0)
cd_spec.set_element_device(cd_ctrl)
devices.append(cd_spec)
# create a new disk - file based - for the vm
disk_spec = config.new_deviceChange()
disk_spec.set_element_fileOperation("create")
disk_spec.set_element_operation("add")
disk_ctlr = VI.ns0.VirtualDisk_Def("disk_ctlr").pyclass()
disk_backing = VI.ns0.VirtualDiskFlatVer2BackingInfo_Def("disk_backing").pyclass()
disk_backing.set_element_fileName(volume_name)
disk_backing.set_element_diskMode("persistent")
disk_backing.ThinProvisioned = True
disk_ctlr.set_element_key(0)
disk_ctlr.set_element_controllerKey(disk_ctrl_key)
disk_ctlr.set_element_unitNumber(0)
disk_ctlr.set_element_backing(disk_backing)
disk_ctlr.set_element_capacityInKB(disksize)
disk_spec.set_element_device(disk_ctlr)
devices.append(disk_spec)
# add a NIC. the network Name must be set as the device name to create the NIC.
nic_spec = config.new_deviceChange()
if network_name:
nic_spec.set_element_operation("add")
nic_ctlr = VI.ns0.VirtualPCNet32_Def("nic_ctlr").pyclass()
nic_backing = VI.ns0.VirtualEthernetCardNetworkBackingInfo_Def("nic_backing").pyclass()
nic_backing.set_element_deviceName(network_name)
nic_ctlr.set_element_addressType("generated")
nic_ctlr.set_element_backing(nic_backing)
nic_ctlr.set_element_key(4)
nic_spec.set_element_device(nic_ctlr)
devices.append(nic_spec)
config.set_element_deviceChange(devices)
create_vm_request.set_element_config(config)
folder_mor = create_vm_request.new__this(vmfmor)
folder_mor.set_attribute_type(vmfmor.get_attribute_type())
create_vm_request.set_element__this(folder_mor)
rp_mor = create_vm_request.new_pool(rpmor)
rp_mor.set_attribute_type(rpmor.get_attribute_type())
create_vm_request.set_element_pool(rp_mor)
host_mor = create_vm_request.new_host(hostmor)
host_mor.set_attribute_type(hostmor.get_attribute_type())
create_vm_request.set_element_host(host_mor)
# CREATE THE VM
taskmor = s._proxy.CreateVM_Task(create_vm_request)._returnval
task = VITask(taskmor, s)
task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if task.get_state() == task.STATE_ERROR:
raise Exception("Error creating vm: %s" %
task.get_error_message())
# Here you should power your VM (refer to the pysphere documentation)
# So it boots from the specified ISO location
try:
new_vm = s.get_vm_by_name(opts.name)
connect_vm_cdroms(new_vm, s)
try:
new_vm.power_on()
except Exception as e:
print "Failed to power-on the new VM using:", opts.name
print "Exception:", str(e)
except Exception as e:
print "Failed to locate the new VM using:", opts.name
print "Exception:", str(e)
# disconnect from the server
s.disconnect()
def main():
parser = argparse.ArgumentParser(
description=
'Roster_builder builds out an YAML roster file by querying vcenter.')
parser.add_argument("-u",
"--username",
help="Vcenter username.",
default="admin")
parser.add_argument("-c",
"--cluster",
help="Specify cluster to grab node data for. Ex: ACDP")
parser.add_argument("-s",
"--site",
help="Build a roster for a specific site.",
default=0)
parser.add_argument(
"-f",
"--file",
help="Name of roster file to write to [Default: roster.txt]",
default="roster.txt")
parser.add_argument(
"-F",
"--format",
help=
"Output format. Supported types are YAML,JSON,CSV. [Default: YAML]",
default="YAML")
parser.add_argument(
"-p",
"--poweredoff",
help="Include powered off machines in output. [Default: off]",
action='store_true')
args = parser.parse_args()
server = VIServer()
vmlist = []
f = open(args.file, 'w')
if args.site:
site_dict = vcenter_lookup(args.site)
print "Using site data: ", site_dict
else:
site_dict = vcenters
print "Enter vcenter password for", args.username
password = getpass.getpass('Password:'******':\n')
if args.cluster is None:
clusters = server.get_clusters().iteritems()
else:
clusters = {"key": args.cluster}.iteritems()
# Grab hosts by cluster
for key, value in clusters:
print "Cluster: ", value
cluster = [
k for k, v in server.get_clusters().iteritems() if v == value
]
for node in cluster:
vmlist = server._retrieve_properties_traversal(
property_names=props,
from_node=node,
obj_type=MORTypes.VirtualMachine)
if vmlist is None:
continue
f.write(' ' + value + ':\n')
for vm in vmlist:
try:
prop_set = vm.PropSet
except AttributeError:
continue
hostName = ""
ipAddress = ""
powerState = ""
name = ""
for prop in prop_set:
if prop.Name == 'config.guestFullName':
guestFullName = prop.Val
if prop.Name == 'summary.runtime.powerState':
powerState = prop.Val
elif prop.Name == 'name':
name = prop.Val
elif prop.Name == 'guest.toolsVersionStatus':
toolsStatus = prop.Val
elif prop.Name == 'guest.hostName':
hostName = prop.Val
elif prop.Name == 'guest.ipAddress':
ipAddress = prop.Val
state, info = guest_tools_map.get(toolsStatus,
(3, "toolsUnknown"))
toolsStatus = guest_tools_map.get(toolsStatus, state)
if hostName == "":
hostName = name
if powerState == 'poweredOff' and args.poweredoff is None:
continue
f.write(' ' + hostName + ':\n')
f.write(' ipAddress: ' + ipAddress + '\n')
f.write(' guestOS: ' + guestFullName + '\n')
f.write(' powerState: ' + powerState + '\n')
f.write(' toolsStatus: ' + info + '\n')
def VirtualMachine_ServerList(VIServer, categories, cluster=None, status=None, tagID=201):
"""
Die Funktion hollt sich als erstes die Informationen "customValue" und "config.files.vmPathName" aka. den Pfad aller VMs aus dem Server raus.
Daraus werden nur die VMs genomen, die den Schluessel 201 aka. "Shutdown-Reihenfolge" besitzen und der mit den uebergeben Parametern uebereinstimmt.
Folgend darauf werden alle laufende VMs gelistet. Diese werden dann mit den VMs die zufor ausgefiltert worden sind abgegliechen und als eine Liste zurueck gegeben.
"""
if status and cluster:
VirtualMachineFetchResult = VIServer.get_registered_vms(cluster=cluster, status=status)
logger.info("Fetching Virtual Machines from cluster: '" + cluster + "' with the status: '" + status + "'")
elif status and cluster is None:
VirtualMachineFetchResult = VIServer.get_registered_vms(status=status)
logger.info("Fetching Virtual Machines with the status: '" + status + "'")
elif cluster and status is None:
VirtualMachineFetchResult = VIServer.get_registered_vms(cluster=cluster)
logger.info("Fetching Virtual Machines from cluster: '" + cluster + "'")
else:
VirtualMachineFetchResult = VIServer.get_registered_vms()
logger.info("Fetching all Virtual Machines from vSphere")
if categories and tagID:
logger.info(
"Filtering Virtual Machines by annotation ID: " + str(tagID) + " with the following content: " + ", ".join(
categories))
VirtualMachineList = []
VirtualMachinesWithAnnotation = []
VirtualMachinesRelated = []
ProperetyNames = ['customValue', 'config.files.vmPathName', 'config.template']
ProperetyResults = VIServer._retrieve_properties_traversal(property_names=ProperetyNames, obj_type="VirtualMachine")
for obj in ProperetyResults:
VirtualMachine = {'annotations': []}
VirtualMachineList.append(VirtualMachine)
if not hasattr(obj, "PropSet"):
continue
for prop in obj.PropSet:
if prop.Name == "name":
VirtualMachine['name'] = prop.Val
elif prop.Name == "config.files.vmPathName":
VirtualMachine['path'] = prop.Val
elif prop.Name == "config.template":
VirtualMachine['is_template'] = prop.Val
elif prop.Name == "customValue":
for annotation in prop.Val.CustomFieldValue:
VirtualMachine['annotations'].append((annotation.Key, annotation.Value))
for VirtualMachine in VirtualMachineList:
if not VirtualMachine['is_template']:
for annotation in VirtualMachine['annotations']:
if tagID in annotation:
for category in categories:
if category in annotation:
VirtualMachinesWithAnnotation.append(VirtualMachine['path'])
for i in VirtualMachinesWithAnnotation:
if i in VirtualMachineFetchResult:
VirtualMachinesRelated.append(i)
return VirtualMachinesRelated
else:
return VirtualMachineFetchResult
def main():
parser = argparse.ArgumentParser(description='Roster_builder builds out an YAML roster file by querying vcenter for the specified regex.')
parser.add_argument("-r", "--regex", help="Regex search string. Example: \"dfw1-access0[0-9].*\"", default=".*")
parser.add_argument("-u", "--username", help="Vcenter username.", default="admin")
parser.add_argument("-c", "--cluster", help="Specify cluster to grab node data for. Ex: ACDP")
parser.add_argument("-s", "--site", help="Build a roster for a specific site.", default=0)
parser.add_argument("-f", "--file", help="Name of roster file to write to [Default: roster.txt]", default="roster.txt")
args = parser.parse_args()
server = VIServer()
properties = ['name', 'summary.runtime.powerState', 'config.guestFullName', 'guest.ipAddress', 'guest.hostName', 'guest.toolsRunningStatus']
hosts = []
vmlist = []
regex = args.regex
f = open(args.file, 'w')
if args.site:
site_dict = vcenter_lookup(args.site)
print "Using site data: ",site_dict
else:
site_dict = vcenters
print "Enter vcenter password for", args.username
password = getpass.getpass('Password:'******':\n')
if args.cluster is None:
clusters = server.get_clusters().iteritems()
else:
clusters = { "key": args.cluster }.iteritems()
for key, value in clusters:
cluster = [k for k,v in server.get_clusters().iteritems() if v==value]
print "Cluster: ",value
for node in cluster:
vmlist = server._retrieve_properties_traversal(
property_names=properties,
from_node=node,
obj_type=MORTypes.VirtualMachine)
if vmlist is None:
continue
f.write(' '+value+':\n')
for vm in vmlist:
try:
prop_set = vm.PropSet
except AttributeError:
continue
for prop in prop_set:
if prop.Name == 'summary.runtime.powerState':
powerState = prop.Val
elif prop.Name == 'guest.hostName':
hostName = prop.Val
elif prop.Name == 'config.guestId':
guestId = prop.Val
elif prop.Name == 'guest.ipAddress':
ipAddress = prop.Val
elif prop.Name == 'name':
name = prop.Val
elif prop.Name == 'guest.toolsRunningStatus':
toolsRunningStatus = prop.Val
if powerState == 'poweredOff':
toolsRunningStatus = 'poweredOff'
if re.search(regex,hostName):
f.write(' '+ hostName + ':\n')
f.write(' ipAddress: ' + ipAddress + '\n')
f.write(' powerState: ' + powerState + '\n')
f.write(' toolsRunningStatus: ' + toolsRunningStatus + '\n')
# Legacy Python that doesn't verify HTTPS certificates by default
pass
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
from pysphere import VIServer
server = VIServer()
HOST = "172.17.11.74"
LOGIN = "******"
PASSWORD = "******"
server.connect(HOST, LOGIN, PASSWORD)
oc = []
oc.append(server._retrieve_properties_traversal(obj_type='VirtualMachine'))
power = []
machines = server.get_registered_vms()
for machine in server.get_registered_vms():
power.append(server.get_vm_by_path(machine).get_status())
zindex = -1
for elem in oc:
for b in elem:
s = (b)
zindex = zindex + 1
print "vmrc://" + LOGIN + ":" + PASSWORD + "@" + HOST + ":443/?moid=" + s.Obj, machines[zindex], power[zindex]
def get_vms_info(host_ip,host_name,host_password):
vms_dict_data = []
server = VIServer()
server.connect(host_ip, host_name, host_password)
# print 'VC connect successful...'
#DebugInfo.objects.create(text_info='VM connect successful...')
vms_info = {}
# VMware API接口定义
properties = [
'summary.vm',
'summary.config.numEthernetCards',
'summary.config.annotation',
'summary.config.numVirtualDisks',
'summary.quickStats.overallCpuUsage',
'summary.quickStats.guestMemoryUsage',
'summary.quickStats.ftLogBandwidth',
'summary.quickStats.hostMemoryUsage',
'summary.quickStats.uptimeSeconds',
'summary.runtime.powerState',
'summary.runtime.bootTime',
'summary.runtime.host',
'summary.runtime.maxCpuUsage',
'summary.runtime.maxMemoryUsage',
'summary.storage.committed',
'summary.storage.uncommitted',
'summary.storage.unshared',
'summary.storage.timestamp',
'guestHeartbeatStatus',
'guest.toolsStatus',
'guest.toolsVersionStatus',
'guest.toolsVersion',
'guest.guestId',
'guest.guestFullName',
'guest.guestState',
'guest.ipAddress',
'guest.hostName',
'name',
'parent',
'config.template',
'config.hardware.numCPU',
'config.hardware.memoryMB'
]
# 通过_retrieve_properties_traversal方法传入API接口定义拿到对象类型为 VirtualMachine 的信息
props = server._retrieve_properties_traversal(property_names=properties, obj_type='VirtualMachine')
# 通过server.get_hosts()拿到VC下面所有的host信息（字典）；
# 通过这个方法可以把'guest.hostName'取出的MOR对象转换成实际的hostname
# hostname = server.get_hosts().items()
for prop in props:
mor = prop.Obj
vm = {}
for p in prop.PropSet:
vm[p.Name] = p.Val
vms_info[mor] = vm
vms_dict = vms_info.values()
for i in range(len(vms_dict)):
vm = vms_dict[i]
# pprint.pprint(vm)
#DebugInfo.objects.create(text_info=vm)
vms_dict_data.append(vm)
#DebugInfo.objects.create(text_info=vms_dict_data)
#print 'VC disconnect successful...'
server.disconnect()
return vms_dict_data
class Vmware:
def __init__(self):
self.host = config.vmware_host
self.user = config.vmware_user
self.pwd = config.vmware_pass
self.connection = VIServer()
self.connection.connect(self.host, self.user, self.pwd)
self.props = VIProperty(self.connection, self.connection._do_service_content.CustomFieldsManager)
self.custom_fields = dict((cf.key, cf.name) for cf in self.props.field)
def get_servers(self):
obj_type = 'HostSystem'
return self._get_initial_data(relations.vmware_server, obj_type)
def get_hypervisors(self):
obj_type = 'HostSystem'
return self._get_initial_data(relations.vmware_hypervisor, obj_type)
def get_virtual_machines(self):
obj_type = 'VirtualMachine'
return self._get_initial_data(relations.vmware_virtual_machine, obj_type)
def get_farm(self):
obj_type = 'ClusterComputeResource'
return self._get_initial_data(relations.vmware_farm, obj_type)
def get_os_versions(self):
hosts_os_versions = self._get_initial_data(relations.vmware_hosts_os_versions, 'HostSystem')
vms_os_versions = self._get_initial_data(relations.vmware_vms_os_versions, 'VirtualMachine')
os_versions = []
hosts_os_versions.extend(vms_os_versions)
for os_version in hosts_os_versions:
if len(os_version.keys()) >= 2:
if os_version not in os_versions:
os_versions.append(os_version)
return os_versions
def get_os_familys(self):
hosts_os_familys = self.get_facts('summary.config.product.name', 'HostSystem')
vms_os_familys = self.get_facts('guest.guestFamily', 'VirtualMachine')
os_familys = []
for os_family in hosts_os_familys | vms_os_familys:
os_familys.append({'name': os_family})
return os_familys
def get_brands(self):
facts_brand = self.get_facts('summary.hardware.vendor', 'HostSystem')
brands = []
for brand in facts_brand:
brands.append({'name': brand})
return brands
def get_models(self):
obj_type = 'HostSystem'
return self._get_initial_data(relations.vmware_models, obj_type)
def _get_initial_data(self, data_map, obj_type):
properties = self.connection._retrieve_properties_traversal(property_names=data_map.values(), obj_type=obj_type)
result = []
for obj in properties:
if not hasattr(obj, "PropSet"):
continue
host = {}
result.append(host)
for prop in obj.PropSet:
for key, value in data_map.iteritems():
if prop.Name == value:
if prop.Name == "summary.hardware.otherIdentifyingInfo":
for license_info in prop.Val.HostSystemIdentificationInfo:
if 'Service tag of the system' in license_info.IdentifierType.Summary:
host['serialnumber'] = license_info.IdentifierValue
elif 'Product ID:' in license_info.IdentifierValue:
host['asset_number'] = license_info.IdentifierValue.split(": ")[1]
elif prop.Name == "customValue":
for annotation in prop.Val.CustomFieldValue:
try:
host['description'] += str(self.custom_fields.get(annotation.Key)) + ": " + str(annotation.Value) + "\n"
except KeyError:
host['description'] = str(self.custom_fields.get(annotation.Key)) + ": " + str(annotation.Value) + "\n"
elif prop.Name == "summary.hardware.memorySize":
host[key] = prop.Val / (1024 * 1024)
else:
try:
host[key] = prop.Val
except SyntaxError:
host[key] = None
return result
def get_relations(self, first_fact, second_fact, obj_type):
result = {}
data_map = {'first_fact': first_fact,
'second_fact': second_fact
}
data = self._get_initial_data(data_map, obj_type)
for item in data:
try:
result[item['first_fact']] = item['second_fact']
except KeyError:
continue
return result
def get_facts(self, fact_name, obj_type):
data_map = {'fact_name': fact_name}
data = self._get_initial_data(data_map, obj_type)
result = set()
for item in data:
try:
result.add(item['fact_name'])
except KeyError:
continue
return result
def __del__(self):
self.connection.disconnect()
class Creator:
# todo; add comment
"""
"""
def __init__(self, manager_address, manager_user, manager_password):
"""
:param manager_address:
:param manager_user:
:param manager_password:
"""
self.esx_server = VIServer()
self.esx_address = manager_address
self.esx_user = manager_user
self.esx_password = manager_password
def __del__(self):
self._disconnect_from_esx()
# todo; add comment
def _connect_to_esx(self):
"""
:raise:
"""
if not self.esx_server.is_connected():
try:
self.esx_server.connect(self.esx_address, self.esx_user, self.esx_password)
except Exception as inst:
raise CreatorException(str(inst))
def _disconnect_from_esx(self):
# todo; add comment
"""
"""
if self.esx_server.is_connected():
self.esx_server.disconnect()
def create_resource_pool(
self,
name,
parent_rp="/",
esx_hostname=None,
cpu_resources=("normal", 4000, 0, True, -1),
memory_resources=("normal", 163840, 0, True, -1),
):
"""
Creates a resource pool on esx server
name - name for new resource pool
parent_pr - parent resource pool
esx_hostname - host name of esx server when resource pool will be created
cpu_resources and memory_resources: tuple
0:share level - 'low' 'normal' 'high' 'custom'
1:share value - 'custom' share value, int
2:reservation - reserved CPU/Memory, int
3:expandable reservation - bool
4:limit - -1 - unlimited, another value - limit value, int
:raise: CreatorException
"""
self._connect_to_esx()
if parent_rp == "/":
parent_rpmor = None
try:
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == "/Resources"]
except IndexError:
raise CreatorException("Couldn't find parent resource pool")
if len(rp_mor_temp) == 0:
raise CreatorException("Couldn't find parent resource pool")
if esx_hostname:
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
if prop.parent.name == esx_hostname:
parent_rpmor = rp
break
if not parent_rpmor:
raise CreatorException("Couldn't find host")
else:
parent_rpmor = rp_mor_temp[0]
else:
parent_rp = "/Resources" + parent_rp
parent_rpmor = None
try:
parent_rp_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == parent_rp]
except IndexError:
raise CreatorException("Couldn't find parent a resource pool")
if len(parent_rp_temp) == 0:
raise CreatorException("Couldn't find parent a resource pool")
##222
if len(parent_rp_temp) == 1:
parent_rpmor = parent_rp_temp[0]
elif esx_hostname:
for rp in parent_rp_temp:
prop = VIProperty(self.esx_server, rp)
while prop.parent.name != "host":
prop = prop.parent
if prop.name == esx_hostname:
parent_rpmor = rp
break
else:
raise CreatorException("ESX Hostname must be specified")
req = VI.CreateResourcePoolRequestMsg()
_this = req.new__this(parent_rpmor)
_this.set_attribute_type(parent_rpmor.get_attribute_type())
req.set_element__this(_this)
req.Name = name
spec = req.new_spec()
cpu_allocation = spec.new_cpuAllocation()
memory_allocation = spec.new_memoryAllocation()
# cpu allocation settings
shares = cpu_allocation.new_shares()
shares.Level = cpu_resources[0]
shares.Shares = cpu_resources[1]
cpu_allocation.Shares = shares
cpu_allocation.Reservation = cpu_resources[2]
cpu_allocation.ExpandableReservation = cpu_resources[3]
cpu_allocation.Limit = cpu_resources[4]
spec.CpuAllocation = cpu_allocation
# memory allocation settings
shares = memory_allocation.new_shares()
shares.Level = memory_resources[0]
shares.Shares = memory_resources[1]
memory_allocation.Shares = shares
memory_allocation.Reservation = memory_resources[2]
memory_allocation.ExpandableReservation = memory_resources[3]
memory_allocation.Limit = memory_resources[4]
spec.MemoryAllocation = memory_allocation
req.Spec = spec
try:
self.esx_server._proxy.CreateResourcePool(req)
except Exception as inst:
self._disconnect_from_esx()
inst = str(inst)
if "already exist" in inst:
raise ExistenceException("Couldn't create resource pool '%s', because it already exist" % name)
else:
raise CreatorException("Couldn't create the resource pool with name '%s'" % name)
def destroy_resource_pool(self, name, esx_hostname=None):
"""
Destroy named resource pool; vm included in this pool will be thrown
on upper resource pool
:param esx_hostname: host name of esx server, which contains resource pool
:param name: name of resource pool
:raise: CreatorException, ExistenceException
"""
self._connect_to_esx()
if name[0] != "/":
rp_name = "/Resources/" + name
else:
rp_name = "/Resources" + name
try:
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == rp_name]
except IndexError:
raise ExistenceException("Couldn't find resource pool '%s'" % name)
rpmor = ""
if esx_hostname:
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
while prop.parent.name != "host":
prop = prop.parent
if prop.name == esx_hostname:
rpmor = rp
break
elif len(rp_mor_temp) == 1:
rpmor = rp_mor_temp[0]
else:
raise CreatorException("ESX Hostname must be specified")
req = VI.Destroy_TaskRequestMsg()
_this = req.new__this(rpmor)
_this.set_attribute_type(rpmor.get_attribute_type())
req.set_element__this(_this)
try:
self.esx_server._proxy.Destroy_Task(req)
# self._disconnect_from_esx()
except Exception:
self._disconnect_from_esx()
raise
def destroy_resource_pool_with_vms(self, name, esx_hostname=None):
"""
Destroy named resource pool; vm included in this pool also will be destroyed
:param name: name of resource pool
:param esx_hostname: host name of esx server, which contains resource pool
:raise: CreatorException, ExistenceException
"""
self._connect_to_esx()
if not name:
raise CreatorException("Couldn't specify resource pool name")
if name[0] != "/":
rp_name = "/Resources/" + name
else:
rp_name = "/Resources" + name
try:
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == rp_name]
except IndexError:
raise CreatorException("Couldn't find resource pool '%s'" % name)
rpmor = ""
if esx_hostname:
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
while prop.parent.name != "host":
prop = prop.parent
if prop.name == esx_hostname:
rpmor = rp
break
elif len(rp_mor_temp) == 1:
rpmor = rp_mor_temp[0]
else:
raise ExistenceException("Couldn't find resource pool '%s'" % name)
prop = VIProperty(self.esx_server, rpmor)
vms = [str(k.name) for k in prop.vm]
for k in vms:
self.destroy_vm(k)
self.destroy_resource_pool(rp_name[10:], esx_hostname)
# self._disconnect_from_esx()
def destroy_vm(self, vmname):
"""
Destroys virtual machine by name
:param vmname: virtual machine name
:raise: ExistenceException, CreatorException
"""
self._connect_to_esx()
try:
vm = self.esx_server.get_vm_by_name(vmname)
except Exception as error:
self._disconnect_from_esx()
raise ExistenceException("Couldn't find VM '%s' - %s" % (vmname, error.message))
try:
if vm.is_powered_on() or vm.is_powering_off() or vm.is_reverting():
vm.power_off()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = self.esx_server._proxy.Destroy_Task(request)._returnval
# Wait for the task to finish
task = VITask(ret, self.esx_server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status != task.STATE_SUCCESS:
raise CreatorException("Couldn't destroy vm - " + task.get_error_message())
except Exception:
self._disconnect_from_esx()
raise CreatorException("Couldn't destroy the virtual machine %s" % vmname)
def create_vm_old(
self,
vmname,
esx_hostname=None,
iso=None,
datacenter=None,
resource_pool="/",
networks=None,
datastore=None,
description=None,
guestosid="debian4Guest",
memorysize=512,
cpucount=1,
disk_space=1048576,
):
"""
Creates virtual machine
:param vmname: name of virtual machine
:param esx_hostname: host's name, when vm will be created; if not specified
and ESX contains more than 1 hosts - raise CreatorException
:param iso: path to .ISO image; must be stored in the same datastore
as the virtual machine is created
:param datacenter: name of datacenter, which contain hosts and datastores
:param resource_pool: name of resource pool, when VM will be created
(e.g. win-servers/win2003)
if resource_pool_path is not defined, VM will created in root of inventory
:param networks: list of existing port groups. NIC are based on this list
:param datastore: name of datastore, which will be contain VM files; if not
specified, VM will be placed in first datastore, which is avaliable
for chosen host
:param description: description for VM
:param guestosid: ID for guest OS; full list
http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html
:param memorysize: size of RAM, which will be avaliable on VM, in Mb
:param cpucount: count of CPU, which will be avaliable on VM
:param create_hard_drive: if True, new .vmdk disk will be created and added to VM
:param disk_space: hard drive's maximal size, in Kb
"""
params = {}
if vmname:
params["vm_name"] = vmname
else:
raise AttributeError("Couldn't specify a virtual machine name")
if iso:
params["iso"] = iso
if datacenter:
params["datacenter_name"] = datacenter
if datastore:
params["datastore_name"] = datastore
if resource_pool:
params["resource_pool_name"] = resource_pool
if not networks:
networks = []
if networks:
params["networks"] = networks
if not description:
params["description"] = "Description of %s" % vmname
else:
params["description"] = description
params["esx_hostname"] = esx_hostname
params["guestosid"] = guestosid
params["memory_size"] = memorysize
params["cpu_count"] = cpucount
params["disk_size"] = disk_space
try:
self.create_vm(params)
except ExistenceException as error:
raise
except CreatorException as error:
raise
except Exception as error:
raise
def create_vm(self, vm_options):
"""
Creates a virtual machine on ESXi server
:param vm_options: dict, which contain parameters for VM
'vm_name'
'iso'
'datacenter_name'
'datastore_name'
'resource_pool_name'
'networks'
'description'
'esx_hostname'
'hard_drive'
'guestosid'
'memory_size'
'cpu_count'
'disk_size'
See create_vm_old for details
:raise: CreatorException, ExistenceException
"""
self._connect_to_esx()
# VM NAME
vm_name = None
try:
vm_name = str(vm_options["vm_name"])
vm_temp = self.esx_server.get_vm_by_name(vm_name)
if vm_temp:
raise ExistenceException('VM "%s" already exists' % vm_name)
except KeyError:
raise CreatorException("Must specify VM name")
except pysphere.VIException as inst:
if "[Object Not Found]" in str(inst):
pass
# HOSTNAME
hosts = self.esx_server.get_hosts()
try:
esx_hostname = vm_options["esx_hostname"]
if not esx_hostname:
raise KeyError
elif not (esx_hostname in hosts.values()):
raise CreatorException("Couldn't find host '%s'" % esx_hostname)
except KeyError:
if len(hosts.values()) > 1:
raise CreatorException("More than 1 host - must specify ESX Hostname")
elif not hosts.values():
raise CreatorException("Couldn't find available host")
esx_hostname = hosts[0]
# MOR and PROPERTIES
hostmor = [k for k, v in hosts.items() if v == esx_hostname][0]
hostprop = VIProperty(self.esx_server, hostmor)
# DATACENTER - FIX EXCEPTION
# todo: fix self.esx_server.get_datacenters().values()
dcs = self.esx_server.get_datacenters()
dc_values = dcs.values()
try:
dc_name = vm_options["datacenter_name"]
if not dc_name in dc_values:
raise CreatorException("Couldn't find datacenter '%s'" + dc_name)
except KeyError:
if len(dc_values) > 1:
raise CreatorException("More than 1 datacenter - must specify ESX Hostname")
elif not dc_values:
raise CreatorException("Couldn't find available datacenter")
dc_name = dc_values[0]
# MOR and PROPERTIES
dcmor = [k for k, v in dcs.items() if v == dc_name][0]
dcprops = VIProperty(self.esx_server, dcmor)
# DATASTORE
dcs = hostprop.datastore
try:
ds_name = vm_options["datastore_name"]
ds_list = []
for ds in dcs:
ds_list.append(ds.name)
if not ds_name in ds_list:
raise CreatorException("Couldn't find datastore or datastore is not available")
except KeyError:
if len(dcs) > 1:
raise CreatorException("More than 1 datastore on ESX - must specify datastore name")
elif not dcs:
raise CreatorException("Couldn't find available datastore")
ds_name = dcs[0].name
# RESOURCE POOL
resource_pool_name = ""
try:
resource_pool_name = vm_options["resource_pool_name"]
if resource_pool_name == "/":
pass
elif resource_pool_name[0] != "/":
resource_pool_name = "/{0}".format(resource_pool_name)
except KeyError:
resource_pool_name = "/"
finally:
rpmor = self._fetch_resource_pool(resource_pool_name, esx_hostname)
if not rpmor:
raise CreatorException("Couldn't find resource pool '%s'" % resource_pool_name)
# NETWORKS
try:
networks = list(vm_options["networks"])
except Exception:
networks = []
try:
iso = vm_options["iso"]
if iso == False:
iso = None
else:
# todo: hide magic
iso = iso[iso.find(ds_name) + len(ds_name) + 1 :]
except KeyError:
iso = None
# Description
try:
description = vm_options["description"]
except KeyError:
description = "Description for VM %s" % vm_name
try:
guestosid = vm_options["guestosid"]
except KeyError:
guestosid = "otherGuest"
try:
memory_size = int(vm_options["memory_size"])
if memory_size <= 0:
raise CreatorException("Disk size must be greater than 0")
except Exception:
memory_size = DEFAULT_MEMORY_SIZE # MB
try:
cpu_count = int(vm_options["cpu_count"])
except Exception:
cpu_count = DEFAULT_CPU_COUNT
try:
disk_size = int(vm_options["disk_size"])
if disk_size < 0:
raise CreatorException("Disk size must be greater than 0")
except Exception:
disk_size = DEFAULT_DISK_SIZE # KB
crprops = self._fetch_computer_resource(dcprops, hostmor)
vmfmor = dcprops.vmFolder._obj
# CREATE VM CONFIGURATION
# get config target
request = VI.QueryConfigTargetRequestMsg()
_this = request.new__this(crprops.environmentBrowser._obj)
_this.set_attribute_type(crprops.environmentBrowser._obj.get_attribute_type())
request.set_element__this(_this)
h = request.new_host(hostmor)
h.set_attribute_type(hostmor.get_attribute_type())
request.set_element_host(h)
config_target = self.esx_server._proxy.QueryConfigTarget(request)._returnval
# get default devices
request = VI.QueryConfigOptionRequestMsg()
_this = request.new__this(crprops.environmentBrowser._obj)
_this.set_attribute_type(crprops.environmentBrowser._obj.get_attribute_type())
request.set_element__this(_this)
h = request.new_host(hostmor)
h.set_attribute_type(hostmor.get_attribute_type())
request.set_element_host(h)
config_option = self.esx_server._proxy.QueryConfigOption(request)._returnval
defaul_devs = config_option.DefaultDevice
# get network name
avaliable_networks = 0
for net in networks:
for n in config_target.Network:
if n.Network.Accessible and n.Network.Name == net:
avaliable_networks += 1
break
if len(networks) != avaliable_networks:
msg = ""
for n in config_target.Network:
msg = "%s %s" % (msg, str(n.Network.Name))
raise CreatorException("Couldn't find all networks; founded: %s" % msg)
# raise ExistenceException("Couldn't find network")
# get datastore
ds = None
for d in config_target.Datastore:
if d.Datastore.Accessible and d.Datastore.Name == ds_name:
ds = d.Datastore.Datastore
ds_name = d.Datastore.Name
break
if not ds:
raise CreatorException("Datastore is not available")
volume_name = "[%s]" % ds_name
# add parameters to the create vm task
create_vm_request = VI.CreateVM_TaskRequestMsg()
config = create_vm_request.new_config()
vmfiles = config.new_files()
vmfiles.set_element_vmPathName(volume_name)
config.set_element_files(vmfiles)
config.set_element_name(vm_name)
config.set_element_annotation(description)
config.set_element_memoryMB(memory_size)
config.set_element_numCPUs(cpu_count)
config.set_element_guestId(guestosid)
devices = []
# add a scsi controller
disk_ctrl_key = 1
scsi_ctrl_spec = config.new_deviceChange()
scsi_ctrl_spec.set_element_operation("add")
scsi_ctrl = VI.ns0.VirtualLsiLogicController_Def("scsi_ctrl").pyclass()
scsi_ctrl.set_element_busNumber(0)
scsi_ctrl.set_element_key(disk_ctrl_key)
scsi_ctrl.set_element_sharedBus("noSharing")
scsi_ctrl_spec.set_element_device(scsi_ctrl)
devices.append(scsi_ctrl_spec)
# find ide controller
if iso:
ide_ctlr = None
for dev in defaul_devs:
if dev.typecode.type[1] == "VirtualIDEController":
ide_ctlr = dev
# add a cdrom based on a physical device
if ide_ctlr:
cd_spec = config.new_deviceChange()
cd_spec.set_element_operation("add")
cd_ctrl = VI.ns0.VirtualCdrom_Def("cd_ctrl").pyclass()
cd_device_backing = VI.ns0.VirtualCdromIsoBackingInfo_Def("cd_device_backing").pyclass()
ds_ref = cd_device_backing.new_datastore(ds)
ds_ref.set_attribute_type(ds.get_attribute_type())
cd_device_backing.set_element_datastore(ds_ref)
cd_device_backing.set_element_fileName("%s %s" % (volume_name, iso))
cd_ctrl.set_element_backing(cd_device_backing)
cd_ctrl.set_element_key(20)
cd_ctrl.set_element_controllerKey(ide_ctlr.get_element_key())
cd_ctrl.set_element_unitNumber(0)
cd_spec.set_element_device(cd_ctrl)
devices.append(cd_spec)
# create a new disk - file based - for the vm
if disk_size != 0:
disk_spec = config.new_deviceChange()
disk_spec.set_element_fileOperation("create")
disk_spec.set_element_operation("add")
disk_ctlr = VI.ns0.VirtualDisk_Def("disk_ctlr").pyclass()
disk_backing = VI.ns0.VirtualDiskFlatVer2BackingInfo_Def("disk_backing").pyclass()
disk_backing.set_element_fileName(volume_name)
disk_backing.set_element_diskMode("persistent")
disk_ctlr.set_element_key(0)
disk_ctlr.set_element_controllerKey(disk_ctrl_key)
disk_ctlr.set_element_unitNumber(0)
disk_ctlr.set_element_backing(disk_backing)
disk_ctlr.set_element_capacityInKB(disk_size)
disk_spec.set_element_device(disk_ctlr)
devices.append(disk_spec)
# add a NIC. the network Name must be set as the device name to create the NIC.
for network_name in networks:
nic_spec = config.new_deviceChange()
nic_spec.set_element_operation("add")
nic_ctlr = VI.ns0.VirtualPCNet32_Def("nic_ctlr").pyclass()
nic_backing = VI.ns0.VirtualEthernetCardNetworkBackingInfo_Def("nic_backing").pyclass()
nic_backing.set_element_deviceName(network_name)
nic_ctlr.set_element_addressType("generated")
nic_ctlr.set_element_backing(nic_backing)
nic_ctlr.set_element_key(4)
nic_spec.set_element_device(nic_ctlr)
devices.append(nic_spec)
config.set_element_deviceChange(devices)
create_vm_request.set_element_config(config)
folder_mor = create_vm_request.new__this(vmfmor)
folder_mor.set_attribute_type(vmfmor.get_attribute_type())
create_vm_request.set_element__this(folder_mor)
rp_mor = create_vm_request.new_pool(rpmor)
rp_mor.set_attribute_type(rpmor.get_attribute_type())
create_vm_request.set_element_pool(rp_mor)
host_mor = create_vm_request.new_host(hostmor)
host_mor.set_attribute_type(hostmor.get_attribute_type())
create_vm_request.set_element_host(host_mor)
# CREATE THE VM - add option "wait"
taskmor = self.esx_server._proxy.CreateVM_Task(create_vm_request)._returnval
task = VITask(taskmor, self.esx_server)
task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if task.get_state() == task.STATE_ERROR:
self._disconnect_from_esx()
raise CreatorException("Error creating vm: %s" % task.get_error_message())
def create_virtual_switch(self, name, num_ports, esx_hostname=None):
"""
Creates a new standard virtual switch on esx
:param name: name for new virtual switch
:param num_ports: numbers of emulated ports
:param esx_hostname: host name of esx server when virtual switch will be created
:raise: CreatorException, ExistenceException
"""
num_ports = int(num_ports)
self._connect_to_esx()
hosts = None
try:
hosts = self.esx_server.get_hosts()
if esx_hostname:
host_system = [k for k, v in hosts.items() if v == esx_hostname][0]
else:
host_system = hosts.keys()[0]
except IndexError:
raise CreatorException("Couldn't find host")
if not host_system:
raise CreatorException("Couldn't find host")
prop = VIProperty(self.esx_server, host_system)
network_system = prop.configManager.networkSystem._obj
for vs in prop.configManager.networkSystem.networkInfo.vswitch:
if vs.name == name:
self._disconnect_from_esx()
raise ExistenceException("Switch '%s' already exist" % name)
request = VI.AddVirtualSwitchRequestMsg()
_this = request.new__this(network_system)
_this.set_attribute_type(network_system.get_attribute_type())
request.set_element__this(_this)
request.set_element_vswitchName(name)
spec = request.new_spec()
spec.set_element_numPorts(num_ports)
request.set_element_spec(spec)
try:
self.esx_server._proxy.AddVirtualSwitch(request)
except Exception:
raise CreatorException("Couldn't create Switch")
# self._disconnect_from_esx()
def destroy_virtual_switch(self, name, esx_hostname=None):
"""
Destroys a named standard virtual switch on esx
:param name: virtual switch's name
:param esx_hostname: host name of esx server when virtual switch placed
:raise: CreatorException, ExistenceException
"""
self._connect_to_esx()
hosts = self.esx_server.get_hosts()
try:
if esx_hostname:
host_system = [k for k, v in hosts.items() if v == esx_hostname][0]
else:
host_system = hosts.keys()[0]
except Exception:
raise CreatorException("Couldn't find host")
prop = VIProperty(self.esx_server, host_system)
network_system = prop.configManager.networkSystem._obj
exist = False
for vs in prop.configManager.networkSystem.networkInfo.vswitch:
if vs.name == name:
exist = True
break
if exist:
request = VI.RemoveVirtualSwitchRequestMsg()
_this = request.new__this(network_system)
_this.set_attribute_type(network_system.get_attribute_type())
request.set_element__this(_this)
request.set_element_vswitchName(name)
try:
self.esx_server._proxy.RemoveVirtualSwitch(request)
except Exception:
raise CreatorException("Couldn't remove virtual switch '%s'" % name)
else:
raise ExistenceException("Couldn't find virtual switch '%s'" % name)
# self._disconnect_from_esx()
def add_port_group(self, switch_name, vlan_name, esx_hostname=None, vlan_id=4095, promiscuous=False):
"""
Add new network to exist switch
:param switch_name: vlan_name of switch which will be reconfigured
:param vlan_name: vlan_name of VLAN
:param esx_hostname: ESX hostname
:param vlan_id: id for VLAN
:param promiscuous: promiscuous mode enable/disable (True/False)
:raise: ExistenceException, CreatorException
"""
self._connect_to_esx()
vlan_id = int(vlan_id)
hosts = self.esx_server.get_hosts()
try:
if esx_hostname:
host_system = [k for k, v in hosts.items() if v == esx_hostname][0]
else:
host_system = hosts.keys()[0]
except Exception:
raise CreatorException("Couldn't find host")
prop = VIProperty(self.esx_server, host_system)
network_system = prop.configManager.networkSystem._obj
request = VI.AddPortGroupRequestMsg()
_this = request.new__this(network_system)
_this.set_attribute_type(network_system.get_attribute_type())
request.set_element__this(_this)
portgrp = request.new_portgrp()
portgrp.set_element_name(vlan_name)
portgrp.set_element_vlanId(vlan_id)
portgrp.set_element_vswitchName(switch_name)
policy = portgrp.new_policy()
security = policy.new_security()
security.set_element_allowPromiscuous(promiscuous)
policy.set_element_security(security)
portgrp.set_element_policy(policy)
request.set_element_portgrp(portgrp)
try:
self.esx_server._proxy.AddPortGroup(request)
except Exception as inst:
message = str(inst)
if "already exist" in message:
raise ExistenceException(
"Couldn't create network '%s:%s' on switch '%s', because it already exists" % vlan_name,
vlan_id,
switch_name,
)
else:
raise CreatorException(
"Couldn't create network '%s:%s' on switch '%s'" % vlan_name, vlan_id, switch_name
)
# self._disconnect_from_esx()
def is_connected(self):
"""
Checks ESX manager connection
:rtype : bool
:return: connection status
"""
return self.esx_server.is_connected()
def vm_power_on(self, vmname):
"""
Turns power on for the virtual machine
:param vmname: virtual machine name
:raise: ExistenceException, AttributeError, Exception
"""
if not vmname:
raise AttributeError("Couldn't specify the virtual machine name")
if not self._is_vm_exist(vmname):
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
try:
self._connect_to_esx()
vm = self.esx_server.get_vm_by_name(vmname)
if not vm.is_powered_on() and not vm.is_powering_on():
vm.power_on()
except Exception as error:
self._disconnect_from_esx()
raise CreatorException(error)
def vm_power_off(self, vmname):
"""
Turns power off for the virtual machine
:param vmname: virtual machine name
:raise: ExistenceException, AttributeError, Exception
"""
if not vmname:
raise AttributeError("Couldn't specify the virtual machine name")
if not self._is_vm_exist(vmname):
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
try:
self._connect_to_esx()
vm = self.esx_server.get_vm_by_name(vmname)
if not vm.is_powered_off() and not vm.is_powering_off():
vm.power_off()
except Exception as error:
self._disconnect_from_esx()
raise CreatorException(error)
def vm_reset(self, vmname):
"""
Resets a virtual machine.
If the virtual machine is powered off, then turns the power on for this virtual machine
:param vmname: virtual machine name
:raise: AttributeError, ExistenceException, Exception
"""
if not vmname:
raise AttributeError("Couldn't specify the virtual machine name")
if not self._is_vm_exist(vmname):
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
try:
self._connect_to_esx()
vm = self.esx_server.get_vm_by_name(vmname)
if not vm.is_powered_off():
vm.reset()
else:
vm.power_on()
except Exception as error:
self._disconnect_from_esx()
raise CreatorException(error)
def get_vm_path(self, vmname):
"""
Gets a virtual machine path on ESX server
:param vmname: virtual machine name
:return: virtual machine path
:raise: CreatorException
"""
self._connect_to_esx()
try:
vm = self.esx_server.get_vm_by_name(vmname)
except Exception:
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
try:
return vm.get_property("path")
except Exception as error:
self._disconnect_from_esx()
raise CreatorException(error)
pass
# todo: REVIEW ME
def get_vm_obj(self, vmname):
"""
Gets a virtual machine object on ESX server
:param vmname: virtual machine name
:return: VIVirtualMachine instance
:raise: CreatorException
"""
self._connect_to_esx()
try:
return self.esx_server.get_vm_by_name(vmname)
except Exception:
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
finally:
self._disconnect_from_esx()
def add_existence_vmdk(self, vm_name, path):
"""
Add existence hard drive (.vmdk) to the virtual machine
:param vm_name: virtual machine name
:param path: hard drive path
:param space: space for hard drive
:raise: ExistenceException, CreatorException
"""
self._connect_to_esx()
try:
vm = self.esx_server.get_vm_by_name(vm_name)
except Exception:
raise ExistenceException("Couldn't find the virtual machine %s" % vm_name)
unit_number = -1
for disk in vm._disks:
unit_number = max(unit_number, disk["device"]["unitNumber"])
unit_number += 1
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dc = spec.new_deviceChange()
dc.Operation = "add"
hd = VI.ns0.VirtualDisk_Def("hd").pyclass()
hd.Key = -100
hd.UnitNumber = unit_number
hd.CapacityInKB = 0
hd.ControllerKey = 1000
backing = VI.ns0.VirtualDiskFlatVer2BackingInfo_Def("backing").pyclass()
backing.FileName = path
backing.DiskMode = "persistent"
backing.ThinProvisioned = False
hd.Backing = backing
connectable = hd.new_connectable()
connectable.StartConnected = True
connectable.AllowGuestControl = False
connectable.Connected = True
hd.Connectable = connectable
dc.Device = hd
spec.DeviceChange = [dc]
request.Spec = spec
task = self.esx_server._proxy.ReconfigVM_Task(request)._returnval
vi_task = VITask(task, self.esx_server)
# Wait for task to finis
status = vi_task.wait_for_state([vi_task.STATE_SUCCESS, vi_task.STATE_ERROR])
if status == vi_task.STATE_ERROR:
self._disconnect_from_esx()
raise CreatorException("ERROR CONFIGURING VM:%s" % vi_task.get_error_message())
# todo: add comment
def _get_portgroup_name(self, name, esx_hostname=None):
"""
Get exist network from ESX
:param name: network name
:param esx_hostname: ESX host name
:return: :raise:
"""
self._connect_to_esx()
hosts = self.esx_server.get_hosts()
try:
if esx_hostname:
host_system = [k for k, v in hosts.items() if v == esx_hostname][0]
else:
host_system = hosts.keys()[0]
except IndexError:
raise CreatorException("Couldn't find host")
if not host_system:
raise CreatorException("Couldn't find host")
prop = VIProperty(self.esx_server, host_system)
for pg in prop.configManager.networkSystem.networkInfo.portgroup:
if pg.spec.name.lower() == name.lower():
real_name = pg.spec.name
# self._disconnect_from_esx()
return real_name
# self._disconnect_from_esx()
return None
# todo: add comment
def _is_vm_exist(self, name):
"""
:param name:
:return:
"""
self._connect_to_esx()
exist = False
try:
self.esx_server.get_vm_by_name(name)
exist = True
except:
pass
# self._disconnect_from_esx()
return exist
# todo: add comment
def _fetch_resource_pool(self, rp_name, esx_hostname):
"""
:param rp_name:
:param esx_hostname:
:return:
"""
rpmor = None
if rp_name == "/":
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == "/Resources"]
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
if prop.parent.name == esx_hostname:
rpmor = rp
break
else:
resource_pool = "/Resources" + rp_name
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == resource_pool]
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
while prop.parent.name != "host":
prop = prop.parent
if prop.name == esx_hostname:
rpmor = rp
break
if rp:
break
return rpmor
# todo: add comment
def _fetch_computer_resource(self, datacenter_props, host):
"""
:param datacenter_props:
:param host:
:return:
"""
host_folder = datacenter_props.hostFolder._obj
# get computer resources
computer_resources = self.esx_server._retrieve_properties_traversal(
property_names=["name", "host"], from_node=host_folder, obj_type="ComputeResource"
)
# get computer resource of this host
crmor = None
for cr in computer_resources:
if crmor:
break
for p in cr.PropSet:
if p.Name == "host":
for h in p.Val.get_element_ManagedObjectReference():
if h == host:
crmor = cr.Obj
break
if crmor:
break
return VIProperty(self.esx_server, crmor)
def get_stats():
stats = dict()
v = VCENTERLIST.split()
for vcenter in v:
logger('verb', "get_stats calls vcenter %s user %s" % (vcenter, USERNAME))
server = VIServer()
try:
server.connect(vcenter, USERNAME, PASSWORD)
except Exception:
logger('warn', "failed to connect to %s" % (vcenter))
continue
# get datastores
for ds, dsname in server.get_datastores().items():
DatastoreCapacity = 0
DatastoreFreespace = 0
DatastoreUsagePercent = 0
try:
logger('verb', "get_stats calls Datastore metrics query on vcenter: %s for datastore: %s" % (vcenter, dsname))
props = server._retrieve_properties_traversal(property_names=['name', 'summary.capacity', 'summary.freeSpace'], from_node=ds, obj_type="Datastore")
for prop_set in props:
# mor = prop_set.Obj #in case you need it
for prop in prop_set.PropSet:
if prop.Name == "summary.capacity":
DatastoreCapacity = (prop.Val / 1048576)
elif prop.Name == "summary.freeSpace":
DatastoreFreespace = (prop.Val / 1048576)
except Exception:
logger('warn', "failed to get Datastore metrics value on vcenter: %s for datastore: %s" % (vcenter, dsname))
DatastoreUsagePercent = (((DatastoreCapacity - DatastoreFreespace) * 100) / DatastoreCapacity)
metricnameZoneDatastoreCapacity = METRIC_DELIM.join([vcenter.lower(), "datastores", dsname.lower(), 'datastorecapacity'])
metricnameZoneDatastoreFreespace = METRIC_DELIM.join([vcenter.lower(), "datastores", dsname.lower(), 'datastorefreespace'])
metricnameZoneDatastoreUsagePercent = METRIC_DELIM.join([vcenter.lower(), "datastores", dsname.lower(), 'datastoreusagepercent'])
try:
stats[metricnameZoneDatastoreCapacity] = DatastoreCapacity
stats[metricnameZoneDatastoreFreespace] = DatastoreFreespace
stats[metricnameZoneDatastoreUsagePercent] = DatastoreUsagePercent
except (TypeError, ValueError):
pass
ZoneDatacentersCount = 0
ZoneClustersCount = 0
ZoneHostsCount = 0
ZoneRunningVMS = 0
ZoneStoppedVMS = 0
ZoneTotalVMS = 0
ZoneMemoryUsage = 0
ZoneCpuUsage = 0
ZoneTotalMemory = 0
ZoneCpuTotal = 0
logger('verb', "get_stats calls get_datacenters query on vcenter: %s" % (vcenter))
datacenters = server.get_datacenters()
logger('verb', "get_stats completed get_datacenters query on vcenter: %s" % (vcenter))
ZoneDatacentersCount = len(datacenters)
for d, dname in server.get_datacenters().items():
if "." in dname:
dname = dname.split(".")[0]
DatacenterRunningVMS = 0
DatacenterStoppedVMS = 0
DatacenterTotalVMS = 0
DatacenterClustersCount = 0
DatacenterHostsCount = 0
DatacenterMemoryUsage = 0
DatacenterCpuUsage = 0
DatacenterTotalMemory = 0
DatacenterCpuTotal = 0
logger('verb', "get_stats calls get_clusters query on vcenter: %s for datacenter: %s" % (vcenter, dname))
clusters = server.get_clusters(d)
logger('verb', "get_stats completed get_clusters query on vcenter: %s for datacenter: %s" % (vcenter, dname))
DatacenterClustersCount = len(clusters)
ZoneClustersCount = ZoneClustersCount + DatacenterClustersCount
for c, cname in server.get_clusters(d).items():
if "." in cname:
cname = cname.split(".")[0]
ClusterMemoryUsage = 0
ClusterCpuUsage = 0
ClusterTotalMemory = 0
ClusterCpuTotal = 0
ClusterRunningVMS = 0
ClusterStoppedVMS = 0
ClusterTotalVMS = 0
logger('verb', "get_stats calls get_hosts query on vcenter: %s for cluster: %s" % (vcenter, cname))
hosts = server.get_hosts(c)
logger('verb', "get_stats completed get_hosts query on vcenter: %s for cluster: %s" % (vcenter, cname))
ClusterHostsCount = len(hosts)
DatacenterHostsCount = DatacenterHostsCount + ClusterHostsCount
ZoneHostsCount = ZoneHostsCount + DatacenterHostsCount
for h, hname in server.get_hosts(c).items():
HostMemoryUsage = 0
HostCpuUsage = 0
HostTotalMemory = 0
HostNumCpuCores = 0
HostMhzPerCore = 0
HostStatus = ''
if "." in hname:
hname = hname.split(".")[0]
try:
logger('verb', "get_stats calls Host CPU and Memory metrics query on vcenter: %s for host: %s" % (vcenter, hname))
props = server._retrieve_properties_traversal(property_names=['name', 'summary.overallStatus', 'summary.quickStats.overallMemoryUsage', 'summary.quickStats.overallCpuUsage', 'summary.hardware.memorySize', 'summary.hardware.numCpuCores', 'summary.hardware.cpuMhz'], from_node=h, obj_type="HostSystem")
for prop_set in props:
# mor = prop_set.Obj #in case you need it
for prop in prop_set.PropSet:
if prop.Name == "summary.quickStats.overallMemoryUsage":
HostMemoryUsage = prop.Val
elif prop.Name == "summary.quickStats.overallCpuUsage":
HostCpuUsage = prop.Val
elif prop.Name == "summary.hardware.memorySize":
HostTotalMemory = (prop.Val / 1048576)
elif prop.Name == "summary.hardware.numCpuCores":
HostNumCpuCores = prop.Val
elif prop.Name == "summary.hardware.cpuMhz":
HostMhzPerCore = prop.Val
elif prop.Name == "summary.overallStatus":
HostStatus = prop.Val
if HostStatus == "green":
HostStatus = 0
elif HostStatus == "gray":
HostStatus = 1
elif HostStatus == "yellow":
HostStatus = 2
elif HostStatus == "red":
HostStatus = 3
except Exception:
logger('warn', "failed to get Host CPU and Memory metrics value on vcenter: %s for host: %s" % (vcenter, hname))
try:
logger('verb', "get_stats calls HostRunningVMS query on vcenter: %s for host: %s" % (vcenter, hname))
HostRunningVMS = len(server.get_registered_vms(h, status='poweredOn'))
except Exception:
logger('warn', "failed to get nb of running VMS value on %s" % (hname))
try:
logger('verb', "get_stats calls HostStoppedVMS query on vcenter: %s for host: %s" % (vcenter, hname))
HostStoppedVMS = len(server.get_registered_vms(h, status='poweredOff'))
except Exception:
logger('warn', "failed to get nb of stopped VMS value on %s" % (hname))
try:
logger('verb', "get_stats calls HostTotalVMS query on vcenter: %s for host: %s" % (vcenter, hname))
HostTotalVMS = len(server.get_registered_vms(h))
except Exception:
logger('warn', "failed to get all VMS count on %s" % (hname))
HostCpuTotal = (HostNumCpuCores * HostMhzPerCore)
HostMemoryUsagePercent = ((HostMemoryUsage * 100) / HostTotalMemory)
HostCpuUsagePercent = ((HostCpuUsage * 100) / HostCpuTotal)
metricnameHostStatus = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hoststatus'])
metricnameHostMemoryUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostmemoryusagepercent'])
metricnameHostCpuUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostcpuusagepercent'])
metricnameHostMemoryUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostmemoryusage'])
metricnameHostCpuUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostcpuusage'])
metricnameHostTotalMemory = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hosttotalmemory'])
metricnameHostCpuTotal = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostcputotal'])
metricnameHostRunningVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostrunningvms'])
metricnameHostStoppedVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hoststoppedvms'])
metricnameHostTotalVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hosttotalvms'])
ClusterMemoryUsage = ClusterMemoryUsage + HostMemoryUsage
ClusterCpuUsage = ClusterCpuUsage + HostCpuUsage
ClusterTotalMemory = ClusterTotalMemory + HostTotalMemory
ClusterCpuTotal = ClusterCpuTotal + HostCpuTotal
ClusterRunningVMS = ClusterRunningVMS + HostRunningVMS
ClusterStoppedVMS = ClusterStoppedVMS + HostStoppedVMS
ClusterTotalVMS = ClusterTotalVMS + HostTotalVMS
ClusterMemoryUsagePercent = ((ClusterMemoryUsage * 100) / ClusterTotalMemory)
ClusterCpuUsagePercent = ((ClusterCpuUsage * 100) / ClusterCpuTotal)
try:
stats[metricnameHostStatus] = HostStatus
stats[metricnameHostMemoryUsage] = HostMemoryUsage
stats[metricnameHostCpuUsage] = HostCpuUsage
stats[metricnameHostTotalMemory] = HostTotalMemory
stats[metricnameHostCpuUsagePercent] = HostCpuUsagePercent
stats[metricnameHostMemoryUsagePercent] = HostMemoryUsagePercent
stats[metricnameHostCpuTotal] = HostCpuTotal
stats[metricnameHostRunningVMS] = HostRunningVMS
stats[metricnameHostStoppedVMS] = HostStoppedVMS
stats[metricnameHostTotalVMS] = HostTotalVMS
except (TypeError, ValueError):
pass
DatacenterRunningVMS = DatacenterRunningVMS + ClusterRunningVMS
DatacenterStoppedVMS = DatacenterStoppedVMS + ClusterStoppedVMS
DatacenterTotalVMS = DatacenterTotalVMS + ClusterTotalVMS
DatacenterMemoryUsage = DatacenterMemoryUsage + ClusterMemoryUsage
DatacenterCpuUsage = DatacenterCpuUsage + ClusterCpuUsage
DatacenterTotalMemory = DatacenterTotalMemory + ClusterTotalMemory
DatacenterCpuTotal = DatacenterCpuTotal + ClusterCpuTotal
DatacenterMemoryUsagePercent = ((DatacenterMemoryUsage * 100) / DatacenterTotalMemory)
DatacenterCpuUsagePercent = ((DatacenterCpuUsage * 100) / DatacenterCpuTotal)
metricnameClusterRunningVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clusterrunningvms'])
metricnameClusterStoppedVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clusterstoppedvms'])
metricnameClusterTotalVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustertotalvms'])
metricnameClusterMemoryUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustermemoryusage'])
metricnameClusterCpuUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustercpuusage'])
metricnameClusterTotalMemory = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustertotalmemory'])
metricnameClusterCpuTotal = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustercputotal'])
metricnameClusterMemoryUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustermemoryusagepercent'])
metricnameClusterCpuUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustercpuusagepercent'])
try:
stats[metricnameClusterRunningVMS] = ClusterRunningVMS
stats[metricnameClusterStoppedVMS] = ClusterStoppedVMS
stats[metricnameClusterTotalVMS] = ClusterTotalVMS
stats[metricnameClusterMemoryUsage] = ClusterMemoryUsage
stats[metricnameClusterCpuUsage] = ClusterCpuUsage
stats[metricnameClusterMemoryUsagePercent] = ClusterMemoryUsagePercent
stats[metricnameClusterCpuUsagePercent] = ClusterCpuUsagePercent
stats[metricnameClusterTotalMemory] = ClusterTotalMemory
stats[metricnameClusterCpuTotal] = ClusterCpuTotal
except (TypeError, ValueError):
pass
# post datacenter metrics count here
ZoneRunningVMS = ZoneRunningVMS + DatacenterRunningVMS
ZoneStoppedVMS = ZoneStoppedVMS + DatacenterStoppedVMS
ZoneTotalVMS = ZoneTotalVMS + DatacenterTotalVMS
ZoneMemoryUsage = ZoneMemoryUsage + DatacenterMemoryUsage
ZoneCpuUsage = ZoneCpuUsage + DatacenterCpuUsage
ZoneTotalMemory = ZoneTotalMemory + DatacenterTotalMemory
ZoneCpuTotal = ZoneCpuTotal + DatacenterCpuTotal
ZoneMemoryUsagePercent = ((ZoneMemoryUsage * 100) / ZoneTotalMemory)
ZoneCpuUsagePercent = ((ZoneCpuUsage * 100) / ZoneCpuTotal)
metricnameDatacenterRunningVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacenterrunningvms'])
metricnameDatacenterStoppedVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacenterstoppedvms'])
metricnameDatacenterTotalVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentertotalvms'])
metricnameDatacenterMemoryUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentermemoryusage'])
metricnameDatacenterCpuUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentercpuusage'])
metricnameDatacenterMemoryUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentermemoryusagepercent'])
metricnameDatacenterCpuUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentercpuusagepercent'])
metricnameDatacenterTotalMemory = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentertotalmemory'])
metricnameDatacenterCpuTotal = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentercputotal'])
try:
stats[metricnameDatacenterRunningVMS] = DatacenterRunningVMS
stats[metricnameDatacenterStoppedVMS] = DatacenterStoppedVMS
stats[metricnameDatacenterTotalVMS] = DatacenterTotalVMS
stats[metricnameDatacenterMemoryUsage] = DatacenterMemoryUsage
stats[metricnameDatacenterCpuUsage] = DatacenterCpuUsage
stats[metricnameDatacenterMemoryUsagePercent] = DatacenterMemoryUsagePercent
stats[metricnameDatacenterCpuUsagePercent] = DatacenterCpuUsagePercent
stats[metricnameDatacenterTotalMemory] = DatacenterTotalMemory
stats[metricnameDatacenterCpuTotal] = DatacenterCpuTotal
except (TypeError, ValueError):
pass
# post zone metrics count here
metricnameZoneRunningVMS = METRIC_DELIM.join([vcenter.lower(), 'zonerunningvms'])
metricnameZoneStoppedVMS = METRIC_DELIM.join([vcenter.lower(), 'zonestoppedvms'])
metricnameZoneTotalVMS = METRIC_DELIM.join([vcenter.lower(), 'zonetotalvms'])
metricnameZoneMemoryUsage = METRIC_DELIM.join([vcenter.lower(), 'zonememoryusage'])
metricnameZoneCpuUsage = METRIC_DELIM.join([vcenter.lower(), 'zonecpuusage'])
metricnameZoneMemoryUsagePercent = METRIC_DELIM.join([vcenter.lower(), 'zonememoryusagepercent'])
metricnameZoneCpuUsagePercent = METRIC_DELIM.join([vcenter.lower(), 'zonecpuusagepercent'])
metricnameZoneTotalMemory = METRIC_DELIM.join([vcenter.lower(), 'zonetotalmemory'])
metricnameZoneCpuTotal = METRIC_DELIM.join([vcenter.lower(), 'zonecputotal'])
try:
stats[metricnameZoneRunningVMS] = ZoneRunningVMS
stats[metricnameZoneStoppedVMS] = ZoneStoppedVMS
stats[metricnameZoneTotalVMS] = ZoneTotalVMS
stats[metricnameZoneMemoryUsage] = ZoneMemoryUsage
stats[metricnameZoneCpuUsage] = ZoneCpuUsage
stats[metricnameZoneMemoryUsagePercent] = ZoneMemoryUsagePercent
stats[metricnameZoneCpuUsagePercent] = ZoneCpuUsagePercent
stats[metricnameZoneTotalMemory] = ZoneTotalMemory
stats[metricnameZoneCpuTotal] = ZoneCpuTotal
except (TypeError, ValueError):
pass
metricnameZoneDatacentersCount = METRIC_DELIM.join([vcenter.lower(), 'zonedatacenterscount'])
metricnameZoneClustersCount = METRIC_DELIM.join([vcenter.lower(), 'zoneclusterscount'])
metricnameZoneHostsCount = METRIC_DELIM.join([vcenter.lower(), 'zonehostscount'])
try:
stats[metricnameZoneDatacentersCount] = ZoneDatacentersCount
stats[metricnameZoneClustersCount] = ZoneClustersCount
stats[metricnameZoneHostsCount] = ZoneHostsCount
except (TypeError, ValueError):
pass
server.disconnect()
return stats
except Exception:
print "CRITICAL - Unable to connect to vSphere"
sys.exit(2)
# collect dict of hosts
hosts = server.get_hosts()
# create an integer to track number of operational and down hosts
hosts_operational = 0
hosts_down = 0
# verify that we got information
if hosts:
# get properties
props = server._retrieve_properties_traversal(property_names=['name', 'runtime.connectionState'], obj_type="HostSystem")
# get powerState for each host
for prop_set in props:
for prop in prop_set.PropSet:
# add host to correct count based on runtime powered state
if prop.Val == "connected":
hosts_operational = hosts_operational + 1
else:
hosts_down = hosts_down + 1
else:
print "CRITICAL - Unable to retrieve hosts"
sys.exit(2)
# disconnect from vcenter
count = 0
clusters = {'10.127.209.21': 1, '10.95.209.21': 2, '10.64.211.139': 3}
for ip in clusters:
print ip
server = VIServer()
server.connect(ip, "nys\dnovicoff", "pitIfu12345")
serverType = server.get_server_type()
print serverType
serverAPI = server.get_api_version()
print serverAPI
vmlist = server.get_registered_vms()
properties = server._retrieve_properties_traversal(
property_names=property_names, obj_type="VirtualMachine")
for propset in properties:
vmToolsVersion = ""
vmPropPath = ""
host = ""
for prop in propset.PropSet:
if prop.Name == "name":
host = prop.Val
elif prop.Name == "guest.toolsVersion":
vmToolsVersion = prop.Val
elif prop.Name == "config.files.vmPathName":
vmPropPath = prop.Val
if not serverVMToolVersion.has_key(host):
serverVMToolVersion[host] = vmToolsVersion
def get_stats():
stats = dict()
v = VCENTERLIST.split()
for vcenter in v:
logger('verb', "get_stats calls vcenter %s user %s" % (vcenter, USERNAME))
server = VIServer()
try:
# Untrusted vSphere certificate bypass
# SSL: CERTIFICATE_VERIFY_FAILED
default_context = ssl._create_default_https_context
ssl._create_default_https_context = ssl._create_unverified_context
server.connect(vcenter, USERNAME, PASSWORD)
except Exception:
logger('warn', "failed to connect to %s" % (vcenter))
continue
# get datastores
for ds, dsname in server.get_datastores().items():
DatastoreCapacity = 0
DatastoreFreespace = 0
DatastoreUsagePercent = 0
try:
logger('verb', "get_stats calls Datastore metrics query on vcenter: %s for datastore: %s" % (vcenter, dsname))
props = server._retrieve_properties_traversal(property_names=['name', 'summary.capacity', 'summary.freeSpace'], from_node=ds, obj_type="Datastore")
for prop_set in props:
# mor = prop_set.Obj #in case you need it
for prop in prop_set.PropSet:
if prop.Name == "summary.capacity":
DatastoreCapacity = (prop.Val / 1048576)
elif prop.Name == "summary.freeSpace":
DatastoreFreespace = (prop.Val / 1048576)
except Exception:
logger('warn', "failed to get Datastore metrics value on vcenter: %s for datastore: %s" % (vcenter, dsname))
DatastoreUsagePercent = (((DatastoreCapacity - DatastoreFreespace) * 100) / DatastoreCapacity) if DatastoreCapacity > 0 else 0
metricnameZoneDatastoreCapacity = METRIC_DELIM.join([vcenter.lower(), "datastores", dsname.lower(), 'datastorecapacity'])
metricnameZoneDatastoreFreespace = METRIC_DELIM.join([vcenter.lower(), "datastores", dsname.lower(), 'datastorefreespace'])
metricnameZoneDatastoreUsagePercent = METRIC_DELIM.join([vcenter.lower(), "datastores", dsname.lower(), 'datastoreusagepercent'])
try:
stats[metricnameZoneDatastoreCapacity] = DatastoreCapacity
stats[metricnameZoneDatastoreFreespace] = DatastoreFreespace
stats[metricnameZoneDatastoreUsagePercent] = DatastoreUsagePercent
except (TypeError, ValueError):
pass
ZoneDatacentersCount = 0
ZoneClustersCount = 0
ZoneHostsCount = 0
ZoneRunningVMS = 0
ZoneStoppedVMS = 0
ZoneTotalVMS = 0
ZoneMemoryUsage = 0
ZoneCpuUsage = 0
ZoneTotalMemory = 0
ZoneCpuTotal = 0
logger('verb', "get_stats calls get_datacenters query on vcenter: %s" % (vcenter))
datacenters = server.get_datacenters()
logger('verb', "get_stats completed get_datacenters query on vcenter: %s" % (vcenter))
ZoneDatacentersCount = len(datacenters)
for d, dname in server.get_datacenters().items():
if "." in dname:
dname = dname.split(".")[0]
DatacenterRunningVMS = 0
DatacenterStoppedVMS = 0
DatacenterTotalVMS = 0
DatacenterClustersCount = 0
DatacenterHostsCount = 0
DatacenterMemoryUsage = 0
DatacenterCpuUsage = 0
DatacenterTotalMemory = 0
DatacenterCpuTotal = 0
logger('verb', "get_stats calls get_clusters query on vcenter: %s for datacenter: %s" % (vcenter, dname))
clusters = server.get_clusters(d)
logger('verb', "get_stats completed get_clusters query on vcenter: %s for datacenter: %s" % (vcenter, dname))
DatacenterClustersCount = len(clusters)
ZoneClustersCount = ZoneClustersCount + DatacenterClustersCount
for c, cname in server.get_clusters(d).items():
if "." in cname:
cname = cname.split(".")[0]
ClusterMemoryUsage = 0
ClusterCpuUsage = 0
ClusterTotalMemory = 0
ClusterCpuTotal = 0
ClusterRunningVMS = 0
ClusterStoppedVMS = 0
ClusterTotalVMS = 0
logger('verb', "get_stats calls get_hosts query on vcenter: %s for cluster: %s" % (vcenter, cname))
hosts = server.get_hosts(c)
logger('verb', "get_stats completed get_hosts query on vcenter: %s for cluster: %s" % (vcenter, cname))
ClusterHostsCount = len(hosts)
DatacenterHostsCount = DatacenterHostsCount + ClusterHostsCount
ZoneHostsCount = ZoneHostsCount + DatacenterHostsCount
for h, hname in server.get_hosts(c).items():
HostMemoryUsage = 0
HostCpuUsage = 0
HostTotalMemory = 0
HostNumCpuCores = 0
HostMhzPerCore = 0
HostStatus = ''
if "." in hname:
hname = hname.split(".")[0]
try:
logger('verb', "get_stats calls Host CPU and Memory metrics query on vcenter: %s for host: %s" % (vcenter, hname))
props = server._retrieve_properties_traversal(property_names=['name', 'summary.overallStatus', 'summary.quickStats.overallMemoryUsage', 'summary.quickStats.overallCpuUsage', 'summary.hardware.memorySize', 'summary.hardware.numCpuCores', 'summary.hardware.cpuMhz'], from_node=h, obj_type="HostSystem")
for prop_set in props:
# mor = prop_set.Obj #in case you need it
for prop in prop_set.PropSet:
if prop.Name == "summary.quickStats.overallMemoryUsage":
HostMemoryUsage = prop.Val
elif prop.Name == "summary.quickStats.overallCpuUsage":
HostCpuUsage = prop.Val
elif prop.Name == "summary.hardware.memorySize":
HostTotalMemory = (prop.Val / 1048576)
elif prop.Name == "summary.hardware.numCpuCores":
HostNumCpuCores = prop.Val
elif prop.Name == "summary.hardware.cpuMhz":
HostMhzPerCore = prop.Val
elif prop.Name == "summary.overallStatus":
HostStatus = prop.Val
if HostStatus == "green":
HostStatus = 0
elif HostStatus == "gray":
HostStatus = 1
elif HostStatus == "yellow":
HostStatus = 2
elif HostStatus == "red":
HostStatus = 3
except Exception:
logger('warn', "failed to get Host CPU and Memory metrics value on vcenter: %s for host: %s" % (vcenter, hname))
try:
logger('verb', "get_stats calls HostRunningVMS query on vcenter: %s for host: %s" % (vcenter, hname))
HostRunningVMS = len(server.get_registered_vms(h, status='poweredOn'))
except Exception:
logger('warn', "failed to get nb of running VMS value on %s" % (hname))
try:
logger('verb', "get_stats calls HostStoppedVMS query on vcenter: %s for host: %s" % (vcenter, hname))
HostStoppedVMS = len(server.get_registered_vms(h, status='poweredOff'))
except Exception:
logger('warn', "failed to get nb of stopped VMS value on %s" % (hname))
try:
logger('verb', "get_stats calls HostTotalVMS query on vcenter: %s for host: %s" % (vcenter, hname))
HostTotalVMS = len(server.get_registered_vms(h))
except Exception:
logger('warn', "failed to get all VMS count on %s" % (hname))
HostCpuTotal = (HostNumCpuCores * HostMhzPerCore)
HostMemoryUsagePercent = ((HostMemoryUsage * 100) / HostTotalMemory)
HostCpuUsagePercent = ((HostCpuUsage * 100) / HostCpuTotal)
metricnameHostStatus = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hoststatus'])
metricnameHostMemoryUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostmemoryusagepercent'])
metricnameHostCpuUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostcpuusagepercent'])
metricnameHostMemoryUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostmemoryusage'])
metricnameHostCpuUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostcpuusage'])
metricnameHostTotalMemory = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hosttotalmemory'])
metricnameHostCpuTotal = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostcputotal'])
metricnameHostRunningVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hostrunningvms'])
metricnameHostStoppedVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hoststoppedvms'])
metricnameHostTotalVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), hname.lower(), 'hosttotalvms'])
ClusterMemoryUsage = ClusterMemoryUsage + HostMemoryUsage
ClusterCpuUsage = ClusterCpuUsage + HostCpuUsage
ClusterTotalMemory = ClusterTotalMemory + HostTotalMemory
ClusterCpuTotal = ClusterCpuTotal + HostCpuTotal
ClusterRunningVMS = ClusterRunningVMS + HostRunningVMS
ClusterStoppedVMS = ClusterStoppedVMS + HostStoppedVMS
ClusterTotalVMS = ClusterTotalVMS + HostTotalVMS
ClusterMemoryUsagePercent = ((ClusterMemoryUsage * 100) / ClusterTotalMemory)
ClusterCpuUsagePercent = ((ClusterCpuUsage * 100) / ClusterCpuTotal)
try:
stats[metricnameHostStatus] = HostStatus
stats[metricnameHostMemoryUsage] = HostMemoryUsage
stats[metricnameHostCpuUsage] = HostCpuUsage
stats[metricnameHostTotalMemory] = HostTotalMemory
stats[metricnameHostCpuUsagePercent] = HostCpuUsagePercent
stats[metricnameHostMemoryUsagePercent] = HostMemoryUsagePercent
stats[metricnameHostCpuTotal] = HostCpuTotal
stats[metricnameHostRunningVMS] = HostRunningVMS
stats[metricnameHostStoppedVMS] = HostStoppedVMS
stats[metricnameHostTotalVMS] = HostTotalVMS
except (TypeError, ValueError):
pass
DatacenterRunningVMS = DatacenterRunningVMS + ClusterRunningVMS
DatacenterStoppedVMS = DatacenterStoppedVMS + ClusterStoppedVMS
DatacenterTotalVMS = DatacenterTotalVMS + ClusterTotalVMS
DatacenterMemoryUsage = DatacenterMemoryUsage + ClusterMemoryUsage
DatacenterCpuUsage = DatacenterCpuUsage + ClusterCpuUsage
DatacenterTotalMemory = DatacenterTotalMemory + ClusterTotalMemory
DatacenterCpuTotal = DatacenterCpuTotal + ClusterCpuTotal
DatacenterMemoryUsagePercent = ((DatacenterMemoryUsage * 100) / DatacenterTotalMemory)
DatacenterCpuUsagePercent = ((DatacenterCpuUsage * 100) / DatacenterCpuTotal)
metricnameClusterRunningVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clusterrunningvms'])
metricnameClusterStoppedVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clusterstoppedvms'])
metricnameClusterTotalVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustertotalvms'])
metricnameClusterMemoryUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustermemoryusage'])
metricnameClusterCpuUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustercpuusage'])
metricnameClusterTotalMemory = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustertotalmemory'])
metricnameClusterCpuTotal = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustercputotal'])
metricnameClusterMemoryUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustermemoryusagepercent'])
metricnameClusterCpuUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), cname.lower(), 'clustercpuusagepercent'])
try:
stats[metricnameClusterRunningVMS] = ClusterRunningVMS
stats[metricnameClusterStoppedVMS] = ClusterStoppedVMS
stats[metricnameClusterTotalVMS] = ClusterTotalVMS
stats[metricnameClusterMemoryUsage] = ClusterMemoryUsage
stats[metricnameClusterCpuUsage] = ClusterCpuUsage
stats[metricnameClusterMemoryUsagePercent] = ClusterMemoryUsagePercent
stats[metricnameClusterCpuUsagePercent] = ClusterCpuUsagePercent
stats[metricnameClusterTotalMemory] = ClusterTotalMemory
stats[metricnameClusterCpuTotal] = ClusterCpuTotal
except (TypeError, ValueError):
pass
# post datacenter metrics count here
ZoneRunningVMS = ZoneRunningVMS + DatacenterRunningVMS
ZoneStoppedVMS = ZoneStoppedVMS + DatacenterStoppedVMS
ZoneTotalVMS = ZoneTotalVMS + DatacenterTotalVMS
ZoneMemoryUsage = ZoneMemoryUsage + DatacenterMemoryUsage
ZoneCpuUsage = ZoneCpuUsage + DatacenterCpuUsage
ZoneTotalMemory = ZoneTotalMemory + DatacenterTotalMemory
ZoneCpuTotal = ZoneCpuTotal + DatacenterCpuTotal
ZoneMemoryUsagePercent = ((ZoneMemoryUsage * 100) / ZoneTotalMemory)
ZoneCpuUsagePercent = ((ZoneCpuUsage * 100) / ZoneCpuTotal)
metricnameDatacenterRunningVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacenterrunningvms'])
metricnameDatacenterStoppedVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacenterstoppedvms'])
metricnameDatacenterTotalVMS = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentertotalvms'])
metricnameDatacenterMemoryUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentermemoryusage'])
metricnameDatacenterCpuUsage = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentercpuusage'])
metricnameDatacenterMemoryUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentermemoryusagepercent'])
metricnameDatacenterCpuUsagePercent = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentercpuusagepercent'])
metricnameDatacenterTotalMemory = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentertotalmemory'])
metricnameDatacenterCpuTotal = METRIC_DELIM.join([vcenter.lower(), dname.lower(), 'datacentercputotal'])
try:
stats[metricnameDatacenterRunningVMS] = DatacenterRunningVMS
stats[metricnameDatacenterStoppedVMS] = DatacenterStoppedVMS
stats[metricnameDatacenterTotalVMS] = DatacenterTotalVMS
stats[metricnameDatacenterMemoryUsage] = DatacenterMemoryUsage
stats[metricnameDatacenterCpuUsage] = DatacenterCpuUsage
stats[metricnameDatacenterMemoryUsagePercent] = DatacenterMemoryUsagePercent
stats[metricnameDatacenterCpuUsagePercent] = DatacenterCpuUsagePercent
stats[metricnameDatacenterTotalMemory] = DatacenterTotalMemory
stats[metricnameDatacenterCpuTotal] = DatacenterCpuTotal
except (TypeError, ValueError):
pass
# post zone metrics count here
metricnameZoneRunningVMS = METRIC_DELIM.join([vcenter.lower(), 'zonerunningvms'])
metricnameZoneStoppedVMS = METRIC_DELIM.join([vcenter.lower(), 'zonestoppedvms'])
metricnameZoneTotalVMS = METRIC_DELIM.join([vcenter.lower(), 'zonetotalvms'])
metricnameZoneMemoryUsage = METRIC_DELIM.join([vcenter.lower(), 'zonememoryusage'])
metricnameZoneCpuUsage = METRIC_DELIM.join([vcenter.lower(), 'zonecpuusage'])
metricnameZoneMemoryUsagePercent = METRIC_DELIM.join([vcenter.lower(), 'zonememoryusagepercent'])
metricnameZoneCpuUsagePercent = METRIC_DELIM.join([vcenter.lower(), 'zonecpuusagepercent'])
metricnameZoneTotalMemory = METRIC_DELIM.join([vcenter.lower(), 'zonetotalmemory'])
metricnameZoneCpuTotal = METRIC_DELIM.join([vcenter.lower(), 'zonecputotal'])
try:
stats[metricnameZoneRunningVMS] = ZoneRunningVMS
stats[metricnameZoneStoppedVMS] = ZoneStoppedVMS
stats[metricnameZoneTotalVMS] = ZoneTotalVMS
stats[metricnameZoneMemoryUsage] = ZoneMemoryUsage
stats[metricnameZoneCpuUsage] = ZoneCpuUsage
stats[metricnameZoneMemoryUsagePercent] = ZoneMemoryUsagePercent
stats[metricnameZoneCpuUsagePercent] = ZoneCpuUsagePercent
stats[metricnameZoneTotalMemory] = ZoneTotalMemory
stats[metricnameZoneCpuTotal] = ZoneCpuTotal
except (TypeError, ValueError):
pass
metricnameZoneDatacentersCount = METRIC_DELIM.join([vcenter.lower(), 'zonedatacenterscount'])
metricnameZoneClustersCount = METRIC_DELIM.join([vcenter.lower(), 'zoneclusterscount'])
metricnameZoneHostsCount = METRIC_DELIM.join([vcenter.lower(), 'zonehostscount'])
try:
stats[metricnameZoneDatacentersCount] = ZoneDatacentersCount
stats[metricnameZoneClustersCount] = ZoneClustersCount
stats[metricnameZoneHostsCount] = ZoneHostsCount
except (TypeError, ValueError):
pass
server.disconnect()
return stats
#!/usr/bin/python
from pysphere import VIServer, VIProperty
from pysphere.resources import VimService_services as VI
from pprint import pprint
HOST = "my esxi server"
USER = "******"
PASSWORD = "******"
s = VIServer()
s.connect(HOST, USER, PASSWORD)
result = s._retrieve_properties_traversal(property_names=["name"],
obj_type="VirtualMachine")
vmlist = [r.PropSet[0].Val for r in result]
for vmname in vmlist:
print "#" * 80
print vmname
vm = s.get_vm_by_name(vmname)
disks = [
d for d in vm.properties.config.hardware.device
if d._type == 'VirtualDisk' and d.backing._type in [
'VirtualDiskFlatVer1BackingInfo', 'VirtualDiskFlatVer2BackingInfo',
'VirtualDiskRawDiskMappingVer1BackingInfo',
'VirtualDiskSparseVer1BackingInfo',
'VirtualDiskSparseVer2BackingInfo'
]
]
# Legacy Python that doesn't verify HTTPS certificates by default
pass
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
from pysphere import VIServer
server = VIServer()
HOST = "172.17.11.74"
LOGIN = "******"
PASSWORD = "******"
server.connect(HOST, LOGIN, PASSWORD)
oc = []
oc.append(server._retrieve_properties_traversal(obj_type='VirtualMachine'))
power = []
machines = server.get_registered_vms()
for machine in server.get_registered_vms():
power.append(server.get_vm_by_path(machine).get_status())
zindex = -1
for elem in oc:
for b in elem:
s = (b)
zindex = zindex + 1
print "vmrc://" + LOGIN + ":" + PASSWORD + "@" + HOST + ":443/?moid=" + s.Obj, machines[
zindex], power[zindex]
datastore = "hit04_sata_datastore04" #if None, will use the first datastore available
datastoretwo = "hit04_sata_datastore05" #if None, will use the first datastore available
extra_config = {'vcpu.hotadd': 'TRUE', 'mem.hotadd': 'TRUE'}
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
# GET INITIAL PROPERTIES AND OBJECTS
dcmor = [k for k, v in s.get_datacenters().items() if v == datacentername][0]
dcprops = VIProperty(s, dcmor)
# networkFolder managed object reference
nfmor = dcprops.networkFolder._obj
dvpg_mors = s._retrieve_properties_traversal(
property_names=['name', 'key'],
from_node=nfmor,
obj_type='DistributedVirtualPortgroup')
# Get the portgroup managed object.
dvpg_mor = None
for dvpg in dvpg_mors:
if dvpg_mor:
break
for p in dvpg.PropSet:
if p.Name == "name" and p.Val == network_name:
dvpg_mor = dvpg
if dvpg_mor:
break
if dvpg_mor == None:
print "Didnt find the dvpg %s, exiting now" % (network_name)
def get_host_vm_info(vcsa_host):
user = "******"
passwd = "xxxxx"
server = VIServer()
server.connect(vcsa_host, user, passwd)
print('\033[32mVC connect successful...\033[0m')
host_info = dict()
for esx_hostname, esx_ip in server.get_hosts().items():
print(esx_hostname, esx_ip)
props = server._retrieve_properties_traversal(property_names=[
'name', 'summary.overallStatus',
'summary.quickStats.overallMemoryUsage',
'summary.quickStats.overallCpuUsage',
'summary.hardware.memorySize', 'summary.hardware.numCpuCores',
'summary.hardware.numCpuThreads', 'summary.hardware.cpuMhz',
'summary.hardware.otherIdentifyingInfo', 'hardware.biosInfo',
'summary.hardware', 'datastore'
],
from_node=esx_hostname,
obj_type="HostSystem")
try:
for prop_set in props:
# mor = prop_set.Obj #in case you need it
for prop in prop_set.PropSet:
if prop.Name == "summary.quickStats.overallMemoryUsage":
used_mem = prop.Val
elif prop.Name == "summary.quickStats.overallCpuUsage":
host_used_cpu = prop.Val
elif prop.Name == "summary.hardware.otherIdentifyingInfo":
identification_info_list = prop.Val.__dict__[
'_HostSystemIdentificationInfo']
host_sn = identification_info_list[-1].__dict__[
'_identifierValue']
elif prop.Name == "summary.hardware.memorySize":
host_info["server_mem"] = prop.Val
elif prop.Name == "summary.hardware.numCpuThreads":
host_cpu_num = prop.Val
elif prop.Name == "summary.hardware.numCpuCores":
host_cpucores_num = prop.Val
elif prop.Name == "summary.hardware.cpuMhz":
mhz_per_core = prop.Val
elif prop.Name == "summary.overallStatus":
host_status = prop.Val
if host_status == "green":
host_info["status"] = "running"
elif host_status == "gray":
host_info["status"] = "down"
elif host_status == "yellow":
host_info["status"] = "running"
elif host_status == "red":
host_info["status"] = "error"
elif prop.Name == "hardware.biosInfo":
time_tuple = prop.Val.__dict__['_releaseDate']
host_info["release_date"] = time.strftime(
"%Y-%m-%d", time_tuple)
# print HostBiosInfo
elif prop.Name == "datastore":
datastore_list = prop.Val.__dict__[
'_ManagedObjectReference']
server_disk = dict()
disk_all_free = dict()
Datastore_All = 0
Datastore_Free = 0
for index, ds in enumerate(datastore_list):
DatastoreCapacity = 0
DatastoreFreespace = 0
DatastoreUsagePercent = 0
props_d = server._retrieve_properties_traversal(
property_names=[
'name', 'summary.capacity',
'summary.freeSpace'
],
from_node=ds,
obj_type="Datastore")
for prop_set_d in props_d:
for prop_d in prop_set_d.PropSet:
if prop_d.Name == "summary.capacity":
DatastoreCapacity = (prop_d.Val /
1024 / 1024 /
1024)
elif prop_d.Name == "summary.freeSpace":
DatastoreFreespace = (prop_d.Val /
1024 / 1024 /
1024)
DatastorePreUsagePercent = ((
(DatastoreCapacity - DatastoreFreespace) * 100)
/ DatastoreCapacity)
disk_all_free[ds] = [
DatastoreCapacity, DatastoreFreespace,
DatastorePreUsagePercent
]
Datastore_All = Datastore_All + DatastoreCapacity
Datastore_Free = Datastore_Free + DatastoreFreespace
DatastoreUsagePercent = ((
(Datastore_All - Datastore_Free) * 100) /
Datastore_All)
server_disk["total"] = Datastore_All
server_disk["free"] = Datastore_Free
server_disk["used_pct"] = DatastoreUsagePercent
server_disk["detail"] = disk_all_free
# print server_disk
elif prop.Name == "summary.hardware":
# print 'hardware----:', prop.Val.__dict__
hardware = prop.Val.__dict__
host_info["product_name"] = hardware['_model']
host_info["uuid"] = hardware['_uuid']
host_info["manufacturer"] = hardware['_vendor']
except Exception as e:
# print(prop.Val.__dict__)
print(e)
continue
host_info["vmware_disk"] = server_disk
host_info["used_cpu"] = (host_used_cpu * 100) / (host_cpucores_num *
mhz_per_core)
host_info["server_cpu"] = host_cpu_num
host_info["used_mem"] = '%.1f' % (
(used_mem * 1024 * 1024 * 100) / host_info["server_mem"])
host_info["is_vm"] = 0
host_info['sn'] = host_sn
host_info["os"] = "VMware ESX"
host_info["hostname"] = esx_hostname
host_info["nic_mac_ip"] = {esx_hostname: [{esx_hostname: [esx_ip]}]}
host_info["check_update_time"] = datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S")
# host_running_num = len(server.get_registered_vms(esx_hostname, status='poweredOn'))
# host_stop_num = len(server.get_registered_vms(esx_hostname, status='poweredOff'))
host_info["vm_num"] = len(server.get_registered_vms(esx_hostname))
res['params'] = host_info
print(esx_ip, host_info)
send(res)
# vm host
vms_info = dict()
properties = [
'summary.vm', 'summary.config.numEthernetCards',
'summary.config.annotation', 'summary.config.numVirtualDisks',
'summary.quickStats.overallCpuUsage',
'summary.quickStats.guestMemoryUsage',
'summary.quickStats.ftLogBandwidth',
'summary.quickStats.hostMemoryUsage',
'summary.quickStats.uptimeSeconds', 'summary.runtime.powerState',
'summary.runtime.bootTime', 'summary.runtime.host',
'summary.runtime.maxCpuUsage', 'summary.runtime.maxMemoryUsage',
'summary.storage.committed', 'summary.storage.uncommitted',
'summary.storage.unshared', 'summary.storage.timestamp',
'guestHeartbeatStatus', 'guest.toolsStatus',
'guest.toolsVersionStatus', 'guest.toolsVersion', 'guest.guestId',
'guest.guestFullName', 'guest.guestState', 'guest.ipAddress',
'guest.hostName', 'name', 'parent', 'config.template',
'config.hardware.numCPU', 'config.hardware.memoryMB', 'config.uuid'
]
# 通过_retrieve_properties_traversal方法传入API接口定义拿到对象类型为 VirtualMachine 的信息
props = server._retrieve_properties_traversal(property_names=properties,
obj_type='VirtualMachine')
server.disconnect()
# 通过server.get_hosts()拿到VC下面所有的host信息（字典）；
# 通过这个方法可以把'guest.hostName'取出的MOR对象转换成实际的hostname
# hostname = server.get_hosts().items()
for prop in props:
mor = prop.Obj
vm = {}
for p in prop.PropSet:
vm[p.Name] = p.Val
vms_info[mor] = vm
vms_dict = vms_info.values()
vm_info = {}
for i in range(len(vms_dict)):
vm = vms_dict[i]
"""
{'config.hardware.numCPU': 2, 'guest.guestId': 'centos64Guest', 'guest.guestFullName': 'CentOS 4/5 or later (64-bit)',
'summary.quickStats.hostMemoryUsage': 3846, 'summary.storage.committed': 68898546142, 'guest.hostName': 'JF-PROD-zk02',
'summary.quickStats.uptimeSeconds': 63854590, 'summary.runtime.maxMemoryUsage': 4096,
'config.uuid': '564d162d-99ee-19a4-9b2d-6721d5e6f9f1', 'guest.ipAddress': '172.20.1.27',
'config.template': False, 'guest.toolsVersionStatus': 'guestToolsCurrent', 'summary.quickStats.ftLogBandwidth': -1,
'summary.config.numEthernetCards': 1, 'summary.storage.uncommitted': 1002, 'config.hardware.memoryMB': 4096,
'summary.runtime.host': 'host-396', 'summary.config.annotation': '', 'parent': 'group-v372',
'summary.quickStats.overallCpuUsage': 66, 'summary.runtime.powerState': 'poweredOn', 'summary.runtime.maxCpuUsage': 4400,
'guest.toolsVersion': '9536', 'guest.guestState': 'running', 'guestHeartbeatStatus': 'green', 'name': 'JF-PROD-zk02',
'summary.storage.timestamp': (2018, 11, 30, 15, 25, 30, 654, 0, 0), 'summary.storage.unshared': 64424509440,
'summary.config.numVirtualDisks': 2, 'summary.quickStats.guestMemoryUsage': 327,
'summary.runtime.bootTime': (2016, 9, 18, 23, 20, 56, 724, 0, 0), 'guest.toolsStatus': 'toolsOk', 'summary.vm': 'vm-401'}
"""
# vm_info["hostname"] = vm["name"]
vm_info["parent_host"] = vm["summary.runtime.host"]
vm_info["uuid"] = vm["config.uuid"]
vm_info["status"] = vm["guest.guestState"]
print(vm_info)
res['params'] = vm_info
send(res)
help="Node ID of the VC from config.json")
args = parser.parse_args()
if args.id_server and args.id_node:
for i in range(0, len(my_data)):
node = my_data[i]['node']
if node == args.id_node:
if hasattr(ssl, '_create_unverified_context'):
ssl._create_default_https_context = ssl._create_unverified_context
s = VIServer()
server = s
s.connect(my_data[i]['ip'], my_data[i]['username'],
my_data[i]['password'])
vmobj = VmBasicOperations(server)
properties = ["config.instanceUuid"]
expected_uuid = args.id_server
results = s._retrieve_properties_traversal(
property_names=properties, obj_type=MORTypes.VirtualMachine)
mor = None
for item in results:
found = False
for p in item.PropSet:
if p.Val == expected_uuid:
found = True
mor = item.Obj
if found:
break
if not mor:
print "Object not found"
else:
prop = VIProperty(s, mor)
print prop.name
print prop.config.instanceUuid
s = VIServer()
s.connect(server, user, password)
#datacentername = s.get_datacenters().values()
#hostname = s.get_hosts().values()
#cluster_name = s.get_clusters().values()
#GET INITIAL PROPERTIES AND OBJECTS
dcmor = [k for k, v in s.get_datacenters().items() if v == datacentername][0]
dcprops = VIProperty(s, dcmor)
hfmor = dcprops.hostFolder._obj
crmors = s._retrieve_properties_traversal(property_names=['name', 'host'],
from_node=hfmor,
obj_type='ComputeResource')
hostmor = [k for k, v in s.get_hosts().items() if v == hostname][0]
crmor = None
for cr in crmors:
if crmor:
break
for p in cr.PropSet:
if p.Name == "host":
for h in p.Val.get_element_ManagedObjectReference():
if h == hostmor:
crmor = cr.Obj
break
if crmor:
