def get_servers(self, provider):
""" Gets various information about the servers so it can be returned to provider_data. The format of the data for each server follows the same format as in the base driver description """
service_server = connect.SmartConnect(host=provider['provider_ip'],
user=provider['username'],
port=int(provider['port']),
pwd=provider['password'],
protocol=provider['protocol'])
servers = []
datacenter = self.get_datacenter(provider)
content = service_server.RetrieveContent()
vmFolder = datacenter.vmFolder
vmList = vmFolder.childEntity
# for vm in vmList:
# print ('Instance is : ', {
# 'hostname' : vm.name,
# 'ip' : vm.guest.ipAddress ,
# 'size' : 'va-small',
# 'used_disk' : vm.summary.storage.committed,
# 'used_ram' : vm.summary.quickStats.hostMemoryUsage,
# 'used_cpu' : vm.summary.quickStats.overallCpuUsage,
# 'status' : vm.overallStatus,
# 'provider' : provider['provider_name'],
# })
for vm in vmList:
server = {
'hostname': vm.name,
'ip': vm.guest.ipAddress,
'size': 'va-small',
'status': vm.overallStatus,
'provider': provider['provider_name'],
'used_disk': vm.summary.storage.committed,
'used_ram': vm.summary.quickStats.hostMemoryUsage,
'used_cpu': vm.summary.quickStats.overallCpuUsage,
}
for key in [('used_disk', 2**30), ('used_ram', 2**20),
('used_cpu', 1)]:
if not server[key[0]]: server[key[0]] = 0
else:
server[key[0]] = round((0.0 + server[key[0]]) / key[1], 2)
# server[key[0]] = 0 if not server[key[0]] else float(server[key[0]]) / key[1]
servers.append(server)
raise tornado.gen.Return(servers)
def test_vm_nic_data(self):
data = {
'ESXi-5.5-16': [],
'ESXi-5.5-17': [],
'ESXi-5.5-18': [],
'ESXi11': ['00:0c:29:e1:e0:f8'],
'ESXi12': ['00:50:56:b4:3c:3c'],
'ESXi20': ['00:50:56:b4:fc:9b', '00:50:56:b4:28:e7'],
'ESXi21': ['00:50:56:b4:8d:7a', '00:50:56:b4:39:b8'],
'ESXi22': ['00:0c:29:36:b5:5a', '00:0c:29:36:b5:64'],
'ESXi23': ['00:50:56:b4:91:f9', '00:50:56:b4:90:9f'],
'ESXi38-v5.0': ['00:0c:29:ce:6a:d8', '00:0c:29:ce:6a:e2'],
'MARVEL-Agents_of_Atlas': [],
'MARVEL-Alex_Power': [],
'MARVEL-Archangel': [],
'MARVEL-Freak': [],
'MARVEL-Hepzibah': [],
'MARVEL-Mach_IV': [],
'MARVEL-Serpent_Society': [],
'MARVEL-Spectrum': [],
'MARVEL-The_Hand': [],
'MARVEL-Vanisher_(Ultimate)': [],
'VCVA-5.5u1-11': ['00:0c:29:9d:a3:8c'],
'VCVA-5.5u1-14': ['00:0c:29:75:21:2e'],
'VCVA33': ['00:0c:29:e3:f9:f7'],
'VCVA36': ['00:0c:29:44:8b:76'],
'VCVA37-v5.0': ['00:50:56:b4:89:db'],
'box': ['00:50:56:82:28:7d'],
'box_copy': ['00:50:56:82:34:02'],
'esx4.1.0': ['00:0c:29:1f:ec:ba', '00:0c:29:1f:ec:c4']
}
# see: http://python3porting.com/noconv.html
si = connect.SmartConnect(host='vcsa',
user='******',
pwd='my_password')
content = si.RetrieveContent()
virtual_machines = content.viewManager.CreateContainerView(
content.rootFolder, [vim.VirtualMachine], True)
for virtual_machine in virtual_machines.view:
name = virtual_machine.name
self.assertTrue(name in data.keys())
macs = data[name]
if virtual_machine.guest:
for net in virtual_machine.guest.net:
self.assertTrue(net.macAddress in macs)
def main():
"""
Simple command-line program for listing the vms in a foler.
"""
args = get_args()
try:
service_instance = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(connect.Disconnect, service_instance)
print " "
session_name = service_instance.content.sessionManager.currentSession.fullName
print "Hello {}".format(session_name)
print "You have successfully logged into {}".format(args.host)
# NOTE (hartsock): only a successfully authenticated session has a
# session key aka session id.
print " "
print " "
# Print list of VMs in the specified folder
VM = args.vm
# This dumps all of the vCenter data into an object
content = service_instance.RetrieveContent()
# get_obj is defined above. It searchs through the content for the specified folder
# It returns a folder object
vm = get_obj(content, [vim.VirtualMachine], VM)
# If the folder was found list it's contents
if vm is not None:
# We will add all of the childObjects of the folder to a variable
#s = folder.childEntity
# Iterate through the VMs in the folder printing the names
#for vm in vms:
print(vm.summary)
else:
print VM, "not found"
except vmodl.MethodFault as error:
#print "Caught vmodl fault : " + error.msg
print error.msg
return -1
return 0
def connect_to_api(module, disconnect_atexit=True):
hostname = module.params['hostname']
username = module.params['username']
password = module.params['password']
validate_certs = module.params['validate_certs']
if validate_certs and not hasattr(ssl, 'SSLContext'):
module.fail_json(
msg=
'pyVim does not support changing verification mode with python < 2.7.9. Either update '
'python or or use validate_certs=false')
ssl_context = None
if not validate_certs:
ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ssl_context.verify_mode = ssl.CERT_NONE
service_instance = None
try:
service_instance = connect.SmartConnect(host=hostname,
user=username,
pwd=password,
sslContext=ssl_context)
except vim.fault.InvalidLogin as e:
module.fail_json(
msg="Unable to log on to vCenter or ESXi API at %s as %s: %s" %
(hostname, username, e.msg))
except (requests.ConnectionError, ssl.SSLError) as e:
module.fail_json(
msg="Unable to connect to vCenter or ESXi API at %s on TCP/443: %s"
% (hostname, e))
except Exception as e:
module.fail_json(
msg="Unknown error connecting to vCenter or ESXi API at %s: %s" %
(hostname, e))
if service_instance is None:
module.fail_json(
msg="Unknown error connecting to vCenter or ESXi API at %s" %
hostname)
# Disabling atexit should be used in special cases only.
# Such as IP change of the ESXi host which removes the connection anyway.
# Also removal significantly speeds up the return of the module
if disconnect_atexit:
atexit.register(connect.Disconnect, service_instance)
return service_instance.RetrieveContent()
def _connect(self):
try:
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_NONE
self.service_instance = connect.SmartConnect(host=self.vCenterIp,
user=self.userName,
pwd=self.password,
port=443,
sslContext=context)
atexit.register(connect.Disconnect, self.service_instance)
#atexit.register(endit)
except IOError as e:
pass
if not self.service_instance:
raise SystemExit("Unable to connect to host with supplied info.")
def main():
"""
Simple command-line program for executing a process in the VM without the
network requirement to actually access it.
"""
args = get_args()
try:
service_instance = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(connect.Disconnect, service_instance)
content = service_instance.RetrieveContent()
vm = content.searchIndex.FindByUuid(None, args.vm_uuid, True)
tools_status = vm.guest.toolsStatus
if (tools_status == 'toolsNotInstalled'
or tools_status == 'toolsNotRunning'):
raise SystemExit(
"VMwareTools is either not running or not installed. "
"Rerun the script after verifying that VMwareTools "
"is running")
creds = vim.vm.guest.NamePasswordAuthentication(username=args.vm_user,
password=args.vm_pwd)
try:
pm = content.guestOperationsManager.processManager
ps = vim.vm.guest.ProcessManager.ProgramSpec(
programPath=args.path_to_program,
arguments=args.program_arguments)
res = pm.StartProgramInGuest(vm, creds, ps)
if res > 0:
print "Program executed, PID is %d" % res
except IOError, e:
print e
except vmodl.MethodFault as error:
print "Caught vmodl fault : " + error.msg
return -1
return 0
def get_vms(config):
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
context.verify_mode = ssl.CERT_NONE
service_instance = connect.SmartConnect(host=config["host"],
user=config["user"],
pwd=config["pass"],
port=config["port"],
sslContext=context)
content = service_instance.RetrieveContent()
container = content.rootFolder # starting point to look into
view_type = [vim.VirtualMachine] # object types to look for
recursive = True # whether we should look into it recursively
container_view = content.viewManager.CreateContainerView(
container, view_type, recursive)
return container_view.view
def _vc_login(self):
try:
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_NONE
service_instance = connect.SmartConnect(
host=self.vc_dns,
user=self.vc_password_id.user,
pwd=self.vc_password_id.decrypt()[0],
port=self.vc_port,
sslContext=context)
# atexit.register(connect.Disconnect, service_instance)
# pdb.set_trace()
# raise Warning ("Login OK")
return service_instance
except vmodl.MethodFault as error:
raise Warning("Caught vmodl fault :", error.msg)
def resMatch(conf,rangeVM,name,UCSaction):
si = connect.SmartConnect(host=name,user=conf.uUser,pwd=conf.uPasswd,sslContext=sslContext)
content=si.content
container = content.viewManager.CreateContainerView(content.rootFolder, [vim.VirtualMachine], True)
listVM = []
listUCS = []
for x in container.view:
listUCS.append(x.name)
for y in rangeVM:
listVM.append(conf.vmprefix+"_test"+str(y))
for item in listVM:
if item in listUCS:
UCSaction[name].append(item)
atexit.register(connect.Disconnect, si)
return UCSaction
def do_setup(self, context):
"""Any initialization the source driver does while starting."""
super(VSphereSourceDriver, self).do_setup(context)
host = self.configuration.vsphere_host
username = self.configuration.vsphere_username
password = self.configuration.vsphere_password
port = self.configuration.vsphere_port
try:
self.con = connect.SmartConnect(host=host,
user=username,
pwd=password,
port=port)
atexit.register(connect.Disconnect, self.con)
self.content = self.con.RetrieveContent()
except Exception:
raise
self._initialized = True
def list_datastore_space():
"""
List all datastores and their free space
"""
sslContext = None
if VMWARE_DISABLE_SSL:
sslContext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
sslContext.verify_mode = ssl.CERT_NONE
try:
service_instance = connect.SmartConnect(host=VMWARE_HOST,
user=VMWARE_USER,
pwd=VMWARE_PASS,
sslContext=sslContext)
if not service_instance:
print("Could not connect to the specified host using specified "
"username and password")
return -1
atexit.register(connect.Disconnect, service_instance)
content = service_instance.RetrieveContent()
# Search for all Datastores
objview = content.viewManager.CreateContainerView(
content.rootFolder, [vim.Datastore], True)
datastores = objview.view
objview.Destroy()
datastore_space = {}
for datastore in datastores:
capacity = datastore.summary.capacity
freeSpace = datastore.summary.freeSpace
datastore_details = {
'capacity': print_size(capacity),
'free': print_size(freeSpace),
'used': print_size(capacity - freeSpace),
'pfree': "%2.2f" % (freeSpace * 100.0 / capacity)
}
datastore_space[datastore.summary.name] = datastore_details
return datastore_space
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
def get_si(self):
"""
Get Service Instance from VCenter
:return:
"""
try:
default_context = ssl._create_default_https_context
ssl._create_default_https_context = ssl._create_unverified_context
self.si = connect.SmartConnect(host=self.envs['vsphere_url'],
user=self.envs['vsphere_user'],
pwd=self.envs['vsphere_pass'],
port=self.envs['vsphere_port'])
ssl._create_default_https_context = default_context
except vmodl.MethodFault as error:
print "Caught vmodl fault : " + error.msg
raise
def main():
parser = argparse.ArgumentParser(description='vCenter login')
parser.add_argument('-s',
'--host',
required=True,
action='store',
help='vSphere IP')
parser.add_argument('-o',
'--port',
type=int,
default=443,
action='store',
help='vSphere Port')
parser.add_argument('-u',
'--user',
required=True,
action='store',
help='User name')
parser.add_argument('-p',
'--password',
required=True,
action='store',
help='Password')
parser.add_argument('-n',
'--name',
required=True,
action='store',
help='Resourcepool name')
args = parser.parse_args()
try:
service_instance = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(connect.Disconnect, service_instance)
libvmtask.resourcepool_destroy(service_instance,
libvmtask.validate_input(args.name))
return 0
except vmodl.MethodFault as error:
print("ERROR: " + error.msg)
sys.exit(1)
def _smart_connect(self, instance, service_check_tags):
# Check for ssl configs and generate an appropriate ssl context object
ssl_verify = instance.get('ssl_verify', True)
ssl_capath = instance.get('ssl_capath', None)
if not ssl_verify:
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_NONE
elif ssl_capath:
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_REQUIRED
context.load_verify_locations(capath=ssl_capath)
# If both configs are used, log a message explaining the default
if not ssl_verify and ssl_capath:
self.log.debug("Your configuration is incorrectly attempting to "
"specify both a CA path, and to disable SSL "
"verification. You cannot do both. Proceeding with "
"disabling ssl verification.")
try:
# Object returned by SmartConnect is a ServerInstance
# https://www.vmware.com/support/developer/vc-sdk/visdk2xpubs/ReferenceGuide/vim.ServiceInstance.html
server_instance = connect.SmartConnect(
host=instance.get('host'),
user=instance.get('username'),
pwd=instance.get('password'),
sslContext=context if not ssl_verify or ssl_capath else None
)
except Exception as e:
err_msg = "Connection to {} failed: {}".format(instance.get('host'), e)
self.service_check(self.SERVICE_CHECK_NAME, AgentCheck.CRITICAL,
tags=service_check_tags, message=err_msg)
raise ConnectionError(err_msg)
# Check that we have sufficient permission for the calls we need to make
try:
server_instance.CurrentTime()
except Exception as e:
err_msg = (
"A connection to {} can be established, but performing operations on the server fails: {}"
).format(instance.get('host'), e)
self.service_check(self.SERVICE_CHECK_NAME, AgentCheck.CRITICAL,
tags=service_check_tags, message=err_msg)
raise ConnectionError(err_msg)
return server_instance
def esxi_shutdown(host, ip):
try:
logger.debug('Host: %s, IP: %s, Port: %s' % (host, ip, esxi_port))
esxi_instance = connect.SmartConnect(host=ip,
user=esxi_user,
pwd=esxi_pass,
port=int(esxi_port))
if not esxi_instance:
msg = 'Could not connect to the host: %s, %s' % (host, ip)
logger.error(msg)
return False, msg
atexit.register(connect.Disconnect, esxi_instance)
content = esxi_instance.RetrieveContent()
object_view = content.viewManager.CreateContainerView(
content.rootFolder, [vim.HostSystem], True)
l_hosts = object_view.view
object_view.Destroy()
print l_hosts[0].summary
## Enter MaintenanceMode
# try:
# main_mode = l_hosts[0].EnterMaintenanceMode_Task(5)
# logger.debug('EnterMaintenanceMode_Task excuted'+str(main_mode))
# except vim.fault.Timedout as err:
# msg = "Caught vim fault: %s" % err.msg
# logger.exception(msg)
# return False, msg
# time.sleep(30)
## Shutdown esxi host
# try:
# shutdown_ = l_hosts[0].ShutdownHost_Task(True)
# logger.debug('shutdown esxi host'+str(shutdown_))
# except vmodl.fault.NotSupported as err:
# msg = "Caught vmodl fault: %s" % err.msg
# logger.exception(msg)
# return False, msg
#
except vmodl.MethodFault as err:
msg = "Caught vmodl fault: %s" % err.msg
logger.exception(msg)
return False, msg
except Exception as err:
msg = "Caught exception: %s" % str(err)
logger.exception(msg)
return False, msg
def initialize(template, config_file):
si = connect.SmartConnect(host='10.51.16.61', user='******', pwd='xxx')
inv=si.RetrieveContent()
DC=inv.rootFolder.childEntity[0]
vm=DC.vmFolder
NETWORK=DC.network
vm_obj=[i for i in vm.childEntity if i.name == '%s' %template][0]
conf1=ConfigObj('%s' %config_file,unrepr=True)
print conf1.keys()
i=0
for vm_type in conf1.keys()[1:]:
for vm_name in conf1['%s' %vm_type]:
clonespec=create_spec(config_file,vm_type,vm_name, DC,NETWORK )
task = vm_obj.Clone(folder=vm, name = '%s' %vm_name, spec=clonespec)
result = WaitTask(task, 'Create %s from template: %s' %(vm_name,template) )
print result
def main():
parser = argparse.ArgumentParser(description='vCenter login')
parser.add_argument('-s', '--host', required=True, action='store', help='vSphere IP')
parser.add_argument('-o', '--port', type=int, default=443, action='store', help='vSphere Port')
parser.add_argument('-u', '--user', required=True, action='store', help='User name')
parser.add_argument('-p', '--password', required=True, action='store', help='Password')
parser.add_argument('-n', '--name', required=False, action='store', help='VM name')
args = parser.parse_args()
try:
service_instance = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(connect.Disconnect, service_instance)
if args.name:
content = service_instance.content
objView = content.viewManager.CreateContainerView(content.rootFolder, [vim.VirtualMachine], True)
vmlist = objView.view
objView.Destroy()
for vm in vmlist:
if vm.name == args.name:
print "Powering on VM " + vm.name
task = vm.PowerOn()
libvmtask.WaitForTasks([task], service_instance)
print "Powered on VM " + vm.name
#libvmtask.list_files(service_instance, '*.vmdk')
#libvmtask.list_files(service_instance, '*.iso')
#libvmtask.detach_disk(vm, service_instance, '[NAS] hulli/hulli.vmdk')
#libvmtask.attach_disk(vm, service_instance, '[NAS] hulli/hulli.vmdk')
else:
raise SystemExit("Please provide a VM name")
return 0
except vmodl.MethodFault as error:
print("ERROR: " + error.msg)
sys.exit(1)
def main():
parser = argparse.ArgumentParser(description='vCenter login')
parser.add_argument('-s',
'--host',
required=True,
action='store',
help='vSphere IP')
parser.add_argument('-o',
'--port',
type=int,
default=443,
action='store',
help='vSphere Port')
parser.add_argument('-u',
'--user',
required=True,
action='store',
help='User name')
parser.add_argument('-p',
'--password',
required=False,
action='store',
help='Password')
parser.add_argument('-n',
'--name',
required=False,
action='store',
help='VM Name to list')
args = parser.parse_args()
try:
service_instance = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(connect.Disconnect, service_instance)
content = service_instance.RetrieveContent()
libvmtask.list_files(service_instance, "*.iso")
return 0
except vmodl.MethodFault as error:
print("ERROR: " + error.msg)
sys.exit(1)
def main():
"""
Simple command-line program demonstrating vSphere perfManager API
"""
args = get_args()
try:
service_instance = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
if not service_instance:
print("Could not connect to the specified host using specified "
"username and password")
return -1
atexit.register(connect.Disconnect, service_instance)
content = service_instance.RetrieveContent()
search_index = content.searchIndex
# quick/dirty way to find an ESXi host
host = search_index.FindByDnsName(dnsName=args.vihost, vmSearch=False)
perfManager = content.perfManager
metricId = vim.PerformanceManager.MetricId(counterId=6, instance="*")
startTime = datetime.datetime.now() - datetime.timedelta(hours=1)
endTime = datetime.datetime.now()
query = vim.PerformanceManager.QuerySpec(maxSample=1,
entity=host,
metricId=[metricId],
startTime=startTime,
endTime=endTime)
print(perfManager.QueryPerf(querySpec=[query]))
except vmodl.MethodFault as e:
print("Caught vmodl fault : " + e.msg)
return -1
except Exception as e:
print("Caught exception : " + str(e))
return -1
return 0
def detail(request, server_id):
server1 = get_object_or_404(server, pk=server_id)
vms.objects.filter(server=server1).delete()
sslContext = None
sslContext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
sslContext.verify_mode = ssl.CERT_NONE
try:
service_instance = connect.SmartConnect(host=server1.IP_addr,user=server1.user,pwd=server1.passwd,port=443,sslContext=sslContext)
atexit.register(connect.Disconnect, service_instance)
content = service_instance.RetrieveContent()
container = content.rootFolder # starting point to look into
viewType = [vim.VirtualMachine] # object types to look for
recursive = True # whether we should look into it recursively
containerView = content.viewManager.CreateContainerView(
container, viewType, recursive)
children = containerView.view
for child in children:
summary = child.summary
Moid = int(re.search(r'\d+', str(child)).group())
Name = summary.config.name
Guest = summary.config.guestFullName
CPU = summary.config.numCpu
Mem = summary.config.memorySizeMB // 1024
run = summary.runtime.powerState
if run == "poweredOn":
run = "y"
else:
run = "n"
#Uuid = summary.config.instanceUuid
if summary.guest is not None:
ip_address = summary.guest.ipAddress
if ip_address:
Ipa = ip_address
else:
Ipa = "none"
server1.vms_set.create(vm_text=Name,moid=Moid,Guest=Guest,CPU=CPU,Mem=Mem,Ipa=Ipa,run=run)
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return render(request, 'vms/detail.html', {'server': server1})
def main():
args = get_args()
ovfd = get_ovf_descriptor(args.ovf_path)
try:
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_NONE
si = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=args.port,
sslContext=context)
except:
print "Unable to connect to %s" % args.host
exit(1)
objs = get_objects(si, args)
manager = si.content.ovfManager
spec_params = vim.OvfManager.CreateImportSpecParams()
import_spec = manager.CreateImportSpec(ovfd,
objs["resource pool"],
objs["datastore"],
spec_params)
lease = objs["resource pool"].ImportVApp(import_spec.importSpec,
objs["datacenter"].vmFolder)
while(True):
if (lease.state == vim.HttpNfcLease.State.ready):
# Assuming single VMDK.
url = lease.info.deviceUrl[0].url.replace('*', args.host)
# Spawn a dawmon thread to keep the lease active while POSTing
# VMDK.
keepalive_thread = Thread(target=keep_lease_alive, args=(lease,))
keepalive_thread.start()
# POST the VMDK to the host via curl. Requests library would work
# too.
curl_cmd = (
"curl -Ss -X POST --insecure -T %s -H 'Content-Type: \
application/x-vnd.vmware-streamVmdk' %s" %
(args.vmdk_path, url))
system(curl_cmd)
lease.HttpNfcLeaseComplete()
keepalive_thread.join()
return 0
elif (lease.state == vim.HttpNfcLease.State.error):
print "Lease error: " + lease.state.error
exit(1)
connect.Disconnect(si)
def _vim_connect(self):
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.verify_mode = ssl.CERT_NONE
display.vvv("ESTABLISH VIM CONNECTION FOR USER: %s on PORT %s TO %s" %
(self._vim_host_user, self._vim_port, self._vim_host),
host=self._vim_host)
try:
service_instance = connect.SmartConnect(host=self._vim_host,
user=self._vim_host_user,
pwd=self._vim_host_pass,
port=self._vim_port,
sslContext=context)
except vim.fault.InvalidLogin:
raise AnsibleError("Login failed for user %s" %
self._vim_host_user)
return service_instance
def connectVcenter(host='', user='', password='', port=443):
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_NONE
service_instance = connect.SmartConnect(host=host,
user=user,
pwd=password,
port=int(port),
sslContext=context)
if not service_instance:
logging.info(
"Unable to connect with the vCenter Server using the provided credentials"
)
return False
atexit.register(connect.Disconnect, service_instance)
#content = service_instance.RetrieveContent()
return service_instance
def vcenter_connection(vcenter, username, password):
"""Returns a vCenter service instance, connected with the given login
information.
"""
if not all([vcenter, username, password]):
LOG.error('vCenter host, username, and password required')
return None
try:
service_instance = connect.SmartConnect(host=vcenter, user=username,
pwd=password,
port=settings.VCENTER_PORT)
except vim.fault.InvalidLogin as e:
LOG.error('Could not connect to %s: %s' % (vcenter, e.msg))
return None
except requests_exceptions.ConnectionError as e:
LOG.error('Could not connect to %s: %s' % (vcenter, e.message))
return None
return service_instance
def connect_to_vcenter(module, disconnect_atexit=True):
hostname = module.params['vcenter_hostname']
username = module.params['vcenter_username']
password = module.params['vcenter_password']
port = module.params['vcenter_port']
try:
service_instance = connect.SmartConnect(host=hostname,
user=username,
pwd=password,
port=port)
if disconnect_atexit:
atexit.register(connect.Disconnect, service_instance)
return service_instance.RetrieveContent()
except vim.fault.InvalidLogin, invalid_login:
module.fail_json(msg=invalid_login.msg, apierror=str(invalid_login))
def search_index(self):
if self._search_index:
return self._search_index
# form a connection...
si = connect.SmartConnect(
host=self.options.host,
user=self.options.user,
pwd=self.options.password,
port=443,
)
# Note: from daemons use a shutdown hook to do this, not the atexit
atexit.register(connect.Disconnect, si)
# http://pubs.vmware.com/vsphere-55/topic/com.vmware.wssdk.apiref.doc/vim.SearchIndex.html
self._search_index = si.content.searchIndex
return self._search_index
def vcenter_auth():
service_instance = None
try:
s = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
s.verify_mode = ssl.CERT_NONE
service_instance = connect.SmartConnect(
host=os.environ["vcenter_host"],
user=os.environ["vcenter_user"],
pwd=os.environ["vcenter_password"],
sslContext=s,
)
atexit.register(connect.Disconnect, service_instance)
except IOError:
pass
if not service_instance:
raise SystemExit("Unable to connect to host with supplied info.")
return service_instance
def main():
# command line
options = get_options()
si = connect.SmartConnect(host=options.host, pwd=options.password)
print("Connected %s" % options.host)
vmHandle = folder.Find(options.vmname)
cspec = Vim.Vm.ConfigSpec()
cspec.messageBusTunnelEnabled = (options.task.lower() == 'enable')
task = vmHandle.Reconfigure(cspec)
WaitForTask(task)
# util.interrogate(vmHandle.config)
print("messageBusTunnelEnabled: %s" %
vmHandle.config.messageBusTunnelEnabled)
def main():
"""
Simple command-line program for listing the virtual machines on a system.
"""
args = get_args()
try:
if args.disable_ssl_verification:
service_instance = connect.SmartConnectNoSSL(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
else:
service_instance = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(connect.Disconnect, service_instance)
content = service_instance.RetrieveContent()
container = content.rootFolder # starting point to look into
viewType = [vim.VirtualMachine] # object types to look for
recursive = True # whether we should look into it recursively
containerView = content.viewManager.CreateContainerView(
container, viewType, recursive)
children = containerView.view
if args.find is not None:
pat = re.compile(args.find, re.IGNORECASE)
for child in children:
if args.find is None:
print_vm_info(child)
else:
if pat.search(child.summary.config.name) is not None:
print_vm_info(child)
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
return 0
def get_datastores(self, data):
"""
Get datastores from VMWare.
"""
try:
ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ssl_context.verify_mode = ssl.CERT_NONE
server_instance = connect.SmartConnect(
host=data['hostname'],
user=data['username'],
pwd=data['password'],
sslContext=ssl_context,
)
except vim.fault.InvalidLogin as e:
raise CallError(e.msg, errno.EPERM)
except socket.gaierror as e:
raise CallError(str(e), e.errno)
content = server_instance.RetrieveContent()
objview = content.viewManager.CreateContainerView(
content.rootFolder, [vim.HostSystem], True)
esxi_hosts = objview.view
objview.Destroy()
datastores = {}
for esxi_host in esxi_hosts:
storage_system = esxi_host.configManager.storageSystem
datastores_host = {}
for host_mount_info in storage_system.fileSystemVolumeInfo.mountInfo:
if host_mount_info.volume.type != 'VMFS':
continue
datastores_host[host_mount_info.volume.name] = {
'uuid': host_mount_info.volume.uuid,
'capacity': host_mount_info.volume.capacity,
'vmfs_version': host_mount_info.volume.version,
'local': host_mount_info.volume.local,
'ssd': host_mount_info.volume.ssd
}
datastores[esxi_host.name] = datastores_host
connect.Disconnect(server_instance)
return datastores
