10596897991

Committed 28 Aug 2024 12:37PM UTC coverage: 87.232% (+0.01%) from 87.222%

Build # 10596897991

Build Type

push

github

Committed by

locker

Commit Message

box: fix memory leak on foreign key constraint failure

Closes #10476
Part-of #10211

NO_TEST=covered by existing tests
NO_DOC=bugfix

(cherry picked from commit a4f456928)

Run Details

68372 of 121601 branches covered (56.23%)

3 of 3 new or added lines in 1 file covered. (100.0%)

81 existing lines in 11 files now uncovered.

101037 of 115825 relevant lines covered (87.23%)

2481617.58 hits per line

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

95.13

/src/box/lua/xlog.c

/*
 * Copyright 2010-2016, 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 "xlog.h"

#include <ctype.h>

#include <say.h>
#include <diag.h>
#include <msgpuck/msgpuck.h>

#include <box/error.h>
#include <box/xlog.h>
#include <box/iproto_constants.h>
#include <box/tuple.h>
#include <box/lua/tuple.h>
#include <lua/msgpack.h>
#include <lua/utils.h>

/* {{{ Helpers */

static uint32_t CTID_STRUCT_XLOG_CURSOR_REF = 0;

static int
lbox_pushcursor(struct lua_State *L, struct xlog_cursor *cur)
{
        struct xlog_cursor **pcur = NULL;
        pcur = (struct xlog_cursor **)luaL_pushcdata(L,
                        CTID_STRUCT_XLOG_CURSOR_REF);
        *pcur = cur;
        return 1;
}

static struct xlog_cursor *
lbox_checkcursor(struct lua_State *L, int narg, const char *src)
{
        uint32_t ctypeid;
        void *data = NULL;
        data = (struct xlog_cursor *)luaL_checkcdata(L, narg, &ctypeid);
        assert(ctypeid == CTID_STRUCT_XLOG_CURSOR_REF);
        if (ctypeid != (uint32_t )CTID_STRUCT_XLOG_CURSOR_REF)
                luaL_error(L, "%s: expecting xlog_cursor object", src);
        return *(struct xlog_cursor **)data;
}

/* }}} */

/* {{{ Xlog Parser */

/**
 * Converts xlog key names to lower case, for example:
 * "SPACE_ID" => "space_id"
 */
static void
lbox_xlog_pushkey(lua_State *L, const char *key)
{
        luaL_Buffer b;
        luaL_buffinit(L, &b);
        for (const char *pos = key; *pos; pos++)
                luaL_addchar(&b, tolower(*pos));
        luaL_pushresult(&b);
}

/**
 * Helper function for lbox_xlog_parse_body that parses one key value pair
 * and adds it to the result table. The MsgPack data must be checked.
 */
static void
lbox_xlog_parse_body_kv(struct lua_State *L, int type, const char **beg)
{
        if (mp_typeof(**beg) != MP_UINT) {
                /* Invalid key type - ignore. */
                mp_next(beg);
                mp_next(beg);
                return;
        }
        uint32_t v = mp_decode_uint(beg);
        if (iproto_type_is_dml(type) && iproto_key_name(v)) {
                /*
                 * Historically, the xlog reader outputs IPROTO_OPS as
                 * "operations", not "ops".
                 */
                lbox_xlog_pushkey(L, (v == IPROTO_OPS ? "operations" :
                                      iproto_key_name(v)));
        } else if (type == VY_INDEX_RUN_INFO && vy_run_info_key_name(v)) {
                lbox_xlog_pushkey(L, vy_run_info_key_name(v));
        } else if (type == VY_INDEX_PAGE_INFO && vy_page_info_key_name(v)) {
                lbox_xlog_pushkey(L, vy_page_info_key_name(v));
        } else if (type == VY_RUN_ROW_INDEX && vy_row_index_key_name(v)) {
                lbox_xlog_pushkey(L, vy_row_index_key_name(v));
        } else {
                lua_pushinteger(L, v); /* unknown key */
        }

        if ((v == IPROTO_KEY || v == IPROTO_TUPLE || v == IPROTO_OLD_TUPLE ||
             v == IPROTO_NEW_TUPLE) && (mp_typeof(**beg) == MP_ARRAY)) {
                /*
                 * Push tuple if possible.
                 */
                const char *tuple_beg = *beg;
                mp_next(beg);
                struct tuple_format *format = box_tuple_format_default();
                struct tuple *tuple = box_tuple_new(format, tuple_beg, *beg);
                if (tuple == NULL)
                        luaT_error(L);
                luaT_pushtuple(L, tuple);
        } else {
                /*
                 * Push Lua objects
                 */
                luamp_decode(L, luaL_msgpack_default, beg);
        }
        lua_settable(L, -3);
}

/**
 * Parses a request body and pushes it to the Lua stack.
 * The MsgPack data must be checked and represent a map.
 */
static void
lbox_xlog_parse_body(struct lua_State *L, int type, const char **beg)
{
        lua_newtable(L);
        uint32_t size = mp_decode_map(beg);
        for (uint32_t i = 0; i < size; i++)
                lbox_xlog_parse_body_kv(L, type, beg);
}

/**
 * Parses a row and pushes it along with its LSN to the Lua stack.
 * On success returns the number of values pushed (> 0). On EOF returns 0.
 */
static int
lbox_xlog_parse_row(struct lua_State *L, const char **pos, const char *end)
{
        int top = lua_gettop(L);
        const char *tmp = *pos;
        if (mp_check(&tmp, end) != 0 || mp_typeof(**pos) != MP_MAP)
                goto bad_row;
        /*
         * Sic: The nrec argument of lua_createtable is chosen so that the
         * output looks pretty when encoded in YAML.
         */
        lua_createtable(L, 0, 8);
        lua_pushliteral(L, "HEADER");
        lua_createtable(L, 0, 8);
        uint64_t type = 0;
        uint64_t tsn = 0;
        uint64_t lsn = 0;
        bool has_tsn = false;
        bool is_commit = false;
        uint32_t size = mp_decode_map(pos);
        for (uint32_t i = 0; i < size; i++) {
                if (mp_typeof(**pos) != MP_UINT) {
                        /* Invalid key type - ignore. */
                        mp_next(pos);
                        mp_next(pos);
                        continue;
                }
                uint64_t key = mp_decode_uint(pos);
                const char *key_name = iproto_key_name(key);
                if (key < iproto_key_MAX &&
                    mp_typeof(**pos) != iproto_key_type[key]) {
                        /* Bad value type - dump as is. */
                        goto dump;
                }
                switch (key) {
                case IPROTO_REQUEST_TYPE: {
                        type = mp_decode_uint(pos);
                        lua_pushliteral(L, "type");
                        const char *type_name = iproto_type_name(type);
                        if (type_name != NULL)
                                lua_pushstring(L, type_name);
                        else
                                luaL_pushuint64(L, type);
                        lua_settable(L, -3);
                        continue;
                }
                case IPROTO_FLAGS: {
                        /* We're only interested in the commit flag. */
                        uint64_t flags = mp_decode_uint(pos);
                        if ((flags & IPROTO_FLAG_COMMIT) != 0)
                                is_commit = true;
                        continue;
                }
                case IPROTO_TSN:
                        /*
                         * TSN is encoded as diff so we dump it after we finish
                         * parsing the header.
                         */
                        tsn = mp_decode_uint(pos);
                        has_tsn = true;
                        continue;
                case IPROTO_LSN:
                        /* Remember LSN to calculate TSN later. */
                        tmp = *pos;
                        lsn = mp_decode_uint(&tmp);
                        break;
                default:
                        break;
                }
dump:
                if (key_name != NULL)
                        lbox_xlog_pushkey(L, key_name);
                else
                        luaL_pushuint64(L, key);
                luamp_decode(L, luaL_msgpack_default, pos);
                lua_settable(L, -3);
        }
        /* The commit flag isn't set for single-statement transactions. */
        if (!has_tsn)
                is_commit = true;
        tsn = lsn - tsn;
        /* Show TSN and commit flag only for multi-statement transactions. */
        if (tsn != lsn || !is_commit) {
                lua_pushliteral(L, "tsn");
                luaL_pushuint64(L, tsn);
                lua_settable(L, -3);
        }
        if (is_commit && tsn != lsn) {
                lua_pushliteral(L, "commit");
                lua_pushboolean(L, true);
                lua_settable(L, -3);
        }
        lua_settable(L, -3); /* HEADER */
        if (*pos < end && type != IPROTO_NOP) {
                tmp = *pos;
                if (mp_check(&tmp, end) != 0 || mp_typeof(**pos) != MP_MAP)
                        goto bad_row;
                lua_pushliteral(L, "BODY");
                lbox_xlog_parse_body(L, type, pos);
                lua_settable(L, -3); /* BODY */
        }
        luaL_pushuint64(L, lsn);
        lua_insert(L, -2);
        return 2;
bad_row:
        /* Silently assume EOF on bad row. */
        lua_settop(L, top);
        return 0;
}

static int
lbox_xlog_parser_iterate(struct lua_State *L)
{
        struct xlog_cursor *cur = lbox_checkcursor(L, 1, "xlog:pairs()");

        int rc = 0;
        /* skip all bad read requests */
        while (true) {
                const char **data;
                const char *end;
                rc = xlog_cursor_next_row_raw(cur, &data, &end);
                assert(rc >= 0);
                if (rc == 0) {
                        rc = lbox_xlog_parse_row(L, data, end);
                        if (rc > 0)
                                return rc;
                }
                while ((rc = xlog_cursor_next_tx(cur)) < 0) {
                        struct error *e = diag_last_error(diag_get());
                        if (e->type != &type_XlogError)
                                luaT_error(L);
                        if ((rc = xlog_cursor_find_tx_magic(cur)) < 0)
                                luaT_error(L);
                        if (rc == 1)
                                break;
                }
                if (rc == 1)
                        break;
        }
        return 0;
}

/* }}} */

static void
lbox_xlog_parser_close(struct xlog_cursor *cur) {
        if (cur == NULL)
                return;
        xlog_cursor_close(cur, false);
        free(cur);
}

static int
lbox_xlog_parser_gc(struct lua_State *L)
{
        struct xlog_cursor *cur = lbox_checkcursor(L, 1, "xlog:gc()");
        lbox_xlog_parser_close(cur);
        return 0;
}

static int
lbox_xlog_parser_open_pairs(struct lua_State *L)
{
        int args_n = lua_gettop(L);
        if (args_n != 1 || !lua_isstring(L, 1))
                luaL_error(L, "Usage: parser.open(log_filename)");

        const char *filename = luaL_checkstring(L, 1);

        /* Construct xlog cursor */
        struct xlog_cursor *cur = (struct xlog_cursor *)calloc(1,
                        sizeof(struct xlog_cursor));
        if (cur == NULL) {
                diag_set(OutOfMemory, sizeof(struct xlog_cursor),
                         "malloc", "struct xlog_cursor");
                return luaT_error(L);
        }
        /* Construct xlog object */
        if (xlog_cursor_open(cur, filename) < 0) {
                free(cur);
                return luaT_error(L);
        }
        if (strncmp(cur->meta.filetype, "SNAP", 4) != 0 &&
            strncmp(cur->meta.filetype, "XLOG", 4) != 0 &&
            strncmp(cur->meta.filetype, "RUN", 3) != 0 &&
            strncmp(cur->meta.filetype, "INDEX", 5) != 0 &&
            strncmp(cur->meta.filetype, "DATA", 4) != 0 &&
            strncmp(cur->meta.filetype, "VYLOG", 4) != 0) {
                char buf[1024];
                snprintf(buf, sizeof(buf), "'%.*s' file type",
                         (int) strlen(cur->meta.filetype),
                         cur->meta.filetype);
                diag_set(ClientError, ER_UNSUPPORTED, "xlog reader", buf);
                xlog_cursor_close(cur, false);
                free(cur);
                return luaT_error(L);
        }
        /* push iteration function */
        lua_pushcclosure(L, &lbox_xlog_parser_iterate, 1);
        /* push log and set GC */
        lbox_pushcursor(L, cur);
        lua_pushcfunction(L, lbox_xlog_parser_gc);
        luaL_setcdatagc(L, -2);
        /* push iterator position */
        lua_pushinteger(L, 0);
        return 3;
}

/** Opens an xlog file and returns its meta block. */
static int
lbox_xlog_parser_open_meta(struct lua_State *L)
{
        int args_n = lua_gettop(L);
        if (args_n != 1 || !lua_isstring(L, 1))
                luaL_error(L, "Usage: parser.open(log_filename)");

        const char *filename = luaL_checkstring(L, 1);

        /* Construct xlog cursor and object */
        struct xlog_cursor *cur = xcalloc(1, sizeof(struct xlog_cursor));
        if (xlog_cursor_open(cur, filename) < 0) {
                return luaT_error(L);
        }

        lua_newtable(L);

        lua_pushstring(L, "filetype");
        lua_pushstring(L, cur->meta.filetype);
        lua_settable(L, -3);

        lua_pushstring(L, "instance_uuid");
        luaT_pushuuidstr(L, &cur->meta.instance_uuid);
        lua_settable(L, -3);

        lua_pushstring(L, "vclock");
        luaT_pushvclock(L, &cur->meta.vclock);
        lua_settable(L, -3);

        lua_pushstring(L, "prev_vclock");
        luaT_pushvclock(L, &cur->meta.prev_vclock);
        lua_settable(L, -3);

        xlog_cursor_close(cur, false);
        free(cur);
        return 1;
}

static const struct luaL_Reg lbox_xlog_parser_lib [] = {
        { "pairs",        lbox_xlog_parser_open_pairs },
        { "meta",        lbox_xlog_parser_open_meta  },
        { NULL,                NULL                        }
};

void
box_lua_xlog_init(struct lua_State *L)
{
        int rc = 0;
        /* Get CTypeIDs */
        rc = luaL_cdef(L, "struct xlog_cursor;"); assert(rc == 0); (void) rc;
        CTID_STRUCT_XLOG_CURSOR_REF = luaL_ctypeid(L, "struct xlog_cursor&");
        assert(CTID_STRUCT_XLOG_CURSOR_REF != 0);

        luaT_newmodule(L, "xlog.lib", lbox_xlog_parser_lib);

        lua_newtable(L);
        lua_setmetatable(L, -2);
        lua_pop(L, 1);
}

/* }}} */

1	/*
2	* Copyright 2010-2016, 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
32	#include "xlog.h"
33
34	#include <ctype.h>
35
36	#include <say.h>
37	#include <diag.h>
38	#include <msgpuck/msgpuck.h>
39
40	#include <box/error.h>
41	#include <box/xlog.h>
42	#include <box/iproto_constants.h>
43	#include <box/tuple.h>
44	#include <box/lua/tuple.h>
45	#include <lua/msgpack.h>
46	#include <lua/utils.h>
47
48	/* {{{ Helpers */
49
50	static uint32_t CTID_STRUCT_XLOG_CURSOR_REF = 0;
51
52	static int
53	lbox_pushcursor(struct lua_State L, struct xlog_cursor cur)	846✔
54	{
55	struct xlog_cursor **pcur = NULL;	846✔
56	pcur = (struct xlog_cursor **)luaL_pushcdata(L,	846✔
57	CTID_STRUCT_XLOG_CURSOR_REF);
58	*pcur = cur;	846✔
59	return 1;	846✔
60	}
61
62	static struct xlog_cursor *
63	lbox_checkcursor(struct lua_State L, int narg, const char src)	14,925✔
64	{
65	uint32_t ctypeid;
66	void *data = NULL;	14,925✔
67	data = (struct xlog_cursor *)luaL_checkcdata(L, narg, &ctypeid);	14,925!
68	assert(ctypeid == CTID_STRUCT_XLOG_CURSOR_REF);	14,925!
69	if (ctypeid != (uint32_t )CTID_STRUCT_XLOG_CURSOR_REF)	14,925!
70	luaL_error(L, "%s: expecting xlog_cursor object", src);	×
71	return (struct xlog_cursor *)data;	14,925✔
72	}
73
74	/* }}} */
75
76	/* {{{ Xlog Parser */
77
78	/**
79	* Converts xlog key names to lower case, for example:
80	* "SPACE_ID" => "space_id"
81	*/
82	static void
83	lbox_xlog_pushkey(lua_State L, const char key)	57,342✔
84	{
85	luaL_Buffer b;
86	luaL_buffinit(L, &b);	57,342!
87	for (const char pos = key; pos; pos++)	418,285✔
88	luaL_addchar(&b, tolower(*pos));	360,943!
89	luaL_pushresult(&b);	57,342!
90	}	57,342✔
91
92	/**
93	* Helper function for lbox_xlog_parse_body that parses one key value pair
94	* and adds it to the result table. The MsgPack data must be checked.
95	*/
96	static void
97	lbox_xlog_parse_body_kv(struct lua_State L, int type, const char *beg)	29,206✔
98	{
99	if (mp_typeof(**beg) != MP_UINT) {	58,412✔
100	/* Invalid key type - ignore. */
101	mp_next(beg);	1✔
102	mp_next(beg);	1✔
103	return;	1✔
104	}
105	uint32_t v = mp_decode_uint(beg);	29,205✔
106	if (iproto_type_is_dml(type) && iproto_key_name(v)) {	29,205✔
107	/*
108	* Historically, the xlog reader outputs IPROTO_OPS as
109	* "operations", not "ops".
110	*/
111	lbox_xlog_pushkey(L, (v == IPROTO_OPS ? "operations" :	58,021✔
112	iproto_key_name(v)));	29,006✔
113	} else if (type == VY_INDEX_RUN_INFO && vy_run_info_key_name(v)) {	190!
114	lbox_xlog_pushkey(L, vy_run_info_key_name(v));	28✔
115	} else if (type == VY_INDEX_PAGE_INFO && vy_page_info_key_name(v)) {	162!
116	lbox_xlog_pushkey(L, vy_page_info_key_name(v));	24✔
117	} else if (type == VY_RUN_ROW_INDEX && vy_row_index_key_name(v)) {	138!
118	lbox_xlog_pushkey(L, vy_row_index_key_name(v));	5✔
119	} else {
120	lua_pushinteger(L, v); /* unknown key */	133✔
121	}
122
123	if ((v == IPROTO_KEY \|\| v == IPROTO_TUPLE \|\| v == IPROTO_OLD_TUPLE \|\|	29,205!
124	v == IPROTO_NEW_TUPLE) && (mp_typeof(**beg) == MP_ARRAY)) {	43,619✔
125	/*
126	* Push tuple if possible.
127	*/
128	const char tuple_beg = beg;	14,539✔
129	mp_next(beg);	14,539✔
130	struct tuple_format *format = box_tuple_format_default();	14,539✔
131	struct tuple tuple = box_tuple_new(format, tuple_beg, beg);	14,539✔
132	if (tuple == NULL)	14,539!
133	luaT_error(L);	×
134	luaT_pushtuple(L, tuple);	14,539✔
135	} else {
136	/*
137	* Push Lua objects
138	*/
139	luamp_decode(L, luaL_msgpack_default, beg);	14,666✔
140	}
141	lua_settable(L, -3);	29,205✔
142	}
143
144	/**
145	* Parses a request body and pushes it to the Lua stack.
146	* The MsgPack data must be checked and represent a map.
147	*/
148	static void
149	lbox_xlog_parse_body(struct lua_State L, int type, const char *beg)	14,610✔
150	{
151	lua_newtable(L);	14,610✔
152	uint32_t size = mp_decode_map(beg);	14,610✔
153	for (uint32_t i = 0; i < size; i++)	43,816✔
154	lbox_xlog_parse_body_kv(L, type, beg);	29,206✔
155	}	14,610✔
156
157	/**
158	* Parses a row and pushes it along with its LSN to the Lua stack.
159	* On success returns the number of values pushed (> 0). On EOF returns 0.
160	*/
161	static int
162	lbox_xlog_parse_row(struct lua_State L, const char pos, const char end)	14,615✔
163	{
164	int top = lua_gettop(L);	14,615!
165	const char tmp = pos;	14,615✔
166	if (mp_check(&tmp, end) != 0 \|\| mp_typeof(**pos) != MP_MAP)	29,229!
167	goto bad_row;	2✔
168	/*
169	* Sic: The nrec argument of lua_createtable is chosen so that the
170	* output looks pretty when encoded in YAML.
171	*/
172	lua_createtable(L, 0, 8);	14,613!
173	lua_pushliteral(L, "HEADER");	14,613!
174	lua_createtable(L, 0, 8);	14,613!
175	uint64_t type = 0;	14,613✔
176	uint64_t tsn = 0;	14,613✔
177	uint64_t lsn = 0;	14,613✔
178	bool has_tsn = false;	14,613✔
179	bool is_commit = false;	14,613✔
180	uint32_t size = mp_decode_map(pos);	14,613!
181	for (uint32_t i = 0; i < size; i++) {	57,506✔
182	if (mp_typeof(**pos) != MP_UINT) {	85,786✔
183	/* Invalid key type - ignore. */
184	mp_next(pos);	1!
185	mp_next(pos);	1!
186	continue;	1✔
187	}
188	uint64_t key = mp_decode_uint(pos);	42,892!
189	const char *key_name = iproto_key_name(key);	42,892!
190	if (key < iproto_key_MAX &&	42,892✔
191	mp_typeof(**pos) != iproto_key_type[key]) {	85,782✔
192	/* Bad value type - dump as is. */
193	goto dump;	1✔
194	}
195	switch (key) {	42,891✔
196	case IPROTO_REQUEST_TYPE: {	14,613✔
197	type = mp_decode_uint(pos);	14,613!
198	lua_pushliteral(L, "type");	14,613!
199	const char *type_name = iproto_type_name(type);	14,613!
200	if (type_name != NULL)	14,613✔
201	lua_pushstring(L, type_name);	14,612!
202	else
203	luaL_pushuint64(L, type);	1!
204	lua_settable(L, -3);	14,613!
205	continue;	14,613✔
206	}
207	case IPROTO_FLAGS: {	2✔
208	/* We're only interested in the commit flag. */
209	uint64_t flags = mp_decode_uint(pos);	2!
210	if ((flags & IPROTO_FLAG_COMMIT) != 0)	2!
211	is_commit = true;	2✔
212	continue;	2✔
213	}
214	case IPROTO_TSN:	6✔
215	/*
216	* TSN is encoded as diff so we dump it after we finish
217	* parsing the header.
218	*/
219	tsn = mp_decode_uint(pos);	6!
220	has_tsn = true;	6✔
221	continue;	6✔
222	case IPROTO_LSN:	13,752✔
223	/* Remember LSN to calculate TSN later. */
224	tmp = *pos;	13,752✔
225	lsn = mp_decode_uint(&tmp);	13,752!
226	break;	13,752✔
227	default:	14,518✔
228	break;	14,518✔
229	}
230	dump:	28,271✔
231	if (key_name != NULL)	28,271✔
232	lbox_xlog_pushkey(L, key_name);	28,270!
233	else
234	luaL_pushuint64(L, key);	1!
235	luamp_decode(L, luaL_msgpack_default, pos);	28,271!
236	lua_settable(L, -3);	28,271!
237	}
238	/* The commit flag isn't set for single-statement transactions. */
239	if (!has_tsn)	14,613✔
240	is_commit = true;	14,607✔
241	tsn = lsn - tsn;	14,613✔
242	/* Show TSN and commit flag only for multi-statement transactions. */
243	if (tsn != lsn \|\| !is_commit) {	14,613✔
244	lua_pushliteral(L, "tsn");	6!
245	luaL_pushuint64(L, tsn);	6!
246	lua_settable(L, -3);	6!
247	}
248	if (is_commit && tsn != lsn) {	14,613✔
249	lua_pushliteral(L, "commit");	2!
250	lua_pushboolean(L, true);	2!
251	lua_settable(L, -3);	2!
252	}
253	lua_settable(L, -3); /* HEADER */	14,613!
254	if (*pos < end && type != IPROTO_NOP) {	14,613!
255	tmp = *pos;	14,612✔
256	if (mp_check(&tmp, end) != 0 \|\| mp_typeof(**pos) != MP_MAP)	29,223!
257	goto bad_row;	2✔
258	lua_pushliteral(L, "BODY");	14,610!
259	lbox_xlog_parse_body(L, type, pos);	14,610!
260	lua_settable(L, -3); /* BODY */	14,610!
261	}
262	luaL_pushuint64(L, lsn);	14,611!
263	lua_insert(L, -2);	14,611!
264	return 2;	14,615✔
265	bad_row:	4✔
266	/* Silently assume EOF on bad row. */
267	lua_settop(L, top);	4!
268	return 0;	4✔
269	}
270
271	static int
272	lbox_xlog_parser_iterate(struct lua_State *L)	14,667✔
273	{
274	struct xlog_cursor *cur = lbox_checkcursor(L, 1, "xlog:pairs()");	14,667✔
275
276	int rc = 0;	14,667✔
277	/* skip all bad read requests */
278	while (true) {	989✔
279	const char **data;
280	const char *end;
281	rc = xlog_cursor_next_row_raw(cur, &data, &end);	15,656!
282	assert(rc >= 0);	15,656!
283	if (rc == 0) {	15,656✔
284	rc = lbox_xlog_parse_row(L, data, end);	14,615!
285	if (rc > 0)	14,615✔
286	return rc;	14,611✔
287	}
288	while ((rc = xlog_cursor_next_tx(cur)) < 0) {	1,048!
289	struct error *e = diag_last_error(diag_get());	3!
290	if (e->type != &type_XlogError)	3!
291	luaT_error(L);	×
292	if ((rc = xlog_cursor_find_tx_magic(cur)) < 0)	3!
293	luaT_error(L);	×
294	if (rc == 1)	3!
295	break;	×
296	}
297	if (rc == 1)	1,045✔
298	break;	56✔
299	}
300	return 0;	56✔
301	}
302
303	/* }}} */
304
305	static void
306	lbox_xlog_parser_close(struct xlog_cursor *cur) {	258✔
307	if (cur == NULL)	258!
308	return;	×
309	xlog_cursor_close(cur, false);	258✔
310	free(cur);	258✔
311	}
312
313	static int
314	lbox_xlog_parser_gc(struct lua_State *L)	258✔
315	{
316	struct xlog_cursor *cur = lbox_checkcursor(L, 1, "xlog:gc()");	258✔
317	lbox_xlog_parser_close(cur);	258✔
318	return 0;	258✔
319	}
320
321	static int
322	lbox_xlog_parser_open_pairs(struct lua_State *L)	848✔
323	{
324	int args_n = lua_gettop(L);	848✔
325	if (args_n != 1 \|\| !lua_isstring(L, 1))	848!
326	luaL_error(L, "Usage: parser.open(log_filename)");	×
327
328	const char *filename = luaL_checkstring(L, 1);	848✔
329
330	/* Construct xlog cursor */
331	struct xlog_cursor cur = (struct xlog_cursor )calloc(1,	848✔
332	sizeof(struct xlog_cursor));
333	if (cur == NULL) {	848!
334	diag_set(OutOfMemory, sizeof(struct xlog_cursor),	×
335	"malloc", "struct xlog_cursor");
336	return luaT_error(L);	×
337	}
338	/* Construct xlog object */
339	if (xlog_cursor_open(cur, filename) < 0) {	848✔
340	free(cur);	1✔
341	return luaT_error(L);	1✔
342	}
343	if (strncmp(cur->meta.filetype, "SNAP", 4) != 0 &&	847✔
344	strncmp(cur->meta.filetype, "XLOG", 4) != 0 &&	25✔
345	strncmp(cur->meta.filetype, "RUN", 3) != 0 &&	12✔
346	strncmp(cur->meta.filetype, "INDEX", 5) != 0 &&	7✔
347	strncmp(cur->meta.filetype, "DATA", 4) != 0 &&	3!
348	strncmp(cur->meta.filetype, "VYLOG", 4) != 0) {	3✔
349	char buf[1024];
350	snprintf(buf, sizeof(buf), "'%.*s' file type",	1✔
351	(int) strlen(cur->meta.filetype),	1✔
352	cur->meta.filetype);	1✔
353	diag_set(ClientError, ER_UNSUPPORTED, "xlog reader", buf);	1!
354	xlog_cursor_close(cur, false);	1!
355	free(cur);	1✔
356	return luaT_error(L);	1!
357	}
358	/* push iteration function */
359	lua_pushcclosure(L, &lbox_xlog_parser_iterate, 1);	846✔
360	/* push log and set GC */
361	lbox_pushcursor(L, cur);	846✔
362	lua_pushcfunction(L, lbox_xlog_parser_gc);	846✔
363	luaL_setcdatagc(L, -2);	846✔
364	/* push iterator position */
365	lua_pushinteger(L, 0);	846✔
366	return 3;	846✔
367	}
368
369	/** Opens an xlog file and returns its meta block. */
370	static int
371	lbox_xlog_parser_open_meta(struct lua_State *L)	31✔
372	{
373	int args_n = lua_gettop(L);	31✔
374	if (args_n != 1 \|\| !lua_isstring(L, 1))	31!
UNCOV 375	luaL_error(L, "Usage: parser.open(log_filename)");	×
376
377	const char *filename = luaL_checkstring(L, 1);	31✔
378
379	/* Construct xlog cursor and object */
380	struct xlog_cursor *cur = xcalloc(1, sizeof(struct xlog_cursor));	31!
381	if (xlog_cursor_open(cur, filename) < 0) {	31!
UNCOV 382	return luaT_error(L);	×
383	}
384
385	lua_newtable(L);	31✔
386
387	lua_pushstring(L, "filetype");	31✔
388	lua_pushstring(L, cur->meta.filetype);	31✔
389	lua_settable(L, -3);	31✔
390
391	lua_pushstring(L, "instance_uuid");	31✔
392	luaT_pushuuidstr(L, &cur->meta.instance_uuid);	31✔
393	lua_settable(L, -3);	31✔
394
395	lua_pushstring(L, "vclock");	31✔
396	luaT_pushvclock(L, &cur->meta.vclock);	31✔
397	lua_settable(L, -3);	31✔
398
399	lua_pushstring(L, "prev_vclock");	31✔
400	luaT_pushvclock(L, &cur->meta.prev_vclock);	31✔
401	lua_settable(L, -3);	31✔
402
403	xlog_cursor_close(cur, false);	31✔
404	free(cur);	31✔
405	return 1;	31✔
406	}
407
408	static const struct luaL_Reg lbox_xlog_parser_lib [] = {
409	{ "pairs", lbox_xlog_parser_open_pairs },
410	{ "meta", lbox_xlog_parser_open_meta },
411	{ NULL, NULL }
412	};
413
414	void
415	box_lua_xlog_init(struct lua_State *L)	5,236✔
416	{
417	int rc = 0;	5,236✔
418	/* Get CTypeIDs */
419	rc = luaL_cdef(L, "struct xlog_cursor;"); assert(rc == 0); (void) rc;	5,236!
420	CTID_STRUCT_XLOG_CURSOR_REF = luaL_ctypeid(L, "struct xlog_cursor&");	5,236✔
421	assert(CTID_STRUCT_XLOG_CURSOR_REF != 0);	5,236!
422
423	luaT_newmodule(L, "xlog.lib", lbox_xlog_parser_lib);	5,236✔
424
425	lua_newtable(L);	5,236✔
426	lua_setmetatable(L, -2);	5,236✔
427	lua_pop(L, 1);	5,236✔
428	}	5,236✔
429
430	/* }}} */

tarantool / tarantool / 10596897991

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