def main():
argument_spec = ecs_argument_spec()
argument_spec.update(dict(
state=dict(default='present', choices=['present', 'absent']),
user_name=dict(type='str', required=True, aliases=['name']),
display_name=dict(type='str'),
mobile_phone=dict(type='str', aliases=['phone']),
email=dict(type='str'),
comments=dict(type='str'),
new_user_name=dict(type='str'),
# new_mobile_phone=dict(type='str'),
# new_display_name=dict(type='str'),
# new_email=dict(type='str'),
# new_comments=dict(type='str')
))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg='footmark required for this module.')
ram_conn = ram_connect(module)
# Get values of variable
state = module.params['state']
user_name = module.params['user_name']
changed = False
# Check if user exists
user = user_exists(module, ram_conn, user_name)
if state == 'absent':
if not user:
module.exit_json(changed=changed, user={})
try:
module.exit_json(changed=user.delete(), user={})
except RAMResponseError as ex:
module.fail_json(msg='Unable to delete user {0}, error: {1}'.format(user_name, ex))
if not user:
try:
user = ram_conn.create_user(**module.params)
module.exit_json(changed=True, user=user.read())
except RAMResponseError as e:
module.fail_json(msg='Unable to create user, error: {0}'.format(e))
try:
res = user.update(**module.params)
if res:
module.exit_json(changed=True, user=res.read())
except RAMResponseError as e:
module.fail_json(msg='Unable to update user, error: {0}'.format(e))
module.exit_json(changed=changed, user=user.read())
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(
dict(state=dict(default='present', choices=['present', 'absent']),
user_name=dict(type='str', required=True, aliases=['name']),
user_access_key_id=dict(type='str'),
status=dict(type='str', choices=['Active', 'Inactive'])))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg='footmark required for this module.')
ram_conn = ram_connect(module)
# Get values of variable
state = module.params['state']
user_access_key_id = module.params['user_access_key_id']
user_name = module.params['user_name']
aks = list_access_key(module, ram_conn, user_name)
changed = False
if state == 'absent':
try:
module.exit_json(
changed=ram_conn.delete_access_key(**module.params),
access_key={})
except RAMResponseError as e:
module.fail_json(
msg='Unable to delete access_key, error: {}'.format(e))
if user_access_key_id:
try:
res = ram_conn.update_access_key(**module.params)
if res:
module.exit_json(changed=True, access_key=res.read())
module.exit_json(changed=changed, access_key={})
except Exception as e:
module.fail_json(
msg='Unable to update access_key, error: {}'.format(e))
if len(aks) < 2:
try:
access_key = ram_conn.create_access_key(**module.params)
module.exit_json(changed=True, access_key=access_key.read())
except RAMResponseError as e:
module.fail_json(
msg='Unable to create access_key, error: {0}'.format(e))
module.exit_json(changed=changed, access_key=aks)
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(
dict(state=dict(default='present', choices=['present', 'absent']),
role_name=dict(type='str', aliases=['name']),
role_id=dict(type='str', aliases=['id']),
assume_role_policy_document=dict(type='str', aliases=['policy']),
description=dict(type='str')))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg='footmark required for this module.')
ram_conn = ram_connect(module)
# Get values of variable
state = module.params['state']
role_name = module.params['role_name']
assume_role_policy_document = module.params['assume_role_policy_document']
role_id = module.params['role_id']
changed = False
# Check if role exists
role = role_exists(module, ram_conn, role_name, role_id)
if state == 'absent':
if not role:
module.exit_json(changed=changed, role={})
try:
module.exit_json(changed=role.delete(), role={})
except RAMResponseError as ex:
module.fail_json(
msg='Unable to delete role {0}, error: {1}'.format(
role_name, ex))
if not role:
try:
role = ram_conn.create_role(**module.params)
module.exit_json(changed=True, role=role.read())
except RAMResponseError as e:
module.fail_json(msg='Unable to create role, error: {0}'.format(e))
if assume_role_policy_document:
try:
changed = role.update_policy(policy=assume_role_policy_document)
module.exit_json(changed=changed, role=role.get().read())
except RAMResponseError as e:
module.fail_json(
msg='Unable to update role policy, error: {0}'.format(e))
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(
dict(state=dict(default='present', choices=['present', 'absent']),
user_name=dict(type='str', required=True, aliases=['name']),
password=dict(type='str'),
new_password=dict(type='str'),
password_reset_required=dict(type='bool', default=False),
mfa_bind_required=dict(type='bool', default=False)))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg='footmark required for this module.')
ram_conn = ram_connect(module)
# Get values of variable
state = module.params['state']
user_name = module.params['user_name']
changed = False
# Check if profile exists
profile = profile_exists(module, ram_conn, user_name)
# module.exit_json(changed=True, profile=profile.read())
if state == 'absent':
if not profile:
module.exit_json(changed=changed, profile={})
try:
changed = ram_conn.delete_login_profile(**module.params)
module.exit_json(changed=changed, profile={})
except RAMResponseError as ex:
module.fail_json(
msg='Unable to delete profile error: {}'.format(ex))
if not profile:
try:
profile = ram_conn.create_login_profile(**module.params)
module.exit_json(changed=True, profile=profile.read())
except RAMResponseError as e:
module.fail_json(
msg='Unable to create profile, error: {0}'.format(e))
try:
changed = profile.update(**module.params)
module.exit_json(changed=changed, profile=profile.read())
except Exception as e:
module.fail_json(msg='Unable to update profile, error: {0}'.format(e))
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(dict(user_name=dict(type='str', aliases=['name'])))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg="Package 'footmark' required for this module.")
try:
access_key = []
for access in ram_connect(module).list_access_keys(**module.params):
access_key.append(access.read())
module.exit_json(changed=False, access_keys=access_key)
except Exception as e:
module.fail_json(
msg=str("Unable to list access_keys, error:{0}".format(e)))
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(
dict(user_name=dict(type='str', required=True, aliases=['name'])))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg="Package 'footmark' required for this module.")
user_name = module.params['user_name']
try:
profile = ram_connect(module).get_login_profile(user_name=user_name)
module.exit_json(changed=False, profile=profile.read())
except Exception as e:
module.fail_json(msg=str("Unable to get profile, error:{0}".format(e)))
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(dict(name_prefix=dict(type='str')))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg="Package 'footmark' required for this module.")
name_prefix = module.params['name_prefix']
try:
users = []
for user in ram_connect(module).list_users():
if name_prefix and not user.name.startswith(name_prefix):
continue
users.append(user.read())
module.exit_json(changed=False, users=users)
except Exception as e:
module.fail_json(msg=str("Unable to list users, error:{0}".format(e)))
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(dict(
user_name=dict(required=True),
)
)
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg="Package 'footmark' required for this module.")
user_name = module.params['user_name']
result = []
try:
ram = ram_connect(module)
for accesskey in ram.list_access_keys(user_name=user_name):
result.append(get_info(accesskey))
module.exit_json(changed=False, access_keys=result, total=len(result))
except ECSResponseError as e:
module.fail_json(msg='Error in describe access_keys: {0}'.format(e))
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(
dict(
state=dict(type='str',
default='present',
choices=['present', 'absent']),
user_name=dict(type='str', required=True),
access_key_id=dict(type='str'),
is_active=dict(type='bool', default=True),
))
if HAS_FOOTMARK is False:
module.fail_json(
msg=
"Package 'footmark' required for the module alicloud_access_key.")
invocations = {
'present': ali_access_key_create,
'absent': ali_access_key_del,
}
module = AnsibleModule(argument_spec=argument_spec)
ram = ram_connect(module)
invocations[module.params.get('state')](module, ram)
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(dict(
state=dict(default='present', choices=['present', 'absent']),
group_name=dict(type='str', required=True, aliases=['name']),
new_group_name=dict(type='str'),
comments=dict(type='str'),
user_name=dict(type='str')
))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg='footmark required for this module.')
ram_conn = ram_connect(module)
# Get values of variable
state = module.params['state']
group_name = module.params['group_name']
new_group_name = module.params['new_group_name']
comments = module.params['comments']
user_name = module.params['user_name']
changed = False
# Check if user exists
group = group_exists(module, ram_conn, group_name)
if state == 'absent':
if user_name:
try:
changed = group.remove_user(user_name=user_name)
module.exit_json(changed=changed, group=group.read())
except Exception as e:
module.fail_json(msg='Unable to remove user to group {0}, error: {1}'.format(group_name, e))
if not group:
module.exit_json(changed=changed, group={})
try:
module.exit_json(changed=group.delete(), group={})
except RAMResponseError as ex:
module.fail_json(msg='Unable to delete group {0}, error: {1}'.format(group_name, ex))
if not group:
try:
group = ram_conn.create_group(**module.params)
module.exit_json(changed=True, group=group.read())
except RAMResponseError as e:
module.fail_json(msg='Unable to create group, error: {0}'.format(e))
if user_name:
try:
changed = group.add_user(user_name=user_name)
except Exception as e:
module.fail_json(msg='Unable to add user to group {0}, error: {1}'.format(group_name, e))
if comments or new_group_name:
try:
changed = group.update(comments=comments, new_group_name=new_group_name)
except RAMResponseError as e:
module.fail_json(msg='Unable to update comments, error: {0}'.format(e))
module.exit_json(changed=changed, group=group.read())
def main():
argument_spec = ecs_argument_spec()
argument_spec.update(
dict(state=dict(default='present', choices=['present', 'absent']),
policy_document=dict(type='str', aliases=['policy']),
policy_name=dict(type='str', required=True, aliases=['name']),
description=dict(type='str'),
user_name=dict(type='str'),
group_name=dict(type='str'),
role_name=dict(type='str'),
policy_type=dict(type='str',
choices=['System', 'Custom'],
aliases=['type'])))
module = AnsibleModule(argument_spec=argument_spec)
if HAS_FOOTMARK is False:
module.fail_json(msg='footmark required for this module.')
ram_conn = ram_connect(module)
# Get values of variable
state = module.params['state']
policy_name = module.params['policy_name']
user_name = module.params['user_name']
group_name = module.params['group_name']
role_name = module.params['role_name']
policy_type = module.params['policy_type']
changed = False
# Check if policy exists
policy = policy_exists(module, ram_conn, policy_name)
if state == 'absent':
if user_name:
try:
module.exit_json(changed=policy.detach_policy_from_user(
user_name=user_name, policy_type=policy_type),
policy=policy.read())
except RAMResponseError as ex:
module.fail_json(
msg='Unable to detach policy {0} from user {1}, error: {2}'
.format(policy_name, user_name, ex))
if group_name:
try:
module.exit_json(changed=policy.detach_policy_from_group(
group_name=group_name, policy_type=policy_type),
policy=policy.read())
except RAMResponseError as ex:
module.fail_json(
msg='Unable to detach policy {0} from group {1}, error: {2}'
.format(policy_name, group_name, ex))
if role_name:
try:
module.exit_json(changed=policy.detach_policy_from_role(
role_name=role_name, policy_type=policy_type),
policy=policy.read())
except RAMResponseError as ex:
module.fail_json(
msg='Unable to detach policy {0} from role {1}, error: {2}'
.format(policy_name, role_name, ex))
if not policy:
module.exit_json(changed=changed, policy={})
try:
module.exit_json(changed=policy.delete(), policy={})
except RAMResponseError as ex:
module.fail_json(
msg='Unable to delete policy {0}, error: {1}'.format(
policy_name, ex))
if not policy:
try:
policy = ram_conn.create_policy(**module.params)
module.exit_json(changed=True, policy=policy.read())
except RAMResponseError as e:
module.fail_json(
msg='Unable to create policy, error: {0}'.format(e))
if user_name and policy_type:
try:
changed = policy.attach_policy_to_user(policy_type=policy_type,
user_name=user_name)
module.exit_json(changed=changed, policy=policy.read())
except Exception as e:
module.fail_json(
msg='Unable to attach policy to user, error: {0}'.format(e))
if group_name and policy_type:
try:
changed = policy.attach_policy_to_group(policy_type=policy_type,
group_name=group_name)
module.exit_json(changed=changed, policy=policy.read())
except Exception as e:
module.fail_json(
msg='Unable to attach policy to group, error: {0}'.format(e))
if role_name and policy_type:
try:
changed = policy.attach_policy_to_role(policy_type=policy_type,
role_name=role_name)
module.exit_json(changed=changed, policy=policy.read())
except Exception as e:
module.fail_json(
msg='Unable to attach policy to role, error: {0}'.format(e))
