def get_placement_spec_for_resource_pool(stub_config,
datacenter_name,
vm_folder_name,
datastore_name):
"""
Returns a VM placement spec for a resourcepool. Ensures that the
vm folder and datastore are all in the same datacenter which is specified.
"""
resource_pool = resource_pool_helper.get_resource_pool(stub_config,
datacenter_name)
folder = folder_helper.get_folder(stub_config,
datacenter_name,
vm_folder_name)
datastore = datastore_helper.get_datastore(stub_config,
datacenter_name,
datastore_name)
# Create the vm placement spec with the datastore, resource pool and vm
# folder
placement_spec = VM.PlacementSpec(folder=folder,
resource_pool=resource_pool,
datastore=datastore)
print("get_placement_spec_for_resource_pool: Result is '{}'".
format(placement_spec))
return placement_spec
def _execute(self):
# Get the identifiers
vm_id = get_vm(self.vsphere_client, self.vm_name)
assert vm_id
resource_pool_id = get_resource_pool(self.vsphere_client,
self.datacenter_name,
self.resource_pool_name)
assert resource_pool_id
# Create a library
storage_backings = self.helper.create_storage_backings(
self.servicemanager, self.datastore_name)
self.library_id = self.helper.create_local_library(
storage_backings, self.library_name)
# Build the create specification
create_spec = VmtxLibraryItem.CreateSpec()
create_spec.source_vm = vm_id
create_spec.library = self.library_id
create_spec.name = self.item_name
create_spec.placement = VmtxLibraryItem.CreatePlacementSpec(
resource_pool=resource_pool_id)
# Create a new library item from the source VM
self.item_id = self.client.vmtx_service.create(create_spec)
print("Created VM template item '{0}' with ID: {1}".format(
self.item_name, self.item_id))
# Retrieve the library item info
info = self.client.vmtx_service.get(self.item_id)
print('VM template guest OS: {0}'.format(info.guest_os))
def _execute(self):
# Get the identifiers
item_id = self.helper.get_item_id_by_name(self.item_name)
assert item_id
resource_pool_id = get_resource_pool(self.vsphere_client,
self.datacenter_name,
self.resource_pool_name)
assert resource_pool_id
version_before_check_out = self.client.library_item_service.get(
item_id).content_version
self.print_live_versions(item_id)
# Build the check out spec
check_out_spec = CheckOuts.CheckOutSpec()
placement_spec = CheckOuts.PlacementSpec()
placement_spec.resource_pool = resource_pool_id
check_out_spec.placement = placement_spec
check_out_spec.name = self.vm_name
# Check out VM from item
vm_id = self.client.check_outs_service.check_out(
item_id, check_out_spec)
print("VM (ID: {}) checked out from item".format(vm_id))
# Get library id associated with checked out VM
info = self.vsphere_client.vcenter.vm.LibraryItem.get(vm_id)
assert info.check_out
print("Library item associated with checked out VM is {}".format(
info.check_out.library_item))
# Check in VM into the library item
check_in_spec = CheckOuts.CheckInSpec()
check_in_spec.message = "Check in message"
version_after_check_in = self.client.check_outs_service.check_in(
item_id, vm_id, check_in_spec)
print("VM (ID: {}) checked into item {}".format(vm_id, item_id))
self.print_live_versions(item_id)
# Rollback to previous version
rollback_message = "Rollback to v{}".format(version_before_check_out)
rollback_spec = Versions.RollbackSpec(rollback_message)
version_after_rollback = self.client.versions_service.rollback(
item_id, version_before_check_out, rollback_spec)
print("Item rolled back to version {}. New item version is {}".format(
version_before_check_out, version_after_rollback))
self.print_live_versions(item_id)
# Delete previous version
self.client.versions_service.delete(item_id, version_after_check_in)
print("Deleted version {} of item".format(version_after_check_in))
self.print_live_versions(item_id)
self.print_change_history(item_id)
def _execute(self):
# Get the identifiers of the resources used for deployment
item_id = self.helper.get_item_id_by_name(self.item_name)
assert item_id
folder_id = get_folder(self.vsphere_client,
self.datacenter_name,
self.folder_name)
assert folder_id
resource_pool_id = get_resource_pool(self.vsphere_client,
self.datacenter_name,
self.resource_pool_name)
assert resource_pool_id
datastore_id = get_datastore_id(self.servicemanager,
self.datastore_name)
assert datastore_id
# Build the deployment specification
placement_spec = VmtxLibraryItem.DeployPlacementSpec(
folder=folder_id,
resource_pool=resource_pool_id)
vm_home_storage_spec = VmtxLibraryItem.DeploySpecVmHomeStorage(
datastore=datastore_id)
disk_storage_spec = VmtxLibraryItem.DeploySpecDiskStorage(
datastore=datastore_id)
deploy_spec = VmtxLibraryItem.DeploySpec(
name=self.vm_name,
placement=placement_spec,
vm_home_storage=vm_home_storage_spec,
disk_storage=disk_storage_spec)
# Deploy a virtual machine from the VM template item
self.vm_id = self.client.vmtx_service.deploy(item_id, deploy_spec)
self.vm = get_obj_by_moId(self.servicemanager.content,
[vim.VirtualMachine], self.vm_id)
print("Deployed VM '{0}' with ID: {1}".format(self.vm.name,
self.vm_id))
# Print a summary of the deployed VM
vm_summary = self.vm.summary.config
print('Guest OS: {0}'.format(vm_summary.guestId))
print('{0} CPU(s)'.format(vm_summary.numCpu))
print('{0} MB memory'.format(vm_summary.memorySizeMB))
print('{0} disk(s)'.format(vm_summary.numVirtualDisks))
print('{0} network adapter(s)'.format(vm_summary.numEthernetCards))
