def vmaction(self, vm_name, vm_hz):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
print e
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
return 0
if vm.is_powered_off() == False:
try:
vm.reset()
# print (type(int(vm_hz)))
for i in range(1, int(vm_hz)):
print u'虚拟机%s 正在重置中。。。。，请等待注册\n' % (vm_name)
time.sleep(1)
print u'重置完成'
server_obj.disconnect()
return 1
except Exception as e:
print e
if vm.is_powered_off() == True:
try:
vm.power_on()
print u'虚拟机%s 正在开机中。。。。' % (vm_name)
server_obj.disconnect()
except Exception as e:
return 2
def main(argv=None):
if argv is None:
argv = sys.argv
server = VIServer()
server.connect(sys.argv[1], sys.argv[2], sys.argv[3])
print "{"
print "\t\"data\":[\n"
first = 1
for ds_mor, name in server.get_datastores().items():
props = VIProperty(server, ds_mor)
if not first:
sys.stdout.write(",")
first = 0
pfree = float(props.summary.freeSpace) / float(props.summary.capacity) * 100
print "\n\t{"
print "\t\t\"{#DSNAME}\":\"%s\"," % name
print "\t\t\"{#DSACCESS}\":\"%d\"," % props.summary.accessible
print "\t\t\"{#DSCAP}\":\"%s\"," % props.summary.capacity
print "\t\t\"{#DSFREE}\":\"%s\"," % props.summary.freeSpace
print "\t\t\"{#DSPFREE}\":\"%s\"" % pfree
sys.stdout.write("\t}")
print "\n\t]"
print "}"
server.disconnect()
def vmwareplugin_datastores(request):
from pysphere import VIServer
data = {
'error': False,
}
if request.POST.get('oid'):
vmware = models.VMWarePlugin.objects.get(id=request.POST.get('oid'))
else:
vmware = None
try:
if request.POST.get('password'):
password = request.POST.get('password')
elif not request.POST.get('password') and vmware:
password = vmware.get_password()
else:
password = ''
server = VIServer()
server.connect(
request.POST.get('hostname'),
request.POST.get('username'),
password,
sock_timeout=7,
)
data['value'] = server.get_datastores().values()
server.disconnect()
except Exception, e:
data['error'] = True
data['errmsg'] = unicode(e).encode('utf8')
def vmwareplugin_datastores(request):
from pysphere import VIServer
data = {
'error': False,
}
if request.POST.get('oid'):
vmware = models.VMWarePlugin.objects.get(id=request.POST.get('oid'))
else:
vmware = None
try:
if request.POST.get('password'):
password = request.POST.get('password')
elif not request.POST.get('password') and vmware:
password = vmware.get_password()
else:
password = ''
server = VIServer()
server.connect(
request.POST.get('hostname'),
request.POST.get('username'),
password,
sock_timeout=7,
)
data['value'] = server.get_datastores().values()
server.disconnect()
except Exception, e:
data['error'] = True
data['errmsg'] = unicode(e).encode('utf8')
class VSphereConnection(ConnectionUserAndKey):
def __init__(self, user_id, key, secure=True,
host=None, port=None, url=None, timeout=None, **kwargs):
if host and url:
raise ValueError('host and url arguments are mutually exclusive')
if host:
host_or_url = host
elif url:
host_or_url = url
else:
raise ValueError('Either "host" or "url" argument must be '
'provided')
self.host_or_url = host_or_url
self.client = None
super(VSphereConnection, self).__init__(user_id=user_id,
key=key, secure=secure,
host=host, port=port,
url=url, timeout=timeout,
**kwargs)
def connect(self):
self.client = VIServer()
trace_file = os.environ.get('LIBCLOUD_DEBUG', None)
try:
self.client.connect(host=self.host_or_url, user=self.user_id,
password=self.key,
sock_timeout=DEFAULT_CONNECTION_TIMEOUT,
trace_file=trace_file)
except Exception:
e = sys.exc_info()[1]
message = e.message
if hasattr(e, 'strerror'):
message = e.strerror
fault = getattr(e, 'fault', None)
if fault == 'InvalidLoginFault':
raise InvalidCredsError(message)
raise LibcloudError(value=message, driver=self.driver)
atexit.register(self.disconnect)
def disconnect(self):
if not self.client:
return
try:
self.client.disconnect()
except Exception:
# Ignore all the disconnect errors
pass
def run_client_method(self, method_name, **method_kwargs):
method = getattr(self.client, method_name, None)
return method(**method_kwargs)
class VSphereConnection(ConnectionUserAndKey):
def __init__(self, user_id, key, secure=True,
host=None, port=None, url=None, timeout=None, **kwargs):
if host and url:
raise ValueError('host and url arguments are mutually exclusive')
if host:
host_or_url = host
elif url:
host_or_url = url
else:
raise ValueError('Either "host" or "url" argument must be '
'provided')
self.host_or_url = host_or_url
self.client = None
super(VSphereConnection, self).__init__(user_id=user_id,
key=key, secure=secure,
host=host, port=port,
url=url, timeout=timeout,
**kwargs)
def connect(self):
self.client = VIServer()
trace_file = os.environ.get('LIBCLOUD_DEBUG', None)
try:
self.client.connect(host=self.host_or_url, user=self.user_id,
password=self.key,
sock_timeout=DEFAULT_CONNECTION_TIMEOUT,
trace_file=trace_file)
except Exception as e:
message = e.message
if hasattr(e, 'strerror'):
message = getattr(e, 'strerror', e.message)
fault = getattr(e, 'fault', None)
if fault == 'InvalidLoginFault':
raise InvalidCredsError(message)
raise LibcloudError(value=message, driver=self.driver)
atexit.register(self.disconnect)
def disconnect(self):
if not self.client:
return
try:
self.client.disconnect()
except Exception:
# Ignore all the disconnect errors
pass
def run_client_method(self, method_name, **method_kwargs):
method = getattr(self.client, method_name, None)
return method(**method_kwargs)
def test_vmware_version_vcenter(self):
""" Is the Vmware version at 5.1?"""
server = VIServer()
server.connect(CREDS.get('Vcenter', 'server'),
CREDS.get('Vcenter', 'user'),
CREDS.get('Vcenter', 'pass'))
api = server.get_api_version()
self.assertEqual('5.1', api)
server.disconnect()
def test_vmware_version_vcenter(self):
""" Is the Vmware version at 5.1?"""
server = VIServer()
server.connect(CREDS.get('Vcenter', 'server'),
CREDS.get('Vcenter', 'user'),
CREDS.get('Vcenter', 'pass'))
api = server.get_api_version()
self.assertEqual('5.1', api)
server.disconnect()
def esxi_version(self):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
servertype, version = server_obj.get_server_type(),server_obj.get_api_version()
server_obj.disconnect()
return servertype, version
except Exception as e:
print e
def main():
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
try:
vm = s.get_vm_by_name(opts.name)
vm.shutdown_guest()
count = 1
wait_for = 60
try:
while count < wait_for and vm.is_powered_off() == False:
count += 1
time.sleep(1)
print "Elapsed %s seconds ..." % str(count)
except Exception as e:
if count >= wait_for:
print "Failed to shutdown the VM (%s) even after %s seconds." % (vmname, str(wait_for))
print "Please login to the EXSi server and fix the issue. Exception: %s" % str(e)
sys.exit(1)
check_count(count, wait_for)
except Exception as e:
print "Failed to locate and shutdown the new VM using:", opts.name
print "VM could not be deleted."
print "Exception:", str(e)
# Invoke Destroy_Task
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 = s._proxy.Destroy_Task(request)._returnval
# Wait for the task to finish
task = VITask(ret, s)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
print "VM successfully deleted from disk"
elif status == task.STATE_ERROR:
print "Error removing vm:", task.get_error_message()
# disconnect from the server
s.disconnect()
def main():
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
template = opts.template
cd_iso_location = opts.iso
datastorename = opts.datastore # if None, will use the first datastore available
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
# Clone the VM.
try:
template_vm = s.get_vm_by_name(template)
except Exception as e:
print "Failed to locate the template."
print "Exception:", str(e)
sys.exit(1)
vm = template_vm.clone(vmname, power_on=False)
cdrom = None
for dev in vm.properties.config.hardware.device:
if dev._type == "VirtualCdrom":
cdrom = dev._obj
break
change_cdrom_type(cdrom, "ISO", "[%s] %s" % (datastorename, cd_iso_location))
apply_changes(vm, s, cdrom)
# 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 vm_status(self, vm_name):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
# servertype, version = server_obj.get_server_type(),server_obj.get_api_version()
except Exception as e:
server_obj.disconnect()
print e
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
if vm.is_powered_off() == False:
server_obj.disconnect()
return 1
if vm.is_powered_off() == True:
server_obj.disconnect()
return 2
except Exception as e:
server_obj.disconnect()
return 3
def vm_status(self, vm_name):
m = Info_log(time.strftime('%Y-%m-%d', time.localtime(time.time())))
log = m.log()
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
# servertype, version = server_obj.get_server_type(),server_obj.get_api_version()
except Exception as e:
server_obj.disconnect()
log.info(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
if vm.is_powered_off() == False:
server_obj.disconnect()
return 1
if vm.is_powered_off() == True:
server_obj.disconnect()
return 2
except Exception as e:
server_obj.disconnect()
return 3
def main():
DisableSSL()
server = VIServer()
server.connect(vCenterIP, username, password)
hostslist = server.get_hosts().values()
# print hostslist
f = open("hosts.txt", "w")
sep = "\n"
f.write(sep.join(hostslist))
f.close()
#Disconnecting from the server
server.disconnect()
def main():
DisableSSL()
server = VIServer()
server.connect(vCenterIP,username,password)
hostslist = server.get_hosts().values()
# print hostslist
f = open("hosts.txt","w")
sep = "\n"
f.write(sep.join(hostslist))
f.close()
#Disconnecting from the server
server.disconnect()
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 esxi_version(self):
m = Info_log(time.strftime('%Y-%m-%d', time.localtime(time.time())))
log = m.log()
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
servertype, version = server_obj.get_server_type(
), server_obj.get_api_version()
server_obj.disconnect()
return servertype, version, self.flag
except Exception as e:
server_obj.disconnect()
log.info(e)
class Server:
def __init__(self):
self.server = VIServer()
self.connect()
def connect(self):
try:
# monkey-patch SSL module (uncomment if unneeded)
#ssl._create_default_https_context = ssl._create_unverified_context
self.server.connect('vsphere-host', 'user', 'password')
except Exception as e:
return str(e)
return False
def disconnect(self):
self.server.disconnect()
def set_ip_via_vsphere(vm_name, fqdn):
#Connect to vSphere
server = VIServer()
server.connect(settings.VSPHERE_HOSTNAME, settings.VSPHERE_USERNAME, settings.VSPHERE_PASSWORD)
#Connect to the new vm. Call the object vm1
vm1 = server.get_vm_by_name(vm_name)
vm1.login_in_guest(settings.VSPHERE_TEMPLATE_USERNAME, settings.VSPHERE_TEMPLATE_PASSWORD)
#login and set the IP and restart networking to get it on the air
vm1.send_file(settings.TEMP_LOCATION_CONFIG_NETWORK.format(fqdn=fqdn), '/etc/sysconfig/network', overwrite=True)
vm1.send_file(settings.TEMP_LOCATION_CONFIG_ETH0.format(fqdn=fqdn), '/etc/sysconfig/network-scripts/ifcfg-eth0', overwrite=True)
vm1.start_process("/sbin/service", args=["network", "restart"])
vm1.start_process("/bin/hostname", args=[fqdn])
#disconnect from vSphere
server.disconnect()
class Server:
def __init__(self):
self.server = VIServer()
self.connect()
def connect(self):
try:
# monkey-patch SSL module (uncomment if unneeded)
#ssl._create_default_https_context = ssl._create_unverified_context
self.server.connect(os.getenv("API_ADDRESS"), os.getenv("USER"), os.getenv("PASSWORD"))
except Exception as e:
return str(e)
return False
def disconnect(self):
self.server.disconnect()
def vm_migrate():
"""Migrate the VMs based on the list given"""
user, passwd, vcenter = get_user_info()
host, servers, servercount = get_serverlist()
s = VIServer()
s.connect(vcenter, user, passwd)
getserver_type_api()
esxhost_input = raw_input('Enter target ESX Host: ')
esxhost = s.get_hosts().items()
for k,v in esxhost:
if v == esxhost_input:
for host in servers:
host = host.strip()
vm = s.get_vm_by_name(host)
vm.migrate(host=k)
time.sleep(10)
s.disconnect()
def revert_and_start():
try:
for host in get_hosts():
server = VIServer()
server.connect(host.ip, host.user, host.pwd)
for vm_path in host.vms:
try:
vm = server.get_vm_by_path(vm_path.strip())
vm.revert_to_snapshot()
if not vm.is_powered_on():
vm.power_on()
except Exception, e:
print "[ERROR] Error happened when revert and start test lab %s" % vm_path
print e
server.disconnect()
except Exception, e:
print "[ERROR] Error happened when prepare test enviroment(revert and start test labs)."
print e
def revert_and_start():
try:
for host in get_hosts():
server = VIServer()
server.connect(host.ip, host.user, host.pwd)
for vm_path in host.vms:
try:
vm = server.get_vm_by_path(vm_path.strip())
vm.revert_to_snapshot()
if not vm.is_powered_on():
vm.power_on()
except Exception, e:
print "[ERROR] Error happened when revert and start test lab %s" % vm_path
print e
server.disconnect()
except Exception, e:
print "[ERROR] Error happened when prepare test enviroment(revert and start test labs)."
print e
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
class vSphere:
hostname = ""
username = ""
password = ""
def __init__(self, vm_path):
self.vm_path = vm_path
def __enter__(self):
self.server = VIServer()
self.server.connect(self.hostname, self.username, self.password)
print "DBG connect"
vm = self.server.get_vm_by_path(self.vm_path)
return vm
def __exit__(self, type, value, traceback):
try:
self.server.disconnect()
print "DBG disconnect"
except VIException as e:
print "DBG problem in disconnection. Fault is: %s" % e.fault
pass
def main():
if len(sys.argv) <> 3:
print ("Usage:")
print (sys.argv[0], "<username> <password")
username = sys.argv[1]
password = sys.argv[2]
vcenter = "ecnshmw1001.sh.cn.ao.ericsson.se"
server = VIServer()
server.connect( vcenter, username, password )
print ("Login .....")
type = server.get_api_type()
version = server.get_api_version()
print ("You are now connecting with {0} with API version {1}".format(type, version))
select(server)
server.disconnect()
class vSphere:
hostname = ""
username = ""
password = ""
def __init__(self, vm_path):
self.vm_path = vm_path
def __enter__(self):
self.server = VIServer()
self.server.connect(self.hostname, self.username, self.password)
print "DBG connect"
vm = self.server.get_vm_by_path(self.vm_path)
return vm
def __exit__(self, type, value, traceback):
try:
self.server.disconnect()
print "DBG disconnect"
except VIException as e:
print "DBG problem in disconnection. Fault is: %s" % e.fault
pass
def vmaction(self, vm_name):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
print(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
print(e)
return 0
if vm.is_powered_off() == False:
try:
vm.reset()
# vm.power_off()
# print (type(int(vm_hz)))
# for i in range(1, int(vm_hz)):
# print (f'虚拟机{vm_name} 正在重置中。。。。，请等待注册\n' )
# time.sleep(1)
# print ('重置完成')
server_obj.disconnect()
return 1
except Exception as e:
print(e)
if vm.is_powered_off() == True:
try:
# vm.power_on()
# print (f'虚拟机{vm_name} 正在开机中。。。。')
server_obj.disconnect()
except Exception as e:
return 2
class vSphere:
def __init__(self, vm_path, sdk_host, sdk_user, sdk_domain, sdk_passwd):
self.vm_path = vm_path
self.sdk_host = sdk_host
self.sdk_user = sdk_domain + "\\" + sdk_user
self.sdk_passwd = sdk_passwd
def __enter__(self):
self.server = VIServer()
self.server.connect(self.sdk_host, self.sdk_user, self.sdk_passwd)
if config.verbose:
logging.debug("connected to vSphere")
vm = self.server.get_vm_by_path(self.vm_path)
return vm
def __exit__(self, type, value, traceback):
try:
self.server.disconnect()
if config.verbose:
logging.debug("disconnected from vSphere")
except VIException as e:
logging.debug("Problem in disconnection. Fault is: %s" % e.fault)
pass
class EsxiServer:
server_ip = ''
user_name = ''
password = ''
connect_flag = False
server = None
def opearte_guest_power(self, src_vm_name, operate):
""""
|##desc: 操作客户机电源（重启、关机、开机）,这种模式不需要vmtools,就是强制操作电源，不走操作系统 ，可能损坏数据
|##:param: >vm1.power_on()
>vm1.reset()
>vm1.suspend() #since pysphere 0.1.5
>vm1.power_off()
|##:return: None
|##@author： jhuang
|##@time：12/12/2017
"""
ovm = self.server.get_vm_by_name(src_vm_name)
if operate == 'power_on':
ovm.power_on()
return True
elif operate == 'reset':
ovm.reset()
return True
elif operate == 'suspend':
ovm.suspend()
return True
elif operate == 'power_off':
ovm.power_off()
return True
else:
print "Operate guest error: operate can noly be set as power_on, reset, suspend, power_off"
return False
def clone(self, src_vm_name, dest_vm_name, datacenter=None, sync_run=True, folder=None, resourcepool=None,
datastore=None, host=None, power_on=True, template=False,
snapshot=None, linked=False):
"""
|##desc: 克隆虚拟机
|##:param: None
|##:return: None
|##@author： jhuang
|##@time：12/12/2017
"""
# get_vm_by_name 在包含2个数据中心的情况下，需要指定参数 datacenter 其中的限定条件为datacenter
# vm1 = server.get_vm_by_path("[DataStore1] Ubantu/Ubantu-10.vmx") 通过路径方法获取对象
logger.debug(src_vm_name)
logger.debug(datacenter)
ovm = self.server.get_vm_by_name(src_vm_name, datacenter)
new_vm = ovm.clone(dest_vm_name)
def create_snapshot(self, src_vm_name, snapShotName):
"""
|##desc: 创建快照
|##:param: None
|##:return: None
|##@author： jhuang
|##@time：12/12/2017
"""
ovm = self.server.get_vm_by_name(src_vm_name)
ovm.create_snapshot(snapShotName)
def set_ssl_no_verify(self):
ssl._create_default_https_context = ssl._create_unverified_context
# Use the given args to connect the esxi server you want
# @ip[string]: ESXi server's IP address
# @name[string]: the username used to login the ESXi server
# @pwd[string]: the password used to login the ESXi server
def connect_server(self, ip, name, pwd, ssl_no_verify=True):
logger.debug(ip)
logger.debug(name)
logger.debug(pwd)
self.server_ip = ip
self.user_name = name
self.password = pwd
self.server = VIServer()
if ssl_no_verify:
self.set_ssl_no_verify()
self.server.connect(self.server_ip, self.user_name, self.password)
self.connect_flag = self.server.is_connected()
if self.connect_flag:
return True
return False
# To get all the definition registered vms from the connected server
# @param[string]: can be set as ALL, POWER_ON, POWER_OFF, SUSPENDED
# According to the param, returns a list of VM Paths. You might also filter by datacenter,
# cluster, or resource pool by providing their name or MORs.
# if cluster is set, datacenter is ignored, and if resource pool is set
# both, datacenter and cluster are ignored.
def get_registered_vms(self, param='ALL', status=None, datacenter=None, cluster=None,
resource_pool=None):
"""
获取注册的主机 （虚拟机）
:param param1: this is a first param
:param param2: this is a second param
:returns: this is a description of what is returned
:raises keyError: raises an exception
@author： jhuang
@time：28/02/2018
"""
if param not in ['ALL', 'POWER_ON', 'POWER_OFF', 'SUSPENDED']:
print "Get VMs error: param can only be set as ALL, POWER_ON, POWER_OFF, or SUSPENDED."
return None
if self.connect_flag == False:
print "Get VMs error: Server not connected."
return None
if param == 'ALL':
return self.server.get_registered_vms(datacenter, cluster, resource_pool)
elif param == 'POWER_ON':
return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOn')
elif param == 'POWER_OFF':
return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='poweredOff')
elif param == 'SUSPENDED':
return self.server.get_registered_vms(datacenter, cluster, resource_pool, status='suspended')
else:
return None
# Disconnect to the Server
def disconnect(self):
if self.connect_flag is True:
self.server = self.server.disconnect()
self.connect_flag == False
# To keep session alive
def keep_session_alive(self):
assert self.server.keep_session_alive()
# To get the server type
def get_server_type(self):
return self.server.get_server_type()
# To get performance manager
def get_performance_manager(self):
return self.server.get_performance_manager()
# To get the all the server's hosts
def get_all_hosts(self):
"""
获取所有主机(这个是宿主机)
Returns a dictionary of the existing hosts keys are their names
and values their ManagedObjectReference object.
"""
return self.server.get_hosts()
# To get all datastores
def get_all_datastores(self):
"""
获取存储列表
Returns a dictionary of the existing datastores. Keys are
ManagedObjectReference and values datastore names.
"""
return self.server.get_datastores()
# To get all clusters
def get_all_clusters(self):
"""
获取所有集群列表
Returns a dictionary of the existing clusters. Keys are their
ManagedObjectReference objects and values their names.
"""
return self.server.get_clusters()
# To get all datacenters
def get_all_datacenters(self):
"""
获取数据中心列表
Returns a dictionary of the existing datacenters. keys are their
ManagedObjectReference objects and values their names.
"""
return self.server.get_datacenters()
# To get all resource pools
def get_all_resource_pools(self):
"""
Returns a dictionary of the existing ResourcePools. keys are their
ManagedObjectReference objects and values their full path names.
"""
return self.server.get_resource_pools()
# To get hosts by name
def get_hosts_by_name(self, from_mor):
"""
Returns a dictionary of the existing ResourcePools. keys are their
ManagedObjectReference objects and values their full path names.
@from_mor: if given, retrieves the hosts contained within the specified
managed entity.
"""
try:
hosts_dic = self.server.get_hosts(from_mor)
except:
print "Get hosts error!"
return None
return hosts_dic
class Server:
"""Vsphere server that a client can connect to"""
SUPPORTED_FILTER_KEYWORDS = ["uuidSpec", "pathSpec", "nameSpec"]
url = os.getenv("VSPHERE_URL")
"""URL of vSphere endpoint"""
# : vSphere account username
username = os.getenv("VSPHERE_USER")
# : vSphere account password
password = os.getenv("VSPHERE_PASSWORD")
def __init__(self, url=None, username=None, password=None):
"""Constructs an Server instance with given endpoint and credentials
:param url: end point hostname/URL to connect to.
As of this release, url must be an http url with port 80, e.g.
like this: http://vsphere.example.com
:param username: vSphere account username
:param password: vSphere account password
"""
self._server = VIServer()
self._vm_datacenters = {}
# don't set to None if already set from environment
if url:
self.url = url
if username:
self.username = username
if password:
self.password = password
def connect(self, url=None, username=None, password=None):
"""Connects to vSphere server using optional arguments
that may override those in Server constructor.
If arguments are not given, previously specified arguments will
be used for connection in this order:
* last connect arguments (if specified)
* constructor arguments (if specified)
* environment variables
If none of the above is specified, the exception MissingArgumentException
is raised
:type url: string
:param url: end point hostname/URL to connect to
:type username: string
:param username: vSphere account username
:type password: string
:param password: vSphere account password
:type password: string
:param password: vSphere account password
"""
if url:
self.url = url
if username:
self.username = username
if password:
self.password = password
# check if all needed properties available for connect
argErrors = []
if not self.url:
argErrors.append("url unknown")
if not self.username:
argErrors.append("username unknown")
if not self.password:
argErrors.append("password unknown")
if argErrors:
raise MissingArgumentError(" ".join(argErrors))
# parse host from url
host = urlparse(self.url).hostname
# perform connect
logger.debug("connect: %s; %s" % (url, username))
self._server.connect(host, self.username, self.password, trace_file=prototrace_file)
def disconnect(self):
"""Disconnects from vSphere server"""
self._server.disconnect()
self._server = []
def power_on_vm(self, instanceUuid, sync_run=True, host=None):
"""Powers on a virtual machine for a given instanceUuid"""
return self._get_instance(instanceUuid).power_on(sync_run, host)
def power_off_vm(self, instanceUuid, sync_run=True):
"""Powers off a virtual machine for a given instanceUuid"""
return self._get_instance(instanceUuid).power_off(sync_run)
def clone_vm(self, instanceUuid, name=None, sync_run=True, host=None):
"""Clones a virtual machine for a given instanceUuid.
:param instanceUuid: instanceUuid of VM to clone
:param name: name to give to the cloned machine.
if None, a new name will be generated using the original instance
name with time stamp appended, e.g.:
'ubuntu_csk1_08-1349968939'
"""
import time
instance = self._get_instance(instanceUuid)
if not name:
name = "%s-%d" % (instance.get_property("name"), time.time())
return instance.clone(name, sync_run, host=host)
def reset_vm(self, instanceUuid, sync_run=True):
"""Powers off a virtual machine for a given instanceUuid"""
return self._get_instance(instanceUuid).reset(sync_run)
def suspend_vm(self, instanceUuid, sync_run=True):
"""Suspends a virtual machine for a given instanceUuid"""
return self._get_instance(instanceUuid).suspend(sync_run)
def list_instances(self, instanceUuid=None, filter=None, datacenter=None):
"""Lists all vmware instances that match the given filter.
:type instanceUuid: string
:param instanceUuid: InstanceUuid to filter on. This is a convenience
parameter that will override a corresponding value in filter,
if it exists.
:param datacenter: name of datacenter to filter VMs registered in that datacenter
:type filter: dict
:param filter: represents a filter specification and can consist of
any valid properties, such as
{ 'config.instanceUuid': [ '50398c64-55ad-7eb2-f14a-6f70b6903b06' ] }
or
{'runtime.powerState': ['poweredOn']}
or
{'runtime.powerState': ['poweredOff'], 'config.instanceUuid': [ '50398c64-55ad-7eb2-f14a-6f70b6903b06' ] }
:rtype: list
:return: A list of :class:`vmware.vsphere.VM`
"""
# get the vm paths
if instanceUuid and len(instanceUuid):
if not isinstance(instanceUuid, str):
raise BadParameterError("instanceUuid parameter must be a string")
if not filter:
filter = {}
filter["config.instanceUuid"] = [instanceUuid]
self._vmspaths = self._server.get_registered_vms(datacenter, advanced_filters=filter)
logger.debug("list_instances: retrieved %d vm paths" % len(self._vmspaths))
# instantiate instances for vm paths
self.vms = []
for p in self._vmspaths:
self.vms.append(VM(p, self))
# first time this function runs, fetch information about vm to datacenter mapping
self._fetch_datacenter_vms()
return self.vms
def get_hosts(self, datacenter=None):
"""Returns a dictionary of the existing hosts keys are their names
and values their ManagedObjectReference object.
Example usage:
>>> server.get_hosts()
{'host-23': '108.61.71.220', 'host-19': '108.61.71.219', 'host-36': '173.71.195.168'}
>>> server.get_hosts('datacenter-12')
>>> from catosphere import Server
>>> server = Server()
>>> server.connect()
>>> server.get_datacenters()
{'datacenter-12': 'csk3', 'datacenter-2': 'csk1', 'datacenter-7': 'csk2'}
>>> server.get_hosts('datacenter-2')
{'host-23': '108.61.71.220', 'host-19': '108.61.71.219'}
>>> server.get_hosts('datacenter-7')
{'host-36': '173.71.195.168'}
>>> server.get_hosts('datacenter-12')
{}
>>> server.get_hosts()
{'host-23': '108.61.71.220', 'host-19': '108.61.71.219', 'host-36': '173.71.195.168'}
>>> server.disconnect()
:return: a dict
e.g.
{'host-23': '108.61.71.220', 'host-19': '108.61.71.219', 'host-36': '173.71.195.168'}
if not hosts are found, empty dict is returned.
"""
if datacenter:
hosts = self._server._get_managed_objects(MORTypes.HostSystem, from_mor=datacenter)
else:
hosts = self._server.get_hosts()
return hosts
def get_datacenters(self):
"""Returns a dictionary of the existing datacenters. keys are their
ManagedObjectReference objects and values their names.
:return: a dict
e.g.
{'datacenter-12': 'csk3', 'datacenter-2': 'csk1', 'datacenter-7': 'csk2'}
"""
return self._server.get_datacenters()
# ******************************************************
# ***************** Private Methods *******************
# ******************************************************
def _fetch_datacenter_vms(self):
""" Fetch/cache datacenter vm mapping information.
This can be later used to retrieve datacenter information for each
VM.
"""
if not self._vm_datacenters:
dcs = self.get_datacenters()
for name in dcs.keys():
self._vm_datacenters[name] = self._server._get_managed_objects(MORTypes.VirtualMachine, from_mor=name)
# logger.debug(': _vm_datacenters: %s' % self._vm_datacenters)
def _get_instance(self, instanceUuid):
""" Retrieves instance by its instanceUuid.
TODO: make this faster by caching instances.
"""
instances = self.list_instances(instanceUuid)
if not instances:
raise InstanceNotFoundError("Instance %s not found" % instanceUuid)
else:
return instances[0]
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
fetch_data(prop.name, prop.config.instanceUuid, random_string,
node, server, vmobj)
s.disconnect()
sys.exit(1)
if __name__ == '__main__':
for vc in range(0, len(my_data)):
##### To establish connection with the VCENTER server #####
if hasattr(ssl, '_create_unverified_context'):
ssl._create_default_https_context = ssl._create_unverified_context
conobj = Connect(my_data[vc]['ip'], my_data[vc]['username'],
my_data[vc]['password'])
node = my_data[vc]['node']
print "Processing node - %s \n" % node
print "Before connection - Main"
server = conobj.connectServer()
print "Got server connection - Main"
class Report:
"""Class report. Generate a dictionnary with the VMs and these properties"""
def __init__(self, config):
self.login = config['user']
self.password = config['password']
self.vcenter = config['vcenter']
self.server = VIServer()
def connect(self):
"""Connect to the hypervisor"""
self.server.connect(self.vcenter, self.login, self.password)
def disconnect(self):
"""Close the connection with the hypervisor"""
if self.server:
self.server.disconnect()
def generate_report(self):
"""Generate the report of the actual connection"""
report = []
# Create the report
vms_list = self.server.get_registered_vms()
for vm_path in vms_list:
virtual_machine = self.server.get_vm_by_path(vm_path)
if str(virtual_machine.__class__
) != "pysphere.vi_virtual_machine.VIVirtualMachine":
continue
if re.match(r'rhel', virtual_machine.get_property('guest_id')):
vm_infos = {
'name': virtual_machine.get_property('name'),
'ip': virtual_machine.get_property('ip_address'),
'os': virtual_machine.get_property('guest_id')
}
try:
status = virtual_machine.get_status()
except Exception, e:
print "Couldn't do it: %s" % e
vm_infos['powered'] = 'none'
report.append(vm_infos)
continue
if status == "POWERED ON":
vm_infos['powered'] = 'on'
# Get version in ssh
ssh = subprocess.Popen([
"ssh", "-i ~/.ssh/id_rsa",
"%s" % vm_infos['name'], "cat /etc/redhat-release"
],
shell=False,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
release = ssh.stdout.readlines()
if release == []:
error = ssh.stderr.readlines()
vm_infos['release'] = "error: " + error
else:
regex = re.compile("release (\d.*).+\(\D*(\d*)\)")
r = regex.search(release[0])
release = r.groups()
if release[1].strip():
vm_infos['release'] = release[0] + "." + release[1]
else:
vm_infos['release'] = release[0]
else:
vm_infos['powered'] = 'off'
report.append(vm_infos)
return report
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)
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)
def main():
setup_logger()
log(level="info",
msg="===================================================")
log(level="info", msg="detect_installation_completion logger initialized.")
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
log(level="info", msg="Attempting to locate the guest VM: %s" % vmname)
count = 1
wait_for = 10
while count < wait_for:
count += 1
try:
guest_vm = s.get_vm_by_name(opts.name)
if guest_vm:
break
except Exception as e:
if count >= wait_for:
log(level="error", msg="Failed to locate the new VM (%s) even after %s seconds." %
(vmname, str(wait_for)))
log(level="info", msg="Please login to the EXSi server and fix the issue. Exception: %s" %
str(e))
sys.exit(1)
time.sleep(1)
log(level="info", msg="Elapsed %s seconds ..." % str(count))
check_count(count, wait_for)
log(level="info", msg="Located VM: %s" % vmname)
log(level="info", msg="Waiting for the OS installation to complete...")
log(level="info", msg="Will wait for about 60 minutes (at max) ...")
wait_for = 3600 # 1 hour.
log(level="info",
msg="Note: There will be no output as the process would be blocked in waiting state until the Guest OS responds.")
log(level="info",
msg="Will automatically timeout after an hour (at max) ...")
try:
guest_vm.wait_for_tools(timeout=wait_for)
except Exception as e:
if count >= wait_for:
log(level="error", msg="Failed to get OS installation status in the new VM (%s) even after %s seconds." %
(vmname, str(wait_for)))
log(level="info", msg="Please login to the EXSi server and fix the issue. Exception: %s" %
str(e))
sys.exit(1)
log(level="info", msg="Received response from the Guest OS.")
log(level="info",
msg="Attempting to login in the Guest to check the status of the OS instalaltion (timeout 5 minutes) ...")
count = 1
wait_for = 300 # 5 minutes
while count < wait_for:
try:
guest_vm.login_in_guest(opts.username, opts.password)
break
except Exception as e:
if count >= wait_for:
log(level="error", msg="Failed to login to the Guest (%s) even after %s seconds." %
(vmname, str(wait_for)))
log(level="info", msg="Please login to the EXSi server and fix the issue. Exception: %s" %
str(e))
sys.exit(1)
count += 1
time.sleep(1)
log(level="info", msg="Elapsed %s seconds ..." % str(count))
check_count(count, wait_for)
log(level="info", msg="Successfully logged into guest.")
log(level="info",
msg="Checking the progress of the OS installation (will timeout after 30 minutes (at max)) ...")
log(level="info", msg="OS installation is still in progress.")
log(level="info",
msg="Waiting for it to complete (will timeout after 60 minutes (at max)) ...")
count = 1
wait_for = 3600 # 60 minutes
filename = "/etc/INSTALLATION_COMPLETED"
while count < wait_for:
try:
flag_file = guest_vm.list_files(filename)
if flag_file[0]['path'] == filename:
log(level="info",
msg="OS installation has completed. Successfully.")
break
except Exception as e:
if count >= wait_for:
log(level="error", msg="OS installation is still in progress in %s even after %s seconds. This is not expected." %
(vmname, str(wait_for)))
log(level="info", msg="Please login to the EXSi server and fix the issue. Exception: %s" %
str(e))
sys.exit(1)
count += 180
time.sleep(180)
log(level="info", msg="Elapsed %s seconds ..." % str(count))
check_count(count, wait_for)
if opts.fetch_ip is True:
vm_ip = guest_vm.get_property(
'net', from_cache=False)[0]['ip_addresses'][0]
log(level="info", msg="IP address of the deployed VM: %s" % str(vm_ip))
ip_file_path = settings.DEPLOYED_VM_IP_SAVE_FOLDER + "/%s.txt" % vmname
try:
with open(ip_file_path, 'w') as f:
f.write(vm_ip)
log(level="info", msg="Saved the IP of the deployed machine in: %s" %
ip_file_path)
f.close()
except:
log(level="error", msg="Failed to save the IP information in %s. Please try again." %
ip_file_path)
else: # if opts.fetch_ip == False
try:
network_fix = guest_vm.list_files('/etc/init.d/vm_network_fix')
log(level="info", msg="Network fix already exists. Nothing needs to be done.")
except:
try:
# Network fix does not exist.
log(level="info", msg="Network fix does not exist. Uploading vm_network_fix.")
guest_vm.send_file('vm_network_fix', '/etc/init.d/vm_network_fix', overwrite=True)
log(level="info", msg="Upload of vm_network_fix successful. Changing permissions.")
guest_vm.start_process('/bin/chmod', args=[
'755', 'vm_network_fix'], cwd='/etc/init.d')
time.sleep(1)
log(level="info", msg="Changing permissions successful. Adding the daemon to start-up sequence.")
guest_vm.start_process('/sbin/chkconfig', args=[
'--add', 'vm_network_fix'], cwd='/etc/init.d')
time.sleep(1)
log(level="info", msg="Updating start-up sequence successful. Starting the daemon.")
guest_vm.start_process('/sbin/service', args=[
'vm_network_fix', 'start'], cwd='/etc/init.d')
time.sleep(1)
log(level="info", msg="Daemon process started successfully.")
except Exception as e:
log(level="error", msg="Failed to upload vm_network_fix and start the daemon. Exception: " + str(e))
log(level="info",
msg="Waiting for 60 seconds so that all services start successfully.")
count = 1
wait_for = 60
while count < wait_for:
count += 2
time.sleep(2)
log(level="info", msg="Elapsed %s seconds ..." % str(count))
log(level="info", msg="All services should be up and running now ...")
log(level="info",
msg="Issuing a graceful shutdown request to the Guest.")
try:
guest_vm.start_process('/sbin/shutdown', args=[
'-h', 'now'], cwd='/root')
time.sleep(1)
count = 1
wait_for = 900 # 30 minutes.
log(level="info", msg="Waiting for the Guest to power-off ...")
while guest_vm.is_powered_off() is False:
time.sleep(1)
count += 1
log(level="info", msg="Elapsed %s seconds ..." % str(count))
if count >= wait_for:
log(level="warning",
msg="Its been 30 minutes and yet the system did not poweroff. This not expected.")
log(level="warning",
msg="OVFTool may hard-poweroff the VM while attempting to create an OVA of it.")
break
if count < wait_for:
log(level="info", msg="%s powered off successfully." % vmname)
except Exception as e:
log(level="error",
msg="Could not issue a graceful shutdown request to the guest.")
log(level="warning",
msg="OVFTool may hard-poweroff the VM while attempting to create an OVA of it.")
log(level="error", msg="Exception: %s" % str(e))
# Disconnect CDROM device from the VM.
try:
disconnect_vm_cdroms(guest_vm, s)
log(level="info", msg="Disconnected Virtual CDROM from %s successfully." %
vmname)
except:
log(level="error", msg="Exception while attempting to disconnect the virtual CD rom of %s." %
vmname)
log(level="error", msg="Exception: %s" % str(e))
# disconnect from the server
s.disconnect()
sys.exit(0)
#!/usr/bin/python
"""
Author: Pryz
Description: Get current status and properties of a VM with pysphere
"""
from pysphere import VIServer
# Connect to the vcenter
LOGIN = "******"
PWD = "password"
VCENTER = "vcenter.labo.fr"
SERVER = VIServer()
SERVER.connect(VCENTER, LOGIN, PWD)
VMNAME = "vm1.labo.fr"
VM = SERVER.get_vm_by_name(VMNAME)
print VM.get_status()
print VM.get_property("ip_address")
print VM.get_properties()
# Close connection
SERVER.disconnect()
#!/usr/bin/python
'''
Author: Pryz
Description: Get current status and properties of a VM with pysphere
'''
from pysphere import VIServer
# Connect to the vcenter
LOGIN = "******"
PWD = "password"
VCENTER = "vcenter.labo.fr"
SERVER = VIServer()
SERVER.connect(VCENTER, LOGIN, PWD)
VMNAME = "vm1.labo.fr"
VM = SERVER.get_vm_by_name(VMNAME)
print VM.get_status()
print VM.get_property('ip_address')
print VM.get_properties()
# Close connection
SERVER.disconnect()
class MyApp:
def __init__(self, parent):
self.myScanner = parent
# self.myScanner.geometry('800x600')
self.myScanner.title('ESX/ESXi Server Vulnerability Scanner')
self.myContainer = Frame(parent)
self.myContainer.pack()
# 提示
self.tip = Label(self.myContainer,
text="提示:\n\
请输入IP、先获取服务器版本。如果是ESX Server，请继续输入用户名，\n\
密码然后开始扫描；如果是ESXi Server，无需用户名密码，直接扫描。\n\
扫描完成后，打开index.html查看结果。",
bg='green')
self.tip.grid(row=0, column=0, columnspan=3)
# IP
self.ip_label = Label(self.myContainer, text="IP:")
self.ip_label.grid(row=1, column=0, sticky=E + W)
self.ip = Entry(self.myContainer, text="")
self.ip.grid(row=1, column=1, sticky=E + W)
# 先检查是ESX还是ESXi
self.getVersion_button = Button(
self.myContainer,
text="获取服务器版本",
fg="black",
command=self.serverVersion) #lose command
self.getVersion_button.grid(row=1, column=2, sticky=W + E)
# Server版本
self.version_label = Label(self.myContainer, text="服务器版本:")
self.version_label.grid(row=2, column=0, sticky=E + W)
self.version_text = Text(self.myContainer, width=35, height=1)
self.version_text.grid(row=2, column=1, columnspan=2, sticky=E + W)
# 用户名
self.user_label = Label(self.myContainer, text="用户名:")
self.user_label.grid(row=3, column=0, sticky=E + W)
self.user = Entry(self.myContainer, text="")
self.user.grid(row=3, column=1, sticky=E + W)
# 密码
self.passwd_label = Label(self.myContainer, text="密码:")
self.passwd_label.grid(row=4, column=0, sticky=E + W)
self.passwd = Entry(self.myContainer, text="")
self.passwd.grid(row=4, column=1, sticky=E + W)
self.passwd['show'] = '*'
# 检查是否有漏洞
self.vulnCheck_button = Button(self.myContainer,
text="扫描",
fg="black",
command=self.vulnCheck) #lose command
self.vulnCheck_button.grid(row=3, column=2, rowspan=2, sticky=W + E)
"""# 运行状况
self.status_label = Label(self.myContainer, text="运行状况:")
self.status_label.grid(row = 5, column = 0, sticky = E+W)
# 运行状态
self.status = Text(self.myContainer, width = 48)
self.status.grid(row = 6, column = 0, columnspan = 3)"""
def serverVersion(self):
self.server = VIServer()
try:
self.server.connect_no_auth(self.ip.get())
self.serverFullname = self.server.get_server_fullname()
self.server.disconnect()
self.version_text.insert('end', self.serverFullname)
except:
print "Maybe the remote host is not a ESX/ESXi Server."
def vulnCheck(self):
#重置result.xml
result = open("result/result.xml", "w")
result.write("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n")
result.write("<result>\n")
result.write("</result>\n")
result.close()
if re.search('ESXi', self.serverFullname):
self.version = re.search('\d\.\d\.\d', self.serverFullname)
self.buildnumber = re.search('\d{6}', self.serverFullname)
# 填写Server信息
info = open("result/server_info.xml", "w")
info.write('<?xml version="1.0" encoding="UTF-8" ?>\n')
info.write("<serverInfo>\n")
info.write(" <release>%s</release>\n" % self.serverFullname)
info.write(" <version>ESXi %s</version>\n" %
self.version.group())
info.write(" <build>%s</build>\n" % self.buildnumber.group())
info.write("</serverInfo>")
info.close()
#获取ESXi扫描脚本
vmsas = os.listdir('ESXi_script')
for vmsa in vmsas:
if vmsa != '__init__.py':
cmd = "python ESXi_script/%s" % vmsa.strip()
os.system(cmd)
# self.status.insert(1.0, "%s complete!\n" % vmsa.strip())
# self.status.insert(END, "%s complete!\n" % vmsa.strip())
else:
x = esx_pkgs()
#重置esx_info.xml
info = open("result/server_info.xml", "w")
if x.connect(self.ip.get(), self.user.get(),
self.passwd.get()) != False:
# 连接目标服务器成功
# self.status.insert(1.0, "Connect remote ESX Server success!!\n")
# self.status.insert('end', "Connect remote ESX Server success!!\n")
# self.status.get(INSERT)
info.write('<?xml version="1.0" encoding="UTF-8" ?>\n')
info.write("<serverInfo>\n")
info.write(" <arch>%s</arch>\n" % x.get_host_cpu())
info.write(" <release>%s</release>\n" % self.serverFullname)
info.write(" <version>%s</version>\n" % x.get_version())
info.write(" <patches>%s</patches>\n" % x.get_esxupdate())
info.write(" <NewestBundle>%s</NewestBundle>\n" %
x.get_newestbundle())
info.write("</serverInfo>")
else: # 连接目标服务器失败
# self.status.insert(1.0, "Can't connect remote ESX server!!\nMaybe the username or password is not correct.\n")
# self.status.insert('end', "Can't connect remote ESX server!!\nMaybe the username or password is not correct.\n")
return False
info.close()
x.disconnect()
#获取ESX扫描脚本
vmsas = os.listdir('ESX_script')
for vmsa in vmsas:
if vmsa != '__init__.py':
cmd = "python ESX_script/%s" % vmsa.strip()
os.system(cmd)
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()
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
"""
def __init__(self, hostname, username, password, **kwargs):
self.api = VIServer()
self.api.connect(hostname, username, password)
def _get_vm(self, vm_name=None):
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def _get_resource_pool(self, resource_pool_name=None):
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def _find_ip(self, vm):
maxwait = 600
net_info = None
waitcount = 0
while net_info is None:
if waitcount > maxwait:
break
net_info = vm.get_property('net', False)
waitcount += 5
time.sleep(5)
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError('This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self, **kwargs):
vm_list = self.api.get_registered_vms(**kwargs)
# The vms come back in an unhelpful format, so run them through a regex
# Example vm name: '[datastore] vmname/vmname.vmx'
def vm_name_generator():
for vm in vm_list:
match = re.match(r'\[.*\] (.*)/\1\..*', vm)
if match:
yield match.group(1)
# Unroll the VM name generator, and sort it to be more user-friendly
return sorted(list(vm_name_generator()))
def info(self):
return '%s %s' % (self.api.get_server_type(), self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' % vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self, source_name, vm_name, resourcepool=None):
vm = self._get_vm(source_name)
if vm:
clone = vm.clone(vm_name, sync_run=True,
resourcepool=self._get_resource_pool(resourcepool))
return self._find_ip(clone)
else:
raise Exception('Could not clone %s' % source_name)
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 MyApp:
def __init__(self, parent):
self.myScanner = parent
# self.myScanner.geometry('800x600')
self.myScanner.title('ESX/ESXi Server Vulnerability Scanner')
self.myContainer = Frame(parent)
self.myContainer.pack()
# 提示
self.tip = Label(self.myContainer, text = "提示:\n\
请输入IP、先获取服务器版本。如果是ESX Server，请继续输入用户名，\n\
密码然后开始扫描；如果是ESXi Server，无需用户名密码，直接扫描。\n\
扫描完成后，打开index.html查看结果。", bg = 'green')
self.tip.grid(row = 0, column = 0, columnspan = 3)
# IP
self.ip_label = Label(self.myContainer, text="IP:")
self.ip_label.grid(row = 1, column = 0, sticky = E+W)
self.ip = Entry(self.myContainer, text="")
self.ip.grid(row = 1, column = 1, sticky = E+W)
# 先检查是ESX还是ESXi
self.getVersion_button = Button(self.myContainer, text="获取服务器版本", fg="black", command = self.serverVersion) #lose command
self.getVersion_button.grid(row = 1, column = 2, sticky = W+E)
# Server版本
self.version_label = Label(self.myContainer, text="服务器版本:")
self.version_label.grid(row = 2, column = 0, sticky = E+W)
self.version_text = Text(self.myContainer, width = 35, height = 1)
self.version_text.grid(row = 2, column = 1, columnspan = 2, sticky = E+W)
# 用户名
self.user_label = Label(self.myContainer, text="用户名:")
self.user_label.grid(row = 3, column = 0, sticky = E+W)
self.user = Entry(self.myContainer, text="")
self.user.grid(row = 3, column = 1, sticky = E+W)
# 密码
self.passwd_label = Label(self.myContainer, text="密码:")
self.passwd_label.grid(row = 4, column = 0, sticky = E+W)
self.passwd = Entry(self.myContainer, text="")
self.passwd.grid(row = 4, column = 1, sticky = E+W)
self.passwd['show'] = '*'
# 检查是否有漏洞
self.vulnCheck_button = Button(self.myContainer, text="扫描", fg="black", command = self.vulnCheck) #lose command
self.vulnCheck_button.grid(row = 3, column = 2, rowspan = 2, sticky = W+E)
"""# 运行状况
self.status_label = Label(self.myContainer, text="运行状况:")
self.status_label.grid(row = 5, column = 0, sticky = E+W)
# 运行状态
self.status = Text(self.myContainer, width = 48)
self.status.grid(row = 6, column = 0, columnspan = 3)"""
def serverVersion(self):
self.server = VIServer()
try:
self.server.connect_no_auth(self.ip.get())
self.serverFullname = self.server.get_server_fullname()
self.server.disconnect()
self.version_text.insert('end', self.serverFullname)
except:
print "Maybe the remote host is not a ESX/ESXi Server."
def vulnCheck(self):
#重置result.xml
result = open("result/result.xml", "w")
result.write("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n")
result.write("<result>\n")
result.write("</result>\n")
result.close()
if re.search('ESXi', self.serverFullname):
self.version = re.search('\d\.\d\.\d', self.serverFullname)
self.buildnumber = re.search('\d{6}', self.serverFullname)
# 填写Server信息
info = open("result/server_info.xml", "w")
info.write('<?xml version="1.0" encoding="UTF-8" ?>\n')
info.write("<serverInfo>\n")
info.write(" <release>%s</release>\n" %self.serverFullname)
info.write(" <version>ESXi %s</version>\n" %self.version.group())
info.write(" <build>%s</build>\n" %self.buildnumber.group())
info.write("</serverInfo>")
info.close()
#获取ESXi扫描脚本
vmsas = os.listdir('ESXi_script')
for vmsa in vmsas:
if vmsa != '__init__.py':
cmd = "python ESXi_script/%s" % vmsa.strip()
os.system(cmd)
# self.status.insert(1.0, "%s complete!\n" % vmsa.strip())
# self.status.insert(END, "%s complete!\n" % vmsa.strip())
else:
x = esx_pkgs()
#重置esx_info.xml
info = open("result/server_info.xml", "w")
if x.connect(self.ip.get(), self.user.get(), self.passwd.get()) != False:
# 连接目标服务器成功
# self.status.insert(1.0, "Connect remote ESX Server success!!\n")
# self.status.insert('end', "Connect remote ESX Server success!!\n")
# self.status.get(INSERT)
info.write('<?xml version="1.0" encoding="UTF-8" ?>\n')
info.write("<serverInfo>\n")
info.write(" <arch>%s</arch>\n" %x.get_host_cpu())
info.write(" <release>%s</release>\n" %self.serverFullname)
info.write(" <version>%s</version>\n" %x.get_version())
info.write(" <patches>%s</patches>\n" %x.get_esxupdate())
info.write(" <NewestBundle>%s</NewestBundle>\n" %x.get_newestbundle())
info.write("</serverInfo>")
else: # 连接目标服务器失败
# self.status.insert(1.0, "Can't connect remote ESX server!!\nMaybe the username or password is not correct.\n")
# self.status.insert('end', "Can't connect remote ESX server!!\nMaybe the username or password is not correct.\n")
return False
info.close()
x.disconnect()
#获取ESX扫描脚本
vmsas = os.listdir('ESX_script')
for vmsa in vmsas:
if vmsa != '__init__.py':
cmd = "python ESX_script/%s" % vmsa.strip()
os.system(cmd)
class VCenterManagement:
server_ip = ''
user_name = ''
password = ''
connect_flag = False
server = None
#vm_list = []
#def __init__(self):
#Use the given args to connect the esxi server you want
#@ip[string]: ESXi server's IP address
#@name[string]: the username used to login the ESXi server
#@pwd[string]: the password used to login the ESXi server
def connect_server(self, ip, name, pwd):
self.server_ip = ip
self.user_name = name
self.password = pwd
self.server = VIServer()
self.server.connect(self.server_ip, self.user_name, self.password)
self.connect_flag = self.server.is_connected()
if self.connect_flag:
return True
return False
#To get all the definition registered vms from the connected server
#@param[string]: can be set as ALL, POWER_ON, POWER_OFF, SUSPENDED
#According to the param, returns a list of VM Paths. You might also filter by datacenter,
#cluster, or resource pool by providing their name or MORs.
#if cluster is set, datacenter is ignored, and if resource pool is set
#both, datacenter and cluster are ignored.
def get_registered_vms(self,
param,
status=None,
datacenter=None,
cluster=None,
resource_pool=None):
if param not in ['ALL', 'POWER_ON', 'POWER_OFF', 'SUSPENDED']:
print "Get VMs error: param can only be set as ALL, POWER_ON, POWER_OFF, or SUSPENDED."
return None
if self.connect_flag == False:
print "Get VMs error: Server not connected."
return None
if param == 'ALL':
return self.server.get_registered_vms(datacenter, cluster,
resource_pool)
elif param == 'POWER_ON':
return self.server.get_registered_vms(datacenter,
cluster,
resource_pool,
status='poweredOn')
elif param == 'POWER_OFF':
return self.server.get_registered_vms(datacenter,
cluster,
resource_pool,
status='poweredOff')
elif param == 'SUSPENDED':
return self.server.get_registered_vms(datacenter,
cluster,
resource_pool,
status='suspended')
else:
return None
#Disconnect to the Server
def disconnect(self):
if self.connect_flag == True:
self.server = self.server.disconnect()
self.connect_flag == False
#To keep session alive
def keep_session_alive(self):
assert self.server.keep_session_alive()
#To get the server type
def get_server_type(self):
return self.server.get_server_type()
#To get performance manager
def get_performance_manager(self):
return self.server.get_performance_manager()
#To get the all the server's hosts
def get_all_hosts(self):
"""
Returns a dictionary of the existing hosts keys are their names
and values their ManagedObjectReference object.
"""
return self.server.get_hosts()
#To get all datastores
def get_all_datastores(self):
"""
Returns a dictionary of the existing datastores. Keys are
ManagedObjectReference and values datastore names.
"""
return self.server.get_datastores()
#To get all clusters
def get_all_clusters(self):
"""
Returns a dictionary of the existing clusters. Keys are their
ManagedObjectReference objects and values their names.
"""
return self.server.get_clusters()
#To get all datacenters
def get_all_datacenters(self):
"""
Returns a dictionary of the existing datacenters. keys are their
ManagedObjectReference objects and values their names.
"""
return self.server.get_datacenters()
#To get all resource pools
def get_all_resource_pools(self):
"""
Returns a dictionary of the existing ResourcePools. keys are their
ManagedObjectReference objects and values their full path names.
"""
return self.server.get_resource_pools()
#To get hosts by name
def get_hosts_by_name(self, from_mor):
"""
Returns a dictionary of the existing ResourcePools. keys are their
ManagedObjectReference objects and values their full path names.
@from_mor: if given, retrieves the hosts contained within the specified
managed entity.
"""
try:
hosts_dic = self.server.get_hosts(from_mor)
except:
print "Get hosts error!"
return None
return hosts_dic
def get_vm_by_name(self, vm_name):
try:
vm = self.server.get_vm_by_name(vm_name)
except:
print "Get vm error!"
return None
return vm
def power_on_vm(self, vm_name):
try:
vm = self.get_vm_by_name(vm_name)
if (vm.is_powered_off()):
vm.power_on()
print "vm " + vm_name + " power on success."
else:
print "vm " + vm_name + "is already power on"
return False
except:
print "Power on vm " + vm_name + "error"
return False
return True
def power_off_vm(self, vm_name):
try:
vm = self.get_vm_by_name(vm_name)
if (vm.is_powered_on()):
vm.power_off()
print "vm " + vm_name + " power off success."
else:
print "vm " + vm_name + "is already power off"
return False
except:
print "Power off vm " + vm_name + " error"
return False
return True
class EsxiController(object):
def __init__(self, servername=None, password=None, username='******'):
# Initialize viserver
self.vi_server = VIServer()
# Specify excluding VMs' preffix
self.p = re.compile('xx|yy', re.I)
self.class_name = self.__class__.__name__
self.servername = servername
self.username = username
self.password = password
self.vmlist = []
self.vmstatusdict = {}
self.inUse_vmstatusdict = {}
self.vmfullnamelist = {}
self.inUse_vmfullnamelist = {}
self.vmdict = {}
self.inUseDict = {}
def connect(self):
logging.debug('connecting to %s' % self.servername)
try:
self.vi_server.connect(self.servername,
self.username,
self.password,
trace_file='/tmp/esxi_debug.txt')
except BaseException as e:
logging.debug('Can not connect to %s: %s' % (self.servername, e))
# sys.exit(1)
else:
if self.vi_server.is_connected():
logging.debug('connected to %s successfully' % self.servername)
logging.debug('Currently server version is: %s %s' %
(self.vi_server.get_server_type(),
self.vi_server.get_api_version()))
def disconnect(self):
self.vi_server.disconnect()
logging.debug('To disconnect from server %s\n' % self.servername)
def get_vmlist(self):
self.vmlist = self.vi_server.get_registered_vms()
return self.vmlist
def get_vmstatus(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmstatus = vm.get_status()
vmname = vminfo['name']
self.vmstatusdict[vmname] = vmstatus
return self.vmstatusdict
def get_inuse_vmstatus(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmstatus = vm.get_status()
vmname = vminfo['name']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.inUse_vmstatusdict[vmname] = vmstatus
return self.inUse_vmstatusdict
def get_vmnamelist(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmfullnameinfo = vminfo['guest_full_name']
self.vmfullnamelist[vmname] = vmfullnameinfo
return self.vmfullnamelist
def get_inuse_vmnamelist(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmfullnameinfo = vminfo['guest_full_name']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.inUse_vmfullnamelist[vmname] = vmfullnameinfo
return self.inUse_vmfullnamelist
def get_inuse_vmdict(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.vmdict[vmname] = vmpath
return self.vmdict
def power_off_all(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
if not vm.is_powered_off():
logging.debug('%s is powered on, now doing power off' % vmPath)
vm.power_off()
def power_on_all(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
if not vm.is_powered_on():
logging.debug('%s is powered off, now doing power on' % vmPath)
vm.power_on()
def power_on_in_use(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None and not vm.is_powered_on():
logging.debug('%s is powered off, now doing power on' % vmname)
vm.power_on()
def power_off_in_use(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None and not vm.is_powered_off():
logging.debug('%s is powered on, now doing power off' % vmname)
vm.power_off()
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)
class Report:
"""Class report. Generate a dictionnary with the VMs and these properties"""
def __init__(self, config):
self.login = config['user']
self.password = config['password']
self.vcenter = config['vcenter']
self.server = VIServer()
def connect(self):
"""Connect to the hypervisor"""
self.server.connect(self.vcenter, self.login, self.password)
def disconnect(self):
"""Close the connection with the hypervisor"""
if self.server:
self.server.disconnect()
def generate_report(self):
"""Generate the report of the actual connection"""
report = []
# Create the report
vms_list = self.server.get_registered_vms()
for vm_path in vms_list:
virtual_machine = self.server.get_vm_by_path(vm_path)
if str(virtual_machine.__class__) != "pysphere.vi_virtual_machine.VIVirtualMachine":
continue
if re.match(r'rhel', virtual_machine.get_property('guest_id')):
vm_infos = {
'name': virtual_machine.get_property('name'),
'ip': virtual_machine.get_property('ip_address'),
'os': virtual_machine.get_property('guest_id')
}
try:
status = virtual_machine.get_status()
except Exception, e:
print "Couldn't do it: %s" % e
vm_infos['powered'] = 'none'
report.append(vm_infos)
continue
if status == "POWERED ON":
vm_infos['powered'] = 'on'
# Get version in ssh
ssh = subprocess.Popen([
"ssh",
"-i ~/.ssh/id_rsa",
"%s" % vm_infos['name'],
"cat /etc/redhat-release"],
shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
release = ssh.stdout.readlines()
if release == []:
error = ssh.stderr.readlines()
vm_infos['release'] = "error: " + error
else:
regex = re.compile("release (\d.*).+\(\D*(\d*)\)")
r = regex.search(release[0])
release = r.groups()
if release[1].strip():
vm_infos['release'] = release[0] + "." + release[1]
else:
vm_infos['release'] = release[0]
else:
vm_infos['powered'] = 'off'
report.append(vm_infos)
return report
def main():
vcenter = ""
esx_username = ""
esx_password = ""
ldap_password = ""
# Read config file in...
vcf = ".vcenters"
try:
file = open(vcf, "r")
read = file.read()
except IOError:
print "ERROR --> Config file '%s' does not exist! Please create it as described below." % vcf
print "--> echo 'vc1 = \"<VCENTER1>\"' > %s" % vcf
print "--> echo 'vc2 = \"<VCENTER2>\"' >> %s" % vcf
print ""
vserver.disconnect()
exit(1)
i = 1
vc = {}
for line in read.splitlines():
if "vc%s = " % i in line:
vc["vc" + str(i)] = line.split('=', 1)[1]
i += 1
if "domain = " in line:
domain = line.split('=', 1)[1].lstrip().translate(None, '"')
vc1 = vc.get("vc1").lstrip().translate(None, '"')
vc2 = vc.get("vc2").lstrip().translate(None, '"')
if domain == None:
print "ERROR --> Domain is blank, add to settings in config..."
print "--> echo 'domain = \"<DOMAIN>\"' >> %s" % vcf
vserver.disconnect()
exit(1)
options, args = usage_and_opts(vc1, vc2)
def connect_vsphere():
default_context = ssl._create_default_https_context
ssl._create_default_https_context = ssl._create_unverified_context
vserver.connect(vcenter, esx_username, esx_password)
if options.username:
esx_username = options.username
print "--> CruzID: " + esx_username
else:
print ""
print " Identity "
print "======================================"
if esx_username == "":
if py3:
esx_username = input("--> Please input your CruzID: ")
else:
esx_username = raw_input("--> Please input your CruzID: ")
else:
print "--> CruzID: " + esx_username
if esx_password == "":
esx_password = getpass.getpass("--> Please input your AD password: "******"--> vCenter: " + vcenter
else:
print ""
print " vCenter "
print "================================"
print "(1) %s" % vc1
print "(2) %s" % vc2
if vcenter == "":
if py3:
esx_c = input("--> Which vCenter: ")
else:
esx_c = raw_input("--> Which vCenter: ")
if esx_c == "1" or esx_c == vc1:
vcenter = vc1
elif esx_c == "2" or esx_c == vc2:
vcenter = vc2
else:
print "ERROR --> Please select a vCenter from list..."
exit(1)
else:
print "--> vCenter: " + vcenter
vserver = VIServer()
connect_vsphere()
hostname = select_host(vserver, options)
vm = vserver.get_vm_by_name(hostname)
ifc, curvlan = get_current_vlan(vserver, vm, hostname)
curhost = vm.properties.runtime.host.name
print ""
print " Settings of VM '%s' " % hostname
print "======================================="
print "Current VLAN: %s" % curvlan
print "Current HOST: %s" % curhost
print ""
destvlan = print_available_vlans(vserver, curhost, hostname, options)
print ""
print "NOTE --> Host will continue to use DHCP on new network if no static IP defined..."
if py3:
ans = input("--> Do you wish to set a static IP for VM '%s'? (Y/N): " %
hostname)
else:
ans = raw_input(
"--> Do you wish to set a static IP for VM '%s'? (Y/N): " %
hostname)
print ""
if ans == "Y" or ans == "y":
set_host_static_ip(vserver, ifc, hostname, esx_username, options)
else:
restart_host_network(hostname, esx_username, ldap_password)
change_dvs_net(vserver, vm, hostname, destvlan, curvlan)
if platform.system() != "Darwin":
call([
"/local/adm/infoblox-scripts/remove_dcnet_dns_from_hostmaster.sh",
hostname
])
vserver.disconnect()
def vmaction(self, vm_name, vm_hz):
m = Info_log(time.strftime('%Y-%m-%d', time.localtime(time.time())))
log = m.log()
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
server_obj.disconnect()
log.info(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
server_obj.disconnect()
return 0
if vm.is_powered_off() == False:
try:
vm.reset()
# logger.info (type(int(vm_hz)))
for i in range(1, int(vm_hz)):
log.info('虚拟机%s 正在重置中。。。。，请等待注册\n' % (vm_name))
time.sleep(1)
log.info('重置完成')
server_obj.disconnect()
return 1
except Exception as e:
server_obj.disconnect()
log.info(e)
if vm.is_powered_off() == True:
try:
vm.power_on()
log.info('虚拟机%s 正在开机中。。。。' % (vm_name))
server_obj.disconnect()
except Exception as e:
server_obj.disconnect()
return 2
print("done")
except:
print("connect to {} failed".format(args.host))
exit(1)
if args.file:
vmxq = read_csv(args.file)
while 1:
if vmxq.qsize() > 0:
d = vmxq.get()
run_script()
else:
break
elif args.show == 'datacenters':
for k, v in vc.get_datacenters().items():
print(k, v)
elif args.show == 'datastores':
for k, v in vc.get_datastores().items():
print(k, v)
elif args.show == 'vmxlist':
for item in vc.get_registered_vms():
print(item)
else:
run_script()
vc.disconnect()
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()
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
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
print_verbose('Connected to server %s' % server)
print_verbose('Server type: %s' % con.get_server_type())
print_verbose('API version: %s' % con.get_api_version())
if allvms:
vms = con.get_registered_vms(None, None, None, 'poweredOn', None)
for vmpath in vms:
print_verbose('================================================================================')
vm = con.get_vm_by_path(vmpath)
vmname = vm.get_property('name')
ip = find_ip(vm,ipv6)
if ip:
print '%s : %s' % (vmname,ip)
else:
print 'ERROR: IP for VM %s not found' % vmname
else:
print_verbose('================================================================================')
print_verbose('Trying to find IP for VM %s' % vmname)
vm = find_vm(vmname)
if vm:
ip = find_ip(vm,ipv6)
if ip:
print '%s : %s' % (vmname,ip)
else:
print 'ERROR: IP for VM %s not found' % vmname
else:
print 'ERROR: %s not found' % vmname
# Disconnecting from server
con.disconnect()
try:
sock.connect( (CARBON_SERVER,CARBON_PORT) )
except:
print "Couldn't connect to %(server)s on port %(port)d, is carbon-agent.py running?" % { 'server':CARBON_SERVER, 'port':CARBON_PORT }
sys.exit(1)
try:
server.connect(HOST, USER, PASSWORD)
except:
print "Unable to connect to vsphere server"
sys.exit(1)
pm = server.get_performance_manager()
while True:
lines = []
for dc_mor, dc_name in server.get_datacenters().items():
now = int(time.time())
datastores = server.get_datastores(dc_mor)
for ds_mor, ds_name in datastores.items():
gphDSName = ds_name.replace('.', '_')
gphDSName = gphDSName.replace(' ', '_')
props = VIProperty(server, ds_mor)
lines.append(prefix + dc_name + ".datastores." + props.summary.type + "." + gphDSName + ".capacity " + str(props.summary.capacity) + " " + str(now))
lines.append(prefix + dc_name + ".datastores." + props.summary.type + "." + gphDSName + ".freespace " + str(props.summary.freeSpace) + " " +str(now))
if hasattr(props.summary, "uncommitted"):
lines.append(prefix + dc_name + ".datastores." + props.summary.type + "." + gphDSName + ".uncommitted " + str(props.summary.uncommitted) + " " + str(now))
message = '\n'.join(lines) + '\n'
sock.sendall(message)
print message
time.sleep(delay)
server.disconnect()
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
if vmname_ip[7] == "linux":
vm.send_file("/var/www/html/scripts/misc/setnetwork.sh",
r"/root/setnetwork.sh",
overwrite=True)
vm.start_process("/bin/chmod", args=["+x", "/root/setnetwork.sh"])
vm.start_process(
"/root/setnetwork.sh",
args=[vmname_ip[1], vmname_ip[2], vmname_ip[3], vmname_ip[4]],
cwd="/root")
ipdict[vmname_ip[0]] = "SUCCESS"
elif vmname_ip[7] == "windows":
vm.send_file("/var/www/html/scripts/misc/winautoip.bat",
r"C:\Users\Administrator\Desktop\winautoip.bat",
overwrite=True)
vm.start_process(
"C:\Users\Administrator\Desktop\winautoip.bat",
args=[vmname_ip[1], vmname_ip[2], vmname_ip[3], vmname_ip[4]])
ipdict[vmname_ip[0]] = "SUCCESS"
except VIException as inst:
#print inst
ipdict["error"] = str(inst)
print json.dumps(ipdict)
if args.setip:
setip(args.setip)
server.disconnect()
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())
