def main(): argument_spec = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( pattern=dict(default='', required=False), ) module = AnsibleModule(argument_spec) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) users_service = connection.system_service().users_service() users = users_service.list(search=module.params['pattern']) module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.ovirt_users=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in users ], ), ) 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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( authz_name=dict(required=True, aliases=['domain']), user_name=dict(rdefault=None), group_name=dict(default=None), namespace=dict(default=None), ) module = AnsibleModule(argument_spec) 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) module.exit_json( changed=False, ansible_facts=dict(jctanner.cloud_ovirt.ovirt_permissions=permissions), ) 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 = jctanner.cloud_ovirt.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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( name=dict(default=None), host=dict(default=None), vm=dict(default=None), ) module = AnsibleModule(argument_spec) 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 module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.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 ], ), ) 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 = jctanner.cloud_ovirt.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 = jctanner.cloud_ovirt.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: 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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( host=dict(required=True), iscsi=dict(default=None, type='dict'), fcp=dict(default=None, type='dict'), ) module = AnsibleModule(argument_spec) 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] module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.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 ], ), ) 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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( vm=dict(required=True), description=dict(default=None), snapshot_id=dict(default=None), ) module = AnsibleModule(argument_spec) 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() module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.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 ], ), ) 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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( name=dict(default=None, required=False), type=dict( default=None, required=True, choices=[ 'os_image', 'os_network', 'os_volume', 'foreman', ], aliases=['provider'], ), ) module = AnsibleModule(argument_spec) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) external_providers_service = _external_provider_service( provider_type=module.params.pop('type'), system_service=connection.system_service(), ) if module.params['name']: external_providers = [ e for e in external_providers_service.list() if fnmatch.fnmatch(e.name, module.params['name']) ] else: external_providers = external_providers_service.list() module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.ovirt_external_providers=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in external_providers ], ), ) 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 = jctanner.cloud_ovirt.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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_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) 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'] ) module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.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 ], ), ) 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 = jctanner.cloud_ovirt.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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( data_center=dict(required=True), name=dict(default=None), ) module = AnsibleModule(argument_spec) 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() module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.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 ], ), ) 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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( id=dict(default=None), name=dict(default=None), ) module = AnsibleModule(argument_spec) 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() module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.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 ], ), ) 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 = jctanner.cloud_ovirt.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) 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'] if state == 'present': ret = entitynics_module.create() elif state == 'absent': ret = entitynics_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 = jctanner.cloud_ovirt.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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_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) 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] module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.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 ], ), ) 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 = jctanner.cloud_ovirt.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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( storage_domain=dict(default=None), max=dict(default=None, type='int'), unregistered=dict(default=False, type='bool'), ) module = AnsibleModule(argument_spec) 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) templates_service = storage_domain_service.templates_service() # Find the unregistered Template we want to register: if module.params.get('unregistered'): templates = templates_service.list(unregistered=True) else: templates = templates_service.list(max=module.params['max']) module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.ovirt_storage_templates=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in templates ], ), ) 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 = jctanner.cloud_ovirt.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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( pattern=dict(default='', required=False), all_content=dict(default=False, type='bool'), cluster_version=dict(default=None, type='str'), ) module = AnsibleModule(argument_spec) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) hosts_service = connection.system_service().hosts_service() hosts = hosts_service.list( search=module.params['pattern'], all_content=module.params['all_content'], follow='cluster', ) cluster_version = module.params.get('cluster_version') if cluster_version is not None: hosts = get_filtered_hosts(cluster_version, hosts) module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.ovirt_hosts=[ get_dict_of_struct( struct=c, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) for c in hosts ], ), ) 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 = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec() module = AnsibleModule(argument_spec) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) api = connection.system_service().get() module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.ovirt_api=get_dict_of_struct( struct=api, connection=connection, fetch_nested=module.params.get('fetch_nested'), attributes=module.params.get('nested_attributes'), ) ), ) 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 = jctanner.cloud_ovirt.ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), name=dict(default=None), description=dict(default=None), type=dict( default=None, required=True, choices=[ OS_IMAGE, NETWORK, OS_VOLUME, FOREMAN, ], aliases=['provider'], ), url=dict(default=None), username=dict(default=None), password=dict(default=None, no_log=True), tenant_name=dict(default=None, aliases=['tenant']), authentication_url=dict(default=None, aliases=['auth_url']), data_center=dict(default=None), read_only=dict(default=None, type='bool'), network_type=dict( default='external', choices=['external', 'neutron'], ), authentication_keys=dict( default=[], aliases=['auth_keys'], type='list', no_log=True, ), ) 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) provider_type_param = module.params.get('type') provider_type, external_providers_service = _external_provider_service( provider_type=provider_type_param, system_service=connection.system_service(), ) external_providers_module = ExternalProviderModule( connection=connection, module=module, service=external_providers_service, ) external_providers_module.provider_type(provider_type) state = module.params.pop('state') if state == 'absent': ret = external_providers_module.remove() elif state == 'present': ret = external_providers_module.create() openstack_volume_provider_id = ret.get('id') if ( provider_type_param == OS_VOLUME and openstack_volume_provider_id ): external_providers_module.update_volume_provider_auth_keys( ret, external_providers_service, module.params.get('authentication_keys'), ) 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 = jctanner.cloud_ovirt.ovirt_full_argument_spec( state=dict(type='str', default='present', choices=['absent', 'present']), cluster=dict(type='str', required=True), name=dict(type='str', required=True), description=dict(type='str'), vm_enforcing=dict(type='bool'), vm_rule=dict(type='str', choices=['disabled', 'negative', 'positive']), host_enforcing=dict(type='bool'), host_rule=dict(type='str', choices=['negative', 'positive']), vms=dict(type='list'), hosts=dict(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) # Check if unsupported parameters were passed: supported_41 = ('host_enforcing', 'host_rule', 'hosts') if not check_support( version='4.1', connection=connection, module=module, params=supported_41, ): module.fail_json( msg='Following parameters are supported since 4.1: {params}'.format( params=supported_41, ) ) clusters_service = connection.system_service().clusters_service() vms_service = connection.system_service().vms_service() hosts_service = connection.system_service().hosts_service() cluster_name = module.params['cluster'] cluster = search_by_name(clusters_service, cluster_name) if cluster is None: raise Exception("Cluster '%s' was not found." % cluster_name) cluster_service = clusters_service.cluster_service(cluster.id) affinity_groups_service = cluster_service.affinity_groups_service() # Fetch VM ids which should be assigned to affinity group: vm_ids = sorted([ get_id_by_name(vms_service, vm_name) for vm_name in module.params['vms'] ]) if module.params['vms'] is not None else None # Fetch host ids which should be assigned to affinity group: host_ids = sorted([ get_id_by_name(hosts_service, host_name) for host_name in module.params['hosts'] ]) if module.params['hosts'] is not None else None affinity_groups_module = AffinityGroupsModule( connection=connection, module=module, service=affinity_groups_service, vm_ids=vm_ids, host_ids=host_ids, ) state = module.params['state'] if state == 'present': ret = affinity_groups_module.create() elif state == 'absent': ret = affinity_groups_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 = jctanner.cloud_ovirt.ovirt_full_argument_spec( state=dict( choices=['present', 'absent', 'attached', 'detached', 'exported'], default='present' ), id=dict(default=None), name=dict(default=None, aliases=['alias']), description=dict(default=None), vm_name=dict(default=None), vm_id=dict(default=None), size=dict(default=None), interface=dict(default=None,), storage_domain=dict(default=None), storage_domains=dict(default=None, type='list'), profile=dict(default=None), quota_id=dict(default=None), format=dict(default='cow', choices=['raw', 'cow']), content_type=dict( default='data', choices=['data', 'iso', 'hosted_engine', 'hosted_engine_sanlock', 'hosted_engine_metadata', 'hosted_engine_configuration'] ), sparse=dict(default=None, type='bool'), bootable=dict(default=None, type='bool'), shareable=dict(default=None, type='bool'), logical_unit=dict(default=None, type='dict'), download_image_path=dict(default=None), upload_image_path=dict(default=None, aliases=['image_path']), force=dict(default=False, type='bool'), sparsify=dict(default=None, type='bool'), openstack_volume_type=dict(default=None), image_provider=dict(default=None), host=dict(default=None), wipe_after_delete=dict(type='bool', default=None), activate=dict(default=None, type='bool'), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) lun = module.params.get('logical_unit') host = module.params['host'] # Fail when host is specified with the LUN id. Lun id is needed to identify # an existing disk if already available inthe environment. if (host and lun is None) or (host and lun.get("id") is None): module.fail_json( msg="Can not use parameter host ({0!s}) without " "specifying the logical_unit id".format(host) ) check_sdk(module) check_params(module) try: disk = None state = module.params['state'] auth = module.params.get('auth') connection = create_connection(auth) disks_service = connection.system_service().disks_service() disks_module = DisksModule( connection=connection, module=module, service=disks_service, ) force_create = False vm_service = get_vm_service(connection, module) if lun: disk = _search_by_lun(disks_service, lun.get('id')) else: disk = disks_module.search_entity(search_params=searchable_attributes(module)) if vm_service and disk: # If the VM don't exist in VMs disks, but still it's found it means it was found # for template with same name as VM, so we should force create the VM disk. force_create = disk.id not in [a.disk.id for a in vm_service.disk_attachments_service().list() if a.disk] ret = None # First take care of creating the VM, if needed: if state in ('present', 'detached', 'attached'): ret = disks_module.create( entity=disk if not force_create else None, result_state=otypes.DiskStatus.OK if lun is None else None, fail_condition=lambda d: d.status == otypes.DiskStatus.ILLEGAL if lun is None else False, force_create=force_create, ) is_new_disk = ret['changed'] ret['changed'] = ret['changed'] or disks_module.update_storage_domains(ret['id']) # We need to pass ID to the module, so in case we want detach/attach disk # we have this ID specified to attach/detach method: module.params['id'] = ret['id'] # Upload disk image in case it's new disk or force parameter is passed: if module.params['upload_image_path'] and (is_new_disk or module.params['force']): uploaded = upload_disk_image(connection, module) ret['changed'] = ret['changed'] or uploaded # Download disk image in case it's file don't exist or force parameter is passed: if ( module.params['download_image_path'] and (not os.path.isfile(module.params['download_image_path']) or module.params['force']) ): downloaded = download_disk_image(connection, module) ret['changed'] = ret['changed'] or downloaded # Disk sparsify, only if disk is of image type: if not module.check_mode: disk = disks_service.disk_service(module.params['id']).get() if disk.storage_type == otypes.DiskStorageType.IMAGE: ret = disks_module.action( action='sparsify', action_condition=lambda d: module.params['sparsify'], wait_condition=lambda d: d.status == otypes.DiskStatus.OK, ) # Export disk as image to glance domain elif state == 'exported': disk = disks_module.search_entity() if disk is None: module.fail_json( msg="Can not export given disk '%s', it doesn't exist" % module.params.get('name') or module.params.get('id') ) if disk.storage_type == otypes.DiskStorageType.IMAGE: ret = disks_module.action( action='export', action_condition=lambda d: module.params['image_provider'], wait_condition=lambda d: d.status == otypes.DiskStatus.OK, storage_domain=otypes.StorageDomain(name=module.params['image_provider']), ) elif state == 'absent': ret = disks_module.remove() # If VM was passed attach/detach disks to/from the VM: if vm_service: disk_attachments_service = vm_service.disk_attachments_service() disk_attachments_module = DiskAttachmentsModule( connection=connection, module=module, service=disk_attachments_service, changed=ret['changed'] if ret else False, ) if state == 'present' or state == 'attached': ret = disk_attachments_module.create() if lun is None: wait( service=disk_attachments_service.service(ret['id']), condition=lambda d: follow_link(connection, d.disk).status == otypes.DiskStatus.OK, wait=module.params['wait'], timeout=module.params['timeout'], ) elif state == 'detached': ret = disk_attachments_module.remove() # When the host parameter is specified and the disk is not being # removed, refresh the information about the LUN. if state != 'absent' and host: hosts_service = connection.system_service().hosts_service() host_id = get_id_by_name(hosts_service, host) disks_service.disk_service(disk.id).refresh_lun(otypes.Host(id=host_id)) 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 = jctanner.cloud_ovirt.ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), id=dict(default=None), name=dict(required=True), data_center=dict(required=True), description=dict(default=None), cluster_threshold=dict(default=None, type='int', aliases=['cluster_soft_limit']), cluster_grace=dict(default=None, type='int', aliases=['cluster_hard_limit']), storage_threshold=dict(default=None, type='int', aliases=['storage_soft_limit']), storage_grace=dict(default=None, type='int', aliases=['storage_hard_limit']), clusters=dict(default=[], type='list'), storages=dict(default=[], 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) datacenters_service = connection.system_service().data_centers_service() dc_name = module.params['data_center'] dc_id = getattr(search_by_name(datacenters_service, dc_name), 'id', None) if dc_id is None: raise Exception("Datacenter '%s' was not found." % dc_name) quotas_service = datacenters_service.service(dc_id).quotas_service() quotas_module = QuotasModule( connection=connection, module=module, service=quotas_service, ) state = module.params['state'] if state == 'present': ret = quotas_module.create() # Manage cluster limits: cl_limit_service = quotas_service.service(ret['id']).quota_cluster_limits_service() for cluster in module.params.get('clusters'): cl_limit_service.add( limit=otypes.QuotaClusterLimit( memory_limit=float(cluster.get('memory')), vcpu_limit=cluster.get('cpu'), cluster=search_by_name( connection.system_service().clusters_service(), cluster.get('name') ), ), ) # Manage storage limits: sd_limit_service = quotas_service.service(ret['id']).quota_storage_limits_service() for storage in module.params.get('storages'): sd_limit_service.add( limit=otypes.QuotaStorageLimit( limit=storage.get('size'), storage_domain=search_by_name( connection.system_service().storage_domains_service(), storage.get('name') ), ) ) elif state == 'absent': ret = quotas_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 = jctanner.cloud_ovirt.ovirt_full_argument_spec( state=dict( choices=['restore', 'present', 'absent'], default='present', ), vm_name=dict(required=True), snapshot_id=dict(default=None), 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) 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(): argument_spec = jctanner.cloud_ovirt.jctanner.cloud_ovirt.ovirt_facts_full_argument_spec( name=dict(default=None), host=dict(default=None), vm=dict(default=None), ) module = AnsibleModule(argument_spec) 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 module.exit_json( changed=False, ansible_facts=dict( jctanner.cloud_ovirt.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 ], ), ) 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 = jctanner.cloud_ovirt.ovirt_full_argument_spec( state=dict( choices=['present', 'absent', 'exported', 'imported', 'registered'], default='present', ), id=dict(default=None), name=dict(default=None), vm=dict(default=None), timezone=dict(type='str'), description=dict(default=None), sso=dict(type='bool'), ballooning_enabled=dict(type='bool', default=None), cluster=dict(default=None), usb_support=dict(type='bool'), allow_partial_import=dict(default=None, type='bool'), cpu_profile=dict(default=None), clone_permissions=dict(type='bool'), export_domain=dict(default=None), storage_domain=dict(default=None), exclusive=dict(type='bool'), clone_name=dict(default=None), image_provider=dict(default=None), soundcard_enabled=dict(type='bool', default=None), smartcard_enabled=dict(type='bool', default=None), image_disk=dict(default=None, aliases=['glance_image_disk_name']), io_threads=dict(type='int', default=None), template_image_disk_name=dict(default=None), version=dict(default=None, type='dict'), seal=dict(type='bool'), vnic_profile_mappings=dict(default=[], type='list'), cluster_mappings=dict(default=[], type='list'), role_mappings=dict(default=[], type='list'), domain_mappings=dict(default=[], type='list'), operating_system=dict(type='str'), memory=dict(type='str'), memory_guaranteed=dict(type='str'), memory_max=dict(type='str'), nics=dict(type='list', default=[]), cloud_init=dict(type='dict'), cloud_init_nics=dict(type='list', default=[]), sysprep=dict(type='dict'), ) 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) templates_service = connection.system_service().templates_service() templates_module = TemplatesModule( connection=connection, module=module, service=templates_service, ) entity = None if module.params['version'] is not None and module.params['version'].get('number') is not None: entity = find_subversion_template(module, templates_service) state = module.params['state'] if state == 'present': force_create = False if entity is None and module.params['version'] is not None: force_create = True ret = templates_module.create( entity=entity, # When user want to create new template subversion, we must make sure # template is force created as it already exists, but new version should be created. force_create=force_create, result_state=otypes.TemplateStatus.OK, search_params=searchable_attributes(module), clone_permissions=module.params['clone_permissions'], seal=module.params['seal'], ) elif state == 'absent': ret = templates_module.remove(entity=entity) elif state == 'exported': template = templates_module.search_entity() if entity is not None: template = entity export_service = templates_module._get_export_domain_service() export_template = search_by_attributes(export_service.templates_service(), id=template.id) ret = templates_module.action( entity=template, action='export', action_condition=lambda t: export_template is None or module.params['exclusive'], wait_condition=lambda t: t is not None, post_action=templates_module.post_export_action, storage_domain=otypes.StorageDomain(id=export_service.get().id), exclusive=module.params['exclusive'], ) elif state == 'imported': template = templates_module.search_entity() if entity is not None: template = entity if template and module.params['clone_name'] is None: ret = templates_module.create( result_state=otypes.TemplateStatus.OK, ) else: kwargs = {} if module.params['image_provider']: kwargs.update( disk=otypes.Disk( name=module.params['template_image_disk_name'] or module.params['image_disk'] ), template=otypes.Template( name=module.params['name'] if module.params['clone_name'] is None else module.params['clone_name'], ), clone=True if module.params['clone_name'] is not None else False, import_as_template=True, ) if module.params['image_disk']: # We need to refresh storage domain to get list of images: templates_module._get_export_domain_service().images_service().list() glance_service = connection.system_service().openstack_image_providers_service() image_provider = search_by_name(glance_service, module.params['image_provider']) images_service = glance_service.service(image_provider.id).images_service() else: images_service = templates_module._get_export_domain_service().templates_service() template_name = module.params['image_disk'] or module.params['name'] entity = search_by_name(images_service, template_name) if entity is None: raise Exception("Image/template '%s' was not found." % template_name) images_service.service(entity.id).import_( storage_domain=otypes.StorageDomain( name=module.params['storage_domain'] ) if module.params['storage_domain'] else None, cluster=otypes.Cluster( name=module.params['cluster'] ) if module.params['cluster'] else None, **kwargs ) # Wait for template to appear in system: template = templates_module.wait_for_import( condition=lambda t: t.status == otypes.TemplateStatus.OK ) ret = templates_module.create(result_state=otypes.TemplateStatus.OK) ret = { 'changed': True, 'id': template.id, 'template': get_dict_of_struct(template), } elif state == 'registered': storage_domains_service = connection.system_service().storage_domains_service() # Find the storage domain with unregistered template: sd_id = get_id_by_name(storage_domains_service, module.params['storage_domain']) storage_domain_service = storage_domains_service.storage_domain_service(sd_id) templates_service = storage_domain_service.templates_service() # Find the unregistered Template we want to register: templates = templates_service.list(unregistered=True) template = next( (t for t in templates if (t.id == module.params['id'] or t.name == module.params['name'])), None ) changed = False if template is None: template = templates_module.search_entity() if template is None: raise ValueError( "Template '%s(%s)' wasn't found." % (module.params['name'], module.params['id']) ) else: # Register the template into the system: changed = True template_service = templates_service.template_service(template.id) template_service.register( allow_partial_import=module.params['allow_partial_import'], cluster=otypes.Cluster( name=module.params['cluster'] ) if module.params['cluster'] else None, vnic_profile_mappings=_get_vnic_profile_mappings(module) if module.params['vnic_profile_mappings'] else None, registration_configuration=otypes.RegistrationConfiguration( cluster_mappings=_get_cluster_mappings(module), role_mappings=_get_role_mappings(module), domain_mappings=_get_domain_mappings(module), ) if (module.params['cluster_mappings'] or module.params['role_mappings'] or module.params['domain_mappings']) else None ) if module.params['wait']: template = templates_module.wait_for_import() else: # Fetch template to initialize return. template = template_service.get() ret = templates_module.create(result_state=otypes.TemplateStatus.OK) ret = { 'changed': changed, 'id': template.id, 'template': get_dict_of_struct(template) } 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 = jctanner.cloud_ovirt.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'), ) 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): profile = module.params.get('profile') if profile and module.params['network']: 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 ) ) 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 # 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)