def main(): argument_spec = ovirt_info_full_argument_spec( max=dict(default=None, type='int'), name=dict(default=None), ) module = AnsibleModule(argument_spec) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) vnic_profiles_service = connection.system_service( ).vnic_profiles_service() vnic_profiles = vnic_profiles_service.list( max=module.params.get('max')) if module.params.get('name') and vnic_profiles: vnic_profiles = [ vnic_profile for vnic_profile in vnic_profiles if vnic_profile.name == module.params.get("name") ] result = dict(ovirt_vnic_profiles=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in vnic_profiles ], ) module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec(pattern=dict( default='', required=False), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_cluster_facts' if is_old_facts: module.deprecate( "The 'ovirt_cluster_facts' module has been renamed to 'ovirt_cluster_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) clusters_service = connection.system_service().clusters_service() clusters = clusters_service.list(search=module.params['pattern']) result = dict(ovirt_clusters=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in clusters ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( id=dict(default=None), state=dict( choices=['present', 'absent'], default='present', ), name=dict(required=True), template=dict(default=None), cluster=dict(default=None), description=dict(default=None), vm=dict(default=None, type='dict'), comment=dict(default=None), vm_per_user=dict(default=None, type='int'), prestarted=dict(default=None, type='int'), vm_count=dict(default=None, type='int'), type=dict(default=None, choices=['automatic', 'manual']), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) check_params(module) try: auth = module.params.pop('auth') connection = create_connection(auth) vm_pools_service = connection.system_service().vm_pools_service() vm_pools_module = VmPoolsModule( connection=connection, module=module, service=vm_pools_service, ) state = module.params['state'] if state == 'present': ret = vm_pools_module.create() # Wait for all VM pool VMs to be created: if module.params['wait']: vms_service = connection.system_service().vms_service() for vm in vms_service.list(search='pool=%s' % module.params['name']): wait( service=vms_service.service(vm.id), condition=lambda vm: vm.status in [otypes.VmStatus.DOWN, otypes.VmStatus.UP], timeout=module.params['timeout'], ) elif state == 'absent': ret = vm_pools_module.remove() module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), id=dict(default=None), address=dict(default=None), path=dict(default=None), nfs_version=dict(default=None), nfs_timeout=dict(default=None, type='int'), nfs_retrans=dict(default=None, type='int'), mount_options=dict(default=None), password=dict(default=None, no_log=True), username=dict(default=None), port=dict(default=None, type='int'), target=dict(default=None), type=dict(default=None), vfs_type=dict(default=None), force=dict(type='bool', default=False), storage=dict(default=None), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) storage_connections_service = connection.system_service( ).storage_connections_service() storage_connection_module = StorageConnectionModule( connection=connection, module=module, service=storage_connections_service, ) entity = None if module.params['id'] is None: entity = find_sc_by_attributes(module, storage_connections_service) state = module.params['state'] if state == 'present': ret = storage_connection_module.create( entity=entity, update_params={'force': True}, ) storage_connection_module.post_present(ret['id']) elif state == 'absent': storage_connection_module.pre_remove(module.params['id']) ret = storage_connection_module.remove(entity=entity) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec(case_sensitive=dict( default=True, type='bool', required=False), from_=dict(default=None, type='int', required=False), max=dict(default=None, type='int', required=False), search=dict(default='', required=False), headers=dict(default='', required=False), query=dict(default='', required=False), wait=dict(default=True, type='bool', required=False)) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_event_facts' if is_old_facts: module.deprecate( "The 'ovirt_event_facts' module has been renamed to 'ovirt_event_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) events_service = connection.system_service().events_service() events = events_service.list( case_sensitive=module.params['case_sensitive'], from_=module.params['from_'], max=module.params['max'], search=module.params['search'], headers=module.params['headers'], query=module.params['query'], wait=module.params['wait']) result = dict(ovirt_events=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in events ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), description=dict(default=None), severity=dict( choices=['error', 'normal', 'warning'], default='normal', ), origin=dict(default=None), custom_id=dict(default=None, type='int'), id=dict(default=None), cluster=dict(default=None), data_center=dict(default=None), host=dict(default=None), storage_domain=dict(default=None), template=dict(default=None), user=dict(default=None), vm=dict(default=None), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) check_sdk(module) # Wait must be set to false if state == absent if module.params['state'] == 'absent' and module.params[ 'wait'] is not False: module.fail_json( msg='When "state" is absent, "wait" must be set to false.') try: auth = module.params.pop('auth') connection = create_connection(auth) events_service = connection.system_service().events_service() events_module = EventsModule( connection=connection, module=module, service=events_service, ) state = module.params['state'] if state == 'present': ret = events_module.create() elif state == 'absent': ret = events_module.remove() module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( vm=dict(required=True), description=dict(default=None), snapshot_id=dict(default=None), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_snapshot_facts' if is_old_facts: module.deprecate("The 'ovirt_snapshot_facts' module has been renamed to 'ovirt_snapshot_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) vms_service = connection.system_service().vms_service() vm_name = module.params['vm'] vm = search_by_name(vms_service, vm_name) if vm is None: raise Exception("VM '%s' was not found." % vm_name) snapshots_service = vms_service.service(vm.id).snapshots_service() if module.params['description']: snapshots = [ e for e in snapshots_service.list() if fnmatch.fnmatch(e.description, module.params['description']) ] elif module.params['snapshot_id']: snapshots = [ snapshots_service.snapshot_service(module.params['snapshot_id']).get() ] else: snapshots = snapshots_service.list() result = dict( ovirt_snapshots=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in snapshots ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict(type='str', default='present', choices=['absent', 'present']), network=dict(type='str', required=True), data_center=dict(type='str', required=True), description=dict(type='str'), name=dict(type='str', required=True), network_filter=dict(type='str'), custom_properties=dict(type='list'), qos=dict(type='str'), pass_through=dict(type='str', choices=['disabled', 'enabled']), port_mirroring=dict(type='bool'), migratable=dict(type='bool'), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) check_params(module) try: auth = module.params.pop('auth') connection = create_connection(auth) vnic_services = connection.system_service().vnic_profiles_service() entitynics_module = EntityVnicPorfileModule( connection=connection, module=module, service=vnic_services, ) state = module.params['state'] entity = get_entity(vnic_services, entitynics_module) if state == 'present': ret = entitynics_module.create(entity=entity, force_create=entity is None) elif state == 'absent': if entity is not None: ret = entitynics_module.remove(entity=entity) else: raise Exception( "Vnic profile '%s' in network '%s' was not found." % (module.params['name'], module.params['network'])) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( data_center=dict(required=True), name=dict(default=None), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_quota_facts' if is_old_facts: module.deprecate( "The 'ovirt_quota_facts' module has been renamed to 'ovirt_quota_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) datacenters_service = connection.system_service().data_centers_service( ) dc_name = module.params['data_center'] dc = search_by_name(datacenters_service, dc_name) if dc is None: raise Exception("Datacenter '%s' was not found." % dc_name) quotas_service = datacenters_service.service(dc.id).quotas_service() if module.params['name']: quotas = [ e for e in quotas_service.list() if fnmatch.fnmatch(e.name, module.params['name']) ] else: quotas = quotas_service.list() result = dict(ovirt_quotas=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in quotas ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( pattern=dict(default='', required=False), all_content=dict(default=False, type='bool'), next_run=dict(default=None, type='bool'), case_sensitive=dict(default=True, type='bool'), max=dict(default=None, type='int'), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_vm_facts' if is_old_facts: module.deprecate( "The 'ovirt_vm_facts' module has been renamed to 'ovirt_vm_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) vms_service = connection.system_service().vms_service() vms = vms_service.list( search=module.params['pattern'], all_content=module.params['all_content'], case_sensitive=module.params['case_sensitive'], max=module.params['max'], ) if module.params['next_run']: vms = [ vms_service.vm_service(vm.id).get(next_run=True) for vm in vms ] result = dict(ovirt_vms=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in vms ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( id=dict(default=None), name=dict(default=None), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_scheduling_policy_facts' if is_old_facts: module.deprecate( "The 'ovirt_scheduling_policy_facts' module has been renamed to 'ovirt_scheduling_policy_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) system_service = connection.system_service() sched_policies_service = system_service.scheduling_policies_service() if module.params['name']: sched_policies = [ e for e in sched_policies_service.list() if fnmatch.fnmatch(e.name, module.params['name']) ] elif module.params['id']: sched_policies = [ sched_policies_service.service(module.params['id']).get() ] else: sched_policies = sched_policies_service.list() result = dict(ovirt_scheduling_policies=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in sched_policies ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( storage_domain=dict(default=None), max=dict(default=None, type='int'), unregistered=dict(default=False, type='bool'), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_storage_vm_facts' if is_old_facts: module.deprecate( "The 'ovirt_storage_vm_facts' module has been renamed to 'ovirt_storage_vm_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) storage_domains_service = connection.system_service( ).storage_domains_service() sd_id = get_id_by_name(storage_domains_service, module.params['storage_domain']) storage_domain_service = storage_domains_service.storage_domain_service( sd_id) vms_service = storage_domain_service.vms_service() # Find the unregistered VM we want to register: if module.params.get('unregistered'): vms = vms_service.list(unregistered=True) else: vms = vms_service.list() result = dict(ovirt_storage_vms=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in vms ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), name=dict(required=True), authz_name=dict(required=True, aliases=['domain']), namespace=dict(default=None), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) check_params(module) try: auth = module.params.pop('auth') connection = create_connection(auth) users_service = connection.system_service().users_service() users_module = UsersModule( connection=connection, module=module, service=users_service, ) state = module.params['state'] if state == 'present': ret = users_module.create( search_params={ 'usrname': username(module), } ) elif state == 'absent': ret = users_module.remove( search_params={ 'usrname': username(module), } ) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), name=dict(default=None, required=True), description=dict(default=None), local=dict(type='bool'), id=dict(default=None), compatibility_version=dict(default=None), quota_mode=dict(choices=['disabled', 'audit', 'enabled']), comment=dict(default=None), mac_pool=dict(default=None), force=dict(default=None, type='bool'), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) check_params(module) try: auth = module.params.pop('auth') connection = create_connection(auth) data_centers_service = connection.system_service().data_centers_service() data_centers_module = DatacentersModule( connection=connection, module=module, service=data_centers_service, ) state = module.params['state'] if state == 'present': ret = data_centers_module.create() elif state == 'absent': ret = data_centers_module.remove(force=module.params['force']) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), cluster=dict(default=None), name=dict(default=None, required=True), vms=dict(default=None, type='list'), hosts=dict(default=None, type='list'), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ('state', 'present', ['cluster']), ], ) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) affinity_labels_service = connection.system_service().affinity_labels_service() affinity_labels_module = AffinityLabelsModule( connection=connection, module=module, service=affinity_labels_service, ) state = module.params['state'] if state == 'present': ret = affinity_labels_module.create() elif state == 'absent': ret = affinity_labels_module.remove() module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent', 'attached', 'detached'], default='present', ), id=dict(default=None), name=dict(required=True), description=dict(default=None), parent=dict(default=None), vms=dict(default=None, type='list'), hosts=dict(default=None, type='list'), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) tags_service = connection.system_service().tags_service() tags_module = TagsModule( connection=connection, module=module, service=tags_service, ) state = module.params['state'] if state in ['present', 'attached', 'detached']: ret = tags_module.create() elif state == 'absent': ret = tags_module.remove() module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), id=dict(default=None), name=dict(default=None), description=dict(default=None), administrative=dict(type='bool', default=False), permits=dict(type='list', default=[]), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[['id', 'name']], ) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) roles_service = connection.system_service().roles_service() roles_module = RoleModule( connection=connection, module=module, service=roles_service, ) state = module.params['state'] if state == 'present': ret = roles_module.create() elif state == 'absent': ret = roles_module.remove() module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( authz_name=dict(required=True, aliases=['domain']), user_name=dict(default=None), group_name=dict(default=None), namespace=dict(default=None), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_permission_facts' if is_old_facts: module.deprecate("The 'ovirt_permission_facts' module has been renamed to 'ovirt_permission_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) permissions_service = _permissions_service(connection, module) permissions = [] for p in permissions_service.list(): newperm = dict() for key, value in p.__dict__.items(): if value and isinstance(value, sdk.Struct): newperm[key[1:]] = get_link_name(connection, value) newperm['%s_id' % key[1:]] = value.id permissions.append(newperm) result = dict(ovirt_permissions=permissions) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent', 'started', 'finished', 'failed'], default='present', ), description=dict(default=None), steps=dict(default=None, type='list'), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=False, ) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) jobs_service = connection.system_service().jobs_service() state = module.params['state'] job = get_entity(jobs_service, module.params['description']) changed = False if state in ['present', 'started']: if job is None or job.status in [ otypes.JobStatus.FINISHED, otypes.JobStatus.FAILED ]: job = jobs_service.add(build_job(module.params['description'])) changed = True changed = attach_steps(module, job.id, jobs_service) or changed if job is not None and job.status not in [ otypes.JobStatus.FINISHED, otypes.JobStatus.FAILED ]: if state in ['absent', 'finished']: jobs_service.job_service(job.id).end(succeeded=True) changed = True elif state == 'failed': jobs_service.job_service(job.id).end(succeeded=False) changed = True ret = { 'changed': changed, 'id': getattr(job, 'id', None), 'job': get_dict_of_struct( struct=job, connection=connection, fetch_nested=True, attributes=module.params.get('nested_attributes'), ), } module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( host=dict(required=True), iscsi=dict(default=None, type='dict'), fcp=dict(default=None, type='dict'), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_host_storage_facts' if is_old_facts: module.deprecate( "The 'ovirt_host_storage_facts' module has been renamed to 'ovirt_host_storage_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) # Get Host hosts_service = connection.system_service().hosts_service() host_id = get_id_by_name(hosts_service, module.params['host']) storage_type = _get_storage_type(module.params) host_service = hosts_service.host_service(host_id) if storage_type == 'iscsi': # Login iscsi = module.params.get('iscsi') _login(host_service, iscsi) # Get LUNs exposed from the specified target host_storages = host_service.storage_service().list() if storage_type == 'iscsi': filterred_host_storages = [ host_storage for host_storage in host_storages if host_storage.type == otypes.StorageType.ISCSI ] if 'target' in iscsi: filterred_host_storages = [ host_storage for host_storage in filterred_host_storages if iscsi.get('target') == host_storage.logical_units[0].target ] elif storage_type == 'fcp': filterred_host_storages = [ host_storage for host_storage in host_storages if host_storage.type == otypes.StorageType.FCP ] result = dict(ovirt_host_storages=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in filterred_host_storages ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), name=dict(default=None, required=True, aliases=['host']), address=dict(default=None), username=dict(default=None), password=dict(default=None, no_log=True), type=dict(default=None), port=dict(default=None, type='int'), order=dict(default=None, type='int'), options=dict(default=None, type='dict'), encrypt_options=dict(default=None, type='bool', aliases=['encrypt']), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) hosts_service = connection.system_service().hosts_service() host = search_by_name(hosts_service, module.params['name']) fence_agents_service = hosts_service.host_service( host.id).fence_agents_service() host_pm_module = HostPmModule( connection=connection, module=module, service=fence_agents_service, ) host_module = HostModule( connection=connection, module=module, service=hosts_service, ) state = module.params['state'] if state == 'present': agent = host_pm_module.search_entity( search_params={ 'address': module.params['address'], 'type': module.params['type'], }) ret = host_pm_module.create(entity=agent) # Enable Power Management, if it's not enabled: host_module.create(entity=host) elif state == 'absent': agent = host_pm_module.search_entity( search_params={ 'address': module.params['address'], 'type': module.params['type'], }) ret = host_pm_module.remove(entity=agent) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict(type='str', default='present', choices=['absent', 'plugged', 'present', 'unplugged']), vm=dict(type='str'), id=dict(default=None), template=dict(type='str'), name=dict(type='str', required=True), interface=dict(type='str'), profile=dict(type='str'), network=dict(type='str'), mac_address=dict(type='str'), linked=dict(type='bool'), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[['vm', 'template']], ) check_sdk(module) try: # Locate the service that manages the virtual machines and use it to # search for the NIC: auth = module.params.pop('auth') connection = create_connection(auth) entity_name = None if module.params.get('vm'): # Locate the VM, where we will manage NICs: entity_name = module.params.get('vm') collection_service = connection.system_service().vms_service() elif module.params.get('template'): entity_name = module.params.get('template') collection_service = connection.system_service().templates_service( ) # TODO: We have to modify the search_by_name function to accept raise_error=True/False, entity = search_by_name(collection_service, entity_name) if entity is None: raise Exception("Vm/Template '%s' was not found." % entity_name) service = collection_service.service(entity.id) cluster_id = entity.cluster nics_service = service.nics_service() entitynics_module = EntityNicsModule( connection=connection, module=module, service=nics_service, ) # Find vNIC id of the network interface (if any): if module.params['network']: profile = module.params.get('profile') cluster_name = get_link_name(connection, cluster_id) dcs_service = connection.system_service().data_centers_service() dc = dcs_service.list(search='Clusters.name=%s' % cluster_name)[0] networks_service = dcs_service.service(dc.id).networks_service() network = next((n for n in networks_service.list() if n.name == module.params['network']), None) if network is None: raise Exception( "Network '%s' was not found in datacenter '%s'." % (module.params['network'], dc.name)) if profile: for vnic in connection.system_service().vnic_profiles_service( ).list(): if vnic.name == profile and vnic.network.id == network.id: entitynics_module.vnic_id = vnic.id else: # When not specified which vnic use ovirtmgmt/ovirtmgmt vnics = get_vnics(networks_service, network, connection) if len(vnics) == 1: entitynics_module.vnic_id = vnics[0].id else: raise Exception( "You didn't specify any vnic profile. " "Following vnic profiles are in system: '%s', please specify one of them" % ([vnic.name for vnic in vnics])) # Handle appropriate action: state = module.params['state'] if state == 'present': ret = entitynics_module.create() elif state == 'absent': ret = entitynics_module.remove() elif state == 'plugged': entitynics_module.create() ret = entitynics_module.action( action='activate', action_condition=lambda nic: not nic.plugged, wait_condition=lambda nic: nic.plugged, ) elif state == 'unplugged': entitynics_module.create() ret = entitynics_module.action( action='deactivate', action_condition=lambda nic: nic.plugged, wait_condition=lambda nic: not nic.plugged, ) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=[ 'present', 'absent', 'maintenance', 'upgraded', 'started', 'restarted', 'stopped', 'reinstalled', 'iscsidiscover', 'iscsilogin' ], default='present', ), name=dict(required=True), id=dict(default=None), comment=dict(default=None), cluster=dict(default=None), address=dict(default=None), password=dict(default=None, no_log=True), public_key=dict(default=False, type='bool', aliases=['ssh_public_key']), kdump_integration=dict(default=None, choices=['enabled', 'disabled']), spm_priority=dict(default=None, type='int'), override_iptables=dict(default=None, type='bool'), force=dict(default=False, type='bool'), timeout=dict(default=600, type='int'), override_display=dict(default=None), kernel_params=dict(default=None, type='list'), hosted_engine=dict(default=None, choices=['deploy', 'undeploy']), power_management_enabled=dict(default=None, type='bool'), activate=dict(default=True, type='bool'), iscsi=dict(default=None, type='dict'), check_upgrade=dict(default=True, type='bool'), reboot_after_upgrade=dict(default=True, type='bool'), vgpu_placement=dict(default=None, choices=['consolidated', 'separated']), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True, required_if=[['state', 'iscsidiscover', ['iscsi']], ['state', 'iscsilogin', ['iscsi']]]) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) hosts_service = connection.system_service().hosts_service() start_event = connection.system_service().events_service().list( max=1)[0] hosts_module = HostsModule( connection=connection, module=module, service=hosts_service, start_event=start_event, ) state = module.params['state'] host = control_state(hosts_module) if state == 'present': ret = hosts_module.create( deploy_hosted_engine=(module.params.get('hosted_engine') == 'deploy') if module.params.get('hosted_engine') is not None else None, activate=module.params['activate'], result_state=( hoststate.MAINTENANCE if module.params['activate'] is False else hoststate.UP) if host is None else None, fail_condition=hosts_module.failed_state_after_reinstall if host is None else lambda h: False, ) if module.params['activate'] and host is not None: ret = hosts_module.action( action='activate', action_condition=lambda h: h.status != hoststate.UP, wait_condition=lambda h: h.status == hoststate.UP, fail_condition=failed_state, ) elif state == 'absent': ret = hosts_module.remove() elif state == 'maintenance': hosts_module.action( action='deactivate', action_condition=lambda h: h.status != hoststate.MAINTENANCE, wait_condition=lambda h: h.status == hoststate.MAINTENANCE, fail_condition=failed_state, ) ret = hosts_module.create() elif state == 'upgraded': result_state = hoststate.MAINTENANCE if host.status == hoststate.MAINTENANCE else hoststate.UP events_service = connection.system_service().events_service() last_event = events_service.list(max=1)[0] if module.params['check_upgrade']: hosts_module.action( action='upgrade_check', action_condition=lambda host: not host.update_available, wait_condition=lambda host: host.update_available or (len([ event for event in events_service.list( from_=int(last_event.id), search='type=885', # Uncomment when 4.1 is EOL, and remove the cond: # if host.name in event.description # search='type=885 and host.name=%s' % host.name, ) if host.name in event.description ]) > 0), fail_condition=lambda host: len([ event for event in events_service.list( from_=int(last_event.id), search='type=839 or type=887 and host.name=%s' % host.name, ) ]) > 0, ) # Set to False, because upgrade_check isn't 'changing' action: hosts_module._changed = False ret = hosts_module.action( action='upgrade', action_condition=lambda h: h.update_available, wait_condition=lambda h: h.status == result_state, post_action=lambda h: time.sleep(module.params['poll_interval'] ), fail_condition=lambda h: hosts_module. failed_state_after_reinstall(h) or (len([ event for event in events_service.list( from_=int(last_event.id), # Fail upgrade if migration fails: # 17: Failed to switch Host to Maintenance mode # 65, 140: Migration failed # 166: No available host was found to migrate VM search='type=65 or type=140 or type=166 or type=17', ) if host.name in event.description ]) > 0), reboot=module.params['reboot_after_upgrade'], ) elif state == 'iscsidiscover': host_id = get_id_by_name(hosts_service, module.params['name']) iscsi_param = module.params['iscsi'] iscsi_targets = hosts_service.service(host_id).iscsi_discover( iscsi=otypes.IscsiDetails( port=int(iscsi_param.get('port', 3260)), username=iscsi_param.get('username'), password=iscsi_param.get('password'), address=iscsi_param.get('address'), portal=iscsi_param.get('portal'), ), ) ret = { 'changed': False, 'id': host_id, 'iscsi_targets': iscsi_targets, } elif state == 'iscsilogin': host_id = get_id_by_name(hosts_service, module.params['name']) iscsi_param = module.params['iscsi'] ret = hosts_module.action( action='iscsi_login', iscsi=otypes.IscsiDetails( port=int(iscsi_param.get('port', 3260)), username=iscsi_param.get('username'), password=iscsi_param.get('password'), address=iscsi_param.get('address'), target=iscsi_param.get('target'), portal=iscsi_param.get('portal'), ), ) elif state == 'started': ret = hosts_module.action( action='fence', action_condition=lambda h: h.status == hoststate.DOWN, wait_condition=lambda h: h.status in [hoststate.UP, hoststate.MAINTENANCE], fail_condition=hosts_module.failed_state_after_reinstall, fence_type='start', ) elif state == 'stopped': hosts_module.action( action='deactivate', action_condition=lambda h: h.status not in [hoststate.MAINTENANCE, hoststate.DOWN], wait_condition=lambda h: h.status in [hoststate.MAINTENANCE, hoststate.DOWN], fail_condition=failed_state, ) ret = hosts_module.action( action='fence', action_condition=lambda h: h.status != hoststate.DOWN, wait_condition=lambda h: h.status == hoststate.DOWN if module.params['wait'] else True, fail_condition=failed_state, fence_type='stop', ) elif state == 'restarted': ret = hosts_module.action( action='fence', wait_condition=lambda h: h.status == hoststate.UP, fail_condition=hosts_module.failed_state_after_reinstall, fence_type='restart', ) elif state == 'reinstalled': # Deactivate host if not in maintanence: hosts_module.action( action='deactivate', action_condition=lambda h: h.status not in [hoststate.MAINTENANCE, hoststate.DOWN], wait_condition=lambda h: h.status in [hoststate.MAINTENANCE, hoststate.DOWN], fail_condition=failed_state, ) # Reinstall host: hosts_module.action( action='install', action_condition=lambda h: h.status == hoststate.MAINTENANCE, post_action=hosts_module.post_reinstall, wait_condition=lambda h: h.status == hoststate.MAINTENANCE, fail_condition=hosts_module.failed_state_after_reinstall, host=otypes.Host( override_iptables=module.params['override_iptables'], ) if module.params['override_iptables'] else None, root_password=module.params['password'], ssh=otypes.Ssh(authentication_method=otypes. SshAuthenticationMethod.PUBLICKEY, ) if module.params['public_key'] else None, deploy_hosted_engine=(module.params.get('hosted_engine') == 'deploy') if module.params.get('hosted_engine') is not None else None, undeploy_hosted_engine=(module.params.get('hosted_engine') == 'undeploy') if module.params.get('hosted_engine') is not None else None, ) # Activate host after reinstall: ret = hosts_module.action( action='activate', action_condition=lambda h: h.status == hoststate.MAINTENANCE, wait_condition=lambda h: h.status == hoststate.UP, fail_condition=failed_state, ) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=[ 'present', 'absent', 'maintenance', 'unattached', 'imported', 'update_ovf_store' ], default='present', ), id=dict(default=None), name=dict(default=None), description=dict(default=None), comment=dict(default=None), data_center=dict(default=None), domain_function=dict(choices=['data', 'iso', 'export'], default='data', aliases=['type']), host=dict(default=None), localfs=dict(default=None, type='dict'), nfs=dict(default=None, type='dict'), iscsi=dict(default=None, type='dict'), managed_block_storage=dict( default=None, type='dict', options=dict(driver_options=dict(type='list'), driver_sensitive_options=dict(type='list', no_log=True))), posixfs=dict(default=None, type='dict'), glusterfs=dict(default=None, type='dict'), fcp=dict(default=None, type='dict'), wipe_after_delete=dict(type='bool', default=None), backup=dict(type='bool', default=None), critical_space_action_blocker=dict(type='int', default=None), warning_low_space=dict(type='int', default=None), destroy=dict(type='bool', default=None), format=dict(type='bool', default=None), discard_after_delete=dict(type='bool', default=None)) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) storage_domains_service = connection.system_service( ).storage_domains_service() storage_domains_module = StorageDomainModule( connection=connection, module=module, service=storage_domains_service, ) state = module.params['state'] control_state(storage_domains_module) if state == 'absent': # Pick random available host when host parameter is missing host_param = module.params['host'] if not host_param: host = search_by_attributes( connection.system_service().hosts_service(), status='up') if host is None: raise Exception( "Not possible to remove storage domain '%s' " "because no host found with status `up`." % module.params['name']) host_param = host.name ret = storage_domains_module.remove( destroy=module.params['destroy'], format=module.params['format'], host=host_param, ) elif state == 'present' or state == 'imported': sd_id = storage_domains_module.create()['id'] storage_domains_module.post_create_check(sd_id) ret = storage_domains_module.action( action='activate', action_condition=lambda s: s.status == sdstate.MAINTENANCE, wait_condition=lambda s: s.status == sdstate.ACTIVE, fail_condition=failed_state, search_params={'id': sd_id} if state == 'imported' else None) elif state == 'maintenance': sd_id = storage_domains_module.create()['id'] storage_domains_module.post_create_check(sd_id) ret = OvirtRetry.backoff(tries=5, delay=1, backoff=2)( storage_domains_module.action)( action='deactivate', action_condition=lambda s: s.status == sdstate.ACTIVE, wait_condition=lambda s: s.status == sdstate.MAINTENANCE, fail_condition=failed_state, ) elif state == 'unattached': ret = storage_domains_module.create() storage_domains_module.pre_remove( storage_domain=storage_domains_service.service( ret['id']).get()) ret['changed'] = storage_domains_module.changed elif state == 'update_ovf_store': ret = storage_domains_module.action(action='update_ovf_store') module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['restore', 'present', 'absent'], default='present', ), vm_name=dict(required=True), snapshot_id=dict(default=None), disks=dict(type='list', options=dict( name=dict(default=None, type='str'), id=dict(default=None, type='str'), )), disk_id=dict(default=None), disk_name=dict(default=None), description=dict(default=None), download_image_path=dict(default=None), upload_image_path=dict(default=None), keep_days_old=dict(default=None, type='int'), use_memory=dict( default=None, type='bool', aliases=['restore_memory', 'save_memory'], ), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True, required_if=[ ('state', 'absent', ['snapshot_id']), ('state', 'restore', ['snapshot_id']), ]) check_sdk(module) ret = {} vm_name = module.params.get('vm_name') auth = module.params['auth'] connection = create_connection(auth) vms_service = connection.system_service().vms_service() vm = search_by_name(vms_service, vm_name) if not vm: module.fail_json( msg="Vm '{name}' doesn't exist.".format(name=vm_name), ) vm_service = vms_service.vm_service(vm.id) snapshots_service = vms_service.vm_service(vm.id).snapshots_service() try: state = module.params['state'] if state == 'present': if module.params.get('disk_id') or module.params.get('disk_name'): module.params['disk_id'] = get_snapshot_disk_id( module, snapshots_service) if module.params['upload_image_path']: ret['changed'] = upload_disk_image(connection, module) if module.params['download_image_path']: ret['changed'] = download_disk_image(connection, module) if module.params.get('keep_days_old') is not None: ret = remove_old_snapshosts(module, vm_service, snapshots_service) else: ret = create_snapshot(module, vm_service, snapshots_service, connection) elif state == 'restore': ret = restore_snapshot(module, vm_service, snapshots_service) elif state == 'absent': ret = remove_snapshot(module, vm_service, snapshots_service) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): module = AnsibleModule( argument_spec=dict( url=dict(default=None), hostname=dict(default=None), username=dict(default=None), password=dict(default=None, no_log=True), ca_file=dict(default=None, type='path'), insecure=dict(required=False, type='bool', default=None), timeout=dict(required=False, type='int', default=0), compress=dict(required=False, type='bool', default=True), kerberos=dict(required=False, type='bool', default=False), headers=dict(required=False, type='dict'), state=dict(default='present', choices=['present', 'absent']), token=dict(default=None), ovirt_auth=dict(required=None, type='dict'), ), required_if=[ ('state', 'absent', ['ovirt_auth']), ], supports_check_mode=True, ) check_sdk(module) state = module.params.get('state') if state == 'present': params = module.params elif state == 'absent': params = module.params['ovirt_auth'] def get_required_parameter(param, env_var, required=False): var = params.get(param) or os.environ.get(env_var) if not var and required and state == 'present': module.fail_json(msg="'%s' is a required parameter." % param) return var url = get_required_parameter('url', 'OVIRT_URL', required=False) hostname = get_required_parameter('hostname', 'OVIRT_HOSTNAME', required=False) if url is None and hostname is None: module.fail_json(msg="You must specify either 'url' or 'hostname'.") if url is None and hostname is not None: url = 'https://{0}/ovirt-engine/api'.format(hostname) username = get_required_parameter('username', 'OVIRT_USERNAME') password = get_required_parameter('password', 'OVIRT_PASSWORD') token = get_required_parameter('token', 'OVIRT_TOKEN') ca_file = get_required_parameter('ca_file', 'OVIRT_CAFILE') insecure = params.get('insecure') if params.get('insecure') is not None else not bool(ca_file) connection = sdk.Connection( url=url, username=username, password=password, ca_file=ca_file, insecure=insecure, timeout=params.get('timeout'), compress=params.get('compress'), kerberos=params.get('kerberos'), headers=params.get('headers'), token=token, ) try: token = connection.authenticate() module.exit_json( changed=False, ansible_facts=dict( ovirt_auth=dict( token=token, url=url, ca_file=ca_file, insecure=insecure, timeout=params.get('timeout'), compress=params.get('compress'), kerberos=params.get('kerberos'), headers=params.get('headers'), ) if state == 'present' else dict() ) ) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: # Close the connection, but don't revoke token connection.close(logout=state == 'absent')
def main(): argument_spec = ovirt_full_argument_spec( state=dict(type='str', default='present', choices=['absent', 'present']), name=dict(type='str'), id=dict(type='str'), memory=dict(type='str'), memory_guaranteed=dict(type='str'), memory_max=dict(type='str'), cpu_sockets=dict(type='int'), cpu_cores=dict(type='int'), cpu_threads=dict(type='int'), operating_system=dict(type='str'), boot_devices=dict(type='list', choices=['cdrom', 'hd', 'network']), serial_console=dict(type='bool'), usb_support=dict(type='bool'), high_availability=dict(type='bool'), high_availability_priority=dict(type='int'), watchdog=dict(type='dict'), host=dict(type='str'), graphical_console=dict(type='dict'), description=dict(type='str'), cpu_mode=dict(type='str'), rng_device=dict(type='str'), rng_bytes=dict(type='int', default=None), rng_period=dict(type='int', default=None), placement_policy=dict(type='str'), cpu_pinning=dict(type='list'), soundcard_enabled=dict(type='bool', default=None), virtio_scsi=dict(type='bool', default=None), smartcard_enabled=dict(type='bool', default=None), io_threads=dict(type='int', default=None), nics=dict(type='list', default=[]), ballooning_enabled=dict(type='bool', default=None), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[['id', 'name']], ) check_sdk(module) check_params(module) try: state = module.params['state'] auth = module.params.pop('auth') connection = create_connection(auth) its_service = connection.system_service().instance_types_service() its_module = InstanceTypeModule( connection=connection, module=module, service=its_service, ) it = its_module.search_entity() if state == 'present': ret = its_module.create(entity=it) its_module.post_present(ret['id']) ret['changed'] = its_module.changed elif state == 'absent': ret = its_module.remove() module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( name=dict(default=None), host=dict(default=None), vm=dict(default=None), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_tag_facts' if is_old_facts: module.deprecate( "The 'ovirt_tag_facts' module has been renamed to 'ovirt_tag_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) tags_service = connection.system_service().tags_service() tags = [] all_tags = tags_service.list() if module.params['name']: tags.extend([ t for t in all_tags if fnmatch.fnmatch(t.name, module.params['name']) ]) if module.params['host']: hosts_service = connection.system_service().hosts_service() host = search_by_name(hosts_service, module.params['host']) if host is None: raise Exception("Host '%s' was not found." % module.params['host']) tags.extend([ tag for tag in hosts_service.host_service( host.id).tags_service().list() ]) if module.params['vm']: vms_service = connection.system_service().vms_service() vm = search_by_name(vms_service, module.params['vm']) if vm is None: raise Exception("Vm '%s' was not found." % module.params['vm']) tags.extend([ tag for tag in vms_service.vm_service(vm.id).tags_service().list() ]) if not (module.params['vm'] or module.params['host'] or module.params['name']): tags = all_tags result = dict(ovirt_tags=[ get_dict_of_struct( struct=t, connection=connection, fetch_nested=module.params['fetch_nested'], attributes=module.params['nested_attributes'], ) for t in tags ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_info_full_argument_spec( name=dict(default=None), host=dict(default=None), vm=dict(default=None), ) module = AnsibleModule(argument_spec) is_old_facts = module._name == 'ovirt_affinity_label_facts' if is_old_facts: module.deprecate( "The 'ovirt_affinity_label_facts' module has been renamed to 'ovirt_affinity_label_info', " "and the renamed one no longer returns ansible_facts", version='2.13') check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) affinity_labels_service = connection.system_service( ).affinity_labels_service() labels = [] all_labels = affinity_labels_service.list() if module.params['name']: labels.extend([ l for l in all_labels if fnmatch.fnmatch(l.name, module.params['name']) ]) if module.params['host']: hosts_service = connection.system_service().hosts_service() if search_by_name(hosts_service, module.params['host']) is None: raise Exception("Host '%s' was not found." % module.params['host']) labels.extend([ label for label in all_labels for host in connection.follow_link(label.hosts) if fnmatch.fnmatch( hosts_service.service(host.id).get().name, module.params['host']) ]) if module.params['vm']: vms_service = connection.system_service().vms_service() if search_by_name(vms_service, module.params['vm']) is None: raise Exception("Vm '%s' was not found." % module.params['vm']) labels.extend([ label for label in all_labels for vm in connection.follow_link(label.vms) if fnmatch.fnmatch( vms_service.service(vm.id).get().name, module.params['vm']) ]) if not (module.params['vm'] or module.params['host'] or module.params['name']): labels = all_labels result = dict(ovirt_affinity_labels=[ get_dict_of_struct( struct=l, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for l in labels ], ) if is_old_facts: module.exit_json(changed=False, ansible_facts=result) else: module.exit_json(changed=False, **result) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict(type='str', default='present', choices=['absent', 'present']), role=dict(type='str', default='UserRole'), object_type=dict(type='str', default='vm', choices=[ 'cluster', 'cpu_profile', 'data_center', 'disk', 'disk_profile', 'host', 'network', 'storage_domain', 'system', 'template', 'vm', 'vm_pool', 'vnic_profile', ]), authz_name=dict(type='str', required=True, aliases=['domain']), object_id=dict(type='str'), object_name=dict(type='str'), user_name=dict(type='str'), group_name=dict(type='str'), namespace=dict(type='str'), quota_name=dict(type='str'), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) check_sdk(module) if (module.params['object_name'] is None and module.params['object_id'] is None) and module.params['object_type'] != 'system': module.fail_json(msg='"object_name" or "object_id" is required') if module.params['user_name'] is None and module.params[ 'group_name'] is None: module.fail_json(msg='"user_name" or "group_name" is required') try: auth = module.params.pop('auth') connection = create_connection(auth) permissions_service = _object_service(connection, module).permissions_service() permissions_module = PermissionsModule( connection=connection, module=module, service=permissions_service, ) permission = _permission(module, permissions_service, connection) state = module.params['state'] if state == 'present': ret = permissions_module.create(entity=permission) elif state == 'absent': ret = permissions_module.remove(entity=permission) module.exit_json(**ret) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)