From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Vladimir Davydov Subject: [PATCH v2 01/11] box: retrieve instance uuid before starting local recovery Date: Fri, 8 Jun 2018 20:34:19 +0300 Message-Id: In-Reply-To: References: In-Reply-To: References: To: kostja@tarantool.org Cc: tarantool-patches@freelists.org List-ID: In order to find out if the current instance fell too much behind its peers in the cluster and so needs to be rebootstrapped, we need to connect it to remote peers before proceeding to local recovery. The problem is box.cfg.replication may have an entry corresponding to the instance itself so before connecting we have to start listening to incoming connections. Since an instance is supposed to sent its uuid in the greeting message, we also have to initialize INSTANCE_UUID early, before we start local recovery. So this patch makes memtx engine constructor not only scan the snapshot directory, but also read the header of the most recent snapshot to initialize INSTANCE_UUID. Needed for #461 --- src/box/box.cc | 18 ++++++++++-------- src/box/memtx_engine.c | 21 ++++++++++++++++++++- 2 files changed, 30 insertions(+), 9 deletions(-) diff --git a/src/box/box.cc b/src/box/box.cc index 61bfa117..e1bf3934 100644 --- a/src/box/box.cc +++ b/src/box/box.cc @@ -1839,6 +1839,15 @@ box_cfg_xc(void) } bool is_bootstrap_leader = false; if (last_checkpoint_lsn >= 0) { + /* Check instance UUID. */ + assert(!tt_uuid_is_nil(&INSTANCE_UUID)); + if (!tt_uuid_is_nil(&instance_uuid) && + !tt_uuid_is_equal(&instance_uuid, &INSTANCE_UUID)) { + tnt_raise(ClientError, ER_INSTANCE_UUID_MISMATCH, + tt_uuid_str(&instance_uuid), + tt_uuid_str(&INSTANCE_UUID)); + } + struct wal_stream wal_stream; wal_stream_create(&wal_stream, cfg_geti64("rows_per_wal")); @@ -1882,7 +1891,6 @@ box_cfg_xc(void) cfg_getd("wal_dir_rescan_delay")); title("hot_standby"); - assert(!tt_uuid_is_nil(&INSTANCE_UUID)); /* * Leave hot standby mode, if any, only * after acquiring the lock. @@ -1902,13 +1910,7 @@ box_cfg_xc(void) recovery_finalize(recovery, &wal_stream.base); engine_end_recovery_xc(); - /* Check replica set and instance UUID. */ - if (!tt_uuid_is_nil(&instance_uuid) && - !tt_uuid_is_equal(&instance_uuid, &INSTANCE_UUID)) { - tnt_raise(ClientError, ER_INSTANCE_UUID_MISMATCH, - tt_uuid_str(&instance_uuid), - tt_uuid_str(&INSTANCE_UUID)); - } + /* Check replica set UUID. */ if (!tt_uuid_is_nil(&replicaset_uuid) && !tt_uuid_is_equal(&replicaset_uuid, &REPLICASET_UUID)) { tnt_raise(ClientError, ER_REPLICASET_UUID_MISMATCH, diff --git a/src/box/memtx_engine.c b/src/box/memtx_engine.c index fac84ce1..de9fd1ba 100644 --- a/src/box/memtx_engine.c +++ b/src/box/memtx_engine.c @@ -164,7 +164,6 @@ memtx_engine_recover_snapshot(struct memtx_engine *memtx, struct xlog_cursor cursor; if (xlog_cursor_open(&cursor, filename) < 0) return -1; - INSTANCE_UUID = cursor.meta.instance_uuid; int rc; struct xrow_header row; @@ -1001,6 +1000,26 @@ memtx_engine_new(const char *snap_dirname, bool force_recovery, if (xdir_scan(&memtx->snap_dir) != 0) goto fail; + /* + * To check if the instance needs to be rebootstrapped, we + * need to connect it to remote peers before proceeding to + * local recovery. In order to do that, we have to start + * listening for incoming connections, because one of remote + * peers may be self. This, in turn, requires us to know the + * instance UUID, as it is a part of a greeting message. + * So if the local directory isn't empty, read the snapshot + * signature right now to initialize the instance UUID. + */ + int64_t snap_signature = xdir_last_vclock(&memtx->snap_dir, NULL); + if (snap_signature >= 0) { + struct xlog_cursor cursor; + if (xdir_open_cursor(&memtx->snap_dir, + snap_signature, &cursor) != 0) + goto fail; + INSTANCE_UUID = cursor.meta.instance_uuid; + xlog_cursor_close(&cursor, false); + } + stailq_create(&memtx->gc_queue); memtx->gc_fiber = fiber_new("memtx.gc", memtx_engine_gc_f); if (memtx->gc_fiber == NULL) -- 2.11.0