def _execute(self):
# Find the cluster's resource pool moid
cluster_obj = get_obj(self.servicemanager.content,
[vim.ClusterComputeResource], self.cluster_name)
assert cluster_obj is not None
print("Cluster Moref: {0}".format(cluster_obj))
deployment_target = LibraryItem.DeploymentTarget(
resource_pool_id=cluster_obj.resourcePool._GetMoId())
# Find lib item id from given item name
find_spec = Item.FindSpec()
find_spec.name = self.lib_item_name
item_ids = self.client.library_item_service.find(find_spec)
assert (item_ids is not None and len(item_ids) > 0), (
'No items found with name: {0}'.format(self.lib_item_name))
lib_item_id = item_ids[0]
ovf_summary = self.client.ovf_lib_item_service.filter(
ovf_library_item_id=lib_item_id, target=deployment_target)
print('Found an OVF template :{0} to deploy.'.format(ovf_summary.name))
# Deploy the ovf template
self.deploy_ovf_template(lib_item_id, ovf_summary, deployment_target)
def _execute(self):
content = self.servicemanager.content
datastore_obj = get_obj(content, [vim.Datastore], self.datastore_name)
if datastore_obj is not None:
self.mo_id = datastore_obj._GetMoId()
print('Datastore MoId: {0}'.format(self.mo_id))
else:
print('Datastore: {0} not found'.format(self.datastore_name))
def _execute(self):
content = self.servicemanager.content
cluster_obj = get_obj(content, [vim.ClusterComputeResource],
self.cluster_name)
if cluster_obj is not None:
self.mo_id = cluster_obj._GetMoId()
print('Cluster MoId: {0}'.format(self.mo_id))
else:
print('Cluster: {0} not found'.format(self.cluster_name))
def execute(self):
# Find the cluster's resource pool moid
cluster_obj = get_obj(self.servicemanager.content,
[vim.ClusterComputeResource], self.cluster_name)
assert cluster_obj is not None
print("Cluster Moref: {0}".format(cluster_obj))
deployment_target = LibraryItem.DeploymentTarget(
resource_pool_id=cluster_obj.resourcePool._GetMoId())
lib_item_id = self.helper.get_item_id_by_name(self.lib_item_name)
assert lib_item_id
ovf_summary = self.client.ovf_lib_item_service.filter(
ovf_library_item_id=lib_item_id, target=deployment_target)
print('Found an OVF template :{0} to deploy.'.format(ovf_summary.name))
# Deploy the ovf template
self.deploy_ovf_template(lib_item_id, ovf_summary, deployment_target)
def _setup(self):
self.datastore_name = self.args.datastorename
self.cluster_name = self.args.clustername
self.folder_name = self.args.foldername
self.datacenter_name = self.args.datacentername
self.servicemanager = self.get_service_manager()
self.datastore_id = get_datastore_id(
service_manager=self.servicemanager,
datastore_name=self.datastore_name)
self.client = ClsApiClient(self.servicemanager)
self.helper = ClsApiHelper(self.client, self.skip_verification)
session = get_unverified_session() if self.skip_verification else None
self.vsphere_client = create_vsphere_client(server=self.server,
username=self.username,
password=self.password,
session=session)
self.folder_id = get_folder(self.vsphere_client, self.datacenter_name,
self.folder_name)
self.storage_backings = self.helper.create_storage_backings(
self.servicemanager, self.datastore_name)
cluster_obj = get_obj(self.servicemanager.content,
[vim.ClusterComputeResource], self.cluster_name)
self.resource_pool_id = cluster_obj.resourcePool._GetMoId()
def deploy_kmip_node(self, spec, debug=False):
# Check if we know about the deployment target yet
if self.vcs_cluster_obj is None:
# Find the cluster's resource pool moid
print()
print("Obtaining the cluster's resource pool moid...")
self.vcs_cluster_obj = get_obj(self.service_manager.content,
[vim.ClusterComputeResource],
self.deploy_to_cluster)
assert self.vcs_cluster_obj is not None
if debug:
print(" --> Cluster: {0}".format(self.vcs_cluster_obj))
# Get a deployment target resource pool from the Cluster Object
deployment_target = LibraryItem.DeploymentTarget(
resource_pool_id=self.vcs_cluster_obj.resourcePool._GetMoId())
if debug:
print(" --> Resource Pool Moref: {0}".format(
self.vcs_cluster_obj.resourcePool._GetMoId()))
# Find lib item id from given item name
find_spec = Item.FindSpec()
find_spec.name = self.selected_item["name"]
item_ids = self.sm_client.library_item_service.find(find_spec)
assert (item_ids is not None and len(item_ids) > 0), (
'No items found with name: {0}'.format(self.selected_item["name"]))
lib_item_id = item_ids[0]
ovf_summary = self.sm_client.ovf_lib_item_service.filter(
ovf_library_item_id=lib_item_id, target=deployment_target)
print()
print('Deploying OVF template: {0} to cluster: {1}...'.format(
ovf_summary.name, self.deploy_to_cluster))
# Build the deployment spec
deployment_spec = LibraryItem.ResourcePoolDeploymentSpec(
name=spec.name,
annotation=ovf_summary.annotation,
accept_all_eula=True,
network_mappings=None,
storage_mappings=None,
storage_provisioning=None,
storage_profile_id=None,
locale=None,
flags=None,
additional_parameters=None,
default_datastore_id=None)
# Deploy the ovf template
print("Deploying HyTrust OVF Template -- please wait...")
print()
result = self.sm_client.ovf_lib_item_service.deploy(
lib_item_id,
deployment_target,
deployment_spec,
client_token=generate_random_uuid())
# The type and ID of the target deployment is available in the deployment result.
if result.succeeded:
print('>>> Deployment successful.')
if debug:
print('Result resource: {0}, ID: {1}'.format(
result.resource_id.type, result.resource_id.id))
error = result.error
# if error is not None:
# for warning in error.warnings:
# print('OVF warning: {}'.format(warning.message))
# Get the vm object
if spec.is_primary():
self.primary_node_id = result.resource_id.id
self.primary_node_obj = get_obj_by_moId(
self.service_manager.content, [vim.VirtualMachine],
self.primary_node_id)
assert self.primary_node_obj is not None
vm_obj = self.primary_node_obj
vm_id = self.primary_node_id
else:
self.secondary_node_id = result.resource_id.id
self.secondary_node_obj = get_obj_by_moId(
self.service_manager.content, [vim.VirtualMachine],
self.secondary_node_id)
assert self.secondary_node_obj is not None
vm_obj = self.secondary_node_obj
vm_id = self.secondary_node_id
# Invoke the SmartConnect() method by supplying the host name, user name, and password.
self.service_instance_stub = SmartConnect(host=self.web_svcs_host,
user=self.sso_user,
pwd=self.sso_pass)
atexit.register(connect.Disconnect, self.service_instance_stub)
content = self.service_instance_stub.RetrieveContent()
if debug:
print("VM UUID: {0}".format(vm_obj.summary.config.uuid))
if spec.is_primary():
self.primary_node_vm = content.searchIndex.FindByUuid(
None, vm_obj.summary.config.uuid, True)
vm = self.primary_node_vm
else:
self.secondary_node_vm = content.searchIndex.FindByUuid(
None, vm_obj.summary.config.uuid, True)
vm = self.secondary_node_vm
print()
print("Setting vApp Options on the VM...")
vapp_spec_list = list()
# Domain Name
vapp_domainName = vim.vApp.PropertyInfo()
vapp_domainName.key = 0
vapp_domainName.value = spec.domain
vapp_spec1 = vim.vApp.PropertySpec()
vapp_spec1.info = vapp_domainName
vapp_spec1.operation = 'edit'
vapp_spec_list.append(vapp_spec1)
# Netmask
vapp_netmask = vim.vApp.PropertyInfo()
vapp_netmask.key = 1
vapp_netmask.value = spec.subnet
vapp_spec2 = vim.vApp.PropertySpec()
vapp_spec2.info = vapp_netmask
vapp_spec2.operation = 'edit'
vapp_spec_list.append(vapp_spec2)
# KCMaster
vapp_kcmaster = vim.vApp.PropertyInfo()
vapp_kcmaster.key = 2
if spec.is_primary():
vapp_kcmaster.value = ''
else:
vapp_kcmaster.userConfigurable = True
vapp_kcmaster.value = self.primary_node_spec.ip
vapp_spec3 = vim.vApp.PropertySpec()
vapp_spec3.info = vapp_kcmaster
vapp_spec3.operation = 'edit'
vapp_spec_list.append(vapp_spec3)
# Console Password
vapp_consolepw = vim.vApp.PropertyInfo()
vapp_consolepw.key = 3
vapp_consolepw.userConfigurable = True
vapp_consolepw.value = spec.consolepw
vapp_spec4 = vim.vApp.PropertySpec()
vapp_spec4.info = vapp_consolepw
vapp_spec4.operation = 'edit'
vapp_spec_list.append(vapp_spec4)
# HTKC Hostname
vapp_htkcHostname = vim.vApp.PropertyInfo()
vapp_htkcHostname.key = 4
vapp_htkcHostname.value = spec.name
vapp_spec5 = vim.vApp.PropertySpec()
vapp_spec5.info = vapp_htkcHostname
vapp_spec5.operation = 'edit'
vapp_spec_list.append(vapp_spec5)
# DNS Servers
vapp_dns = vim.vApp.PropertyInfo()
vapp_dns.key = 5
vapp_dns.value = spec.dns
vapp_spec6 = vim.vApp.PropertySpec()
vapp_spec6.info = vapp_dns
vapp_spec6.operation = 'edit'
vapp_spec_list.append(vapp_spec6)
# HTKC IP Address
vapp_htkcIP = vim.vApp.PropertyInfo()
vapp_htkcIP.key = 6
vapp_htkcIP.value = spec.ip
vapp_spec7 = vim.vApp.PropertySpec()
vapp_spec7.info = vapp_htkcIP
vapp_spec7.operation = 'edit'
vapp_spec_list.append(vapp_spec7)
# NTP Servers
vapp_ntp = vim.vApp.PropertyInfo()
vapp_ntp.key = 7
vapp_ntp.value = '0.us.pool.ntp.org, 1.us.pool.ntp.org'
vapp_spec8 = vim.vApp.PropertySpec()
vapp_spec8.info = vapp_ntp
vapp_spec8.operation = 'edit'
vapp_spec_list.append(vapp_spec8)
# Gateway
vapp_gateway = vim.vApp.PropertyInfo()
vapp_gateway.key = 8
vapp_gateway.value = spec.gateway
vapp_spec9 = vim.vApp.PropertySpec()
vapp_spec9.info = vapp_gateway
vapp_spec9.operation = 'edit'
vapp_spec_list.append(vapp_spec9)
# KC Cluster Password
vapp_kcpw = vim.vApp.PropertyInfo()
vapp_kcpw.key = 9
vapp_kcpw.userConfigurable = True
vapp_kcpw.value = spec.clusterpw
vapp_spec10 = vim.vApp.PropertySpec()
vapp_spec10.info = vapp_kcpw
vapp_spec10.operation = 'edit'
vapp_spec_list.append(vapp_spec10)
# Make the modifications
config_spec = vim.vm.ConfigSpec()
config_spec.vAppConfig = vim.vApp.VmConfigSpec()
config_spec.vAppConfig.property = vapp_spec_list
reconfig_task = vm.ReconfigVM_Task(config_spec)
task.wait_for_task(reconfig_task)
print("Successfully modified VM:[{0}] properties".format(
spec.name))
# Add the KMS tag to the VM
print()
print('Tagging the KMS VM :: {0}...'.format(spec.name))
kms_tag_attached = self.tag_vm(vm_id, self.kms_tag_id)
assert kms_tag_attached
if debug:
print('Tagged KMS vm: {0}'.format(vm_id))
# Power on the VM and wait for the power on operation to be completed
print()
print("Powering on the KMS Server: {0} ...".format(spec.name))
poweron_vm(self.service_manager.content, vm_obj)
while vm.runtime.powerState != vim.VirtualMachinePowerState.poweredOn:
print("Waiting for VM [{0}] to power on...".format(spec.name))
time.sleep(3)
# Get a WebKMS ticket so we can manipulate the console if we need to
if spec.is_primary():
self.primary_node_ticket = vm.AcquireTicket("webmks")
ticket = self.primary_node_ticket
else:
self.secondary_node_ticket = vm.AcquireTicket("webmks")
ticket = self.secondary_node_ticket
print("WebMKS Ticket: {0}".format(ticket))
print("WMKS URL: wss://{0}:{1}/ticket/{2}".format(
ticket.host, ticket.port, ticket.ticket))
else:
print('Deployment failed.')
for error in result.error.errors:
print('OVF error: {}'.format(error.message))
def __init__(self):
parser = sample_cli.build_arg_parser()
parser.add_argument('--clustername',
action='store',
required=True,
help='Name of the cluster to be tagged')
parser.add_argument('--categoryname',
action='store',
required=True,
help='Name of the Category to be created')
parser.add_argument('--categorydesc',
action='store',
default='Sample category description',
help='Description of the Category to be created')
parser.add_argument('--tagname',
action='store',
required=True,
help='Name of the tag to be created')
parser.add_argument('--tagdesc',
action='store',
default='Sample tag description',
help='Description of the tag to be created')
args = sample_util.process_cli_args(parser.parse_args())
self.cleardata = args.cleardata
self.cluster_name = args.clustername
self.category_name = args.categoryname
self.category_desc = args.categorydesc
self.tag_name = args.tagname
self.tag_desc = args.tagdesc
self.skip_verification = args.skipverification
session = get_unverified_session() if args.skipverification else None
# Connect to vSphere client
self.client = create_vsphere_client(server=args.server,
username=args.username,
password=args.password,
session=session)
# For vSphere 6.0 users, use pyVmomi to get the cluster ID
context = get_unverified_context() if self.skip_verification else None
si = SmartConnect(host=args.server,
user=args.username,
pwd=args.password,
sslContext=context)
cluster_obj = vim_utils.get_obj(content=si.RetrieveContent(),
vimtype=[vim.ClusterComputeResource],
name=args.clustername)
if cluster_obj:
self.cluster_moid = cluster_obj._GetMoId()
print('Found cluster:{} mo_id:{}'.format(self.cluster_name,
self.cluster_moid))
else:
raise ValueError('Cluster with name "{}" not found'.format(
self.cluster_name))
from pyVmomi import vim
from samples.vsphere.common.service_manager import ServiceManager
from samples.vsphere.contentlibrary.lib.cls_api_client import ClsApiClient
from samples.vsphere.common.vim.helpers.vim_utils import get_obj
from com.vmware.content.library_client import Item
from com.vmware.vcenter.ovf_client import LibraryItem
vm_name = ''
rp_name = ''
template_name = ''
esx_host = ''
api_host = ''
api_user = ''
api_pass = ''
service_manager = ServiceManager(api_host, api_user, api_pass, True)
service_manager.connect()
client = ClsApiClient(service_manager)
find_spec = Item.FindSpec(name=template_name)
ovf_template_id = client.library_item_service.find(find_spec)[0]
target = get_obj(service_manager.content, [vim.HostSystem], esx_host)
rp = get_obj(service_manager.content, [vim.ResourcePool], rp_name)
deployment_target = LibraryItem.DeploymentTarget(
host_id=target._GetMoId(), resource_pool_id=rp._GetMoId())
deployment_spec = LibraryItem.ResourcePoolDeploymentSpec(name=template_name +
'_deployed',
accept_all_eula=True)
client.ovf_lib_item_service.deploy(ovf_template_id, deployment_target,
deployment_spec)