def __init__(self, module):
"""Constructor."""
super(VmwareContentDeployTemplate, self).__init__(module)
self.pyv = PyVmomi(module=module)
vm = self.pyv.get_vm()
if vm:
self.module.exit_json(
changed=False,
vm_deploy_info=dict(
msg="Virtual Machine '%s' already exists." %
self.module.params['name'],
vm_id=vm._moId,
))
self.template_service = self.api_client.vcenter.vm_template.LibraryItems
self.template_name = self.params.get('template')
self.content_library_name = self.params.get('content_library')
self.vm_name = self.params.get('name')
self.datacenter = self.params.get('datacenter')
self.datastore = self.params.get('datastore')
self.datastore_cluster = self.params.get('datastore_cluster')
self.datastore_id = None
self.folder = self.params.get('folder')
self.resourcepool = self.params.get('resource_pool')
self.cluster = self.params.get('cluster')
self.host = self.params.get('host')
def __init__(self, module):
"""
Constructor
"""
super(VmwareTagManager, self).__init__(module)
self.pyv = PyVmomi(module=module)
self.object_type = self.params.get('object_type')
self.object_name = self.params.get('object_name')
self.managed_object = None
if self.object_type == 'VirtualMachine':
self.managed_object = self.pyv.get_vm_or_template(self.object_name)
if self.object_type == 'Folder':
self.managed_object = self.pyv.find_folder_by_name(self.object_name)
if self.object_type == 'Datacenter':
self.managed_object = self.pyv.find_datacenter_by_name(self.object_name)
if self.object_type == 'Datastore':
self.managed_object = self.pyv.find_datastore_by_name(self.object_name)
if self.object_type == 'DatastoreCluster':
self.managed_object = self.pyv.find_datastore_cluster_by_name(self.object_name)
self.object_type = 'StoragePod'
if self.object_type == 'ClusterComputeResource':
self.managed_object = self.pyv.find_cluster_by_name(self.object_name)
if self.object_type == 'ResourcePool':
self.managed_object = self.pyv.find_resource_pool_by_name(self.object_name)
if self.object_type == 'HostSystem':
self.managed_object = self.pyv.find_hostsystem_by_name(self.object_name)
if self.object_type == 'DistributedVirtualSwitch':
self.managed_object = find_dvs_by_name(self.pyv.content, self.object_name)
self.object_type = 'VmwareDistributedVirtualSwitch'
if self.object_type == 'DistributedVirtualPortgroup':
dvs_name, pg_name = self.object_name.split(":", 1)
dv_switch = find_dvs_by_name(self.pyv.content, dvs_name)
if dv_switch is None:
self.module.fail_json(msg="A distributed virtual switch with name %s does not exist" % dvs_name)
self.managed_object = find_dvspg_by_name(dv_switch, pg_name)
if self.managed_object is None:
self.module.fail_json(msg="Failed to find the managed object for %s with type %s" % (self.object_name, self.object_type))
if not hasattr(self.managed_object, '_moId'):
self.module.fail_json(msg="Unable to find managed object id for %s managed object" % self.object_name)
self.dynamic_managed_object = DynamicID(type=self.object_type, id=self.managed_object._moId)
self.tag_service = self.api_client.tagging.Tag
self.category_service = self.api_client.tagging.Category
self.tag_association_svc = self.api_client.tagging.TagAssociation
self.tag_names = self.params.get('tag_names')
def __init__(self, module):
"""Constructor."""
super(VmwareContentLibCreate, self).__init__(module)
self.content_service = self.api_client
self.local_libraries = dict()
# Track all existing library names, to block update/delete if duplicates exist
self.existing_library_names = []
self.library_name = self.params.get('library_name')
self.library_description = self.params.get('library_description')
self.library_type = self.params.get('library_type')
self.library_types = dict()
self.subscription_url = self.params.get('subscription_url')
self.ssl_thumbprint = self.params.get('ssl_thumbprint')
self.datastore_name = self.params.get('datastore_name')
self.update_on_demand = self.params.get('update_on_demand')
self.library_types = {
'local': self.content_service.content.LocalLibrary,
'subscribed': self.content_service.content.SubscribedLibrary
}
# Import objects of both types to prevent duplicate names
self.get_all_libraries(self.library_types['local'])
self.get_all_libraries(self.library_types['subscribed'])
# Set library type for create/update actions
self.library_service = self.library_types[self.library_type]
self.pyv = PyVmomi(module=module)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type='str'),
name_match=dict(type='str', choices=['first', 'last'], default='first'),
uuid=dict(type='str'),
use_instance_uuid=dict(type='bool', default=False),
moid=dict(type='str'),
folder=dict(type='str'),
datacenter=dict(type='str', required=True),
tags=dict(type='bool', default=False),
schema=dict(type='str', choices=['summary', 'vsphere'], default='summary'),
properties=dict(type='list', elements='str'),
tag_details=dict(type='bool', default=False),
)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[['name', 'uuid', 'moid']],
supports_check_mode=True)
if module.params.get('folder'):
# FindByInventoryPath() does not require an absolute path
# so we should leave the input folder path unmodified
module.params['folder'] = module.params['folder'].rstrip('/')
if module.params['schema'] != 'vsphere' and module.params.get('properties'):
module.fail_json(msg="The option 'properties' is only valid when the schema is 'vsphere'")
pyv = PyVmomi(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
# VM already exists
if vm:
try:
if module.params['schema'] == 'summary':
instance = pyv.gather_facts(vm)
else:
instance = pyv.to_json(vm, module.params['properties'])
if module.params.get('tags'):
if not HAS_VSPHERE:
module.fail_json(msg="Unable to find 'vCloud Suite SDK' Python library which is required."
" Please refer this URL for installation steps"
" - https://code.vmware.com/web/sdk/vsphere-automation-python")
vm_rest_client = VmwareTag(module)
tags = []
if module.params.get('tag_details'):
tags = vm_rest_client.get_tags_for_vm(vm_mid=vm._moId)
else:
dynamic_obj = DynamicID(type='VirtualMachine', id=vm._moId)
tags = vm_rest_client.get_vm_tags(vm_rest_client.tag_service,
vm_rest_client.tag_association_svc,
vm_mid=dynamic_obj)
instance.update(tags=tags)
module.exit_json(instance=instance)
except Exception as exc:
module.fail_json(msg="Information gathering failed with exception %s" % to_text(exc))
else:
vm_id = (module.params.get('uuid') or module.params.get('name') or module.params.get('moid'))
module.fail_json(msg="Unable to gather information for non-existing VM %s" % vm_id)
def __init__(self, module):
"""Constructor."""
super(VmwareContentLibCreate, self).__init__(module)
self.content_service = self.api_client
self.local_libraries = dict()
self.library_name = self.params.get('library_name')
self.library_description = self.params.get('library_description')
self.library_type = self.params.get('library_type')
self.library_types = dict()
self.datastore_name = self.params.get('datastore_name')
self.get_all_libraries()
self.pyv = PyVmomi(module=module)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(state=dict(type='str',
default='present',
choices=['present', 'absent']),
name=dict(type='str'),
name_match=dict(type='str',
choices=['first', 'last'],
default='first'),
uuid=dict(type='str'),
moid=dict(type='str'),
folder=dict(type='str'),
vnc_ip=dict(type='str', default='0.0.0.0'),
vnc_port=dict(type='int', default=0),
vnc_password=dict(type='str', default='',
no_log=True),
datacenter=dict(type='str', default='ha-datacenter'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[['name', 'uuid', 'moid']],
mutually_exclusive=[['name', 'uuid', 'moid']])
module.deprecate(
msg=
"The 'vmware_guest_vnc' module is deprecated because vSphere 7.0 removed the built-in VNC server",
date="2022-10-15",
collection_name="community.vmware")
result = dict(changed=False, failed=False)
pyv = PyVmomi(module)
vm = pyv.get_vm()
if vm:
result = set_vnc_extraconfig(pyv.content, vm,
(module.params['state'] == "present"),
module.params['vnc_ip'],
module.params['vnc_port'],
module.params['vnc_password'])
else:
vm_id = module.params.get('uuid') or module.params.get(
'name') or module.params.get('moid')
module.fail_json(
msg=
"Unable to set VNC config for non-existing virtual machine : '%s'"
% vm_id)
if result.get('failed') is True:
module.fail_json(**result)
module.exit_json(**result)
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
state=dict(type='str',
default='present',
choices=['present', 'poweredon']),
template=dict(type='str', aliases=['template_src'], required=True),
content_library=dict(type='str',
aliases=['content_library_src'],
required=False),
name=dict(type='str', required=True, aliases=['vm_name']),
datacenter=dict(type='str', required=True),
datastore=dict(type='str', required=True),
folder=dict(type='str', required=True),
host=dict(type='str', required=True),
resource_pool=dict(type='str', required=False),
cluster=dict(type='str', required=False),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
result = {'failed': False, 'changed': False}
pyv = PyVmomi(module=module)
vm = pyv.get_vm()
if vm:
module.exit_json(changed=False,
vm_deploy_info=dict(
msg="Virtual Machine '%s' already Exists." %
module.params['name'],
vm_id=vm._moId,
))
vmware_contentlib_create = VmwareContentDeployTemplate(module)
if module.params['state'] in ['present']:
if module.check_mode:
result.update(
vm_name=module.params['name'],
changed=True,
desired_operation='Create VM with PowerOff State',
)
module.exit_json(**result)
vmware_contentlib_create.deploy_vm_from_template()
if module.params['state'] == 'poweredon':
if module.check_mode:
result.update(
vm_name=module.params['name'],
changed=True,
desired_operation='Create VM with PowerON State',
)
module.exit_json(**result)
vmware_contentlib_create.deploy_vm_from_template(power_on=True)
def __init__(self, module):
"""Constructor."""
super(VmwareContentDeployOvfTemplate, self).__init__(module)
# Initialize member variables
self.module = module
self._pyv = PyVmomi(module=module)
self._template_service = self.api_client.vcenter.vm_template.LibraryItems
self._datacenter_id = None
self._datastore_id = None
self._library_item_id = None
self._folder_id = None
self._host_id = None
self._cluster_id = None
self._resourcepool_id = None
self.result = {}
# Turn on debug if not specified, but ANSIBLE_DEBUG is set
if self.module._debug:
self.warn('Enable debug output because ANSIBLE_DEBUG was set.')
self.params['log_level'] = 'debug'
self.log_level = self.params['log_level']
if self.log_level == 'debug':
# Turn on debugging
self.result['debug'] = {}
# Get parameters
self.template = self.params.get('template')
self.library = self.params.get('library')
self.vm_name = self.params.get('name')
self.datacenter = self.params.get('datacenter')
self.datastore = self.params.get('datastore')
self.datastore_cluster = self.params.get('datastore_cluster')
self.folder = self.params.get('folder')
self.resourcepool = self.params.get('resource_pool')
self.cluster = self.params.get('cluster')
self.host = self.params.get('host')
self.storage_provisioning = self.params['storage_provisioning']
if self.storage_provisioning == 'eagerzeroedthick':
self.storage_provisioning = 'eagerZeroedThick'
vm = self._pyv.get_vm()
if vm:
self.result['vm_deploy_info'] = dict(
msg="Virtual Machine '%s' already Exists." % self.vm_name,
vm_id=vm._moId,
)
self._fail(msg="Virtual Machine deployment failed")
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
ovf_template=dict(type='str',
aliases=['template_src', 'ovf'],
required=True),
name=dict(type='str', required=True, aliases=['vm_name']),
datacenter=dict(type='str', required=True),
datastore=dict(type='str', required=True),
folder=dict(type='str', required=True),
host=dict(type='str', required=True),
resource_pool=dict(type='str', required=True),
cluster=dict(type='str', required=False),
storage_provisioning=dict(
type='str',
required=False,
choices=['thin', 'thick', 'eagerZeroedThick'],
default=None),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
result = {'failed': False, 'changed': False}
pyv = PyVmomi(module=module)
vm = pyv.get_vm()
if vm:
module.exit_json(changed=False,
vm_deploy_info=dict(
msg="Virtual Machine '%s' already Exists." %
module.params['name'],
vm_id=vm._moId,
))
vmware_contentlib_create = VmwareContentDeployOvfTemplate(module)
if module.check_mode:
result.update(
vm_name=module.params['name'],
changed=True,
desired_operation='Create VM with PowerOff State',
)
module.exit_json(**result)
vmware_contentlib_create.deploy_vm_from_ovf_template()
def __init__(self, module):
"""
Constructor
"""
super(VmwareTagManager, self).__init__(module)
self.pyv = PyVmomi(module=module)
moid = self.params.get('moid')
self.object_type = self.params.get('object_type')
managed_object_id = None
if moid:
managed_object_id = moid
else:
object_name = self.params.get('object_name')
managed_object = self.get_managed_object(object_name,
self.object_type)
if managed_object is None:
self.module.fail_json(
msg="Failed to find the managed object for %s with type %s"
% (object_name, self.object_type))
if not hasattr(managed_object, '_moId'):
self.module.fail_json(
msg="Unable to find managed object id for %s managed object"
% object_name)
managed_object_id = managed_object._moId
self.dynamic_managed_object = DynamicID(type=self.object_type,
id=managed_object_id)
self.tag_service = self.api_client.tagging.Tag
self.category_service = self.api_client.tagging.Category
self.tag_association_svc = self.api_client.tagging.TagAssociation
self.tag_names = self.params.get('tag_names')
def __init__(self, module):
"""
Constructor
"""
super(VmwareObjectRename, self).__init__(module)
self.pyv = PyVmomi(module=module)
self.soap_stub = self.pyv.si._stub
self.object_type = self.params.get('object_type')
self.object_name = self.params.get('object_name')
self.object_new_name = self.params.get('new_name')
self.object_moid = self.params.get('object_moid')
self.managed_object = None
class VmwareContentLibCreate(VmwareRestClient):
def __init__(self, module):
"""Constructor."""
super(VmwareContentLibCreate, self).__init__(module)
self.content_service = self.api_client
self.local_libraries = dict()
self.library_name = self.params.get('library_name')
self.library_description = self.params.get('library_description')
self.library_type = self.params.get('library_type')
self.library_types = dict()
self.datastore_name = self.params.get('datastore_name')
self.get_all_libraries()
self.pyv = PyVmomi(module=module)
def process_state(self):
"""
Manage states of Content Library
"""
self.desired_state = self.params.get('state')
library_states = {
'absent': {
'present': self.state_destroy_library,
'absent': self.state_exit_unchanged,
},
'present': {
'present': self.state_update_library,
'absent': self.state_create_library,
}
}
library_states[self.desired_state][self.check_content_library_status()]()
def get_all_libraries(self):
content_libs = self.content_service.content.LocalLibrary.list()
if content_libs:
for content_lib in content_libs:
lib_details = self.content_service.content.LocalLibrary.get(content_lib)
self.local_libraries[lib_details.name] = dict(
lib_name=lib_details.name,
lib_description=lib_details.description,
lib_id=lib_details.id,
lib_type=lib_details.type
)
def check_content_library_status(self):
"""
Check if Content Library exists or not
Returns: 'present' if library found, else 'absent'
"""
ret = 'present' if self.library_name in self.local_libraries else 'absent'
return ret
def state_create_library(self):
# Find the datastore by the given datastore name
datastore_id = self.pyv.find_datastore_by_name(datastore_name=self.datastore_name)
if not datastore_id:
self.module.fail_json(msg="Failed to find the datastore %s" % self.datastore_name)
self.datastore_id = datastore_id._moId
# Build the storage backing for the library to be created
storage_backings = []
storage_backing = StorageBacking(type=StorageBacking.Type.DATASTORE, datastore_id=self.datastore_id)
storage_backings.append(storage_backing)
# Build the specification for the library to be created
create_spec = LibraryModel()
create_spec.name = self.library_name
create_spec.description = self.library_description
self.library_types = {'local': create_spec.LibraryType.LOCAL,
'subscribed': create_spec.LibraryType.SUBSCRIBED}
create_spec.type = self.library_types[self.library_type]
create_spec.storage_backings = storage_backings
# Create a local content library backed the VC datastore
library_id = self.content_service.content.LocalLibrary.create(create_spec=create_spec,
client_token=str(uuid.uuid4()))
if library_id:
self.module.exit_json(
changed=True,
content_library_info=dict(
msg="Content Library '%s' created." % create_spec.name,
library_id=library_id,
library_description=self.library_description,
library_type=create_spec.type,
)
)
self.module.exit_json(changed=False,
content_library_info=dict(msg="Content Library not created. Datastore and library_type required", library_id=''))
def state_update_library(self):
"""
Update Content Library
"""
changed = False
library_id = self.local_libraries[self.library_name]['lib_id']
content_library_info = dict(msg="Content Library %s is unchanged." % self.library_name, library_id=library_id)
library_update_spec = LibraryModel()
library_desc = self.local_libraries[self.library_name]['lib_description']
desired_lib_desc = self.params.get('library_description')
if library_desc != desired_lib_desc:
library_update_spec.description = desired_lib_desc
self.content_service.content.LocalLibrary.update(library_id, library_update_spec)
content_library_info['msg'] = 'Content Library %s updated.' % self.library_name
changed = True
self.module.exit_json(changed=changed, content_library_info=content_library_info)
def state_destroy_library(self):
"""
Delete Content Library
"""
library_id = self.local_libraries[self.library_name]['lib_id']
self.content_service.content.LocalLibrary.delete(library_id=library_id)
self.module.exit_json(
changed=True,
content_library_info=dict(
msg="Content Library '%s' deleted." % self.library_name,
library_id=library_id
)
)
def state_exit_unchanged(self):
"""
Return unchanged state
"""
self.module.exit_json(changed=False)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
state=dict(type='str', default='present',
choices=['present', 'powered-off', 'powered-on', 'reboot-guest', 'restarted', 'shutdown-guest', 'suspended']),
name=dict(type='str'),
name_match=dict(type='str', choices=['first', 'last'], default='first'),
uuid=dict(type='str'),
moid=dict(type='str'),
use_instance_uuid=dict(type='bool', default=False),
folder=dict(type='str'),
force=dict(type='bool', default=False),
scheduled_at=dict(type='str'),
schedule_task_name=dict(),
schedule_task_description=dict(),
schedule_task_enabled=dict(type='bool', default=True),
state_change_timeout=dict(type='int', default=0),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[
['name', 'uuid', 'moid'],
],
)
result = dict(changed=False,)
pyv = PyVmomi(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
if vm:
# VM already exists, so set power state
scheduled_at = module.params.get('scheduled_at', None)
if scheduled_at:
if not pyv.is_vcenter():
module.fail_json(msg="Scheduling task requires vCenter, hostname %s "
"is an ESXi server." % module.params.get('hostname'))
powerstate = {
'present': vim.VirtualMachine.PowerOn,
'powered-off': vim.VirtualMachine.PowerOff,
'powered-on': vim.VirtualMachine.PowerOn,
'reboot-guest': vim.VirtualMachine.RebootGuest,
'restarted': vim.VirtualMachine.Reset,
'shutdown-guest': vim.VirtualMachine.ShutdownGuest,
'suspended': vim.VirtualMachine.Suspend,
}
dt = ''
try:
dt = datetime.strptime(scheduled_at, '%d/%m/%Y %H:%M')
except ValueError as e:
module.fail_json(msg="Failed to convert given date and time string to Python datetime object,"
"please specify string in 'dd/mm/yyyy hh:mm' format: %s" % to_native(e))
schedule_task_spec = vim.scheduler.ScheduledTaskSpec()
schedule_task_name = module.params['schedule_task_name'] or 'task_%s' % str(randint(10000, 99999))
schedule_task_desc = module.params['schedule_task_description']
if schedule_task_desc is None:
schedule_task_desc = 'Schedule task for vm %s for ' \
'operation %s at %s' % (vm.name, module.params['state'], scheduled_at)
schedule_task_spec.name = schedule_task_name
schedule_task_spec.description = schedule_task_desc
schedule_task_spec.scheduler = vim.scheduler.OnceTaskScheduler()
schedule_task_spec.scheduler.runAt = dt
schedule_task_spec.action = vim.action.MethodAction()
schedule_task_spec.action.name = powerstate[module.params['state']]
schedule_task_spec.enabled = module.params['schedule_task_enabled']
try:
pyv.content.scheduledTaskManager.CreateScheduledTask(vm, schedule_task_spec)
# As this is async task, we create scheduled task and mark state to changed.
module.exit_json(changed=True)
except vim.fault.InvalidName as e:
module.fail_json(msg="Failed to create scheduled task %s for %s : %s" % (module.params.get('state'),
vm.name,
to_native(e.msg)))
except vim.fault.DuplicateName as e:
module.exit_json(changed=False, details=to_native(e.msg))
except vmodl.fault.InvalidArgument as e:
module.fail_json(msg="Failed to create scheduled task %s as specifications "
"given are invalid: %s" % (module.params.get('state'),
to_native(e.msg)))
else:
result = set_vm_power_state(pyv.content, vm, module.params['state'], module.params['force'], module.params['state_change_timeout'])
else:
id = module.params.get('uuid') or module.params.get('moid') or module.params.get('name')
module.fail_json(msg="Unable to set power state for non-existing virtual machine : '%s'" % id)
if result.get('failed') is True:
module.fail_json(**result)
module.exit_json(**result)
def get_virtual_machines(self):
"""
Get one/all virtual machines and related configurations information.
"""
folder = self.params.get('folder')
folder_obj = None
if folder:
folder_obj = self.content.searchIndex.FindByInventoryPath(folder)
if not folder_obj:
self.module.fail_json(msg="Failed to find folder specified by %(folder)s" % self.params)
vm_name = self.params.get('vm_name')
if vm_name:
virtual_machine = find_vm_by_name(self.content, vm_name=vm_name, folder=folder_obj)
if not virtual_machine:
self.module.fail_json(msg="Failed to find virtual machine %s" % vm_name)
else:
virtual_machines = [virtual_machine]
else:
virtual_machines = get_all_objs(self.content, [vim.VirtualMachine], folder=folder_obj)
_virtual_machines = []
for vm in virtual_machines:
_ip_address = ""
summary = vm.summary
if summary.guest is not None:
_ip_address = summary.guest.ipAddress
if _ip_address is None:
_ip_address = ""
_mac_address = []
all_devices = _get_vm_prop(vm, ('config', 'hardware', 'device'))
if all_devices:
for dev in all_devices:
if isinstance(dev, vim.vm.device.VirtualEthernetCard):
_mac_address.append(dev.macAddress)
net_dict = {}
vmnet = _get_vm_prop(vm, ('guest', 'net'))
if vmnet:
for device in vmnet:
net_dict[device.macAddress] = dict()
net_dict[device.macAddress]['ipv4'] = []
net_dict[device.macAddress]['ipv6'] = []
for ip_addr in device.ipAddress:
if "::" in ip_addr:
net_dict[device.macAddress]['ipv6'].append(ip_addr)
else:
net_dict[device.macAddress]['ipv4'].append(ip_addr)
esxi_hostname = None
esxi_parent = None
if summary.runtime.host:
esxi_hostname = summary.runtime.host.summary.config.name
esxi_parent = summary.runtime.host.parent
cluster_name = None
if esxi_parent and isinstance(esxi_parent, vim.ClusterComputeResource):
cluster_name = summary.runtime.host.parent.name
vm_attributes = dict()
if self.module.params.get('show_attribute'):
vm_attributes = self.get_vm_attributes(vm)
vm_tags = list()
if self.module.params.get('show_tag'):
vm_tags = self.get_tag_info(vm)
vm_folder = PyVmomi.get_vm_path(content=self.content, vm_name=vm)
datacenter = get_parent_datacenter(vm)
datastore_url = list()
datastore_attributes = ('name', 'url')
if vm.config.datastoreUrl:
for entry in vm.config.datastoreUrl:
datastore_url.append({key: getattr(entry, key) for key in dir(entry) if key in datastore_attributes})
virtual_machine = {
"guest_name": summary.config.name,
"guest_fullname": summary.config.guestFullName,
"power_state": summary.runtime.powerState,
"ip_address": _ip_address, # Kept for backward compatibility
"mac_address": _mac_address, # Kept for backward compatibility
"uuid": summary.config.uuid,
"vm_network": net_dict,
"esxi_hostname": esxi_hostname,
"datacenter": datacenter.name,
"cluster": cluster_name,
"attributes": vm_attributes,
"tags": vm_tags,
"folder": vm_folder,
"moid": vm._moId,
"datastore_url": datastore_url,
}
vm_type = self.module.params.get('vm_type')
is_template = _get_vm_prop(vm, ('config', 'template'))
if vm_type == 'vm' and not is_template:
_virtual_machines.append(virtual_machine)
elif vm_type == 'template' and is_template:
_virtual_machines.append(virtual_machine)
elif vm_type == 'all':
_virtual_machines.append(virtual_machine)
return _virtual_machines
class VmwareContentDeployTemplate(VmwareRestClient):
def __init__(self, module):
"""Constructor."""
super(VmwareContentDeployTemplate, self).__init__(module)
# Initialize member variables
self.module = module
self._pyv = PyVmomi(module=module)
self._template_service = self.api_client.vcenter.vm_template.LibraryItems
self._datacenter_id = None
self._datastore_id = None
self._library_item_id = None
self._folder_id = None
self._host_id = None
self._cluster_id = None
self._resourcepool_id = None
self.result = {}
# Turn on debug if not specified, but ANSIBLE_DEBUG is set
if self.module._debug:
self.warn('Enable debug output because ANSIBLE_DEBUG was set.')
self.params['log_level'] = 'debug'
self.log_level = self.params['log_level']
if self.log_level == 'debug':
# Turn on debugging
self.result['debug'] = {}
# Get parameters
self.template = self.params.get('template')
self.library = self.params.get('library')
self.vm_name = self.params.get('name')
self.datacenter = self.params.get('datacenter')
self.datastore = self.params.get('datastore')
self.datastore_cluster = self.params.get('datastore_cluster')
self.folder = self.params.get('folder')
self.resourcepool = self.params.get('resource_pool')
self.cluster = self.params.get('cluster')
self.host = self.params.get('host')
vm = self._pyv.get_vm()
if vm:
self.result['vm_deploy_info'] = dict(
msg="Virtual Machine '%s' already Exists." % self.vm_name,
vm_id=vm._moId,
)
self._fail(msg="Virtual Machine deployment failed")
def deploy_vm_from_template(self, power_on=False):
# Find the datacenter by the given datacenter name
self._datacenter_id = self.get_datacenter_by_name(self.datacenter)
if not self._datacenter_id:
self._fail(msg="Failed to find the datacenter %s" %
self.datacenter)
# Find the datastore by the given datastore name
if self.datastore:
self._datastore_id = self.get_datastore_by_name(
self.datacenter, self.datastore)
if not self._datastore_id:
self._fail(msg="Failed to find the datastore %s" %
self.datastore)
# Find the datastore by the given datastore cluster name
if self.datastore_cluster and not self._datastore_id:
dsc = self._pyv.find_datastore_cluster_by_name(
self.datastore_cluster)
if dsc:
self.datastore = self._pyv.get_recommended_datastore(dsc)
self._datastore_id = self.get_datastore_by_name(
self.datacenter, self.datastore)
else:
self._fail(msg="Failed to find the datastore cluster %s" %
self.datastore_cluster)
if not self._datastore_id:
self._fail(
msg=
"Failed to find the datastore using either datastore or datastore cluster"
)
# Find the LibraryItem (Template) by the given LibraryItem name
if self.library:
self._library_item_id = self.get_library_item_from_content_library_name(
self.template, self.library)
if not self._library_item_id:
self._fail(
msg=
"Failed to find the library Item %s in content library %s"
% (self.template, self.library))
else:
self._library_item_id = self.get_library_item_by_name(
self.template)
if not self._library_item_id:
self._fail(msg="Failed to find the library Item %s" %
self.template)
# Find the folder by the given FQPN folder name
# The FQPN is I(datacenter)/I(folder type)/folder name/... for
# example Lab/vm/someparent/myfolder is a vm folder in the Lab datacenter.
folder_obj = self._pyv.find_folder_by_fqpn(self.folder,
self.datacenter,
folder_type='vm')
if folder_obj:
self._folder_id = folder_obj._moId
if not self._folder_id:
self._fail(msg="Failed to find the folder %s" % self.folder)
# Find the Host by the given name
if self.host:
self._host_id = self.get_host_by_name(self.datacenter, self.host)
if not self._host_id:
self._fail(msg="Failed to find the Host %s" % self.host)
# Find the Cluster by the given Cluster name
if self.cluster:
self._cluster_id = self.get_cluster_by_name(
self.datacenter, self.cluster)
if not self._cluster_id:
self._fail(msg="Failed to find the Cluster %s" % self.cluster)
cluster_obj = self.api_client.vcenter.Cluster.get(self._cluster_id)
self._resourcepool_id = cluster_obj.resource_pool
# Find the resourcepool by the given resourcepool name
if self.resourcepool and self.cluster and self.host:
self._resourcepool_id = self.get_resource_pool_by_name(
self.datacenter, self.resourcepool, self.cluster, self.host)
if not self._resourcepool_id:
self._fail(msg="Failed to find the resource_pool %s" %
self.resourcepool)
# Create VM placement specs
self.placement_spec = LibraryItems.DeployPlacementSpec(
folder=self._folder_id)
if self._host_id:
self.placement_spec.host = self._host_id
if self._resourcepool_id:
self.placement_spec.resource_pool = self._resourcepool_id
if self._cluster_id:
self.placement_spec.cluster = self._cluster_id
self.vm_home_storage_spec = LibraryItems.DeploySpecVmHomeStorage(
datastore=to_native(self._datastore_id))
self.disk_storage_spec = LibraryItems.DeploySpecDiskStorage(
datastore=to_native(self._datastore_id))
self.deploy_spec = LibraryItems.DeploySpec(
name=self.vm_name,
placement=self.placement_spec,
vm_home_storage=self.vm_home_storage_spec,
disk_storage=self.disk_storage_spec,
powered_on=power_on)
vm_id = ''
try:
vm_id = self._template_service.deploy(self._library_item_id,
self.deploy_spec)
except Error as error:
self._fail(msg="%s" % self.get_error_message(error))
except Exception as err:
self._fail(msg="%s" % to_native(err))
if not vm_id:
self.result['vm_deploy_info'] = dict(
msg="Virtual Machine deployment failed", vm_id='')
self._fail(msg="Virtual Machine deployment failed")
self.result['changed'] = True
self.result['vm_deploy_info'] = dict(
msg="Deployed Virtual Machine '%s'." % self.vm_name,
vm_id=vm_id,
)
self._exit()
#
# Wrap AnsibleModule methods
#
def _mod_debug(self):
if self.log_level == 'debug':
self.result['debug'] = dict(datacenter_id=self._datacenter_id,
datastore_id=self._datastore_id,
library_item_id=self._library_item_id,
folder_id=self._folder_id,
host_id=self._host_id,
cluster_id=self._cluster_id,
resourcepool_id=self._resourcepool_id)
def _fail(self, msg):
self._mod_debug()
self.module.fail_json(msg=msg, **self.result)
def _exit(self):
self._mod_debug()
self.module.exit_json(**self.result)
class VmwareTagManager(VmwareRestClient):
def __init__(self, module):
"""
Constructor
"""
super(VmwareTagManager, self).__init__(module)
self.pyv = PyVmomi(module=module)
self.object_type = self.params.get('object_type')
self.object_name = self.params.get('object_name')
self.managed_object = None
if self.object_type == 'VirtualMachine':
self.managed_object = self.pyv.get_vm_or_template(self.object_name)
if self.object_type == 'Datacenter':
self.managed_object = self.pyv.find_datacenter_by_name(
self.object_name)
if self.object_type == 'ClusterComputeResource':
self.managed_object = self.pyv.find_cluster_by_name(
self.object_name)
if self.object_type == 'HostSystem':
self.managed_object = self.pyv.find_hostsystem_by_name(
self.object_name)
if self.object_type == 'DistributedVirtualSwitch':
self.managed_object = find_dvs_by_name(self.pyv.content,
self.object_name)
self.object_type = 'VmwareDistributedVirtualSwitch'
if self.object_type == 'DistributedVirtualPortgroup':
dvs_name, pg_name = self.object_name.split(":", 1)
dv_switch = find_dvs_by_name(self.pyv.content, dvs_name)
if dv_switch is None:
self.module.fail_json(
msg=
"A distributed virtual switch with name %s does not exist"
% dvs_name)
self.managed_object = find_dvspg_by_name(dv_switch, pg_name)
if self.managed_object is None:
self.module.fail_json(
msg="Failed to find the managed object for %s with type %s" %
(self.object_name, self.object_type))
if not hasattr(self.managed_object, '_moId'):
self.module.fail_json(
msg="Unable to find managed object id for %s managed object" %
self.object_name)
self.dynamic_managed_object = DynamicID(type=self.object_type,
id=self.managed_object._moId)
self.tag_service = self.api_client.tagging.Tag
self.category_service = self.api_client.tagging.Category
self.tag_association_svc = self.api_client.tagging.TagAssociation
self.tag_names = self.params.get('tag_names')
def ensure_state(self):
"""
Manage the internal state of tags
"""
results = dict(
changed=False,
tag_status=dict(),
)
changed = False
action = self.params.get('state')
available_tag_obj = self.get_tags_for_object(
tag_service=self.tag_service,
tag_assoc_svc=self.tag_association_svc,
dobj=self.dynamic_managed_object)
_temp_prev_tags = [
"%s:%s" % (tag['category_name'], tag['name']) for tag in
self.get_tags_for_dynamic_obj(self.dynamic_managed_object)
]
results['tag_status']['previous_tags'] = _temp_prev_tags
results['tag_status']['desired_tags'] = self.tag_names
# Check if category and tag combination exists as per user request
removed_tags_for_set = False
for tag in self.tag_names:
category_obj, category_name, tag_name = None, None, None
if isinstance(tag, dict):
tag_name = tag.get('tag')
category_name = tag.get('category')
if category_name:
# User specified category
category_obj = self.search_svc_object_by_name(
self.category_service, category_name)
if not category_obj:
self.module.fail_json(
msg="Unable to find the category %s" %
category_name)
elif isinstance(tag, str):
if ":" in tag:
# User specified category
category_name, tag_name = tag.split(":", 1)
category_obj = self.search_svc_object_by_name(
self.category_service, category_name)
if not category_obj:
self.module.fail_json(
msg="Unable to find the category %s" %
category_name)
else:
# User specified only tag
tag_name = tag
if category_name:
tag_obj = self.get_tag_by_category(tag_name=tag_name,
category_name=category_name)
else:
tag_obj = self.get_tag_by_name(tag_name=tag_name)
if not tag_obj:
self.module.fail_json(msg="Unable to find the tag %s" %
tag_name)
if action in ('add', 'present'):
if tag_obj not in available_tag_obj:
# Tag is not already applied
try:
self.tag_association_svc.attach(
tag_id=tag_obj.id,
object_id=self.dynamic_managed_object)
changed = True
except Error as error:
self.module.fail_json(msg="%s" %
self.get_error_message(error))
elif action == 'set':
# Remove all tags first
try:
if not removed_tags_for_set:
for av_tag in available_tag_obj:
self.tag_association_svc.detach(
tag_id=av_tag.id,
object_id=self.dynamic_managed_object)
removed_tags_for_set = True
self.tag_association_svc.attach(
tag_id=tag_obj.id,
object_id=self.dynamic_managed_object)
changed = True
except Error as error:
self.module.fail_json(msg="%s" %
self.get_error_message(error))
elif action in ('remove', 'absent'):
if tag_obj in available_tag_obj:
try:
self.tag_association_svc.detach(
tag_id=tag_obj.id,
object_id=self.dynamic_managed_object)
changed = True
except Error as error:
self.module.fail_json(msg="%s" %
self.get_error_message(error))
_temp_curr_tags = [
"%s:%s" % (tag['category_name'], tag['name']) for tag in
self.get_tags_for_dynamic_obj(self.dynamic_managed_object)
]
results['tag_status']['current_tags'] = _temp_curr_tags
results['changed'] = changed
self.module.exit_json(**results)
class VmwareContentLibCreate(VmwareRestClient):
def __init__(self, module):
"""Constructor."""
super(VmwareContentLibCreate, self).__init__(module)
self.content_service = self.api_client
self.local_libraries = dict()
# Track all existing library names, to block update/delete if duplicates exist
self.existing_library_names = []
self.library_name = self.params.get('library_name')
self.library_description = self.params.get('library_description')
self.library_type = self.params.get('library_type')
self.library_types = dict()
self.subscription_url = self.params.get('subscription_url')
self.ssl_thumbprint = self.params.get('ssl_thumbprint')
self.datastore_name = self.params.get('datastore_name')
self.update_on_demand = self.params.get('update_on_demand')
self.library_types = {
'local': self.content_service.content.LocalLibrary,
'subscribed': self.content_service.content.SubscribedLibrary
}
# Import objects of both types to prevent duplicate names
self.get_all_libraries(self.library_types['local'])
self.get_all_libraries(self.library_types['subscribed'])
# Set library type for create/update actions
self.library_service = self.library_types[self.library_type]
self.pyv = PyVmomi(module=module)
def process_state(self):
"""
Manage states of Content Library
"""
self.desired_state = self.params.get('state')
library_states = {
'absent': {
'present': self.state_destroy_library,
'absent': self.state_exit_unchanged,
},
'present': {
'present': self.state_update_library,
'absent': self.state_create_library,
}
}
library_states[self.desired_state][
self.check_content_library_status()]()
def get_all_libraries(self, library_service):
content_libs = library_service.list()
if content_libs:
for content_lib in content_libs:
lib_details = library_service.get(content_lib)
lib_dict = dict(lib_name=lib_details.name,
lib_description=lib_details.description,
lib_id=lib_details.id,
lib_type=lib_details.type)
if lib_details.type == "SUBSCRIBED":
lib_dict[
"lib_sub_url"] = lib_details.subscription_info.subscription_url
lib_dict[
"lib_sub_on_demand"] = lib_details.subscription_info.on_demand
lib_dict[
"lib_sub_ssl_thumbprint"] = lib_details.subscription_info.ssl_thumbprint
self.local_libraries[lib_details.name] = lib_dict
self.existing_library_names.append(lib_details.name)
def check_content_library_status(self):
"""
Check if Content Library exists or not
Returns: 'present' if library found, else 'absent'
"""
ret = 'present' if self.library_name in self.local_libraries else 'absent'
return ret
def fail_when_duplicated(self):
if self.existing_library_names.count(self.library_name) > 1:
self.module.fail_json(
msg="Operation cannot continue, library [%s] is not unique" %
self.library_name)
def state_exit_unchanged(self):
"""
Return unchanged state
"""
self.module.exit_json(changed=False)
def set_subscription_spec(self):
if "https:" in self.subscription_url and not self.ssl_thumbprint:
self.module.fail_json(
msg="While using HTTPS, a SSL thumbprint must be provided.")
subscription_info = SubscriptionInfo()
subscription_info.on_demand = self.update_on_demand
subscription_info.automatic_sync_enabled = True
subscription_info.subscription_url = self.subscription_url
if "https:" in self.subscription_url:
subscription_info.ssl_thumbprint = self.ssl_thumbprint
return subscription_info
def create_update(self, spec, library_id=None, update=False):
"""
Create or update call and exit cleanly if call completes
"""
if self.module.check_mode:
action = 'would be updated' if update else 'would be created'
else:
try:
if update:
self.library_service.update(library_id, spec)
action = "updated"
else:
library_id = self.library_service.create(create_spec=spec,
client_token=str(
uuid.uuid4()))
action = "created"
except ResourceInaccessible as e:
message = (
"vCenter Failed to make connection to %s with exception: %s "
"If using HTTPS, check that the SSL thumbprint is valid" %
(self.subscription_url, str(e)))
self.module.fail_json(msg=message)
content_library_info = dict(
msg="Content Library '%s' %s." % (spec.name, action),
library_id=library_id,
library_description=self.library_description,
library_type=spec.type,
)
if spec.type == "SUBSCRIBED":
content_library_info[
"library_subscription_url"] = spec.subscription_info.subscription_url
content_library_info[
"library_subscription_on_demand"] = spec.subscription_info.on_demand
content_library_info[
"library_subscription_ssl_thumbprint"] = spec.subscription_info.ssl_thumbprint
self.module.exit_json(changed=True,
content_library_info=content_library_info)
def state_create_library(self):
# Fail if no datastore is specified
if not self.datastore_name:
self.module.fail_json(
msg="datastore_name must be specified for create operations")
# Find the datastore by the given datastore name
datastore_id = self.pyv.find_datastore_by_name(
datastore_name=self.datastore_name)
if not datastore_id:
self.module.fail_json(msg="Failed to find the datastore %s" %
self.datastore_name)
self.datastore_id = datastore_id._moId
# Build the storage backing for the library to be created
storage_backings = []
storage_backing = StorageBacking(type=StorageBacking.Type.DATASTORE,
datastore_id=self.datastore_id)
storage_backings.append(storage_backing)
# Build the specification for the library to be created
create_spec = LibraryModel()
create_spec.name = self.library_name
create_spec.description = self.library_description
self.library_types = {
'local': create_spec.LibraryType.LOCAL,
'subscribed': create_spec.LibraryType.SUBSCRIBED
}
create_spec.type = self.library_types[self.library_type]
create_spec.storage_backings = storage_backings
# Build subscribed specification
if self.library_type == "subscribed":
subscription_info = self.set_subscription_spec()
subscription_info.authentication_method = SubscriptionInfo.AuthenticationMethod.NONE
create_spec.subscription_info = subscription_info
self.create_update(spec=create_spec)
def state_update_library(self):
"""
Update Content Library
"""
self.fail_when_duplicated()
changed = False
library_id = self.local_libraries[self.library_name]['lib_id']
library_update_spec = LibraryModel()
# Ensure library types are consistent
existing_library_type = self.local_libraries[
self.library_name]['lib_type'].lower()
if existing_library_type != self.library_type:
self.module.fail_json(
msg="Library [%s] is of type %s, cannot be changed to %s" %
(self.library_name, existing_library_type, self.library_type))
# Compare changeable subscribed attributes
if self.library_type == "subscribed":
existing_subscription_url = self.local_libraries[
self.library_name]['lib_sub_url']
sub_url_changed = (existing_subscription_url !=
self.subscription_url)
existing_on_demand = self.local_libraries[
self.library_name]['lib_sub_on_demand']
sub_on_demand_changed = (existing_on_demand !=
self.update_on_demand)
sub_ssl_thumbprint_changed = False
if "https:" in self.subscription_url and self.ssl_thumbprint:
existing_ssl_thumbprint = self.local_libraries[
self.library_name]['lib_sub_ssl_thumbprint']
sub_ssl_thumbprint_changed = (existing_ssl_thumbprint !=
self.ssl_thumbprint)
if sub_url_changed or sub_on_demand_changed or sub_ssl_thumbprint_changed:
subscription_info = self.set_subscription_spec()
library_update_spec.subscription_info = subscription_info
changed = True
# Compare description
library_desc = self.local_libraries[
self.library_name]['lib_description']
desired_lib_desc = self.params.get('library_description')
if library_desc != desired_lib_desc:
library_update_spec.description = desired_lib_desc
changed = True
if changed:
library_update_spec.name = self.library_name
self.create_update(spec=library_update_spec,
library_id=library_id,
update=True)
content_library_info = dict(msg="Content Library %s is unchanged." %
self.library_name,
library_id=library_id)
self.module.exit_json(changed=False,
content_library_info=dict(
msg=content_library_info,
library_id=library_id))
def state_destroy_library(self):
"""
Delete Content Library
"""
self.fail_when_duplicated()
library_id = self.local_libraries[self.library_name]['lib_id']
# Setup library service based on existing object type to allow library_type to unspecified
library_service = self.library_types[self.local_libraries[
self.library_name]['lib_type'].lower()]
if self.module.check_mode:
action = 'would be deleted'
else:
action = 'deleted'
library_service.delete(library_id=library_id)
self.module.exit_json(
changed=True,
content_library_info=dict(msg="Content Library '%s' %s." %
(self.library_name, action),
library_id=library_id))
class VmwareContentDeployTemplate(VmwareRestClient):
def __init__(self, module):
"""Constructor."""
super(VmwareContentDeployTemplate, self).__init__(module)
self.pyv = PyVmomi(module=module)
vm = self.pyv.get_vm()
if vm:
self.module.exit_json(
changed=False,
vm_deploy_info=dict(
msg="Virtual Machine '%s' already exists." %
self.module.params['name'],
vm_id=vm._moId,
))
self.template_service = self.api_client.vcenter.vm_template.LibraryItems
self.template_name = self.params.get('template')
self.content_library_name = self.params.get('content_library')
self.vm_name = self.params.get('name')
self.datacenter = self.params.get('datacenter')
self.datastore = self.params.get('datastore')
self.datastore_cluster = self.params.get('datastore_cluster')
self.datastore_id = None
self.folder = self.params.get('folder')
self.resourcepool = self.params.get('resource_pool')
self.cluster = self.params.get('cluster')
self.host = self.params.get('host')
def deploy_vm_from_template(self, power_on=False):
# Find the datacenter by the given datacenter name
self.datacenter_id = self.get_datacenter_by_name(
datacenter_name=self.datacenter)
if not self.datacenter_id:
self.module.fail_json(msg="Failed to find the datacenter %s" %
self.datacenter)
if self.datastore:
# Find the datastore by the given datastore name
self.datastore_id = self.get_datastore_by_name(
self.datacenter, self.datastore)
if self.datastore_cluster:
# Find the datastore by the given datastore cluster name
datastore_cluster = self.pyv.find_datastore_cluster_by_name(
self.datastore_cluster,
folder=self.datastore_id.datastoreFolder)
if not datastore_cluster:
self.module.fail_json(
msg="Failed to find the datastore cluster %s" %
self.datastore_cluster)
self.datastore_id = self.pyv.get_recommended_datastore(
datastore_cluster)
if not self.datastore_id:
if self.datastore:
self.module.fail_json(msg="Failed to find the datastore %s" %
self.datastore)
if self.datastore_cluster:
self.module.fail_json(
msg=
"Failed to find the datastore using datastore cluster %s" %
self.datastore_cluster)
# Find the LibraryItem (Template) by the given LibraryItem name
if self.content_library_name:
self.library_item_id = self.get_library_item_from_content_library_name(
self.template_name, self.content_library_name)
if not self.library_item_id:
self.module.fail_json(
msg=
"Failed to find the library Item %s in content library %s"
% (self.template_name, self.content_library_name))
else:
self.library_item_id = self.get_library_item_by_name(
self.template_name)
if not self.library_item_id:
self.module.fail_json(
msg="Failed to find the library Item %s" %
self.template_name)
# Find the folder by the given folder name
self.folder_id = self.get_folder_by_name(self.datacenter, self.folder)
if not self.folder_id:
self.module.fail_json(msg="Failed to find the folder %s" %
self.folder)
# Find the Host by given HostName
self.host_id = None
if self.host:
self.host_id = self.get_host_by_name(self.datacenter, self.host)
if not self.host_id:
self.module.fail_json(msg="Failed to find the Host %s" %
self.host)
# Find the resourcepool by the given resourcepool name
self.cluster_id = None
self.resourcepool_id = None
if self.resourcepool:
self.resourcepool_id = self.get_resource_pool_by_name(
self.datacenter, self.resourcepool, self.cluster, self.host)
if not self.resourcepool_id:
self.module.fail_json(
msg="Failed to find the resource_pool %s" %
self.resourcepool)
# Find the Cluster by the given Cluster name
if self.cluster:
self.cluster_id = self.get_cluster_by_name(self.datacenter,
self.cluster)
if not self.cluster_id:
self.module.fail_json(msg="Failed to find the Cluster %s" %
self.cluster)
cluster_obj = self.api_client.vcenter.Cluster.get(self.cluster_id)
self.resourcepool_id = cluster_obj.resource_pool
# Create VM placement specs
self.placement_spec = LibraryItems.DeployPlacementSpec(
folder=self.folder_id)
if self.host_id:
self.placement_spec.host = self.host_id
if self.resourcepool_id:
self.placement_spec.resource_pool = self.resourcepool_id
if self.cluster_id:
self.placement_spec.cluster = self.cluster_id
self.vm_home_storage_spec = LibraryItems.DeploySpecVmHomeStorage(
datastore=to_native(self.datastore_id))
self.disk_storage_spec = LibraryItems.DeploySpecDiskStorage(
datastore=to_native(self.datastore_id))
self.deploy_spec = LibraryItems.DeploySpec(
name=self.vm_name,
placement=self.placement_spec,
vm_home_storage=self.vm_home_storage_spec,
disk_storage=self.disk_storage_spec,
powered_on=power_on)
vm_id = ''
try:
vm_id = self.template_service.deploy(self.library_item_id,
self.deploy_spec)
except Error as error:
self.module.fail_json(msg="%s" % self.get_error_message(error))
except Exception as err:
self.module.fail_json(msg="%s" % to_native(err))
if vm_id:
self.module.exit_json(changed=True,
vm_deploy_info=dict(
msg="Deployed Virtual Machine '%s'." %
self.vm_name,
vm_id=vm_id,
))
self.module.exit_json(changed=False,
vm_deploy_info=dict(
msg="Virtual Machine deployment failed",
vm_id=vm_id))
class VmwareContentDeployOvfTemplate(VmwareRestClient):
def __init__(self, module):
"""Constructor."""
super(VmwareContentDeployOvfTemplate, self).__init__(module)
# Initialize member variables
self.module = module
self._pyv = PyVmomi(module=module)
self._template_service = self.api_client.vcenter.vm_template.LibraryItems
self._datacenter_id = None
self._datastore_id = None
self._library_item_id = None
self._folder_id = None
self._host_id = None
self._cluster_id = None
self._resourcepool_id = None
self.result = {}
# Turn on debug if not specified, but ANSIBLE_DEBUG is set
if self.module._debug:
self.warn('Enable debug output because ANSIBLE_DEBUG was set.')
self.params['log_level'] = 'debug'
self.log_level = self.params['log_level']
if self.log_level == 'debug':
# Turn on debugging
self.result['debug'] = {}
# Get parameters
self.template = self.params.get('template')
self.library = self.params.get('library')
self.vm_name = self.params.get('name')
self.datacenter = self.params.get('datacenter')
self.datastore = self.params.get('datastore')
self.datastore_cluster = self.params.get('datastore_cluster')
self.folder = self.params.get('folder')
self.resourcepool = self.params.get('resource_pool')
self.cluster = self.params.get('cluster')
self.host = self.params.get('host')
self.storage_provisioning = self.params['storage_provisioning']
if self.storage_provisioning == 'eagerzeroedthick':
self.storage_provisioning = 'eagerZeroedThick'
vm = self._pyv.get_vm()
if vm:
self.result['vm_deploy_info'] = dict(
msg="Virtual Machine '%s' already Exists." % self.vm_name,
vm_id=vm._moId,
)
self._fail(msg="Virtual Machine deployment failed")
def deploy_vm_from_ovf_template(self):
# Find the datacenter by the given datacenter name
self._datacenter_id = self.get_datacenter_by_name(self.datacenter)
if not self._datacenter_id:
self._fail(msg="Failed to find the datacenter %s" %
self.datacenter)
# Find the datastore by the given datastore name
if self.datastore:
self._datastore_id = self.get_datastore_by_name(
self.datacenter, self.datastore)
if not self._datastore_id:
self._fail(msg="Failed to find the datastore %s" %
self.datastore)
# Find the datastore by the given datastore cluster name
if self.datastore_cluster and not self._datastore_id:
dsc = self._pyv.find_datastore_cluster_by_name(
self.datastore_cluster)
if dsc:
self.datastore = self._pyv.get_recommended_datastore(dsc)
self._datastore_id = self.get_datastore_by_name(
self.datacenter, self.datastore)
else:
self._fail(msg="Failed to find the datastore cluster %s" %
self.datastore_cluster)
if not self._datastore_id:
self._fail(
msg=
"Failed to find the datastore using either datastore or datastore cluster"
)
# Find the LibraryItem (Template) by the given LibraryItem name
if self.library:
self._library_item_id = self.get_library_item_from_content_library_name(
self.template, self.library)
if not self._library_item_id:
self._fail(
msg=
"Failed to find the library Item %s in content library %s"
% (self.template, self.library))
else:
self._library_item_id = self.get_library_item_by_name(
self.template)
if not self._library_item_id:
self._fail(msg="Failed to find the library Item %s" %
self.template)
# Find the folder by the given FQPN folder name
# The FQPN is I(datacenter)/I(folder type)/folder name/... for
# example Lab/vm/someparent/myfolder is a vm folder in the Lab datacenter.
folder_obj = self._pyv.find_folder_by_fqpn(self.folder,
self.datacenter,
folder_type='vm')
if folder_obj:
self._folder_id = folder_obj._moId
if not self._folder_id:
self._fail(msg="Failed to find the folder %s" % self.folder)
# Find the Host by the given name
if self.host:
self._host_id = self.get_host_by_name(self.datacenter, self.host)
if not self._host_id:
self._fail(msg="Failed to find the Host %s" % self.host)
# Find the Cluster by the given Cluster name
if self.cluster:
self._cluster_id = self.get_cluster_by_name(
self.datacenter, self.cluster)
if not self._cluster_id:
self._fail(msg="Failed to find the Cluster %s" % self.cluster)
cluster_obj = self.api_client.vcenter.Cluster.get(self._cluster_id)
self._resourcepool_id = cluster_obj.resource_pool
# Find the resourcepool by the given resourcepool name
if self.resourcepool and self.cluster and self.host:
self._resourcepool_id = self.get_resource_pool_by_name(
self.datacenter, self.resourcepool, self.cluster, self.host)
if not self._resourcepool_id:
self._fail(msg="Failed to find the resource_pool %s" %
self.resourcepool)
if not self._resourcepool_id:
self._fail(
msg="Failed to find a resource pool either by name or cluster")
deployment_target = LibraryItem.DeploymentTarget(
resource_pool_id=self._resourcepool_id, folder_id=self._folder_id)
self.ovf_summary = self.api_client.vcenter.ovf.LibraryItem.filter(
ovf_library_item_id=self._library_item_id,
target=deployment_target)
self.deploy_spec = LibraryItem.ResourcePoolDeploymentSpec(
name=self.vm_name,
annotation=self.ovf_summary.annotation,
accept_all_eula=True,
network_mappings=None,
storage_mappings=None,
storage_provisioning=self.storage_provisioning,
storage_profile_id=None,
locale=None,
flags=None,
additional_parameters=None,
default_datastore_id=self._datastore_id)
response = {'succeeded': False}
try:
response = self.api_client.vcenter.ovf.LibraryItem.deploy(
self._library_item_id, deployment_target, self.deploy_spec)
except Error as error:
self._fail(msg="%s" % self.get_error_message(error))
except Exception as err:
self._fail(msg="%s" % to_native(err))
if not response.succeeded:
self.result['vm_deploy_info'] = dict(
msg="Virtual Machine deployment failed", vm_id='')
self._fail(msg="Virtual Machine deployment failed")
self.result['changed'] = True
self.result['vm_deploy_info'] = dict(
msg="Deployed Virtual Machine '%s'." % self.vm_name,
vm_id=response.resource_id.id,
)
self._exit()
#
# Wrap AnsibleModule methods
#
def _mod_debug(self):
if self.log_level == 'debug':
self.result['debug'].update(
dict(
datacenter_id=self._datacenter_id,
datastore_id=self._datastore_id,
library_item_id=self._library_item_id,
folder_id=self._folder_id,
host_id=self._host_id,
cluster_id=self._cluster_id,
resourcepool_id=self._resourcepool_id,
))
def _fail(self, msg):
self._mod_debug()
self.module.fail_json(msg=msg, **self.result)
def _exit(self):
self._mod_debug()
self.module.exit_json(**self.result)