10580740899

Committed 26 Aug 2024 07:47PM UTC coverage: 87.224% (+0.02%) from 87.205%

Build # 10580740899

Build Type

push

github

Committed by

Gerold103

Commit Message

test: fix #5430 test

The test blocked on the `wait_log` for registering replica2 on the master
node. The `wait_log` does not throw an error on timeout, and its return
value is ignored in the test, so the test simply continued after the
timeout and succeeded.

The reason the test blocked was that after 70a6883 we are unable to
register an anonymous replica while its relay has not stopped:
https://github.com/tarantool/tarantool/blob/<a class=hub.com/tarantool/tarantool/commit/<a class="double-link" href="https://git"><a class=hub.com/tarantool/tarantool/commit/9e616ab6f2f94ba2bcad3044187c474a1c05a8c5">9e616ab6f/src/box/box.cc#L4422-L4427

At the same time, the anonymous replica's relay cannot finish, because it
is blocked by `cbus_unpair` in `wal_clear_watcher`:
https://github.com/tarantool/tarantool/blob/9e616ab6f2f94ba2bcad3044187c474a1c05a8c5/src/box/relay.cc#L1068-L1074
https://github.com/tarantool/tarantool/blob/9e616ab6f2f94ba2bcad3044187c474a1c05a8c5/src/lib/core/cbus.h#L440-L442

To fix this let's move `ERRINJ_REPLICA_JOIN_DELAY` before
`box_register_replica`. This error injection is not used right now, so we
can reuse it here instead of `ERRINJ_WAL_DELAY`. This way the WAL won't get
blocked, and we will be able to get 2 concurrent replica registrations.

Let's also echo the `wait_log` result to make sure the fails in the future.

Closes #9617

NO_CHANGELOG=<test fix>
NO_DOC=<test fix>

Run Details

68358 of 121593 branches covered (56.22%)

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

242 existing lines in 17 files now uncovered.

101017 of 115813 relevant lines covered (87.22%)

2464496.47 hits per line

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

97.94

/src/lib/vclock/vclock.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 "vclock.h"

#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>

#include "diag.h"
#include "tt_static.h"

int64_t
vclock_follow(struct vclock *vclock, uint32_t replica_id, int64_t lsn)
{
        assert(lsn >= 0);
        assert(replica_id < VCLOCK_MAX);
        int64_t prev_lsn = vclock_get(vclock, replica_id);
        assert(lsn > prev_lsn);
        /* Easier add each time than check. */
        vclock->map |= 1U << replica_id;
        vclock->lsn[replica_id] = lsn;
        vclock->signature += lsn - prev_lsn;
        return prev_lsn;
}

static int
vclock_snprint(char *buf, int size, const struct vclock *vclock)
{
        int total = 0;
        SNPRINT(total, snprintf, buf, size, "{");

        const char *sep = "";
        struct vclock_iterator it;
        vclock_iterator_init(&it, vclock);
        vclock_foreach(&it, replica) {
                SNPRINT(total, snprintf, buf, size, "%s%u: %lld",
                        sep, (unsigned)replica.id, (long long)replica.lsn);
                sep = ", ";
        }

        SNPRINT(total, snprintf, buf, size, "}");
        return total;
}

const char *
vclock_to_string(const struct vclock *vclock)
{
        char *buf = tt_static_buf();
        if (vclock_snprint(buf, TT_STATIC_BUF_LEN, vclock) < 0)
                return "<failed to format vclock>";
        return buf;
}

size_t
vclock_from_string(struct vclock *vclock, const char *str)
{
        long replica_id;
        long long lsn;

        const char *p = str;
        begin:
                if (*p == '{') {
                        ++p;
                        goto key;
                } else if (isblank(*p)) {
                        ++p;
                        goto begin;
                }
                goto error;
        key:
                if (isdigit(*p)) {
                        errno = 0;
                        replica_id = strtol(p, (char **) &p, 10);
                        if (errno != 0 || replica_id < 0 || replica_id >= VCLOCK_MAX)
                                goto error;
                        goto sep;
                } else if (*p == '}') {
                        ++p;
                        goto end;
                } else if (isblank(*p)) {
                        ++p;
                        goto key;
                }
                goto error;
        sep:
                if (*p == ':') {
                        ++p;
                        goto val;
                } else if (isblank(*p)) {
                        ++p;
                        goto sep;
                }
                goto error;
        val:
                if (isblank(*p)) {
                        ++p;
                        goto val;
                } else if (isdigit(*p)) {
                        errno = 0;
                        lsn = strtoll(p, (char **)  &p, 10);
                        if (errno != 0 || lsn < 0 || lsn > INT64_MAX ||
                            replica_id >= VCLOCK_MAX ||
                            vclock_get(vclock, replica_id) > 0)
                                goto error;
                        vclock->map |= 1U << replica_id;
                        vclock->lsn[replica_id] = lsn;
                        goto comma;
                }
                goto error;
        comma:
                if (isspace(*p)) {
                        ++p;
                        goto comma;
                } else if (*p == '}') {
                        ++p;
                        goto end;
                } else if (*p == ',') {
                        ++p;
                        goto key;
                }
                goto error;
        end:
                if (*p == '\0') {
                        vclock->signature = vclock_calc_sum(vclock);
                        return 0;
                } else if (isblank(*p)) {
                        ++p;
                        goto end;
                }
                /* goto error; */
        error:
                return p - str + 1; /* error */
}

static int
vclockset_node_compare(const struct vclock *a, const struct vclock *b)
{
        int res = vclock_compare(a, b);
        /*
         * In a vclock set, we do not allow clocks which are not
         * strictly ordered.
         * See also xdir_scan(), in which we check & skip
         * duplicate vclocks.
         */
        if (res == VCLOCK_ORDER_UNDEFINED)
                return 0;
        return res;
}

rb_gen(, vclockset_, vclockset_t, struct vclock, link, vclockset_node_compare);

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	#include "vclock.h"
32
33	#include <stdio.h>
34	#include <stdarg.h>
35	#include <ctype.h>
36
37	#include "diag.h"
38	#include "tt_static.h"
39
40	int64_t
41	vclock_follow(struct vclock *vclock, uint32_t replica_id, int64_t lsn)	4,983,990✔
42	{
43	assert(lsn >= 0);	4,983,990!
44	assert(replica_id < VCLOCK_MAX);	4,983,990!
45	int64_t prev_lsn = vclock_get(vclock, replica_id);	4,983,990✔
46	assert(lsn > prev_lsn);	4,983,980✔
47	/* Easier add each time than check. */
48	vclock->map \|= 1U << replica_id;	4,983,980✔
49	vclock->lsn[replica_id] = lsn;	4,983,980✔
50	vclock->signature += lsn - prev_lsn;	4,983,980✔
51	return prev_lsn;	4,983,980✔
52	}
53
54	static int
55	vclock_snprint(char buf, int size, const struct vclock vclock)	30,022✔
56	{
57	int total = 0;	30,022✔
58	SNPRINT(total, snprintf, buf, size, "{");	60,044!
59
60	const char *sep = "";	30,022✔
61	struct vclock_iterator it;
62	vclock_iterator_init(&it, vclock);	30,022!
63	vclock_foreach(&it, replica) {	56,284!
64	SNPRINT(total, snprintf, buf, size, "%s%u: %lld",	26,262!
65	sep, (unsigned)replica.id, (long long)replica.lsn);
66	sep = ", ";	26,262!
67	}
68
69	SNPRINT(total, snprintf, buf, size, "}");	30,022!
70	return total;	30,022✔
71	}
72
73	const char *
74	vclock_to_string(const struct vclock *vclock)	30,022✔
75	{
76	char *buf = tt_static_buf();	30,022✔
77	if (vclock_snprint(buf, TT_STATIC_BUF_LEN, vclock) < 0)	30,022!
78	return "<failed to format vclock>";	×
79	return buf;	30,022✔
80	}
81
82	size_t
83	vclock_from_string(struct vclock vclock, const char str)	25,610✔
84	{
85	long replica_id;
86	long long lsn;
87
88	const char *p = str;	25,610✔
89	begin:	25,622✔
90	if (*p == '{') {	25,622✔
91	++p;	25,602✔
92	goto key;	25,602✔
93	} else if (isblank(*p)) {	20✔
94	++p;	12✔
95	goto begin;	12✔
96	}
97	goto error;	8✔
98	key:	30,772✔
99	if (isdigit(*p)) {	30,772✔
100	errno = 0;	18,316✔
101	replica_id = strtol(p, (char **) &p, 10);	18,316✔
102	if (errno != 0 \|\| replica_id < 0 \|\| replica_id >= VCLOCK_MAX)	18,315!
UNCOV 103	goto error;	×
104	goto sep;	18,315✔
105	} else if (*p == '}') {	12,456✔
106	++p;	9,863✔
107	goto end;	9,863✔
108	} else if (isblank(*p)) {	2,593✔
109	++p;	2,587✔
110	goto key;	2,587✔
111	}
112	goto error;	6✔
113	sep:	18,319✔
114	if (*p == ':') {	18,319✔
115	++p;	18,312✔
116	goto val;	18,312✔
117	} else if (isblank(*p)) {	7✔
118	++p;	4✔
119	goto sep;	4✔
120	}
121	goto error;	3✔
122	val:	36,607✔
123	if (isblank(*p)) {	36,607✔
124	++p;	18,295✔
125	goto val;	18,295✔
126	} else if (isdigit(*p)) {	18,312✔
127	errno = 0;	18,305✔
128	lsn = strtoll(p, (char **) &p, 10);	18,305✔
129	if (errno != 0 \|\| lsn < 0 \|\| lsn > INT64_MAX \|\|	18,307!
130	replica_id >= VCLOCK_MAX \|\|	18,302✔
131	vclock_get(vclock, replica_id) > 0)	18,302!
132	goto error;	7✔
133	vclock->map \|= 1U << replica_id;	18,300✔
134	vclock->lsn[replica_id] = lsn;	18,300✔
135	goto comma;	18,300✔
136	}
137	goto error;	7✔
138	comma:	18,305✔
139	if (isspace(*p)) {	18,305✔
140	++p;	5✔
141	goto comma;	5✔
142	} else if (*p == '}') {	18,300✔
143	++p;	15,716✔
144	goto end;	15,716✔
145	} else if (*p == ',') {	2,584✔
146	++p;	2,583✔
147	goto key;	2,583✔
148	}
149	goto error;	1✔
150	end:	25,579✔
151	if (*p == '\0') {	25,583✔
152	vclock->signature = vclock_calc_sum(vclock);	25,578!
153	return 0;	25,613✔
154	} else if (isblank(*p)) {	5✔
155	++p;	4✔
156	goto end;	4✔
157	}
158	/* goto error; */
159	error:	1✔
160	return p - str + 1; /* error */	33✔
161	}
162
163	static int
164	vclockset_node_compare(const struct vclock a, const struct vclock b)	180,508✔
165	{
166	int res = vclock_compare(a, b);	180,508✔
167	/*
168	* In a vclock set, we do not allow clocks which are not
169	* strictly ordered.
170	* See also xdir_scan(), in which we check & skip
171	* duplicate vclocks.
172	*/
173	if (res == VCLOCK_ORDER_UNDEFINED)	180,525✔
174	return 0;	49✔
175	return res;	180,476✔
176	}
177
178	rb_gen(, vclockset_, vclockset_t, struct vclock, link, vclockset_node_compare);	384,735!

tarantool / tarantool / 10580740899

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