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)
