12262982371

Committed 10 Dec 2024 07:07PM UTC coverage: 87.276% (+0.003%) from 87.273%

Build # 12262982371

Build Type

push

github

Committed by

Totktonada

Commit Message

config: add error on the same instance names

Tarantool couldn't start with more than one group/replicaset/instance
with the same name. Applying cluster configuration with name duplicates
results with failed checks during the config application and violated
constraints w/o proper error message.

This patch makes Tarantool throw a proper error when it has instances
with the same name in different replicasets in the cluster
configuration.
Here is an example of such configuration:
```yaml
groups:
  g-001:
    replicasets:
      r-001:
        instances:
          i-001: {}
      r-002:
        instances:
          i-001: {}
```

Closes #10347

NO_DOC=bugfix

(cherry picked from commit 5d57e6508)

Run Details

68591 of 121826 branches covered (56.3%)

101204 of 115959 relevant lines covered (87.28%)

2652155.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.48

/src/box/lua/ctl.c

/*
 * Copyright 2010-2018, Tarantool AUTHORS, please see AUTHORS file.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the
 *    following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "box/lua/ctl.h"

#include <tarantool_ev.h>

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

#include "lua/utils.h"
#include "lua/trigger.h"
#include "box/lua/trigger.h"

#include "box/box.h"
#include "box/schema.h"
#include "box/engine.h"
#include "box/memtx_engine.h"
#include "box/raft.h"
#include "box/security.h"

#include "core/event.h"

static int
lbox_ctl_wait_ro(struct lua_State *L)
{
        int index = lua_gettop(L);
        double timeout = TIMEOUT_INFINITY;
        if (index > 0)
                timeout = luaT_checknumber(L, 1);
        if (box_wait_ro(true, timeout) != 0)
                return luaT_error(L);
        return 0;
}

static int
lbox_ctl_wait_rw(struct lua_State *L)
{
        int index = lua_gettop(L);
        double timeout = TIMEOUT_INFINITY;
        if (index > 0)
                timeout = luaT_checknumber(L, 1);
        if (box_wait_ro(false, timeout) != 0)
                return luaT_error(L);
        return 0;
}

static int
lbox_ctl_on_shutdown(struct lua_State *L)
{
        return luaT_event_reset_trigger(L, 1, box_on_shutdown_event);
}

static int
lbox_ctl_on_schema_init(struct lua_State *L)
{
        struct event *event = event_get("box.ctl.on_schema_init", true);
        return luaT_event_reset_trigger(L, 1, event);
}

static int
lbox_ctl_on_recovery_state(struct lua_State *L)
{
        return luaT_event_reset_trigger(L, 1, box_on_recovery_state_event);
}
static int
lbox_ctl_on_election(struct lua_State *L)
{
        return luaT_event_reset_trigger(L, 1, box_raft_on_election_event);
}

static int
lbox_ctl_promote(struct lua_State *L)
{
        if (box_promote() != 0)
                return luaT_error(L);
        return 0;
}

static int
lbox_ctl_demote(struct lua_State *L)
{
        if (box_demote() != 0)
                return luaT_error(L);
        return 0;
}

static int
lbox_ctl_make_bootstrap_leader(struct lua_State *L)
{
        if (box_make_bootstrap_leader() != 0)
                return luaT_error(L);
        return 0;
}

static int
lbox_ctl_is_recovery_finished(struct lua_State *L)
{
        struct memtx_engine *memtx;
        memtx = (struct memtx_engine *)engine_by_name("memtx");
        lua_pushboolean(L, (memtx ?
                (memtx->state < MEMTX_OK ? 0 : 1) : 0));
        return 1;
}

static int
lbox_ctl_set_on_shutdown_timeout(struct lua_State *L)
{
        int index = lua_gettop(L);
        if (index != 1) {
                diag_set(IllegalParams, "function expected one argument");
                luaT_error(L);
        }

        double wait_time = luaT_checknumber(L, 1);
        if (wait_time <= 0) {
                diag_set(IllegalParams,
                         "on_shutdown timeout must be greater then zero");
                luaT_error(L);
        }

        on_shutdown_trigger_timeout = wait_time;
        return 0;
}

/**
 * Enable or disable security.iproto_lockdown option.
 */
static int
lbox_ctl_set_iproto_lockdown(struct lua_State *L)
{
#if defined(ENABLE_SECURITY)
        int index = lua_gettop(L);
        if (index != 1 || !lua_isboolean(L, 1)) {
                diag_set(IllegalParams,
                         "function expected one boolean argument");
                luaT_error(L);
        }
        bool new_val = lua_toboolean(L, 1);
        if (security_set_iproto_lockdown(new_val) != 0)
                return luaT_error(L);
#else
        diag_set(IllegalParams,
                 "box.ctl.iproto_lockdown() is available only in "
                 "Enterprise Edition builds.");
        luaT_error(L);
#endif
        return 0;
}

static const struct luaL_Reg lbox_ctl_lib[] = {
        {"wait_ro", lbox_ctl_wait_ro},
        {"wait_rw", lbox_ctl_wait_rw},
        {"on_shutdown", lbox_ctl_on_shutdown},
        {"on_schema_init", lbox_ctl_on_schema_init},
        {"on_recovery_state", lbox_ctl_on_recovery_state},
        {"on_election", lbox_ctl_on_election},
        {"promote", lbox_ctl_promote},
        /* An old alias. */
        {"clear_synchro_queue", lbox_ctl_promote},
        {"demote", lbox_ctl_demote},
        {"make_bootstrap_leader", lbox_ctl_make_bootstrap_leader},
        {"is_recovery_finished", lbox_ctl_is_recovery_finished},
        {"set_on_shutdown_timeout", lbox_ctl_set_on_shutdown_timeout},
        {"iproto_lockdown", lbox_ctl_set_iproto_lockdown},
        {NULL, NULL}
};

void
box_lua_ctl_init(struct lua_State *L)
{
        luaL_findtable(L, LUA_GLOBALSINDEX, "box.ctl", 0);
        luaL_setfuncs(L, lbox_ctl_lib, 0);
        lua_pop(L, 1);
}

1	/*
2	* Copyright 2010-2018, Tarantool AUTHORS, please see AUTHORS file.
3	*
4	* Redistribution and use in source and binary forms, with or
5	* without modification, are permitted provided that the following
6	* conditions are met:
7	*
8	* 1. Redistributions of source code must retain the above
9	* copyright notice, this list of conditions and the
10	* following disclaimer.
11	*
12	* 2. Redistributions in binary form must reproduce the above
13	* copyright notice, this list of conditions and the following
14	* disclaimer in the documentation and/or other materials
15	* provided with the distribution.
16	*
17	* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21	* <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
22	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28	* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29	* SUCH DAMAGE.
30	*/
31	#include "box/lua/ctl.h"
32
33	#include <tarantool_ev.h>
34
35	#include <lua.h>
36	#include <lauxlib.h>
37	#include <lualib.h>
38
39	#include "lua/utils.h"
40	#include "lua/trigger.h"
41	#include "box/lua/trigger.h"
42
43	#include "box/box.h"
44	#include "box/schema.h"
45	#include "box/engine.h"
46	#include "box/memtx_engine.h"
47	#include "box/raft.h"
48	#include "box/security.h"
49
50	#include "core/event.h"
51
52	static int
53	lbox_ctl_wait_ro(struct lua_State *L)	7✔
54	{
55	int index = lua_gettop(L);	7✔
56	double timeout = TIMEOUT_INFINITY;	7✔
57	if (index > 0)	7✔
58	timeout = luaT_checknumber(L, 1);	2✔
59	if (box_wait_ro(true, timeout) != 0)	6✔
60	return luaT_error(L);	2✔
61	return 0;	4✔
62	}
63
64	static int
65	lbox_ctl_wait_rw(struct lua_State *L)	322✔
66	{
67	int index = lua_gettop(L);	322✔
68	double timeout = TIMEOUT_INFINITY;	322✔
69	if (index > 0)	322✔
70	timeout = luaT_checknumber(L, 1);	10✔
71	if (box_wait_ro(false, timeout) != 0)	321✔
72	return luaT_error(L);	156✔
73	return 0;	165✔
74	}
75
76	static int
77	lbox_ctl_on_shutdown(struct lua_State *L)	51,960✔
78	{
79	return luaT_event_reset_trigger(L, 1, box_on_shutdown_event);	51,960✔
80	}
81
82	static int
83	lbox_ctl_on_schema_init(struct lua_State *L)	881✔
84	{
85	struct event *event = event_get("box.ctl.on_schema_init", true);	881✔
86	return luaT_event_reset_trigger(L, 1, event);	881✔
87	}
88
89	static int
90	lbox_ctl_on_recovery_state(struct lua_State *L)	80✔
91	{
92	return luaT_event_reset_trigger(L, 1, box_on_recovery_state_event);	80✔
93	}
94	static int
95	lbox_ctl_on_election(struct lua_State *L)	78✔
96	{
97	return luaT_event_reset_trigger(L, 1, box_raft_on_election_event);	78✔
98	}
99
100	static int
101	lbox_ctl_promote(struct lua_State *L)	235✔
102	{
103	if (box_promote() != 0)	235✔
104	return luaT_error(L);	22✔
105	return 0;	213✔
106	}
107
108	static int
109	lbox_ctl_demote(struct lua_State *L)	123✔
110	{
111	if (box_demote() != 0)	123✔
112	return luaT_error(L);	5✔
113	return 0;	118✔
114	}
115
116	static int
117	lbox_ctl_make_bootstrap_leader(struct lua_State *L)	4✔
118	{
119	if (box_make_bootstrap_leader() != 0)	4!
120	return luaT_error(L);	×
121	return 0;	4✔
122	}
123
124	static int
125	lbox_ctl_is_recovery_finished(struct lua_State *L)	289✔
126	{
127	struct memtx_engine *memtx;
128	memtx = (struct memtx_engine *)engine_by_name("memtx");	289✔
129	lua_pushboolean(L, (memtx ?	500✔
130	(memtx->state < MEMTX_OK ? 0 : 1) : 0));	211✔
131	return 1;	289✔
132	}
133
134	static int
135	lbox_ctl_set_on_shutdown_timeout(struct lua_State *L)	1,296✔
136	{
137	int index = lua_gettop(L);	1,296✔
138	if (index != 1) {	1,296!
139	diag_set(IllegalParams, "function expected one argument");	×
140	luaT_error(L);	×
141	}
142
143	double wait_time = luaT_checknumber(L, 1);	1,296✔
144	if (wait_time <= 0) {	1,296!
145	diag_set(IllegalParams,	×
146	"on_shutdown timeout must be greater then zero");
147	luaT_error(L);	×
148	}
149
150	on_shutdown_trigger_timeout = wait_time;	1,296✔
151	return 0;	1,296✔
152	}
153
154	/**
155	* Enable or disable security.iproto_lockdown option.
156	*/
157	static int
158	lbox_ctl_set_iproto_lockdown(struct lua_State *L)	×
159	{
160	#if defined(ENABLE_SECURITY)
161	int index = lua_gettop(L);
162	if (index != 1 \|\| !lua_isboolean(L, 1)) {
163	diag_set(IllegalParams,
164	"function expected one boolean argument");
165	luaT_error(L);
166	}
167	bool new_val = lua_toboolean(L, 1);
168	if (security_set_iproto_lockdown(new_val) != 0)
169	return luaT_error(L);
170	#else
171	diag_set(IllegalParams,	×
172	"box.ctl.iproto_lockdown() is available only in "
173	"Enterprise Edition builds.");
174	luaT_error(L);	×
175	#endif
176	return 0;	×
177	}
178
179	static const struct luaL_Reg lbox_ctl_lib[] = {
180	{"wait_ro", lbox_ctl_wait_ro},
181	{"wait_rw", lbox_ctl_wait_rw},
182	{"on_shutdown", lbox_ctl_on_shutdown},
183	{"on_schema_init", lbox_ctl_on_schema_init},
184	{"on_recovery_state", lbox_ctl_on_recovery_state},
185	{"on_election", lbox_ctl_on_election},
186	{"promote", lbox_ctl_promote},
187	/* An old alias. */
188	{"clear_synchro_queue", lbox_ctl_promote},
189	{"demote", lbox_ctl_demote},
190	{"make_bootstrap_leader", lbox_ctl_make_bootstrap_leader},
191	{"is_recovery_finished", lbox_ctl_is_recovery_finished},
192	{"set_on_shutdown_timeout", lbox_ctl_set_on_shutdown_timeout},
193	{"iproto_lockdown", lbox_ctl_set_iproto_lockdown},
194	{NULL, NULL}
195	};
196
197	void
198	box_lua_ctl_init(struct lua_State *L)	5,474✔
199	{
200	luaL_findtable(L, LUA_GLOBALSINDEX, "box.ctl", 0);	5,474✔
201	luaL_setfuncs(L, lbox_ctl_lib, 0);	5,474✔
202	lua_pop(L, 1);	5,474✔
203	}	5,474✔

tarantool / tarantool / 12262982371

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous