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)
def get_control_instance(params):
module_hostvars = params['module_hostvars']
play_hosts = params['play_hosts']
console_sock = params['console_sock']
app_name = params['app_name']
control_console = helpers.get_control_console(console_sock)
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,
})
def check_members_alive(params):
console_sock = params['console_sock']
allowed_states = params['allowed_states']
control_console = helpers.get_control_console(console_sock)
bad_members, err = control_console.eval_res_err(
'''
local fun = require('fun')
local membership = require('membership')
local cartridge_topology = require('cartridge.topology')
local confapplier = require('cartridge.confapplier')
local topology_cfg = confapplier.get_readonly('topology')
if topology_cfg == nil then
return nil, "Instances aren't joined to cluster yet"
end
local allowed_states = ...
local bad_members = {}
for _it, instance_uuid, server in fun.filter(cartridge_topology.not_disabled, topology_cfg.servers) do
local member = membership.get_member(server.uri) or {}
if (member.payload.uuid ~= instance_uuid) then
table.insert(bad_members, string.format(
'%s uuid mismatch: expected %s, have %s',
server.uri, instance_uuid, member.payload.uuid
))
elseif (member.status ~= 'alive') then
table.insert(bad_members, string.format(
'%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)
def check_instance_state(control_console, expected_states,
check_buckets_are_discovered):
instance_state, err = control_console.eval_res_err('''
return require('cartridge.confapplier').get_state()
''')
if not instance_state:
return helpers.ModuleRes(failed=True,
msg="Impossible to get state: %s" % err)
if instance_state not in expected_states:
return helpers.ModuleRes(
failed=True,
msg="Instance is not in one of states: %s, it's in '%s' state" % (
expected_states,
instance_state,
),
)
if check_buckets_are_discovered:
buckets_ok, err = control_console.eval_res_err('''
local vshard_utils = require('cartridge.vshard-utils')
local vshard_router = require('cartridge.roles.vshard-router')
local function check_group_buckets(group_name, group_opts)
if not group_opts.bootstrapped then
return true
end
local router = vshard_router.get(group_name)
if router == nil then
return true
end
local unknown_buckets = router:info().bucket.unknown
if unknown_buckets == 0 then
return true
end
return nil, string.format(
"%s out of %s buckets are not discovered in group '%s'",
unknown_buckets,
group_opts.bucket_count,
group_name
)
end
local groups = vshard_utils.get_known_groups()
for group_name, group_opts in pairs(groups) do
local _, err = check_group_buckets(group_name, group_opts)
if err ~= nil then
return nil, err
end
end
return true
''')
if not buckets_ok:
return helpers.ModuleRes(failed=True, msg=err)
return helpers.ModuleRes(changed=False)
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)
def check_stateboard_state(control_console):
box_status, err = control_console.eval_res_err('''
if type(box.cfg) == 'function' or box.cfg.listen == nil then
return nil, "box hasn't been configured"
end
return true
''')
if not box_status:
return helpers.ModuleRes(failed=True,
msg="Stateboard is not running: %s" % err)
return helpers.ModuleRes(changed=False)
def get_alive_not_expelled_instance(params):
module_hostvars = params['module_hostvars']
play_hosts = params['play_hosts']
app_name = params['app_name']
canditates_by_uris = {}
for instance_name in play_hosts:
instance_vars = module_hostvars[instance_name]
if helpers.is_expelled(instance_vars) or helpers.is_stateboard(
instance_vars):
continue
instance_config = instance_vars.get('config')
if instance_config is None:
continue
advertise_uri = instance_config['advertise_uri']
canditates_by_uris[advertise_uri] = instance_name
alive_not_expelled_instance_name = None
for uri, instance_name in sorted(canditates_by_uris.items()):
host, port = uri.rsplit(':', 1)
try:
conn = socket.create_connection((host, port),
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,
})
def main():
module = AnsibleModule(argument_spec=argument_spec)
try:
res = get_systemd_units_info(module.params)
except Exception as e:
res = helpers.ModuleRes(exception=e)
res.exit(module)
def manage_failover_new(control_console, failover_params):
current_failover_params = get_failover_params(control_console)
func_body = '''
return require('cartridge').failover_set_params(...)
'''
res, err = control_console.eval_res_err(func_body, failover_params)
if err is not None:
errmsg = 'Failed to set failover params: {}'.format(err)
return helpers.ModuleRes(failed=True, msg=errmsg)
new_failover_params = get_failover_params(control_console)
changed = new_failover_params != current_failover_params
return helpers.ModuleRes(changed=changed)
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)
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)
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)
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)
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()
def check_cluster_issues(params):
allow_warnings = params['allow_warnings']
show_issues = params['show_issues']
console_sock = params['console_sock']
control_console = helpers.get_control_console(console_sock)
issues, err = control_console.eval_res_err('''
return require('cartridge.issues').list_on_cluster()
''')
if err is not None:
msg = "Received error on getting list of cluster issues: %s" % err
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)
def manage_failover_old(control_console, failover_params):
failover_enabled = failover_params['mode'] == 'eventual'
current_failover, _ = control_console.eval_res_err('''
return require('cartridge').admin_get_failover()
''')
if current_failover == failover_enabled:
return helpers.ModuleRes(changed=False)
function_name = 'admin_enable_failover' if failover_enabled else 'admin_disable_failover'
func_body = '''
local function_name = ...
return require('cartridge')[function_name]()
'''
_, err = control_console.eval_res_err(func_body, function_name)
if err is not None:
errmsg = 'Failed {}: {}'.format(function_name, err)
return helpers.ModuleRes(failed=True, msg=errmsg)
return helpers.ModuleRes()
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)
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)
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)
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)
def apply_app_config(params):
# We cannot use the fact 'dest' from the copy task,
# because in the case of transferring a folder with one file,
# 'dest' will contain the path to the file, not the path to the folder.
# Therefore, we consider the path ourselves.
remote_config_path = os.path.join(
params['remote_dir'], os.path.basename(params['local_config_path']))
upload_mode = prepare_upload_mode(
upload_mode=params['upload_mode'],
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,
})
def set_needs_restart(params):
instance_info = params['instance_info']
console_sock = instance_info['console_sock']
# check if instance was not started yet
if not os.path.exists(console_sock):
return helpers.ModuleRes(changed=True, fact=True)
try:
control_console = helpers.get_control_console(console_sock)
except helpers.CartridgeException as e:
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)
def failover_promote(params):
console_sock = params['console_sock']
control_console = helpers.get_control_console(console_sock)
err = check_leaders_promotion_is_possible(control_console)
if err is not None:
return helpers.ModuleRes(failed=True, msg=err)
failover_promote_params = params.get('failover_promote_params')
if failover_promote_params is None:
failover_promote_params = {}
critical_warnings = []
# get replicaset leaders
if params['promote_play_hosts']:
module_hostvars = params['module_hostvars']
play_hosts = params['play_hosts']
replicaset_leaders, dead_replicasets = get_replicaset_leaders_by_play_hosts(
play_hosts, module_hostvars, control_console)
if dead_replicasets:
critical_warnings.append(
'These replicasets have no alive instances across specified play hosts: %s'
% ', '.join(sorted(dead_replicasets)))
else:
specified_replicaset_leaders = failover_promote_params.get(
'replicaset_leaders')
replicaset_leaders, err = get_replicaset_leaders_by_aliases(
specified_replicaset_leaders, control_console)
if err is not None:
return helpers.ModuleRes(failed=True, msg=err)
if not replicaset_leaders:
if critical_warnings:
return helpers.ModuleRes(
failed=True,
msg="Failed to promote leaders: %s" % err,
warnings=critical_warnings,
)
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)
def validate_config(params):
found_replicasets = {}
found_common_params = {}
warnings = []
for host in params['play_hosts']:
instance_vars = params['module_hostvars'][host]
if instance_vars.get('edit_topology_timeout') is not None:
warnings.append(
"Variable 'edit_topology_timeout' is deprecated since 1.9.0 and will be removed in 2.0.0. "
"Use 'edit_topology_healthy_timeout' instead."
)
if instance_vars.get('instance_start_timeout') is not None:
warnings.append(
"Variable 'instance_start_timeout' is deprecated since 1.10.0 and will be removed in 2.0.0. "
"Use 'instance_start_retries' and 'instance_start_delay' instead."
)
if instance_vars.get('instance_discover_buckets_timeout') is not None:
warnings.append(
"Variable 'instance_discover_buckets_timeout' is deprecated since 1.10.0 and will be removed in 2.0.0. "
"Use 'instance_discover_buckets_retries' and 'instance_discover_buckets_delay' instead."
)
# Validate types
errmsg = validate_types(instance_vars)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
if instance_vars.get('stateboard') is True:
errmsg = check_stateboard(instance_vars)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
continue
# All required params should be specified
errmsg = check_required_params(instance_vars, host)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
errmsg = check_cluster_cookie_symbols(instance_vars.get('cartridge_cluster_cookie'))
if errmsg is not None:
return errmsg
# Instance config
errmsg = check_instance_config(instance_vars['config'], host)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
# Params common for all instances
errmsg = check_params_the_same_for_all_hosts(instance_vars, found_common_params)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
# Cartridge defaults
if 'cartridge_defaults' in instance_vars:
if 'cluster_cookie' in instance_vars['cartridge_defaults']:
errmsg = 'Cluster cookie must be specified in "cartridge_cluster_cookie", not in "cartridge_defaults"'
return helpers.ModuleRes(failed=True, msg=errmsg)
# Instance state
if instance_vars.get('expelled') is True and instance_vars.get('restarted') is True:
errmsg = 'Flags "expelled" and "restarted" cannot be set at the same time'
return helpers.ModuleRes(failed=True, msg=errmsg)
# Replicasets
errmsg = check_replicaset(instance_vars, found_replicasets)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
# Dist retention
if 'cartridge_keep_num_latest_dists' in instance_vars:
keep_num_latest_dists = instance_vars['cartridge_keep_num_latest_dists']
if keep_num_latest_dists <= 0:
errmsg = '"cartridge_keep_num_latest_dists" should be greater than 0'
return helpers.ModuleRes(failed=True, msg=errmsg)
if keep_num_latest_dists == 1:
warnings.append(
"Using 'cartridge_keep_num_latest_dists' equals to 1 can be dangerous. "
"Make sure that there are no instances that use old versions"
)
# Authorization params
errmsg = check_auth(found_common_params)
if errmsg is not None:
return helpers.ModuleRes(failed=True, msg=errmsg)
# Clusterwide config
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)
def edit_topology(params):
console_sock = params['console_sock']
module_hostvars = params['module_hostvars']
play_hosts = params['play_hosts']
healthy_timeout = params['healthy_timeout']
allow_missed_instances = params['allow_missed_instances']
replicasets = get_configured_replicasets(module_hostvars, play_hosts)
instances = get_instances_to_configure(module_hostvars, play_hosts)
if not replicasets and not instances:
return helpers.ModuleRes(changed=False)
control_console = helpers.get_control_console(console_sock)
helpers.set_twophase_options_from_params(control_console, params)
set_enabled_roles(replicasets, control_console)
cluster_instances = helpers.get_cluster_instances(control_console)
cluster_replicasets = helpers.get_cluster_replicasets(control_console)
# Configure replicasets and instances:
# * Create new replicasets.
# * Edit existent replicasets and join new instances to them.
# In this case failover_priority isn't changed since
# new instances hasn't UUIDs before join.
# * Expel instances.
# * Configure instances that are already joined.
# New instances aren't configured here since they don't have
# UUIDs before join.
topology_params, err = get_topology_params(replicasets,
cluster_replicasets, instances,
cluster_instances,
allow_missed_instances)
if err is not None:
return helpers.ModuleRes(
failed=True,
msg="Failed to collect edit topology params: %s" % err)
topology_changed = False
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 topology: %s" % err)
topology_changed = True
# Without this `Peer closed` error is returned on second `edit_topology`
# call in some cases (e.g. when new instance is joined at first call
# and then it's configured on second)
# See https://github.com/tarantool/cartridge/issues/1320
# The simplest w/a is to add a little delay between this calls,
# and we just perform `is_healthy` call here.
# If everything is Ok - this call doesn't take a long time, but
# guarantees that next `edit_topology` call wouldn't fail.
# If cluster isn't healthy then it's good to show error.
if not wait_for_cluster_is_healthy(control_console, healthy_timeout):
return helpers.ModuleRes(
failed=True,
msg="Cluster isn't healthy after editing topology")
# Now we need to get updated instances and replicasets
# configuration to check if we need one more call.
# `edit_topology` returns summary of updated instances
# so let's use it to update cluster_instances and cluster_replicasets.
update_cluster_instances_and_replicasets(res, instances,
cluster_instances,
cluster_replicasets)
# Configure failover_priority and instances that were joined on previous call:
# * Edit failover_priority of replicasets if it's needed.
# * Configure instances that weren't configured on first `edit_topology` call.
topology_params, err = get_replicasets_failover_priority_and_instances_params(
replicasets, cluster_replicasets, instances, cluster_instances,
allow_missed_instances)
if err is not None:
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)
def get_instance_info(params):
app_name = params['app_name']
instance_name = params['instance_name']
instance_vars = params['instance_vars']
instance_info = {'paths_to_remove_on_expel': []}
# app conf file
instance_info['app_conf_file'] = get_app_conf_file(
instance_vars['cartridge_conf_dir'], app_name)
# instance conf file
instance_info['conf_file'] = get_instance_conf_file(
instance_vars['cartridge_conf_dir'],
app_name,
instance_name,
instance_vars['stateboard'],
)
instance_info['paths_to_remove_on_expel'].append(
instance_info['conf_file'])
# instance id (e.g. used for conf section name)
instance_info['instance_id'] = get_instance_conf_section(
app_name, instance_name, instance_vars['stateboard'])
# console socket, PID file paths
instance_info['console_sock'] = helpers.get_instance_console_sock(
instance_vars['cartridge_run_dir'], app_name, instance_name,
instance_vars['stateboard'])
instance_info['paths_to_remove_on_expel'].append(
instance_info['console_sock'])
instance_info['pid_file'] = helpers.get_instance_pid_file(
instance_vars['cartridge_run_dir'], app_name, instance_name,
instance_vars['stateboard'])
# instance work dir
instance_info['work_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_data_dir'], app_name, instance_name,
instance_vars['stateboard'])
instance_info['paths_to_remove_on_expel'].append(instance_info['work_dir'])
# instance memtx dir
instance_info['memtx_dir'] = None
if instance_vars['cartridge_memtx_dir_parent']:
instance_info['memtx_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_memtx_dir_parent'], app_name,
instance_name, instance_vars['stateboard'])
instance_info['paths_to_remove_on_expel'].append(
instance_info['memtx_dir'])
# instance vinyl dir
instance_info['vinyl_dir'] = None
if instance_vars['cartridge_vinyl_dir_parent']:
instance_info['vinyl_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_vinyl_dir_parent'], app_name,
instance_name, instance_vars['stateboard'])
instance_info['paths_to_remove_on_expel'].append(
instance_info['vinyl_dir'])
# instance wal dir
instance_info['wal_dir'] = None
if instance_vars['cartridge_wal_dir_parent']:
instance_info['wal_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_wal_dir_parent'], app_name, instance_name,
instance_vars['stateboard'])
instance_info['paths_to_remove_on_expel'].append(
instance_info['wal_dir'])
# systemd service name
instance_info['systemd_service'] = get_instance_systemd_service(
app_name, instance_name, instance_vars['stateboard'])
# 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)
def get_systemd_units_info(params):
app_name = params['app_name']
instance_vars = params['instance_vars']
tnt_version = params['tnt_version']
systemd_units_info = {}
stateboard_name = helpers.get_instance_id(app_name, stateboard=True)
systemd_units_info['stateboard_name'] = stateboard_name
systemd_units_info['app_unit_file'] = '%[email protected]' % app_name
systemd_units_info['stateboard_unit_file'] = '%s.service' % stateboard_name
systemd_units_info['instance_work_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_data_dir'], app_name, instance_name="%i"
)
systemd_units_info['stateboard_work_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_data_dir'], app_name, stateboard=True
)
systemd_units_info['instance_memtx_dir'] = None
systemd_units_info['stateboard_memtx_dir'] = None
if instance_vars['cartridge_memtx_dir_parent']:
systemd_units_info['instance_memtx_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_memtx_dir_parent'], app_name, instance_name="%i"
)
systemd_units_info['stateboard_memtx_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_memtx_dir_parent'], app_name, stateboard=True
)
systemd_units_info['instance_vinyl_dir'] = None
systemd_units_info['stateboard_vinyl_dir'] = None
if instance_vars['cartridge_vinyl_dir_parent']:
systemd_units_info['instance_vinyl_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_vinyl_dir_parent'], app_name, instance_name="%i"
)
systemd_units_info['stateboard_vinyl_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_vinyl_dir_parent'], app_name, stateboard=True
)
systemd_units_info['instance_wal_dir'] = None
systemd_units_info['stateboard_wal_dir'] = None
if instance_vars['cartridge_wal_dir_parent']:
systemd_units_info['instance_wal_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_wal_dir_parent'], app_name, instance_name="%i"
)
systemd_units_info['stateboard_wal_dir'] = helpers.get_instance_dir(
instance_vars['cartridge_wal_dir_parent'], app_name, stateboard=True
)
systemd_units_info['instance_pid_file'] = helpers.get_instance_pid_file(
instance_vars['cartridge_run_dir'], app_name, instance_name="%i"
)
systemd_units_info['stateboard_pid_file'] = helpers.get_instance_pid_file(
instance_vars['cartridge_run_dir'], app_name, stateboard=True
)
systemd_units_info['instance_console_sock'] = helpers.get_instance_console_sock(
instance_vars['cartridge_run_dir'], app_name, instance_name="%i"
)
systemd_units_info['stateboard_console_sock'] = helpers.get_instance_console_sock(
instance_vars['cartridge_run_dir'], app_name, stateboard=True
)
if not instance_vars['cartridge_multiversion']:
instance_dist_dir = instance_vars['dist_dir']
stateboard_dir = instance_vars['dist_dir']
else:
instances_dir = instance_vars['cartridge_app_instances_dir']
instance_dist_dir = helpers.get_multiversion_instance_code_dir(
instances_dir, app_name, instance_name="%i",
)
stateboard_dir = helpers.get_multiversion_instance_code_dir(
instances_dir, app_name, stateboard=True,
)
systemd_units_info['instance_entrypoint'] = os.path.join(instance_dist_dir, 'init.lua')
systemd_units_info['stateboard_entrypoint'] = os.path.join(stateboard_dir, 'stateboard.init.lua')
if tnt_version:
opensource_tarantool_binary = '/usr/bin/tarantool'
systemd_units_info['instance_tarantool_binary'] = opensource_tarantool_binary
systemd_units_info['stateboard_tarantool_binary'] = opensource_tarantool_binary
else:
systemd_units_info['instance_tarantool_binary'] = os.path.join(instance_dist_dir, 'tarantool')
systemd_units_info['stateboard_tarantool_binary'] = os.path.join(stateboard_dir, 'tarantool')
return helpers.ModuleRes(changed=False, fact=systemd_units_info)