You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kvrocks.apache.org by ti...@apache.org on 2022/10/16 03:56:49 UTC

[incubator-kvrocks] branch unstable updated: Move TCL test integration/replication to Go case (#997)

This is an automated email from the ASF dual-hosted git repository.

tison pushed a commit to branch unstable
in repository https://gitbox.apache.org/repos/asf/incubator-kvrocks.git


The following commit(s) were added to refs/heads/unstable by this push:
     new 5474e15  Move TCL test integration/replication to Go case (#997)
5474e15 is described below

commit 5474e159ffa9fb5f2f5277f9d58e8e2b4b5d40df
Author: hulk <hu...@gmail.com>
AuthorDate: Sun Oct 16 11:56:44 2022 +0800

    Move TCL test integration/replication to Go case (#997)
    
    * Move TCL test integration/replication to Go case
    
    * Fix didn't send replication master auth if it's created in flight
    
    The root cause is we determined whether to send auth command or not on
    creating the replication state machine. If we add the master auth
    after creating the replication thread, it will nerver send auth command
    without recreating the replication state machine.
    
    * Resolve PR comments
    
    * Fix PR comments
    
    * Move replication test case into integration
---
 src/replication.cc                                 |  18 +-
 src/replication.h                                  |   3 +-
 .../integration/replication/replication_test.go    | 351 +++++++++++++++++++++
 tests/gocase/util/server.go                        |   9 +
 tests/tcl/tests/integration/replication.tcl        | 310 ------------------
 tests/tcl/tests/test_helper.tcl                    |   1 -
 6 files changed, 369 insertions(+), 323 deletions(-)

diff --git a/src/replication.cc b/src/replication.cc
index 9293a65..ced1cbb 100644
--- a/src/replication.cc
+++ b/src/replication.cc
@@ -178,17 +178,6 @@ void ReplicationThread::CallbacksStateMachine::SetWriteCB(bufferevent *bev, buff
   bufferevent_setcb(bev, nullptr, cb, ConnEventCB, state_machine_ptr);
 }
 
-ReplicationThread::CallbacksStateMachine::CallbacksStateMachine(
-    ReplicationThread *repl, ReplicationThread::CallbacksStateMachine::CallbackList &&handlers)
-    : repl_(repl), handlers_(std::move(handlers)) {
-  // Note: It may cause data races to use 'masterauth' directly.
-  // It is acceptable because password change is a low frequency operation.
-  if (!repl_->srv_->GetConfig()->masterauth.empty()) {
-    handlers_.emplace_front(CallbacksStateMachine::READ, "auth read", authReadCB);
-    handlers_.emplace_front(CallbacksStateMachine::WRITE, "auth write", authWriteCB);
-  }
-}
-
 void ReplicationThread::CallbacksStateMachine::EvCallback(bufferevent *bev, void *ctx) {
   auto self = static_cast<CallbacksStateMachine *>(ctx);
 LOOP_LABEL:
@@ -237,6 +226,13 @@ void ReplicationThread::CallbacksStateMachine::Start() {
     return;
   }
 
+  // Note: It may cause data races to use 'masterauth' directly.
+  // It is acceptable because password change is a low frequency operation.
+  if (!repl_->srv_->GetConfig()->masterauth.empty()) {
+    handlers_.emplace_front(CallbacksStateMachine::READ, "auth read", authReadCB);
+    handlers_.emplace_front(CallbacksStateMachine::WRITE, "auth write", authWriteCB);
+  }
+
   while (!repl_->stop_flag_ && bev == nullptr) {
     Status s = Util::SockConnect(repl_->host_, repl_->port_, &cfd);
     if (!s.IsOK()) {
diff --git a/src/replication.h b/src/replication.h
index 4ae484c..75159f4 100644
--- a/src/replication.h
+++ b/src/replication.h
@@ -111,7 +111,8 @@ class ReplicationThread {
     };
     using CallbackType = std::tuple<EventType, std::string, std::function<State(bufferevent *, void *)>>;
     using CallbackList = std::deque<CallbackType>;
-    CallbacksStateMachine(ReplicationThread *repl, CallbackList &&handlers);
+    CallbacksStateMachine(ReplicationThread *repl, CallbackList &&handlers)
+        : repl_(repl), handlers_(std::move(handlers)) {}
 
     void Start();
     void Stop();
diff --git a/tests/gocase/integration/replication/replication_test.go b/tests/gocase/integration/replication/replication_test.go
new file mode 100644
index 0000000..720c1ca
--- /dev/null
+++ b/tests/gocase/integration/replication/replication_test.go
@@ -0,0 +1,351 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package replication
+
+import (
+	"context"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/apache/incubator-kvrocks/tests/gocase/util"
+	"github.com/go-redis/redis/v9"
+	"github.com/stretchr/testify/require"
+)
+
+func TestReplicationLoading(t *testing.T) {
+	srvA := util.StartServer(t, map[string]string{})
+	defer srvA.Close()
+	rdbA := srvA.NewClient()
+	defer func() { require.NoError(t, rdbA.Close()) }()
+	util.Populate(t, rdbA, "", 100, 10)
+
+	srvB := util.StartServer(t, map[string]string{})
+	defer srvB.Close()
+	rdbB := srvB.NewClient()
+	defer func() { require.NoError(t, rdbB.Close()) }()
+
+	t.Run("Set instance A as slave of B", func(t *testing.T) {
+		ctx := context.Background()
+		require.NoError(t, rdbA.ConfigSet(ctx, "slave-empty-db-before-fullsync", "yes").Err())
+		require.NoError(t, rdbA.ConfigSet(ctx, "fullsync-recv-file-delay", "2").Err())
+		util.SlaveOf(t, rdbA, srvB)
+		// Become loading state in 5 second
+		require.Eventually(t, func() bool {
+			return util.FindInfoEntry(rdbA, "loading") == "1"
+		}, 5*time.Second, 50*time.Millisecond)
+
+		require.Eventually(t, func() bool {
+			return util.FindInfoEntry(rdbA, "loading") == "0"
+		}, 50*time.Second, 100*time.Millisecond)
+
+		// Reset config
+		time.Sleep(time.Second)
+		require.NoError(t, rdbA.ConfigSet(ctx, "slave-empty-db-before-fullsync", "no").Err())
+		require.NoError(t, rdbA.ConfigSet(ctx, "fullsync-recv-file-delay", "0").Err())
+		util.WaitForSync(t, rdbA)
+	})
+}
+
+func TestReplicationBasics(t *testing.T) {
+	master := util.StartServer(t, map[string]string{})
+	defer master.Close()
+	masterClient := master.NewClient()
+	defer func() { require.NoError(t, masterClient.Close()) }()
+
+	ctx := context.Background()
+	require.NoError(t, masterClient.Set(ctx, "mykey", "foo", 0).Err())
+	require.NoError(t, masterClient.Set(ctx, "mystring", "a", 0).Err())
+	require.NoError(t, masterClient.LPush(ctx, "mylist", "a", "b", "c").Err())
+	require.NoError(t, masterClient.SAdd(ctx, "myset", "a", "b", "c").Err())
+	require.NoError(t, masterClient.HMSet(ctx, "myhash", "a", 1, "b", 2, "c", 3).Err())
+	require.NoError(t, masterClient.ZAdd(ctx, "myzset",
+		redis.Z{Score: 1, Member: "a"},
+		redis.Z{Score: 2, Member: "b"},
+		redis.Z{Score: 3, Member: "c"},
+	).Err())
+
+	slave := util.StartServer(t, map[string]string{})
+	defer slave.Close()
+	slaveClient := slave.NewClient()
+	defer func() { require.NoError(t, slaveClient.Close()) }()
+
+	t.Run("Second server should have role master at first", func(t *testing.T) {
+		util.Populate(t, slaveClient, "", 100, 10)
+		require.Equal(t, "master", util.FindInfoEntry(slaveClient, "role"))
+	})
+
+	t.Run("The role should immediately be changed to 'replica'", func(t *testing.T) {
+		util.SlaveOf(t, slaveClient, master)
+		require.Equal(t, "slave", util.FindInfoEntry(slaveClient, "role"))
+	})
+
+	util.WaitForSync(t, slaveClient)
+	t.Run("Sync should have transferred keys from master", func(t *testing.T) {
+		require.Equal(t, masterClient.Get(ctx, "mykey"), slaveClient.Get(ctx, "mykey"))
+		require.Equal(t, masterClient.Get(ctx, "mystring"), slaveClient.Get(ctx, "mystring"))
+		require.Equal(t, masterClient.LRange(ctx, "mylist", 0, -1),
+			slaveClient.LRange(ctx, "mylist", 0, -1))
+		require.Equal(t, masterClient.HGetAll(ctx, "myhash"), slaveClient.HGetAll(ctx, "myhash"))
+		require.Equal(t, masterClient.ZRangeWithScores(ctx, "myzset", 0, -1),
+			slaveClient.ZRangeWithScores(ctx, "myzset", 0, -1))
+		require.Equal(t, masterClient.SMembers(ctx, "myhash"), slaveClient.SMembers(ctx, "myhash"))
+	})
+
+	t.Run("The link status should be up", func(t *testing.T) {
+		require.Equal(t, "up", util.FindInfoEntry(slaveClient, "master_link_status"))
+	})
+
+	t.Run("SET on the master should immediately propagate", func(t *testing.T) {
+		require.NoError(t, masterClient.Set(ctx, "mykey", "bar", 0).Err())
+		require.Eventually(t, func() bool {
+			return slaveClient.Get(ctx, "mykey").Val() == "bar"
+		}, 50*time.Second, 100*time.Millisecond)
+	})
+
+	t.Run("FLUSHALL should be replicated", func(t *testing.T) {
+		require.NoError(t, masterClient.FlushAll(ctx).Err())
+		time.Sleep(100 * time.Millisecond)
+		require.NoError(t, masterClient.Do(ctx, "dbsize", "scan").Err())
+		require.Eventually(t, func() bool {
+			masterDBSize, err := masterClient.Do(ctx, "dbsize").Result()
+			require.NoError(t, err)
+			slaveDBSize, err := slaveClient.Do(ctx, "dbsize").Result()
+			require.NoError(t, err)
+			return masterDBSize.(int64) == 0 && slaveDBSize.(int64) == 0
+		}, 5*time.Second, 100*time.Millisecond)
+	})
+
+	t.Run("ROLE in master reports master with a slave", func(t *testing.T) {
+		vals, err := masterClient.Do(ctx, "role").Slice()
+		require.NoError(t, err)
+		require.EqualValues(t, 3, len(vals))
+		// The order of vals in master is: role, offset, slaves
+		require.EqualValues(t, "master", vals[0])
+		masterOffset, err := strconv.Atoi(vals[1].(string))
+		require.NoError(t, err)
+		require.Greater(t, masterOffset, 0)
+		slaves, ok := vals[2].([]interface{})
+		require.True(t, ok)
+		require.EqualValues(t, 1, len(slaves))
+		slave0, _ := slaves[0].([]interface{})
+		require.EqualValues(t, 3, len(slave0))
+		slaveOffset, err := strconv.Atoi(slave0[2].(string))
+		require.NoError(t, err)
+		util.BetweenValues(t, slaveOffset, 1, masterOffset)
+	})
+
+	t.Run("ROLE in slave reports slave in connected state", func(t *testing.T) {
+		vals, err := slaveClient.Do(ctx, "role").StringSlice()
+		require.NoError(t, err)
+		require.EqualValues(t, 5, len(vals))
+		// The order of vals in slave is: role, master_host, master_port, slave_state, offset
+		require.Equal(t, "slave", vals[0])
+		require.Equal(t, "connected", vals[3])
+	})
+}
+
+func TestReplicationWithMultiSlaves(t *testing.T) {
+	srvA := util.StartServer(t, map[string]string{})
+	defer srvA.Close()
+	rdbA := srvA.NewClient()
+	defer func() { require.NoError(t, rdbA.Close()) }()
+	util.Populate(t, rdbA, "", 100, 10)
+
+	srvB := util.StartServer(t, map[string]string{})
+	defer srvB.Close()
+	rdbB := srvB.NewClient()
+	defer func() { require.NoError(t, rdbB.Close()) }()
+	util.Populate(t, rdbB, "", 100, 10)
+
+	srvC := util.StartServer(t, map[string]string{})
+	defer srvC.Close()
+	rdbC := srvC.NewClient()
+	defer func() { require.NoError(t, rdbC.Close()) }()
+	util.Populate(t, rdbC, "", 50, 10)
+
+	t.Run("Multi slaves full sync with master at the same time", func(t *testing.T) {
+		util.SlaveOf(t, rdbA, srvC)
+		util.SlaveOf(t, rdbB, srvC)
+		util.WaitForSync(t, rdbA)
+		util.WaitForSync(t, rdbB)
+		require.Eventually(t, func() bool {
+			roleA := rdbA.Do(context.Background(), "role").String()
+			roleB := rdbB.Do(context.Background(), "role").String()
+			return strings.Contains(roleA, "connected") && strings.Contains(roleB, "connected")
+		}, 50*time.Second, 100*time.Millisecond)
+		require.Equal(t, "2", util.FindInfoEntry(rdbC, "sync_full"))
+	})
+}
+
+func TestReplicationWithLimitSpeed(t *testing.T) {
+	master := util.StartServer(t, map[string]string{
+		"max-replication-mb":            "1",
+		"rocksdb.compression":           "no",
+		"rocksdb.write_buffer_size":     "1",
+		"rocksdb.target_file_size_base": "1",
+	})
+	defer master.Close()
+	masterClient := master.NewClient()
+	defer func() { require.NoError(t, masterClient.Close()) }()
+	util.Populate(t, masterClient, "", 1024, 10240)
+
+	ctx := context.Background()
+	require.NoError(t, masterClient.Set(ctx, "a", "b", 0).Err())
+	require.NoError(t, masterClient.Do(ctx, "compact").Err())
+
+	require.Eventually(t, func() bool {
+		return util.FindInfoEntry(masterClient, "is_compacting") == "no"
+	}, 10*time.Second, 100*time.Millisecond)
+
+	slave := util.StartServer(t, map[string]string{})
+	defer slave.Close()
+	slaveClient := slave.NewClient()
+	defer func() { require.NoError(t, slaveClient.Close()) }()
+	util.Populate(t, slaveClient, "", 1026, 1)
+
+	t.Run("resume broken transfer based files", func(t *testing.T) {
+		// Try to transfer some files, because max-replication-mb 1,
+		// so maybe more than 5 files are transferred for sleep 5s.
+		util.SlaveOf(t, slaveClient, master)
+		time.Sleep(5 * time.Second)
+
+		// Restart master server, let the slave try to full sync with master again,
+		// because slave already received some SST files, so we will skip them.
+		master.Restart()
+		masterClient.Close()
+		masterClient = master.NewClient()
+
+		require.NoError(t, masterClient.ConfigSet(ctx, "max-replication-mb", "0").Err())
+		require.Eventually(t, func() bool {
+			return slave.LogFileMatches(t, ".*skip count: 1.*")
+		}, 50*time.Second, 1000*time.Millisecond)
+		util.WaitForSync(t, slaveClient)
+		require.Equal(t, "b", slaveClient.Get(ctx, "a").Val())
+	})
+}
+
+func TestReplicationShareCheckpoint(t *testing.T) {
+	master := util.StartServer(t, map[string]string{})
+	defer master.Close()
+	masterClient := master.NewClient()
+	defer func() { require.NoError(t, masterClient.Close()) }()
+	util.Populate(t, masterClient, "", 1024, 1)
+	ctx := context.Background()
+	require.NoError(t, masterClient.Set(ctx, "a", "b", 0).Err())
+	require.NoError(t, masterClient.Do(ctx, "compact").Err())
+	time.Sleep(time.Second)
+
+	slave1 := util.StartServer(t, map[string]string{})
+	defer slave1.Close()
+	slave1Client := slave1.NewClient()
+	defer func() { require.NoError(t, slave1Client.Close()) }()
+	util.Populate(t, slave1Client, "", 1026, 1)
+
+	slave2 := util.StartServer(t, map[string]string{})
+	defer slave2.Close()
+	slave2Client := slave2.NewClient()
+	defer func() { require.NoError(t, slave2Client.Close()) }()
+	util.Populate(t, slave2Client, "", 1026, 1)
+
+	t.Run("two slaves share one checkpoint for full replication", func(t *testing.T) {
+		util.SlaveOf(t, slave1Client, master)
+		util.SlaveOf(t, slave2Client, master)
+
+		require.Eventually(t, func() bool {
+			return master.LogFileMatches(t, ".*Use current existing checkpoint.*")
+		}, 50*time.Second, 100*time.Millisecond)
+		util.WaitForSync(t, slave1Client)
+		util.WaitForSync(t, slave2Client)
+		require.Equal(t, "b", slave1Client.Get(ctx, "a").Val())
+		require.Equal(t, "b", slave2Client.Get(ctx, "a").Val())
+	})
+}
+
+func TestReplicationContinueRunning(t *testing.T) {
+	master := util.StartServer(t, map[string]string{})
+	defer master.Close()
+	masterClient := master.NewClient()
+	defer func() { require.NoError(t, masterClient.Close()) }()
+
+	slave := util.StartServer(t, map[string]string{})
+	defer slave.Close()
+	slaveClient := slave.NewClient()
+	defer func() { require.NoError(t, slaveClient.Close()) }()
+
+	util.SlaveOf(t, slaveClient, master)
+	util.WaitForSync(t, slaveClient)
+
+	t.Run("Master doesn't pause replicating with replicas, #346", func(t *testing.T) {
+		ctx := context.Background()
+		// In #346, we find a bug, if one command contains more than special
+		// number updates, master won't send replication stream to replicas.
+		masterClient.HSet(ctx, "myhash", map[string]interface{}{
+			"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9,
+			"a": "a", "b": "b", "c": "c", "d": "d", "e": "e", "f": "f", "g": "g", "h": "h", "i": "i", "j": "j", "k": "k"})
+		require.EqualValues(t, 21, masterClient.HLen(ctx, "myhash").Val())
+		util.WaitForOffsetSync(t, masterClient, slaveClient)
+		require.Equal(t, "1", slaveClient.HGet(ctx, "myhash", "1").Val())
+		require.Equal(t, "a", slaveClient.HGet(ctx, "myhash", "a").Val())
+	})
+}
+
+func TestReplicationChangePassword(t *testing.T) {
+	master := util.StartServer(t, map[string]string{})
+	defer master.Close()
+	masterClient := master.NewClient()
+	defer func() { require.NoError(t, masterClient.Close()) }()
+
+	slave := util.StartServer(t, map[string]string{})
+	defer slave.Close()
+	slaveClient := slave.NewClient()
+	defer func() { require.NoError(t, slaveClient.Close()) }()
+
+	util.SlaveOf(t, slaveClient, master)
+	util.WaitForSync(t, slaveClient)
+
+	t.Run("Slave can re-sync with master after password change", func(t *testing.T) {
+		ctx := context.Background()
+		require.Contains(t, slaveClient.Info(ctx, "replication").String(), "role:slave")
+		masterReplicationInfo := masterClient.Info(ctx, "replication").String()
+		require.Contains(t, masterReplicationInfo, "role:master")
+		require.Contains(t, masterReplicationInfo, slave.Host())
+		require.Contains(t, masterReplicationInfo, strconv.Itoa(int(slave.Port())))
+
+		// Change password and break repl connection
+		require.NoError(t, masterClient.ConfigSet(ctx, "requirepass", "pass").Err())
+		require.NoError(t, slaveClient.ConfigSet(ctx, "requirepass", "pass").Err())
+		require.NoError(t, slaveClient.ConfigSet(ctx, "masterauth", "pass").Err())
+
+		killedSlaveCount, err := masterClient.ClientKillByFilter(ctx, "type", "slave").Result()
+		require.NoError(t, err)
+		require.Greater(t, killedSlaveCount, int64(0))
+
+		// Sleep to wait for the killed connection state to prevent `WaitForSync` running
+		// before the slave finds the connection is down.
+		time.Sleep(time.Second)
+		util.WaitForSync(t, slaveClient)
+		masterReplicationInfo = masterClient.Info(ctx, "replication").String()
+		require.Contains(t, masterReplicationInfo, "role:master")
+		require.Contains(t, masterReplicationInfo, slave.Host())
+		require.Contains(t, masterReplicationInfo, strconv.Itoa(int(slave.Port())))
+	})
+}
diff --git a/tests/gocase/util/server.go b/tests/gocase/util/server.go
index 2f6239d..eadfef1 100644
--- a/tests/gocase/util/server.go
+++ b/tests/gocase/util/server.go
@@ -27,6 +27,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"syscall"
 	"testing"
 	"time"
@@ -61,6 +62,14 @@ func (s *KvrocksServer) Port() uint16 {
 	return s.addr.AddrPort().Port()
 }
 
+func (s *KvrocksServer) LogFileMatches(t testing.TB, pattern string) bool {
+	dir := s.configs["dir"]
+	content, err := os.ReadFile(dir + "/kvrocks.INFO")
+	require.NoError(t, err)
+	p := regexp.MustCompile(pattern)
+	return p.Match(content)
+}
+
 func (s *KvrocksServer) NewClient() *redis.Client {
 	return s.NewClientWithOption(&redis.Options{Addr: s.addr.String()})
 }
diff --git a/tests/tcl/tests/integration/replication.tcl b/tests/tcl/tests/integration/replication.tcl
deleted file mode 100644
index e04d7ab..0000000
--- a/tests/tcl/tests/integration/replication.tcl
+++ /dev/null
@@ -1,310 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-# Copyright (c) 2006-2020, Salvatore Sanfilippo
-# See bundled license file licenses/LICENSE.redis for details.
-
-# This file is copied and modified from the Redis project,
-# which started out as: https://github.com/redis/redis/blob/dbcc0a8/tests/integration/replication.tcl
-
-start_server {tags {"repl"}} {
-    set A [srv 0 client]
-    set A_host "localhost"
-    set A_port [srv 0 port]
-    populate 100 "" 10
-    start_server {} {
-        set B [srv 0 client]
-        set B_host [srv 0 host]
-        set B_port [srv 0 port]
-
-        test {Set instance A as slave of B} {
-            $A config set slave-empty-db-before-fullsync yes
-            $A config set fullsync-recv-file-delay 2
-            $A slaveof $B_host $B_port
-
-            # in loading status
-            after 1000
-            assert_equal {1} [s -1 loading]
-            wait_for_condition 500 100 {
-                [s -1 loading] == 0
-            } else {
-                fail "Fail to load master snapshot"
-            }
-            # reset config
-            after 1000
-            $A config set fullsync-recv-file-delay 0
-            $A config set slave-empty-db-before-fullsync no
-
-            wait_for_condition 50 100 {
-                [lindex [$A role] 0] eq {slave} &&
-                [string match {*master_link_status:up*} [$A info replication]]
-            } else {
-                fail "Can't turn the instance into a replica"
-            }
-        }
-    }
-}
-
-start_server {tags {"repl"}} {
-    r set mykey foo
-    r set mystring a
-    r lpush mylist a b c
-    r sadd myset a b c
-    r hmset myhash a 1 b 2 c 3
-    r zadd myzset 1 a 2 b 3 c
-
-    start_server {} {
-        test {Second server should have role master at first} {
-            # Can't statify partial replication
-            populate 100 "" 10
-            s role
-        } {master}
-
-        test {The role should immediately be changed to "replica"} {
-            r slaveof [srv -1 host] [srv -1 port]
-            s role
-        } {slave}
-
-        wait_for_sync r
-        test {Sync should have transferred keys from master} {
-            assert_equal [r -1 get mykey] [r get mykey]
-            assert_equal [r -1 get mystring] [r get mystring]
-            assert_equal [r -1 lrange mylist 0 -1] [r lrange mylist 0 -1]
-            assert_equal [r -1 hgetall myhash] [r hgetall myhash]
-            assert_equal [r -1 zrange myzset 0 -1 WITHSCORES] [r ZRANGE myzset 0 -1 WITHSCORES]
-            assert_equal [r -1 smembers myset] [r smembers myset]
-        }
-
-        test {The link status should be up} {
-            s master_link_status
-        } {up}
-
-        test {SET on the master should immediately propagate} {
-            r -1 set mykey bar
-
-            wait_for_condition 500 100 {
-                [r  0 get mykey] eq {bar}
-            } else {
-                fail "SET on master did not propagated on replica"
-            }
-        }
-
-        test {FLUSHALL should replicate} {
-            r -1 flushall
-            after 100
-            r -1 dbsize scan
-            r 0 dbsize scan
-            after 200
-            if {$::valgrind} {after 2000}
-            list [r -1 dbsize] [r 0 dbsize]
-        } {0 0}
-
-        test {ROLE in master reports master with a slave} {
-            set res [r -1 role]
-            lassign $res role offset slaves
-            assert {$role eq {master}}
-            assert {$offset > 0}
-            assert {[llength $slaves] == 1}
-            lassign [lindex $slaves 0] master_host master_port slave_offset
-            assert {$slave_offset <= $offset}
-        }
-
-        test {ROLE in slave reports slave in connected state} {
-            set res [r role]
-            lassign $res role master_host master_port slave_state slave_offset
-            assert {$role eq {slave}}
-            assert {$slave_state eq {connected}}
-        }
-    }
-}
-
-start_server {tags {"repl"}} {
-    set A [srv 0 client]
-    populate 100 "" 10
-
-    start_server {} {
-        set B [srv 0 client]
-        populate 100 "" 10
-
-        start_server {} {
-            set C [srv 0 client]
-            set C_host [srv 0 host]
-            set C_port [srv 0 port]
-            populate 50 "" 10
-
-            test {Multi slaves full sync with master at the same time} {
-                $A slaveof $C_host $C_port
-                $B slaveof $C_host $C_port
-                
-                wait_for_sync $A
-                wait_for_sync $B
-
-                # Wait for finishing full replication
-                wait_for_condition 500 100 {
-                    [string match {*connected*} [$A role]] &&
-                    [string match {*connected*} [$B role]]
-                } else {
-                     fail "Slaves can't sync with master"
-                }
-                # Only 2 full sync
-                assert_equal 2 [s sync_full]
-            }
-        }
-    }
-}
-
-start_server {tags {"repl"} overrides {max-replication-mb 1 rocksdb.compression no
-                    rocksdb.write_buffer_size 1 rocksdb.target_file_size_base 1}} {
-    # Generate multiple sst files
-    populate 1024 "" 10240
-    r set a b
-    r compact
-    after 1000
-    # Wait for finishing compaction
-    wait_for_condition 100 100 {
-        [s is_compacting] eq no
-    } else {
-        fail "Failed to compact DB"
-    }
-
-    start_server {} {
-        test {resume broken transfer based files} {
-            populate 1026 "" 1
-            set dir [lindex [r config get dir] 1]
-
-            # Try to transfer some files, because max-replication-mb 1,
-            # so maybe more than 5 files are transfered for sleep 5s
-            r slaveof [srv -1 host] [srv -1 port]
-            after 5000
-
-            # Restart master server, let slave full sync with master again,
-            # because slave already recieved some sst files, so we will skip them.
-            restart_server -1 true false
-            r -1 config set max-replication-mb 0
-
-            wait_for_condition 50 1000 {
-                [log_file_matches $dir/kvrocks.INFO "*skip count: 1*"]
-            } else {
-                fail "Fail to resume broken transfer based files"
-            }
-
-            # Slave loads checkpoint successfully
-            wait_for_sync r
-            assert_equal b [r get a]
-        }
-    }
-}
-
-start_server {tags {"repl"}} {
-    # Generate multiple sst files
-    populate 1024 "" 1
-    r set a b
-    r compact
-    after 1000
-
-    set master_host [srv 0 host]
-    set master_port [srv 0 port]
-    set dir [lindex [r config get dir] 1]
-    set master_log $dir/kvrocks.INFO
-
-    start_server {} {
-        populate 1026 "" 1
-        set slave1 [srv 0 client]
-        start_server {} {
-            set slave2 [srv 0 client]
-            populate 1026 "" 1
-
-            test {two slaves share one checkpoint for full replication} {
-                $slave1 slaveof $master_host $master_port
-                $slave2 slaveof $master_host $master_port
-
-                wait_for_condition 500 100 {
-                    [log_file_matches $master_log "*Use current existing checkpoint*"]
-                } else {
-                    fail "Fail to share one checkpoint"
-                }
-                wait_for_sync $slave1
-                wait_for_sync $slave2
-                assert_equal b [$slave1 get a]
-                assert_equal b [$slave2 get a]
-            }
-        }
-    }
-}
-
-start_server {tags {"repl"}} {
-    set slave [srv 0 client]
-    start_server {} {
-        $slave slaveof [srv 0 host] [srv 0 port]
-        wait_for_sync $slave
-
-        test {Master doesn't pause replicating with replicas, #346} {
-            # In #346, we find a bug, if one command contains more than special
-            # number updates, master won't send replication stream to replicas.
-            r hset myhash 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 \
-                          a a b b c c d d e e f f g g h h i i j j k k
-            assert_equal 21 [r hlen myhash]
-
-            wait_for_ofs_sync r $slave
-            assert_equal 1 [$slave hget myhash 1]
-            assert_equal a [$slave hget myhash a]
-        }
-    }
-}
-
-start_server {tags {"repl"}} {
-    set slave [srv 0 client]
-    set slave_ip [srv 0 host]
-    set slave_port [srv 0 port]
-    start_server {} {
-        set master [srv 0 client]
-        set master_ip [srv 0 host]
-        set master_port [srv 0 port]
-        test {Slave can re-sync with master after password change} {
-            $slave slaveof $master_ip $master_port
-            wait_for_sync $slave
-            catch {$slave info replication} var
-            assert_match {*role:slave*} $var
-            catch {$master info replication} var
-            assert_match {*role:master*[$slave_ip]*[$slave_port]*} $var
-
-            # Change password and break repl connection
-            $master config set requirepass pass
-            $slave config set requirepass pass
-            $slave config set masterauth pass
-
-            set ret [$master client list]
-            set lines [split $ret "\n"]
-            global conn_addr
-            foreach  line $lines {
-                if {[string match "*cmd=psync*" $line]} {
-                    set list [split $line " "]
-                    foreach str $list {
-                        if {[string match "*addr=*" $str]} {
-                            set conn_addr [string range $str 5 end]
-                        }
-                    }
-                }
-            }
-
-            $master client kill $conn_addr
-            wait_for_sync $slave
-            catch {$master info replication} var
-            assert_match {*role:master*[$slave_ip]*[$slave_port]*} $var
-        }
-    }
-}
diff --git a/tests/tcl/tests/test_helper.tcl b/tests/tcl/tests/test_helper.tcl
index 80f7323..f66cd9d 100644
--- a/tests/tcl/tests/test_helper.tcl
+++ b/tests/tcl/tests/test_helper.tcl
@@ -37,7 +37,6 @@ set ::all_tests {
     unit/type/stream
     unit/geo
     integration/slotmigrate
-    integration/replication
 }
 
 # Index to the next test to run in the ::all_tests list.