def main(): argument_spec = dict( name=dict(required=True), description=dict(), organization=dict(required=True), variables=dict(), kind=dict(choices=['', 'smart'], default=''), host_filter=dict(), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') description = module.params.get('description') organization = module.params.get('organization') variables = module.params.get('variables') state = module.params.get('state') kind = module.params.get('kind') host_filter = module.params.get('host_filter') json_output = {'inventory': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) inventory = tower_cli.get_resource('inventory') try: org_res = tower_cli.get_resource('organization') org = org_res.get(name=organization) if state == 'present': result = inventory.modify(name=name, organization=org['id'], variables=variables, description=description, kind=kind, host_filter=host_filter, create_on_missing=True) json_output['id'] = result['id'] elif state == 'absent': result = inventory.delete(name=name, organization=org['id']) except (exc.NotFound) as excinfo: module.fail_json( msg='Failed to update inventory, organization not found: {0}'. format(excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest) as excinfo: module.fail_json( msg='Failed to update inventory: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( name=dict(required=True), description=dict(required=False), kind=dict(required=False, choices=KIND_CHOICES.keys()), inputs=dict(type='dict', required=False), injectors=dict(type='dict', required=False), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=False) name = module.params.get('name') kind = module.params.get('kind') state = module.params.get('state') json_output = {'credential_type': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) credential_type_res = tower_cli.get_resource('credential_type') params = {} params['name'] = name params['kind'] = kind params['managed_by_tower'] = False if module.params.get('description'): params['description'] = module.params.get('description') if module.params.get('inputs'): params['inputs'] = module.params.get('inputs') if module.params.get('injectors'): params['injectors'] = module.params.get('injectors') try: if state == 'present': params['create_on_missing'] = True result = credential_type_res.modify(**params) json_output['id'] = result['id'] elif state == 'absent': params['fail_on_missing'] = False result = credential_type_res.delete(**params) except (exc.ConnectionError, exc.BadRequest) as excinfo: module.fail_json( msg='Failed to update credential type: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( job_id=dict(type='int', required=True), timeout=dict(type='int'), min_interval=dict(type='float', default=1), max_interval=dict(type='float', default=30), ) module = TowerModule(argument_spec, supports_check_mode=True) json_output = {} fail_json = None tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) job = tower_cli.get_resource('job') params = module.params.copy() # tower-cli gets very noisy when monitoring. # We pass in our our outfile to suppress the out during our monitor call. outfile = StringIO() params['outfile'] = outfile job_id = params.get('job_id') try: result = job.monitor(job_id, **params) except exc.Timeout as excinfo: result = job.status(job_id) result['id'] = job_id json_output['msg'] = 'Timeout waiting for job to finish.' json_output['timeout'] = True except exc.NotFound as excinfo: fail_json = dict( msg='Unable to wait, no job_id {0} found: {1}'.format( job_id, excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest) as excinfo: fail_json = dict(msg='Unable to wait for job: {0}'.format(excinfo), changed=False) if fail_json is not None: module.fail_json(**fail_json) json_output['success'] = True for k in ('id', 'status', 'elapsed', 'started', 'finished'): json_output[k] = result.get(k) module.exit_json(**json_output)
def main(): argument_spec = dict( username=dict(required=True), first_name=dict(), last_name=dict(), password=dict(no_log=True), email=dict(required=True), superuser=dict(type='bool', default=False), auditor=dict(type='bool', default=False), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) username = module.params.get('username') first_name = module.params.get('first_name') last_name = module.params.get('last_name') password = module.params.get('password') email = module.params.get('email') superuser = module.params.get('superuser') auditor = module.params.get('auditor') state = module.params.get('state') json_output = {'username': username, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) user = tower_cli.get_resource('user') try: if state == 'present': result = user.modify(username=username, first_name=first_name, last_name=last_name, email=email, password=password, is_superuser=superuser, is_auditor=auditor, create_on_missing=True) json_output['id'] = result['id'] elif state == 'absent': result = user.delete(username=username) except (exc.ConnectionError, exc.BadRequest) as excinfo: module.fail_json( msg='Failed to update the user: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( job_template=dict(required=True, type='str'), job_type=dict(choices=['run', 'check', 'scan']), inventory=dict(type='str', default=None), credential=dict(type='str', default=None), limit=dict(), tags=dict(type='list'), extra_vars=dict(type='list'), ) module = TowerModule(argument_spec, supports_check_mode=True) json_output = {} tags = module.params.get('tags') tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) try: params = module.params.copy() if isinstance(tags, list): params['tags'] = ','.join(tags) job = tower_cli.get_resource('job') lookup_fields = ('job_template', 'inventory', 'credential') for field in lookup_fields: try: name = params.pop(field) if name: result = tower_cli.get_resource(field).get(name=name) params[field] = result['id'] except exc.NotFound as excinfo: module.fail_json( msg='Unable to launch job, {0}/{1} was not found: {2}'. format(field, name, excinfo), changed=False) result = job.launch(no_input=True, **params) json_output['id'] = result['id'] json_output['status'] = result['status'] except (exc.ConnectionError, exc.BadRequest) as excinfo: module.fail_json(msg='Unable to launch job: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( name=dict(required=True), description=dict(), organization=dict(required=True), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') description = module.params.get('description') organization = module.params.get('organization') state = module.params.get('state') json_output = {'team': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) team = tower_cli.get_resource('team') try: org_res = tower_cli.get_resource('organization') org = org_res.get(name=organization) if state == 'present': result = team.modify(name=name, organization=org['id'], description=description, create_on_missing=True) json_output['id'] = result['id'] elif state == 'absent': result = team.delete(name=name, organization=org['id']) except (exc.NotFound) as excinfo: module.fail_json( msg='Failed to update team, organization not found: {0}'. format(excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest, exc.NotFound, exc.AuthError) as excinfo: module.fail_json(msg='Failed to update team: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( user=dict(), team=dict(), role=dict(choices=[ "admin", "read", "member", "execute", "adhoc", "update", "use", "auditor", "project_admin", "inventory_admin", "credential_admin", "workflow_admin", "notification_admin" ]), target_team=dict(), inventory=dict(), job_template=dict(), credential=dict(), organization=dict(), project=dict(), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) role_type = module.params.pop('role') state = module.params.pop('state') json_output = {'role': role_type, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) role = tower_cli.get_resource('role') params = update_resources(module, module.params) params['type'] = role_type try: if state == 'present': result = role.grant(**params) json_output['id'] = result['id'] elif state == 'absent': result = role.revoke(**params) except (exc.ConnectionError, exc.BadRequest, exc.NotFound, exc.AuthError) as excinfo: module.fail_json(msg='Failed to update role: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( ldap_server_protocol=dict(type='str', default='ldaps' ), ldap_server_name=dict(type='str'), ldap_server_port=dict(type='int', default=636), ldap_bind_dn=dict(type='str'), ldap_bind_password=dict(type='str', no_log=True), ldap_start_tls=dict(type='bool', default=False), ldap_user_search=dict(type='list'), ldap_group_search=dict(type='str'), ldap_group_type=dict(type='str', choices=['active_directory', 'open_ldap' ,'freeipa'], default='active_directory'), ldap_superuser=dict(type='str'), ldap_organization_map=dict(type='list'), ldap_team_map=dict(type='list'), state=dict(type='str', choices=['present','absent'], default='present'), ldap_user_attr_map = transform_ldap_user_attr_map() ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) if not HAS_TOWER_CLI: module.fail_json(msg="ansible-tower-cli required for this module") tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): state = module.params.get('state') json_output = {} get_ldap_values(module) if state == 'absent': clear_all_ldap_config(module, module.check_mode) if module.changed_values: json_output['changed'] = True json_output['msg'] = ('The following LDAP settings were cleared %s' % module.changed_values) else: json_output['changed'] = False json_output['msg'] = 'LDAP settings already cleared' else: modify_ldap_config(module, module.check_mode) if module.changed_values: json_output['changed'] = True json_output['msg'] = ('The following LDAP settings were changed %s' % module.changed_values) else: json_output['changed'] = False module.exit_json(**json_output)
def main(): argument_spec = dict() module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) host = tower_cli.get_resource('host') try: result = host.list() json_output = {'hosts': result} except (exc.NotFound) as excinfo: module.fail_json( msg='Failed to update host, inventory not found: {0}'.format( excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest, exc.AuthError) as excinfo: module.fail_json(msg='Failed to update host: {0}'.format(excinfo), changed=False) module.exit_json(**json_output)
def main(): argument_spec = dict( all=dict(type='bool', default=False), credential=dict(type='list', default=[]), credential_type=dict(type='list', default=[]), inventory=dict(type='list', default=[]), inventory_script=dict(type='list', default=[]), job_template=dict(type='list', default=[]), notification_template=dict(type='list', default=[]), organization=dict(type='list', default=[]), project=dict(type='list', default=[]), team=dict(type='list', default=[]), user=dict(type='list', default=[]), workflow=dict(type='list', default=[]), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=False) if not HAS_TOWER_CLI: module.fail_json(msg='ansible-tower-cli required for this module') if not TOWER_CLI_HAS_EXPORT: module.fail_json( msg='ansible-tower-cli version does not support export') export_all = module.params.get('all') assets_to_export = {} for asset_type in SEND_ORDER: assets_to_export[asset_type] = module.params.get(asset_type) result = dict( assets=None, changed=False, message='', ) tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): try: receiver = Receiver() result['assets'] = receiver.export_assets( all=export_all, asset_input=assets_to_export) module.exit_json(**result) except TowerCLIError as e: result['message'] = e.message module.fail_json(msg='Receive Failed', **result)
def main(): argument_spec = dict( name=dict(required=True), description=dict(default=''), job_type=dict(choices=['run', 'check', 'scan'], required=True), inventory=dict(default=''), project=dict(required=True), playbook=dict(required=True), credential=dict(default=''), vault_credential=dict(default=''), forks=dict(type='int'), limit=dict(default=''), verbosity=dict(type='int', choices=[0, 1, 2, 3, 4], default=0), extra_vars_path=dict(type='path', required=False), job_tags=dict(default=''), force_handlers_enabled=dict(type='bool', default=False), skip_tags=dict(default=''), start_at_task=dict(default=''), timeout=dict(type='int', default=0), fact_caching_enabled=dict(type='bool', default=False), host_config_key=dict(default=''), ask_diff_mode=dict(type='bool', default=False), ask_extra_vars=dict(type='bool', default=False), ask_limit=dict(type='bool', default=False), ask_tags=dict(type='bool', default=False), ask_skip_tags=dict(type='bool', default=False), ask_job_type=dict(type='bool', default=False), ask_verbosity=dict(type='bool', default=False), ask_inventory=dict(type='bool', default=False), ask_credential=dict(type='bool', default=False), survey_enabled=dict(type='bool', default=False), survey_spec=dict(type='dict', required=False), become_enabled=dict(type='bool', default=False), diff_mode_enabled=dict(type='bool', default=False), concurrent_jobs_enabled=dict(type='bool', default=False), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') state = module.params.pop('state') json_output = {'job_template': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) jt = tower_cli.get_resource('job_template') params = update_resources(module, module.params) params = update_fields(params) params['create_on_missing'] = True try: if state == 'present': result = jt.modify(**params) json_output['id'] = result['id'] elif state == 'absent': result = jt.delete(**params) except (exc.ConnectionError, exc.BadRequest, exc.NotFound) as excinfo: module.fail_json( msg='Failed to update job template: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( name=dict(required=True), description=dict(required=False), inventory=dict(required=True), source=dict(required=True, choices=SOURCE_CHOICES.keys()), credential=dict(required=False), source_vars=dict(required=False), timeout=dict(type='int', required=False), source_project=dict(required=False), source_path=dict(required=False), update_on_project_update=dict(type='bool', required=False), source_regions=dict(required=False), instance_filters=dict(required=False), group_by=dict(required=False), source_script=dict(required=False), overwrite=dict(type='bool', required=False), overwrite_vars=dict(type='bool', required=False), update_on_launch=dict(type='bool', required=False), update_cache_timeout=dict(type='int', required=False), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') inventory = module.params.get('inventory') source = module.params.get('source') state = module.params.get('state') json_output = {'inventory_source': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) inventory_source = tower_cli.get_resource('inventory_source') try: params = {} params['name'] = name params['source'] = source if module.params.get('description'): params['description'] = module.params.get('description') if module.params.get('credential'): credential_res = tower_cli.get_resource('credential') try: credential = credential_res.get( name=module.params.get('credential')) params['credential'] = credential['id'] except (exc.NotFound) as excinfo: module.fail_json( msg='Failed to update credential source,' 'credential not found: {0}'.format(excinfo), changed=False) if module.params.get('source_project'): source_project_res = tower_cli.get_resource('project') try: source_project = source_project_res.get( name=module.params.get('source_project')) params['source_project'] = source_project['id'] except (exc.NotFound) as excinfo: module.fail_json(msg='Failed to update source project,' 'project not found: {0}'.format(excinfo), changed=False) if module.params.get('source_script'): source_script_res = tower_cli.get_resource('inventory_script') try: script = source_script_res.get( name=module.params.get('source_script')) params['source_script'] = script['id'] except (exc.NotFound) as excinfo: module.fail_json(msg='Failed to update source script,' 'script not found: {0}'.format(excinfo), changed=False) try: inventory_res = tower_cli.get_resource('inventory') params['inventory'] = inventory_res.get(name=inventory)['id'] except (exc.NotFound) as excinfo: module.fail_json(msg='Failed to update inventory source, ' 'inventory not found: {0}'.format(excinfo), changed=False) for key in ('source_vars', 'timeout', 'source_path', 'update_on_project_update', 'source_regions', 'instance_filters', 'group_by', 'overwrite', 'overwrite_vars', 'update_on_launch', 'update_cache_timeout'): if module.params.get(key) is not None: params[key] = module.params.get(key) if state == 'present': params['create_on_missing'] = True result = inventory_source.modify(**params) json_output['id'] = result['id'] elif state == 'absent': params['fail_on_missing'] = False result = inventory_source.delete(**params) except (exc.ConnectionError, exc.BadRequest) as excinfo: module.fail_json(msg='Failed to update inventory source: \ {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( assets=dict(required=False), files=dict(required=False, default=[], type='list'), prevent=dict(required=False, default=[], type='list'), password_management=dict(required=False, default='default', choices=['default', 'random']), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=False) if not HAS_TOWER_CLI: module.fail_json(msg='ansible-tower-cli required for this module') if not TOWER_CLI_HAS_EXPORT: module.fail_json( msg='ansible-tower-cli version does not support export') assets = module.params.get('assets') prevent = module.params.get('prevent') password_management = module.params.get('password_management') files = module.params.get('files') result = dict( changed=False, msg='', output='', ) if not assets and not files: result['msg'] = "Assets or files must be specified" module.fail_json(**result) path = None if assets: # We got assets so we need to dump this out to a temp file and append that to files handle, path = mkstemp(prefix='', suffix='', dir='') with open(path, 'w') as f: f.write(assets) files.append(path) tower_auth = tower_auth_config(module) failed = False with settings.runtime_values(**tower_auth): try: sender = Sender(no_color=False) old_stdout = sys.stdout sys.stdout = captured_stdout = StringIO() try: sender.send(files, prevent, password_management) except TypeError as e: # Newer versions of TowerCLI require 4 parameters sender.send(files, prevent, [], password_management) if sender.error_messages > 0: failed = True result[ 'msg'] = "Transfer Failed with %d errors" % sender.error_messages if sender.changed_messages > 0: result['changed'] = True except TowerCLIError as e: result['msg'] = e.message failed = True finally: if path is not None: os.remove(path) result['output'] = captured_stdout.getvalue().split("\n") sys.stdout = old_stdout # Return stdout so that module returns will work if failed: module.fail_json(**result) else: module.exit_json(**result)
def main(): argument_spec = dict( name=dict(required=True), description=dict(), inventory=dict(required=True), variables=dict(), credential=dict(), source=dict(choices=[ "manual", "file", "ec2", "rax", "vmware", "gce", "azure", "azure_rm", "openstack", "satellite6", "cloudforms", "custom" ], default="manual"), source_regions=dict(), source_vars=dict(), instance_filters=dict(), group_by=dict(), source_script=dict(), overwrite=dict(type='bool', default=False), overwrite_vars=dict(), update_on_launch=dict(type='bool', default=False), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') inventory = module.params.get('inventory') credential = module.params.get('credential') state = module.params.pop('state') variables = module.params.get('variables') if variables: if variables.startswith('@'): filename = os.path.expanduser(variables[1:]) with open(filename, 'r') as f: variables = f.read() json_output = {'group': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) group = tower_cli.get_resource('group') try: params = module.params.copy() params['create_on_missing'] = True params['variables'] = variables inv_res = tower_cli.get_resource('inventory') inv = inv_res.get(name=inventory) params['inventory'] = inv['id'] if credential: cred_res = tower_cli.get_resource('credential') cred = cred_res.get(name=credential) params['credential'] = cred['id'] if state == 'present': result = group.modify(**params) json_output['id'] = result['id'] elif state == 'absent': result = group.delete(**params) except (exc.NotFound) as excinfo: module.fail_json( msg='Failed to update the group, inventory not found: {0}'. format(excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest, exc.NotFound) as excinfo: module.fail_json( msg='Failed to update the group: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( name=dict(required=True), user=dict(), team=dict(), kind=dict(required=True, choices=KIND_CHOICES.keys()), host=dict(), username=dict(), password=dict(no_log=True), ssh_key_data=dict(no_log=True, type='str'), ssh_key_unlock=dict(no_log=True), authorize=dict(type='bool', default=False), authorize_password=dict(no_log=True), client=dict(), security_token=dict(), secret=dict(), tenant=dict(), subscription=dict(), domain=dict(), become_method=dict(), become_username=dict(), become_password=dict(no_log=True), vault_password=dict(no_log=True), description=dict(), organization=dict(required=True), project=dict(), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') organization = module.params.get('organization') state = module.params.get('state') json_output = {'credential': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) credential = tower_cli.get_resource('credential') try: params = {} params['create_on_missing'] = True params['name'] = name if organization: org_res = tower_cli.get_resource('organization') org = org_res.get(name=organization) params['organization'] = org['id'] try: tower_cli.get_resource('credential_type') except (ImportError, AttributeError): # /api/v1/ backwards compat # older versions of tower-cli don't *have* a credential_type # resource params['kind'] = module.params['kind'] else: credential_type = credential_type_for_v1_kind( module.params, module) params['credential_type'] = credential_type['id'] if module.params.get('description'): params['description'] = module.params.get('description') if module.params.get('user'): user_res = tower_cli.get_resource('user') user = user_res.get(username=module.params.get('user')) params['user'] = user['id'] if module.params.get('team'): team_res = tower_cli.get_resource('team') team = team_res.get(name=module.params.get('team')) params['team'] = team['id'] if module.params.get('ssh_key_data'): data = module.params.get('ssh_key_data') if os.path.exists(data): module.deprecate( msg= 'ssh_key_data should be a string, not a path to a file. Use lookup(\'file\', \'/path/to/file\') instead', version="2.12") if os.path.isdir(data): module.fail_json( msg='attempted to read contents of directory: %s' % data) with open(data, 'rb') as f: module.params['ssh_key_data'] = to_text(f.read()) else: module.params['ssh_key_data'] = data for key in ('authorize', 'authorize_password', 'client', 'security_token', 'secret', 'tenant', 'subscription', 'domain', 'become_method', 'become_username', 'become_password', 'vault_password', 'project', 'host', 'username', 'password', 'ssh_key_data', 'ssh_key_unlock'): if 'kind' in params: params[key] = module.params.get(key) elif module.params.get(key): params.setdefault('inputs', {})[key] = module.params.get(key) if state == 'present': result = credential.modify(**params) json_output['id'] = result['id'] elif state == 'absent': result = credential.delete(**params) except (exc.NotFound) as excinfo: module.fail_json( msg='Failed to update credential, organization not found: {0}'. format(excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest, exc.NotFound) as excinfo: module.fail_json( msg='Failed to update credential: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( name=dict(), description=dict(), organization=dict(), scm_type=dict(choices=['manual', 'git', 'hg', 'svn'], default='manual'), scm_url=dict(), scm_branch=dict(), scm_credential=dict(), scm_clean=dict(type='bool', default=False), scm_delete_on_update=dict(type='bool', default=False), scm_update_on_launch=dict(type='bool', default=False), local_path=dict(), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') description = module.params.get('description') organization = module.params.get('organization') scm_type = module.params.get('scm_type') if scm_type == "manual": scm_type = "" scm_url = module.params.get('scm_url') local_path = module.params.get('local_path') scm_branch = module.params.get('scm_branch') scm_credential = module.params.get('scm_credential') scm_clean = module.params.get('scm_clean') scm_delete_on_update = module.params.get('scm_delete_on_update') scm_update_on_launch = module.params.get('scm_update_on_launch') state = module.params.get('state') json_output = {'project': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) project = tower_cli.get_resource('project') try: if state == 'present': try: org_res = tower_cli.get_resource('organization') org = org_res.get(name=organization) except (exc.NotFound) as excinfo: module.fail_json( msg= 'Failed to update project, organization not found: {0}' .format(organization), changed=False) if scm_credential: try: cred_res = tower_cli.get_resource('credential') try: cred = cred_res.get(name=scm_credential) except (tower_cli.exceptions.MultipleResults ) as multi_res_excinfo: module.warn( 'Multiple credentials found for {0}, falling back looking in project organization' .format(scm_credential)) cred = cred_res.get(name=scm_credential, organization=org['id']) scm_credential = cred['id'] except (exc.NotFound) as excinfo: module.fail_json( msg= 'Failed to update project, credential not found: {0}' .format(scm_credential), changed=False) result = project.modify( name=name, description=description, organization=org['id'], scm_type=scm_type, scm_url=scm_url, local_path=local_path, scm_branch=scm_branch, scm_clean=scm_clean, credential=scm_credential, scm_delete_on_update=scm_delete_on_update, scm_update_on_launch=scm_update_on_launch, create_on_missing=True) json_output['id'] = result['id'] elif state == 'absent': result = project.delete(name=name) except (exc.ConnectionError, exc.BadRequest) as excinfo: module.fail_json( msg='Failed to update project: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( name=dict(required=True), description=dict(required=False), organization=dict(required=False), notification_type=dict(required=True, choices=['email', 'slack', 'twilio', 'pagerduty', 'hipchat', 'webhook', 'irc']), notification_configuration=dict(required=False), username=dict(required=False), sender=dict(required=False), recipients=dict(required=False, type='list'), use_tls=dict(required=False, type='bool'), host=dict(required=False), use_ssl=dict(required=False, type='bool'), password=dict(required=False, no_log=True), port=dict(required=False, type='int'), channels=dict(required=False, type='list'), token=dict(required=False, no_log=True), account_token=dict(required=False, no_log=True), from_number=dict(required=False), to_numbers=dict(required=False, type='list'), account_sid=dict(required=False), subdomain=dict(required=False), service_key=dict(required=False, no_log=True), client_name=dict(required=False), message_from=dict(required=False), api_url=dict(required=False), color=dict(required=False, choices=['yellow', 'green', 'red', 'purple', 'gray', 'random']), rooms=dict(required=False, type='list'), notify=dict(required=False, type='bool'), url=dict(required=False), headers=dict(required=False, type='dict', default={}), server=dict(required=False), nickname=dict(required=False), targets=dict(required=False, type='list'), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') description = module.params.get('description') organization = module.params.get('organization') notification_type = module.params.get('notification_type') notification_configuration = module.params.get('notification_configuration') username = module.params.get('username') sender = module.params.get('sender') recipients = module.params.get('recipients') use_tls = module.params.get('use_tls') host = module.params.get('host') use_ssl = module.params.get('use_ssl') password = module.params.get('password') port = module.params.get('port') channels = module.params.get('channels') token = module.params.get('token') account_token = module.params.get('account_token') from_number = module.params.get('from_number') to_numbers = module.params.get('to_numbers') account_sid = module.params.get('account_sid') subdomain = module.params.get('subdomain') service_key = module.params.get('service_key') client_name = module.params.get('client_name') message_from = module.params.get('message_from') api_url = module.params.get('api_url') color = module.params.get('color') rooms = module.params.get('rooms') notify = module.params.get('notify') url = module.params.get('url') headers = module.params.get('headers') server = module.params.get('server') nickname = module.params.get('nickname') targets = module.params.get('targets') state = module.params.get('state') json_output = {'notification': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) notification_template = tower_cli.get_resource('notification_template') try: org_res = tower_cli.get_resource('organization') org = org_res.get(name=organization) if state == 'present': result = notification_template.modify(name=name, description=description, organization=org['id'], notification_type=notification_type, notification_configuration=notification_configuration, username=username, sender=sender, recipients=recipients, use_tls=use_tls, host=host, use_ssl=use_ssl, password=password, port=port, channels=channels, token=token, account_token=account_token, from_number=from_number, to_numbers=to_numbers, account_sid=account_sid, subdomain=subdomain, service_key=service_key, client_name=client_name, message_from=message_from, api_url=api_url, color=color, rooms=rooms, notify=notify, url=url, headers=headers, server=server, nickname=nickname, targets=targets, create_on_missing=True) json_output['id'] = result['id'] elif state == 'absent': result = notification_template.delete(name=name) except (exc.NotFound) as excinfo: module.fail_json(msg='Failed to update notification template, organization not found: {0}'.format(excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest, exc.AuthError) as excinfo: module.fail_json(msg='Failed to update notification template: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( name=dict(required=True), description=dict(required=False), extra_vars=dict(required=False), organization=dict(required=False), allow_simultaneous=dict(type='bool', required=False), schema=dict(required=False), survey=dict(required=False), survey_enabled=dict(type='bool', required=False), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=False) name = module.params.get('name') state = module.params.get('state') schema = None if module.params.get('schema'): schema = module.params.get('schema') if schema and state == 'absent': module.fail_json( msg='Setting schema when state is absent is not allowed', changed=False) json_output = {'workflow_template': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) wfjt_res = tower_cli.get_resource('workflow') params = {} params['name'] = name if module.params.get('description'): params['description'] = module.params.get('description') if module.params.get('organization'): organization_res = tower_cli.get_resource('organization') try: organization = organization_res.get( name=module.params.get('organization')) params['organization'] = organization['id'] except exc.NotFound as excinfo: module.fail_json(msg='Failed to update organization source,' 'organization not found: {0}'.format(excinfo), changed=False) if module.params.get('survey'): params['survey_spec'] = module.params.get('survey') for key in ('allow_simultaneous', 'extra_vars', 'survey_enabled', 'description'): if module.params.get(key): params[key] = module.params.get(key) try: if state == 'present': params['create_on_missing'] = True result = wfjt_res.modify(**params) json_output['id'] = result['id'] if schema: wfjt_res.schema(result['id'], schema) elif state == 'absent': params['fail_on_missing'] = False result = wfjt_res.delete(**params) except (exc.ConnectionError, exc.BadRequest) as excinfo: module.fail_json(msg='Failed to update workflow template: \ {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)
def main(): argument_spec = dict( name=dict(required=True), group=dict(required=True), inventory=dict(required=True), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') group = module.params.get('group') inventory = module.params.get('inventory') state = module.params.pop('state') json_output = { 'name': name, 'group': group, 'inventory': inventory, 'state': state } tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) try: params = module.params.copy() # Get existing resources inventories = tower_cli.get_resource('inventory') hosts = tower_cli.get_resource('host') groups = tower_cli.get_resource('group') # Find specific inventory inv = inventories.get(name=inventory) # Find specific host host = hosts.get(name=name, inventory=inv['id']) params['host'] = host['id'] # Find specific group if group == '*': grp = groups.list(inventory=inv['id'], all_pages=True) else: grp = groups.get(name=group, inventory=inv['id']) params['group'] = grp['id'] if state == "present": if group == '*': for g in grp['results']: params['group'] = g['id'] result = hosts.associate(**params) if result['changed']: result[ 'msg'] = 'Successfully associated ' + name + ' with ' + g[ 'name'] elif not result['changed']: result[ 'msg'] = name + ' is already associated with ' + g[ 'name'] else: result = hosts.associate(**params) if result['changed']: result[ 'msg'] = 'Successfully associated ' + name + ' with ' + group elif not result['changed']: result[ 'msg'] = name + ' is already associated with ' + group elif state == "absent": if group == '*': for g in grp['results']: params['group'] = g['id'] result = hosts.disassociate(**params) if result['changed']: result[ 'msg'] = 'Successfully disassociated ' + name + ' with ' + g[ 'name'] elif not result['changed']: result[ 'msg'] = name + ' is already disassociated with ' + g[ 'name'] else: result = hosts.disassociate(**params) if result['changed']: result[ 'msg'] = 'Successfully disassociated ' + name + ' with ' + group elif not result['changed']: result[ 'msg'] = name + ' is already disassociated with ' + group except (exc.NotFound) as excinfo: module.fail_json( msg='Failed to update the host, not found: {0}'.format( excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest, exc.NotFound) as excinfo: module.fail_json( msg='Failed to update the host: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] json_output['msg'] = result['msg'] module.exit_json(**json_output)
def main(): argument_spec = dict( workflow_template=dict(required=True), extra_vars=dict(required=False), wait=dict(required=False, default=True, type='bool'), timeout=dict(required=False, default=None, type='int'), ) module = TowerModule( argument_spec=argument_spec, supports_check_mode=True ) workflow_template = module.params.get('workflow_template') extra_vars = module.params.get('extra_vars') wait = module.params.get('wait') timeout = module.params.get('timeout') # If we are going to use this result to return we can consider ourselfs changed result = dict( changed=False, msg='initial message' ) tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): # First we will test the connection. This will be a test for both check and run mode # Note, we are not using the tower_check_mode method here because we want to do more than just a ping test # If we are in check mode we also want to validate that we can find the workflow try: ping_result = client.get('/ping').json() # Stuff the version into the results as an FYI result['tower_version'] = ping_result['version'] except(ServerError, ConnectionError, BadRequest) as excinfo: result['msg'] = "Failed to reach Tower: {0}".format(excinfo) module.fail_json(**result) # Now that we know we can connect, lets verify that we can resolve the workflow_template try: workflow = tower_cli.get_resource("workflow").get(**{'name': workflow_template}) except TowerCLIError as e: result['msg'] = "Failed to find workflow: {0}".format(e) module.fail_json(**result) # Since we were able to find the workflow, if we are in check mode we can return now if module.check_mode: result['msg'] = "Check mode passed" module.exit_json(**result) # We are no ready to run the workflow try: result['job_info'] = tower_cli.get_resource('workflow_job').launch( workflow_job_template=workflow['id'], monitor=False, wait=wait, timeout=timeout, extra_vars=extra_vars ) if wait: # If we were waiting for a result we will fail if the workflow failed if result['job_info']['failed']: result['msg'] = "Workflow execution failed" module.fail_json(**result) else: module.exit_json(**result) # We were not waiting and there should be no way we can make it here without the workflow fired off so we can return a success module.exit_json(**result) except TowerCLIError as e: result['msg'] = "Failed to execute workflow: {0}".format(e) module.fail_json(**result)
def main(): argument_spec = dict( name=dict(required=True), description=dict(), inventory=dict(required=True), enabled=dict(type='bool', default=True), variables=dict(), groups=dict(type='list'), state=dict(choices=['present', 'absent'], default='present'), ) module = TowerModule(argument_spec=argument_spec, supports_check_mode=True) name = module.params.get('name') description = module.params.get('description') inventory = module.params.get('inventory') enabled = module.params.get('enabled') state = module.params.get('state') groups = module.params.get('groups') variables = module.params.get('variables') if variables: if variables.startswith('@'): filename = os.path.expanduser(variables[1:]) with open(filename, 'r') as f: variables = f.read() json_output = {'host': name, 'state': state} tower_auth = tower_auth_config(module) with settings.runtime_values(**tower_auth): tower_check_mode(module) host = tower_cli.get_resource('host') try: inv_res = tower_cli.get_resource('inventory') inv = inv_res.get(name=inventory) if state == 'present': result = host.modify(name=name, inventory=inv['id'], enabled=enabled, variables=variables, description=description, create_on_missing=True) json_output['id'] = result['id'] if groups: result['changed'] = associate_host_to_group( name, groups, host, inv, json_output) elif state == 'absent': result = host.delete(name=name, inventory=inv['id']) except (exc.NotFound) as excinfo: module.fail_json( msg='Failed to update host, inventory not found: {0}'.format( excinfo), changed=False) except (exc.ConnectionError, exc.BadRequest) as excinfo: module.fail_json(msg='Failed to update host: {0}'.format(excinfo), changed=False) json_output['changed'] = result['changed'] module.exit_json(**json_output)