def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( uuid=dict(aliases=['id']), name=dict(required=True), description=dict(), role_type=dict( choices=['User', 'DomainAdmin', 'ResourceAdmin', 'Admin'], default='User'), state=dict(choices=['present', 'absent'], default='present'), )) module = AssibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_role = AssibleCloudStackRole(module) state = module.params.get('state') if state == 'absent': role = acs_role.absent_role() else: role = acs_role.present_role() result = acs_role.get_result(role) module.exit_json(**result)
def main(): module = AssibleModule(argument_spec=dict(desc=dict(type='str'), ), ) results = dict(msg="you just ran me.mycoll2.module1", desc=module.params.get('desc')) module.exit_json(**results)
def main(): module = AssibleModule( argument_spec=dict(name=dict(type='str', required=True), use=dict(type='str', choices=STRATS.keys())), supports_check_mode=True, ) hostname = Hostname(module) name = module.params['name'] current_hostname = hostname.get_current_hostname() permanent_hostname = hostname.get_permanent_hostname() changed = hostname.update_current_and_permanent_hostname() if name != current_hostname: name_before = current_hostname elif name != permanent_hostname: name_before = permanent_hostname kw = dict(changed=changed, name=name, assible_facts=dict(assible_hostname=name.split('.')[0], assible_nodename=name, assible_fqdn=socket.getfqdn(), assible_domain='.'.join( socket.getfqdn().split('.')[1:]))) if changed: kw['diff'] = { 'after': 'hostname = ' + name + '\n', 'before': 'hostname = ' + name_before + '\n' } module.exit_json(**kw)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( role=dict(required=True), name=dict(required=True), permission=dict(choices=['allow', 'deny'], default='deny'), description=dict(), state=dict(choices=['present', 'absent'], default='present'), parent=dict(), )) module = AssibleModule(argument_spec=argument_spec, required_together=cs_required_together(), mutually_exclusive=(['permission', 'parent'], ), supports_check_mode=True) acs_role_perm = AssibleCloudStackRolePermission(module) state = module.params.get('state') if state in ['absent']: role_permission = acs_role_perm.remove_role_perm() else: role_permission = acs_role_perm.create_or_update_role_perm() result = acs_role_perm.get_result(role_permission) module.exit_json(**result)
def main(): module = AssibleModule({}) this_module = sys.modules[__name__] module.exit_json( failed=not getattr(this_module, 'AssibleModule', False) )
def main(): module = AssibleModule(argument_spec={}) module.exit_json(**dict( found=bool(paramiko or assible_paramiko), paramiko=bool(paramiko), assible_paramiko=bool(assible_paramiko), ))
def main(): module = AssibleModule( argument_spec=dict( name=dict(required=True), selection=dict(choices=['install', 'hold', 'deinstall', 'purge'], required=True)), supports_check_mode=True, ) dpkg = module.get_bin_path('dpkg', True) name = module.params['name'] selection = module.params['selection'] # Get current settings. rc, out, err = module.run_command([dpkg, '--get-selections', name], check_rc=True) if not out: current = 'not present' else: current = out.split()[1] changed = current != selection if module.check_mode or not changed: module.exit_json(changed=changed, before=current, after=selection) module.run_command([dpkg, '--set-selections'], data="%s %s" % (name, selection), check_rc=True) module.exit_json(changed=changed, before=current, after=selection)
def main(): module = AssibleModule(argument_spec=dict(), supports_check_mode=True) module.run_command_environ_update = dict(LANG="C", LC_ALL="C") service_modules = (ServiceScanService, SystemctlScanService, AIXScanService) all_services = {} incomplete_warning = False for svc_module in service_modules: svcmod = svc_module(module) svc = svcmod.gather_services() if svc is not None: all_services.update(svc) if svcmod.incomplete_warning: incomplete_warning = True if len(all_services) == 0: results = dict( skipped=True, msg= "Failed to find any services. Sometimes this is due to insufficient privileges." ) else: results = dict(assible_facts=dict(services=all_services)) if incomplete_warning: results[ 'msg'] = "WARNING: Could not find status for all services. Sometimes this is due to insufficient privileges." module.exit_json(**results)
def do_echo(): p = _load_params() d = json.loads(basic._ASSIBLE_ARGS) d['ASSIBLE_MODULE_ARGS'] = {} basic._ASSIBLE_ARGS = json.dumps(d).encode('utf-8') module = AssibleModule(argument_spec={}) module.exit_json(args_in=p)
def main(): module = AssibleModule(argument_spec=dict(), supports_check_mode=True) result = dict( two=two(), three=my_util3.three(), ) module.exit_json(**result)
def test_sanity_check(self): basic._load_params = lambda: {} # Module used internally to execute ssh-keygen system executable module = AssibleModule(argument_spec={}) host = '10.0.0.1' key = '%s ssh-rsa ASDF foo@bar' % (host, ) keygen = module.get_bin_path('ssh-keygen') sanity_check(module, host, key, keygen)
def main(): module = AssibleModule( argument_spec=dict( test=dict(type='str'), ), ) module.exit_json()
def main(): module_args = dict( username=dict(type='str', required=True), password=dict(type='str', required=True, no_log=True), ) module = AssibleModule( argument_spec=module_args, required_together=[('username', 'password')], ) # Debugging purposes, get the Kerberos version. On platforms like OpenSUSE this may not be on the PATH. try: process = subprocess.Popen(['krb5-config', '--version'], stdout=subprocess.PIPE) stdout, stderr = process.communicate() version = to_text(stdout) except OSError as e: if e.errno != errno.ENOENT: raise version = 'Unknown (no krb5-config)' # Heimdal has a few quirks that we want to paper over in this module # 1. KRB5_TRACE does not work in any released version (<=7.7), we need to use a custom krb5.config to enable it # 2. When reading the password it reads from the pty not stdin by default causing an issue with subprocess. We # can control that behaviour with '--password-file=STDIN' is_heimdal = os.uname()[0] in ['Darwin', 'FreeBSD'] kinit_args = ['kinit'] config = {} if is_heimdal: kinit_args.append('--password-file=STDIN') config['logging'] = {'krb5': 'FILE:/dev/stdout'} kinit_args.append( to_text(module.params['username'], errors='surrogate_or_strict')) with krb5_conf(module, config): # Weirdly setting KRB5_CONFIG in the modules environment block does not work unless we pass it in explicitly. # Take a copy of the existing environment to make sure the process has the same env vars as ours. Also set # KRB5_TRACE to output and debug logs helping to identify problems when calling kinit with MIT. kinit_env = os.environ.copy() kinit_env['KRB5_TRACE'] = '/dev/stdout' process = subprocess.Popen(kinit_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=kinit_env) stdout, stderr = process.communicate( to_bytes(module.params['password'], errors='surrogate_or_strict') + b'\n') rc = process.returncode module.exit_json(changed=True, stdout=to_text(stdout), stderr=to_text(stderr), rc=rc, version=version)
def main(): module = AssibleModule( argument_spec=dict(filter=dict(choices=['result', 'status']), ), supports_check_mode=True, ) facts = gather_cloud_init_data_facts(module) result = dict(changed=False, assible_facts=facts, **facts) module.exit_json(**result)
def main(): result = dict(changed=False) module = AssibleModule(argument_spec=dict( facts=dict(type=dict, default={}))) result['assible_facts'] = module.params['facts'] result['running_python_interpreter'] = sys.executable module.exit_json(**result)
def main(): module = AssibleModule(argument_spec=dict( data=dict(type='dict', required=True), capitalize_first=dict(type='bool', default=False), ), ) result = snake_dict_to_camel_dict(module.params['data'], module.params['capitalize_first']) module.exit_json(data=result)
def main(): module = AssibleModule(argument_spec=dict(data=dict(type='str', default='pong'), ), supports_check_mode=True) if module.params['data'] == 'crash': raise Exception("boom") result = dict(ping=module.params['data'], ) module.exit_json(**result)
def main(): module = AssibleModule(argument_spec=dict(data=dict(required=False, default=None), ), supports_check_mode=True) result = dict(ping='pong') if module.params['data']: if module.params['data'] == 'crash': raise Exception("boom") result['ping'] = module.params['data'] result['location'] = 'role: bar' module.exit_json(**result)
def main(): module = AssibleModule( argument_spec=dict(), ) result = { 'selinux_special_fs': module._selinux_special_fs, 'tmpdir': module._tmpdir, 'keep_remote_files': module._keep_remote_files, 'version': module.assible_version, } module.exit_json(**result)
def main(): module = AssibleModule(argument_spec={ 'name': { 'default': 'світ' }, }, ) name = module.params['name'] module.exit_json( msg='Greeting {name} completed.'.format(name=name.title()), greeting='Привіт, {name}!'.format(name=name), )
def __init__(self, *args, **kwargs): kwargs['argument_spec'] = self.argspec AssibleModule.__init__(self, *args, **kwargs) if not HAS_K8S_MODULE_HELPER: self.fail_json(msg=missing_required_lib('openshift'), exception=K8S_IMP_ERR, error=to_native(k8s_import_exception)) self.openshift_version = openshift.__version__ if not HAS_YAML: self.fail_json(msg=missing_required_lib("PyYAML"), exception=YAML_IMP_ERR)
def main(): module = AssibleModule(argument_spec=dict( data=dict(type='dict', required=True), reversible=dict(type='bool', default=False), ignore_list=dict(type='list', default=[]), ), ) result = camel_dict_to_snake_dict(module.params['data'], module.params['reversible'], module.params['ignore_list']) module.exit_json(data=result)
def main(): module = AssibleModule(argument_spec=dict( name=dict(required=True, type='str', aliases=['host']), key=dict(required=False, type='str'), path=dict(default="~/.ssh/known_hosts", type='path'), hash_host=dict(required=False, type='bool', default=False), state=dict(default='present', choices=['absent', 'present']), ), supports_check_mode=True) results = enforce_state(module, module.params) module.exit_json(**results)
def main(): module = AssibleModule( argument_spec=dict() ) rlimit_nofile = resource.getrlimit(resource.RLIMIT_NOFILE) try: maxfd = subprocess.MAXFD except AttributeError: maxfd = -1 module.exit_json(rlimit_nofile=rlimit_nofile, maxfd=maxfd, infinity=resource.RLIM_INFINITY)
def main(): module = AssibleModule(argument_spec=dict( at_the_top=dict(type='str', default='some string'), last_one=dict(type='str', default='some string'), egress=dict(type='list', elements='dict', options=dict(port=dict(type='int', required=True), )), ingress=dict(type='list', elements='dict', options=dict(port=dict(type='int', required=True), )), ), ) module.exit_json()
def main(): module = AssibleModule(argument_spec=dict(test_docs_suboptions=dict( type='dict', options=dict( a_first=dict(type='str'), m_middle=dict( type='dict', options=dict(a_suboption=dict(type='str')), ), z_last=dict(type='str'), ), ), ), ) module.exit_json()
def main(): # This module verifies that AssibleModule works when cwd exists but is unreadable. # This situation can occur when running tasks as an unprivileged user. try: cwd = os.getcwd() except OSError: # Compensate for macOS being unable to access cwd as an unprivileged user. # This test is a no-op in this case. # Testing for os.getcwd() failures is handled by the test_cwd_missing module. cwd = '/' os.chdir(cwd) module = AssibleModule(argument_spec=dict()) module.exit_json(before=cwd, after=os.getcwd())
def main(): module = AssibleModule(argument_spec=dict( arg1=dict(type='str', default='default1'), arg2=dict(type='str', default='default2'), arg3=dict(type='str', default='default3'), ), supports_check_mode=True) result = dict(test_module_defaults=dict( arg1=module.params['arg1'], arg2=module.params['arg2'], arg3=module.params['arg3'], ), ) module.exit_json(**result)
def test_invalid_symbolic_modes(mocker, stat_info, mode_string, expected): mock_stat = mocker.MagicMock() mock_stat.st_mode = stat_info with pytest.raises(ValueError) as exc: assert AssibleModule._symbolic_mode_to_octal(mock_stat, mode_string) == 'blah' assert exc.match(expected)
def main(): """main entry point for module execution """ argument_spec = dict( commands=dict(type="list", required=True), wait_for=dict(type="list", aliases=["waitfor"]), match=dict(default="all", choices=["all", "any"]), retries=dict(default=10, type="int"), interval=dict(default=1, type="int"), ) argument_spec.update(ios_argument_spec) module = AssibleModule(argument_spec=argument_spec, supports_check_mode=True) warnings = list() result = {"changed": False, "warnings": warnings} commands = parse_commands(module, warnings) wait_for = module.params["wait_for"] or list() try: conditionals = [Conditional(c) for c in wait_for] except AttributeError as exc: module.fail_json(msg=to_text(exc)) retries = module.params["retries"] interval = module.params["interval"] match = module.params["match"] while retries > 0: responses = run_commands(module, commands) for item in list(conditionals): if item(responses): if match == "any": conditionals = list() break conditionals.remove(item) if not conditionals: break time.sleep(interval) retries -= 1 if conditionals: failed_conditions = [item.raw for item in conditionals] msg = "One or more conditional statements have not been satisfied" module.fail_json(msg=msg, failed_conditions=failed_conditions) result.update({ "stdout": responses, "stdout_lines": list(to_lines(responses)) }) module.exit_json(**result)