RedisCI

Details for run #5856 (ok)

redis-cluster (53cb27b)

Fri Jun 16 09:57:36 CEST 2017

@cd /ssd/ci/redis

Working dir is now '/ssd/ci/redis'

@git reset --hard

HEAD is now at 29e3ff9 Merge pull request #3926 from QuChen88/3.2

@git checkout unstable

Switched to branch 'unstable'
Your branch is up-to-date with 'origin/unstable'.

@git pull origin unstable

From git://github.com/antirez/redis
 * branch            unstable   -> FETCH_HEAD
Already up-to-date.

@make distclean

cd src && make distclean
make[1]: Entering directory `/ssd/ci/redis/src'
rm -rf redis-server redis-sentinel redis-cli redis-benchmark redis-check-rdb redis-check-aof *.o *.gcda *.gcno *.gcov redis.info lcov-html Makefile.dep dict-benchmark
(cd ../deps && make distclean)
make[2]: Entering directory `/ssd/ci/redis/deps'
(cd hiredis && make clean) > /dev/null || true
(cd linenoise && make clean) > /dev/null || true
(cd lua && make clean) > /dev/null || true
(cd jemalloc && [ -f Makefile ] && make distclean) > /dev/null || true
(rm -f .make-*)
make[2]: Leaving directory `/ssd/ci/redis/deps'
(rm -f .make-*)
make[1]: Leaving directory `/ssd/ci/redis/src'

@make

cd src && make all
make[1]: Entering directory `/ssd/ci/redis/src'
    CC Makefile.dep
make[1]: Leaving directory `/ssd/ci/redis/src'
make[1]: Entering directory `/ssd/ci/redis/src'
rm -rf redis-server redis-sentinel redis-cli redis-benchmark redis-check-rdb redis-check-aof *.o *.gcda *.gcno *.gcov redis.info lcov-html Makefile.dep dict-benchmark
(cd ../deps && make distclean)
make[2]: Entering directory `/ssd/ci/redis/deps'
(cd hiredis && make clean) > /dev/null || true
(cd linenoise && make clean) > /dev/null || true
(cd lua && make clean) > /dev/null || true
(cd jemalloc && [ -f Makefile ] && make distclean) > /dev/null || true
(rm -f .make-*)
make[2]: Leaving directory `/ssd/ci/redis/deps'
(rm -f .make-*)
echo STD=-std=c99 -pedantic -DREDIS_STATIC='' >> .make-settings
echo WARN=-Wall -W -Wno-missing-field-initializers >> .make-settings
echo OPT=-O2 >> .make-settings
echo MALLOC=jemalloc >> .make-settings
echo CFLAGS= >> .make-settings
echo LDFLAGS= >> .make-settings
echo REDIS_CFLAGS= >> .make-settings
echo REDIS_LDFLAGS= >> .make-settings
echo PREV_FINAL_CFLAGS=-std=c99 -pedantic -DREDIS_STATIC='' -Wall -W -Wno-missing-field-initializers -O2 -g -ggdb   -I../deps/hiredis -I../deps/linenoise -I../deps/lua/src -DUSE_JEMALLOC -I../deps/jemalloc/include >> .make-settings
echo PREV_FINAL_LDFLAGS=  -g -ggdb -rdynamic >> .make-settings
(cd ../deps && make hiredis linenoise lua jemalloc)
make[2]: Entering directory `/ssd/ci/redis/deps'
(cd hiredis && make clean) > /dev/null || true
(cd linenoise && make clean) > /dev/null || true
(cd lua && make clean) > /dev/null || true
(cd jemalloc && [ -f Makefile ] && make distclean) > /dev/null || true
(rm -f .make-*)
(echo "" > .make-ldflags)
(echo "" > .make-cflags)
MAKE hiredis
cd hiredis && make static
make[3]: Entering directory `/ssd/ci/redis/deps/hiredis'
cc -std=c99 -pedantic -c -O3 -fPIC  -Wall -W -Wstrict-prototypes -Wwrite-strings -g -ggdb  net.c
cc -std=c99 -pedantic -c -O3 -fPIC  -Wall -W -Wstrict-prototypes -Wwrite-strings -g -ggdb  hiredis.c
cc -std=c99 -pedantic -c -O3 -fPIC  -Wall -W -Wstrict-prototypes -Wwrite-strings -g -ggdb  sds.c
cc -std=c99 -pedantic -c -O3 -fPIC  -Wall -W -Wstrict-prototypes -Wwrite-strings -g -ggdb  async.c
cc -std=c99 -pedantic -c -O3 -fPIC  -Wall -W -Wstrict-prototypes -Wwrite-strings -g -ggdb  read.c
ar rcs libhiredis.a net.o hiredis.o sds.o async.o read.o
make[3]: Leaving directory `/ssd/ci/redis/deps/hiredis'
MAKE linenoise
cd linenoise && make
make[3]: Entering directory `/ssd/ci/redis/deps/linenoise'
cc  -Wall -Os -g  -c linenoise.c
make[3]: Leaving directory `/ssd/ci/redis/deps/linenoise'
MAKE lua
cd lua/src && make all CFLAGS="-O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC='' " MYLDFLAGS="" AR="ar rcu"
make[3]: Entering directory `/ssd/ci/redis/deps/lua/src'
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lapi.o lapi.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lcode.o lcode.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o ldebug.o ldebug.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o ldo.o ldo.c
ldo.c: In function 'f_parser':
ldo.c:496:7: warning: unused variable 'c' [-Wunused-variable]
   int c = luaZ_lookahead(p->z);
       ^
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o ldump.o ldump.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lfunc.o lfunc.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lgc.o lgc.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o llex.o llex.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lmem.o lmem.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lobject.o lobject.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lopcodes.o lopcodes.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lparser.o lparser.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lstate.o lstate.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lstring.o lstring.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o ltable.o ltable.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o ltm.o ltm.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lundump.o lundump.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lvm.o lvm.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lzio.o lzio.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o strbuf.o strbuf.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o fpconv.o fpconv.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lauxlib.o lauxlib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lbaselib.o lbaselib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o ldblib.o ldblib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o liolib.o liolib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lmathlib.o lmathlib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o loslib.o loslib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o ltablib.o ltablib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lstrlib.o lstrlib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o loadlib.o loadlib.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o linit.o linit.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lua_cjson.o lua_cjson.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lua_struct.o lua_struct.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lua_cmsgpack.o lua_cmsgpack.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lua_bit.o lua_bit.c
ar rcu liblua.a lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o lundump.o lvm.o lzio.o strbuf.o fpconv.o lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o lstrlib.o loadlib.o linit.o lua_cjson.o lua_struct.o lua_cmsgpack.o lua_bit.o	# DLL needs all object files
ranlib liblua.a
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o lua.o lua.c
cc -o lua  lua.o liblua.a -lm 
liblua.a(loslib.o): In function `os_tmpname':
loslib.c:(.text+0x29c): warning: the use of `tmpnam' is dangerous, better use `mkstemp'
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o luac.o luac.c
cc -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC=''    -c -o print.o print.c
cc -o luac  luac.o print.o liblua.a -lm 
make[3]: Leaving directory `/ssd/ci/redis/deps/lua/src'
MAKE jemalloc
cd jemalloc && ./configure --with-lg-quantum=3 --with-jemalloc-prefix=je_ --enable-cc-silence CFLAGS="-std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops " LDFLAGS=""
checking for xsltproc... /usr/bin/xsltproc
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables... 
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking how to run the C preprocessor... gcc -E
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for ANSI C header files... yes
checking for sys/types.h... yes
checking for sys/stat.h... yes
checking for stdlib.h... yes
checking for string.h... yes
checking for memory.h... yes
checking for strings.h... yes
checking for inttypes.h... yes
checking for stdint.h... yes
checking for unistd.h... yes
checking whether byte ordering is bigendian... no
checking size of void *... 8
checking size of int... 4
checking size of long... 8
checking size of intmax_t... 8
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking whether pause instruction is compilable... yes
checking for ar... ar
checking malloc.h usability... yes
checking malloc.h presence... yes
checking for malloc.h... yes
checking whether malloc_usable_size definition can use const argument... no
checking whether __attribute__ syntax is compilable... yes
checking whether compiler supports -fvisibility=hidden... yes
checking whether compiler supports -Werror... yes
checking whether tls_model attribute is compilable... yes
checking whether compiler supports -Werror... yes
checking whether alloc_size attribute is compilable... yes
checking whether compiler supports -Werror... yes
checking whether format(gnu_printf, ...) attribute is compilable... yes
checking whether compiler supports -Werror... yes
checking whether format(printf, ...) attribute is compilable... yes
checking for a BSD-compatible install... /usr/bin/install -c
checking for ranlib... ranlib
checking for ld... /usr/bin/ld
checking for autoconf... /usr/bin/autoconf
checking for memalign... yes
checking for valloc... yes
checking configured backtracing method... N/A
checking for sbrk... yes
checking whether utrace(2) is compilable... no
checking whether valgrind is compilable... yes
checking whether a program using __builtin_ffsl is compilable... yes
checking LG_PAGE... 12
checking pthread.h usability... yes
checking pthread.h presence... yes
checking for pthread.h... yes
checking for pthread_create in -lpthread... yes
checking for library containing clock_gettime... none required
checking for secure_getenv... yes
checking for issetugid... no
checking for _malloc_thread_cleanup... no
checking for _pthread_mutex_init_calloc_cb... no
checking for TLS... yes
checking whether C11 atomics is compilable... no
checking whether atomic(9) is compilable... no
checking whether Darwin OSAtomic*() is compilable... no
checking whether madvise(2) is compilable... yes
checking whether to force 32-bit __sync_{add,sub}_and_fetch()... no
checking whether to force 64-bit __sync_{add,sub}_and_fetch()... no
checking for __builtin_clz... yes
checking whether Darwin OSSpin*() is compilable... no
checking whether glibc malloc hook is compilable... yes
checking whether glibc memalign hook is compilable... yes
checking whether pthreads adaptive mutexes is compilable... yes
checking for stdbool.h that conforms to C99... yes
checking for _Bool... yes
configure: creating ./config.status
config.status: creating Makefile
config.status: creating jemalloc.pc
config.status: creating doc/html.xsl
config.status: creating doc/manpages.xsl
config.status: creating doc/jemalloc.xml
config.status: creating include/jemalloc/jemalloc_macros.h
config.status: creating include/jemalloc/jemalloc_protos.h
config.status: creating include/jemalloc/jemalloc_typedefs.h
config.status: creating include/jemalloc/internal/jemalloc_internal.h
config.status: creating test/test.sh
config.status: creating test/include/test/jemalloc_test.h
config.status: creating config.stamp
config.status: creating bin/jemalloc-config
config.status: creating bin/jemalloc.sh
config.status: creating bin/jeprof
config.status: creating include/jemalloc/jemalloc_defs.h
config.status: creating include/jemalloc/internal/jemalloc_internal_defs.h
config.status: creating test/include/test/jemalloc_test_defs.h
config.status: executing include/jemalloc/internal/private_namespace.h commands
config.status: executing include/jemalloc/internal/private_unnamespace.h commands
config.status: executing include/jemalloc/internal/public_symbols.txt commands
config.status: executing include/jemalloc/internal/public_namespace.h commands
config.status: executing include/jemalloc/internal/public_unnamespace.h commands
config.status: executing include/jemalloc/internal/size_classes.h commands
config.status: executing include/jemalloc/jemalloc_protos_jet.h commands
config.status: executing include/jemalloc/jemalloc_rename.h commands
config.status: executing include/jemalloc/jemalloc_mangle.h commands
config.status: executing include/jemalloc/jemalloc_mangle_jet.h commands
config.status: executing include/jemalloc/jemalloc.h commands
===============================================================================
jemalloc version   : 4.0.3-0-ge9192eacf8935e29fc62fddc2701f7942b1cc02c
library revision   : 2

CONFIG             : --with-lg-quantum=3 --with-jemalloc-prefix=je_ --enable-cc-silence 'CFLAGS=-std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops ' LDFLAGS=
CC                 : gcc
CFLAGS             : -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -fvisibility=hidden
CPPFLAGS           :  -D_GNU_SOURCE -D_REENTRANT
LDFLAGS            : 
EXTRA_LDFLAGS      : 
LIBS               :  -lpthread
TESTLIBS           : 
RPATH_EXTRA        : 

XSLTPROC           : /usr/bin/xsltproc
XSLROOT            : /usr/share/xml/docbook/stylesheet/docbook-xsl

PREFIX             : /usr/local
BINDIR             : /usr/local/bin
DATADIR            : /usr/local/share
INCLUDEDIR         : /usr/local/include
LIBDIR             : /usr/local/lib
MANDIR             : /usr/local/share/man

srcroot            : 
abs_srcroot        : /ssd/ci/redis/deps/jemalloc/
objroot            : 
abs_objroot        : /ssd/ci/redis/deps/jemalloc/

JEMALLOC_PREFIX    : je_
JEMALLOC_PRIVATE_NAMESPACE
                   : je_
install_suffix     : 
autogen            : 0
cc-silence         : 1
debug              : 0
code-coverage      : 0
stats              : 1
prof               : 0
prof-libunwind     : 0
prof-libgcc        : 0
prof-gcc           : 0
tcache             : 1
fill               : 1
utrace             : 0
valgrind           : 1
xmalloc            : 0
munmap             : 0
lazy_lock          : 0
tls                : 1
cache-oblivious    : 1
===============================================================================
cd jemalloc && make CFLAGS="-std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops " LDFLAGS="" lib/libjemalloc.a
make[3]: Entering directory `/ssd/ci/redis/deps/jemalloc'
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/jemalloc.o src/jemalloc.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/arena.o src/arena.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/atomic.o src/atomic.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/base.o src/base.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/bitmap.o src/bitmap.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/chunk.o src/chunk.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/chunk_dss.o src/chunk_dss.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/chunk_mmap.o src/chunk_mmap.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/ckh.o src/ckh.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/ctl.o src/ctl.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/extent.o src/extent.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/hash.o src/hash.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/huge.o src/huge.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/mb.o src/mb.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/mutex.o src/mutex.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/pages.o src/pages.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/prof.o src/prof.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/quarantine.o src/quarantine.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/rtree.o src/rtree.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/stats.o src/stats.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/tcache.o src/tcache.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/util.o src/util.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/tsd.o src/tsd.c
gcc -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops  -c -D_GNU_SOURCE -D_REENTRANT -Iinclude -Iinclude -o src/valgrind.o src/valgrind.c
ar crus lib/libjemalloc.a src/jemalloc.o src/arena.o src/atomic.o src/base.o src/bitmap.o src/chunk.o src/chunk_dss.o src/chunk_mmap.o src/ckh.o src/ctl.o src/extent.o src/hash.o src/huge.o src/mb.o src/mutex.o src/pages.o src/prof.o src/quarantine.o src/rtree.o src/stats.o src/tcache.o src/util.o src/tsd.o src/valgrind.o
make[3]: Leaving directory `/ssd/ci/redis/deps/jemalloc'
make[2]: Leaving directory `/ssd/ci/redis/deps'
    CC adlist.o
    CC quicklist.o
    CC ae.o
    CC anet.o
    CC dict.o
    CC server.o
    CC sds.o
    CC zmalloc.o
    CC lzf_c.o
    CC lzf_d.o
    CC pqsort.o
    CC zipmap.o
    CC sha1.o
    CC ziplist.o
    CC release.o
    CC networking.o
    CC util.o
    CC object.o
    CC db.o
    CC replication.o
    CC rdb.o
    CC t_string.o
    CC t_list.o
    CC t_set.o
    CC t_zset.o
    CC t_hash.o
    CC config.o
    CC aof.o
    CC pubsub.o
    CC multi.o
    CC debug.o
    CC sort.o
    CC intset.o
    CC syncio.o
    CC cluster.o
    CC crc16.o
    CC endianconv.o
    CC slowlog.o
    CC scripting.o
    CC bio.o
    CC rio.o
    CC rand.o
    CC memtest.o
    CC crc64.o
    CC bitops.o
    CC sentinel.o
    CC notify.o
    CC setproctitle.o
    CC blocked.o
    CC hyperloglog.o
    CC latency.o
    CC sparkline.o
    CC redis-check-rdb.o
    CC geo.o
    CC lazyfree.o
    CC module.o
    CC evict.o
    CC expire.o
    CC geohash.o
    CC geohash_helper.o
    CC childinfo.o
    CC defrag.o
    CC siphash.o
    CC rax.o
    LINK redis-server
    INSTALL redis-sentinel
    CC redis-cli.o
    LINK redis-cli
    CC redis-benchmark.o
    LINK redis-benchmark
    INSTALL redis-check-rdb
    CC redis-check-aof.o
    LINK redis-check-aof

Hint: It's a good idea to run 'make test' ;)

make[1]: Leaving directory `/ssd/ci/redis/src'

@./runtest-cluster

Starting redis #0 at port 30000
Starting redis #1 at port 30001
Starting redis #2 at port 30002
Starting redis #3 at port 30003
Starting redis #4 at port 30004
Starting redis #5 at port 30005
Starting redis #6 at port 30006
Starting redis #7 at port 30007
Starting redis #8 at port 30008
Starting redis #9 at port 30009
Starting redis #10 at port 30010
Starting redis #11 at port 30011
Starting redis #12 at port 30012
Starting redis #13 at port 30013
Starting redis #14 at port 30014
Starting redis #15 at port 30015
Starting redis #16 at port 30016
Starting redis #17 at port 30017
Starting redis #18 at port 30018
Starting redis #19 at port 30019
Testing unit: 00-base.tcl
09:49:22> (init) Restart killed instances: OK
09:49:22> Cluster nodes are reachable: OK
09:49:22> Cluster nodes hard reset: OK
09:49:22> Cluster Join and auto-discovery test: OK
09:49:25> Before slots allocation, all nodes report cluster failure: OK
09:49:25> Different nodes have different IDs: OK
09:49:25> It is possible to perform slot allocation: OK
09:49:25> After the join, every node gets a different config epoch: .OK
09:49:27> Nodes should report cluster_state is ok now: OK
09:49:29> It is possible to write and read from the cluster: OK
Testing unit: 01-faildet.tcl
09:49:29> (init) Restart killed instances: OK
09:49:29> Cluster nodes are reachable: OK
09:49:29> Cluster nodes hard reset: OK
09:49:29> Cluster Join and auto-discovery test: OK
09:49:32> Before slots allocation, all nodes report cluster failure: OK
09:49:32> Create a 5 nodes cluster: OK
09:49:36> Cluster should start ok: OK
09:49:36> Killing two slave nodes: OK
09:49:38> Cluster should be still up: OK
09:49:38> Killing one master node: OK
09:49:39> Cluster should be down now: OK
09:49:42> Restarting master node: OK
09:49:42> Cluster should be up again: OK
Testing unit: 02-failover.tcl
09:49:48> (init) Restart killed instances: redis/5 redis/6 OK
09:49:48> Cluster nodes are reachable: OK
09:49:48> Cluster nodes hard reset: OK
09:49:48> Cluster Join and auto-discovery test: OK
09:49:51> Before slots allocation, all nodes report cluster failure: OK
09:49:51> Create a 5 nodes cluster: OK
09:49:55> Cluster is up: OK
09:49:55> Cluster is writable: OK
09:49:55> Instance #5 is a slave: OK
09:49:55> Instance #5 synced with the master: OK
09:49:55> Killing one master node: OK
09:49:56> Wait for failover: OK
09:50:00> Cluster should eventually be up again: OK
09:50:00> Cluster is writable: OK
09:50:00> Instance #5 is now a master: OK
09:50:00> Restarting the previously killed master node: OK
09:50:00> Instance #0 gets converted into a slave: OK
Testing unit: 03-failover-loop.tcl
09:50:00> (init) Restart killed instances: OK
09:50:00> Cluster nodes are reachable: OK
09:50:00> Cluster nodes hard reset: OK
09:50:00> Cluster Join and auto-discovery test: OK
09:50:03> Before slots allocation, all nodes report cluster failure: OK
09:50:03> Create a 5 nodes cluster: OK
09:50:07> Cluster is up: OK
--- Iteration 19 ---
09:50:07> Wait for slave of #3 to sync: OK
09:50:07> Cluster is writable before failover: OK
09:50:08> Killing node #3: OK
09:50:09> Wait failover by #8 with old epoch 4: OK
09:50:12> Cluster should eventually be up again: OK
09:50:12> Cluster is writable again: OK
09:50:12> Restarting node #3: OK
09:50:12> Instance #3 is now a slave: OK
09:50:12> We can read back the value we set before: OK
--- Iteration 18 ---
09:50:12> Cluster is writable before failover: OK
09:50:12> Killing node #3: OK
09:50:13> Cluster should eventually be up again: OK
09:50:13> Cluster is writable again: OK
09:50:13> Restarting node #3: OK
09:50:13> Instance #3 is now a slave: OK
09:50:13> We can read back the value we set before: OK
--- Iteration 17 ---
09:50:13> Wait for slave of #4 to sync: OK
09:50:13> Cluster is writable before failover: OK
09:50:13> Killing node #4: OK
09:50:14> Wait failover by #9 with old epoch 5: OK
09:50:17> Cluster should eventually be up again: OK
09:50:17> Cluster is writable again: OK
09:50:17> Restarting node #4: OK
09:50:17> Instance #4 is now a slave: OK
09:50:17> We can read back the value we set before: OK
--- Iteration 16 ---
09:50:17> Cluster is writable before failover: OK
09:50:17> Killing node #6: OK
09:50:18> Cluster should eventually be up again: OK
09:50:18> Cluster is writable again: OK
09:50:18> Restarting node #6: OK
09:50:18> Instance #6 is now a slave: OK
09:50:18> We can read back the value we set before: OK
--- Iteration 15 ---
09:50:19> Cluster is writable before failover: OK
09:50:19> Killing node #4: OK
09:50:20> Cluster should eventually be up again: OK
09:50:20> Cluster is writable again: OK
09:50:20> Restarting node #4: OK
09:50:20> Instance #4 is now a slave: OK
09:50:20> We can read back the value we set before: OK
--- Iteration 14 ---
09:50:20> Cluster is writable before failover: OK
09:50:20> Killing node #3: OK
09:50:21> Cluster should eventually be up again: OK
09:50:21> Cluster is writable again: OK
09:50:21> Restarting node #3: OK
09:50:21> Instance #3 is now a slave: OK
09:50:21> We can read back the value we set before: OK
--- Iteration 13 ---
09:50:21> Wait for slave of #2 to sync: OK
09:50:21> Cluster is writable before failover: OK
09:50:21> Killing node #2: OK
09:50:22> Wait failover by #7 with old epoch 3: OK
09:50:25> Cluster should eventually be up again: OK
09:50:25> Cluster is writable again: OK
09:50:25> Restarting node #2: OK
09:50:25> Instance #2 is now a slave: OK
09:50:25> We can read back the value we set before: OK
--- Iteration 12 ---
09:50:25> Cluster is writable before failover: OK
09:50:25> Killing node #3: OK
09:50:26> Cluster should eventually be up again: OK
09:50:26> Cluster is writable again: OK
09:50:26> Restarting node #3: OK
09:50:26> Instance #3 is now a slave: OK
09:50:26> We can read back the value we set before: OK
--- Iteration 11 ---
09:50:27> Wait for slave of #7 to sync: OK
09:50:27> Cluster is writable before failover: OK
09:50:27> Killing node #7: OK
09:50:28> Wait failover by #2 with old epoch 23: OK
09:50:31> Cluster should eventually be up again: OK
09:50:31> Cluster is writable again: OK
09:50:31> Restarting node #7: OK
09:50:31> Instance #7 is now a slave: OK
09:50:31> We can read back the value we set before: OK
--- Iteration 10 ---
09:50:31> Wait for slave of #8 to sync: OK
09:50:31> Cluster is writable before failover: OK
09:50:31> Killing node #8: OK
09:50:32> Wait failover by #3 with old epoch 21: OK
09:50:35> Cluster should eventually be up again: OK
09:50:35> Cluster is writable again: OK
09:50:35> Restarting node #8: OK
09:50:35> Instance #8 is now a slave: OK
09:50:35> We can read back the value we set before: OK
--- Iteration 9 ---
09:50:35> Cluster is writable before failover: OK
09:50:35> Killing node #7: OK
09:50:36> Cluster should eventually be up again: OK
09:50:36> Cluster is writable again: OK
09:50:36> Restarting node #7: OK
09:50:36> Instance #7 is now a slave: OK
09:50:36> We can read back the value we set before: OK
--- Iteration 8 ---
09:50:36> Cluster is writable before failover: OK
09:50:36> Killing node #6: OK
09:50:37> Cluster should eventually be up again: OK
09:50:37> Cluster is writable again: OK
09:50:37> Restarting node #6: OK
09:50:37> Instance #6 is now a slave: OK
09:50:37> We can read back the value we set before: OK
--- Iteration 7 ---
09:50:37> Wait for slave of #9 to sync: OK
09:50:37> Cluster is writable before failover: OK
09:50:37> Killing node #9: OK
09:50:38> Wait failover by #4 with old epoch 22: OK
09:50:41> Cluster should eventually be up again: OK
09:50:41> Cluster is writable again: OK
09:50:41> Restarting node #9: OK
09:50:41> Instance #9 is now a slave: OK
09:50:41> We can read back the value we set before: OK
--- Iteration 6 ---
09:50:41> Cluster is writable before failover: OK
09:50:41> Killing node #6: OK
09:50:42> Cluster should eventually be up again: OK
09:50:42> Cluster is writable again: OK
09:50:42> Restarting node #6: OK
09:50:42> Instance #6 is now a slave: OK
09:50:42> We can read back the value we set before: OK
--- Iteration 5 ---
09:50:43> Wait for slave of #0 to sync: OK
09:50:43> Cluster is writable before failover: OK
09:50:43> Killing node #0: OK
09:50:44> Wait failover by #5 with old epoch 1: OK
09:50:47> Cluster should eventually be up again: OK
09:50:47> Cluster is writable again: OK
09:50:47> Restarting node #0: OK
09:50:47> Instance #0 is now a slave: OK
09:50:47> We can read back the value we set before: OK
--- Iteration 4 ---
09:50:47> Cluster is writable before failover: OK
09:50:47> Killing node #0: OK
09:50:48> Cluster should eventually be up again: OK
09:50:48> Cluster is writable again: OK
09:50:48> Restarting node #0: OK
09:50:48> Instance #0 is now a slave: OK
09:50:48> We can read back the value we set before: OK
--- Iteration 3 ---
09:50:48> Wait for slave of #3 to sync: OK
09:50:48> Cluster is writable before failover: OK
09:50:48> Killing node #3: OK
09:50:49> Wait failover by #8 with old epoch 25: OK
09:50:53> Cluster should eventually be up again: OK
09:50:53> Cluster is writable again: OK
09:50:53> Restarting node #3: OK
09:50:53> Instance #3 is now a slave: OK
09:50:53> We can read back the value we set before: OK
--- Iteration 2 ---
09:50:53> Cluster is writable before failover: OK
09:50:53> Killing node #3: OK
09:50:54> Cluster should eventually be up again: OK
09:50:54> Cluster is writable again: OK
09:50:54> Restarting node #3: OK
09:50:54> Instance #3 is now a slave: OK
09:50:54> We can read back the value we set before: OK
--- Iteration 1 ---
09:50:54> Cluster is writable before failover: OK
09:50:54> Killing node #3: OK
09:50:55> Cluster should eventually be up again: OK
09:50:55> Cluster is writable again: OK
09:50:55> Restarting node #3: OK
09:50:55> Instance #3 is now a slave: OK
09:50:55> We can read back the value we set before: OK
09:50:55> Post condition: current_epoch >= my_epoch everywhere: OK
Testing unit: 04-resharding.tcl
09:50:55> (init) Restart killed instances: OK
09:50:55> Cluster nodes are reachable: OK
09:50:55> Cluster nodes hard reset: OK
09:50:55> Cluster Join and auto-discovery test: OK
09:50:58> Before slots allocation, all nodes report cluster failure: OK
09:50:58> Create a 5 nodes cluster: OK
09:51:01> Cluster is up: OK
09:51:01> Enable AOF in all the instances: OK
09:51:02> Cluster consistency during live resharding: WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW...Starting resharding...WW...............................................................WWW................................................................W.......................................W....................................W....................................W...........................................W..............................................W...........................................W.........................................W........................................W...........................................W.............................................W.......................................W................................................W....................................W.............................................W.................................................W...........................................W.................................................................W....................................W.................................W.........................................W..........WWWW...Starting resharding...WW...............................................................WWW..............................................................................W.....................................W...............................................W....................................................W...........................................W...................................W.................................................W................................W...................................................W.......................................W.................................................W........................................................W.......................................W.................................W...................................W..........................................W....................................................W....................................W......................................W..........................................W...................................W...........................WWWW...Starting resharding...WW...............................................................WWW.......WWWWW...Starting resharding...WW.............................................W..................WW......................................................................W...............................................W......................................W..............................................W.........................................W............................................W...........................................W.................................W...............................W.............................................................W..................................W....................................W...............................................W................................W..........................................W.......................................W................................................W..........................................W.......................................W.....................................W.......................................W...............................................WWWWOK
09:51:57> Verify 50000 keys for consistency with logical content: OK
09:52:06> Crash and restart all the instances: OK
09:52:28> Cluster should eventually be up again: OK
09:52:30> Verify 50000 keys after the crash & restart: OK
09:52:39> Disable AOF in all the instances: OK
09:52:39> Verify slaves consistency: OK
Testing unit: 05-slave-selection.tcl
09:52:40> (init) Restart killed instances: OK
09:52:40> Cluster nodes are reachable: OK
09:52:40> Cluster nodes hard reset: OK
09:52:40> Cluster Join and auto-discovery test: OK
09:52:43> Before slots allocation, all nodes report cluster failure: OK
09:52:43> Create a 5 nodes cluster: OK
09:52:47> Cluster is up: OK
09:52:47> The first master has actually two slaves: OK
09:52:47> Slaves of #0 are instance #5 and #10 as expected: OK
09:52:47> Instance #5 and #10 synced with the master: OK
09:52:47> Slaves are both able to receive and acknowledge writes: OK
09:52:47> Write data while slave #10 is paused and can't receive it: OK
09:52:58> Wait for instance #5 (and not #10) to turn into a master: OK
09:53:02> Wait for the node #10 to return alive before ending the test: OK
09:53:02> Cluster should eventually be up again: OK
09:53:02> Node #10 should eventually replicate node #5: OK
Testing unit: 06-slave-stop-cond.tcl
09:53:03> (init) Restart killed instances: redis/0 OK
09:53:03> Cluster nodes are reachable: OK
09:53:03> Cluster nodes hard reset: OK
09:53:03> Cluster Join and auto-discovery test: OK
09:53:06> Before slots allocation, all nodes report cluster failure: OK
09:53:06> Create a 5 nodes cluster: OK
09:53:10> Cluster is up: OK
09:53:10> The first master has actually one slave: OK
09:53:10> Slaves of #0 is instance #5 as expected: OK
09:53:10> Instance #5 synced with the master: OK
09:53:10> Lower the slave validity factor of #5 to the value of 2: OK
09:53:10> Break master-slave link and prevent further reconnections: OK
09:53:31> Slave #5 is reachable and alive: OK
09:53:31> Slave #5 should not be able to failover: OK
09:53:41> Cluster should be down: OK
Testing unit: 07-replica-migration.tcl
09:53:41> (init) Restart killed instances: redis/0 OK
09:53:41> Cluster nodes are reachable: OK
09:53:41> Cluster nodes hard reset: OK
09:53:41> Cluster Join and auto-discovery test: OK
09:53:43> Before slots allocation, all nodes report cluster failure: OK
09:53:43> Create a 5 nodes cluster: OK
09:53:47> Cluster is up: OK
09:53:47> Each master should have two replicas attached: OK
09:53:47> Killing all the slaves of master #0 and #1: OK
09:53:55> Master #0 should have at least one replica: OK
09:53:57> Master #1 should have at least one replica: OK
09:53:59> Master #2 should have at least one replica: OK
09:53:59> Master #3 should have at least one replica: OK
09:53:59> Master #4 should have at least one replica: OK
09:53:59> (init) Restart killed instances: redis/5 redis/6 redis/10 redis/11 OK
09:53:59> Cluster nodes are reachable: OK
09:53:59> Cluster nodes hard reset: OK
09:53:59> Cluster Join and auto-discovery test: OK
09:54:02> Before slots allocation, all nodes report cluster failure: OK
09:54:02> Create a 5 nodes cluster: OK
09:54:06> Cluster is up: OK
09:54:06> Kill slave #7 of master #2. Only slave left is #12 now: OK
09:54:07> Killing master node #2, #12 should failover: OK
09:54:08> Wait for failover: OK
09:54:11> Cluster should eventually be up again: OK
09:54:11> Cluster is writable: OK
09:54:12> Instance 12 is now a master without slaves: OK
09:54:12> Master #12 should get at least one migrated replica: OK
Testing unit: 08-update-msg.tcl
09:54:17> (init) Restart killed instances: redis/2 redis/7 OK
09:54:17> Cluster nodes are reachable: OK
09:54:17> Cluster nodes hard reset: OK
09:54:17> Cluster Join and auto-discovery test: OK
09:54:20> Before slots allocation, all nodes report cluster failure: OK
09:54:20> Create a 5 nodes cluster: OK
09:54:24> Cluster is up: OK
09:54:24> Cluster is writable: OK
09:54:24> Instance #5 is a slave: OK
09:54:24> Instance #5 synced with the master: OK
09:54:24> Killing one master node: OK
09:54:25> Wait for failover: OK
09:54:28> Cluster should eventually be up again: OK
09:54:28> Cluster is writable: OK
09:54:28> Instance #5 is now a master: OK
09:54:28> Killing the new master #5: OK
09:54:29> Cluster should be down now: OK
09:54:32> Restarting the old master node: OK
09:54:32> Instance #0 gets converted into a slave: OK
09:54:32> Restarting the new master node: OK
09:54:32> Cluster is up again: OK
Testing unit: 09-pubsub.tcl
09:54:38> (init) Restart killed instances: OK
09:54:38> Cluster nodes are reachable: OK
09:54:38> Cluster nodes hard reset: OK
09:54:38> Cluster Join and auto-discovery test: OK
09:54:41> Before slots allocation, all nodes report cluster failure: OK
09:54:41> Create a 5 nodes cluster: OK
09:54:45> Test publishing to master: OK
09:54:45> Test publishing to slave: OK
Testing unit: 10-manual-failover.tcl
09:54:45> (init) Restart killed instances: OK
09:54:45> Cluster nodes are reachable: OK
09:54:45> Cluster nodes hard reset: OK
09:54:45> Cluster Join and auto-discovery test: OK
09:54:48> Before slots allocation, all nodes report cluster failure: OK
09:54:48> Create a 5 nodes cluster: OK
09:54:52> Cluster is up: OK
09:54:52> Cluster is writable: OK
09:54:52> Instance #5 is a slave: OK
09:54:52> Instance #5 synced with the master: OK
09:54:53> Send CLUSTER FAILOVER to #5, during load: WWWWWWWWWWOK
09:54:56> Wait for failover: OK
09:54:56> Cluster should eventually be up again: OK
09:54:56> Cluster is writable: OK
09:54:56> Instance #5 is now a master: OK
09:54:56> Verify 50000 keys for consistency with logical content: OK
09:54:57> Instance #0 gets converted into a slave: OK
09:54:57> (init) Restart killed instances: OK
09:54:57> Cluster nodes are reachable: OK
09:54:57> Cluster nodes hard reset: OK
09:54:58> Cluster Join and auto-discovery test: OK
09:55:00> Before slots allocation, all nodes report cluster failure: OK
09:55:00> Create a 5 nodes cluster: OK
09:55:04> Cluster is up: OK
09:55:04> Cluster is writable: OK
09:55:04> Instance #5 is a slave: OK
09:55:04> Instance #5 synced with the master: OK
09:55:04> Make instance #0 unreachable without killing it: OK
09:55:04> Send CLUSTER FAILOVER to instance #5: OK
09:55:04> Instance #5 is still a slave after some time (no failover): OK
09:55:09> Wait for instance #0 to return back alive: OK
09:55:14> (init) Restart killed instances: OK
09:55:14> Cluster nodes are reachable: OK
09:55:14> Cluster nodes hard reset: OK
09:55:14> Cluster Join and auto-discovery test: OK
09:55:17> Before slots allocation, all nodes report cluster failure: OK
09:55:17> Create a 5 nodes cluster: OK
09:55:21> Cluster is up: OK
09:55:21> Cluster is writable: OK
09:55:21> Instance #5 is a slave: OK
09:55:21> Instance #5 synced with the master: OK
09:55:21> Make instance #0 unreachable without killing it: OK
09:55:21> Send CLUSTER FAILOVER to instance #5: OK
09:55:21> Instance #5 is a master after some time: OK
09:55:21> Wait for instance #0 to return back alive: OK
Testing unit: 11-manual-takeover.tcl
09:55:31> (init) Restart killed instances: OK
09:55:31> Cluster nodes are reachable: OK
09:55:31> Cluster nodes hard reset: OK
09:55:31> Cluster Join and auto-discovery test: OK
09:55:34> Before slots allocation, all nodes report cluster failure: OK
09:55:34> Create a 5 nodes cluster: OK
09:55:38> Cluster is up: OK
09:55:38> Cluster is writable: OK
09:55:38> Killing majority of master nodes: OK
09:55:41> Cluster should eventually be down: OK
09:55:42> Use takeover to bring slaves back: OK
09:55:42> Cluster should eventually be up again: OK
09:55:42> Cluster is writable: OK
09:55:42> Instance #5, #6, #7 are now masters: OK
09:55:42> Restarting the previously killed master nodes: OK
09:55:42> Instance #0, #1, #2 gets converted into a slaves: OK
Testing unit: 12-replica-migration-2.tcl
09:55:42> (init) Restart killed instances: OK
09:55:42> Cluster nodes are reachable: OK
09:55:42> Cluster nodes hard reset: OK
09:55:42> Cluster Join and auto-discovery test: OK
09:55:45> Before slots allocation, all nodes report cluster failure: OK
09:55:45> Create a 5 nodes cluster: OK
09:55:48> Cluster is up: OK
09:55:48> Each master should have at least two replicas attached: OK
09:55:48> Resharding all the master #0 slots away from it: >>> Performing Cluster Check (using node 127.0.0.1:30000)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
>>> Rebalancing across 5 nodes. Total weight = 4.0
Moving 909 slots from 127.0.0.1:30000 to 127.0.0.1:30001
#############################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################
Moving 831 slots from 127.0.0.1:30000 to 127.0.0.1:30004
###############################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################
Moving 821 slots from 127.0.0.1:30000 to 127.0.0.1:30003
#####################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################
Moving 724 slots from 127.0.0.1:30000 to 127.0.0.1:30002
####################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################
OK
09:57:18> Master #0 should lose its replicas: OK
09:57:19> Resharding back some slot to master #0: >>> Performing Cluster Check (using node 127.0.0.1:30000)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
>>> Rebalancing across 5 nodes. Total weight = 4.01
Moving 11 slots from 127.0.0.1:30004 to 127.0.0.1:30000
###########
Moving 11 slots from 127.0.0.1:30001 to 127.0.0.1:30000
###########
Moving 11 slots from 127.0.0.1:30002 to 127.0.0.1:30000
###########
Moving 11 slots from 127.0.0.1:30003 to 127.0.0.1:30000
###########
OK
09:57:31> Master #0 should re-acquire one or more replicas: OK
Cleaning up...
GOOD! No errors.