def __init__(self, module, datacenter_name, cluster_name=None):
"""
Doctring: Init
"""
super(VmwareDrsGroupInfoManager, self).__init__(module)
self.__datacenter_name = datacenter_name
self.__datacenter_obj = None
self.__cluster_name = cluster_name
self.__cluster_obj = None
self.__msg = 'Nothing to see here...'
self.__result = dict()
self.__changed = False
if datacenter_name:
datacenter_obj = find_datacenter_by_name(self.content, datacenter_name=datacenter_name)
self.cluster_obj_list = []
if datacenter_obj:
folder = datacenter_obj.hostFolder
self.cluster_obj_list = get_all_objs(self.content, [vim.ClusterComputeResource], folder)
else:
raise Exception("Datacenter '%s' not found" % self.__datacenter_name)
if cluster_name:
cluster_obj = self.find_cluster_by_name(cluster_name=self.__cluster_name)
if cluster_obj is None:
raise Exception("Cluster '%s' not found" % self.__cluster_name)
else:
self.cluster_obj_list = [cluster_obj]
def state_add_rp(self):
changed = True
rp_spec = vim.ResourceConfigSpec()
cpu_alloc = vim.ResourceAllocationInfo()
cpu_alloc.expandableReservation = self.cpu_expandable_reservations
cpu_alloc.limit = int(self.cpu_limit)
cpu_alloc.reservation = int(self.cpu_reservation)
cpu_alloc_shares = vim.SharesInfo()
cpu_alloc_shares.level = self.cpu_shares
cpu_alloc.shares = cpu_alloc_shares
rp_spec.cpuAllocation = cpu_alloc
mem_alloc = vim.ResourceAllocationInfo()
mem_alloc.limit = int(self.mem_limit)
mem_alloc.expandableReservation = self.mem_expandable_reservations
mem_alloc.reservation = int(self.mem_reservation)
mem_alloc_shares = vim.SharesInfo()
mem_alloc_shares.level = self.mem_shares
mem_alloc.shares = mem_alloc_shares
rp_spec.memoryAllocation = mem_alloc
self.dc_obj = find_datacenter_by_name(
self.content, self.datacenter)
self.cluster_obj = find_cluster_by_name_datacenter(
self.dc_obj, self.cluster)
rootResourcePool = self.cluster_obj.resourcePool
rootResourcePool.CreateResourcePool(self.resource_pool, rp_spec)
self.module.exit_json(changed=changed)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(name=dict(type='str', required=True),
datacenter=dict(type='str', required=True),
recursive=dict(type='bool', default=False))
module = AnsibleModule(argument_spec=argument_spec)
try:
pyv = PyVmomiHelper(module)
dc = find_datacenter_by_name(pyv.content, module.params['datacenter'])
if dc is None:
module.fail_json(msg="Failed to find the datacenter %s" %
module.params['datacenter'])
folder = dc.vmFolder
name = module.params['name']
if "/" in name:
paths = name.split("/")
paths.pop()
paths = "/".join(paths)
name = name.split("/").pop()
folder = pyv.find_folder(dc.vmFolder, paths)
if folder is None:
module.fail_json(msg="Unable to find folder: %s" % paths)
vms = []
pyv.find_vms(folder, name, module.params['recursive'], vms)
vms.sort(reverse=True)
module.exit_json(vms=vms)
except Exception as exc:
module.fail_json(msg="Fact gather failed with exception %s" %
to_text(exc))
def get_objects(self):
self.datastore = find_datastore_by_name(self.si,
self.params['datastore'])
if not self.datastore:
self.module.fail_json(msg='%(datastore)s could not be located' %
self.params)
self.datacenter = find_datacenter_by_name(self.si,
self.params['datacenter'])
if not self.datacenter:
self.module.fail_json(msg='%(datacenter)s could not be located' %
self.params)
self.resource_pool = find_resource_pool_by_name(
self.si, self.params['resource_pool'])
if not self.resource_pool:
self.module.fail_json(
msg='%(resource_pool)s could not be located' % self.params)
for key, value in self.params['networks'].items():
network = find_network_by_name(self.si, value)
if not network:
self.module.fail_json(msg='%(network)s could not be located' %
self.params)
network_mapping = vim.OvfManager.NetworkMapping()
network_mapping.name = key
network_mapping.network = network
self.network_mappings.append(network_mapping)
return self.datastore, self.datacenter, self.resource_pool, self.network_mappings
def __init__(self, module):
super(VmwareDrsFactManager, self).__init__(module)
datacenter_name = self.params.get('datacenter', None)
if datacenter_name:
datacenter_obj = find_datacenter_by_name(
self.content, datacenter_name=datacenter_name)
self.cluster_obj_list = []
if datacenter_obj:
folder = datacenter_obj.hostFolder
self.cluster_obj_list = get_all_objs(
self.content, [vim.ClusterComputeResource], folder)
else:
self.module.fail_json(changed=False,
msg="Datacenter '%s' not found" %
datacenter_name)
cluster_name = self.params.get('cluster_name', None)
if cluster_name:
cluster_obj = self.find_cluster_by_name(cluster_name=cluster_name)
if cluster_obj is None:
self.module.fail_json(changed=False,
msg="Cluster '%s' not found" %
cluster_name)
else:
self.cluster_obj_list = [cluster_obj]
def state_add_rp(self):
changed = True
rp_spec = vim.ResourceConfigSpec()
cpu_alloc = vim.ResourceAllocationInfo()
cpu_alloc.expandableReservation = self.cpu_expandable_reservations
cpu_alloc.limit = int(self.cpu_limit)
cpu_alloc.reservation = int(self.cpu_reservation)
cpu_alloc_shares = vim.SharesInfo()
cpu_alloc_shares.level = self.cpu_shares
cpu_alloc.shares = cpu_alloc_shares
rp_spec.cpuAllocation = cpu_alloc
mem_alloc = vim.ResourceAllocationInfo()
mem_alloc.limit = int(self.mem_limit)
mem_alloc.expandableReservation = self.mem_expandable_reservations
mem_alloc.reservation = int(self.mem_reservation)
mem_alloc_shares = vim.SharesInfo()
mem_alloc_shares.level = self.mem_shares
mem_alloc.shares = mem_alloc_shares
rp_spec.memoryAllocation = mem_alloc
self.dc_obj = find_datacenter_by_name(self.content, self.datacenter)
if self.dc_obj is None:
self.module.fail_json(msg="Unable to find datacenter with name %s" % self.datacenter)
self.cluster_obj = find_cluster_by_name(self.content, self.cluster, datacenter=self.dc_obj)
if self.cluster_obj is None:
self.module.fail_json(msg="Unable to find cluster with name %s" % self.cluster)
rootResourcePool = self.cluster_obj.resourcePool
rootResourcePool.CreateResourcePool(self.resource_pool, rp_spec)
self.module.exit_json(changed=changed)
def check_cluster_configuration(self):
"""
Check cluster configuration
Returns: 'Present' if cluster exists, else 'absent'
"""
try:
self.datacenter = find_datacenter_by_name(self.content,
self.datacenter_name)
if self.datacenter is None:
self.module.fail_json(msg="Datacenter %s does not exist." %
self.datacenter_name)
self.cluster = self.find_cluster_by_name(
cluster_name=self.cluster_name)
if self.cluster is None:
return 'absent'
return 'present'
except vmodl.RuntimeFault as runtime_fault:
self.module.fail_json(msg=to_native(runtime_fault.msg))
except vmodl.MethodFault as method_fault:
self.module.fail_json(msg=to_native(method_fault.msg))
except Exception as generic_exc:
self.module.fail_json(msg="Failed to check configuration"
" due to generic exception %s" %
to_native(generic_exc))
def process_state(self):
self.dc_obj = find_datacenter_by_name(self.content, self.datacenter)
if self.dc_obj == None:
self.module.fail_json(msg="Datacenter '%s' not found!" %
(self.datacenter))
try:
folder_states = {
'absent': {
'present': self.state_remove_folder,
'absent': self.state_exit_unchanged,
},
'present': {
'present': self.state_exit_unchanged,
'absent': self.state_add_folder,
}
}
folder_states[self.state][self.check_folder_state()]()
except vmodl.RuntimeFault as runtime_fault:
self.module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
self.module.fail_json(msg=method_fault.msg)
except Exception as e:
self.module.fail_json(msg=str(e))
def check_cluster_configuration(self):
try:
self.datacenter = find_datacenter_by_name(self.content,
self.datacenter_name)
if self.datacenter is None:
self.module.fail_json(
msg="Datacenter %s does not exist, "
"please create first with Ansible Module vmware_datacenter or manually."
% self.datacenter_name)
self.cluster = find_cluster_by_name_datacenter(
self.datacenter, self.cluster_name)
if self.cluster is None:
return 'absent'
else:
desired_state = (self.enable_ha, self.enable_drs,
self.enable_vsan)
current_state = (
self.cluster.configurationEx.dasConfig.enabled,
self.cluster.configurationEx.drsConfig.enabled,
self.cluster.configurationEx.vsanConfigInfo.enabled)
if desired_state != current_state:
return 'update'
else:
return 'present'
except vmodl.RuntimeFault as runtime_fault:
self.module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
self.module.fail_json(msg=method_fault.msg)
def __init__(self, module):
super(VMwareCluster, self).__init__(module)
self.cluster_name = module.params['cluster_name']
self.datacenter_name = module.params['datacenter']
self.enable_ha = module.params['enable_ha']
self.datacenter = None
self.cluster = None
self.host_isolation_response = getattr(
vim.cluster.DasVmSettings.IsolationResponse,
self.params.get('host_isolation_response'))
if self.enable_ha and (
self.params.get('slot_based_admission_control')
or self.params.get('reservation_based_admission_control')
or self.params.get('failover_host_admission_control')):
self.ha_admission_control = True
else:
self.ha_admission_control = False
self.datacenter = find_datacenter_by_name(self.content,
self.datacenter_name)
if self.datacenter is None:
self.module.fail_json(msg="Datacenter %s does not exist." %
self.datacenter_name)
self.cluster = self.find_cluster_by_name(
cluster_name=self.cluster_name)
if self.cluster is None:
self.module.fail_json(msg="Cluster %s does not exist." %
self.cluster_name)
def __init__(self, module):
super(VMwareCluster, self).__init__(module)
self.cluster_name = module.params['cluster_name']
self.datacenter_name = module.params['datacenter']
self.enable_drs = module.params['enable_drs']
self.datacenter = None
self.cluster = None
self.datacenter = find_datacenter_by_name(self.content,
self.datacenter_name)
if self.datacenter is None:
self.module.fail_json(msg="Datacenter %s does not exist." %
self.datacenter_name)
self.cluster = self.find_cluster_by_name(
cluster_name=self.cluster_name)
if self.cluster is None:
self.module.fail_json(msg="Cluster %s does not exist." %
self.cluster_name)
self.advanced_settings = self.params.get('advanced_settings')
if self.advanced_settings:
self.changed_advanced_settings = option_diff(
self.advanced_settings,
self.cluster.configurationEx.drsConfig.option)
else:
self.changed_advanced_settings = None
def check_evc_configuration(self):
"""
Check evc configuration
Returns: 'Present' if evc enabled, else 'absent'
"""
try:
self.datacenter = find_datacenter_by_name(self.content,
self.datacenter_name)
if self.datacenter is None:
self.module.fail_json(msg="Datacenter '%s' does not exist." %
self.datacenter_name)
self.cluster = self.find_cluster_by_name(
cluster_name=self.cluster_name,
datacenter_name=self.datacenter)
if self.cluster is None:
self.module.fail_json(msg="Cluster '%s' does not exist." %
self.cluster_name)
self.evcm = self.cluster.EvcManager()
if not self.evcm:
self.module.fail_json(
msg="Unable to get EVC manager for cluster '%s'." %
self.cluster_name)
self.evc_state = self.evcm.evcState
self.current_evc_mode = self.evc_state.currentEVCModeKey
if not self.current_evc_mode:
return 'absent'
return 'present'
except Exception as generic_exc:
self.module.fail_json(msg="Failed to check configuration"
" due to generic exception %s" %
to_native(generic_exc))
def check_cluster_configuration(self):
try:
self.datacenter = find_datacenter_by_name(self.content, self.datacenter_name)
if self.datacenter is None:
self.module.fail_json(msg="Datacenter %s does not exist, "
"please create first with Ansible Module vmware_datacenter or manually."
% self.datacenter_name)
self.cluster = find_cluster_by_name_datacenter(self.datacenter, self.cluster_name)
if self.cluster is None:
return 'absent'
else:
desired_state = (self.enable_ha,
self.enable_drs,
self.enable_vsan)
current_state = (self.cluster.configurationEx.dasConfig.enabled,
self.cluster.configurationEx.drsConfig.enabled,
self.cluster.configurationEx.vsanConfigInfo.enabled)
if desired_state != current_state:
return 'update'
else:
return 'present'
except vmodl.RuntimeFault as runtime_fault:
self.module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
self.module.fail_json(msg=method_fault.msg)
def __init__(self, module, cluster_name, group_name, state,
datacenter_name=None, vm_list=None, host_list=None):
"""
Init
"""
super(VmwareDrsGroupManager, self).__init__(module)
self.__datacenter_name = datacenter_name
self.__datacenter_obj = None
self.__cluster_name = cluster_name
self.__cluster_obj = None
self.__group_name = group_name
self.__group_obj = None
self.__operation = None
self.__vm_list = vm_list
self.__vm_obj_list = []
self.__host_list = host_list
self.__host_obj_list = []
self.__msg = 'Nothing to see here...'
self.__result = dict()
self.__changed = False
self.__state = state
if datacenter_name is not None:
self.__datacenter_obj = find_datacenter_by_name(self.content, self.__datacenter_name)
if self.__datacenter_obj is None and module.check_mode is False:
raise Exception("Datacenter '%s' not found" % self.__datacenter_name)
self.__cluster_obj = find_cluster_by_name(content=self.content,
cluster_name=self.__cluster_name,
datacenter=self.__datacenter_obj)
# Throw error if cluster does not exist
if self.__cluster_obj is None:
if module.check_mode is False:
raise Exception("Cluster '%s' not found" % self.__cluster_name)
else:
# get group
self.__group_obj = self.__get_group_by_name()
# Set result here. If nothing is to be updated, result is already set
self.__set_result(self.__group_obj)
# Dont populate lists if we are deleting group
if state == 'present':
if self.__group_obj:
self.__operation = 'edit'
else:
self.__operation = 'add'
if self.__vm_list is not None:
self.__set_vm_obj_list(vm_list=self.__vm_list)
if self.__host_list is not None:
self.__set_host_obj_list(host_list=self.__host_list)
else:
self.__operation = 'remove'
def state_add_rp(self):
changed = True
result = None
root_resource_pool = None
rp_spec=vim.ResourceConfigSpec()
cpu_alloc=vim.ResourceAllocationInfo()
cpu_alloc.expandableReservation = self.cpu_expandable_reservations
cpu_alloc.limit = int(self.cpu_limit)
cpu_alloc.reservation = int(self.cpu_reservation)
cpu_alloc_shares = vim.SharesInfo()
cpu_alloc_shares.level = self.cpu_shares
cpu_alloc.shares = cpu_alloc_shares
rp_spec.cpuAllocation = cpu_alloc
mem_alloc = vim.ResourceAllocationInfo()
mem_alloc.limit = int(self.mem_limit)
mem_alloc.expandableReservation = self.mem_expandable_reservations
mem_alloc.reservation = int(self.mem_reservation)
mem_alloc_shares = vim.SharesInfo()
mem_alloc_shares.level = self.mem_shares
mem_alloc.shares = mem_alloc_shares
rp_spec.memoryAllocation = mem_alloc
self.dc_obj = find_datacenter_by_name(self.content, self.datacenter)
self.cluster_obj = find_cluster_by_name_datacenter(self.dc_obj, self.cluster)
rootResourcePool = self.cluster_obj.resourcePool
task = rootResourcePool.CreateResourcePool(self.resource_pool, rp_spec)
self.module.exit_json(changed = changed)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(dict(datacenter=dict(default=None, type='str'),
cluster=dict(default=None, type='str'),
folder=dict(type='str', default='/vm'),
vm_id=dict(required=True, type='str'),
vm_id_type=dict(default='vm_name', type='str', choices=['inventory_path', 'uuid', 'dns_name', 'vm_name']),
vm_username=dict(required=False, type='str'),
vm_password=dict(required=False, type='str', no_log=True),
vm_shell=dict(required=True, type='str'),
vm_shell_args=dict(default=" ", type='str'),
vm_shell_env=dict(default=None, type='list'),
vm_shell_cwd=dict(default=None, type='str')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False,
required_if=[['vm_id_type', 'inventory_path', ['folder']]],
)
if not HAS_PYVMOMI:
module.fail_json(changed=False, msg='pyvmomi is required for this module')
try:
p = module.params
datacenter_name = p['datacenter']
cluster_name = p['cluster']
folder = p['folder']
content = connect_to_api(module)
datacenter = None
if datacenter_name:
datacenter = find_datacenter_by_name(content, datacenter_name)
if not datacenter:
module.fail_json(changed=False, msg="datacenter not found")
cluster = None
if cluster_name:
cluster = find_cluster_by_name(content, cluster_name, datacenter)
if not cluster:
module.fail_json(changed=False, msg="cluster not found")
if p['vm_id_type'] == 'inventory_path':
vm = find_vm_by_id(content, vm_id=p['vm_id'], vm_id_type="inventory_path", folder=folder)
else:
vm = find_vm_by_id(content, vm_id=p['vm_id'], vm_id_type=p['vm_id_type'], datacenter=datacenter, cluster=cluster)
if not vm:
module.fail_json(msg='VM not found')
msg = execute_command(content, vm, p['vm_username'], p['vm_password'],
p['vm_shell'], p['vm_shell_args'], p['vm_shell_env'], p['vm_shell_cwd'])
module.exit_json(changed=True, uuid=vm.summary.config.uuid, msg=msg)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(changed=False, msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(changed=False, msg=method_fault.msg)
except Exception as e:
module.fail_json(changed=False, msg=str(e))
def __init__(self, module):
super(VmwareFolderManager, self).__init__(module)
datacenter_name = self.params.get('datacenter', None)
self.datacenter_obj = find_datacenter_by_name(
self.content, datacenter_name=datacenter_name)
if self.datacenter_obj is None:
self.module.fail_json(msg="Failed to find datacenter %s" %
datacenter_name)
def get_datacenter(context, module):
try:
datacenter_name = module.params.get('datacenter_name')
datacenter = find_datacenter_by_name(context, datacenter_name)
return datacenter
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(msg=method_fault.msg)
def find_host_by_cluster_datacenter(self):
self.dc_obj = find_datacenter_by_name(self.content, self.datacenter)
self.cluster_obj = find_cluster_by_name_datacenter(self.dc_obj, self.cluster)
for host in self.cluster_obj.host:
if host.name == self.hostname:
return host, self.cluster
return None, self.cluster
def state_create_dvs(self):
changed = True
result = None
if not self.module.check_mode:
dc = find_datacenter_by_name(self.content, self.datacenter_name)
changed, result = self.create_dvswitch(dc.networkFolder)
self.module.exit_json(changed=changed, result=str(result))
def get_datacenter(context, module):
try:
datacenter_name = module.params.get('datacenter_name')
datacenter = find_datacenter_by_name(context, datacenter_name)
return datacenter
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(msg=method_fault.msg)
def find_host_by_cluster_datacenter(self):
self.dc_obj = find_datacenter_by_name(self.content, self.datacenter)
self.cluster_obj = find_cluster_by_name_datacenter(self.dc_obj, self.cluster)
for host in self.cluster_obj.host:
if host.name == self.hostname:
return host, self.cluster
return None, self.cluster
def state_create_dvs(self):
changed = True
result = None
if not self.module.check_mode:
dc = find_datacenter_by_name(self.content, self.datacenter_name)
changed, result = self.create_dvswitch(dc.networkFolder)
self.module.exit_json(changed=changed, result=str(result))
def __init__(self, module):
super(VMwareShellManager, self).__init__(module)
datacenter_name = module.params['datacenter']
cluster_name = module.params['cluster']
folder = module.params['folder']
self.pm = self.content.guestOperationsManager.processManager
self.timeout = self.params.get('timeout', 3600)
self.wait_for_pid = self.params.get('wait_for_process', False)
datacenter = None
if datacenter_name:
datacenter = find_datacenter_by_name(self.content, datacenter_name)
if not datacenter:
module.fail_json(
changed=False,
msg="Unable to find %(datacenter)s datacenter" %
module.params)
cluster = None
if cluster_name:
cluster = find_cluster_by_name(self.content, cluster_name,
datacenter)
if not cluster:
module.fail_json(changed=False,
msg="Unable to find %(cluster)s cluster" %
module.params)
if module.params['vm_id_type'] == 'inventory_path':
vm = find_vm_by_id(self.content,
vm_id=module.params['vm_id'],
vm_id_type="inventory_path",
folder=folder)
else:
vm = find_vm_by_id(self.content,
vm_id=module.params['vm_id'],
vm_id_type=module.params['vm_id_type'],
datacenter=datacenter,
cluster=cluster)
if not vm:
module.fail_json(msg='Unable to find virtual machine.')
tools_status = vm.guest.toolsStatus
if tools_status in ['toolsNotInstalled', 'toolsNotRunning']:
self.module.fail_json(
msg=
"VMwareTools is not installed or is not running in the guest."
" VMware Tools are necessary to run this module.")
try:
self.execute_command(vm, module.params)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(changed=False, msg=to_native(runtime_fault.msg))
except vmodl.MethodFault as method_fault:
module.fail_json(changed=False, msg=to_native(method_fault.msg))
except Exception as e:
module.fail_json(changed=False, msg=to_native(e))
def getfolders(self):
if not self.datacenter:
self.datacenter = find_datacenter_by_name(self.content, self.params['datacenter'])
if self.datacenter is None:
self.module.fail_json(msg="Unable to find datacenter %(datacenter)s" % self.params)
self.folders = self._build_folder_tree(self.datacenter.vmFolder)
self._build_folder_map(self.folders)
def check_dvs(self):
"""Check if DVS is present"""
datacenter = find_datacenter_by_name(self.content, self.datacenter_name)
if datacenter is None:
self.module.fail_json(msg="Failed to find datacenter %s" % self.datacenter_name)
else:
self.datacenter = datacenter
self.dvs = find_dvs_by_name(self.content, self.switch_name)
if self.dvs is None:
return 'absent'
return 'present'
def getfolders(self):
if not self.datacenter:
self.datacenter = find_datacenter_by_name(
self.content, self.params['datacenter'])
if self.datacenter is None:
self.module.fail_json(
msg="Unable to find datacenter %(datacenter)s" % self.params)
self.folders = self._build_folder_tree(self.datacenter.vmFolder)
self._build_folder_map(self.folders)
def get_datacenter(self):
try:
datacenter_obj = find_datacenter_by_name(self.content, self.datacenter_name)
return datacenter_obj
except (vmodl.MethodFault, vmodl.RuntimeFault) as runtime_fault:
self.module.fail_json(msg="Failed to get datacenter '%s'"
" due to : %s" % (self.datacenter_name,
to_native(runtime_fault.msg)))
except Exception as generic_exc:
self.module.fail_json(msg="Failed to get datacenter"
" '%s' due to generic error: %s" % (self.datacenter_name,
to_native(generic_exc)))
def find_host_by_cluster_datacenter(self):
self.dc = find_datacenter_by_name(self.content, self.datacenter_name)
self.cluster = find_cluster_by_name(self.content, self.cluster_name, self.dc)
if self.cluster is None:
self.module.fail_json(msg="Unable to find cluster %(cluster_name)s" % self.module.params)
for host in self.cluster.host:
if host.name == self.esxi_hostname:
return host, self.cluster
return None, self.cluster
def get_datacenter(self):
try:
datacenter_obj = find_datacenter_by_name(self.content, self.datacenter_name)
return datacenter_obj
except (vmodl.MethodFault, vmodl.RuntimeFault) as runtime_fault:
self.module.fail_json(msg="Failed to get datacenter '%s'"
" due to : %s" % (self.datacenter_name,
to_native(runtime_fault.msg)))
except Exception as generic_exc:
self.module.fail_json(msg="Failed to get datacenter"
" '%s' due to generic error: %s" % (self.datacenter_name,
to_native(generic_exc)))
def __init__(self, module):
super(VmwareGuestFileManager, self).__init__(module)
datacenter_name = module.params['datacenter']
cluster_name = module.params['cluster']
folder = module.params['folder']
datacenter = None
if datacenter_name:
datacenter = find_datacenter_by_name(self.content, datacenter_name)
if not datacenter:
module.fail_json(
msg="Unable to find %(datacenter)s datacenter" %
module.params)
cluster = None
if cluster_name:
cluster = find_cluster_by_name(self.content, cluster_name,
datacenter)
if not cluster:
module.fail_json(msg="Unable to find %(cluster)s cluster" %
module.params)
if module.params['vm_id_type'] == 'inventory_path':
vm = find_vm_by_id(self.content,
vm_id=module.params['vm_id'],
vm_id_type="inventory_path",
folder=folder)
else:
vm = find_vm_by_id(self.content,
vm_id=module.params['vm_id'],
vm_id_type=module.params['vm_id_type'],
datacenter=datacenter,
cluster=cluster)
if not vm:
module.fail_json(msg='Unable to find virtual machine.')
self.vm = vm
try:
result = dict(changed=False)
if module.params['directory']:
result = self.directory()
if module.params['copy']:
result = self.copy()
if module.params['fetch']:
result = self.fetch()
module.exit_json(**result)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=to_native(runtime_fault.msg))
except vmodl.MethodFault as method_fault:
module.fail_json(msg=to_native(method_fault.msg))
except Exception as e:
module.fail_json(msg=to_native(e))
def get_all_hosts_by_datacenter_cluster(self, datacenter_name,
cluster_name):
"""Get all hosts from cluster by datacenter and cluster name"""
datacenter_obj = find_datacenter_by_name(
self.content, datacenter_name=datacenter_name)
cluster_obj = find_cluster_by_name(self.content,
cluster_name=cluster_name,
datacenter=datacenter_obj)
if cluster_obj:
return [host for host in cluster_obj.host]
else:
return []
def __init__(self, module):
super(VmwareFolderManager, self).__init__(module)
datacenter_name = self.params.get('datacenter', None)
self.datacenter_obj = find_datacenter_by_name(self.content, datacenter_name=datacenter_name)
if self.datacenter_obj is None:
self.module.fail_json(msg="Failed to find datacenter %s" % datacenter_name)
self.datacenter_folder_type = {
'vm': self.datacenter_obj.vmFolder,
'host': self.datacenter_obj.hostFolder,
'datastore': self.datacenter_obj.datastoreFolder,
'network': self.datacenter_obj.networkFolder,
}
def __init__(self, module):
super(VmwreClusterInfoManager, self).__init__(module)
datacenter = self.params.get('datacenter')
cluster_name = self.params.get('cluster_name')
self.cluster_objs = []
if datacenter:
datacenter_obj = find_datacenter_by_name(self.content, datacenter_name=datacenter)
if datacenter_obj is None:
self.module.fail_json(msg="Failed to find datacenter '%s'" % datacenter)
self.cluster_objs = self.get_all_cluster_objs(parent=datacenter_obj)
elif cluster_name:
cluster_obj = find_cluster_by_name(self.content, cluster_name=cluster_name)
if cluster_obj is None:
self.module.fail_json(msg="Failed to find cluster '%s'" % cluster_name)
self.cluster_objs = [cluster_obj]
def __init__(self, module):
super(VmwreClusterFactsManager, self).__init__(module)
datacenter = self.params.get('datacenter')
cluster_name = self.params.get('cluster_name')
self.cluster_objs = []
if datacenter:
datacenter_obj = find_datacenter_by_name(self.content, datacenter_name=datacenter)
if datacenter_obj is None:
self.module.fail_json(msg="Failed to find datacenter '%s'" % datacenter)
self.cluster_objs = self.get_all_cluster_objs(parent=datacenter_obj)
elif cluster_name:
cluster_obj = find_cluster_by_name(self.content, cluster_name=cluster_name)
if cluster_obj is None:
self.module.fail_json(msg="Failed to find cluster '%s'" % cluster_name)
self.cluster_objs = [cluster_obj]
def __init__(self, module):
"""
Doctring: Init
"""
super(VmwareVmHostRuleDrs, self).__init__(module)
self.__datacenter_name = module.params.get('datacenter', None)
self.__datacenter_obj = None
self.__cluster_name = module.params['cluster_name']
self.__cluster_obj = None
self.__vm_group_name = module.params.get('vm_group_name', None)
self.__host_group_name = module.params.get('host_group_name', None)
self.__rule_name = module.params['drs_rule_name']
self.__enabled = module.params['enabled']
self.__mandatory = module.params['mandatory']
self.__affinity_rule = module.params['affinity_rule']
self.__state = module.params['state']
self.__msg = 'Nothing to see here...'
self.__result = dict()
self.__changed = False
if self.__datacenter_name is not None:
self.__datacenter_obj = find_datacenter_by_name(
self.content, self.__datacenter_name)
if self.__datacenter_obj is None and module.check_mode is False:
raise Exception("Datacenter '%s' not found" %
self.__datacenter_name)
self.__cluster_obj = find_cluster_by_name(
content=self.content,
cluster_name=self.__cluster_name,
datacenter=self.__datacenter_obj)
# Throw error if cluster does not exist
if self.__cluster_obj is None and module.check_mode is False:
raise Exception("Cluster '%s' not found" % self.__cluster_name)
# Dont populate lists if we are deleting group
if self.__state == 'present':
# Get list of vm groups only if state is present
self.__vm_group_obj = self.__get_group_by_name(
group_name=self.__vm_group_name)
self.__host_group_obj = self.__get_group_by_name(
group_name=self.__host_group_name, host_group=True)
def state_add_folder(self):
changed = True
result = None
self.dc_obj = find_datacenter_by_name(self.content, self.datacenter)
self.cluster_obj = find_cluster_by_name_datacenter(self.dc_obj, self.cluster)
self.folder_expanded = self.folder.split("/")
index = 0
for f in self.folder_expanded:
if not self.get_obj([vim.Folder],f):
if index == 0:
#First object gets created on the datacenter
task = self.dc_obj.vmFolder.CreateFolder(name=f)
else:
parent_f = self.get_obj([vim.Folder],self.folder_expanded[index - 1])
task = parent_f.CreateFolder(name=f)
index = index + 1
self.module.exit_json(changed = changed)
def __init__(self, module):
super(VMwareCluster, self).__init__(module)
self.cluster_name = module.params['cluster_name']
self.datacenter_name = module.params['datacenter']
self.enable_ha = module.params['enable_ha']
self.datacenter = None
self.cluster = None
self.datacenter = find_datacenter_by_name(self.content,
self.datacenter_name)
if self.datacenter is None:
self.module.fail_json(msg="Datacenter %s does not exist." %
self.datacenter_name)
self.cluster = self.find_cluster_by_name(
cluster_name=self.cluster_name)
if self.cluster is None:
self.module.fail_json(msg="Cluster %s does not exist." %
self.cluster_name)
def __init__(self, module):
super(VmwareGuestFileManager, self).__init__(module)
datacenter_name = module.params['datacenter']
cluster_name = module.params['cluster']
folder = module.params['folder']
datacenter = None
if datacenter_name:
datacenter = find_datacenter_by_name(self.content, datacenter_name)
if not datacenter:
module.fail_json(msg="Unable to find %(datacenter)s datacenter" % module.params)
cluster = None
if cluster_name:
cluster = find_cluster_by_name(self.content, cluster_name, datacenter)
if not cluster:
module.fail_json(msg="Unable to find %(cluster)s cluster" % module.params)
if module.params['vm_id_type'] == 'inventory_path':
vm = find_vm_by_id(self.content, vm_id=module.params['vm_id'], vm_id_type="inventory_path", folder=folder)
else:
vm = find_vm_by_id(self.content, vm_id=module.params['vm_id'], vm_id_type=module.params['vm_id_type'],
datacenter=datacenter, cluster=cluster)
if not vm:
module.fail_json(msg='Unable to find virtual machine.')
self.vm = vm
try:
result = dict(changed=False)
if module.params['directory']:
result = self.directory()
if module.params['copy']:
result = self.copy()
if module.params['fetch']:
result = self.fetch()
module.exit_json(**result)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=to_native(runtime_fault.msg))
except vmodl.MethodFault as method_fault:
module.fail_json(msg=to_native(method_fault.msg))
except Exception as e:
module.fail_json(msg=to_native(e))
def state_add_folder(self):
changed = True
result = None
self.dc_obj = find_datacenter_by_name(self.content, self.datacenter)
self.cluster_obj = find_cluster_by_name_datacenter(self.dc_obj, self.cluster)
self.folder_expanded = self.folder.split("/")
index = 0
for f in self.folder_expanded:
if not self.get_obj([vim.Folder],f):
if index == 0:
#First object gets created on the datacenter
task = self.dc_obj.vmFolder.CreateFolder(name=f)
else:
parent_f = self.get_obj([vim.Folder],self.folder_expanded[index - 1])
task = parent_f.CreateFolder(name=f)
index = index + 1
self.module.exit_json(changed = changed)
def get_objects(self):
self.datastore = find_datastore_by_name(self.si,
self.params['datastore'])
if not self.datastore:
self.module.fail_json(msg='%(datastore)s could not be located' %
self.params)
self.datacenter = find_datacenter_by_name(self.si,
self.params['datacenter'])
if not self.datacenter:
self.module.fail_json(msg='%(datacenter)s could not be located' %
self.params)
# self.vm = find_vm_by_name(self.si, self.params['name'])
# if not self.vm:
# self.module.fail_json(msg='%(name)s could not be located' % self.params)
self.resource_pool = find_resource_pool_by_name(
self.si, self.params['resource_pool'])
if not self.resource_pool:
self.module.fail_json(
msg='%(resource_pool)s could not be located' % self.params)
for key, value in self.params['ovf_networks'].items():
network = find_network_by_name(self.si, value)
if not network:
self.module.fail_json(
msg='%(ovf_network)s could not be located' % self.params)
network_mapping = vim.OvfManager.NetworkMapping()
network_mapping.name = key
network_mapping.network = network
self.network_mappings.append(network_mapping)
if self.params['property_map']:
for key, value in self.params['property_map'].items():
property_map = vim.KeyValue()
property_map.key = key
property_map.value = value
self.property_mappings.append(property_map)
return self.datastore, self.datacenter, self.resource_pool, self.network_mappings, self.property_mappings
def __init__(self, module):
super(VmwareDrsFactManager, self).__init__(module)
datacenter_name = self.params.get('datacenter', None)
if datacenter_name:
datacenter_obj = find_datacenter_by_name(self.content, datacenter_name=datacenter_name)
self.cluster_obj_list = []
if datacenter_obj:
folder = datacenter_obj.hostFolder
self.cluster_obj_list = get_all_objs(self.content, [vim.ClusterComputeResource], folder)
else:
self.module.fail_json(changed=False, msg="Datacenter '%s' not found" % datacenter_name)
cluster_name = self.params.get('cluster_name', None)
if cluster_name:
cluster_obj = self.find_cluster_by_name(cluster_name=cluster_name)
if cluster_obj is None:
self.module.fail_json(changed=False, msg="Cluster '%s' not found" % cluster_name)
else:
self.cluster_obj_list = [cluster_obj]
def __init__(self, module):
super(VmwareFolderManager, self).__init__(module)
datacenter_name = self.params.get('datacenter', None)
self.datacenter_obj = find_datacenter_by_name(self.content, datacenter_name=datacenter_name)
if self.datacenter_obj is None:
self.module.fail_json(msg="Failed to find datacenter %s" % datacenter_name)
