def add_resource_pools_to_provider_vdc(self, pvdc_name,
resource_pool_names):
"""Add Resource Pools to a Provider Virtual Datacenter.
:param str pvdc_name: name of the Provider Virtual Datacenter.
:param list resource_pool_names: list or resource pool names.
:return: an object containing EntityType.TASK XML data which represents
the asynchronous task that is adding Resource Pools to the PVDC.
:rtype: lxml.objectify.ObjectifiedElement
"""
provider_vdc = self.get_res_by_name(ResourceType.PROVIDER_VDC,
pvdc_name)
pvdc_resource = self.client.get_resource(provider_vdc.get('href'))
pvdc_ext_href = get_admin_extension_href(pvdc_resource.get('href'))
pvdc_ext_resource = self.client.get_resource(pvdc_ext_href)
vc_name = pvdc_ext_resource.VimServer.get('name')
vc_href = pvdc_ext_resource.VimServer.get('href')
rp_morefs = self.get_resource_pool_morefs(vc_name, vc_href,
resource_pool_names)
payload = E_VMEXT.UpdateResourcePoolSetParams()
for rp_moref in rp_morefs:
add_item = E_VMEXT.AddItem()
add_item.append(
E_VMEXT.VimServerRef(type=EntityType.VIRTUAL_CENTER.value,
href=vc_href))
add_item.append(E_VMEXT.MoRef(rp_moref))
add_item.append(E_VMEXT.VimObjectType('RESOURCE_POOL'))
payload.append(add_item)
return self.client.post_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.UPDATE_RESOURCE_POOLS,
media_type=EntityType.RES_POOL_SET_UPDATE_PARAMS.value,
contents=payload)
def enable_extension(self, name, enabled=True, namespace=None):
"""Enable or disable an API extension service.
:param str name: the name of the extension service whose we want to
enable/disable.
:param str namespace: the namespace of the extension service. If not
specified (i.e. = None), we will use the value passed in the
`name` parameter.
:param bool enabled: flag to enable or disable the extension.
:return: object containing EntityType.ADMIN_SERVICE XML data
representing the updated API extension.
:rtype: lxml.objectify.ObjectifiedElement
"""
record = self.client.get_typed_query(
ResourceType.ADMIN_SERVICE,
qfilter='name==%s;namespace==%s' %
(name, namespace if namespace else name),
query_result_format=QueryResultFormat.RECORDS).find_unique()
params = E_VMEXT.Service({'name': name})
params.append(E_VMEXT.Namespace(record.get('namespace')))
params.append(E_VMEXT.Enabled('true' if enabled else 'false'))
params.append(E_VMEXT.RoutingKey(record.get('routingKey')))
params.append(E_VMEXT.Exchange(record.get('exchange')))
self.client.put_resource(record.get('href'), params, None)
return record.get('href')
def update_extension(self, name, namespace=None, routing_key=None,
exchange=None, description=None):
"""Update properties for an existing API extension.
:param str name: name of the API extension.
:param str namespace: namespace of the API extension.
:param str routing_key: AMQP routing key to use for the extension.
:param str exchange: AMQP exchange to use for the extension.
:return: href of the API extension.
:rtype: str
:raises MissingRecordException: if an extension with the given name and
namespace couldn't be found.
:raise MultipleRecordsException: if more than one service with the
given name and namespace are found.
"""
record = self._get_extension_record(name=name,
namespace=namespace,
format=QueryResultFormat.RECORDS)
params = E_VMEXT.Service({'name': name})
description = description or record.get('description')
if description is not None:
params.append(E.Description(description))
params.append(E_VMEXT.Namespace(record.get('namespace')))
params.append(E_VMEXT.Enabled(record.get('enabled')))
params.append(E_VMEXT.RoutingKey(
routing_key if routing_key else record.get('routingKey')))
params.append(E_VMEXT.Exchange(
exchange if exchange else record.get('exchange')))
self.client.put_resource(record.get('href'), params, None)
return record.get('href')
def enable_extension(self, name, enabled=True, namespace=None):
"""Enable or disable an API extension service.
:param str name: the name of the extension service whose we want to
enable/disable.
:param str namespace: the namespace of the extension service. If not
specified (i.e. = None), we will use the value passed in the
`name` parameter.
:param bool enabled: flag to enable or disable the extension.
:return: href of the service being enabled/disabled.
:rtype: str
:raises MissingRecordException: if a service with the given name and
namespace couldn't be found.
:raise MultipleRecordsException: if more than one service with the
given name and namespace are found.
"""
record = self._get_extension_record(name=name,
namespace=namespace,
format=QueryResultFormat.RECORDS)
params = E_VMEXT.Service({'name': name})
params.append(E_VMEXT.Namespace(record.get('namespace')))
params.append(E_VMEXT.Enabled('true' if enabled else 'false'))
params.append(E_VMEXT.RoutingKey(record.get('routingKey')))
params.append(E_VMEXT.Exchange(record.get('exchange')))
self.client.put_resource(record.get('href'), params, None)
return record.get('href')
def update(self,
name,
new_name=None,
url=None,
username=None,
password=None):
"""Update the connected NSX-T Manager.
:param str name: name of the NSX-T Manager.
:param str new_name: name of the NSX-T Manager
:param str url: NSX-T Manager URL Endpoint
:param str username: NSX-T Manager user name
:param str password: NSX-T Manager password
:rtype: lxml.objectify.ObjectifiedElement
"""
nsxt_manager = self.get(name)
new_name = new_name or name
nsxtManagerParams = E_VMEXT.NsxTManager(name=new_name)
if username:
nsxtManagerParams['Username'] = E_VMEXT.Username(username)
if password:
nsxtManagerParams['Password'] = E_VMEXT.Password(password)
if url:
nsxtManagerParams['Url'] = E_VMEXT.Url(url)
return self.client.put_linked_resource(nsxt_manager, RelationType.EDIT,
EntityType.NSXT_MANAGER.value,
nsxtManagerParams)
def pvdc_del_storage_profile(self, pvdc_name, storage_profile_names):
"""Delete storage profiles from a PVDC.
:param str pvdc_name: name of the Provider Virtual Datacenter.
:param list storage_profile_names: list of storage profile names.
:return: an object containing EntityType.TASK XML data which represents
the async task that is deleting storage profiles from the PVDC.
:rtype: lxml.objectify.ObjectifiedElement
:raises: EntityNotFoundException: if any storage_profile_name is not
associated with the specified PVDC.
"""
provider_vdc, pvdc_ext_href, pvdc_ext_resource = self.get_pvdc(
pvdc_name)
sp_map = {}
if hasattr(pvdc_ext_resource,
'{' + NSMAP['vcloud'] + '}StorageProfiles'):
stor_profs = \
pvdc_ext_resource['{' + NSMAP['vcloud'] + '}StorageProfiles']
if hasattr(stor_profs,
'{' + NSMAP['vcloud'] + '}ProviderVdcStorageProfile'):
for stor_prof in stor_profs.ProviderVdcStorageProfile:
sp_map[stor_prof.get('name')] = stor_prof.get('href')
payload = E_VMEXT.UpdateProviderVdcStorageProfiles()
for sp_name in storage_profile_names:
if sp_name not in sp_map.keys():
raise EntityNotFoundException(
'storage profile: \'%s\' not in this PVDC' % sp_name)
sp_href = sp_map[sp_name]
payload.append(E_VMEXT.RemoveStorageProfile(href=sp_href))
sp_resource = self.client.get_resource(sp_href)
links = get_links(
resource=sp_resource,
rel=RelationType.EDIT,
media_type=EntityType.VMW_PVDC_STORAGE_PROFILE.value)
num_links = len(links)
if num_links == 1:
if hasattr(sp_resource, '{' + NSMAP['vcloud'] + '}Units'):
units = \
sp_resource['{' + NSMAP['vcloud'] + '}Units']
disable_payload = \
E_VMEXT.VMWProviderVdcStorageProfile(
name=sp_name,
href=sp_href
)
disable_payload.append(E.Enabled('false'))
disable_payload.append(units)
self.client.put_linked_resource(
resource=sp_resource,
rel=RelationType.EDIT,
media_type=EntityType.VMW_PVDC_STORAGE_PROFILE.value,
contents=disable_payload)
return self.client.post_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.EDIT,
media_type=EntityType.UPDATE_PROVIDER_VDC_STORAGE_PROFILES.value,
contents=payload)
def __create_vimobj_ref(self, vc_href, pg_moref, pg_type):
"""Creates the VimObjectRef."""
vim_object_ref = E_VMEXT.VimObjectRef()
vim_object_ref.append(E_VMEXT.VimServerRef(href=vc_href))
vim_object_ref.append(E_VMEXT.MoRef(pg_moref))
vim_object_ref.append(E_VMEXT.VimObjectType(pg_type))
return vim_object_ref
def add_api_filters_to_service(self, name, patterns, namespace=None):
"""."""
ext_record = self._get_extension_record(
name=name, namespace=namespace,
format=QueryResultFormat.REFERENCES)
ext = self.client.get_resource(uri=ext_record.get('href'))
for pattern in patterns:
api_filter = E_VMEXT.ApiFilter(E_VMEXT.UrlPattern(pattern.strip()))
self.client.post_linked_resource(
resource=ext, rel=RelationType.ADD,
media_type=EntityType.API_FILTER.value, contents=api_filter)
def enable_extension(self, name, enabled=True):
record = self.client.get_typed_query(
self.TYPE_NAME,
equality_filter=('name', name),
query_result_format=QueryResultFormat.RECORDS).find_unique()
params = E_VMEXT.Service({'name': name})
params.append(E_VMEXT.Namespace(record.get('namespace')))
params.append(E_VMEXT.Enabled('true' if enabled else 'false'))
params.append(E_VMEXT.RoutingKey(record.get('routingKey')))
params.append(E_VMEXT.Exchange(record.get('exchange')))
self.client.put_resource(record.get('href'), params, None)
return record.get('href')
def _to_settings(self, config, password):
settings = E_VMEXT.AmqpSettings()
settings.append(E_VMEXT.AmqpHost(config['AmqpHost']))
settings.append(E_VMEXT.AmqpPort(config['AmqpPort']))
settings.append(E_VMEXT.AmqpUsername(config['AmqpUsername']))
settings.append(E_VMEXT.AmqpPassword(password))
settings.append(E_VMEXT.AmqpExchange(config['AmqpExchange']))
settings.append(E_VMEXT.AmqpVHost(config['AmqpVHost']))
settings.append(E_VMEXT.AmqpUseSSL(config['AmqpUseSSL']))
settings.append(E_VMEXT.AmqpSslAcceptAll(config['AmqpSslAcceptAll']))
settings.append(E_VMEXT.AmqpPrefix(config['AmqpPrefix']))
return settings
def add_extension(self, name, namespace, routing_key, exchange, patterns,
description=None):
"""Add an API extension service.
:param str name: name of the new API extension service.
:param str namespace: namespace of the new API extension service.
:param str routing_key: AMQP routing key to use with the extension.
:param str exchange: AMQP exchange to use with the extension.
:param list patterns: list of url API filters to register with the
extension.
:return: object containing EntityType.ADMIN_SERVICE XML data i.e. the
sparse representation of the API extension.
:rtype: lxml.objectify.ObjectifiedElement
"""
params = E_VMEXT.Service({'name': name})
if description is not None:
params.append(E.Description(description))
params.append(E_VMEXT.Namespace(namespace))
params.append(E_VMEXT.Enabled('true'))
params.append(E_VMEXT.RoutingKey(routing_key))
params.append(E_VMEXT.Exchange(exchange))
filters = E_VMEXT.ApiFilters()
for pattern in patterns:
filters.append(
E_VMEXT.ApiFilter(E_VMEXT.UrlPattern(pattern.strip())))
params.append(filters)
ext = self.client.get_extension()
ext_services = self.client.get_linked_resource(
ext, RelationType.DOWN, EntityType.EXTENSION_SERVICES.value)
return self.client.post_linked_resource(ext_services, RelationType.ADD,
EntityType.ADMIN_SERVICE.value,
params)
def add_extension(self, name, namespace, routing_key, exchange, patterns):
"""Add an API extension.
:param name: (str): The name of the new API extension service.
:param namespace: (str): The namespace of the new API extension
service.
:param routing_key: (str): AMQP routing key to use with the extension.
:param exchange: (str): AMQP exchange to use with the extension.
:param patterns: (str): URI API filters to register with the extension.
:return: (lxml.objectify.ObjectifiedElement): object containing
the sparse representation of the API extension.
"""
params = E_VMEXT.Service({'name': name})
params.append(E_VMEXT.Namespace(namespace))
params.append(E_VMEXT.Enabled('true'))
params.append(E_VMEXT.RoutingKey(routing_key))
params.append(E_VMEXT.Exchange(exchange))
filters = E_VMEXT.ApiFilters()
for pattern in patterns:
filters.append(
E_VMEXT.ApiFilter(E_VMEXT.UrlPattern(pattern.strip())))
params.append(filters)
ext = self.client.get_extension()
ext_services = self.client.get_linked_resource(
ext, RelationType.DOWN, EntityType.EXTENSION_SERVICES.value)
return self.client.post_linked_resource(ext_services, RelationType.ADD,
EntityType.ADMIN_SERVICE.value,
params)
def attach_resource_pools_to_provider_vdc(self, pvdc_name,
resource_pool_names):
"""Attach Resource Pools to a Provider Virtual Datacenter.
This function attaches one or more resource pools (RPs) to a
Provider Virtual Datacenter (PVDC).
Caveat: The current implementation of this function takes a list of RP
"basenames" as input. A basename is the last element of a full
pathname. For example, given a pathname /a/b/c, the basename of that
pathname is "c". Since RP names are only required to have unique
pathnames but not unique basenames, this function may not work
correctly if there are non-unique RP basenames. Therefore, in order to
use this function, all RP basenames must be unique. It is therefore up
to the user of this function to be aware of this limitation and name
their RPs appropriately. This limitation will be fixed in a future
version of this function.
:param str pvdc_name: name of the Provider Virtual Datacenter.
:param list resource_pool_names: list or resource pool names.
:return: an object containing EntityType.TASK XML data which represents
the asynchronous task that is adding Resource Pools to the PVDC.
:rtype: lxml.objectify.ObjectifiedElement
"""
provider_vdc = self.get_res_by_name(ResourceType.PROVIDER_VDC,
pvdc_name)
pvdc_resource = self.client.get_resource(provider_vdc.get('href'))
pvdc_ext_href = get_admin_extension_href(pvdc_resource.get('href'))
pvdc_ext_resource = self.client.get_resource(pvdc_ext_href)
vc_name = pvdc_ext_resource.VimServer.get('name')
vc_href = pvdc_ext_resource.VimServer.get('href')
rp_morefs = self.get_resource_pool_morefs(vc_name, vc_href,
resource_pool_names)
payload = E_VMEXT.UpdateResourcePoolSetParams()
for rp_moref in rp_morefs:
add_item = E_VMEXT.AddItem()
add_item.append(
E_VMEXT.VimServerRef(type=EntityType.VIRTUAL_CENTER.value,
href=vc_href))
add_item.append(E_VMEXT.MoRef(rp_moref))
add_item.append(E_VMEXT.VimObjectType('RESOURCE_POOL'))
payload.append(add_item)
return self.client.post_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.UPDATE_RESOURCE_POOLS,
media_type=EntityType.RES_POOL_SET_UPDATE_PARAMS.value,
contents=payload)
def attach_vcenter(self,
vc_server_name,
vc_server_host,
vc_admin_user,
vc_admin_pwd,
is_enabled,
vc_root_folder=None,
nsx_server_name=None,
nsx_host=None,
nsx_admin_user=None,
nsx_admin_pwd=None):
"""Register (attach) a VirtualCenter server (also known as VimServer).
:param str vc_server_name: vc server name (virtual center name).
:param str vc_server_host: FQDN or IP address of vc host.
:param str vc_admin_user: vc admin user.
:param str vc_admin_pwd: vc admin password.
:param str is_enabled: true if VC is to be enabled.
:param str vc_root_folder: vc root folder.
:param str nsx_server_name: NSX server name.
:param str nsx_host: FQDN or IP address of NSX host.
:param str nsx_admin_user: NSX admin user.
:param str nsx_admin_pwd: NSX admin password.
:return: an object containing REGISTER_VC_SERVER_PARAMS XML data that
represents the newly registered (attached) VimServer.
:rtype: lxml.objectify.ObjectifiedElement
"""
register_vc_server_params = E_VMEXT.RegisterVimServerParams()
vc_server = E_VMEXT.VimServer(name=vc_server_name)
vc_server.append(E_VMEXT.Username(vc_admin_user))
vc_server.append(E_VMEXT.Password(vc_admin_pwd))
vc_server_host_url = urlparse(vc_server_host)
if vc_server_host_url.netloc != '':
vc_server.append(E_VMEXT.Url(vc_server_host))
else:
vc_server.append(E_VMEXT.Url('https://' + vc_server_host + ':443'))
vc_server.append(E_VMEXT.IsEnabled(is_enabled))
if vc_root_folder is not None:
vc_server.append(E_VMEXT.rootFolder(vc_root_folder))
register_vc_server_params.append(vc_server)
if nsx_server_name is not None:
nsx_manager = E_VMEXT.ShieldManager(name=nsx_server_name)
nsx_manager.append(E_VMEXT.Username(nsx_admin_user))
nsx_manager.append(E_VMEXT.Password(nsx_admin_pwd))
nsx_host_url = urlparse(nsx_host)
if nsx_host_url.netloc != '':
nsx_manager.append(E_VMEXT.Url(nsx_host))
else:
nsx_manager.append(E_VMEXT.Url('https://' + nsx_host + ':443'))
register_vc_server_params.append(nsx_manager)
return self.client.\
post_linked_resource(resource=self.extension.get_resource(),
rel=RelationType.ADD,
media_type=EntityType.
REGISTER_VC_SERVER_PARAMS.value,
contents=register_vc_server_params)
def add(self, name, url, username, password):
"""Add NSX-T Manager with vCD.
:param str name: name of the NSX-T Manager.
:param str url: NSX-T Manager URL Endpoint
:param str username: NSX-T Manager user name
:param str password: NSX-T Manager password
:rtype: lxml.objectify.ObjectifiedElement
"""
nsxtManagerParams = E_VMEXT.NsxTManager(E_VMEXT.Username(username),
E_VMEXT.Password(password),
E_VMEXT.Url(url),
name=name)
return self.client.post_linked_resource(self.get_resource(),
RelationType.ADD,
EntityType.NSXT_MANAGER.value,
nsxtManagerParams)
def attach_vcenter(self,
vc_server_name,
vc_server_host,
vc_admin_user,
vc_admin_pwd,
nsx_server_name=None,
nsx_host=None,
nsx_admin_user=None,
nsx_admin_pwd=None,
is_enabled=None):
"""Register (attach) a VirtualCenter server (also known as VimServer).
:param: vc_server_name: (str): vc_server_name (VC name).
:param: vc_server_host: (str): FQDN or IP address of VC host.
:param: vc_admin_user: (str): vc_admin user.
:param: vc_admin_pwd: (str): vc_admin password.
:param: nsx_server_name: (str): NSX server name.
:param: nsx_host (str): FQDN or IP address of NSX host.
:param: nsx_admin_user: (str): NSX admin user.
:param: nsx_admin_pwd: (str): NSX admin password.
:return: A :class:lxml.objectify.StringElement object describing the
: newly registered (attached) VimServer.
"""
register_vc_server_params = E_VMEXT.RegisterVimServerParams()
vc_server = E_VMEXT.VimServer(name=vc_server_name)
vc_server.append(E_VMEXT.Username(vc_admin_user))
vc_server.append(E_VMEXT.Password(vc_admin_pwd))
vc_server.append(E_VMEXT.Url('https://' + vc_server_host + ':443'))
if is_enabled is not None:
vc_server.append(E_VMEXT.IsEnabled(is_enabled))
register_vc_server_params.append(vc_server)
if nsx_server_name is not None:
nsx_manager = E_VMEXT.ShieldManager(name=nsx_server_name)
nsx_manager.append(E_VMEXT.Username(nsx_admin_user))
nsx_manager.append(E_VMEXT.Password(nsx_admin_pwd))
nsx_manager.append(E_VMEXT.Url('https://' + nsx_host + ':443'))
register_vc_server_params.append(nsx_manager)
return self.client.\
post_linked_resource(resource=self.extension.get_resource(),
rel=RelationType.ADD,
media_type=EntityType.
REGISTER_VC_SERVER_PARAMS.value,
contents=register_vc_server_params)
def attach_port_group(self, vim_server_name, port_group_name):
"""Attach a portgroup to an external network.
:param str vc_name: name of vc where portgroup is present.
:param str pg_name: name of the portgroup to be attached to
external network.
return: object containing vmext:VMWExternalNetwork XML element that
representing the external network.
:rtype: lxml.objectify.ObjectifiedElement
"""
ext_net = self.get_resource()
platform = Platform(self.client)
if not vim_server_name or not port_group_name:
raise InvalidParameterException(
"Either vCenter Server name is none or portgroup name is none")
vc_record = platform.get_vcenter(vim_server_name)
vc_href = vc_record.get('href')
pg_moref_types = \
platform.get_port_group_moref_types(vim_server_name,
port_group_name)
if hasattr(ext_net, '{' + NSMAP['vmext'] + '}VimPortGroupRef'):
vim_port_group_refs = E_VMEXT.VimPortGroupRefs()
vim_object_ref1 = self.__create_vimobj_ref(vc_href,
pg_moref_types[0],
pg_moref_types[1])
# Create a new VimObjectRef using vc href, portgroup moref and type
# from existing VimPortGroupRef. Add the VimObjectRef to
# VimPortGroupRefs and then delete VimPortGroupRef
# from external network.
vim_pg_ref = ext_net['{' + NSMAP['vmext'] + '}VimPortGroupRef']
vc2_href = vim_pg_ref.VimServerRef.get('href')
vim_object_ref2 = self.__create_vimobj_ref(
vc2_href, vim_pg_ref.MoRef.text, vim_pg_ref.VimObjectType.text)
vim_port_group_refs.append(vim_object_ref1)
vim_port_group_refs.append(vim_object_ref2)
ext_net.remove(vim_pg_ref)
ext_net.append(vim_port_group_refs)
else:
vim_port_group_refs = \
ext_net['{' + NSMAP['vmext'] + '}VimPortGroupRefs']
vim_object_ref1 = self.__create_vimobj_ref(vc_href,
pg_moref_types[0],
pg_moref_types[1])
vim_port_group_refs.append(vim_object_ref1)
return self.client. \
put_linked_resource(ext_net, rel=RelationType.EDIT,
media_type=EntityType.
EXTERNAL_NETWORK.value,
contents=ext_net)
def enable_extension(self, name, enabled=True):
"""Enable or disable the API extension service.
:param name: (str): The name of the extension service.
:param enabled: (bool): Flag to enable or disable the extension.
:return: (lxml.objectify.ObjectifiedElement): object containing
the representation of the API extension.
"""
record = self.client.get_typed_query(
self.TYPE_NAME,
equality_filter=('name', name),
query_result_format=QueryResultFormat.RECORDS).find_unique()
params = E_VMEXT.Service({'name': name})
params.append(E_VMEXT.Namespace(record.get('namespace')))
params.append(E_VMEXT.Enabled('true' if enabled else 'false'))
params.append(E_VMEXT.RoutingKey(record.get('routingKey')))
params.append(E_VMEXT.Exchange(record.get('exchange')))
self.client.put_resource(record.get('href'), params, None)
return record.get('href')
def enable_disable_vcenter(self, vc_name, enable_flag):
"""Enable or disable a Virtual Center (VC) server.
:param str vc_name: name of VC server.
:param boolean enable_flag: True means enable, False means disable.
:return: an object containing EntityType.TASK XML data which represents
the asynchronous task that is enabling or disabling the VC.
rtype: lxml.objectify.ObjectifiedElement'
"""
vc = self.get_vcenter(vc_name)
if enable_flag:
vc.IsEnabled = E_VMEXT.IsEnabled('true')
else:
vc.IsEnabled = E_VMEXT.IsEnabled('false')
return self.client.\
put_linked_resource(resource=vc,
rel=RelationType.EDIT,
media_type=EntityType.VIRTUAL_CENTER.value,
contents=vc)
def pvdc_add_storage_profile(self,
pvdc_name,
storage_profile_names):
"""Add storage profiles to a PVDC.
:param str pvdc_name: name of the Provider Virtual Datacenter.
:param list storage_profile_names: list of storage profile names.
:return: an object containing EntityType.TASK XML data which represents
the async task that is deleting storage profiles from the PVDC.
:rtype: lxml.objectify.ObjectifiedElement
:raises: EntityNotFoundException: if any storage_profile_name is not
available.
"""
provider_vdc, pvdc_ext_href, pvdc_ext_resource = self.get_pvdc(
pvdc_name)
avail_storage_profiles = self.client.get_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.DOWN,
media_type=EntityType.VMW_STORAGE_PROFILES.value)
avail_sps = []
if hasattr(avail_storage_profiles,
'{' + NSMAP['vmext'] + '}VMWStorageProfile'):
for avail_stor_prof in avail_storage_profiles.VMWStorageProfile:
avail_sps.append(avail_stor_prof.get('name'))
payload = E_VMEXT.UpdateProviderVdcStorageProfiles()
for sp_to_add in storage_profile_names:
if sp_to_add not in avail_sps:
raise EntityNotFoundException(
'storage profile: \'%s\' not available' % sp_to_add)
payload.append(E_VMEXT.AddStorageProfile(sp_to_add))
return self.client.post_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.EDIT,
media_type=EntityType.UPDATE_PROVIDER_VDC_STORAGE_PROFILES.value,
contents=payload)
def _to_settings(self, config, password):
"""Converts dictionary representation of configuration to XML element.
:param dict config: dictionary representation of AMQP service
configuration.
:param str password: password of the user for the AMQP service.
:return: an object containing EntityType.AMQP_SETTINGS XML data
representing the configuration of the AMQP service.
:rtype: lxml.objectify.ObjectifiedElement
"""
settings = E_VMEXT.AmqpSettings()
settings.append(E_VMEXT.AmqpHost(config['AmqpHost']))
settings.append(E_VMEXT.AmqpPort(config['AmqpPort']))
settings.append(E_VMEXT.AmqpUsername(config['AmqpUsername']))
settings.append(E_VMEXT.AmqpPassword(password))
settings.append(E_VMEXT.AmqpExchange(config['AmqpExchange']))
settings.append(E_VMEXT.AmqpVHost(config['AmqpVHost']))
settings.append(E_VMEXT.AmqpUseSSL(config['AmqpUseSSL']))
settings.append(E_VMEXT.AmqpSslAcceptAll(config['AmqpSslAcceptAll']))
settings.append(E_VMEXT.AmqpPrefix(config['AmqpPrefix']))
return settings
def add_extension(self, name, namespace, routing_key, exchange, patterns):
params = E_VMEXT.Service({'name': name})
params.append(E_VMEXT.Namespace(namespace))
params.append(E_VMEXT.Enabled('true'))
params.append(E_VMEXT.RoutingKey(routing_key))
params.append(E_VMEXT.Exchange(exchange))
filters = E_VMEXT.ApiFilters()
for pattern in patterns:
filters.append(
E_VMEXT.ApiFilter(E_VMEXT.UrlPattern(pattern.strip())))
params.append(filters)
ext = self.client.get_extension()
ext_services = self.client.get_linked_resource(
ext, RelationType.DOWN, EntityType.EXTENSION_SERVICES.value)
return self.client.post_linked_resource(ext_services, RelationType.ADD,
EntityType.ADMIN_SERVICE.value,
params)
def register_nsxt_manager(self,
nsxt_manager_name,
nsxt_manager_url,
nsxt_manager_username,
nsxt_manager_password,
nsxt_manager_description=None):
"""Register a NSX-T manager.
:param str nsxt_manager_name: name of NSX-T manager.
:param str nsxt_manager_url: URL of NSX-T manager server.
:param str nsxt_manager_username: username of NSX-T manager admin.
:param str nsxt_manager_password: password of NSX-T manager admin.
:param str nsxt_manager_description: description of NSX-T manager.
:return: an object containing XML data the newly registered NSX-T
manager.
:rtype: lxml.objectify.ObjectifiedElement
"""
payload = E_VMEXT.NsxTManager(name=nsxt_manager_name)
if (nsxt_manager_description is not None):
payload.append(E.Description(nsxt_manager_description))
payload.append(E_VMEXT.Username(nsxt_manager_username))
payload.append(E_VMEXT.Password(nsxt_manager_password))
payload.append(E_VMEXT.Url(nsxt_manager_url))
nsxt_manager_resource = self.client.get_linked_resource(
resource=self.extension.get_resource(),
rel=RelationType.DOWN,
media_type=EntityType.NETWORK_MANAGERS.value)
return self.client.\
post_linked_resource(resource=nsxt_manager_resource,
rel=RelationType.ADD,
media_type=EntityType.NSXT_MANAGER.value,
contents=payload)
def create_provider_vdc(self,
vim_server_name,
resource_pool_names,
storage_profiles,
pvdc_name,
is_enabled=None,
description=None,
highest_hw_vers=None,
vxlan_network_pool=None):
"""Create a Provider Virtual Datacenter.
:param: vim_server_name: (str): vim_server_name (VC name).
:param: resource_pool_names: (list): list of resource_pool_names.
:param: storage_profiles: (list): list of storageProfile namespace.
:param: pvdc_name: (str): name of PVDC to be created.
:param: is_enabled: (boolean): enable flag.
:param: description: (str): description of pvdc.
:param: highest_hw_vers: (str): highest supported hw vers number.
:param: vxlan_network_pool: (str): name of vxlan_network_pool.
:return: A :class:lxml.objectify.StringElement object describing the
: new provider VDC.
"""
vc_record = self.get_vcenter(vim_server_name)
vc_href = vc_record.get('href')
rp_morefs = self.get_resource_pool_morefs(vim_server_name,
vc_href,
resource_pool_names)
vmw_prov_vdc_params = E_VMEXT.VMWProviderVdcParams(name=pvdc_name)
if description is not None:
vmw_prov_vdc_params.append(E.Description(description))
resource_pool_refs = E_VMEXT.ResourcePoolRefs()
for rp_moref in rp_morefs:
vim_object_ref = E_VMEXT.VimObjectRef()
vim_object_ref.append(E_VMEXT.VimServerRef(href=vc_href))
vim_object_ref.append(E_VMEXT.MoRef(rp_moref))
vim_object_ref.append(E_VMEXT.VimObjectType('RESOURCE_POOL'))
resource_pool_refs.append(vim_object_ref)
vmw_prov_vdc_params.append(resource_pool_refs)
vmw_prov_vdc_params.append(E_VMEXT.VimServer(href=vc_href))
if vxlan_network_pool is not None:
vxlan_network_pool_record = self.get_vxlan_network_pool(
vxlan_network_pool)
vx_href = vxlan_network_pool_record.get('href')
vmw_prov_vdc_params.append(E_VMEXT.VxlanNetworkPool(
href=vx_href))
if highest_hw_vers is not None:
vmw_prov_vdc_params.append(
E_VMEXT.HighestSupportedHardwareVersion(highest_hw_vers))
if is_enabled is not None:
vmw_prov_vdc_params.append(E_VMEXT.IsEnabled(is_enabled))
for storage_profile in storage_profiles:
vmw_prov_vdc_params.append(E_VMEXT.StorageProfile(
storage_profile))
random_username_suffix = uuid.uuid4().hex
default_user = '******' + random_username_suffix[:8]
default_pwd = 'PWD' + random_username_suffix[:8]
vmw_prov_vdc_params.append(E_VMEXT.DefaultPassword(default_pwd))
vmw_prov_vdc_params.append(E_VMEXT.DefaultUsername(default_user))
return self.client.post_linked_resource(self.extension.get_resource(),
rel=RelationType.ADD,
media_type=EntityType.
PROVIDER_VDC_PARAMS.value,
contents=vmw_prov_vdc_params)
def create_external_network(self,
name,
vim_server_name,
port_group_names,
gateway_ip,
netmask,
ip_ranges,
description=None,
primary_dns_ip=None,
secondary_dns_ip=None,
dns_suffix=None):
"""Create an external network.
:param str name: name of external network to be created.
:param str vim_server_name: VIM server_name (VC name).
:param list port_group_names: list of port group names.
:param str gateway_ip: IP address of the gateway of the new network.
:param str netmask: Netmask of the gateway.
:param list ip_ranges: list of IP ranges used for static pool
allocation in the network. For example, [192.168.1.2-192.168.1.49,
192.168.1.100-192.168.1.149].
:param str description: description of external network.
:param str primary_dns_ip: IP address of primary DNS server.
:param str secondary_dns_ip: IP address of secondary DNS Server.
:param str dns_suffix: DNS suffix.
:return: an object containing vmext:VMWExternalNetwork XML element that
represents the new external network.
:rtype: lxml.objectify.ObjectifiedElement
"""
vc_record = self.get_vcenter(vim_server_name)
vc_href = vc_record.get('href')
pg_morefs = self.get_port_group_morefs(port_group_names)
vmw_external_network = E_VMEXT.VMWExternalNetwork(name=name)
if description is not None:
vmw_external_network.append(E.Description(description))
config = E.Configuration()
ip_scopes = E.IpScopes()
ip_scope = E.IpScope()
ip_scope.append(E.IsInherited(False))
ip_scope.append(E.Gateway(gateway_ip))
ip_scope.append(E.Netmask(netmask))
if primary_dns_ip is not None:
ip_scope.append(E.Dns1(primary_dns_ip))
if secondary_dns_ip is not None:
ip_scope.append(E.Dns2(secondary_dns_ip))
if dns_suffix is not None:
ip_scope.append(E.DnsSuffix(dns_suffix))
e_ip_ranges = E.IpRanges()
for ip_range in ip_ranges:
e_ip_range = E.IpRange()
ip_range_token = ip_range.split('-')
e_ip_range.append(E.StartAddress(ip_range_token[0]))
e_ip_range.append(E.EndAddress(ip_range_token[1]))
e_ip_ranges.append(e_ip_range)
ip_scope.append(e_ip_ranges)
ip_scopes.append(ip_scope)
config.append(ip_scopes)
config.append(E.FenceMode(FenceMode.ISOLATED.value))
vmw_external_network.append(config)
vim_port_group_refs = E_VMEXT.VimPortGroupRefs()
for pg_moref in pg_morefs:
vim_object_ref = E_VMEXT.VimObjectRef()
vim_object_ref.append(E_VMEXT.VimServerRef(href=vc_href))
vim_object_ref.append(E_VMEXT.MoRef(pg_moref[0]))
vim_object_ref.append(E_VMEXT.VimObjectType(pg_moref[1]))
vim_port_group_refs.append(vim_object_ref)
vmw_external_network.append(vim_port_group_refs)
return self.client.post_linked_resource(
self.extension.get_resource(),
rel=RelationType.ADD,
media_type=EntityType.EXTERNAL_NETWORK.value,
contents=vmw_external_network)
def attach_vcenter(self,
vc_server_name,
vc_server_host,
vc_admin_user,
vc_admin_pwd,
is_enabled,
vc_root_folder=None,
nsx_server_name=None,
nsx_host=None,
nsx_admin_user=None,
nsx_admin_pwd=None):
"""Register (attach) a VirtualCenter server (also known as VimServer).
:param str vc_server_name: vc server name (virtual center name).
:param str vc_server_host: FQDN or IP address of vc host.
:param str vc_admin_user: vc admin user.
:param str vc_admin_pwd: vc admin password.
:param str is_enabled: true if VC is to be enabled.
:param str vc_root_folder: vc root folder.
:param str nsx_server_name: NSX server name.
:param str nsx_host: FQDN or IP address of NSX host.
:param str nsx_admin_user: NSX admin user.
:param str nsx_admin_pwd: NSX admin password.
:return: an object containing REGISTER_VC_SERVER_PARAMS XML data that
represents the newly registered (attached) VimServer.
:rtype: lxml.objectify.ObjectifiedElement
"""
register_vc_server_params = E_VMEXT.RegisterVimServerParams()
vc_server = E_VMEXT.VimServer(name=vc_server_name)
vc_server.append(E_VMEXT.Username(vc_admin_user))
vc_server.append(E_VMEXT.Password(vc_admin_pwd))
vc_server_host_url = urlparse(vc_server_host)
if vc_server_host_url.netloc is not '':
vc_server.append(E_VMEXT.Url(vc_server_host))
else:
vc_server.append(E_VMEXT.Url('https://' + vc_server_host + ':443'))
vc_server.append(E_VMEXT.IsEnabled(is_enabled))
if vc_root_folder is not None:
vc_server.append(E_VMEXT.rootFolder(vc_root_folder))
register_vc_server_params.append(vc_server)
if nsx_server_name is not None:
nsx_manager = E_VMEXT.ShieldManager(name=nsx_server_name)
nsx_manager.append(E_VMEXT.Username(nsx_admin_user))
nsx_manager.append(E_VMEXT.Password(nsx_admin_pwd))
nsx_host_url = urlparse(nsx_host)
if nsx_host_url.netloc is not '':
nsx_manager.append(E_VMEXT.Url(nsx_host))
else:
nsx_manager.append(E_VMEXT.Url('https://' + nsx_host + ':443'))
register_vc_server_params.append(nsx_manager)
return self.client.\
post_linked_resource(resource=self.extension.get_resource(),
rel=RelationType.ADD,
media_type=EntityType.
REGISTER_VC_SERVER_PARAMS.value,
contents=register_vc_server_params)
def pvdc_migrate_vms(self,
pvdc_name,
vms_to_migrate,
src_resource_pool,
target_resource_pool=None):
"""Migrate VMs to (an optionally) specified ResourcePool.
:param str pvdc_name: name of the Provider Virtual Datacenter.
:param list(str) vms_to_migrate: list of VMs to migrate.
:param str src_resource_pool: source resource pool name.
:param str target_resource_pool: target resource pool name (optional).
This function migrates the specified VMs to (an optionally) specified
target resource pool. If no target resource pool is specified, the
system will automatically choose a target resource pool and migrate
the VMs to it. If any of the vms_to_migrate are not found on the
source resource pool, an exception will be thrown.
:return: an object containing EntityType.TASK XML data which represents
the async task that is migrating VMs.
:rtype: lxml.objectify.ObjectifiedElement
:raises: EntityNotFoundException: if source or target resource pool
cannot be found, or if any of the vms_to_migrate are
not found on the source resource pool.
"""
provider_vdc = self.get_ref_by_name(ResourceType.PROVIDER_VDC,
pvdc_name)
pvdc_ext_href = get_admin_extension_href(provider_vdc.get('href'))
pvdc_ext_resource = self.client.get_resource(pvdc_ext_href)
vc_name = pvdc_ext_resource.VimServer.get('name')
vc_href = pvdc_ext_resource.VimServer.get('href')
# find the src_respool_resource to get href and link to migrate VMs
query_filter = 'vcName==%s' % urllib.parse.quote(vc_name)
query = self.client.get_typed_query(
ResourceType.RESOURCE_POOL.value,
query_result_format=QueryResultFormat.RECORDS,
qfilter=query_filter)
res_pools_in_use = {}
for res_pool in list(query.execute()):
res_pools_in_use[res_pool.get('name')] = res_pool.get('moref')
if src_resource_pool not in res_pools_in_use.keys():
raise EntityNotFoundException(
'source resource pool: \'%s\' not found' % src_resource_pool)
else:
src_rp_moref = res_pools_in_use[src_resource_pool]
if target_resource_pool is not None:
if target_resource_pool not in res_pools_in_use.keys():
raise EntityNotFoundException(
'target resource pool: \'%s\' not found' %
target_resource_pool)
else:
target_rp_moref = res_pools_in_use[target_resource_pool]
res_pools_in_pvdc = self.client.get_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.DOWN,
media_type=EntityType.VMW_PROVIDER_VDC_RESOURCE_POOL_SET.value)
pvdc_res_pools = {}
if hasattr(res_pools_in_pvdc,
'{' + NSMAP['vmext'] + '}VMWProviderVdcResourcePool'):
for res_pool in res_pools_in_pvdc.VMWProviderVdcResourcePool:
pvdc_res_pools[res_pool.ResourcePoolVimObjectRef.MoRef] = \
res_pool
src_respool_resource = pvdc_res_pools[src_rp_moref]
# create map of VM names to VM hrefs (in source respool)
vms_in_respool = self.client.get_linked_resource(
resource=src_respool_resource,
rel=RelationType.RESOURCE_POOL_VM_LIST,
media_type=None)
vm_hrefs_in_respool = {}
if hasattr(vms_in_respool, 'ResourcePoolVMRecord'):
for vm in vms_in_respool.ResourcePoolVMRecord:
vm_hrefs_in_respool[vm.get('name')] = vm.get('href')
# check that vms_to_migrate are contained in vms in respool
# and build the vms to migrate list
payload = E_VMEXT.MigrateParams()
for vm_to_migrate in vms_to_migrate:
if vm_to_migrate in vm_hrefs_in_respool.keys():
payload.append(
E_VMEXT.VmRef(href=vm_hrefs_in_respool[vm_to_migrate]))
else:
raise EntityNotFoundException(
'virtual machine \'%s\' not Found' % vm_to_migrate)
# if target respool specified, add target RP <vc, moref> to payload
if target_resource_pool is not None:
res_pool_ref = E_VMEXT.ResourcePoolRef()
vc_ref = E_VMEXT.VimServerRef(href=vc_href)
moref = E_VMEXT.MoRef(target_rp_moref)
obj_type = E_VMEXT.VimObjectType('RESOURCE_POOL')
res_pool_ref.append(vc_ref)
res_pool_ref.append(moref)
res_pool_ref.append(obj_type)
payload.append(res_pool_ref)
# do the migrate, return task
return self.client.post_linked_resource(resource=src_respool_resource,
rel=RelationType.MIGRATE_VMS,
media_type=None,
contents=payload)
def detach_resource_pools_from_provider_vdc(self, pvdc_name,
resource_pool_names):
"""Disable & Detach Resource Pools from a Provider Virtual Datacenter.
This function deletes resource pools (RPs) from a Provider Virtual
Datacenter (PVDC). In order to do this, the input "user-friendly" RP
names must be translated into RP hrefs. This is a multi-step process.
1) create a dictionary that maps RP names associated w/ this PVDC's
backing VC to morefs.
2) create a list of morefs_to_delete, using the dictionary created
in step 1 -- filtered by the input set of RP names.
3) create a dictionary that maps RP morefs associated w/ this PVDC to
RP hrefs.
4) Use the list of morefs_to_delete (created in step 2) to filter
the list of RP hrefs created as a dictionary in step 3 to create
the final payload.
Note that in order to delete a RP, it must first be disabled. This is
done for each RP to be deleted if the disable link is present (which
indicates that the RP is enabled).
Caveat: The current implementation of this function takes a list of RP
"basenames" as input. A basename is the last element of a full
pathname. For example, given a pathname /a/b/c, the basename of that
pathname is "c". Since RP names are only required to have unique
pathnames but not unique basenames, this function may not work
correctly if there are non-unique RP basenames. Therefore, in order to
use this function, all RP basenames must be unique. It is therefore up
to the user of this function to be aware of this limitation and name
their RPs appropriately. This limitation will be fixed in a future
version of this function.
:param str pvdc_name: name of the Provider Virtual Datacenter.
:param list resource_pool_names: list or resource pool names.
:return: an object containing EntityType.TASK XML data which represents
the async task that is deleting Resource Pools from the PVDC.
:rtype: lxml.objectify.ObjectifiedElement
:raises: EntityNotFoundException: if any resource_pool_name cannot be
found.
:raises: ValidationError: if primary resource pool is input for
deletion.
"""
provider_vdc = self.get_ref_by_name(ResourceType.PROVIDER_VDC,
pvdc_name)
pvdc_ext_href = get_admin_extension_href(provider_vdc.get('href'))
pvdc_ext_resource = self.client.get_resource(pvdc_ext_href)
vc_name = pvdc_ext_resource.VimServer.get('name')
# find the RPs in use that are associated with the backing VC
name_filter = ('vcName', vc_name)
query = self.client.get_typed_query(
ResourceType.RESOURCE_POOL.value,
query_result_format=QueryResultFormat.RECORDS,
equality_filter=name_filter)
res_pools_in_use = {}
for res_pool in list(query.execute()):
res_pools_in_use[res_pool.get('name')] = res_pool.get('moref')
morefs_to_delete = []
for resource_pool_name in resource_pool_names:
if resource_pool_name in res_pools_in_use.keys():
morefs_to_delete.append(res_pools_in_use[resource_pool_name])
else:
raise EntityNotFoundException(
'resource pool \'%s\' not Found' % resource_pool_name)
res_pools_in_pvdc = self.client.get_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.DOWN,
media_type=EntityType.VMW_PROVIDER_VDC_RESOURCE_POOL_SET.value)
pvdc_res_pools = {}
if hasattr(res_pools_in_pvdc,
'{' + NSMAP['vmext'] + '}VMWProviderVdcResourcePool'):
for res_pool in res_pools_in_pvdc.VMWProviderVdcResourcePool:
pvdc_res_pools[res_pool.ResourcePoolVimObjectRef.MoRef] = \
res_pool
res_pool_to_delete_refs = []
for moref in morefs_to_delete:
if moref not in pvdc_res_pools.keys():
raise EntityNotFoundException(
'resource pool with moref \'%s\' not Found' % moref)
else:
res_pool = pvdc_res_pools[moref]
if res_pool.get('primary') == 'true':
raise ValidationError(
'cannot delete primary respool with moref \'%s\' ' %
res_pool.ResourcePoolVimObjectRef.MoRef)
else:
# disable the RP if it is enabled
links = get_links(resource=res_pool,
rel=RelationType.DISABLE)
num_links = len(links)
if num_links == 1:
self.client.\
post_linked_resource(resource=res_pool,
rel=RelationType.DISABLE,
media_type=None,
contents=None)
res_pool_to_delete_refs.append(res_pool)
payload = E_VMEXT.UpdateResourcePoolSetParams()
for res_pool_ref in res_pool_to_delete_refs:
del_item = E_VMEXT.DeleteItem(
href=res_pool_ref.ResourcePoolRef.get('href'),
type=EntityType.VMW_PROVIDER_VDC_RESOURCE_POOL.value)
payload.append(del_item)
return self.client.post_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.UPDATE_RESOURCE_POOLS,
media_type=EntityType.RES_POOL_SET_UPDATE_PARAMS.value,
contents=payload)
def create_provider_vdc(self,
vim_server_name,
resource_pool_names,
storage_profiles,
pvdc_name,
is_enabled=None,
description=None,
highest_hw_vers=None,
vxlan_network_pool=None,
nsxt_manager_name=None):
"""Create a Provider Virtual Datacenter.
:param str vim_server_name: vim_server_name (VC name).
:param list resource_pool_names: list of resource_pool_names.
:param list storage_profiles: (list): list of storageProfile names.
:param str pvdc_name: name of PVDC to be created.
:param bool is_enabled: flag, True to enable and False to disable.
:param str description: description of pvdc.
:param str highest_hw_vers: highest supported hw version number.
:param str vxlan_network_pool: name of vxlan_network_pool.
:param str nsxt_manager_name: name of nsx-t manager.
:return: an object containing vmext:VMWProviderVdc XML element that
represents the new provider VDC.
:rtype: lxml.objectify.ObjectifiedElement
"""
vc_record = self.get_vcenter(vim_server_name)
vc_href = vc_record.get('href')
rp_morefs = self.get_resource_pool_morefs(vc_href, resource_pool_names)
vmw_prov_vdc_params = E_VMEXT.VMWProviderVdcParams(name=pvdc_name)
if description is not None:
vmw_prov_vdc_params.append(E.Description(description))
resource_pool_refs = E_VMEXT.ResourcePoolRefs()
for rp_moref in rp_morefs:
vim_object_ref = E_VMEXT.VimObjectRef()
vim_object_ref.append(E_VMEXT.VimServerRef(href=vc_href))
vim_object_ref.append(E_VMEXT.MoRef(rp_moref))
vim_object_ref.append(E_VMEXT.VimObjectType('RESOURCE_POOL'))
resource_pool_refs.append(vim_object_ref)
vmw_prov_vdc_params.append(resource_pool_refs)
vmw_prov_vdc_params.append(E_VMEXT.VimServer(href=vc_href))
if vxlan_network_pool is not None:
network_pool_rec = self.get_ref_by_name(ResourceType.NETWORK_POOL,
vxlan_network_pool)
vx_href = network_pool_rec.get('href')
vmw_prov_vdc_params.append(E_VMEXT.VxlanNetworkPool(href=vx_href))
if nsxt_manager_name is not None:
nsxt_manager_rec = self.get_ref_by_name(ResourceType.NSXT_MANAGER,
nsxt_manager_name)
nsxt_href = nsxt_manager_rec.get('href')
vmw_prov_vdc_params.append(
E_VMEXT.NsxTManagerReference(href=nsxt_href))
if highest_hw_vers is not None:
vmw_prov_vdc_params.append(
E_VMEXT.HighestSupportedHardwareVersion(highest_hw_vers))
if is_enabled is not None:
vmw_prov_vdc_params.append(E_VMEXT.IsEnabled(is_enabled))
for storage_profile in storage_profiles:
vmw_prov_vdc_params.append(E_VMEXT.StorageProfile(storage_profile))
random_username_suffix = uuid.uuid4().hex
default_user = '******' + random_username_suffix[:8]
default_pwd = 'PWD' + random_username_suffix[:8]
vmw_prov_vdc_params.append(E_VMEXT.DefaultPassword(default_pwd))
vmw_prov_vdc_params.append(E_VMEXT.DefaultUsername(default_user))
return self.client.post_linked_resource(
self.extension.get_resource(),
rel=RelationType.ADD,
media_type=EntityType.PROVIDER_VDC_PARAMS.value,
contents=vmw_prov_vdc_params)
