From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from [87.239.111.99] (localhost [127.0.0.1]) by dev.tarantool.org (Postfix) with ESMTP id 9D5BE6EC5D; Fri, 2 Apr 2021 15:37:57 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 dev.tarantool.org 9D5BE6EC5D DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=tarantool.org; s=dev; t=1617367077; bh=9dcYrCzcnDnqEQb1tSaYsYFcGEybGKDFPb28ml9aDVQ=; h=To:Date:In-Reply-To:References:Subject:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=ba30DqrJ44uuzyDvE4j22zpXBoAXLjbqBgHaPpo4l/PgPzep6GLWadvPcJhjvkhJ5 5AXnopfFFTn4bWXrvhudYN4k6velqF9yHdwV6z1OwYNf8d9YBIPkVTM4jCNBvoeaoF IveKNFXNzGJ22NB+Hk9PyVkdI0tgkgMfBuoJ/E+8= Received: from mail-lf1-f54.google.com (mail-lf1-f54.google.com [209.85.167.54]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by dev.tarantool.org (Postfix) with ESMTPS id 9EC386EC63 for ; Fri, 2 Apr 2021 15:35:50 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 dev.tarantool.org 9EC386EC63 Received: by mail-lf1-f54.google.com with SMTP id g8so7363335lfv.12 for ; Fri, 02 Apr 2021 05:35:50 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=5Ot31JYbCRlpGIM6FBzxkD4rAKqFqH/Ly07MDm9G+4A=; b=d2978a8yyel//zaHO4dzTY0658LMOzHDXy2lE21+D4KNYj6X8LO+ZtOvZyk2a7aVok /6h5lPin5gsrKJHAIIBL3iPsGxuRqcXQPFDd5Fl6Zhx6AOrXpg5AO+dai2AR8ion5Sf9 4gTUzMV10zxW14/M1bj27yHnP5iSSMKhjNCth1KBHWO/1622h3CRFJBsh19n1WndePqL DZ7/Pg4uzmFeeLxMmaCEGK4D1s04I0bG9jD+eK0PaVSWC4zvLwGzBxETg3QGwi4xSY0k G7dC9DgDENc+D8sOcDO12hLwOWe/v3olZ6eIwWdaEf4bf6Crgrffp02H8FEaaWqHDo// O77A== X-Gm-Message-State: AOAM530OWAw6KYo5MPARgCMiDQYSVF6edhk3dqURmTzHUBjwN9IxGPdJ NBBBzbHwOhk9KBqU29SvabWm0lAYVPi3pg== X-Google-Smtp-Source: ABdhPJyCg8XkJzRmWoIgJr4HUJVUNDKyd8vzhXZL+7wwWIltnOq49lcWaswAsh4IyeG6sh+8fv8Fmw== X-Received: by 2002:ac2:4a75:: with SMTP id q21mr8316675lfp.457.1617366949085; Fri, 02 Apr 2021 05:35:49 -0700 (PDT) Received: from grain.localdomain ([5.18.171.94]) by smtp.gmail.com with ESMTPSA id p13sm929710ljc.72.2021.04.02.05.35.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 02 Apr 2021 05:35:47 -0700 (PDT) Received: by grain.localdomain (Postfix, from userid 1000) id 325215601FC; Fri, 2 Apr 2021 15:34:22 +0300 (MSK) To: tml Date: Fri, 2 Apr 2021 15:34:20 +0300 Message-Id: <20210402123420.885834-8-gorcunov@gmail.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210402123420.885834-1-gorcunov@gmail.com> References: <20210402123420.885834-1-gorcunov@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [Tarantool-patches] [PATCH v20 7/7] test: add box.lib test X-BeenThere: tarantool-patches@dev.tarantool.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Tarantool development patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Cyrill Gorcunov via Tarantool-patches Reply-To: Cyrill Gorcunov Cc: Vladislav Shpilevoy Errors-To: tarantool-patches-bounces@dev.tarantool.org Sender: "Tarantool-patches" Note that the test is disabled in suite.ini for a while because we need to update test-run first like | diff --git a/pretest_clean.lua b/pretest_clean.lua | index 446ecf2..b356ebd 100644 | --- a/pretest_clean.lua | +++ b/pretest_clean.lua | @@ -228,6 +228,7 @@ local function clean() | ['box.internal.sequence'] = true, | ['box.internal.session'] = true, | ['box.internal.space'] = true, | + ['box.lib'] = true, | buffer = true, | clock = true, | console = true, Part-of #4642 Signed-off-by: Cyrill Gorcunov --- test/box/CMakeLists.txt | 4 + test/box/cfunc1.c | 58 +++++ test/box/cfunc2.c | 137 +++++++++++ test/box/cfunc3.c | 25 ++ test/box/cfunc4.c | 28 +++ test/box/lib.result | 530 ++++++++++++++++++++++++++++++++++++++++ test/box/lib.test.lua | 203 +++++++++++++++ test/box/suite.ini | 2 +- 8 files changed, 986 insertions(+), 1 deletion(-) create mode 100644 test/box/cfunc1.c create mode 100644 test/box/cfunc2.c create mode 100644 test/box/cfunc3.c create mode 100644 test/box/cfunc4.c create mode 100644 test/box/lib.result create mode 100644 test/box/lib.test.lua diff --git a/test/box/CMakeLists.txt b/test/box/CMakeLists.txt index 944831af2..c9dcbbb7b 100644 --- a/test/box/CMakeLists.txt +++ b/test/box/CMakeLists.txt @@ -5,3 +5,7 @@ build_module(reload2 reload2.c) build_module(func_restore1 func_restore1.c) build_module(func_restore2 func_restore2.c) build_module(tuple_bench tuple_bench.c) +build_module(cfunc1 cfunc1.c) +build_module(cfunc2 cfunc2.c) +build_module(cfunc3 cfunc3.c) +build_module(cfunc4 cfunc4.c) diff --git a/test/box/cfunc1.c b/test/box/cfunc1.c new file mode 100644 index 000000000..f6829372a --- /dev/null +++ b/test/box/cfunc1.c @@ -0,0 +1,58 @@ +#include +#include +#include + +#include "module.h" + +/* + * Before the reload functions are just declared + * and simply exit with zero. + * + * After the module reload we should provide real + * functionality. + */ + +int +cfunc_nop(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + (void)ctx; + (void)args; + (void)args_end; + return 0; +} + +int +cfunc_fetch_seq_evens(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + (void)ctx; + (void)args; + (void)args_end; + return 0; +} + +int +cfunc_multireturn(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + (void)ctx; + (void)args; + (void)args_end; + return 0; +} + +int +cfunc_args(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + (void)ctx; + (void)args; + (void)args_end; + return 0; +} + +int +cfunc_sum(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + (void)ctx; + (void)args; + (void)args_end; + return 0; +} diff --git a/test/box/cfunc2.c b/test/box/cfunc2.c new file mode 100644 index 000000000..8c583e993 --- /dev/null +++ b/test/box/cfunc2.c @@ -0,0 +1,137 @@ +#include +#include +#include + +#include "module.h" + +/* + * Just make sure we've been called. + */ +int +cfunc_nop(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + (void)ctx; + (void)args; + (void)args_end; + return 0; +} + +/* + * Fetch first N even numbers (just to make sure the order of + * arguments is not screwed). + */ +int +cfunc_fetch_seq_evens(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + int arg_count = mp_decode_array(&args); + if (arg_count != 1) { + return box_error_set(__FILE__, __LINE__, ER_PROC_C, "%s", + "invalid argument count"); + } + int field_count = mp_decode_array(&args); + if (field_count < 1) { + return box_error_set(__FILE__, __LINE__, ER_PROC_C, "%s", + "invalid array size"); + } + + /* + * We expect even numbers sequence here. The idea is + * to test invalid data an issue an error from inside + * of C function. + */ + for (int i = 1; i <= field_count; i++) { + int val = mp_decode_uint(&args); + int needed = 2 * i; + if (val != needed) { + char res[128]; + snprintf(res, sizeof(res), "%s %d != %d", + "invalid argument", val, needed); + return box_error_set(__FILE__, __LINE__, + ER_PROC_C, "%s", res); + } + } + + return 0; +} + +/* + * Return one element array twice. + */ +int +cfunc_multireturn(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + char tuple_buf[512]; + char *d = tuple_buf; + d = mp_encode_array(d, 1); + d = mp_encode_uint(d, 1); + assert(d <= tuple_buf + sizeof(tuple_buf)); + + box_tuple_format_t *fmt = box_tuple_format_default(); + box_tuple_t *tuple_a = box_tuple_new(fmt, tuple_buf, d); + if (tuple_a == NULL) + return -1; + int rc = box_return_tuple(ctx, tuple_a); + if (rc == 0) + return box_return_tuple(ctx, tuple_a); + return rc; +} + +/* + * Encode int + string pair back. + */ +int +cfunc_args(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + uint32_t arg_count = mp_decode_array(&args); + if (arg_count != 2) { + return box_error_set(__FILE__, __LINE__, ER_PROC_C, "%s", + "invalid argument count"); + } + + if (mp_typeof(*args) != MP_UINT) { + return box_error_set(__FILE__, __LINE__, ER_PROC_C, "%s", + "tuple field must be uint"); + } + uint32_t num = mp_decode_uint(&args); + + if (mp_typeof(*args) != MP_STR) { + return box_error_set(__FILE__, __LINE__, ER_PROC_C, "%s", + "tuple field must be string"); + } + const char *str = args; + uint32_t len = mp_decode_strl(&str); + + char tuple_buf[512]; + char *d = tuple_buf; + d = mp_encode_array(d, 2); + d = mp_encode_uint(d, num); + d = mp_encode_str(d, str, len); + assert(d <= tuple_buf + sizeof(tuple_buf)); + + box_tuple_format_t *fmt = box_tuple_format_default(); + box_tuple_t *tuple = box_tuple_new(fmt, tuple_buf, d); + if (tuple == NULL) + return -1; + + return box_return_tuple(ctx, tuple); +} + +/* + * Sum two integers. + */ +int +cfunc_sum(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + uint32_t arg_count = mp_decode_array(&args); + if (arg_count != 2) { + return box_error_set(__FILE__, __LINE__, ER_PROC_C, "%s", + "invalid argument count"); + } + uint64_t a = mp_decode_uint(&args); + uint64_t b = mp_decode_uint(&args); + + char res[16]; + char *end = mp_encode_uint(res, a + b); + box_return_mp(ctx, res, end); + return 0; +} diff --git a/test/box/cfunc3.c b/test/box/cfunc3.c new file mode 100644 index 000000000..668790fbf --- /dev/null +++ b/test/box/cfunc3.c @@ -0,0 +1,25 @@ +#include +#include +#include + +#include "module.h" + +/* + * Sum two integers. + */ +int +cfunc_add(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + uint32_t arg_count = mp_decode_array(&args); + if (arg_count != 2) { + return box_error_set(__FILE__, __LINE__, ER_PROC_C, "%s", + "invalid argument count"); + } + uint64_t a = mp_decode_uint(&args); + uint64_t b = mp_decode_uint(&args); + + char res[16]; + char *end = mp_encode_uint(res, a + b); + box_return_mp(ctx, res, end); + return 0; +} diff --git a/test/box/cfunc4.c b/test/box/cfunc4.c new file mode 100644 index 000000000..cc079b335 --- /dev/null +++ b/test/box/cfunc4.c @@ -0,0 +1,28 @@ +#include +#include +#include + +#include "module.h" + +/* + * Sum two integers and add a constant, + * so that result will be different after + * the reload. + */ +int +cfunc_add(box_function_ctx_t *ctx, const char *args, const char *args_end) +{ + const uint32_t delta = 10; + uint32_t arg_count = mp_decode_array(&args); + if (arg_count != 2) { + return box_error_set(__FILE__, __LINE__, ER_PROC_C, "%s", + "invalid argument count"); + } + uint64_t a = mp_decode_uint(&args); + uint64_t b = mp_decode_uint(&args); + + char res[16]; + char *end = mp_encode_uint(res, a + b + delta); + box_return_mp(ctx, res, end); + return 0; +} diff --git a/test/box/lib.result b/test/box/lib.result new file mode 100644 index 000000000..43c396dbd --- /dev/null +++ b/test/box/lib.result @@ -0,0 +1,530 @@ +-- test-run result file version 2 +-- +-- gh-4642: New box.lib module to be able to +-- run C stored functions on read only nodes +-- without requirement to register them with +-- box.schema.func help. +-- +build_path = os.getenv("BUILDDIR") + | --- + | ... +package.cpath = build_path..'/test/box/?.so;'..build_path..'/test/box/?.dylib;'..package.cpath + | --- + | ... + +boxlib = require('box.lib') + | --- + | ... +fio = require('fio') + | --- + | ... + +ext = (jit.os == "OSX" and "dylib" or "so") + | --- + | ... + +cfunc_path = fio.pathjoin(build_path, "test/box/cfunc.") .. ext + | --- + | ... +cfunc1_path = fio.pathjoin(build_path, "test/box/cfunc1.") .. ext + | --- + | ... +cfunc2_path = fio.pathjoin(build_path, "test/box/cfunc2.") .. ext + | --- + | ... +cfunc3_path = fio.pathjoin(build_path, "test/box/cfunc3.") .. ext + | --- + | ... +cfunc4_path = fio.pathjoin(build_path, "test/box/cfunc4.") .. ext + | --- + | ... + +_ = pcall(fio.unlink(cfunc_path)) + | --- + | ... +fio.symlink(cfunc1_path, cfunc_path) + | --- + | - true + | ... + +_, err = pcall(boxlib.load, 'non-such-module') + | --- + | ... +assert(err ~= nil) + | --- + | - true + | ... + +-- All functions are sitting in cfunc.so. +old_module = boxlib.load('cfunc') + | --- + | ... +assert(old_module['debug_refs'] == 1) + | --- + | - true + | ... +old_module_copy = boxlib.load('cfunc') + | --- + | ... +assert(old_module['debug_refs'] == 2) + | --- + | - true + | ... +assert(old_module_copy['debug_refs'] == 2) + | --- + | - true + | ... +old_module_copy:unload() + | --- + | - true + | ... +assert(old_module['debug_refs'] == 1) + | --- + | - true + | ... +old_cfunc_nop = old_module:load('cfunc_nop') + | --- + | ... +old_cfunc_fetch_seq_evens = old_module:load('cfunc_fetch_seq_evens') + | --- + | ... +old_cfunc_multireturn = old_module:load('cfunc_multireturn') + | --- + | ... +old_cfunc_args = old_module:load('cfunc_args') + | --- + | ... +old_cfunc_sum = old_module:load('cfunc_sum') + | --- + | ... +assert(old_module['debug_refs'] == 6) + | --- + | - true + | ... + +-- Test for error on nonexisting function. +_, err = pcall(old_module.load, old_module, 'no-such-func') + | --- + | ... +assert(err ~= nil) + | --- + | - true + | ... + +-- Make sure they all are callable. +old_cfunc_nop() + | --- + | ... +old_cfunc_fetch_seq_evens() + | --- + | ... +old_cfunc_multireturn() + | --- + | ... +old_cfunc_args() + | --- + | ... +old_cfunc_sum() + | --- + | ... + +-- Unload the module but keep old functions alive, so +-- they keep reference to NOP module internally +-- and still callable. +old_module:unload() + | --- + | - true + | ... +-- Test refs via function name. +assert(old_cfunc_nop['debug_module_refs'] == 5) + | --- + | - true + | ... +old_cfunc_nop() + | --- + | ... +old_cfunc_fetch_seq_evens() + | --- + | ... +old_cfunc_multireturn() + | --- + | ... +old_cfunc_args() + | --- + | ... +old_cfunc_sum() + | --- + | ... + +-- The module is unloaded I should not be able +-- to load new shared library. +old_module:load('cfunc') + | --- + | - error: Expects function = module:load('name') but not module object passed + | ... +-- Neither I should be able to unload module twise. +old_module:unload() + | --- + | - error: The module is unloaded + | ... + +-- Clean old functions. +old_cfunc_nop:unload() + | --- + | - true + | ... +old_cfunc_fetch_seq_evens:unload() + | --- + | - true + | ... +old_cfunc_multireturn:unload() + | --- + | - true + | ... +old_cfunc_args:unload() + | --- + | - true + | ... +assert(old_cfunc_sum['debug_module_refs'] == 1) + | --- + | - true + | ... +old_cfunc_sum:unload() + | --- + | - true + | ... + +-- And reload old module again. +old_module = boxlib.load('cfunc') + | --- + | ... +old_module_ptr = old_module['debug_ptr'] + | --- + | ... +assert(old_module['debug_refs'] == 1) + | --- + | - true + | ... + +-- Overwrite module with new contents. +_ = pcall(fio.unlink(cfunc_path)) + | --- + | ... +fio.symlink(cfunc2_path, cfunc_path) + | --- + | - true + | ... + +-- Load new module, cache should be updated. +new_module = boxlib.load('cfunc') + | --- + | ... +new_module_ptr = new_module['debug_ptr'] + | --- + | ... + +-- Old and new module keep one reference with +-- different IDs. +assert(old_module['debug_refs'] == 1) + | --- + | - true + | ... +assert(old_module['debug_refs'] == new_module['debug_refs']) + | --- + | - true + | ... +assert(old_module_ptr ~= new_module_ptr) + | --- + | - true + | ... + +-- All functions from old module should be loadable. +old_cfunc_nop = old_module:load('cfunc_nop') + | --- + | ... +old_cfunc_fetch_seq_evens = old_module:load('cfunc_fetch_seq_evens') + | --- + | ... +old_cfunc_multireturn = old_module:load('cfunc_multireturn') + | --- + | ... +old_cfunc_args = old_module:load('cfunc_args') + | --- + | ... +old_cfunc_sum = old_module:load('cfunc_sum') + | --- + | ... +assert(old_cfunc_nop['debug_module_ptr'] == old_module_ptr) + | --- + | - true + | ... +assert(old_cfunc_fetch_seq_evens['debug_module_ptr'] == old_module_ptr) + | --- + | - true + | ... +assert(old_cfunc_multireturn['debug_module_ptr'] == old_module_ptr) + | --- + | - true + | ... +assert(old_cfunc_args['debug_module_ptr'] == old_module_ptr) + | --- + | - true + | ... +assert(old_cfunc_sum['debug_module_ptr'] == old_module_ptr) + | --- + | - true + | ... +assert(old_module['debug_refs'] == 6) + | --- + | - true + | ... + +-- Lookup for updated symbols. +new_cfunc_nop = new_module:load('cfunc_nop') + | --- + | ... +new_cfunc_fetch_seq_evens = new_module:load('cfunc_fetch_seq_evens') + | --- + | ... +new_cfunc_multireturn = new_module:load('cfunc_multireturn') + | --- + | ... +new_cfunc_args = new_module:load('cfunc_args') + | --- + | ... +new_cfunc_sum = new_module:load('cfunc_sum') + | --- + | ... +assert(new_cfunc_nop['debug_module_ptr'] == new_module_ptr) + | --- + | - true + | ... +assert(new_cfunc_fetch_seq_evens['debug_module_ptr'] == new_module_ptr) + | --- + | - true + | ... +assert(new_cfunc_multireturn['debug_module_ptr'] == new_module_ptr) + | --- + | - true + | ... +assert(new_cfunc_args['debug_module_ptr'] == new_module_ptr) + | --- + | - true + | ... +assert(new_cfunc_sum['debug_module_ptr'] == new_module_ptr) + | --- + | - true + | ... +assert(new_module['debug_refs'] == 6) + | --- + | - true + | ... + +-- Call old functions. +old_cfunc_nop() + | --- + | ... +old_cfunc_fetch_seq_evens() + | --- + | ... +old_cfunc_multireturn() + | --- + | ... +old_cfunc_args() + | --- + | ... +old_cfunc_sum() + | --- + | ... + +-- Call new functions. +new_cfunc_nop() + | --- + | ... +new_cfunc_multireturn() + | --- + | - [1] + | - [1] + | ... +new_cfunc_fetch_seq_evens({2,4,6}) + | --- + | ... +new_cfunc_fetch_seq_evens({1,2,3}) -- error, odd numbers sequence + | --- + | - error: invalid argument 1 != 2 + | ... +new_cfunc_args(1, "hello") + | --- + | - [1, 'hello'] + | ... +new_cfunc_sum(1) -- error, one arg passed + | --- + | - error: invalid argument count + | ... +new_cfunc_sum(1,2) + | --- + | - 3 + | ... + +-- Cleanup old module's functions. +old_cfunc_nop:unload() + | --- + | - true + | ... +old_cfunc_fetch_seq_evens:unload() + | --- + | - true + | ... +old_cfunc_multireturn:unload() + | --- + | - true + | ... +old_cfunc_args:unload() + | --- + | - true + | ... +old_cfunc_sum:unload() + | --- + | - true + | ... +old_module:unload() + | --- + | - true + | ... + +-- Cleanup new module data. +new_cfunc_nop:unload() + | --- + | - true + | ... +new_cfunc_multireturn:unload() + | --- + | - true + | ... +new_cfunc_fetch_seq_evens:unload() + | --- + | - true + | ... +new_cfunc_args:unload() + | --- + | - true + | ... +new_cfunc_sum:unload() + | --- + | - true + | ... +new_module:unload() + | --- + | - true + | ... + +-- Cleanup the generated symlink. +_ = pcall(fio.unlink(cfunc_path)) + | --- + | ... + +-- Test double hashing: create function +-- in box.schema.fun so that it should +-- appear in box.lib hash. +fio.symlink(cfunc3_path, cfunc_path) + | --- + | - true + | ... +box.schema.func.create('cfunc.cfunc_add', {language = "C"}) + | --- + | ... +box.schema.user.grant('guest', 'execute', 'function', 'cfunc.cfunc_add') + | --- + | ... +box.func['cfunc.cfunc_add']:call({1,2}) + | --- + | - 3 + | ... + +old_module = boxlib.load('cfunc') + | --- + | ... +assert(old_module['debug_refs'] == 3) -- box.lib + 2 box.schema.func + | --- + | - true + | ... +old_func = old_module:load('cfunc_add') + | --- + | ... +assert(old_module['debug_refs'] == 4) -- plus function instance + | --- + | - true + | ... +old_func(1,2) + | --- + | - 3 + | ... + +-- Now update on disk and reload the module. +_ = pcall(fio.unlink(cfunc_path)) + | --- + | ... +fio.symlink(cfunc4_path, cfunc_path) + | --- + | - true + | ... + +box.schema.func.reload("cfunc") + | --- + | ... +box.func['cfunc.cfunc_add']:call({1,2}) + | --- + | - 13 + | ... + +-- The box.lib instance should carry own +-- references to the module and old +-- function. And reloading must not +-- affect old functions. Thus one for +-- box.lib and one for box.lib function. +assert(old_module['debug_refs'] == 2) + | --- + | - true + | ... +old_func(1,2) + | --- + | - 3 + | ... +old_func:unload() + | --- + | - true + | ... +old_module:unload() + | --- + | - true + | ... + +-- Same time the reload should update +-- low level module cache, thus two +-- for box and box function plus one +-- new box.lib. +new_module = boxlib.load('cfunc') + | --- + | ... +assert(new_module['debug_refs'] == 3) + | --- + | - true + | ... + +-- Box function should carry own module. +box.func['cfunc.cfunc_add']:call({1,2}) + | --- + | - 13 + | ... + +-- Cleanup. +_ = pcall(fio.unlink(cfunc_path)) + | --- + | ... +new_module:unload() + | --- + | - true + | ... +box.schema.func.drop('cfunc.cfunc_add') + | --- + | ... diff --git a/test/box/lib.test.lua b/test/box/lib.test.lua new file mode 100644 index 000000000..445c2121c --- /dev/null +++ b/test/box/lib.test.lua @@ -0,0 +1,203 @@ +-- +-- gh-4642: New box.lib module to be able to +-- run C stored functions on read only nodes +-- without requirement to register them with +-- box.schema.func help. +-- +build_path = os.getenv("BUILDDIR") +package.cpath = build_path..'/test/box/?.so;'..build_path..'/test/box/?.dylib;'..package.cpath + +boxlib = require('box.lib') +fio = require('fio') + +ext = (jit.os == "OSX" and "dylib" or "so") + +cfunc_path = fio.pathjoin(build_path, "test/box/cfunc.") .. ext +cfunc1_path = fio.pathjoin(build_path, "test/box/cfunc1.") .. ext +cfunc2_path = fio.pathjoin(build_path, "test/box/cfunc2.") .. ext +cfunc3_path = fio.pathjoin(build_path, "test/box/cfunc3.") .. ext +cfunc4_path = fio.pathjoin(build_path, "test/box/cfunc4.") .. ext + +_ = pcall(fio.unlink(cfunc_path)) +fio.symlink(cfunc1_path, cfunc_path) + +_, err = pcall(boxlib.load, 'non-such-module') +assert(err ~= nil) + +-- All functions are sitting in cfunc.so. +old_module = boxlib.load('cfunc') +assert(old_module['debug_refs'] == 1) +old_module_copy = boxlib.load('cfunc') +assert(old_module['debug_refs'] == 2) +assert(old_module_copy['debug_refs'] == 2) +old_module_copy:unload() +assert(old_module['debug_refs'] == 1) +old_cfunc_nop = old_module:load('cfunc_nop') +old_cfunc_fetch_seq_evens = old_module:load('cfunc_fetch_seq_evens') +old_cfunc_multireturn = old_module:load('cfunc_multireturn') +old_cfunc_args = old_module:load('cfunc_args') +old_cfunc_sum = old_module:load('cfunc_sum') +assert(old_module['debug_refs'] == 6) + +-- Test for error on nonexisting function. +_, err = pcall(old_module.load, old_module, 'no-such-func') +assert(err ~= nil) + +-- Make sure they all are callable. +old_cfunc_nop() +old_cfunc_fetch_seq_evens() +old_cfunc_multireturn() +old_cfunc_args() +old_cfunc_sum() + +-- Unload the module but keep old functions alive, so +-- they keep reference to NOP module internally +-- and still callable. +old_module:unload() +-- Test refs via function name. +assert(old_cfunc_nop['debug_module_refs'] == 5) +old_cfunc_nop() +old_cfunc_fetch_seq_evens() +old_cfunc_multireturn() +old_cfunc_args() +old_cfunc_sum() + +-- The module is unloaded I should not be able +-- to load new shared library. +old_module:load('cfunc') +-- Neither I should be able to unload module twise. +old_module:unload() + +-- Clean old functions. +old_cfunc_nop:unload() +old_cfunc_fetch_seq_evens:unload() +old_cfunc_multireturn:unload() +old_cfunc_args:unload() +assert(old_cfunc_sum['debug_module_refs'] == 1) +old_cfunc_sum:unload() + +-- And reload old module again. +old_module = boxlib.load('cfunc') +old_module_ptr = old_module['debug_ptr'] +assert(old_module['debug_refs'] == 1) + +-- Overwrite module with new contents. +_ = pcall(fio.unlink(cfunc_path)) +fio.symlink(cfunc2_path, cfunc_path) + +-- Load new module, cache should be updated. +new_module = boxlib.load('cfunc') +new_module_ptr = new_module['debug_ptr'] + +-- Old and new module keep one reference with +-- different IDs. +assert(old_module['debug_refs'] == 1) +assert(old_module['debug_refs'] == new_module['debug_refs']) +assert(old_module_ptr ~= new_module_ptr) + +-- All functions from old module should be loadable. +old_cfunc_nop = old_module:load('cfunc_nop') +old_cfunc_fetch_seq_evens = old_module:load('cfunc_fetch_seq_evens') +old_cfunc_multireturn = old_module:load('cfunc_multireturn') +old_cfunc_args = old_module:load('cfunc_args') +old_cfunc_sum = old_module:load('cfunc_sum') +assert(old_cfunc_nop['debug_module_ptr'] == old_module_ptr) +assert(old_cfunc_fetch_seq_evens['debug_module_ptr'] == old_module_ptr) +assert(old_cfunc_multireturn['debug_module_ptr'] == old_module_ptr) +assert(old_cfunc_args['debug_module_ptr'] == old_module_ptr) +assert(old_cfunc_sum['debug_module_ptr'] == old_module_ptr) +assert(old_module['debug_refs'] == 6) + +-- Lookup for updated symbols. +new_cfunc_nop = new_module:load('cfunc_nop') +new_cfunc_fetch_seq_evens = new_module:load('cfunc_fetch_seq_evens') +new_cfunc_multireturn = new_module:load('cfunc_multireturn') +new_cfunc_args = new_module:load('cfunc_args') +new_cfunc_sum = new_module:load('cfunc_sum') +assert(new_cfunc_nop['debug_module_ptr'] == new_module_ptr) +assert(new_cfunc_fetch_seq_evens['debug_module_ptr'] == new_module_ptr) +assert(new_cfunc_multireturn['debug_module_ptr'] == new_module_ptr) +assert(new_cfunc_args['debug_module_ptr'] == new_module_ptr) +assert(new_cfunc_sum['debug_module_ptr'] == new_module_ptr) +assert(new_module['debug_refs'] == 6) + +-- Call old functions. +old_cfunc_nop() +old_cfunc_fetch_seq_evens() +old_cfunc_multireturn() +old_cfunc_args() +old_cfunc_sum() + +-- Call new functions. +new_cfunc_nop() +new_cfunc_multireturn() +new_cfunc_fetch_seq_evens({2,4,6}) +new_cfunc_fetch_seq_evens({1,2,3}) -- error, odd numbers sequence +new_cfunc_args(1, "hello") +new_cfunc_sum(1) -- error, one arg passed +new_cfunc_sum(1,2) + +-- Cleanup old module's functions. +old_cfunc_nop:unload() +old_cfunc_fetch_seq_evens:unload() +old_cfunc_multireturn:unload() +old_cfunc_args:unload() +old_cfunc_sum:unload() +old_module:unload() + +-- Cleanup new module data. +new_cfunc_nop:unload() +new_cfunc_multireturn:unload() +new_cfunc_fetch_seq_evens:unload() +new_cfunc_args:unload() +new_cfunc_sum:unload() +new_module:unload() + +-- Cleanup the generated symlink. +_ = pcall(fio.unlink(cfunc_path)) + +-- Test double hashing: create function +-- in box.schema.fun so that it should +-- appear in box.lib hash. +fio.symlink(cfunc3_path, cfunc_path) +box.schema.func.create('cfunc.cfunc_add', {language = "C"}) +box.schema.user.grant('guest', 'execute', 'function', 'cfunc.cfunc_add') +box.func['cfunc.cfunc_add']:call({1,2}) + +old_module = boxlib.load('cfunc') +assert(old_module['debug_refs'] == 3) -- box.lib + 2 box.schema.func +old_func = old_module:load('cfunc_add') +assert(old_module['debug_refs'] == 4) -- plus function instance +old_func(1,2) + +-- Now update on disk and reload the module. +_ = pcall(fio.unlink(cfunc_path)) +fio.symlink(cfunc4_path, cfunc_path) + +box.schema.func.reload("cfunc") +box.func['cfunc.cfunc_add']:call({1,2}) + +-- The box.lib instance should carry own +-- references to the module and old +-- function. And reloading must not +-- affect old functions. Thus one for +-- box.lib and one for box.lib function. +assert(old_module['debug_refs'] == 2) +old_func(1,2) +old_func:unload() +old_module:unload() + +-- Same time the reload should update +-- low level module cache, thus two +-- for box and box function plus one +-- new box.lib. +new_module = boxlib.load('cfunc') +assert(new_module['debug_refs'] == 3) + +-- Box function should carry own module. +box.func['cfunc.cfunc_add']:call({1,2}) + +-- Cleanup. +_ = pcall(fio.unlink(cfunc_path)) +new_module:unload() +box.schema.func.drop('cfunc.cfunc_add') diff --git a/test/box/suite.ini b/test/box/suite.ini index d5f72e559..f82115605 100644 --- a/test/box/suite.ini +++ b/test/box/suite.ini @@ -2,7 +2,7 @@ core = tarantool description = Database tests script = box.lua -disabled = rtree_errinj.test.lua tuple_bench.test.lua +disabled = rtree_errinj.test.lua tuple_bench.test.lua lib.test.lua long_run = huge_field_map_long.test.lua config = engine.cfg release_disabled = errinj.test.lua errinj_index.test.lua rtree_errinj.test.lua upsert_errinj.test.lua iproto_stress.test.lua gh-4648-func-load-unload.test.lua -- 2.30.2