def __init__(self, module): super(VMwareHostDatastore, self).__init__(module) self.gather_nfs_mount_info = self.module.params[ 'gather_nfs_mount_info'] self.gather_vmfs_mount_info = self.module.params[ 'gather_vmfs_mount_info'] self.schema = self.module.params['schema'] self.properties = self.module.params['properties'] if self.module.params['show_tag']: self.vmware_client = VmwareRestClient(self.module)
def properties_facts(self): ansible_facts = self.to_json(self.host, self.params.get('properties')) if self.params.get('show_tag'): vmware_client = VmwareRestClient(self.module) tag_info = { 'tags': vmware_client.get_tags_for_hostsystem(hostsystem_mid=self.host._moId) } ansible_facts.update(tag_info) self.module.exit_json(changed=False, ansible_facts=ansible_facts)
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_category_facts = VmwareCategoryFactsManager(module) vmware_category_facts.get_all_tag_categories()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( tag_names=dict(type='list', required=True, elements='raw'), state=dict(type='str', choices=['absent', 'add', 'present', 'remove', 'set'], default='add'), moid=dict(type='str'), object_name=dict(type='str'), object_type=dict(type='str', required=True, choices=[ 'VirtualMachine', 'Datacenter', 'ClusterComputeResource', 'HostSystem', 'DistributedVirtualSwitch', 'DistributedVirtualPortgroup', 'Datastore', 'ResourcePool', 'Folder', 'DatastoreCluster' ]), ) module = AnsibleModule(argument_spec=argument_spec, mutually_exclusive=[ ('moid', 'object_name'), ], required_one_of=[ ['moid', 'object_name'], ]) vmware_tag_manager = VmwareTagManager(module) vmware_tag_manager.ensure_state()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( library_name=dict(type='str', required=True), library_description=dict(type='str', required=False), library_type=dict(type='str', required=False, choices=['local', 'subscribed'], default='local'), datastore_name=dict(type='str', required=False, aliases=['datastore']), state=dict(type='str', choices=['present', 'absent'], default='present', required=False), subscription_url=dict(type='str', default='', required=False), ssl_thumbprint=dict(type='str', default='', required=False), update_on_demand=dict(type='bool', default=False, required=False), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ('library_type', 'subscribed', ['subscription_url']), ], ) vmware_contentlib_create = VmwareContentLibCreate(module) vmware_contentlib_create.process_state()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_tag_info = VmTagInfoManager(module) vmware_tag_info.get_all_tags()
def all_facts(self): ansible_facts = {} ansible_facts.update(self.get_cpu_facts()) ansible_facts.update(self.get_memory_facts()) ansible_facts.update(self.get_datastore_facts()) ansible_facts.update(self.get_network_facts()) ansible_facts.update(self.get_system_facts()) ansible_facts.update(self.get_vsan_facts()) ansible_facts.update(self.get_cluster_facts()) if self.params.get('show_tag'): vmware_client = VmwareRestClient(self.module) tag_info = { 'tags': vmware_client.get_tags_for_hostsystem(hostsystem_mid=self.host._moId) } ansible_facts.update(tag_info) self.module.exit_json(changed=False, ansible_facts=ansible_facts)
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if module._name == 'vmware_tag_facts': module.deprecate("The 'vmware_tag_facts' module has been renamed to 'vmware_tag_info'", version='2.13') vmware_tag_info = VmTagInfoManager(module) vmware_tag_info.get_all_tags()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update(cluster_name=dict(type='str', required=True), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=False, ) vmware_namespace_cluster_manage = VmwareNamespaceClusterVdsManage(module) vmware_namespace_cluster_manage.get_cluster_info()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update(library_id=dict(type='str', required=False), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_contentlib_info = VmwareContentLibInfo(module) if module.params.get('library_id'): vmware_contentlib_info.get_content_lib_details( module.params['library_id']) else: vmware_contentlib_info.get_all_content_libs()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( encryption_key=dict(type='str', required=False), description=dict(type='str', required=False), decryption_key=dict(type='str', required=False), api=dict(type='str', required=False, choices=['list', 'export', 'import', 'validate']), profiles=dict(type='str', required=False), config_path=dict(type='str', required=False), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) result = {'failed': False, 'changed': False} vmware_vc_infra_profile = VcenterProfile(module) vmware_vc_version = VcVersionChecker(module) vmware_vc_version.check_vc_version() if module.params['api'].lower() == "list": if module.check_mode: result.update( changed=False, desired_operation='list_vc_profile_configs', ) module.exit_json(**result) vmware_vc_infra_profile.list_vc_infraprofile_configs() if module.params['api'].lower() == "export": if module.check_mode: result.update( changed=False, desired_operation='export_vc_profile_configs', ) module.exit_json(**result) vmware_vc_infra_profile.vc_export_profile_task() if module.params['api'].lower() == "import": if module.check_mode: result.update( changed=True, desired_operation='import_vc_profile_configs', ) module.exit_json(**result) vmware_vc_infra_profile.vc_import_profile_task() if module.params['api'].lower() == "validate": if module.check_mode: result.update( changed=True, desired_operation='import_vc_profile_configs', ) module.exit_json(**result) vmware_vc_infra_profile.vc_validate_profile_task()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( tag_name=dict(type='str', required=True), tag_description=dict(type='str', default='', required=False), category_id=dict(type='str', required=False), state=dict(type='str', choices=['present', 'absent'], default='present', required=False), ) module = AnsibleModule(argument_spec=argument_spec) vmware_tag = VmwareTag(module) vmware_tag.ensure_state()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if module._name in ('vmware_tag_facts', 'community.vmware.vmware_tag_facts'): module.deprecate( "The 'vmware_tag_facts' module has been renamed to 'vmware_tag_info'", version='3.0.0', collection_name='community.vmware') # was Ansible 2.13 vmware_tag_info = VmTagInfoManager(module) vmware_tag_info.get_all_tags()
class VmwareDatacenterInfo(PyVmomi): def __init__(self, module): super(VmwareDatacenterInfo, self).__init__(module) if self.params.get('show_tag'): self.vmware_client = VmwareRestClient(self.module) def get_datacenter_info(self): self.datacenter_name = self.params.get('datacenter') results = dict( changed=False, datacenter_info=[], ) datacenter_objs = self.get_managed_objects_properties( vim_type=vim.Datacenter, properties=['name']) dcs = [] for dc_obj in datacenter_objs: if len(dc_obj.propSet) == 1: if self.datacenter_name is not None: if dc_obj.propSet[0].val == to_native( self.datacenter_name): dcs.append(dc_obj.obj) continue else: dcs.append(dc_obj.obj) for obj in dcs: if obj is None: continue temp_dc = dict( name=obj.name, moid=obj._moId, ) if self.module.params['schema'] == 'summary': temp_dc.update( dict( config_status=obj.configStatus, overall_status=obj.overallStatus, )) else: temp_dc.update(self.to_json(obj, self.params.get('properties'))) if self.params.get('show_tag'): temp_dc.update({ 'tags': self.vmware_client.get_tags_for_datacenter( datacenter_mid=obj._moId) }) results['datacenter_info'].append(temp_dc) self.module.exit_json(**results)
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( tag_names=dict(type='list', required=True), state=dict(type='str', choices=['absent', 'add', 'present', 'remove', 'set'], default='add'), object_name=dict(type='str', required=True), object_type=dict(type='str', required=True, choices=['VirtualMachine', 'Datacenter', 'ClusterComputeResource', 'HostSystem', 'DistributedVirtualSwitch', 'DistributedVirtualPortgroup']), ) module = AnsibleModule(argument_spec=argument_spec) vmware_tag_manager = VmwareTagManager(module) vmware_tag_manager.ensure_state()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( log_level=dict(type='str', choices=[ 'debug', 'info', 'normal', ], default='normal'), template=dict(type='str', aliases=['ovf', 'ovf_template', 'template_src'], required=True), library=dict(type='str', aliases=['content_library', 'content_library_src'], required=False), name=dict(type='str', aliases=['vm_name'], required=True), datacenter=dict(type='str', required=True), datastore=dict(type='str', required=False), datastore_cluster=dict(type='str', required=False), folder=dict(type='str', default='vm'), host=dict(type='str', required=False), resource_pool=dict(type='str', required=False), cluster=dict(type='str', required=False), storage_provisioning=dict( type='str', choices=['thin', 'thick', 'eagerZeroedThick', 'eagerzeroedthick'], default='thin', fallback=(env_fallback, ['VMWARE_STORAGE_PROVISIONING'])), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[ ['datastore', 'datastore_cluster'], ['host', 'cluster'], ], ) result = {'failed': False, 'changed': False} 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 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 main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( object_name=dict(), object_moid=dict(), new_name=dict(aliases=['object_new_name'], required=True), object_type=dict(type='str', required=True), ) module = AnsibleModule(argument_spec=argument_spec, mutually_exclusive=[ ['object_name', 'object_moid'], ]) vmware_object_rename = VmwareObjectRename(module) vmware_object_rename.ensure_state()
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=False), datastore_cluster=dict(type='str', required=False), folder=dict(type='str', required=True), host=dict(type='str', required=False), resource_pool=dict(type='str', required=False), cluster=dict(type='str', required=False), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[ ['datastore', 'datastore_cluster'], ], ) result = {'failed': False, 'changed': False} 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 main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( object_name=dict(), object_moid=dict(), new_name=dict(aliases=['object_new_name'], required=True), object_type=dict(type='str', required=True, choices=['ClusterComputeResource', 'Cluster', 'Datacenter', 'Datastore', 'Folder', 'Network', 'ResourcePool', 'VM', 'VirtualMachine']) ) module = AnsibleModule( argument_spec=argument_spec, mutually_exclusive=[ ['object_name', 'object_moid'], ] ) vmware_object_rename = VmwareObjectRename(module) vmware_object_rename.ensure_state()
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( category_name=dict(type='str', required=True), category_description=dict(type='str', default='', required=False), category_cardinality=dict(type='str', choices=["multiple", "single"], default="multiple"), new_category_name=dict(type='str'), state=dict(type='str', choices=['present', 'absent'], default='present'), associable_object_types=dict( type='list', choices=[ 'All objects', 'Cluster', 'Content Library', 'Datacenter', 'Datastore', 'Datastore Cluster', 'Distributed Port Group', 'Distributed Switch', 'Folder', 'Host', 'Library item', 'Network', 'Host Network', 'Opaque Network', 'Resource Pool', 'vApp', 'Virtual Machine', ], elements='str', ), ) module = AnsibleModule(argument_spec=argument_spec) vmware_category = VmwareCategory(module) vmware_category.ensure_state()
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 gather_cluster_info(self): """ Gather information about cluster """ results = dict(changed=False, clusters=dict()) if self.schema == 'summary': for cluster in self.cluster_objs: # Default values ha_failover_level = None ha_restart_priority = None ha_vm_tools_monitoring = None ha_vm_min_up_time = None ha_vm_max_failures = None ha_vm_max_failure_window = None ha_vm_failure_interval = None enabled_vsan = False vsan_auto_claim_storage = False hosts = [] # Hosts for host in cluster.host: hosts.append({ 'name': host.name, 'folder': self.get_vm_path(self.content, host), }) # HA das_config = cluster.configurationEx.dasConfig if das_config.admissionControlPolicy: ha_failover_level = das_config.admissionControlPolicy.failoverLevel if das_config.defaultVmSettings: ha_restart_priority = das_config.defaultVmSettings.restartPriority, ha_vm_tools_monitoring = das_config.defaultVmSettings.vmToolsMonitoringSettings.vmMonitoring, ha_vm_min_up_time = das_config.defaultVmSettings.vmToolsMonitoringSettings.minUpTime, ha_vm_max_failures = das_config.defaultVmSettings.vmToolsMonitoringSettings.maxFailures, ha_vm_max_failure_window = das_config.defaultVmSettings.vmToolsMonitoringSettings.maxFailureWindow, ha_vm_failure_interval = das_config.defaultVmSettings.vmToolsMonitoringSettings.failureInterval, # DRS drs_config = cluster.configurationEx.drsConfig # VSAN if hasattr(cluster.configurationEx, 'vsanConfigInfo'): vsan_config = cluster.configurationEx.vsanConfigInfo enabled_vsan = vsan_config.enabled vsan_auto_claim_storage = vsan_config.defaultConfig.autoClaimStorage tag_info = [] if self.params.get('show_tag'): vmware_client = VmwareRestClient(self.module) tag_info = vmware_client.get_tags_for_cluster( cluster_mid=cluster._moId) resource_summary = self.to_json(cluster.GetResourceUsage()) if '_vimtype' in resource_summary: del resource_summary['_vimtype'] results['clusters'][unquote(cluster.name)] = dict( hosts=hosts, enable_ha=das_config.enabled, ha_failover_level=ha_failover_level, ha_vm_monitoring=das_config.vmMonitoring, ha_host_monitoring=das_config.hostMonitoring, ha_admission_control_enabled=das_config. admissionControlEnabled, ha_restart_priority=ha_restart_priority, ha_vm_tools_monitoring=ha_vm_tools_monitoring, ha_vm_min_up_time=ha_vm_min_up_time, ha_vm_max_failures=ha_vm_max_failures, ha_vm_max_failure_window=ha_vm_max_failure_window, ha_vm_failure_interval=ha_vm_failure_interval, enabled_drs=drs_config.enabled, drs_enable_vm_behavior_overrides=drs_config. enableVmBehaviorOverrides, drs_default_vm_behavior=drs_config.defaultVmBehavior, drs_vmotion_rate=drs_config.vmotionRate, enabled_vsan=enabled_vsan, vsan_auto_claim_storage=vsan_auto_claim_storage, tags=tag_info, resource_summary=resource_summary, moid=cluster._moId, datacenter=get_parent_datacenter(cluster).name) else: for cluster in self.cluster_objs: results['clusters'][unquote(cluster.name)] = self.to_json( cluster, self.properties) self.module.exit_json(**results)
class VmwareStoragePolicyManager(SPBM): def __init__(self, module): super(VmwareStoragePolicyManager, self).__init__(module) self.rest_client = VmwareRestClient(module) # # MOB METHODS # # These will generate the individual items with the following expected structure (see # https://github.com/vmware/pyvmomi/blob/master/pyVmomi/PbmObjects.py): # # PbmProfile: array # - name: string # description: string # constraints: PbmCapabilityConstraints # subProfiles: ArrayOfPbmCapabilitySubProfile # - name: string # capability: ArrayOfPbmCapabilityInstance # - constraint: ArrayOfCapabilityConstraintInstance # - id: string # value: anyType # values: arrayOfStrings # - tags # # def create_mob_tag_values(self, tags): return pbm.capability.types.DiscreteSet(values=tags) def create_mob_capability_property_instance(self, tag_id, tag_operator, tags): return pbm.capability.PropertyInstance( id=tag_id, operator=tag_operator, value=self.create_mob_tag_values(tags)) def create_mob_capability_constraint_instance(self, tag_id, tag_operator, tags): return pbm.capability.ConstraintInstance(propertyInstance=[ self.create_mob_capability_property_instance( tag_id, tag_operator, tags) ]) def create_mob_capability_metadata_uniqueid(self, tag_category): return pbm.capability.CapabilityMetadata.UniqueId( namespace="http://www.vmware.com/storage/tag", id=tag_category) def create_mob_capability_instance(self, tag_id, tag_operator, tags, tag_category): return pbm.capability.CapabilityInstance( id=self.create_mob_capability_metadata_uniqueid(tag_category), constraint=[ self.create_mob_capability_constraint_instance( tag_id, tag_operator, tags) ]) def create_mob_capability_constraints_subprofile(self, tag_id, tag_operator, tags, tag_category): return pbm.profile.SubProfileCapabilityConstraints.SubProfile( name="Tag based placement", capability=[ self.create_mob_capability_instance(tag_id, tag_operator, tags, tag_category) ]) def create_mob_capability_subprofile(self, tag_id, tag_operator, tags, tag_category): return pbm.profile.SubProfileCapabilityConstraints(subProfiles=[ self.create_mob_capability_constraints_subprofile( tag_id, tag_operator, tags, tag_category) ]) def create_mob_pbm_update_spec(self, tag_id, tag_operator, tags, tag_category, description): return pbm.profile.CapabilityBasedProfileUpdateSpec( description=description, constraints=self.create_mob_capability_subprofile( tag_id, tag_operator, tags, tag_category)) def create_mob_pbm_create_spec(self, tag_id, tag_operator, tags, tag_category, description, name): return pbm.profile.CapabilityBasedProfileCreateSpec( name=name, description=description, resourceType=pbm.profile.ResourceType(resourceType="STORAGE"), category="REQUIREMENT", constraints=self.create_mob_capability_subprofile( tag_id, tag_operator, tags, tag_category)) def get_tag_constraints(self, capabilities): """ Return tag constraints for a profile given its capabilities """ tag_constraints = {} for capability in capabilities: for constraint in capability.constraint: if hasattr(constraint, 'propertyInstance'): for propertyInstance in constraint.propertyInstance: if hasattr(propertyInstance.value, 'values'): tag_constraints['id'] = propertyInstance.id tag_constraints[ 'values'] = propertyInstance.value.values tag_constraints[ 'operator'] = propertyInstance.operator return tag_constraints def get_profile_manager(self): self.get_spbm_connection() return self.spbm_content.profileManager def get_storage_policies(self, profile_manager): profile_ids = profile_manager.PbmQueryProfile( resourceType=pbm.profile.ResourceType(resourceType="STORAGE"), profileCategory="REQUIREMENT") profiles = [] if profile_ids: profiles = profile_manager.PbmRetrieveContent( profileIds=profile_ids) return profiles def format_profile(self, profile): formatted_profile = { 'name': profile.name, 'id': profile.profileId.uniqueId, 'description': profile.description } return formatted_profile def format_tag_mob_id(self, tag_category): return "com.vmware.storage.tag." + tag_category + ".property" def format_results_and_exit(self, results, policy, changed): results['vmware_vm_storage_policy'] = self.format_profile(policy) results['changed'] = changed self.module.exit_json(**results) def update_storage_policy(self, policy, pbm_client, results): expected_description = self.params.get('description') expected_tags = [self.params.get('tag_name')] expected_tag_category = self.params.get('tag_category') expected_tag_id = self.format_tag_mob_id(expected_tag_category) expected_operator = "NOT" if self.params.get('tag_affinity'): expected_operator = None needs_change = False if policy.description != expected_description: needs_change = True if hasattr(policy.constraints, 'subProfiles'): for subprofile in policy.constraints.subProfiles: tag_constraints = self.get_tag_constraints( subprofile.capability) if tag_constraints['id'] == expected_tag_id: if tag_constraints['values'] != expected_tags: needs_change = True else: needs_change = True if tag_constraints['operator'] != expected_operator: needs_change = True else: needs_change = True if needs_change: pbm_client.PbmUpdate(profileId=policy.profileId, updateSpec=self.create_mob_pbm_update_spec( expected_tag_id, expected_operator, expected_tags, expected_tag_category, expected_description)) self.format_results_and_exit(results, policy, needs_change) def remove_storage_policy(self, policy, pbm_client, results): pbm_client.PbmDelete(profileId=[policy.profileId]) self.format_results_and_exit(results, policy, True) def create_storage_policy(self, policy, pbm_client, results): profile_ids = pbm_client.PbmCreate( createSpec=self.create_mob_pbm_create_spec( self.format_tag_mob_id(self.params.get('tag_category')), None, [self.params.get('tag_name')], self.params.get('tag_category'), self.params.get('description'), self.params.get('name'))) policy = pbm_client.PbmRetrieveContent(profileIds=[profile_ids]) self.format_results_and_exit(results, policy[0], True) def ensure_state(self): client = self.get_profile_manager() policies = self.get_storage_policies(client) policy_name = self.params.get('name') results = dict(changed=False, vmware_vm_storage_policy={}) if self.params.get('state') == 'present': if self.params.get('tag_category') is None: self.module.fail_json( msg="tag_category is required when 'state' is 'present'") if self.params.get('tag_name') is None: self.module.fail_json( msg="tag_name is required when 'state' is 'present'") # ensure if the category exists category_result = self.rest_client.get_category_by_name( self.params.get('tag_category')) if category_result is None: self.module.fail_json( msg="%s is not found in vCenter Server tag categories" % self.params.get('tag_category')) # ensure if the tag exists tag_result = self.rest_client.get_tag_by_category( self.params.get('tag_name'), self.params.get('tag_category')) if tag_result is None: self.module.fail_json( msg="%s is not found in vCenter Server tags" % self.params.get('tag_name')) # loop through and update the first match for policy in policies: if policy.name == policy_name: self.update_storage_policy(policy, client, results) # if we didn't exit by now create the profile self.create_storage_policy(policy, client, results) if self.params.get('state') == 'absent': # loop through and delete the first match for policy in policies: if policy.name == policy_name: self.remove_storage_policy(policy, client, results) # if we didn't exit by now exit without changing anything self.module.exit_json(**results)
class VMwareHostDatastore(PyVmomi): """ This class populates the datastore list """ def __init__(self, module): super(VMwareHostDatastore, self).__init__(module) self.gather_nfs_mount_info = self.module.params[ 'gather_nfs_mount_info'] self.gather_vmfs_mount_info = self.module.params[ 'gather_vmfs_mount_info'] self.schema = self.module.params['schema'] self.properties = self.module.params['properties'] if self.module.params['show_tag']: self.vmware_client = VmwareRestClient(self.module) def check_datastore_host(self, esxi_host, datastore): """ Get all datastores of specified ESXi host """ esxi = self.find_hostsystem_by_name(esxi_host) if esxi is None: self.module.fail_json(msg="Failed to find ESXi hostname %s " % esxi_host) storage_system = esxi.configManager.storageSystem host_file_sys_vol_mount_info = storage_system.fileSystemVolumeInfo.mountInfo for host_mount_info in host_file_sys_vol_mount_info: if host_mount_info.volume.name == datastore: return host_mount_info return None def build_datastore_list(self, datastore_list): """ Build list with datastores """ datastores = list() for datastore in datastore_list: if self.schema == 'summary': summary = datastore.summary datastore_summary = dict() datastore_summary['accessible'] = summary.accessible datastore_summary['capacity'] = summary.capacity datastore_summary['name'] = summary.name datastore_summary['freeSpace'] = summary.freeSpace datastore_summary['maintenanceMode'] = summary.maintenanceMode datastore_summary[ 'multipleHostAccess'] = summary.multipleHostAccess datastore_summary['type'] = summary.type if self.gather_nfs_mount_info or self.gather_vmfs_mount_info: if self.gather_nfs_mount_info and summary.type.startswith( "NFS"): # get mount info from the first ESXi host attached to this NFS datastore host_mount_info = self.check_datastore_host( summary.datastore.host[0].key.name, summary.name) datastore_summary[ 'nfs_server'] = host_mount_info.volume.remoteHost datastore_summary[ 'nfs_path'] = host_mount_info.volume.remotePath if self.gather_vmfs_mount_info and summary.type == "VMFS": # get mount info from the first ESXi host attached to this VMFS datastore host_mount_info = self.check_datastore_host( summary.datastore.host[0].key.name, summary.name) datastore_summary[ 'vmfs_blockSize'] = host_mount_info.volume.blockSize datastore_summary[ 'vmfs_version'] = host_mount_info.volume.version datastore_summary[ 'vmfs_uuid'] = host_mount_info.volume.uuid # uncommitted is optional / not always set if not summary.uncommitted: summary.uncommitted = 0 datastore_summary['uncommitted'] = summary.uncommitted datastore_summary['url'] = summary.url # Calculated values datastore_summary[ 'provisioned'] = summary.capacity - summary.freeSpace + summary.uncommitted datastore_summary['datastore_cluster'] = 'N/A' if isinstance(datastore.parent, vim.StoragePod): datastore_summary[ 'datastore_cluster'] = datastore.parent.name if self.module.params['show_tag']: datastore_summary[ 'tags'] = self.vmware_client.get_tags_for_datastore( datastore._moId) if self.module.params['name']: if datastore_summary['name'] == self.module.params['name']: datastores.extend([datastore_summary]) else: datastores.extend([datastore_summary]) else: temp_ds = self.to_json(datastore, self.properties) if self.module.params['show_tag']: temp_ds.update({ 'tags': self.vmware_client.get_tags_for_datastore( datastore._moId) }) if self.module.params['name']: if datastore.name == self.module.params['name']: datastores.extend(([temp_ds])) else: datastores.extend(([temp_ds])) return datastores
def __init__(self, module): super(VmwareStoragePolicyManager, self).__init__(module) self.rest_client = VmwareRestClient(module)
def __init__(self, module): super(VmwareVmInfo, self).__init__(module) if self.module.params.get('show_tag'): self.vmware_client = VmwareRestClient(self.module)
class VmwareVmInfo(PyVmomi): def __init__(self, module): super(VmwareVmInfo, self).__init__(module) if self.module.params.get('show_tag'): self.vmware_client = VmwareRestClient(self.module) def get_tag_info(self, vm_dynamic_obj): return self.vmware_client.get_tags_for_vm(vm_mid=vm_dynamic_obj._moId) def get_vm_attributes(self, vm): return dict((x.name, v.value) for x in self.custom_field_mgr for v in vm.customValue if x.key == v.key) # https://github.com/vmware/pyvmomi-community-samples/blob/master/samples/getallvms.py 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
def get_tag_info(self, vm_dynamic_obj): vmware_client = VmwareRestClient(self.module) return vmware_client.get_tags_for_vm(vm_mid=vm_dynamic_obj._moId)
def main(): argument_spec = VmwareRestClient.vmware_client_argument_spec() argument_spec.update( cluster_distributed_switch=dict(type='str', required=False), cluster_name=dict(type='str', required=True), default_content_library=dict(type='str', required=False), dns_search_domains=dict(type='list', required=False), egress_cidrs=dict(type='list', required=False), ephemeral_storage_policy=dict(type='str', required=False), haproxy_ca_chain=dict(type='str', required=False), haproxy_management_ip=dict(type='str', required=False), haproxy_management_port=dict(type='str', required=False, default='5556'), haproxy_password=dict(type='str', required=False), haproxy_ip_range_list=dict(type='list', required=False), haproxy_username=dict(type='str', required=False), image_storage_policy=dict(type='str', required=False), ingress_cidrs=dict(type='list', required=False), management_address_count=dict(type='int', required=False, default=5), management_dns_servers=dict(type='list', required=False), management_gateway=dict(type='str', required=False), management_netmask=dict(type='str', required=False), management_ntp_servers=dict(type='list', required=False), management_port_group=dict(type='str', required=False), management_starting_address=dict(type='str', required=False), master_storage_policy=dict(type='str', required=False), network_provider=dict( type='str', required=True, choices=['VSPHERE_NETWORK', 'NSXT_CONTAINER_PLUGIN']), nsx_edge_cluster=dict(type='str', required=False), pod_cidrs=dict(type='list', required=False), workload_dns_servers=dict(type='list', required=False), workload_gateway=dict(type='str', required=False), workload_netmask=dict(type='str', required=False), workload_ntp_servers=dict(type='list', required=False), workload_portgroup=dict(type='str', required=False), workload_ip_range_list=dict(type='list', required=False), services_cidr=dict(type='str', required=False), supervisor_size=dict(type='str', choices=['TINY', 'SMALL', 'MEDIUM', 'LARGE'], required=False), state=dict(type='str', choices=['present', 'absent'], default='present', required=False), # storage_policy_name=dict(type='str', required=False), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ('state', 'present', [ 'ephemeral_storage_policy', 'image_storage_policy', 'management_dns_servers', 'management_gateway', 'management_netmask', 'management_ntp_servers', 'management_port_group', 'management_starting_address', 'master_storage_policy', 'network_provider', 'services_cidr', 'supervisor_size', 'workload_dns_servers', 'workload_ntp_servers' ]), ('network_provider', 'VSPHERE_NETWORK', [ 'haproxy_ca_chain', 'haproxy_management_ip', 'haproxy_password', 'haproxy_ip_range_list', 'haproxy_username', 'workload_dns_servers', 'workload_gateway', 'workload_portgroup', 'workload_ip_range_list', 'workload_netmask', ]), ('network_provider', 'NSXT_CONTAINER_PLUGIN', [ 'cluster_distributed_switch', 'egress_cidrs', 'ingress_cidrs', 'nsx_edge_cluster', 'pod_cidrs' ]), ]) vmware_namespace_cluster_manage = VmwareNamespaceClusterVdsManage(module) vmware_namespace_cluster_manage.process_state()