21338668454

Committed 25 Jan 2026 08:00PM UTC coverage: 73.505% (-15.0%) from 88.463%

Build # 21338668454

Build Type

Pull #477

github

Committed by

ita-sammann

Commit Message

test: dump xlogs and snaps for debug

Pull Request Pull Request #477: test: attempt to mitigate replication bug on cluster start

Run Details

1 of 2 new or added lines in 1 file covered. (50.0%)

856 existing lines in 47 files now uncovered.

4253 of 5786 relevant lines covered (73.51%)

55.54 hits per line

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

82.52

/crud/delete.lua

local checks = require('checks')
local errors = require('errors')

local call = require('crud.common.call')
local const = require('crud.common.const')
local utils = require('crud.common.utils')
local sharding = require('crud.common.sharding')
local sharding_key_module = require('crud.common.sharding.sharding_key')
local sharding_metadata_module = require('crud.common.sharding.sharding_metadata')
local dev_checks = require('crud.common.dev_checks')
local schema = require('crud.common.schema')
local bucket_ref_unref = require('crud.common.sharding.bucket_ref_unref')

local DeleteError = errors.new_class('DeleteError', {capture_stack = false})

local delete = {}

local DELETE_FUNC_NAME = 'delete_on_storage'
local CRUD_DELETE_FUNC_NAME = utils.get_storage_call(DELETE_FUNC_NAME)

local function delete_on_storage(space_name, key, field_names, opts)
    dev_checks('string', '?', '?table', {
        bucket_id = 'number|cdata',
        sharding_key_hash = '?number',
        sharding_func_hash = '?number',
        skip_sharding_hash_check = '?boolean',
        noreturn = '?boolean',
        fetch_latest_metadata = '?boolean',
    })

    opts = opts or {}

    local space = box.space[space_name]
    if space == nil then
        return nil, DeleteError:new("Space %q doesn't exist", space_name)
    end

    local _, err = sharding.check_sharding_hash(space_name,
                                                opts.sharding_func_hash,
                                                opts.sharding_key_hash,
                                                opts.skip_sharding_hash_check)

    if err ~= nil then
        return nil, err
    end

    local ref_ok, bucket_ref_err, unref = bucket_ref_unref.bucket_refrw(opts.bucket_id, space.engine)
    if not ref_ok then
        return nil, bucket_ref_err
    end

    -- add_space_schema_hash is false because
    -- reloading space format on router can't avoid delete error on storage
    local result =  schema.wrap_func_result(space, space.delete, {
        add_space_schema_hash = false,
        field_names = field_names,
        noreturn = opts.noreturn,
        fetch_latest_metadata = opts.fetch_latest_metadata,
    }, space, key)

    local unref_ok, err_unref = unref(opts.bucket_id, space.engine)
    if not unref_ok then
        return nil, err_unref
    end

    return result
end

delete.storage_api = {[DELETE_FUNC_NAME] = delete_on_storage}

-- returns result, err, need_reload
-- need_reload indicates if reloading schema could help
-- see crud.common.schema.wrap_func_reload()
local function call_delete_on_router(vshard_router, space_name, key, opts)
    dev_checks('table', 'string', '?', {
        timeout = '?number',
        bucket_id = '?',
        fields = '?table',
        vshard_router = '?string|table',
        noreturn = '?boolean',
        fetch_latest_metadata = '?boolean',
    })

    local space, err, netbox_schema_version = utils.get_space(space_name, vshard_router, opts.timeout)
    if err ~= nil then
        return nil, DeleteError:new("An error occurred during the operation: %s", err), const.NEED_SCHEMA_RELOAD
    end
    if space == nil then
        return nil, DeleteError:new("Space %q doesn't exist", space_name), const.NEED_SCHEMA_RELOAD
    end

    if box.tuple.is(key) then
        key = key:totable()
    end

    local sharding_key_hash = nil
    local skip_sharding_hash_check = nil

    local sharding_key = key
    if opts.bucket_id == nil then
        if space.index[0] == nil then
            return nil, DeleteError:new("Cannot fetch primary index parts"), const.NEED_SCHEMA_RELOAD
        end
        local primary_index_parts = space.index[0].parts

        local sharding_key_data, err = sharding_metadata_module.fetch_sharding_key_on_router(vshard_router, space_name)
        if err ~= nil then
            return nil, err
        end

        sharding_key, err = sharding_key_module.extract_from_pk(vshard_router,
                                                                space_name,
                                                                sharding_key_data.value,
                                                                primary_index_parts, key)
        if err ~= nil then
            return nil, err
        end

        sharding_key_hash = sharding_key_data.hash
    else
        skip_sharding_hash_check = true
    end

    local bucket_id_data, err = sharding.key_get_bucket_id(vshard_router, space_name, sharding_key, opts.bucket_id)
    if err ~= nil then
        return nil, err
    end

    -- When the sharding index (bucket_id) is the primary index, bucket_id can be passed as box.NULL.
    sharding.fill_bucket_id_pk(space, key, bucket_id_data.bucket_id)

    local delete_on_storage_opts = {
        bucket_id = bucket_id_data.bucket_id,
        sharding_func_hash = bucket_id_data.sharding_func_hash,
        sharding_key_hash = sharding_key_hash,
        skip_sharding_hash_check = skip_sharding_hash_check,
        noreturn = opts.noreturn,
        fetch_latest_metadata = opts.fetch_latest_metadata,
    }

    local call_opts = {
        mode = 'write',
        timeout = opts.timeout,
    }

    local storage_result, err = call.single(vshard_router,
        bucket_id_data.bucket_id, CRUD_DELETE_FUNC_NAME,
        {space_name, key, opts.fields, delete_on_storage_opts},
        call_opts
    )

    if err ~= nil then
        local err_wrapped = DeleteError:new("Failed to call delete on storage-side: %s", err)

        if sharding.result_needs_sharding_reload(err) then
            return nil, err_wrapped, const.NEED_SHARDING_RELOAD
        end

        return nil, err_wrapped
    end

    if storage_result.err ~= nil then
        return nil, DeleteError:new("Failed to delete: %s", storage_result.err)
    end

    if opts.noreturn == true then
        return nil
    end

    local tuple = storage_result.res

    if opts.fetch_latest_metadata == true then
        -- This option is temporary and is related to [1], [2].
        -- [1] https://github.com/tarantool/crud/issues/236
        -- [2] https://github.com/tarantool/crud/issues/361
        space = utils.fetch_latest_metadata_when_single_storage(space, space_name, netbox_schema_version,
                                                                vshard_router, opts, storage_result.storage_info)
    end

    return utils.format_result({tuple}, space, opts.fields)
end

--- Deletes tuple from the specified space by key
--
-- @function call
--
-- @param string space_name
--  A space name
--
-- @param key
--  Primary key value
--
-- @tparam ?number opts.timeout
--  Function call timeout
--
-- @tparam ?number opts.bucket_id
--  Bucket ID
--  (by default, it's vshard.router.bucket_id_strcrc32 of primary key)
--
-- @tparam ?string|table opts.vshard_router
--  Cartridge vshard group name or vshard router instance.
--  Set this parameter if your space is not a part of the
--  default vshard cluster.
--
-- @tparam ?boolean opts.noreturn
--  Suppress returning successfully processed tuple.
--
-- @return[1] object
-- @treturn[2] nil
-- @treturn[2] table Error description
--
function delete.call(space_name, key, opts)
    checks('string', '?', {
        timeout = '?number',
        bucket_id = '?',
        fields = '?table',
        vshard_router = '?string|table',
        noreturn = '?boolean',
        fetch_latest_metadata = '?boolean',
    })

    opts = opts or {}

    local vshard_router, err = utils.get_vshard_router_instance(opts.vshard_router)
    if err ~= nil then
        return nil, DeleteError:new(err)
    end

    return schema.wrap_func_reload(vshard_router, sharding.wrap_method, call_delete_on_router,
                                   space_name, key, opts)
end

return delete

1	local checks = require('checks')	19✔
2	local errors = require('errors')	19✔
3
4	local call = require('crud.common.call')	19✔
5	local const = require('crud.common.const')	19✔
6	local utils = require('crud.common.utils')	19✔
7	local sharding = require('crud.common.sharding')	19✔
8	local sharding_key_module = require('crud.common.sharding.sharding_key')	19✔
9	local sharding_metadata_module = require('crud.common.sharding.sharding_metadata')	19✔
10	local dev_checks = require('crud.common.dev_checks')	19✔
11	local schema = require('crud.common.schema')	19✔
12	local bucket_ref_unref = require('crud.common.sharding.bucket_ref_unref')	19✔
13
14	local DeleteError = errors.new_class('DeleteError', {capture_stack = false})	19✔
15
16	local delete = {}	19✔
17
18	local DELETE_FUNC_NAME = 'delete_on_storage'	19✔
19	local CRUD_DELETE_FUNC_NAME = utils.get_storage_call(DELETE_FUNC_NAME)	19✔
20
21	local function delete_on_storage(space_name, key, field_names, opts)
22	dev_checks('string', '?', '?table', {	4✔
23	bucket_id = 'number\|cdata',
24	sharding_key_hash = '?number',
25	sharding_func_hash = '?number',
26	skip_sharding_hash_check = '?boolean',
27	noreturn = '?boolean',
28	fetch_latest_metadata = '?boolean',
29	})
30
31	opts = opts or {}	4✔
32
33	local space = box.space[space_name]	4✔
34	if space == nil then	4✔
35	return nil, DeleteError:new("Space %q doesn't exist", space_name)	×
36	end
37
38	local _, err = sharding.check_sharding_hash(space_name,	8✔
39	opts.sharding_func_hash,	4✔
40	opts.sharding_key_hash,	4✔
41	opts.skip_sharding_hash_check)	4✔
42
43	if err ~= nil then	4✔
UNCOV 44	return nil, err	×
45	end
46
47	local ref_ok, bucket_ref_err, unref = bucket_ref_unref.bucket_refrw(opts.bucket_id, space.engine)	4✔
48	if not ref_ok then	4✔
49	return nil, bucket_ref_err	×
50	end
51
52	-- add_space_schema_hash is false because
53	-- reloading space format on router can't avoid delete error on storage
54	local result = schema.wrap_func_result(space, space.delete, {	8✔
55	add_space_schema_hash = false,
56	field_names = field_names,	4✔
57	noreturn = opts.noreturn,	4✔
58	fetch_latest_metadata = opts.fetch_latest_metadata,	4✔
59	}, space, key)	4✔
60
61	local unref_ok, err_unref = unref(opts.bucket_id, space.engine)	4✔
62	if not unref_ok then	4✔
63	return nil, err_unref	×
64	end
65
66	return result	4✔
67	end
68
69	delete.storage_api = {[DELETE_FUNC_NAME] = delete_on_storage}	19✔
70
71	-- returns result, err, need_reload
72	-- need_reload indicates if reloading schema could help
73	-- see crud.common.schema.wrap_func_reload()
74	local function call_delete_on_router(vshard_router, space_name, key, opts)
75	dev_checks('table', 'string', '?', {	8✔
76	timeout = '?number',
77	bucket_id = '?',
78	fields = '?table',
79	vshard_router = '?string\|table',
80	noreturn = '?boolean',
81	fetch_latest_metadata = '?boolean',
82	})
83
84	local space, err, netbox_schema_version = utils.get_space(space_name, vshard_router, opts.timeout)	8✔
85	if err ~= nil then	8✔
86	return nil, DeleteError:new("An error occurred during the operation: %s", err), const.NEED_SCHEMA_RELOAD	×
87	end
88	if space == nil then	8✔
89	return nil, DeleteError:new("Space %q doesn't exist", space_name), const.NEED_SCHEMA_RELOAD	8✔
90	end
91
92	if box.tuple.is(key) then	8✔
93	key = key:totable()	×
94	end
95
96	local sharding_key_hash = nil	4✔
97	local skip_sharding_hash_check = nil
98
99	local sharding_key = key	4✔
100	if opts.bucket_id == nil then	4✔
101	if space.index[0] == nil then	4✔
102	return nil, DeleteError:new("Cannot fetch primary index parts"), const.NEED_SCHEMA_RELOAD	×
103	end
104	local primary_index_parts = space.index[0].parts	4✔
105
106	local sharding_key_data, err = sharding_metadata_module.fetch_sharding_key_on_router(vshard_router, space_name)	4✔
107	if err ~= nil then	4✔
108	return nil, err	×
109	end
110
111	sharding_key, err = sharding_key_module.extract_from_pk(vshard_router,	8✔
112	space_name,	4✔
113	sharding_key_data.value,	4✔
114	primary_index_parts, key)	8✔
115	if err ~= nil then	4✔
UNCOV 116	return nil, err	×
117	end
118
119	sharding_key_hash = sharding_key_data.hash	4✔
120	else
UNCOV 121	skip_sharding_hash_check = true	×
122	end
123
124	local bucket_id_data, err = sharding.key_get_bucket_id(vshard_router, space_name, sharding_key, opts.bucket_id)	4✔
125	if err ~= nil then	4✔
UNCOV 126	return nil, err	×
127	end
128
129	-- When the sharding index (bucket_id) is the primary index, bucket_id can be passed as box.NULL.
130	sharding.fill_bucket_id_pk(space, key, bucket_id_data.bucket_id)	4✔
131
132	local delete_on_storage_opts = {	4✔
133	bucket_id = bucket_id_data.bucket_id,	4✔
134	sharding_func_hash = bucket_id_data.sharding_func_hash,	4✔
135	sharding_key_hash = sharding_key_hash,	4✔
136	skip_sharding_hash_check = skip_sharding_hash_check,	4✔
137	noreturn = opts.noreturn,	4✔
138	fetch_latest_metadata = opts.fetch_latest_metadata,	4✔
139	}
140
141	local call_opts = {	4✔
142	mode = 'write',
143	timeout = opts.timeout,	4✔
144	}
145
146	local storage_result, err = call.single(vshard_router,	8✔
147	bucket_id_data.bucket_id, CRUD_DELETE_FUNC_NAME,	4✔
148	{space_name, key, opts.fields, delete_on_storage_opts},	4✔
149	call_opts
150	)	4✔
151
152	if err ~= nil then	4✔
UNCOV 153	local err_wrapped = DeleteError:new("Failed to call delete on storage-side: %s", err)	×
154
UNCOV 155	if sharding.result_needs_sharding_reload(err) then	×
UNCOV 156	return nil, err_wrapped, const.NEED_SHARDING_RELOAD	×
157	end
158
159	return nil, err_wrapped	×
160	end
161
162	if storage_result.err ~= nil then	4✔
UNCOV 163	return nil, DeleteError:new("Failed to delete: %s", storage_result.err)	×
164	end
165
166	if opts.noreturn == true then	4✔
UNCOV 167	return nil	×
168	end
169
170	local tuple = storage_result.res	4✔
171
172	if opts.fetch_latest_metadata == true then	4✔
173	-- This option is temporary and is related to [1], [2].
174	-- [1] https://github.com/tarantool/crud/issues/236
175	-- [2] https://github.com/tarantool/crud/issues/361
176	space = utils.fetch_latest_metadata_when_single_storage(space, space_name, netbox_schema_version,
UNCOV 177	vshard_router, opts, storage_result.storage_info)	×
178	end
179
180	return utils.format_result({tuple}, space, opts.fields)	4✔
181	end
182
183	--- Deletes tuple from the specified space by key
184	--
185	-- @function call
186	--
187	-- @param string space_name
188	-- A space name
189	--
190	-- @param key
191	-- Primary key value
192	--
193	-- @tparam ?number opts.timeout
194	-- Function call timeout
195	--
196	-- @tparam ?number opts.bucket_id
197	-- Bucket ID
198	-- (by default, it's vshard.router.bucket_id_strcrc32 of primary key)
199	--
200	-- @tparam ?string\|table opts.vshard_router
201	-- Cartridge vshard group name or vshard router instance.
202	-- Set this parameter if your space is not a part of the
203	-- default vshard cluster.
204	--
205	-- @tparam ?boolean opts.noreturn
206	-- Suppress returning successfully processed tuple.
207	--
208	-- @return[1] object
209	-- @treturn[2] nil
210	-- @treturn[2] table Error description
211	--
212	function delete.call(space_name, key, opts)	19✔
213	checks('string', '?', {	10✔
214	timeout = '?number',
215	bucket_id = '?',
216	fields = '?table',
217	vshard_router = '?string\|table',
218	noreturn = '?boolean',
219	fetch_latest_metadata = '?boolean',
220	})
221
222	opts = opts or {}	10✔
223
224	local vshard_router, err = utils.get_vshard_router_instance(opts.vshard_router)	10✔
225	if err ~= nil then	10✔
226	return nil, DeleteError:new(err)	8✔
227	end
228
229	return schema.wrap_func_reload(vshard_router, sharding.wrap_method, call_delete_on_router,	6✔
230	space_name, key, opts)	6✔
231	end
232
233	return delete	19✔

tarantool / crud / 21338668454

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