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=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 = 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)
self.object_type = self.params.get('object_type')
self.object_name = self.params.get('object_name')
if self.object_type == 'VirtualMachine':
self.managed_object = self.pyv.get_vm_or_template(self.object_name)
self.dynamic_managed_object = DynamicID(
type=self.object_type, id=self.managed_object._moId)
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))
self.tag_service = Tag(self.connect)
self.category_service = Category(self.connect)
self.tag_association_svc = TagAssociation(self.connect)
self.tag_names = self.params.get('tag_names')
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'),
folder=dict(type='str', default='/vm'),
question=dict(type='str', required=True),
answer=dict(type='str', required=True),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[
['name', 'uuid'],
],
)
result = dict(changed=True,)
pyv = PyVmomi(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
if vm:
# VM exists
result['answer'] = answer_vm(vm=vm, question=module.params['question'], answer=module.params['answer'])
else:
module.fail_json(msg="Unable to answer non-existing virtual machine : '%s'" % (module.params.get('uuid') or module.params.get('name')))
module.exit_json(**result)
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 test_vmdk_disk_path_split(mocker, fake_ansible_module):
""" Test vmdk_disk_path_split function"""
fake_ansible_module.params = test_data[0][0]
mocker.patch('ansible.module_utils.vmware.connect_to_api', new=fake_connect_to_api)
pyv = PyVmomi(fake_ansible_module)
v = pyv.vmdk_disk_path_split('[ds1] VM_0001/VM0001_0.vmdk')
assert v == ('ds1', 'VM_0001/VM0001_0.vmdk', 'VM0001_0.vmdk', 'VM_0001')
def test_vmdk_disk_path_split_negative(mocker, fake_ansible_module):
""" Test vmdk_disk_path_split function"""
fake_ansible_module.params = test_data[0][0]
mocker.patch('ansible.module_utils.vmware.connect_to_api', new=fake_connect_to_api)
with pytest.raises(FailJson) as exec_info:
pyv = PyVmomi(fake_ansible_module)
pyv.vmdk_disk_path_split('[ds1]')
assert 'Bad path' in exec_info.value.kwargs['msg']
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),
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')
)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[['name', 'uuid']],
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_VCLOUD:
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/60/vcloudsuite-python")
vm_rest_client = VmwareTag(module)
instance.update(
tags=vm_rest_client.get_vm_tags(vm_rest_client.tag_service,
vm_rest_client.tag_association_svc,
vm_mid=vm._moId)
)
module.exit_json(instance=instance)
except Exception as exc:
module.fail_json(msg="Fact gather failed with exception %s" % to_text(exc))
else:
module.fail_json(msg="Unable to gather facts for non-existing VM %s" % (module.params.get('uuid') or
module.params.get('name')))
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(
name=dict(type='str'),
name_match=dict(type='str', choices=['first', 'last'],
default='first'),
uuid=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[
['name', 'uuid'],
],
)
result = dict(changed=False, )
pyv = PyVmomi(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
if vm:
facts = pyv.gather_facts(vm)
power_state = facts['hw_power_status'].lower()
# VMware will fail the ReconfigVM_Task if the VM is powered on. For idempotency
# in our UAT automation, we need to exit 'OK' and not change the VM if it is powered on.
if power_state == 'poweredoff':
result['uuid'] = str(uuid())
config_spec = vim.vm.ConfigSpec()
config_spec.uuid = result['uuid']
try:
task = vm.ReconfigVM_Task(config_spec)
result['changed'], info = wait_for_task(task)
except vmodl.fault.InvalidRequest as e:
self.module.fail_json(
msg=
"Failed to modify bios.uuid of virtual machine due to invalid configuration "
"parameter %s" % to_native(e.msg))
else:
module.fail_json(
msg=
"Unable to set bios uuid for non-existing virtual machine : '%s'" %
(module.params.get('uuid') or module.params.get('name')))
module.exit_json(**result)
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
vm=dict(type='str', required=True),
uuid=dict(type='str', required=True),
tags=dict(type='dict', required=True),
category_ids=dict(type='dict', required=True),
)
module = AnsibleModule(argument_spec=argument_spec)
pyv = PyVmomi(module)
vm = pyv.get_vm()
vmware_tag = VmwareTag(module)
result = vmware_tag.apply_tags(vm._moId, module.params['category_ids'],
module.params['tags'])
module.exit_json()
def test_pyvmomi_lib_exists(mocker, fake_ansible_module):
""" Test if Pyvmomi is present or not"""
mocker.patch('ansible.module_utils.vmware.HAS_PYVMOMI', new=False)
with pytest.raises(FailJson) as exec_info:
PyVmomi(fake_ansible_module)
assert 'Failed to import the required Python library (PyVmomi) on' in exec_info.value.kwargs['msg']
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
state=dict(type='str',
default='present',
choices=[
'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'),
folder=dict(type='str', default='/vm'),
force=dict(type='bool', default=False),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[
['name', 'uuid'],
],
)
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
result = set_vm_power_state(pyv.content, vm, module.params['state'],
module.params['force'])
else:
module.fail_json(
msg=
"Unable to set power state for non-existing virtual machine : '%s'"
% (module.params.get('uuid') or module.params.get('name')))
if result.get('failed') is True:
module.fail_json(**result)
module.exit_json(**result)
def test_requests_lib_exists(mocker, fake_ansible_module):
""" Test if requests is present or not"""
mocker.patch('ansible.module_utils.vmware.HAS_REQUESTS', new=False)
with pytest.raises(FailJson) as exec_info:
PyVmomi(fake_ansible_module)
msg = "Unable to find 'requests' Python library which is required. Please install using 'pip install requests'"
assert msg == exec_info.value.kwargs['msg']
def test_pyvmomi_lib_exists(mocker, fake_ansible_module):
""" Test if Pyvmomi is present or not"""
mocker.patch('ansible.module_utils.vmware.HAS_PYVMOMI', new=False)
with pytest.raises(FailJson) as exec_info:
PyVmomi(fake_ansible_module)
assert 'PyVmomi Python module required. Install using "pip install PyVmomi"' == exec_info.value.kwargs[
'msg']
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']])
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 test_validate_certs(mocker, fake_ansible_module):
""" Test if SSL is required or not"""
fake_ansible_module.params = test_data[3][0]
mocker.patch('ansible.module_utils.vmware.ssl', new=None)
with pytest.raises(FailJson) as exec_info:
PyVmomi(fake_ansible_module)
msg = 'pyVim does not support changing verification mode with python < 2.7.9.' \
' Either update python or use validate_certs=false.'
assert msg == exec_info.value.kwargs['msg']
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'),
folder=dict(type='str', default='/vm'),
bootdelay=dict(type='int'),
bootorder=dict(type='list'),
bootretrydelay=dict(type='int'),
bootretry=dict(type='bool'),
enterbios=dict(type='bool'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[
['name', 'uuid'],
],
)
pyv = PyVmomi(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
if vm:
result = build_hardware_map(vm, vim)
#result = get_boot_options_vm(vm=vm)
#changed, configspec = compare_boot_options(vim, result, module.params)
else:
module.fail_json(
msg=
"Unable to set boot options on non-existing virtual machine : '%s'"
% (module.params.get('uuid') or module.params.get('name')))
module.exit_json(**result)
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
def test_validate_certs(mocker, fake_ansible_module):
""" Test if SSL is required or not"""
fake_ansible_module.params = dict(
username='******',
password='******',
hostname='esxi1',
validate_certs=True,
)
mocker.patch('ansible.module_utils.vmware.ssl', new=None)
with pytest.raises(FailJson) as exec_info:
PyVmomi(fake_ansible_module)
msg = 'pyVim does not support changing verification mode with python < 2.7.9.' \
' Either update python or use validate_certs=false.'
assert msg == exec_info.value.kwargs['msg']
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'),
folder=dict(type='str', default='/vm'),
force=dict(type='bool', default=False),
scheduled_at=dict(type='str'),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[
['name', 'uuid'],
],
)
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 = {
'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_desc = 'Schedule task for vm %s for operation %s at %s' % (vm.name,
module.params.get('state'),
scheduled_at)
schedule_task_spec.name = schedule_task_desc
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.get('state')]
schedule_task_spec.enabled = True
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(chanaged=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'])
else:
module.fail_json(msg="Unable to set power state for non-existing virtual machine : '%s'" % (module.params.get('uuid') or module.params.get('name')))
if result.get('failed') is True:
module.fail_json(**result)
module.exit_json(**result)
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'),
folder=dict(type='str', default='/vm'),
force=dict(type='bool', default=False),
scheduled_at=dict(type='str'),
state_change_timeout=dict(type='int', default=0),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[
['name', 'uuid'],
],
)
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 = {
'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_desc = 'Schedule task for vm %s for operation %s at %s' % (vm.name,
module.params.get('state'),
scheduled_at)
schedule_task_spec.name = schedule_task_desc
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.get('state')]
schedule_task_spec.enabled = True
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(chanaged=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'])
else:
module.fail_json(msg="Unable to set power state for non-existing virtual machine : '%s'" % (module.params.get('uuid') or module.params.get('name')))
if result.get('failed') is True:
module.fail_json(**result)
module.exit_json(**result)
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)
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 is_tag_category(self, cat_obj, tag_obj):
for tag in self.tag_service.list_tags_for_category(cat_obj.id):
if tag_obj.name == self.tag_service.get(tag).name:
return True
return False
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)
# Already existing tags from the given object
avail_tag_obj_name_list = [tag.name for tag in available_tag_obj]
results['tag_status']['previous_tags'] = avail_tag_obj_name_list
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 ":" 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
tag_obj = self.search_svc_object_by_name(self.tag_service, tag_name)
if not tag_obj:
self.module.fail_json(msg="Unable to find the tag %s" % tag_name)
if category_name and category_obj and not self.is_tag_category(category_obj, tag_obj):
self.module.fail_json(msg="Category %s does not contain tag %s" % (category_name, 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))
results['tag_status']['current_tags'] = [tag.name for tag in self.get_tags_for_object(self.tag_service,
self.tag_association_svc,
self.dynamic_managed_object)]
results['changed'] = changed
self.module.exit_json(**results)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
disk_provisioning=dict(type='str',
default='thin',
choices=[
'flat', 'eagerZeroedThick',
'monolithicSparse', 'twoGbMaxExtentSparse',
'twoGbMaxExtentFlat', 'thin', 'sparse',
'thick', 'seSparse', 'monolithicFlat'
]),
name=dict(type='str', required=True),
datacenter=dict(type='str', default='ha-datacenter'),
datastore=dict(type='str', default='datastore1'),
resource_pool=dict(type='str', default='Resources'),
name_match=dict(type='str', choices=['first', 'last'],
default='first'),
networks=dict(type='list', default=[]),
property_map=dict(type='dict', default={}),
deployment_option=dict(type='str', default=None),
uuid=dict(type='str'),
folder=dict(type='str', default='/vm'),
ovf_networks=dict(type='dict', default={'VM Network': 'VM Network'}),
ovf=dict(type=path_exists),
force=dict(type='bool', default=False),
power_on=dict(type='bool', default=True),
wait=dict(type='bool', default=True),
wait_for_ip_address=dict(type='bool', default=True),
guest_id=dict(type='str'),
customization=dict(type='dict', default={}, no_log=True),
)
module = AnsibleModule(argument_spec=argument_spec, )
if not module.params['power_on'] and (module.params['wait_for_ip_address']
or module.params['wait']):
module.fail_json(msg='Cannot wait for VM when power_on=False')
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi python library not found')
pyv_ovf = PyVmomi(module)
pyv_vmomihelper = PyVmomiHelper(module)
vm_ovf = pyv_ovf.get_vm()
#vm_find = find_vm_by_name()
#vm_ovf_helper = pyv_vmomihelper.get_vm()
deploy_ovf = VMwareDeployOvf(module)
deploy_ovf_PyVmH = PyVmomiHelper(module)
vm = deploy_ovf.get_vm_obj()
if vm:
if vm.runtime.powerState != 'poweredOff':
if module.params['force']:
set_vm_power_state(deploy_ovf_PyVmH.content, vm, 'poweredoff',
module.params['force'])
else:
module.fail_json(
msg=
"Virtual Machine is Powered ON. Please Power Off the VM or use force to power it off before doing any customizations."
)
if module.params['networks'] or module.params['customization']:
deploy_ovf_PyVmH.customize_vm(vm)
myspec = deploy_ovf_PyVmH.customspec
task = vm.CustomizeVM_Task(spec=myspec)
facts = deploy_ovf.vm_power_on(vm)
#wait_for_task(task)
#task_power=vm.PowerOn()
#wait_for_task(task_power)
#facts=pyv_vmomihelper.gather_facts(vm)
#cust=self.customspec
#deploy_ovf_PyVmH.customize_vm(vm_obj=vm)
#customspec = vim.vm.customization.Specification()
else:
module.fail_json(
msg=
"VM already exists in the vCenter..! Use networks or customization parameters to customize the existing VM"
)
else:
#deploy_ovf = VMwareDeployOvf(module)
deploy_ovf.upload()
deploy_ovf.complete()
#facts = deploy_ovf.power_on()
if module.params['networks'] or module.params['customization']:
vm_deploy = deploy_ovf.get_vm_obj()
deploy_ovf_PyVmH.customize_vm(vm_deploy)
myspec = deploy_ovf_PyVmH.customspec
task = vm_deploy.CustomizeVM_Task(spec=myspec)
# custom_wait_for_task(task, module)
try:
wait_for_task(task)
except Exception, e:
module.fail_json(msg="Error:%s" % e.message.msg)
if task.info.state == 'error':
module.fail_json(msg="Error occured: %s" %
to_native(task.info.error.msg))
try:
facts = deploy_ovf.vm_power_on(vm_deploy)
except Exception, e:
module.fail_json(msg="Error from vCenter: %s" % (e.message))
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
remove_unmanaged_tasks=dict(type='bool', default=False),
managed_tasks=dict(type='list', default=[]),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
result = {
"changed": False,
"vCenterScheduledTasksRemoved": [],
"diff": {
"before": [],
"after": []
}
}
pyv = PyVmomi(module)
if not pyv.is_vcenter():
module.fail_json(
msg="vcenter_scheduled_tasks is meant for vCenter, hostname %s "
"is not vCenter server." % module.params.get('hostname'))
existingScheduledTasks = pyv.content.scheduledTaskManager.RetrieveEntityScheduledTask(
)
for existingScheduledTask in existingScheduledTasks:
result['diff']['before'].append(existingScheduledTask.info.name)
diffs = diffcheck(result['diff']['before'], module.params['managed_tasks'])
if diffs:
if module.params['remove_unmanaged_tasks']:
for diff in diffs:
existingScheduledTasks = pyv.content.scheduledTaskManager.RetrieveEntityScheduledTask(
)
for existingScheduledTask in existingScheduledTasks:
if diff == existingScheduledTask.info.name:
existingScheduledTask.RemoveScheduledTask()
result['vCenterScheduledTasksRemoved'].append(diff)
result['changed'] = True
else:
module.debug(
'This task is managed by ansible config - not deleting "%s"'
% diff)
else:
module.debug(
'argurment remove_unmanaged_tasks is false so skipping the removal of unmanaged tasks'
)
else:
module.debug(
'There is no difference between desired state and current state - no changes required'
)
existingScheduledTasks = pyv.content.scheduledTaskManager.RetrieveEntityScheduledTask(
)
for existingScheduledTask in existingScheduledTasks:
result['diff']['after'].append(existingScheduledTask.info.name)
module.exit_json(**result)
def vmware_guest_facts(VcenterConfig: VcenterConfig,
show_attribute=False,
datacenter='Datacenter',
uuid='',
schema='summary',
name='') -> dict:
"""
:param VcenterConfig:
:param show_attribute:
:param datacenter:
:param uuid:
:param schema:
:param name:
:return: {
"annotation": "",
"current_snapshot": null,
"customvalues": {},
"guest_consolidation_needed": false,
"guest_question": null,
"guest_tools_status": "guestToolsNotRunning",
"guest_tools_version": "10247",
"hw_cores_per_socket": 1,
"hw_datastores": [
"ds_226_3"
],
"hw_esxi_host": "10.76.33.226",
"hw_eth0": {
"addresstype": "assigned",
"ipaddresses": null,
"label": "Network adapter 1",
"macaddress": "00:50:56:87:a5:9a",
"macaddress_dash": "00-50-56-87-a5-9a",
"portgroup_key": null,
"portgroup_portkey": null,
"summary": "VM Network"
},
"hw_files": [
"[ds_226_3] ubuntu_t/ubuntu_t.vmx",
"[ds_226_3] ubuntu_t/ubuntu_t.nvram",
"[ds_226_3] ubuntu_t/ubuntu_t.vmsd",
"[ds_226_3] ubuntu_t/vmware.log",
"[ds_226_3] u0001/u0001.vmdk"
],
"hw_folder": "/DC0/vm/Discovered virtual machine",
"hw_guest_full_name": null,
"hw_guest_ha_state": null,
"hw_guest_id": null,
"hw_interfaces": [
"eth0"
],
"hw_is_template": false,
"hw_memtotal_mb": 1024,
"hw_name": "ubuntu_t",
"hw_power_status": "poweredOff",
"hw_processor_count": 1,
"hw_product_uuid": "4207072c-edd8-3bd5-64dc-903fd3a0db04",
"hw_version": "vmx-13",
"instance_uuid": "5007769d-add3-1e12-f1fe-225ae2a07caf",
"ipv4": null,
"ipv6": null,
"module_hw": true,
"snapshots": [],
"tags": [
"backup"
],
"vnc": {}
}
"""
argument_spec = {
'show_attribute': show_attribute,
'datacenter': datacenter,
# 'uuid': uuid,
'schema': schema,
# 'name': name
}
if uuid:
argument_spec['uuid'] = uuid
if name:
argument_spec['name'] = name
argument_spec.update(**VcenterConfig.as_dict())
# print(argument_spec)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
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'):
vm_rest_client = VmwareTag(module)
instance.update(tags=vm_rest_client.get_vm_tags(
vm_rest_client.tag_service,
vm_rest_client.tag_association_svc,
vm_mid=vm._moId))
return instance
# module.exit_json(instance=instance)
except Exception as exc:
module.fail_json(msg="Fact gather failed with exception %s" %
to_text(exc))
else:
module.fail_json(
msg="Unable to gather facts for non-existing VM %s" %
(module.params.get('uuid') or module.params.get('name')))
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')
if self.object_type == 'VirtualMachine':
self.managed_object = self.pyv.get_vm_or_template(self.object_name)
self.dynamic_managed_object = DynamicID(
type=self.object_type, id=self.managed_object._moId)
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))
self.tag_service = Tag(self.connect)
self.category_service = Category(self.connect)
self.tag_association_svc = TagAssociation(self.connect)
self.tag_names = self.params.get('tag_names')
def is_tag_category(self, cat_obj, tag_obj):
for tag in self.tag_service.list_tags_for_category(cat_obj.id):
if tag_obj.name == self.tag_service.get(tag).name:
return True
return False
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)
# Already existing tags from the given object
avail_tag_obj_name_list = [tag.name for tag in available_tag_obj]
results['tag_status']['previous_tags'] = avail_tag_obj_name_list
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 ":" 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
tag_obj = self.search_svc_object_by_name(self.tag_service,
tag_name)
if not tag_obj:
self.module.fail_json(msg="Unable to find the tag %s" %
tag_name)
if category_name and category_obj and not self.is_tag_category(
category_obj, tag_obj):
self.module.fail_json(
msg="Category %s does not contain tag %s" %
(category_name, tag_name))
if action in ('add', 'present'):
if tag_obj not in available_tag_obj:
# Tag is not already applied
self.tag_association_svc.attach(
tag_id=tag_obj.id,
object_id=self.dynamic_managed_object)
changed = True
elif action == 'set':
# Remove all tags first
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
elif action in ('remove', 'absent'):
if tag_obj in available_tag_obj:
self.tag_association_svc.detach(
tag_id=tag_obj.id,
object_id=self.dynamic_managed_object)
changed = True
results['tag_status']['current_tags'] = [
tag.name for tag in self.get_tags_for_object(
self.tag_service, self.tag_association_svc,
self.dynamic_managed_object)
]
results['changed'] = changed
self.module.exit_json(**results)
