def run_module(): module = AnsibleModule( argument_spec=yaml.safe_load(DOCUMENTATION)['options'], supports_check_mode=True, required_if=[['state', 'present', ['data', 'metadata']]], ) # Gather module parameters in variables name = module.params.get('name') state = module.params.get('state') max_mds = module.params.get('max_mds') if module.check_mode: module.exit_json( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) startd = datetime.datetime.now() changed = False # will return either the image name or None container_image = is_containerized() if state == "present": rc, cmd, out, err = exec_command(module, get_fs(module, container_image=container_image)) if rc == 0: fs = json.loads(out) if max_mds and fs["mdsmap"]["max_mds"] != max_mds: rc, cmd, out, err = exec_command(module, set_fs(module, container_image=container_image)) if rc == 0: changed = True else: rc, cmd, out, err = exec_command(module, create_fs(module, container_image=container_image)) if max_mds and max_mds > 1: exec_command(module, set_fs(module, container_image=container_image)) if rc == 0: changed = True elif state == "absent": rc, cmd, out, err = exec_command(module, get_fs(module, container_image=container_image)) if rc == 0: exec_command(module, fail_fs(module, container_image=container_image)) rc, cmd, out, err = exec_command(module, remove_fs(module, container_image=container_image)) if rc == 0: changed = True else: rc = 0 out = "Ceph File System {} doesn't exist".format(name) elif state == "info": rc, cmd, out, err = exec_command(module, get_fs(module, container_image=container_image)) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed)
def main(): module = AnsibleModule( argument_spec=dict( ids=dict(type='list', required=True), cluster=dict(type='str', required=False, default='ceph'), state=dict(type='str', required=True, choices=['destroy', 'down', 'in', 'out', 'purge', 'rm']), # noqa: E501 ), supports_check_mode=True, ) ids = module.params.get('ids') cluster = module.params.get('cluster') state = module.params.get('state') if state in ['destroy', 'purge'] and len(ids) > 1: module.fail_json( msg='destroy and purge only support one OSD at at time', rc=1) # noqa: E501 startd = datetime.datetime.now() container_image = is_containerized() cmd = generate_ceph_cmd(['osd', state], ids, cluster=cluster, container_image=container_image) # noqa: E501 if state in ['destroy', 'purge']: cmd.append('--yes-i-really-mean-it') if module.check_mode: exit_module(module=module, out='', rc=0, cmd=cmd, err='', startd=startd, changed=False) else: rc, out, err = module.run_command(cmd) changed = True if state in ['down', 'in', 'out'] and 'marked' not in err: changed = False exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed)
def main(): module = AnsibleModule( argument_spec=dict( name=dict(type='str', required=True, choices=[ 'noup', 'nodown', 'noout', 'nobackfill', 'norebalance', 'norecover', 'noscrub', 'nodeep-scrub' ]), cluster=dict(type='str', required=False, default='ceph'), state=dict(type='str', required=False, default='present', choices=['present', 'absent']), ), supports_check_mode=True, ) name = module.params.get('name') cluster = module.params.get('cluster') state = module.params.get('state') startd = datetime.datetime.now() container_image = is_containerized() if state == 'present': cmd = generate_ceph_cmd(['osd', 'set'], [name], cluster=cluster, container_image=container_image) else: cmd = generate_ceph_cmd(['osd', 'unset'], [name], cluster=cluster, container_image=container_image) if module.check_mode: exit_module(module=module, out='', rc=0, cmd=cmd, err='', startd=startd, changed=False) else: rc, out, err = module.run_command(cmd) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=True)
def main(): module = AnsibleModule( argument_spec=dict( name=dict(type='str', required=True), cluster=dict(type='str', required=False, default='ceph'), state=dict(type='str', required=False, default='enable', choices=['enable', 'disable']), # noqa: E501 ), supports_check_mode=True, ) name = module.params.get('name') cluster = module.params.get('cluster') state = module.params.get('state') startd = datetime.datetime.now() container_image = is_containerized() cmd = generate_ceph_cmd(['mgr', 'module'], [state, name], cluster=cluster, container_image=container_image) if module.check_mode: exit_module(module=module, out='', rc=0, cmd=cmd, err='', startd=startd, changed=False) else: rc, out, err = module.run_command(cmd) if 'is already enabled' in err: changed = False else: changed = True exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed)
def run_module(): module_args = dict( cluster=dict(type='str', required=False, default='ceph'), name=dict(type='str', required=True), state=dict(type='str', required=False, default='present', choices=['present', 'absent', 'list']), details=dict(type='bool', required=False, default=False), size=dict(type='str', required=False), min_size=dict(type='str', required=False), pg_num=dict(type='str', required=False), pgp_num=dict(type='str', required=False), pg_autoscale_mode=dict(type='str', required=False, default='on'), target_size_ratio=dict(type='str', required=False, default=None), pool_type=dict(type='str', required=False, default='replicated', choices=['replicated', 'erasure', '1', '3']), erasure_profile=dict(type='str', required=False, default='default'), rule_name=dict(type='str', required=False, default=None), expected_num_objects=dict(type='str', required=False, default="0"), application=dict(type='str', required=False, default=None), ) module = AnsibleModule(argument_spec=module_args, supports_check_mode=True) # Gather module parameters in variables cluster = module.params.get('cluster') name = module.params.get('name') state = module.params.get('state') details = module.params.get('details') size = module.params.get('size') min_size = module.params.get('min_size') pg_num = module.params.get('pg_num') pgp_num = module.params.get('pgp_num') pg_autoscale_mode = module.params.get('pg_autoscale_mode') target_size_ratio = module.params.get('target_size_ratio') application = module.params.get('application') if (module.params.get('pg_autoscale_mode').lower() in ['true', 'on', 'yes']): pg_autoscale_mode = 'on' elif (module.params.get('pg_autoscale_mode').lower() in ['false', 'off', 'no']): pg_autoscale_mode = 'off' else: pg_autoscale_mode = 'warn' if module.params.get('pool_type') == '1': pool_type = 'replicated' elif module.params.get('pool_type') == '3': pool_type = 'erasure' else: pool_type = module.params.get('pool_type') if not module.params.get('rule_name'): rule_name = 'replicated_rule' if pool_type == 'replicated' else None else: rule_name = module.params.get('rule_name') erasure_profile = module.params.get('erasure_profile') expected_num_objects = module.params.get('expected_num_objects') user_pool_config = { 'pool_name': { 'value': name }, 'pg_num': { 'value': pg_num, 'cli_set_opt': 'pg_num' }, 'pgp_num': { 'value': pgp_num, 'cli_set_opt': 'pgp_num' }, 'pg_autoscale_mode': { 'value': pg_autoscale_mode, 'cli_set_opt': 'pg_autoscale_mode' }, 'target_size_ratio': { 'value': target_size_ratio, 'cli_set_opt': 'target_size_ratio' }, 'application': { 'value': application }, 'type': { 'value': pool_type }, 'erasure_profile': { 'value': erasure_profile }, 'crush_rule': { 'value': rule_name, 'cli_set_opt': 'crush_rule' }, 'expected_num_objects': { 'value': expected_num_objects }, 'size': { 'value': size, 'cli_set_opt': 'size' }, 'min_size': { 'value': min_size } } if module.check_mode: module.exit_json( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) startd = datetime.datetime.now() changed = False # will return either the image name or None container_image = is_containerized() user = "******" keyring_filename = cluster + '.' + user + '.keyring' user_key = os.path.join("/etc/ceph/", keyring_filename) if state == "present": rc, cmd, out, err = exec_command( module, check_pool_exist(cluster, name, user, user_key, container_image=container_image)) # noqa: E501 if rc == 0: running_pool_details = get_pool_details( module, cluster, name, user, user_key, container_image=container_image) # noqa: E501 user_pool_config['pg_placement_num'] = { 'value': str(running_pool_details[2]['pg_placement_num']), 'cli_set_opt': 'pgp_num' } # noqa: E501 delta = compare_pool_config(user_pool_config, running_pool_details[2]) if len(delta) > 0: keys = list(delta.keys()) details = running_pool_details[2] if details['erasure_code_profile'] and 'size' in keys: del delta['size'] if details['pg_autoscale_mode'] == 'on': delta.pop('pg_num', None) delta.pop('pgp_num', None) if len(delta) == 0: out = "Skipping pool {}.\nUpdating either 'size' on an erasure-coded pool or 'pg_num'/'pgp_num' on a pg autoscaled pool is incompatible".format( name) # noqa: E501 else: rc, cmd, out, err = update_pool( module, cluster, name, user, user_key, delta, container_image=container_image) # noqa: E501 if rc == 0: changed = True else: out = "Pool {} already exists and there is nothing to update.".format( name) # noqa: E501 else: rc, cmd, out, err = exec_command( module, create_pool( cluster, name, user, user_key, user_pool_config=user_pool_config, # noqa: E501 container_image=container_image)) # noqa: E501 if user_pool_config['application']['value']: rc, _, _, _ = exec_command( module, enable_application_pool( cluster, name, user_pool_config['application']['value'], # noqa: E501 user, user_key, container_image=container_image)) # noqa: E501 if user_pool_config['min_size']['value']: # not implemented yet pass changed = True elif state == "list": rc, cmd, out, err = exec_command( module, list_pools(cluster, name, user, user_key, details, container_image=container_image)) # noqa: E501 if rc != 0: out = "Couldn't list pool(s) present on the cluster" elif state == "absent": rc, cmd, out, err = exec_command( module, check_pool_exist(cluster, name, user, user_key, container_image=container_image)) # noqa: E501 if rc == 0: rc, cmd, out, err = exec_command( module, remove_pool(cluster, name, user, user_key, container_image=container_image)) # noqa: E501 changed = True else: rc = 0 out = "Skipped, since pool {} doesn't exist".format(name) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed)
def run_module(): module_args = dict( cluster=dict(type='str', required=False, default='ceph'), name=dict(type='str', required=False), state=dict(type='str', required=False, default='present', choices=[ 'present', 'update', 'absent', 'list', 'info', 'fetch_initial_keys', 'generate_secret' ]), caps=dict(type='dict', required=False, default=None), secret=dict(type='str', required=False, default=None, no_log=True), import_key=dict(type='bool', required=False, default=True), dest=dict(type='str', required=False, default='/etc/ceph/'), user=dict(type='str', required=False, default='client.admin'), user_key=dict(type='str', required=False, default=None), output_format=dict(type='str', required=False, default='json', choices=['json', 'plain', 'xml', 'yaml'])) module = AnsibleModule( argument_spec=module_args, supports_check_mode=True, add_file_common_args=True, ) file_args = module.load_file_common_arguments(module.params) # Gather module parameters in variables state = module.params['state'] name = module.params.get('name') cluster = module.params.get('cluster') caps = module.params.get('caps') secret = module.params.get('secret') import_key = module.params.get('import_key') dest = module.params.get('dest') user = module.params.get('user') user_key = module.params.get('user_key') output_format = module.params.get('output_format') changed = False result = dict( changed=changed, stdout='', stderr='', rc=0, start='', end='', delta='', ) if module.check_mode: module.exit_json(**result) startd = datetime.datetime.now() # will return either the image name or None container_image = is_containerized() # Test if the key exists, if it does we skip its creation # We only want to run this check when a key needs to be added # There is no guarantee that any cluster is running and we don't need one _secret = secret _caps = caps key_exist = 1 if not user_key: user_key_filename = '{}.{}.keyring'.format(cluster, user) user_key_dir = '/etc/ceph' user_key_path = os.path.join(user_key_dir, user_key_filename) else: user_key_path = user_key if (state in ["present", "update"]): # if dest is not a directory, the user wants to change the file's name # (e,g: /etc/ceph/ceph.mgr.ceph-mon2.keyring) if not os.path.isdir(dest): file_path = dest else: if 'bootstrap' in dest: # Build a different path for bootstrap keys as there are stored # as /var/lib/ceph/bootstrap-rbd/ceph.keyring keyring_filename = cluster + '.keyring' else: keyring_filename = cluster + "." + name + ".keyring" file_path = os.path.join(dest, keyring_filename) file_args['path'] = file_path if import_key: _info_key = [] rc, cmd, out, err = exec_commands( module, info_key(cluster, name, user, user_key_path, output_format, container_image)) # noqa E501 key_exist = rc if not caps and key_exist != 0: fatal("Capabilities must be provided when state is 'present'", module) # noqa E501 if key_exist != 0 and secret is None and caps is None: fatal( "Keyring doesn't exist, you must provide 'secret' and 'caps'", module) # noqa E501 if key_exist == 0: _info_key = json.loads(out) if not secret: secret = _info_key[0]['key'] _secret = _info_key[0]['key'] if not caps: caps = _info_key[0]['caps'] _caps = _info_key[0]['caps'] if secret == _secret and caps == _caps: if not os.path.isfile(file_path): rc, cmd, out, err = exec_commands( module, get_key(cluster, user, user_key_path, name, file_path, container_image)) # noqa E501 result["rc"] = rc if rc != 0: result[ "stdout"] = "Couldn't fetch the key {0} at {1}.".format( name, file_path) # noqa E501 module.exit_json(**result) result[ "stdout"] = "fetched the key {0} at {1}.".format( name, file_path) # noqa E501 result[ "stdout"] = "{0} already exists and doesn't need to be updated.".format( name) # noqa E501 result["rc"] = 0 module.set_fs_attributes_if_different(file_args, False) module.exit_json(**result) else: if os.path.isfile(file_path) and not secret or not caps: result[ "stdout"] = "{0} already exists in {1} you must provide secret *and* caps when import_key is {2}".format( name, dest, import_key) # noqa E501 result["rc"] = 0 module.exit_json(**result) if (key_exist == 0 and (secret != _secret or caps != _caps)) or key_exist != 0: # noqa E501 rc, cmd, out, err = exec_commands( module, create_key(module, result, cluster, user, user_key_path, name, secret, caps, import_key, file_path, container_image)) # noqa E501 if rc != 0: result["stdout"] = "Couldn't create or update {0}".format(name) result["stderr"] = err module.exit_json(**result) module.set_fs_attributes_if_different(file_args, False) changed = True elif state == "absent": if key_exist == 0: rc, cmd, out, err = exec_commands( module, delete_key(cluster, user, user_key_path, name, container_image)) if rc == 0: changed = True else: rc = 0 elif state == "info": rc, cmd, out, err = exec_commands( module, info_key(cluster, name, user, user_key_path, output_format, container_image)) # noqa E501 elif state == "list": rc, cmd, out, err = exec_commands( module, list_keys(cluster, user, user_key_path, container_image)) elif state == "fetch_initial_keys": hostname = socket.gethostname().split('.', 1)[0] user = "******" keyring_filename = cluster + "-" + hostname + "/keyring" user_key_path = os.path.join("/var/lib/ceph/mon/", keyring_filename) rc, cmd, out, err = exec_commands( module, list_keys(cluster, user, user_key_path, container_image)) if rc != 0: result["stdout"] = "failed to retrieve ceph keys" result["sdterr"] = err result['rc'] = 0 module.exit_json(**result) entities = lookup_ceph_initial_entities(module, out) output_format = "plain" for entity in entities: key_path = build_key_path(cluster, entity) if key_path is None: fatal("Failed to build key path, no entity yet?", module) elif os.path.isfile(key_path): # if the key is already on the filesystem # there is no need to fetch it again continue extra_args = [ '-o', key_path, ] info_cmd = info_key(cluster, entity, user, user_key_path, output_format, container_image) # we use info_cmd[0] because info_cmd is an array made of an array info_cmd[0].extend(extra_args) rc, cmd, out, err = exec_commands(module, info_cmd) # noqa E501 file_args = module.load_file_common_arguments(module.params) file_args['path'] = key_path module.set_fs_attributes_if_different(file_args, False) elif state == "generate_secret": out = generate_secret().decode() cmd = '' rc = 0 err = '' changed = True endd = datetime.datetime.now() delta = endd - startd result = dict( cmd=cmd, start=str(startd), end=str(endd), delta=str(delta), rc=rc, stdout=out.rstrip("\r\n"), stderr=err.rstrip("\r\n"), changed=changed, ) if rc != 0: module.fail_json(msg='non-zero return code', **result) module.exit_json(**result)
def run_module(): module_args = dict( cluster=dict(type='str', required=False, default='ceph'), objectstore=dict(type='str', required=False, choices=['bluestore', 'filestore'], default='bluestore'), action=dict(type='str', required=False, choices=[ 'create', 'zap', 'batch', 'prepare', 'activate', 'list', 'inventory' ], default='create'), # noqa: 4502 data=dict(type='str', required=False), data_vg=dict(type='str', required=False), journal=dict(type='str', required=False), journal_vg=dict(type='str', required=False), db=dict(type='str', required=False), db_vg=dict(type='str', required=False), wal=dict(type='str', required=False), wal_vg=dict(type='str', required=False), crush_device_class=dict(type='str', required=False), dmcrypt=dict(type='bool', required=False, default=False), batch_devices=dict(type='list', required=False, default=[]), osds_per_device=dict(type='int', required=False, default=1), journal_size=dict(type='str', required=False, default='5120'), journal_devices=dict(type='list', required=False, default=[]), block_db_size=dict(type='str', required=False, default='-1'), block_db_devices=dict(type='list', required=False, default=[]), wal_devices=dict(type='list', required=False, default=[]), report=dict(type='bool', required=False, default=False), osd_fsid=dict(type='str', required=False), osd_id=dict(type='str', required=False), destroy=dict(type='bool', required=False, default=True), ) module = AnsibleModule(argument_spec=module_args, supports_check_mode=True, mutually_exclusive=[ ('data', 'osd_fsid', 'osd_id'), ], required_if=[('action', 'zap', ('data', 'osd_fsid', 'osd_id'), True)]) result = dict( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) if module.check_mode: module.exit_json(**result) # start execution startd = datetime.datetime.now() # get the desired action action = module.params['action'] # will return either the image name or None container_image = is_containerized() # Assume the task's status will be 'changed' changed = True if action == 'create' or action == 'prepare': # First test if the device has Ceph LVM Metadata rc, cmd, out, err = exec_command(module, list_osd(module, container_image)) # list_osd returns a dict, if the dict is empty this means # we can not check the return code since it's not consistent # with the plain output # see: http://tracker.ceph.com/issues/36329 # FIXME: it's probably less confusing to check for rc # convert out to json, ansible returns a string... try: out_dict = json.loads(out) except ValueError: fatal( "Could not decode json output: {} from the command {}".format( out, cmd), module) # noqa: E501 if out_dict: data = module.params['data'] result[ 'stdout'] = 'skipped, since {0} is already used for an osd'.format( data) # noqa: E501 result['rc'] = 0 module.exit_json(**result) # Prepare or create the OSD rc, cmd, out, err = exec_command( module, prepare_or_create_osd(module, action, container_image)) err = re.sub('[a-zA-Z0-9+/]{38}==', '*' * 8, err) elif action == 'activate': if container_image: fatal( "This is not how container's activation happens, nothing to activate", module) # noqa: E501 # Activate the OSD rc, cmd, out, err = exec_command(module, activate_osd()) elif action == 'zap': # Zap the OSD skip = [] for device_type in ['journal', 'data', 'db', 'wal']: # 1/ if we passed vg/lv if module.params.get('{}_vg'.format(device_type), None) and module.params.get( device_type, None): # noqa: E501 # 2/ check this is an actual lv/vg ret = is_lv(module, module.params['{}_vg'.format(device_type)], module.params[device_type], container_image) # noqa: E501 skip.append(ret) # 3/ This isn't a lv/vg device if not ret: module.params['{}_vg'.format(device_type)] = False module.params[device_type] = False # 4/ no journal|data|db|wal|_vg was passed, so it must be a raw device # noqa: E501 elif not module.params.get('{}_vg'.format(device_type), None) and module.params.get( device_type, None): # noqa: E501 skip.append(True) cmd = zap_devices(module, container_image) if any(skip) or module.params.get('osd_fsid', None) \ or module.params.get('osd_id', None): rc, cmd, out, err = exec_command(module, cmd) for scan_cmd in ['vgscan', 'lvscan']: module.run_command([scan_cmd, '--cache']) else: out = 'Skipped, nothing to zap' err = '' changed = False rc = 0 elif action == 'list': # List Ceph LVM Metadata on a device rc, cmd, out, err = exec_command(module, list_osd(module, container_image)) elif action == 'inventory': # List storage device inventory. rc, cmd, out, err = exec_command( module, list_storage_inventory(module, container_image)) elif action == 'batch': # Batch prepare AND activate OSDs report = module.params.get('report', None) # Add --report flag for the idempotency test report_flags = [ '--report', '--format=json', ] cmd = batch(module, container_image, report=True) batch_report_cmd = copy.copy(cmd) batch_report_cmd.extend(report_flags) # Run batch --report to see what's going to happen # Do not run the batch command if there is nothing to do rc, cmd, out, err = exec_command(module, batch_report_cmd) try: if not out: out = '{}' report_result = json.loads(out) except ValueError: strategy_changed_in_out = "strategy changed" in out strategy_changed_in_err = "strategy changed" in err strategy_changed = strategy_changed_in_out or \ strategy_changed_in_err if strategy_changed: if strategy_changed_in_out: out = json.dumps({ "changed": False, "stdout": out.rstrip("\r\n") }) elif strategy_changed_in_err: out = json.dumps({ "changed": False, "stderr": err.rstrip("\r\n") }) rc = 0 changed = False else: out = out.rstrip("\r\n") result = dict( cmd=cmd, stdout=out.rstrip('\r\n'), stderr=err.rstrip('\r\n'), rc=rc, changed=changed, ) if strategy_changed: module.exit_json(**result) module.fail_json(msg='non-zero return code', **result) if not report: if 'changed' in report_result: # we have the old batch implementation # if not asking for a report, let's just run the batch command changed = report_result['changed'] if changed: # Batch prepare the OSD rc, cmd, out, err = exec_command( module, batch(module, container_image)) err = re.sub('[a-zA-Z0-9+/]{38}==', '*' * 8, err) else: # we have the refactored batch, its idempotent so lets just # run it rc, cmd, out, err = exec_command( module, batch(module, container_image)) err = re.sub('[a-zA-Z0-9+/]{38}==', '*' * 8, err) else: cmd = batch_report_cmd endd = datetime.datetime.now() delta = endd - startd result = dict( cmd=cmd, start=str(startd), end=str(endd), delta=str(delta), rc=rc, stdout=out.rstrip('\r\n'), stderr=err.rstrip('\r\n'), changed=changed, ) if rc != 0: module.fail_json(msg='non-zero return code', **result) module.exit_json(**result)
def run_module(): module = AnsibleModule( argument_spec=yaml.safe_load(DOCUMENTATION)['options'], supports_check_mode=True, required_if=[['apply', True, ['render_path']]], ) # Gather module parameters in variables cluster = module.params.get('cluster') service_type = module.params.get('service_type') service_id = module.params.get('service_type') service_name = module.params.get('service_name') hosts = module.params.get('hosts') host_pattern = module.params.get('host_pattern') networks = module.params.get('networks') labels = module.params.get('labels') spec = module.params.get('spec') extra = module.params.get('extra') apply = module.params.get('apply') render_path = module.params.get('render_path') if module.check_mode: module.exit_json( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) startd = datetime.datetime.now() changed = False # PROCESSING PARAMETERS if service_id is None: service_id = service_type if service_name is None: service_name = "{}.{}".format(service_type, service_id) # no spec is provided if spec is None: spec = {} # no spec is provided if extra is None: extra = {} # no labels are defined if labels is None: labels = [] # no networks are defined if networks is None: networks = [] d = ceph_spec.CephDaemonSpec(service_type, service_id, service_name, hosts, host_pattern, networks, spec, labels, **extra) if apply: container_image = is_containerized() render('{}/{}'.format(render_path, service_type), d.make_daemon_spec()) cmd = generate_orch_cli(cluster, '{}/{}'.format(render_path, service_type), container_image) rc, cmd, out, err = exec_command(module, cmd) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed) else: # render the dict as the output of the module module.exit_json(changed=True, result=d.make_daemon_spec())
def run_module(): module_args = dict( cluster=dict(type='str', required=False, default='ceph'), name=dict(type='str', required=True), state=dict(type='str', required=False, choices=['present', 'absent', 'info'], default='present'), password=dict(type='str', required=False, no_log=True), roles=dict(type='list', required=False, choices=['administrator', 'read-only', 'block-manager', 'rgw-manager', 'cluster-manager', 'pool-manager', 'cephfs-manager'], default=[]), ) module = AnsibleModule( argument_spec=module_args, supports_check_mode=True, required_if=[['state', 'present', ['password']]] ) # Gather module parameters in variables name = module.params.get('name') state = module.params.get('state') roles = module.params.get('roles') password = module.params.get('password') if module.check_mode: module.exit_json( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) startd = datetime.datetime.now() changed = False # will return either the image name or None container_image = is_containerized() if state == "present": rc, cmd, out, err = exec_command(module, get_user(module, container_image=container_image)) if rc == 0: user = json.loads(out) user['roles'].sort() roles.sort() if user['roles'] != roles: rc, cmd, out, err = exec_command(module, set_roles(module, container_image=container_image)) changed = True rc, cmd, out, err = exec_command(module, set_password(module, container_image=container_image), stdin=password) else: rc, cmd, out, err = exec_command(module, create_user(module, container_image=container_image), stdin=password) rc, cmd, out, err = exec_command(module, set_roles(module, container_image=container_image)) changed = True elif state == "absent": rc, cmd, out, err = exec_command(module, get_user(module, container_image=container_image)) if rc == 0: rc, cmd, out, err = exec_command(module, remove_user(module, container_image=container_image)) changed = True else: rc = 0 out = "Dashboard User {} doesn't exist".format(name) elif state == "info": rc, cmd, out, err = exec_command(module, get_user(module, container_image=container_image)) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed)
def main(): module = AnsibleModule(argument_spec=dict( name=dict(type='str', required=True), cluster=dict(type='str', required=False, default='ceph'), state=dict(type='str', required=False, choices=['present', 'absent', 'info'], default='present'), rule_type=dict(type='str', required=False, choices=['replicated', 'erasure']), bucket_root=dict(type='str', required=False), bucket_type=dict(type='str', required=False, choices=[ 'osd', 'host', 'chassis', 'rack', 'row', 'pdu', 'pod', 'room', 'datacenter', 'zone', 'region', 'root' ]), device_class=dict(type='str', required=False), profile=dict(type='str', required=False)), supports_check_mode=True, required_if=[('state', 'present', ['rule_type']), ('rule_type', 'replicated', ['bucket_root', 'bucket_type']), ('rule_type', 'erasure', ['profile'])]) # Gather module parameters in variables name = module.params.get('name') state = module.params.get('state') rule_type = module.params.get('rule_type') if module.check_mode: module.exit_json( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) startd = datetime.datetime.now() changed = False # will return either the image name or None container_image = is_containerized() if state == "present": rc, cmd, out, err = exec_command( module, get_rule(module, container_image=container_image)) if rc != 0: rc, cmd, out, err = exec_command( module, create_rule(module, container_image=container_image)) changed = True else: rule = json.loads(out) if (rule['type'] == 1 and rule_type == 'erasure') or ( rule['type'] == 3 and rule_type == 'replicated'): module.fail_json( msg="Can not convert crush rule {} to {}".format( name, rule_type), changed=False, rc=1) elif state == "absent": rc, cmd, out, err = exec_command( module, get_rule(module, container_image=container_image)) if rc == 0: rc, cmd, out, err = exec_command( module, remove_rule(module, container_image=container_image)) changed = True else: rc = 0 out = "Crush Rule {} doesn't exist".format(name) elif state == "info": rc, cmd, out, err = exec_command( module, get_rule(module, container_image=container_image)) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed)
def run_module(): module_args = dict( cluster=dict(type='str', required=False, default='ceph'), name=dict(type='str', required=True), state=dict(type='str', required=False, choices=['present', 'absent'], default='present'), stripe_unit=dict(type='str', required=False), k=dict(type='str', required=False), m=dict(type='str', required=False), ) module = AnsibleModule( argument_spec=module_args, supports_check_mode=True, required_if=[['state', 'present', ['k', 'm']]], ) # Gather module parameters in variables name = module.params.get('name') cluster = module.params.get('cluster') state = module.params.get('state') stripe_unit = module.params.get('stripe_unit') k = module.params.get('k') m = module.params.get('m') if module.check_mode: module.exit_json( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) startd = datetime.datetime.now() changed = False # will return either the image name or None container_image = is_containerized() if state == "present": rc, cmd, out, err = exec_command( module, get_profile(module, name, cluster, container_image=container_image)) # noqa: E501 if rc == 0: # the profile already exists, let's check whether we have to # update it current_profile = json.loads(out) if current_profile['k'] != k or \ current_profile['m'] != m or \ current_profile.get('stripe_unit', stripe_unit) != stripe_unit: rc, cmd, out, err = exec_command( module, create_profile( module, name, k, m, stripe_unit, cluster, force=True, container_image=container_image)) # noqa: E501 changed = True else: # the profile doesn't exist, it has to be created rc, cmd, out, err = exec_command( module, create_profile( module, name, k, m, stripe_unit, # noqa: E501 cluster, container_image=container_image)) # noqa: E501 if rc == 0: changed = True elif state == "absent": rc, cmd, out, err = exec_command( module, delete_profile(module, name, cluster, container_image=container_image)) # noqa: E501 if not err: out = 'Profile {} removed.'.format(name) changed = True else: rc = 0 out = "Skipping, the profile {} doesn't exist".format(name) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed) # noqa: E501
def run_module(): module = AnsibleModule( argument_spec=yaml.safe_load(DOCUMENTATION)['options'], supports_check_mode=True, required_if=[['state', 'present', ['password']]]) # Gather module parameters in variables name = module.params.get('name') state = module.params.get('state') roles = module.params.get('roles') password = module.params.get('password') if module.check_mode: module.exit_json( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) startd = datetime.datetime.now() changed = False # will return either the image name or None container_image = is_containerized() if state == "present": rc, cmd, out, err = exec_command( module, get_user(module, container_image=container_image)) if rc == 0: user = json.loads(out) user['roles'].sort() roles.sort() if user['roles'] != roles: rc, cmd, out, err = exec_command( module, set_roles(module, container_image=container_image)) changed = True rc, cmd, out, err = exec_command( module, set_password(module, container_image=container_image), stdin=password) else: rc, cmd, out, err = exec_command( module, create_user(module, container_image=container_image), stdin=password) rc, cmd, out, err = exec_command( module, set_roles(module, container_image=container_image)) changed = True elif state == "absent": rc, cmd, out, err = exec_command( module, get_user(module, container_image=container_image)) if rc == 0: rc, cmd, out, err = exec_command( module, remove_user(module, container_image=container_image)) changed = True else: rc = 0 out = "Dashboard User {} doesn't exist".format(name) elif state == "info": rc, cmd, out, err = exec_command( module, get_user(module, container_image=container_image)) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed)
def run_module(): module_args = dict( cluster=dict(type="str", required=False, default="ceph"), name=dict(type="str", required=True), state=dict(type="str", required=False, choices=["present", "absent"], default="present"), caps=dict(type="list", required=True), ) module = AnsibleModule( argument_spec=module_args, supports_check_mode=True, ) # Gather module parameters in variables name = module.params.get("name") state = module.params.get("state") caps = module.params.get("caps") startd = datetime.datetime.now() changed = False # will return either the image name or None container_image = is_containerized() diff = dict(before="", after="") # get user infos for diff rc, cmd, out, err = exec_command( module, get_user(module, container_image=container_image)) if rc == 0: before_user = json.loads(out) before_caps = sorted(before_user["caps"], key=lambda d: d["type"]) diff["before"] = json.dumps(before_caps, indent=4) out = "" err = "" if state == "present": cmd = add_caps(module, container_image=container_image) elif state == "absent": cmd = remove_caps(module, container_image=container_image) if not module.check_mode: rc, cmd, out, err = exec_command(module, cmd) else: out_caps = params_to_caps_output(before_user["caps"], caps, deletion=(state == "absent")) out = json.dumps(dict(caps=out_caps)) if rc == 0: after_user = json.loads(out)["caps"] after_user = sorted(after_user, key=lambda d: d["type"]) diff["after"] = json.dumps(after_user, indent=4) changed = diff["before"] != diff["after"] else: out = "User {} doesn't exist".format(name) exit_module( module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed, diff=diff, )
def main(): module = AnsibleModule( argument_spec=yaml.safe_load(DOCUMENTATION)['options'], supports_check_mode=True, required_if=[('state', 'present', ['rule_type']), ('rule_type', 'replicated', ['bucket_root', 'bucket_type']), ('rule_type', 'erasure', ['profile'])]) # Gather module parameters in variables name = module.params.get('name') state = module.params.get('state') rule_type = module.params.get('rule_type') if module.check_mode: module.exit_json( changed=False, stdout='', stderr='', rc=0, start='', end='', delta='', ) startd = datetime.datetime.now() changed = False # will return either the image name or None container_image = is_containerized() if state == "present": rc, cmd, out, err = exec_command( module, get_rule(module, container_image=container_image)) if rc != 0: rc, cmd, out, err = exec_command( module, create_rule(module, container_image=container_image)) changed = True else: rule = json.loads(out) if (rule['type'] == 1 and rule_type == 'erasure') or ( rule['type'] == 3 and rule_type == 'replicated'): module.fail_json( msg="Can not convert crush rule {} to {}".format( name, rule_type), changed=False, rc=1) elif state == "absent": rc, cmd, out, err = exec_command( module, get_rule(module, container_image=container_image)) if rc == 0: rc, cmd, out, err = exec_command( module, remove_rule(module, container_image=container_image)) changed = True else: rc = 0 out = "Crush Rule {} doesn't exist".format(name) elif state == "info": rc, cmd, out, err = exec_command( module, get_rule(module, container_image=container_image)) exit_module(module=module, out=out, rc=rc, cmd=cmd, err=err, startd=startd, changed=changed)