'%s status is %s',
server.uri, member.status
))
elseif allowed_states ~= nil and next(allowed_states) ~= nil then
local member_state = member.payload.state
if fun.index(member_state, allowed_states) == nil then
table.insert(bad_members, string.format(
'%s state is %s',
server.uri, member_state
))
end
end
end
return bad_members
''', allowed_states)
if err is not None:
return helpers.ModuleRes(failed=True, msg=err)
if bad_members:
return helpers.ModuleRes(failed=True,
msg="Some instances aren't alive: %s" %
', '.join(sorted(bad_members)))
return helpers.ModuleRes(changed=False)
if __name__ == '__main__':
helpers.execute_module(argument_spec, check_members_alive)
return instance_vars['ansible_host']
raise Exception('Instance %s has not "ansible_host" option!' %
instance_name)
def get_one_not_expelled_instance_for_machine(params):
module_hostvars = params['module_hostvars']
play_hosts = params['play_hosts']
machine_hostnames = set()
instance_names = []
for instance_name in play_hosts:
instance_vars = module_hostvars[instance_name]
if helpers.is_expelled(instance_vars):
continue
machine_hostname = get_machine_hostname(instance_vars, instance_name)
if machine_hostname not in machine_hostnames:
machine_hostnames.add(machine_hostname)
instance_names.append(instance_name)
return helpers.ModuleRes(changed=False, fact=instance_names)
if __name__ == '__main__':
helpers.execute_module(argument_spec,
get_one_not_expelled_instance_for_machine)
remote_config_path=remote_config_path,
)
output_format, apply_config_func = get_output_format_and_apply_config_func(
upload_mode,
console_sock=params['console_sock'],
upload_url=params['upload_url'],
cluster_cookie=params['cluster_cookie'],
tdg_token=params['tdg_token'],
)
temp_paths = [remote_config_path]
new_config_path = prepare_config(remote_config_path, output_format,
upload_mode)
if new_config_path != remote_config_path:
temp_paths.append(new_config_path)
changed = apply_config_func(new_config_path)
return helpers.ModuleRes(changed=changed,
fact={
'temp_paths': temp_paths,
'upload_url': params['upload_url'],
'upload_mode': params['upload_mode'],
'expected_format': output_format,
})
if __name__ == '__main__':
helpers.execute_module(argument_spec, apply_app_config)
end
end
return true
''')
if not buckets_ok:
return helpers.ModuleRes(failed=True, msg=err)
return helpers.ModuleRes(changed=False)
def check_state(params):
try:
control_console = helpers.get_control_console(params['console_sock'])
if params['stateboard']:
return check_stateboard_state(control_console)
else:
return check_instance_state(
control_console,
params['expected_states'],
params['check_buckets_are_discovered'],
)
except helpers.CartridgeException as e:
return helpers.ModuleRes(exception=e)
if __name__ == '__main__':
helpers.execute_module(argument_spec, check_state)
def get_package_info(params):
package_path = params['package_path']
app_name = params['app_name']
package_type = get_package_type(package_path)
if package_type == 'rpm':
package_info = get_rpm_info(package_path)
elif package_type == 'deb':
package_info = get_deb_info(package_path)
elif package_type == 'tgz':
package_info = get_tgz_info(package_path)
else:
return helpers.ModuleRes(failed=True,
msg='Unknown package type: %s' % package_type)
if package_type != 'tgz' and package_info['name'] != app_name:
msg = "Value 'cartridge_app_name' should be equal to package name. " + \
"Found 'cartridge_app_name': '%s', package name: '%s'" % (app_name, package_info['name'])
return helpers.ModuleRes(failed=True, msg=msg)
package_info['type'] = package_type
return helpers.ModuleRes(changed=False, fact=package_info)
if __name__ == '__main__':
helpers.execute_module(argument_spec, get_package_info)
allowed_errcodes = [
helpers.CartridgeErrorCodes.SOCKET_NOT_FOUND,
helpers.CartridgeErrorCodes.FAILED_TO_CONNECT_TO_SOCKET,
helpers.CartridgeErrorCodes.INSTANCE_IS_NOT_STARTED_YET
]
if e.code in allowed_errcodes:
return helpers.ModuleRes(changed=True, fact=True)
raise e
if params['check_package_updated']:
needs_restart, err = check_needs_restart_to_update_package(params)
if err is not None:
return helpers.ModuleRes(failed=True, msg=err)
if needs_restart:
return helpers.ModuleRes(changed=True, fact=True)
if params['check_config_updated']:
needs_restart, err = check_needs_restart_to_update_config(
params, control_console)
if err is not None:
return helpers.ModuleRes(failed=True, msg=err)
if needs_restart:
return helpers.ModuleRes(changed=True, fact=True)
return helpers.ModuleRes(changed=False, fact=False)
if __name__ == '__main__':
helpers.execute_module(argument_spec, set_needs_restart)
'upload_config_timeout': {'required': False, 'type': 'int'},
'apply_config_timeout': {'required': False, 'type': 'int'},
}
def bootstrap_vshard(params):
control_console = helpers.get_control_console(params['console_sock'])
helpers.set_twophase_options_from_params(control_console, params)
can_bootstrap, _ = control_console.eval_res_err('''
return require('cartridge.vshard-utils').can_bootstrap()
''')
if not can_bootstrap:
return helpers.ModuleRes(changed=False)
ok, err = control_console.eval_res_err('''
return require('cartridge.admin').bootstrap_vshard()
''')
if not ok:
errmsg = 'Vshard bootstrap failed: {}'.format(err)
return helpers.ModuleRes(failed=True, msg=errmsg)
return helpers.ModuleRes()
if __name__ == '__main__':
helpers.execute_module(argument_spec, bootstrap_vshard)
errmsg = check_app_config(found_common_params)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
# Failover
errmsg = check_failover(found_common_params)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
# Scenario
errmsg = check_scenario(found_common_params)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
# Failover promote params
errmsg = check_failover_promote_params(found_common_params)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
if found_common_params.get('cartridge_failover') is not None:
warnings.append(
"Variable 'cartridge_failover' is deprecated since 1.3.0 and will be removed in 2.0.0. "
"Use 'cartridge_failover_params' instead."
)
return helpers.ModuleRes(changed=False, warnings=warnings)
if __name__ == '__main__':
helpers.execute_module(argument_spec, validate_config)
timeout=CONNECTION_TIMEOUT)
conn.settimeout(CONNECTION_TIMEOUT)
conn.recv(1024)
except socket.error:
continue
alive_not_expelled_instance_name = instance_name
break
if alive_not_expelled_instance_name is None:
errmsg = "Not found any alive instance that is not expelled and is not a stateboard"
return helpers.ModuleRes(failed=True, msg=errmsg)
instance_vars = module_hostvars[alive_not_expelled_instance_name]
run_dir = instance_vars.get('cartridge_run_dir')
console_sock = helpers.get_instance_console_sock(
run_dir,
app_name,
alive_not_expelled_instance_name,
)
return helpers.ModuleRes(changed=False,
fact={
'name': alive_not_expelled_instance_name,
'console_sock': console_sock,
})
if __name__ == '__main__':
helpers.execute_module(argument_spec, get_alive_not_expelled_instance)
control_instance_name, err = get_control_instance_name(
module_hostvars, play_hosts, control_console)
if err is not None:
return helpers.ModuleRes(failed=True, msg=err)
# in the ideal imagined world we could just use
# instance_vars['instance_info'], but if control instance is not
# in play_hosts, instance_info isn't computed for it
instance_vars = module_hostvars[control_instance_name]
run_dir = instance_vars.get('cartridge_run_dir')
control_instance_console_sock = helpers.get_instance_console_sock(
run_dir,
app_name,
control_instance_name,
)
http_port = instance_vars.get('config', {}).get('http_port')
return helpers.ModuleRes(changed=False,
fact={
'name': control_instance_name,
'console_sock': control_instance_console_sock,
'http_port': http_port,
})
if __name__ == '__main__':
helpers.execute_module(argument_spec, get_control_instance)
def connect_to_membership(params):
control_console = helpers.get_control_console(params['console_sock'])
module_hostvars = params['module_hostvars']
play_hosts = params['play_hosts']
changed = False
for instance_name, instance_vars in module_hostvars.items():
if helpers.is_expelled(instance_vars) or helpers.is_stateboard(
instance_vars):
continue
if 'config' not in instance_vars or 'advertise_uri' not in instance_vars[
'config']:
continue
connected, err = probe_server(control_console,
instance_vars['config']['advertise_uri'])
if err is not None and instance_name in play_hosts:
return helpers.ModuleRes(failed=True, msg=err)
if connected:
changed = True
return helpers.ModuleRes(changed=changed)
if __name__ == '__main__':
helpers.execute_module(argument_spec, connect_to_membership)
return helpers.ModuleRes(changed=False)
force_inconsistency = failover_promote_params.get('force_inconsistency')
# set two-phase commit opts
helpers.set_twophase_options_from_params(control_console, params)
active_leaders = get_active_leaders(control_console)
_, err = call_failover_promote(control_console, replicaset_leaders,
force_inconsistency)
if err is not None:
return helpers.ModuleRes(
failed=True,
msg="Failed to promote leaders: %s" % err,
warnings=critical_warnings,
)
new_active_leaders = get_active_leaders(control_console)
if critical_warnings:
return helpers.ModuleRes(failed=True,
msg="Promoted with critical warnings",
warnings=critical_warnings)
return helpers.ModuleRes(changed=active_leaders != new_active_leaders)
if __name__ == '__main__':
helpers.execute_module(argument_spec, failover_promote)
return False, None
if not helpers.box_cfg_was_called(control_console):
if strict_mode:
return None, "Impossible to patch instance config: 'box.cfg' wasn't called"
return False, None
old_box_config = helpers.get_box_cfg(control_console)
new_config = deepcopy(defaults or {})
new_config.update(instance_config)
return change_dynamic_params(control_console, old_box_config, new_config,
strict_mode)
def patch_instance_in_runtime(params):
console_sock = params['console_sock']
instance_config = params['instance_config']
cartridge_defaults = params['cartridge_defaults']
strict_mode = params['strict_mode']
changed, error = configure_box_cfg_params(console_sock, instance_config,
cartridge_defaults, strict_mode)
if error is not None:
return helpers.ModuleRes(failed=True, msg=error)
return helpers.ModuleRes(changed=changed)
if __name__ == '__main__':
helpers.execute_module(argument_spec, patch_instance_in_runtime)
# tmpfiles conf
instance_info['tmpfiles_conf'] = os.path.join(
instance_vars['cartridge_tmpfiles_dir'], '%s.conf' % app_name)
# code dirs
if not instance_vars['cartridge_multiversion']:
dist_dir = os.path.join(instance_vars['cartridge_app_install_dir'],
app_name)
instance_info['dist_dir'] = dist_dir
instance_info['instance_dist_dir'] = dist_dir
else:
instance_info['dist_dir'] = get_multiversion_dist_dir(
instance_vars['cartridge_app_install_dir'],
instance_vars.get('cartridge_package_path'))
instance_info[
'instance_dist_dir'] = helpers.get_multiversion_instance_code_dir(
instance_vars['cartridge_app_instances_dir'],
app_name,
instance_name,
instance_vars['stateboard'],
)
return helpers.ModuleRes(changed=False, fact=instance_info)
if __name__ == '__main__':
helpers.execute_module(argument_spec, get_instance_info)
return None, "Unknown scenario '%s'" % scenario_name
scenario = scenarios[scenario_name]
return scenario, None
def get_scenario_steps(params):
steps_paths = get_steps_paths(params['role_path'], params['custom_steps_dir'], params['custom_steps'])
scenario, err = get_scenario(
params['scenario'],
params['role_scenarios'], params['custom_scenarios'], params['scenario_name'],
)
if err:
return helpers.ModuleRes(failed=True, msg=err)
scenario_steps = []
for step_name in scenario:
if step_name not in steps_paths:
return helpers.ModuleRes(failed=True, msg="Unknown step '%s'" % step_name)
scenario_steps.append({
'name': step_name,
'path': steps_paths[step_name],
})
return helpers.ModuleRes(changed=False, fact=scenario_steps)
if __name__ == '__main__':
helpers.execute_module(argument_spec, get_scenario_steps)
def manage_failover(params):
failover_params = params.get('failover_params')
if isinstance(failover_params, bool):
failover_params = {
'mode': 'eventual' if failover_params is True else 'disabled'
}
rename_dict_key_if_exists(failover_params, 'stateboard_params',
'tarantool_params')
if failover_params.get('state_provider') == 'stateboard':
failover_params['state_provider'] = 'tarantool'
control_console = helpers.get_control_console(params['console_sock'])
helpers.set_twophase_options_from_params(control_console, params)
version = get_tarantool_version(control_console)
if version is not None and version >= NEW_FAILOVER_API_CARTRIDGE_VERSION:
return manage_failover_new(control_console, failover_params)
else:
if failover_params['mode'] == 'stateful':
errmsg = 'Stateful failover is supported since cartridge {}'.format(
NEW_FAILOVER_API_CARTRIDGE_VERSION)
return helpers.ModuleRes(failed=True, msg=errmsg)
return manage_failover_old(control_console, failover_params)
if __name__ == '__main__':
helpers.execute_module(argument_spec, manage_failover)
}
def section_is_deleted(section):
return 'deleted' in section and section['deleted'] is True
def config_app(params):
control_console = helpers.get_control_console(params['console_sock'])
config = params['app_config']
new_sections = {}
for section_name, section in config.items():
if section_is_deleted(section):
new_sections[section_name] = None
else:
new_sections[section_name] = section.get('body')
helpers.set_twophase_options_from_params(control_console, params)
changed, err = helpers.patch_clusterwide_config(control_console,
new_sections)
if err is not None:
return helpers.ModuleRes(failed=True, msg=err)
return helpers.ModuleRes(changed=changed)
if __name__ == '__main__':
helpers.execute_module(argument_spec, config_app)
#!/usr/bin/env python
from ansible.module_utils.helpers import Helpers as helpers
argument_spec = {
'console_sock': {'required': True, 'type': 'str'},
'body': {'required': True, 'type': 'str'},
'args': {'required': False, 'default': [], 'type': 'list'},
}
def eval_code(params):
body = params['body']
args = params['args']
control_console = helpers.get_control_console(params['console_sock'])
eval_res = control_console.eval(body, *args)
return helpers.ModuleRes(changed=False, fact=eval_res)
if __name__ == '__main__':
helpers.execute_module(argument_spec, eval_code)
return helpers.ModuleRes(
failed=True,
msg=
"Failed to collect edit topology params for changing failover_priority "
"and configuring new instances: %s" % err)
if topology_params:
res, err = control_console.eval_res_err(edit_topology_func_body,
topology_params)
if err is not None:
return helpers.ModuleRes(
failed=True,
msg=
"Failed to edit failover priority and configure instances: %s"
% err)
topology_changed = True
if not wait_for_cluster_is_healthy(control_console, healthy_timeout):
return helpers.ModuleRes(
failed=True,
msg=
"Cluster isn't healthy after editing failover priority and configuring instances"
)
return helpers.ModuleRes(changed=topology_changed)
if __name__ == '__main__':
helpers.execute_module(argument_spec, edit_topology)
'expelled',
'stateboard',
],
}
def get_cached_facts(params):
hostvars = params['hostvars']
facts = {}
for instance_name, instance_vars in hostvars.items():
role_vars = hostvars[instance_name].get('role_facts', {})
for target, fact_names in FACTS_BY_TARGETS.items():
facts[target] = facts.get(target, {})
facts[target][instance_name] = facts[target].get(instance_name, {})
for fact_name in fact_names:
if fact_name in role_vars:
facts[target][instance_name][fact_name] = role_vars[
fact_name]
elif fact_name in instance_vars:
facts[target][instance_name][fact_name] = instance_vars[
fact_name]
return helpers.ModuleRes(changed=False, facts=facts)
if __name__ == '__main__':
helpers.execute_module(argument_spec, get_cached_facts)
if issues is None:
return helpers.ModuleRes(failed=True, msg=msg)
helpers.warn(msg)
issues_by_level = {}
for issue in issues:
level = issue['level']
if level not in issues_by_level:
issues_by_level[level] = []
issues_by_level[level].append(issue)
if show_issues:
messages = get_messages(issues_by_level)
helpers.warn(*messages)
if issues:
if allow_warnings:
critical_issues_num = len(issues) - len(issues_by_level.get('warning', []))
if critical_issues_num > 0:
return helpers.ModuleRes(failed=True, msg="Cluster has %s critical issues" % critical_issues_num)
else:
return helpers.ModuleRes(failed=True, msg="Cluster has %s issues" % len(issues))
return helpers.ModuleRes(changed=False)
if __name__ == '__main__':
helpers.execute_module(argument_spec, check_cluster_issues)
