class LibraryPublishSubscribe(SampleBase):
"""
Demonstrates the basic sync workflow to publish and subscribe content libraries.
Note: the workflow needs an existing VC datastore with available storage.
"""
VCSP_USERNAME = '******'
DEMO_PASSWORD = '******'
SYNC_TIMEOUT_SEC = 60
DEMO_FILENAME = 'test.iso'
def __init__(self):
SampleBase.__init__(self, self.__doc__)
self.servicemanager = None
self.client = None
self.helper = None
self.datastore_name = None
self.pub_lib_name = "demo-publib"
self.sub_lib_name = "demo-sublib"
self.pub_lib_id = None
self.sub_lib_id = None
def _options(self):
self.argparser.add_argument('-datastorename',
'--datastorename',
help='The name of the datastore.')
def _setup(self):
self.datastore_name = self.args.datastorename
assert self.datastore_name is not None
self.servicemanager = self.get_service_manager()
self.client = ClsApiClient(self.servicemanager)
self.helper = ClsApiHelper(self.client, self.skip_verification)
def _execute(self):
storage_backings = self.helper.create_storage_backings(
self.servicemanager, self.datastore_name)
# Create a published library backed the VC datastore using vAPIs
self.pub_lib_id = self.create_published_library(storage_backings)
assert self.pub_lib_id is not None
print('Published library created: ID: {0}'.format(self.pub_lib_id))
pub_lib = self.client.local_library_service.get(self.pub_lib_id)
pub_lib_url = pub_lib.publish_info.publish_url
assert pub_lib_url is not None
print('Publish URL : {0}'.format(pub_lib_url))
# Create a library item in the published library
pub_lib_item_id = self.helper.create_iso_library_item(
self.pub_lib_id, 'item_1', self.DEMO_FILENAME)
assert self.client.library_item_service.get(
pub_lib_item_id) is not None
# Create the subscribed library
sub_lib, sub_spec = self.create_subcribed_library(
storage_backings, pub_lib_url)
assert self.sub_lib_id is not None
print('Subscribed library created: ID: {0}'.format(self.sub_lib_id))
# It is not mandatory to verify sync, it is just for demonstrating the sample workflow.
assert (ClsSyncHelper(self.client,
self.SYNC_TIMEOUT_SEC).verify_library_sync(
self.pub_lib_id, sub_lib))
sub_lib = self.client.subscribed_library_service.get(self.sub_lib_id)
print('Subscribed library synced : {0}'.format(sub_lib.last_sync_time))
sub_item_ids = self.client.library_item_service.list(self.sub_lib_id)
assert len(sub_item_ids) == 1, 'Subscribed library must have one item'
# Add another item to the published library
self.helper.create_iso_library_item(self.pub_lib_id, 'item_2',
self.DEMO_FILENAME)
# Manually synchronize the subscribed library to get the latest changes immediately.
self.client.subscribed_library_service.sync(self.sub_lib_id)
# It is not mandatory to verify sync, it is just for demonstrating the sample workflow.
assert (ClsSyncHelper(self.client,
self.SYNC_TIMEOUT_SEC).verify_library_sync(
self.pub_lib_id, sub_lib))
sub_lib = self.client.subscribed_library_service.get(self.sub_lib_id)
print('Subscribed library synced : {0}'.format(sub_lib.last_sync_time))
# List the subscribed items.
sub_item_ids = self.client.library_item_service.list(self.sub_lib_id)
assert len(sub_item_ids) == 2, 'Subscribed library must have two items'
for sub_item_id in sub_item_ids:
sub_item = self.client.library_item_service.get(sub_item_id)
print('Subscribed item : {0}'.format(sub_item.name))
# Change the subscribed library to be on-demand
sub_spec.subscription_info.on_demand = True
self.client.subscribed_library_service.update(self.sub_lib_id,
sub_spec)
# Evict the cached content of the first subscribed library item
self.client.subscribed_item_service.evict(sub_item_id)
sub_item = self.client.library_item_service.get(sub_item_id)
print('Subscribed item evicted : {0}'.format(sub_item.name))
assert not sub_item.cached, 'Subscribed item must not be cached'
# Force synchronize the subscribed library item to fetch and cache the content
self.client.subscribed_item_service.sync(sub_item_id, True)
# It is not mandatory to verify sync, it is just for demonstrating the sample workflow.
assert (ClsSyncHelper(
self.client, self.SYNC_TIMEOUT_SEC).verify_item_sync(sub_item_id))
sub_item = self.client.library_item_service.get(sub_item_id)
print('Subscribed item force sync : {0}'.format(sub_item.name))
assert sub_item.cached, 'Subscribed item must be cached'
def create_published_library(self, storage_backings):
# Build the authenticated publish info.
# Note: The username will be 'vcsp'.
pub_info = PublishInfo()
pub_info.published = True
pub_info.authentication_method = PublishInfo.AuthenticationMethod.BASIC
pub_info.password = self.DEMO_PASSWORD
# Build the specification for the published library to be created
pub_spec = LibraryModel()
pub_spec.name = self.pub_lib_name
pub_spec.description = "Published library backed by VC datastore"
pub_spec.publish_info = pub_info
pub_spec.type = pub_spec.LibraryType.LOCAL
pub_spec.storage_backings = storage_backings
pub_lib_id = self.client.local_library_service.create(
create_spec=pub_spec, client_token=generate_random_uuid())
return pub_lib_id
def create_subcribed_library(self, storage_backings, pub_lib_url):
# Build the subscription information using the publish URL of the published
# library. The username must be 'vcsp'.
sub_info = SubscriptionInfo()
sub_info.authentication_method = SubscriptionInfo.AuthenticationMethod.BASIC
sub_info.user_name = self.VCSP_USERNAME
sub_info.password = self.DEMO_PASSWORD
sub_info.on_demand = False
sub_info.automatic_sync_enabled = True
sub_info.subscription_url = pub_lib_url
# Build the specification for the subscribed library
sub_spec = LibraryModel()
sub_spec.name = self.sub_lib_name
sub_spec.type = sub_spec.LibraryType.SUBSCRIBED
sub_spec.subscription_info = sub_info
sub_spec.storage_backings = storage_backings
self.sub_lib_id = self.client.subscribed_library_service.create(
create_spec=sub_spec, client_token=generate_random_uuid())
sub_lib = self.client.subscribed_library_service.get(self.sub_lib_id)
return sub_lib, sub_spec
def _cleanup(self):
if self.sub_lib_id:
self.client.subscribed_library_service.delete(self.sub_lib_id)
print('Deleted subscribed library Id: {0}'.format(self.sub_lib_id))
if self.pub_lib_id:
self.client.local_library_service.delete(self.pub_lib_id)
print('Deleted published library Id : {0}'.format(self.pub_lib_id))
class VmtxPublish(SampleBase):
"""
Demonstrates the VMTX push sync workflow to publish and subscribe VMTX items.
Note: the workflow needs an existing VC datastore with available storage.
"""
SYNC_TIMEOUT_SEC = 60
def __init__(self):
SampleBase.__init__(self, self.__doc__)
self.servicemanager = None
self.client = None
self.helper = None
self.datastore_name = None
self.resource_pool_id = None
self.folder_id = None
self.pub_libs_to_clean = []
self.sub_libs_to_clean = []
self.vms_to_clean = []
def _options(self):
self.argparser.add_argument('-datacentername',
'--datacentername',
required=True,
help='The name of the datacenter')
self.argparser.add_argument('-datastorename',
'--datastorename',
required=True,
help='The name of the datastore.')
self.argparser.add_argument('-clustername',
'--clustername',
required=True,
help='The name of the cluster to be used.')
self.argparser.add_argument('-foldername',
'--foldername',
required=True,
help='The name of the folder in the '
'datacenter for creating a subscription')
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 _execute(self):
self.create_new_subscription()
self.create_subscription_from_existing_subscribed_library()
def create_new_subscription(self):
"""
Sample code for creating a new subscription for VMTX templates
"""
# Create a published library and a new subscription
pub_lib_name = "pub_lib_new_" + str(uuid.uuid4())
pub_lib_id = self.create_published_library(pub_lib_name).id
self.pub_libs_to_clean.append(pub_lib_id)
sub_lib_name = "sub_lib_new_" + str(uuid.uuid4())
subscription_id = self.create_subscription_new(pub_lib_id,
sub_lib_name)
# Get the subscribed library associated with the subscription
subscription_info = self.client.subscriptions.get(
pub_lib_id, subscription_id)
sub_lib = self.client.library_service.get(
subscription_info.subscribed_library)
self.sub_libs_to_clean.append(sub_lib.id)
# - Create a VMTX item on the published library
# - Push-synchronize the subscription and verify the sync
vm_name = "sample_vm_new_" + str(uuid.uuid4())
vmtx_item_name = "sample_vmtx_item_existing_" + str(uuid.uuid4())
vmtx_item_id = self.create_vmtx_item(pub_lib_id, vm_name,
vmtx_item_name)
self.client.local_library_service.publish(pub_lib_id)
assert self.verify_vmtx_sync(sub_lib, vmtx_item_id)
def create_subscription_from_existing_subscribed_library(self):
"""
Sample code for converting existing Subscribed library
to use a VMTX subscription
"""
# Create a published library and get its publish URL
pub_lib_name = "pub_lib_existing_" + str(uuid.uuid4())
pub_lib = self.create_published_library(pub_lib_name)
self.pub_libs_to_clean.append(pub_lib.id)
pub_lib_url = pub_lib.publish_info.publish_url
# Create a subscribed library
sub_lib_name = "sub_lib_existing_" + str(uuid.uuid4())
sub_lib = self.create_subscribed_library(pub_lib_url, sub_lib_name)
self.create_subscription_for_existing_subscribed_library(
pub_lib.id, sub_lib.id)
# - Create a VMTX item on the published library
# - Push-synchronize the subscription and verify the sync
vm_name = "sample_vm_existing_" + str(uuid.uuid4())
vmtx_item_name = "sample_vmtx_item_existing_" + str(uuid.uuid4())
vmtx_item_id = self.create_vmtx_item(pub_lib.id, vm_name,
vmtx_item_name)
self.client.local_library_service.publish(pub_lib.id)
assert self.verify_vmtx_sync(sub_lib, vmtx_item_id)
def create_vmtx_item(self, pub_lib_id, vm_name, vmtx_item_name):
# Upload OVF, create a VM, and use that VM to create a VMTX item
ovf_item_id = self.create_ovf_template_item(pub_lib_id)
source_vmtx_vm_id = self.create_vm(ovf_item_id, vm_name)
self.vms_to_clean.append(source_vmtx_vm_id)
vmtx_item_id = self.create_vmtx_item_from_vm(pub_lib_id,
source_vmtx_vm_id,
vmtx_item_name)
return vmtx_item_id
def create_published_library(self, pub_lib_name):
pub_info = PublishInfo()
pub_info.published = True
# VMTX sync needs the authentication to be turned off
pub_info.authentication_method = PublishInfo.AuthenticationMethod.NONE
pub_spec = LibraryModel()
pub_spec.name = pub_lib_name
pub_spec.description = "Sample Published library"
pub_spec.publish_info = pub_info
pub_spec.type = pub_spec.LibraryType.LOCAL
pub_spec.storage_backings = self.storage_backings
pub_lib_id = self.client.local_library_service.create(
create_spec=pub_spec, client_token=generate_random_uuid())
print("Published library created, id: {0}".format(pub_lib_id))
pub_lib = self.client.library_service.get(pub_lib_id)
return pub_lib
def create_subscribed_library(self, pub_lib_url, sub_lib_name):
# Build the subscription information using the publish URL of the published
# library
sub_info = SubscriptionInfo()
sub_info.authentication_method = SubscriptionInfo.AuthenticationMethod.NONE
# on_demand = False for library and item level publish
# on_demand = True for only item level publish, the library level
# publish will only sync the item metadata
sub_info.on_demand = False
sub_info.automatic_sync_enabled = True
sub_info.subscription_url = pub_lib_url
# Build the specification for the subscribed library
sub_spec = LibraryModel()
sub_spec.name = sub_lib_name
sub_spec.type = sub_spec.LibraryType.SUBSCRIBED
sub_spec.subscription_info = sub_info
sub_spec.storage_backings = self.storage_backings
sub_lib_id = self.client.subscribed_library_service.create(
create_spec=sub_spec, client_token=generate_random_uuid())
self.sub_libs_to_clean.append(sub_lib_id)
print("Subscribed library created, id: {0}".format(sub_lib_id))
sub_lib = self.client.subscribed_library_service.get(sub_lib_id)
return sub_lib
def create_subscription_new(self, pub_lib_id, sub_lib_name):
# Create a new subscription. Such subscription is created on the published
# library, and can be later used for a push-sync
#
# spec
# +--subscribed_library
# +--target: CREATE_NEW
# +--subscribed_library: DO NOT SPECIFY as this is new
# +--new_subscribed_library
# +--name, description, automatic_sync_enabled, on_demand
# +--location: LOCAL/REMOTE
# +--subscribed_library_vcenter: (VcenterInfo) DO NOT SPECIFY for location=LOCAL
# +--placement:
# +--Resource pool and folder for the VM
# +--network for the VM
client_token = str(uuid.uuid4())
spec = Subscriptions.CreateSpec()
subscribed_library = Subscriptions.CreateSpecSubscribedLibrary()
subscribed_library.location = Subscriptions.Location.LOCAL
subscribed_library.target = \
Subscriptions.CreateSpecSubscribedLibrary.Target.CREATE_NEW
new_subscribed_library = Subscriptions.CreateSpecNewSubscribedLibrary()
new_subscribed_library.name = sub_lib_name
new_subscribed_library.description = "Sample subscribed library"
backing = StorageBacking(StorageBacking.Type.DATASTORE,
self.datastore_id)
new_subscribed_library.storage_backings = [backing]
new_subscribed_library.automatic_sync_enabled = False
# on_demand = False for library and item level publish
# on_demand = True for only item level publish, the library level
# publish will only sync the item metadata
new_subscribed_library.on_demand = False
subscribed_library.new_subscribed_library = new_subscribed_library
placement = Subscriptions.CreateSpecPlacement()
placement.resource_pool = self.resource_pool_id
placement.folder = self.folder_id
# Setting network to null implies that the subscription will use the
# same network as the source VM
# Warning - this may lead to failure if the same network is not
# available to the subscriber
placement.network = None
subscribed_library.placement = placement
spec.subscribed_library = subscribed_library
subscription_id = self.client.subscriptions.create(
pub_lib_id, spec, client_token)
print("Subscription created, id: {0}".format(subscription_id))
return subscription_id
def create_subscription_for_existing_subscribed_library(
self, pub_lib_id, sub_lib_id):
# Create a subscription for an existing subscribed library. This subscription
# and can be later used for a push-sync to that subscribed library
#
# spec
# +--subscribed_library
# +--target: USE_EXISTING
# +--subscribed_library: ID of existing subscribed library
# +--new_subscribed_library: DO NOT SPECIFY for target=USE_EXISTING
# +--location: LOCAL/REMOTE
# +--subscribed_library_vcenter: (VcenterInfo) DO NOT SPECIFY from location=LOCAL
# +--placement:
# +--Resource pool and folder for the VM
# +--network for the VM
client_token = str(uuid.uuid4())
spec = Subscriptions.CreateSpec()
subscribed_library = Subscriptions.CreateSpecSubscribedLibrary()
subscribed_library.target = \
Subscriptions.CreateSpecSubscribedLibrary.Target.USE_EXISTING
subscribed_library.subscribed_library = sub_lib_id
subscribed_library.location = "LOCAL"
placement = Subscriptions.CreateSpecPlacement()
placement.resource_pool = self.resource_pool_id
placement.folder = self.folder_id
# Setting network to null implies that the subscription will use the
# same network as the source VM
# Warning - this may lead to failure if the same network is not
# available to the subscriber
placement.network = None
subscribed_library.placement = placement
spec.subscribed_library = subscribed_library
subscription_id = self.client.subscriptions.create(
pub_lib_id, spec, client_token)
print("Subscription created id: {0}".format(subscription_id))
return subscription_id
def create_ovf_template_item(self, library_id):
# Create an OVF item
ovf_item_id = self.helper.create_library_item(
library_id=library_id,
item_name='sample-ovf-item',
item_description='Sample OVF template',
item_type='ovf')
print('Library item created id: {0}'.format(ovf_item_id))
# Upload a VM template to the CL
ovf_files_map = self.helper.get_ovf_files_map(
ClsApiHelper.SIMPLE_OVF_RELATIVE_DIR)
self.helper.upload_files(library_item_id=ovf_item_id,
files_map=ovf_files_map)
return ovf_item_id
def create_vm(self, ovf_item_id, vm_name):
# Deploy a VM using the given ovf template
deployment_target = LibraryItem.DeploymentTarget(
resource_pool_id=self.resource_pool_id)
ovf_summary = self.client.ovf_lib_item_service.filter(
ovf_library_item_id=ovf_item_id, target=deployment_target)
vm_id = self.deploy_ovf_template(ovf_item_id, ovf_summary,
deployment_target, vm_name)
print("Virtual Machine created, id: {0}".format(vm_id))
return vm_id
def deploy_ovf_template(self, lib_item_id, ovf_summary, deployment_target,
vm_name):
# Build the deployment spec
deployment_spec = LibraryItem.ResourcePoolDeploymentSpec(
name=vm_name,
annotation=ovf_summary.annotation,
accept_all_eula=True)
# Deploy the ovf template
result = self.client.ovf_lib_item_service.deploy(
lib_item_id,
deployment_target,
deployment_spec,
client_token=generate_random_uuid())
if result.succeeded:
vm_id = result.resource_id.id
return vm_id
else:
print('Deployment failed.')
for error in result.error.errors:
print('OVF error: {}'.format(error.message))
raise Exception('OVF deploy failed.')
def create_vmtx_item_from_vm(self, library_id, source_vm_id,
vmtx_item_name):
# Create a VMTX item using the given VM as source
create_spec = VmtxLibraryItem.CreateSpec()
create_spec.source_vm = source_vm_id
create_spec.library = library_id
create_spec.name = vmtx_item_name
create_spec.description = 'sample-vmtx-description'
create_spec.placement = VmtxLibraryItem.CreatePlacementSpec()
create_spec.placement.resource_pool = self.resource_pool_id
vmtx_item_id = self.client.vmtx_service.create(create_spec)
print("VMTX item created id: {0}".format(vmtx_item_id))
return vmtx_item_id
def verify_vmtx_sync(self, sub_lib, vmtx_item_id):
# Wait until the VMTX item in the subscription is synchronized with
# the one in the published library
start_time = time.time()
while time.time() - start_time < self.SYNC_TIMEOUT_SEC:
sub_item_ids = self.client.library_item_service.list(sub_lib.id)
# Only vmtx item will be synced using the push mechanism, so check
# the length to be one
if len(sub_item_ids) == 1:
source_id = self.client.library_item_service.get(
sub_item_ids[0]).source_id
# Verify that the source for the VMTX item in the subscribed
# library is the VMTX item in the published library
if source_id == vmtx_item_id:
return True
else:
print("VMTX source item id mismatch")
return False
# Give some more time for sync
time.sleep(1)
print("Timed out while waiting for sync")
return False
def _cleanup(self):
for lib_id in self.pub_libs_to_clean:
print("deleting published library: {0}".format(lib_id))
self.client.local_library_service.delete(lib_id)
for lib_id in self.sub_libs_to_clean:
print("deleting subscribed library: {0}".format(lib_id))
self.client.subscribed_library_service.delete(lib_id)
for vm_id in self.vms_to_clean:
vm_obj = get_obj_by_moId(self.servicemanager.content,
[vim.VirtualMachine], vm_id)
delete_object(self.servicemanager.content, vm_obj)
class SignedOvaImport(SampleBase):
"""
Demonstrates the workflow to import an OVA file into the content library,
as an OVF library item.
Note: the workflow needs an existing VC DS with available storage.
"""
#SIGNED_OVA_FILENAME = 'nostalgia-signed.ova'
# SIGNED_OVA_FILENAME = 'IoTC_VA-2.0.2.12565-32613116_OVF10.ova'
# SIGNED_OVA_RELATIVE_DIR = '../resources/signedOvaWithCertWarning/'
def __init__(self):
SampleBase.__init__(self, self.__doc__)
self.servicemanager = None
self.client = None
self.helper = None
self.datastore_name = None
#self.lib_name = 'Pulse_Content_sb'
self.local_lib_id = None
self.lib_item_name = None
self.lib_item_id = None
def _options(self):
self.argparser.add_argument('-datastorename',
'--datastorename',
required=True,
help='The name of the datastore.')
self.argparser.add_argument(
'-libitemname',
'--libitemname',
required=True,
help='The name of the Library Item Inside Content Library.')
self.argparser.add_argument(
'-locallibid',
'--locallibid',
required=True,
help='The ID of Local Library to which the OVA has to be linked.')
self.argparser.add_argument('-ovaname',
'--ovaname',
required=True,
help='Name of the OVA.')
self.argparser.add_argument('-ovapath',
'--ovapath',
required=True,
help='Path to the OVA.')
def _setup(self):
self.servicemanager = self.get_service_manager()
self.client = ClsApiClient(self.servicemanager)
self.helper = ClsApiHelper(self.client, self.skip_verification)
def _execute(self):
# Build the storage backing for the library to be created using given datastore name
self.datastore_name = self.args.datastorename
storage_backings = self.helper.create_storage_backings(
service_manager=self.servicemanager,
datastore_name=self.datastore_name)
#Assigning Library Item Name
self.lib_item_name = self.args.libitemname
# Create a local content library backed by the VC datastore using vAPIs
#self.local_lib_id = self.helper.create_local_library(storage_backings, self.lib_name)
self.local_lib_id = self.args.locallibid
# Create a new library item in the content library for uploading the files
self.lib_item_id = self.helper.create_library_item(
library_id=self.local_lib_id,
item_name=self.lib_item_name,
item_description='Pulse OVA',
item_type='ovf')
print('Library item created. ID: {0}'.format(self.lib_item_id))
#Assigning OVA name and Path
self.SIGNED_OVA_FILENAME = self.args.ovaname
self.SIGNED_OVA_RELATIVE_DIR = self.args.ovapath
ova_file_map = self.helper.get_ova_file_map(
self.SIGNED_OVA_RELATIVE_DIR,
local_filename=self.SIGNED_OVA_FILENAME)
# Create a new upload session for uploading the files
# To ignore expected warnings and skip preview info check,
# you can set create_spec.warning_behavior during session creation
session_id = self.client.upload_service.create(
create_spec=UpdateSessionModel(library_item_id=self.lib_item_id),
client_token=generate_random_uuid())
self.helper.upload_files_in_session(ova_file_map, session_id)
# Wait for terminal preview state and obtain preview warnings if any
#self.wait_for_terminal_preview_state(session_id, AVAILABLE)
self.wait_for_terminal_preview_state(session_id, AVAILABLE)
session = self.client.upload_service.get(session_id)
preview_info = session.preview_info
# Collect generated preview warning types
preview_warning_types = []
print('Preview warnings for the session are the following:')
for preview_warning in preview_info.warnings:
print(preview_warning.message.default_message)
preview_warning_types.append(preview_warning.type)
# Ignore preview warnings on session
ignore_warning_behaviors = []
for warning_type in preview_warning_types:
warning_behavior = WarningBehavior(type=warning_type, ignored=True)
ignore_warning_behaviors.append(warning_behavior)
self.client.upload_service.update(
session_id,
update_spec=UpdateSessionModel(
warning_behavior=ignore_warning_behaviors))
print(
'All preview warnings are ignored, proceeding to complete the session'
)
self.client.upload_service.complete(session_id)
self.client.upload_service.delete(session_id)
print(
'Uploaded ova file as an ovf template to library item {0}'.format(
self.lib_item_id))
def wait_for_terminal_preview_state(self,
session_id,
expected_terminal_preview_state,
timeout_sec=300):
"""
Periodically checks update session for preview state to reach a terminal state.
:param session_id: ID of update session for which preview state is checked
:param expected_terminal_preview_state: expected terminal preview state
:param timeout_sec: number of seconds to wait before timing out
"""
preview_state = None
start_time = time.time()
terminal_preview_state_list = [NOT_APPLICABLE, AVAILABLE]
while (time.time() - start_time) < timeout_sec:
session = self.client.upload_service.get(session_id)
if session.state == 'ERROR':
raise Exception(
'Session is in error state, error message: {}'.format(
session.error_message))
preview_state = session.preview_info.state
# check if preview state is in one of the terminal states
if preview_state not in terminal_preview_state_list:
time.sleep(1)
else:
break
if preview_state != expected_terminal_preview_state:
raise Exception(
'Preview state did not reach expected {} state, actual preview state: '
'{}'.format(expected_terminal_preview_state, preview_state))
def _cleanup(self):
if self.local_lib_id:
self.client.local_library_service.delete(
library_id=self.local_lib_id)
print('Deleted library ID: {0}'.format(self.local_lib_id))
class CaptureVMTemplateToContentLibrary(SampleBase):
"""
Demonstrates the workflow to capture a virtual machine into a content library.
Note: The sample needs an existing virtual machine to capture.
"""
def __init__(self):
SampleBase.__init__(self, self.__doc__)
self.servicemanager = None
self.datastore_name = None
self.datastore_id = None
self.cl_name = "LocalLibraryToCapture"
self.vm_name = None
self.vm_template_name = 'CapturedOvf'
self.vm_template_description = 'Captured OVF description'
self.deployable_resource_type = 'VirtualMachine' # Substitute 'VirtualApp' for vApp
self.content_library = None
self.library_item_id = None
def _options(self):
self.argparser.add_argument('-datastorename',
'--datastorename',
required=True,
help='The name of the datastore for'
' content library backing (of type vmfs)')
self.argparser.add_argument('-vmname',
'--vmname',
required=True,
help='Name of the VM to be captured')
def _setup(self):
self.datastore_name = self.args.datastorename
assert self.datastore_name is not None
self.vm_name = self.args.vmname
assert self.vm_name is not None
if self.servicemanager is None:
self.servicemanager = self.get_service_manager()
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)
def _execute(self):
storage_backings = self.helper.create_storage_backings(
self.servicemanager, self.datastore_name)
print('Creating Content Library')
# Create a content library
library_id = self.helper.create_local_library(storage_backings,
self.cl_name)
self.content_library = self.client.local_library_service.get(
library_id)
vm_id = get_vm(self.vsphere_client, self.vm_name)
assert vm_id is not None
param = self.create_capture_param(self.content_library,
self.vm_template_name,
self.vm_template_description)
self.library_item_id = self.capture_source_vm(vm_id, param)
assert self.library_item_id is not None
assert self.client.library_item_service.get(
self.library_item_id) is not None
print(
'The VM id : {0} is captured as vm template library item id : {1}'.
format(vm_id, self.library_item_id))
def capture_source_vm(self, vm_id, param):
source = LibraryItem.DeployableIdentity(self.deployable_resource_type,
vm_id)
result = self.client.ovf_lib_item_service.create(
source,
param["target"],
param["spec"],
client_token=generate_random_uuid())
return result.ovf_library_item_id
def create_capture_param(self, library, name, description):
spec = LibraryItem.CreateSpec(name=name, description=description)
target = LibraryItem.CreateTarget(library_id=library.id,
library_item_id=None)
return {"target": target, "spec": spec}
def _cleanup(self):
# delete the local library.
if self.content_library is not None:
self.client.local_library_service.delete(
library_id=self.content_library.id)
print('Deleted Library Id: {0}'.format(self.content_library.id))
class IsoMount(SampleBase):
"""
Demonstrates the content library ISO item mount and
unmount workflow via the mount and unmount APIs from the
ISO service.
"""
ISO_FILENAME = 'test.iso'
def __init__(self):
SampleBase.__init__(self, self.__doc__)
self.servicemanager = None
self.client = None
self.datastore_name = None
self.lib_name = "iso-demo-lib"
self.local_library = None
self.iso_item_name = "iso-demo-lib-item"
self.vm_name = None
def _options(self):
self.argparser.add_argument(
'-datastorename',
'--datastorename',
required=True,
help='The name of a datastore (of type vmfs) that is'
' accessible to the vm specified with --vmname.')
self.argparser.add_argument(
'-vmname',
'--vmname',
required=True,
help='The name of the vm where iso will be mounted. '
'The vm needs to be already created on the vCenter')
def _setup(self):
self.datastore_name = self.args.datastorename
assert self.datastore_name is not None
self.vm_name = self.args.vmname
assert self.vm_name is not None
self.servicemanager = self.get_service_manager()
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)
def _execute(self):
storage_backings = self.helper.create_storage_backings(
self.servicemanager, self.datastore_name)
library_id = self.helper.create_local_library(storage_backings,
self.lib_name)
self.local_library = self.client.local_library_service.get(library_id)
library_item_id = self.helper.create_iso_library_item(
library_id, self.iso_item_name, self.ISO_FILENAME)
vm_id = get_vm(self.vsphere_client, self.vm_name)
assert vm_id is not None
# Mount the iso item as a CDROM device
device_id = self.client.iso_service.mount(library_item_id, vm_id)
assert device_id is not None
print('Mounted library item {0} on vm {1} at device {2}'.format(
self.iso_item_name, self.vm_name, device_id))
# Unmount the CDROM
self.client.iso_service.unmount(vm_id, device_id)
print('Unmounted library item {0} from vm {1} mounted at device {2}'.
format(self.iso_item_name, self.vm_name, device_id))
def _cleanup(self):
if self.local_library:
self.client.local_library_service.delete(
library_id=self.local_library.id)
print('Deleted Library Id: {0}'.format(self.local_library.id))
class ContentUpdate(SampleBase):
"""
Demonstrates the workflow of updating a content library item.
Note: the workflow needs an existing datastore (of type vmfs) with available storage.
"""
ISO_FILE_1 = 'test.iso'
ISO_FILE_2 = 'test-2.iso'
ISO_ITEM_NAME = 'test'
def __init__(self):
SampleBase.__init__(self, self.__doc__)
self.servicemanager = None
self.client = None
self.helper = None
self.datastore_name = None
self.lib_name = "demo-lib"
self.local_library = None
def _options(self):
self.argparser.add_argument('-datastorename',
'--datastorename',
help='The name of the datastore where '
'the library will be created.')
def _setup(self):
self.datastore_name = self.args.datastorename
assert self.datastore_name is not None
self.servicemanager = self.get_service_manager()
self.client = ClsApiClient(self.servicemanager)
self.helper = ClsApiHelper(self.client, self.skip_verification)
def _execute(self):
storage_backings = self.helper.create_storage_backings(
self.servicemanager, self.datastore_name)
library_id = self.helper.create_local_library(storage_backings,
self.lib_name)
self.local_library = self.client.local_library_service.get(library_id)
self.delete_and_upload_scenario(library_id)
self.replace_scenario(library_id)
def replace_scenario(self, library_id):
"""
:param library_id: the Iso item will be created, and then replaced in this library
:return: None
Content update scenario 2:
Update ISO library item by creating an update session for the
item, then adding the new ISO file using the same session file
name into the update session, which will replace the existing
ISO file upon session complete.
"""
iso_item_id = self.helper.create_library_item(
library_id=library_id,
item_name=self.ISO_ITEM_NAME,
item_description='Sample iso file',
item_type='iso')
print('ISO Library item version (on creation) {0}:'.format(
self.get_item_version(iso_item_id)))
iso_files_map = self.helper.get_iso_file_map(
item_filename=self.ISO_FILE_1, disk_filename=self.ISO_FILE_1)
self.helper.upload_files(library_item_id=iso_item_id,
files_map=iso_files_map)
original_version = self.get_item_version(iso_item_id)
print('ISO Library item version (on original content upload) {0}:'.
format(original_version))
session_id = self.client.upload_service.create(
create_spec=UpdateSessionModel(library_item_id=iso_item_id),
client_token=generate_random_uuid())
# Use the same item filename (update endpoint, as it's a replace scenario)
iso_files_map = self.helper.get_iso_file_map(
item_filename=self.ISO_FILE_1, disk_filename=self.ISO_FILE_2)
self.helper.upload_files_in_session(iso_files_map, session_id)
self.client.upload_service.complete(session_id)
self.client.upload_service.delete(session_id)
updated_version = self.get_item_version(iso_item_id)
print('ISO Library item version (after content update): {0}'.format(
updated_version))
assert updated_version > original_version, 'content update should increase the version'
def delete_and_upload_scenario(self, library_id):
"""
:param library_id: the OVF item will be created and updated in this library
:return: None
Content update scenario 1:
Update OVF library item by creating an update session for the
OVF item, removing all existing files in the session, then
adding all new files into the same update session, and completing
the session to finish the content update.
"""
# Create a new library item in the content library for uploading the files
ovf_item_id = self.helper.create_library_item(
library_id=library_id,
item_name='demo-ovf-item',
item_description='Sample simple VM template',
item_type='ovf')
assert ovf_item_id is not None
print('Library item created id: {0}'.format(ovf_item_id))
print('OVF Library item version (at creation) {0}:'.format(
self.get_item_version(ovf_item_id)))
# Upload a VM template to the CL
ovf_files_map = self.helper.get_ovf_files_map(
ClsApiHelper.SIMPLE_OVF_RELATIVE_DIR)
self.helper.upload_files(library_item_id=ovf_item_id,
files_map=ovf_files_map)
print('Uploaded ovf and vmdk files to library item {0}'.format(
ovf_item_id))
original_version = self.get_item_version(ovf_item_id)
print('OVF Library item version (on original content upload): {0}'.
format(original_version))
# Create a new session and perform content update
session_id = self.client.upload_service.create(
create_spec=UpdateSessionModel(library_item_id=ovf_item_id),
client_token=generate_random_uuid())
existing_files = self.client.upload_file_service.list(session_id)
for file in existing_files:
print('deleting {0}'.format(file.name))
self.client.upload_file_service.remove(session_id, file.name)
ovf_files_map = self.helper.get_ovf_files_map(
ovf_location=ClsApiHelper.PLAIN_OVF_RELATIVE_DIR)
self.helper.upload_files_in_session(ovf_files_map, session_id)
self.client.upload_service.complete(session_id)
self.client.upload_service.delete(session_id)
updated_version = self.get_item_version(ovf_item_id)
print('OVF Library item version (after content update): {0}'.format(
updated_version))
assert updated_version > original_version, 'content update should increase the version'
def get_item_version(self, item_id):
ovf_item_model = self.client.library_item_service.get(item_id)
pre_update_version = ovf_item_model.content_version
return pre_update_version
def _cleanup(self):
if self.local_library:
self.client.local_library_service.delete(
library_id=self.local_library.id)
print('Deleted Library Id: {0}'.format(self.local_library.id))
class CreateVmTemplate(SampleBase):
"""
Demonstrates how to create a library item containing a virtual machine
template from a virtual machine.
Prerequisites:
- A virtual machine
- A datacenter
- A resource pool
- A datastore
"""
def __init__(self):
SampleBase.__init__(self, self.__doc__)
self.servicemanager = None
self.client = None
self.helper = None
self.vm_name = None
self.datastore_name = None
self.library_name = 'demo-vmtx-lib'
self.item_name = None
self.item_id = None
def _options(self):
self.argparser.add_argument('-vmname',
'--vmname',
required=True,
help='The name of the source VM from '
'which to create a library item')
self.argparser.add_argument('-datacentername',
'--datacentername',
required=True,
help='The name of the datacenter in which '
'to place the VM template')
self.argparser.add_argument('-resourcepoolname',
'--resourcepoolname',
required=True,
help='The name of the resource pool in '
'the datacenter in which to place '
'the VM template')
self.argparser.add_argument('-datastorename',
'--datastorename',
required=True,
help='The name of the datastore in which '
'to create a library and VM template')
self.argparser.add_argument('-itemname',
'--itemname',
help='The name of the library item to '
'create. The item will contain a '
'VM template.')
def _setup(self):
# Required arguments
self.vm_name = self.args.vmname
self.datacenter_name = self.args.datacentername
self.resource_pool_name = self.args.resourcepoolname
self.datastore_name = self.args.datastorename
# Optional arguments
self.item_name = (self.args.itemname
if self.args.itemname else rand('vmtx-item-'))
self.servicemanager = self.get_service_manager()
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)
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 _cleanup(self):
if self.library_id:
self.client.local_library_service.delete(self.library_id)
print('Deleted library ID: {0}'.format(self.library_id))