def vcenter_resources(ipaddress, user, password):
"""
vCenter に接続して Cluster 毎のCPU/MEM、起動しているVMのCPU/MEMを集計して返す
"""
return_dict = {} # 関数から返すリスト
si = SmartConnect(host=ipaddress, user=user, pwd=password)
atexit.register(Disconnect, si)
content = si.RetrieveContent()
root_folder = content.rootFolder
# データセンタ
for datacenter in root_folder.childEntity:
for cluster in datacenter.hostFolder.childEntity:
return_dict.setdefault('vcenter', {})
return_dict['vcenter'].setdefault(cluster.name, {})
# ホスト
hosts_cpu = 0
hosts_mem = 0
guests_cpu = 0
guests_mem = 0
for host in cluster.host:
hosts_cpu += host.hardware.cpuInfo.numCpuThreads
hosts_mem += int(float(convertMemory(
host.hardware.memorySize)))
# 起動しているVMだけを対象にする
for vm in host.vm:
if vm.summary.runtime.powerState == 'poweredOn':
guests_cpu += vm.summary.config.numCpu
guests_mem += int(
float(vm.summary.config.memorySizeMB // 1024))
return_dict['vcenter'].setdefault(cluster.name, {})
return_dict['vcenter'][cluster.name]['hosts_cpu'] = hosts_cpu
return_dict['vcenter'][cluster.name]['hosts_mem'] = hosts_mem
return_dict['vcenter'][cluster.name]['guests_cpu'] = guests_cpu
return_dict['vcenter'][cluster.name]['guests_mem'] = guests_mem
return return_dict
def main():
args = GetArgs()
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
if (args.insecure):
context.verify_mode = ssl.CERT_NONE
else:
context.verify_mode = ssl.CERT_REQUIRED
try:
si = None
if args.password:
password = args.password
else:
password = getpass.getpass(
prompt="Enter password for host {} and user {}: ".format(
args.host, args.user))
try:
si = SmartConnect(host=args.host,
user=args.user,
pwd=password,
port=int(args.port),
sslContext=context)
except IOError, e:
pass
if not si:
print(
'Could not connect to the specified host using specified username and password'
)
return -1
atexit.register(Disconnect, si)
content = si.RetrieveContent()
retProps = get_properties(content, [vim.VirtualMachine],
['name', 'snapshot'], vim.VirtualMachine)
for vm in retProps:
if ('snapshot' in vm):
print('\n' + vm['name'])
print_snap_info(vm['snapshot'])
def _get_instances(self, inkwargs):
''' Make API calls '''
instances = []
si = SmartConnect(**inkwargs)
self.debugl('retrieving all instances')
if not si:
print("Could not connect to the specified host using specified "
"username and password")
return -1
atexit.register(Disconnect, si)
content = si.RetrieveContent()
# Create a search container for virtualmachines
self.debugl('creating containerview for virtualmachines')
container = content.rootFolder
viewType = [vim.VirtualMachine]
recursive = True
containerView = content.viewManager.CreateContainerView(
container, viewType, recursive)
children = containerView.view
for child in children:
# If requested, limit the total number of instances
if self.args.max_instances:
if len(instances) >= (self.args.max_instances):
break
instances.append(child)
self.debugl("%s total instances in container view" % len(instances))
if self.args.host:
instances = [x for x in instances if x.name == self.args.host]
instance_tuples = []
for instance in sorted(instances):
if self.guest_props != False:
ifacts = self.facts_from_proplist(instance)
else:
ifacts = self.facts_from_vobj(instance)
instance_tuples.append((instance, ifacts))
self.debugl('facts collected for all instances')
return instance_tuples
def main():
args = get_args()
si = SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(Disconnect, si)
content = si.RetrieveContent()
print 'Searching for VM {}'.format(args.vmname)
vm_obj = get_obj(content, [vim.VirtualMachine], args.vmname)
if vm_obj:
change_disk_mode(si, vm_obj, args.disk_number, args.mode)
print 'VM Disk {} successfully ' \
'changed to mode {}.'.format(args.disk_number,
args.mode)
else:
print "VM not found."
def getData(host, username, password, port, log):
log.debug(
'In getData. host is %s, username is %s, password is %s, port is %s \n'
% (host, username, password, port))
serviceInstance = SmartConnect(host=host,
user=username,
pwd=password,
port=port,
sslContext=ssl._create_unverified_context())
atexit.register(Disconnect, serviceInstance)
content = serviceInstance.RetrieveContent()
vm_view = content.viewManager.CreateContainerView(content.rootFolder,
[vim.VirtualMachine],
True)
vms = [vm for vm in vm_view.view]
log.debug(' in getData - vms is %s \n' % (vms))
vm_view.Destroy()
return vms
class VMWareClient:
def __init__(self, host, user, password, port=443, insecure=True):
if insecure:
self._service_instance = SmartConnectNoSSL(host=host, user=user, pwd=password, port=port)
else:
self._service_instance = SmartConnect(host=host, user=user, pwd=password, port=port)
self._host = host
self._user = user
self._password = password
atexit.register(Disconnect, self._service_instance)
self._content = self._service_instance.RetrieveContent()
def create_datacenter(self, name):
folder = self._content.rootFolder
return folder.CreateDatacenter(name=name)
def create_cluster(self, name, datacenter):
host_folder = datacenter.hostFolder
cluster_spec = vim.cluster.ConfigSpecEx()
return host_folder.CreateClusterEx(name=name, spec=cluster_spec)
def handle(ctx, payload):
host = payload.get("host")
port = payload.get("port", 443)
if host is None:
raise Exception("Host required")
secrets = ctx["secrets"]
if secrets is None:
raise Exception("Requires vsphere secrets")
username = secrets["username"]
password = secrets.get("password", "")
context = None
if hasattr(ssl, '_create_unverified_context'):
context = ssl._create_unverified_context()
si = SmartConnect(host=host,
user=username,
pwd=password,
port=port,
sslContext=context)
if not si:
raise Exception(
"Could not connect to the specified host using specified "
"username and password")
try:
content = si.RetrieveContent()
container = content.viewManager.CreateContainerView(
content.rootFolder, [vim.VirtualMachine], True)
templates = []
for c in container.view:
if c.config.template:
templates.append(
{
"name": c.name,
"guest": c.config.guestFullName,
"annotation": c.config.annotation
}
)
return templates
except Exception as e:
return {"exception": "%s" % e}
finally:
Disconnect(si)
def connect_to_vcenter(self):
"""
远程连接vcenter api服务器并获取si, content
:return: instace and content
"""
try:
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.verify_mode = ssl.CERT_NONE
# 获取连接对象
si = SmartConnect(host=self.vcenter_server,
user=self.vcenter_username,
pwd=self.vcenter_password,
port=self.port,
sslContext=context)
# 断开连接
atexit.register(Disconnect, si)
content = si.RetrieveContent()
return si, content
except Exception as e:
exit('登录失败,请检查vcenter url或用户名和密码')
def main():
args = get_args()
# connect to vc
si = SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=args.port)
# disconnect vc
atexit.register(Disconnect, si)
content = si.RetrieveContent()
print 'Searching for VM {}'.format(args.vmname)
vm_obj = get_obj(content, [vim.VirtualMachine], args.vmname)
if vm_obj:
update_virtual_nic_state(si, vm_obj, args.unitnumber, args.state)
print 'VM NIC {} successfully' \
' state changed to {}'.format(args.unitnumber, args.state)
else:
print "VM not found"
def getData(host, username, password, port, log):
log.debug(
'In getData. host is %s, username is %s, password is %s, port is %s \n'
% (host, username, password, port))
serviceInstance = SmartConnect(host=host,
user=username,
pwd=password,
port=port)
atexit.register(Disconnect, serviceInstance)
content = serviceInstance.RetrieveContent()
datastore_view = content.viewManager.CreateContainerView(
content.rootFolder, [vim.Datastore], True)
datastores = []
for datastore in datastore_view.view:
datastore.RefreshDatastore()
datastores.append(datastore)
log.debug(' in getData - datastores is %s \n' % (datastores))
datastore_view.Destroy()
return datastores
def get_vsphere_networks(host, port, username, password):
vsphere_conn = SmartConnect(
user=username,
pwd=password,
host=host,
port=port,
)
vsphere_content = vsphere_conn.RetrieveContent()
vsphere_container = vsphere_content.viewManager.CreateContainerView(
vsphere_content.rootFolder,
[vim.Network],
True,
)
nets = vsphere_container.view
vsphere_container.Destroy()
nets = [{
'name': net.name,
'distributed': is_distributed(net),
} for net in nets]
Disconnect(vsphere_conn)
return nets
def main():
args = au.get_args()
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
# connect this thing
service_instance = SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=args.port,
sslContext=ctx)
# disconnect this thing
atexit.register(Disconnect, service_instance)
# get content
content = service_instance.RetrieveContent()
vm = au.get_obj(content, [vim.VirtualMachine], args.vm_name)
ip_address = au.get_ip_for_vm_network(vm, args.port_group_name)
return ip_address
def main():
ls = []
while True:
vm_name = raw_input("enter the vm name if u know")
iP = raw_input("enter the vm ip if u have any idea what is it")
if vm_name == 'done' or iP == 'done':
break
else:
if len(vm_name) > 0:
ls.append(vm_name)
elif len(iP) > 0:
ls.append(iP)
requests.packages.urllib3.disable_warnings()
# Disabling SSL certificate verification
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.verify_mode = ssl.CERT_NONE
# connect this thing
si = SmartConnect(host='1.1.1.1',
user='******',
pwd='abcd',
port=443,
sslContext=context)
# disconnect this thing
atexit.register(Disconnect, si)
for i in ls:
vm = None
if re.search('^[0-9].*', i):
search_index = si.content.searchIndex
vm = search_index.FindByIp(ip=i, vmSearch=True)
print "vm found using ip hahahahaha"
destroy(si, vm)
elif re.search('^[A-za-z]*', i):
content = si.RetrieveContent()
vm = get_obj(content, [vim.VirtualMachine], i)
print "vm found using name hahahahaha"
destroy(si, vm)
else:
print "VM not found hehehehe"
class VMWareClient:
def __init__(self, host, user, password, port=443, insecure=True):
if insecure:
self._service_instance = SmartConnectNoSSL(host=host,
user=user,
pwd=password,
port=port)
else:
self._service_instance = SmartConnect(host=host,
user=user,
pwd=password,
port=port)
self._host = host
self._user = user
self._password = password
atexit.register(Disconnect, self._service_instance)
self._content = self._service_instance.RetrieveContent()
def create_datacenter(self, name):
folder = self._content.rootFolder
return folder.CreateDatacenter(name=name)
def create_cluster(self, name, datacenter):
host_folder = datacenter.hostFolder
cluster_spec = vim.cluster.ConfigSpecEx()
return host_folder.CreateClusterEx(name=name, spec=cluster_spec)
def add_host_to_vc(self, host_ip, host_username, host_password,
datacenter_name, cluster_name):
host_connect_spec = vim.host.ConnectSpec()
host_connect_spec.hostName = host_ip
host_connect_spec.userName = host_username
host_connect_spec.password = host_password
host_connect_spec.force = True
host_connect_spec.sslThumbprint = get_ssl_thumbprint(host_ip)
datacenter = self.create_datacenter(datacenter_name)
cluster = self.create_cluster(cluster_name, datacenter)
add_host_task = cluster.AddHost(spec=host_connect_spec,
asConnected=True)
wait_for_tasks(self._service_instance, [add_host_task])
def main():
"""
Simple command-line program for listing the virtual machines on a system.
"""
args = GetArgs()
config.read(VMFAST_INI)
context = None
if hasattr(ssl, '_create_unverified_context'):
context = ssl._create_unverified_context()
si = SmartConnect(host=config.get('vmware', 'server'),
user=config.get('vmware', 'username'),
pwd=config.get('vmware', 'password'),
port=config.getint('vmware', 'port'),
sslContext=context)
if not si:
print("Could not connect to the specified host using specified "
"username and password")
return -1
atexit.register(Disconnect, si)
content = si.RetrieveContent()
for child in content.rootFolder.childEntity:
if hasattr(child, 'vmFolder'):
datacenter = child
vmFolder = datacenter.vmFolder
vmList = vmFolder.childEntity
for vm in vmList:
PrintVmInfo(vm)
# pretty print the results
json_str = json.dumps(inventory,
sort_keys=True,
indent=4,
separators=(',', ': '))
print(json_str)
return 0
def main():
args = get_args()
# connect to vc
si = SmartConnect(
host=args.params['hostname'],
user=args.params['username'],
pwd=args.params['password'],
port=args.params['port'])
# disconnect vc
atexit.register(Disconnect, si)
content = si.RetrieveContent()
print 'Searching for VM {}'.format(args.params['vm_name'])
vm_obj = get_obj(content, [vim.VirtualMachine], args.params['vm_name'])
if vm_obj:
update_virtual_nic_state(si, vm_obj, args.params['nic_number'], args.params['nic_state'])
print 'VM NIC {} successfully' \
' state changed to {}'.format(args.params['nic_number'], args.params['nic_state'])
else:
print "VM not found"
def main():
args = GetArgs()
try:
si = SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(Disconnect, si)
content = si.RetrieveContent()
for datacenter in content.rootFolder.childEntity:
print "##################################################"
print "##################################################"
print "### datacenter : " + datacenter.name
print "##################################################"
if printVM:
if hasattr(datacenter.vmFolder, 'childEntity'):
vmFolder = datacenter.vmFolder
vmList = vmFolder.childEntity
for vm in vmList:
printVmInformation(vm)
if printDatastore:
datastores = datacenter.datastore
for ds in datastores:
printDatastoreInformation(ds)
if printHost:
if hasattr(datacenter.vmFolder, 'childEntity'):
hostFolder = datacenter.hostFolder
computeResourceList = hostFolder.childEntity
for computeResource in computeResourceList:
printComputeResourceInformation(computeResource)
except vmodl.MethodFault as error:
print "Caught vmodl fault : " + error.msg
return -1
return 0
def poll_vc():
# subprocess.Popen("/home/fm0g/Seafile/midgar/work/github/vSummary/scripts/testing/vc_uuid.py")
# FIX THIS
global dryrun, verbose, host_portgroups
host_portgroups = {}
verbose = 0
##
result = "Error in request"
http_status = 500
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.verify_mode = ssl.CERT_NONE
try:
si = SmartConnect(host=request.form['host'], user=request.form['user'], pwd=request.form['pwd'], port=443, sslContext=context)
# Figuring out the UUID of the vcenter server
content = si.RetrieveContent()
if content.about.instanceUuid:
vc_uuid = content.about.instanceUuid
http_status = 200
api_url = "http://127.0.0.1/api/update.php"
result = {}
result['ESXi'] = host_inventory(si, vc_uuid, api_url)
result['VM'] = vm_inventory(si, vc_uuid, api_url)
result['ResPool'] = respool_inventory(si, vc_uuid, api_url)
result['DS'] = datastore_inventory(si, vc_uuid, api_url)
result['DC'] = datacenter_inventory(si, vc_uuid, api_url)
result['Folder'] = folder_inventory(si, vc_uuid, api_url)
result['Cluster'] = cluster_inventory(si, vc_uuid, api_url)
result['DVS'] = dvs_inventory(si, vc_uuid, api_url)
result['DVSPG'] = dvs_portgroup_inventory(si, vc_uuid, api_url)
else:
result = "Error Getting vCenter UUID!"
except vim.fault.InvalidLogin:
result = "Invalid Credentials"
except vim.fault.NoPermission:
result = "User Lacks Permissions"
except Exception as e:
result = str(e)
finally:
return json.dumps(result), http_status
def get_vc_uuid():
result = "Error in request"
http_status = 500
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.verify_mode = ssl.CERT_NONE
try:
si = SmartConnect(host=request.form['host'], user=request.form['user'], pwd=request.form['pwd'], port=443, sslContext=context)
# Figuring out the UUID of the vcenter server
content = si.RetrieveContent()
if content.about.instanceUuid:
result = content.about.instanceUuid
http_status = 200
else:
result = "Error Getting vCenter UUID!"
except vim.fault.InvalidLogin:
result = "Invalid Credentials"
except vim.fault.NoPermission:
result = "User Lacks Permissions"
except Exception as e:
result = str(e)
finally:
return result, http_status
def main():
"""
Simple command-line program for listing the virtual machines on a system.
"""
args = GetArgs()
if args.password:
password = args.password
else:
password = getpass.getpass(prompt='Enter password for host %s and '
'user %s: ' % (args.host, args.user))
context = None
if hasattr(ssl, '_create_unverified_context'):
context = ssl._create_unverified_context()
si = SmartConnect(host=args.host,
user=args.user,
pwd=password,
port=int(args.port),
sslContext=context)
if not si:
print("Could not connect to the specified host using specified "
"username and password")
return -1
atexit.register(Disconnect, si)
content = si.RetrieveContent()
for child in content.rootFolder.childEntity:
if hasattr(child, 'vmFolder'):
datacenter = child
vmFolder = datacenter.vmFolder
vmList = vmFolder.childEntity
for vm in vmList:
PrintVmInfo(vm)
with open(csvfile, "w") as output:
writer = csv.writer(output, lineterminator='\n')
for row in data:
writer.writerow([row])
return 0
def main():
opts = validate_options()
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
si = SmartConnect(host=opts.VCIP,
user=opts.vcuser,
pwd=opts.vcpasswd,
sslContext=context)
print 'Logged into the vCenter'
atexit.register(Disconnect, si)
content = si.RetrieveContent()
container = content.rootFolder
viewType = [vim.VirtualMachine]
recursive = True
containerView = content.viewManager.CreateContainerView(
container, viewType, recursive)
children = containerView.view
if len(children) < 1:
print 'Could not locate any VM in inventory , exiting'
exit()
vm_reconfig(opts.vmname, children)
def _get_instances(self, inkwargs):
"""Make API calls."""
instances = []
si = SmartConnect(**inkwargs)
if not si:
print("Could not connect to the specified host using specified "
"username and password")
return -1
atexit.register(Disconnect, si)
content = si.RetrieveContent()
for child in content.rootFolder.childEntity:
instances += self._get_instances_from_children(child)
if self.args.max_instances:
if len(instances) >= (self.args.max_instances+1):
instances = instances[0:(self.args.max_instances+1)]
instance_tuples = []
for instance in sorted(instances):
ifacts = self.facts_from_vobj(instance)
instance_tuples.append((instance, ifacts))
return instance_tuples
def execute_program(self):
try:
service_instance = SmartConnect(host=self.vcenter_hostname,
user=self.vcenter_username,
pwd=self.vcenter_password,
port=int(self.vcenter_port))
atexit.register(Disconnect, service_instance)
si = service_instance.RetrieveContent()
search_index = si.searchIndex
vm = search_index.FindByUuid(None, self.vm_uuid, True, 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=self.vm_username, password=self.vm_password)
try:
pm = si.guestOperationsManager.processManager
ps = vim.vm.guest.ProcessManager.ProgramSpec(
programPath=self.vm_pathProgram,
arguments=self.vm_arguProgram,
)
res = pm.StartProgramInGuest(vm, creds, ps)
if res > 0:
module.exit_json(change=True,
result="Program executed, PID is %d" %
res)
except IOError, e:
module.fail_json(change=False, msg=str(e))
except vmodl.MethodFault as error:
module.fail_json(change=True,
msg="Caught vmodl fault : %s" % error.msg)
def Create(VMName, OS, ram, storage, lifetime, pwd, username, host, pathiso,
Status):
print("this is http in angular is get \n", VMName, OS, ram, storage,
lifetime, pwd, username, host, pathiso, Status)
#**************************setting***************************
s = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
s.verify_mode = ssl.CERT_NONE
si = SmartConnect(host=host, user=username, pwd=pwd, sslContext=s)
content = si.RetrieveContent()
datacenter = content.viewManager.CreateContainerView(content.rootFolder,
[vim.Datacenter],
recursive=True).view
hostSysteminfo = content.viewManager.CreateContainerView(
content.rootFolder, [vim.HostSystem], recursive=True).view[0]
datastoreinfo = content.viewManager.CreateContainerView(
content.rootFolder, [vim.Datastore], recursive=True).view[0]
#***********************************************************************
res = CheckResourc(hostSysteminfo, ram, storage, datastoreinfo)
if (res == True):
print(res)
vm = CreateVM(host, username, pwd, VMName, OS, ram * 1024, storage,
pathiso, Status)
#get ip for vm TODO
ip = None
userid = GetUserID(username, pwd)
vmdate = (datetime.now() + timedelta(days=lifetime)).date()
virtualmachine = Management(vm.uuid, VMName, ip, OS, Status, ram,
storage, vmdate, userid)
InsertVM(virtualmachine.UniqueiD, virtualmachine.VMName,
str(virtualmachine.Ip), virtualmachine.OperatingSystem,
virtualmachine.Status, str(virtualmachine.Ram),
str(virtualmachine.Storage), str(virtualmachine.LifeTime),
str(virtualmachine.IdUser))
return True
else:
print(
"It is impossible to produce such a virtual machine because there are insufficient resources !!!"
)
return False
def main():
s = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
s.verify_mode = ssl.CERT_NONE
si = SmartConnect(host="your_host",
user="******",
pwd="password",
sslContext=s)
print(si.CurrentTime())
content = si.RetrieveContent()
container = content.rootFolder # starting point to look into
viewType = [vim.VirtualMachine] # object types to look for
recursive = True # whether we should look into it recursively
containerView = content.viewManager.CreateContainerView(
container, viewType, recursive)
children = containerView.view
exportxls(children)
for child in children:
print_vm_info(child)
def test_2_nodes_added(self):
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
# connect this thing
service_instance = SmartConnect(host=self.vsphere_server,
user=self.vsphere_user,
pwd=self.vsphere_password,
port=443,
sslContext=ctx)
# disconnect this thing
atexit.register(Disconnect, service_instance)
# get content
content = service_instance.RetrieveContent()
for index in range(1, self.acceptance_node_vm_count + 1):
vm_name = "Voyager-vBMC-%03d-%s" % (index, self.wats_env_num)
vm = au.get_obj(content, [vim.VirtualMachine], vm_name)
au.Reboot_vm_and_wait_for_ip(vm)
self.wait_for_respose_size("http://192.168.50.4:8080/api/common/nodes",
self.acceptance_node_vm_count)
process = Popen([self.mcc_file_path, "nodes"],
stdin=PIPE,
stdout=PIPE,
stderr=PIPE)
output, _ = process.communicate()
nodes_regex = re.compile(
"\|\s*([0-9A-Za-z]+)\s*\|\s*(compute|switch)\s*\|\s*(Discovered|Added)\s*\|(\s*)\|\n"
)
count = len(nodes_regex.findall(output))
self.assertEqual(count, self.acceptance_node_vm_count)
all_matches = nodes_regex.finditer(output)
for node_match in all_matches:
self.assertEqual(node_match.group(2), "compute")
self.assertEqual(node_match.group(3), "Added")
def main(vcent):
context = None
if hasattr(ssl, '_create_unverified_context'):
context = ssl._create_unverified_context()
si = SmartConnect(
host=vcent.ip,
# user='******',
user=vcent.user,
pwd=vcent.password,
# port=int(args.port),
sslContext=context)
if not si:
print("Could not connect to the specified host using specified "
"username and password")
return -1
atexit.register(Disconnect, si)
#检查虚拟在宿主机上是否还存在
vms = Vms.objects.filter(vcent=vcent).all()
search_index = si.content.searchIndex
if vms:
for v in vms:
vmv = search_index.FindByUuid(None, v.uuid, True, True)
print(vmv)
if vmv is None:
v.delete()
#获取每台宿主机上虚拟机列表
content = si.RetrieveContent()
for child in content.rootFolder.childEntity:
if hasattr(child, 'vmFolder'):
datacenter = child
vmFolder = datacenter.vmFolder
vmList = vmFolder.childEntity
for vm in vmList:
PrintVmInfo(vm=vm, vcent=vcent)
return 0
def main():
args = au.get_args()
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
# connect this thing
service_instance = SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=args.port,
sslContext=ctx)
# disconnect this thing
atexit.register(Disconnect, service_instance)
# get content
content = service_instance.RetrieveContent()
# create the test_vswitch and the port groups
rhd_vswitch = args.test_id + "-RHD-to-Nodes"
rhd_vswitch_pg = args.test_id + "-RHD-to-Nodes-PG"
vm = au.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm:
au.Destroy_vm(vm)
if args.delete_network:
port_group = au.get_obj(content, [vim.Network], rhd_vswitch_pg)
if port_group:
for host in port_group.host:
print(host)
au.DelHostPortgroup(host, rhd_vswitch_pg)
vswitch = au.get_obj(content, [vim.Network], rhd_vswitch)
if vswitch:
for host in port_group.host:
print(host)
au.DelHostSwitch(host, rhd_vswitch)
class VSphereClient:
def __init__(self, credential, host, port=443):
self.host = host
self.port = port
self.username = credential.username
self.password = credential.password
self.si = None
self.content = None
def login(self):
context = None
if hasattr(ssl, '_create_unverified_context'):
context = ssl._create_unverified_context()
self.si = SmartConnect(host=self.host,
user=self.username,
pwd=self.password,
port=self.port,
sslContext=context)
self._retrieve_content()
def disconnect(self):
return Disconnect(self.si)
def _retrieve_content(self):
self.content = self.si.RetrieveContent()
def _get_view_obj(self, vim_type):
return self.content.viewManager.CreateContainerView(
self.content.rootFolder, [vim_type], True)
def get_hosts(self):
view_obj = self._get_view_obj(vim.HostSystem)
return [host for host in view_obj.view]
def get_datacenters(self):
view_obj = self._get_view_obj(vim.Datacenter)
return [dc for dc in view_obj.view]
def main():
"""
Let this thing fly
"""
args = get_args()
# connect this thing
if args.insecure:
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.verify_mode = ssl.CERT_NONE
si = SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=args.port,
sslContext=context)
else:
si = SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=args.port)
# disconnect this thing
atexit.register(Disconnect, si)
content = si.RetrieveContent()
template = None
template = get_obj(content, [vim.VirtualMachine], args.template)
if template:
# if args.linked_clone:
# take_template_snapshot(si, template)
clone_vm(content, template, args.vm_name, si, args.datacenter_name,
args.vm_folder, args.datastore_name, args.cluster_name,
args.resource_pool, args.power_on, args.cpus, args.memory,
args.linked_clone)
else:
print "template not found"
