[Tarantool-patches] [PATCH 12/20] net.box: rewrite error decoder in C
Vladimir Davydov
vdavydov at tarantool.org
Fri Jul 23 14:07:22 MSK 2021
This patch moves response_decoder table (which decodes only errors
despite its name) from Lua to C. This is a step towards rewriting
performance-critical parts of net.box in C.
---
src/box/lua/net_box.c | 60 +++++++++++++++++++++++++++++++++++++++
src/box/lua/net_box.lua | 62 ++---------------------------------------
2 files changed, 62 insertions(+), 60 deletions(-)
diff --git a/src/box/lua/net_box.c b/src/box/lua/net_box.c
index c0c3725e5350..e88db6323afa 100644
--- a/src/box/lua/net_box.c
+++ b/src/box/lua/net_box.c
@@ -40,6 +40,8 @@
#include "box/xrow.h"
#include "box/tuple.h"
#include "box/execute.h"
+#include "box/error.h"
+#include "box/mp_error.h"
#include "lua/msgpack.h"
#include <base64.h>
@@ -1082,6 +1084,63 @@ netbox_decode_method(struct lua_State *L)
return 2;
}
+/*
+ * Decodes an error from raw data and pushes it to Lua stack. Takes a pointer
+ * to the data (char ptr) and an error code.
+ */
+static int
+netbox_decode_error(struct lua_State *L)
+{
+ uint32_t ctypeid;
+ const char **data = luaL_checkcdata(L, 1, &ctypeid);
+ assert(ctypeid == CTID_CHAR_PTR || ctypeid == CTID_CONST_CHAR_PTR);
+ uint32_t errcode = lua_tointeger(L, 2);
+ struct error *error = NULL;
+ assert(mp_typeof(**data) == MP_MAP);
+ uint32_t map_size = mp_decode_map(data);
+ for (uint32_t i = 0; i < map_size; ++i) {
+ uint32_t key = mp_decode_uint(data);
+ if (key == IPROTO_ERROR) {
+ if (error != NULL)
+ error_unref(error);
+ error = error_unpack_unsafe(data);
+ if (error == NULL)
+ return luaT_error(L);
+ error_ref(error);
+ /*
+ * IPROTO_ERROR comprises error encoded with
+ * IPROTO_ERROR_24, so we may ignore content
+ * of that key.
+ */
+ break;
+ } else if (key == IPROTO_ERROR_24) {
+ if (error != NULL)
+ error_unref(error);
+ const char *reason = "";
+ uint32_t reason_len = 0;
+ if (mp_typeof(**data) == MP_STR)
+ reason = mp_decode_str(data, &reason_len);
+ box_error_raise(errcode, "%.*s", reason_len, reason);
+ error = box_error_last();
+ error_ref(error);
+ continue;
+ }
+ mp_next(data); /* skip value */
+ }
+ if (error == NULL) {
+ /*
+ * Error body is missing in the response.
+ * Set the error code without a 'reason' message
+ */
+ box_error_raise(errcode, "");
+ error = box_error_last();
+ error_ref(error);
+ }
+ luaT_pusherror(L, error);
+ error_unref(error);
+ return 1;
+}
+
int
luaopen_net_box(struct lua_State *L)
{
@@ -1090,6 +1149,7 @@ luaopen_net_box(struct lua_State *L)
{ "encode_method", netbox_encode_method },
{ "decode_greeting",netbox_decode_greeting },
{ "decode_method", netbox_decode_method },
+ { "decode_error", netbox_decode_error },
{ "communicate", netbox_communicate },
{ NULL, NULL}
};
diff --git a/src/box/lua/net_box.lua b/src/box/lua/net_box.lua
index 9e41d6c0844b..d7394b088752 100644
--- a/src/box/lua/net_box.lua
+++ b/src/box/lua/net_box.lua
@@ -27,6 +27,7 @@ local encode_auth = internal.encode_auth
local encode_method = internal.encode_method
local decode_greeting = internal.decode_greeting
local decode_method = internal.decode_method
+local decode_error = internal.decode_error
local TIMEOUT_INFINITY = 500 * 365 * 86400
local VSPACE_ID = 281
@@ -73,14 +74,6 @@ local M_COUNT = 16
-- Injects raw data into connection. Used by console and tests.
local M_INJECT = 17
-ffi.cdef[[
-struct error *
-error_unpack_unsafe(const char **data);
-
-void
-error_unref(struct error *e);
-]]
-
-- utility tables
local is_final_state = {closed = 1, error = 1}
@@ -97,29 +90,6 @@ local function version_at_least(peer_version_id, major, minor, patch)
return peer_version_id >= version_id(major, minor, patch)
end
-local function decode_error(raw_data)
- local ptr = ffi.new('const char *[1]', raw_data)
- local err = ffi.C.error_unpack_unsafe(ptr)
- if err ~= nil then
- err._refs = err._refs + 1
- -- From FFI it is returned as 'struct error *', which is
- -- not considered equal to 'const struct error &', and is
- -- is not accepted by functions like box.error(). Need to
- -- cast explicitly.
- err = ffi.cast('const struct error &', err)
- err = ffi.gc(err, ffi.C.error_unref)
- else
- -- Error unpacker installs fail reason into diag.
- box.error()
- end
- return err, ptr[0]
-end
-
-local response_decoder = {
- [IPROTO_ERROR_24] = decode,
- [IPROTO_ERROR] = decode_error,
-}
-
local function next_id(id) return band(id + 1, 0x7FFFFFFF) end
--
@@ -538,42 +508,14 @@ local function create_transport(host, port, user, password, callback,
return
end
local status = hdr[IPROTO_STATUS_KEY]
- local body
local body_len = body_end - body_rpos
if status > IPROTO_CHUNK_KEY then
-- Handle errors
requests[id] = nil
request.id = nil
- local map_len, key
- map_len, body_rpos = decode_map_header(body_rpos, body_len)
- -- Reserve for 2 keys and 2 array indexes. Because no
- -- any guarantees how Lua will decide to save the
- -- sparse table.
- body = table_new(2, 2)
- for _ = 1, map_len do
- key, body_rpos = decode(body_rpos)
- local rdec = response_decoder[key]
- if rdec then
- body[key], body_rpos = rdec(body_rpos)
- else
- _, body_rpos = decode(body_rpos)
- end
- end
- assert(body_end == body_rpos, "invalid xrow length")
request.errno = band(status, IPROTO_ERRNO_MASK)
- -- IPROTO_ERROR comprises error encoded with
- -- IPROTO_ERROR_24, so we may ignore content of that
- -- key.
- if body[IPROTO_ERROR] ~= nil then
- request.response = body[IPROTO_ERROR]
- assert(type(request.response) == 'cdata')
- else
- request.response = box.error.new({
- code = request.errno,
- reason = body[IPROTO_ERROR_24]
- })
- end
+ request.response = decode_error(body_rpos, request.errno)
request.cond:broadcast()
return
end
--
2.25.1
More information about the Tarantool-patches
mailing list