1start_server {tags {"repl"}} {
2    start_server {} {
3        test {First server should have role slave after SLAVEOF} {
4            r -1 slaveof [srv 0 host] [srv 0 port]
5            wait_for_condition 50 100 {
6                [s -1 role] eq {slave} &&
7                [string match {*master_link_status:up*} [r -1 info replication]]
8            } else {
9                fail "Can't turn the instance into a slave"
10            }
11        }
12
13        test {BRPOPLPUSH replication, when blocking against empty list} {
14            set rd [redis_deferring_client]
15            $rd brpoplpush a b 5
16            r lpush a foo
17            wait_for_condition 50 100 {
18                [r debug digest] eq [r -1 debug digest]
19            } else {
20                fail "Master and slave have different digest: [r debug digest] VS [r -1 debug digest]"
21            }
22        }
23
24        test {BRPOPLPUSH replication, list exists} {
25            set rd [redis_deferring_client]
26            r lpush c 1
27            r lpush c 2
28            r lpush c 3
29            $rd brpoplpush c d 5
30            after 1000
31            assert_equal [r debug digest] [r -1 debug digest]
32        }
33    }
34}
35
36start_server {tags {"repl"}} {
37    r set mykey foo
38
39    start_server {} {
40        test {Second server should have role master at first} {
41            s role
42        } {master}
43
44        test {SLAVEOF should start with link status "down"} {
45            r slaveof [srv -1 host] [srv -1 port]
46            s master_link_status
47        } {down}
48
49        test {The role should immediately be changed to "slave"} {
50            s role
51        } {slave}
52
53        wait_for_sync r
54        test {Sync should have transferred keys from master} {
55            r get mykey
56        } {foo}
57
58        test {The link status should be up} {
59            s master_link_status
60        } {up}
61
62        test {SET on the master should immediately propagate} {
63            r -1 set mykey bar
64
65            wait_for_condition 500 100 {
66                [r  0 get mykey] eq {bar}
67            } else {
68                fail "SET on master did not propagated on slave"
69            }
70        }
71
72        test {FLUSHALL should replicate} {
73            r -1 flushall
74            if {$::valgrind} {after 2000}
75            list [r -1 dbsize] [r 0 dbsize]
76        } {0 0}
77
78        test {ROLE in master reports master with a slave} {
79            set res [r -1 role]
80            lassign $res role offset slaves
81            assert {$role eq {master}}
82            assert {$offset > 0}
83            assert {[llength $slaves] == 1}
84            lassign [lindex $slaves 0] master_host master_port slave_offset
85            assert {$slave_offset <= $offset}
86        }
87
88        test {ROLE in slave reports slave in connected state} {
89            set res [r role]
90            lassign $res role master_host master_port slave_state slave_offset
91            assert {$role eq {slave}}
92            assert {$slave_state eq {connected}}
93        }
94    }
95}
96
97foreach dl {no yes} {
98    start_server {tags {"repl"}} {
99        set master [srv 0 client]
100        $master config set repl-diskless-sync $dl
101        set master_host [srv 0 host]
102        set master_port [srv 0 port]
103        set slaves {}
104        set load_handle0 [start_write_load $master_host $master_port 3]
105        set load_handle1 [start_write_load $master_host $master_port 5]
106        set load_handle2 [start_write_load $master_host $master_port 20]
107        set load_handle3 [start_write_load $master_host $master_port 8]
108        set load_handle4 [start_write_load $master_host $master_port 4]
109        start_server {} {
110            lappend slaves [srv 0 client]
111            start_server {} {
112                lappend slaves [srv 0 client]
113                start_server {} {
114                    lappend slaves [srv 0 client]
115                    test "Connect multiple slaves at the same time (issue #141), diskless=$dl" {
116                        # Send SALVEOF commands to slaves
117                        [lindex $slaves 0] slaveof $master_host $master_port
118                        [lindex $slaves 1] slaveof $master_host $master_port
119                        [lindex $slaves 2] slaveof $master_host $master_port
120
121                        # Wait for all the three slaves to reach the "online"
122                        # state from the POV of the master.
123                        set retry 500
124                        while {$retry} {
125                            set info [r -3 info]
126                            if {[string match {*slave0:*state=online*slave1:*state=online*slave2:*state=online*} $info]} {
127                                break
128                            } else {
129                                incr retry -1
130                                after 100
131                            }
132                        }
133                        if {$retry == 0} {
134                            error "assertion:Slaves not correctly synchronized"
135                        }
136
137                        # Wait that slaves acknowledge they are online so
138                        # we are sure that DBSIZE and DEBUG DIGEST will not
139                        # fail because of timing issues.
140                        wait_for_condition 500 100 {
141                            [lindex [[lindex $slaves 0] role] 3] eq {connected} &&
142                            [lindex [[lindex $slaves 1] role] 3] eq {connected} &&
143                            [lindex [[lindex $slaves 2] role] 3] eq {connected}
144                        } else {
145                            fail "Slaves still not connected after some time"
146                        }
147
148                        # Stop the write load
149                        stop_write_load $load_handle0
150                        stop_write_load $load_handle1
151                        stop_write_load $load_handle2
152                        stop_write_load $load_handle3
153                        stop_write_load $load_handle4
154
155                        # Make sure that slaves and master have same
156                        # number of keys
157                        wait_for_condition 500 100 {
158                            [$master dbsize] == [[lindex $slaves 0] dbsize] &&
159                            [$master dbsize] == [[lindex $slaves 1] dbsize] &&
160                            [$master dbsize] == [[lindex $slaves 2] dbsize]
161                        } else {
162                            fail "Different number of keys between masted and slave after too long time."
163                        }
164
165                        # Check digests
166                        set digest [$master debug digest]
167                        set digest0 [[lindex $slaves 0] debug digest]
168                        set digest1 [[lindex $slaves 1] debug digest]
169                        set digest2 [[lindex $slaves 2] debug digest]
170                        assert {$digest ne 0000000000000000000000000000000000000000}
171                        assert {$digest eq $digest0}
172                        assert {$digest eq $digest1}
173                        assert {$digest eq $digest2}
174                    }
175               }
176            }
177        }
178    }
179}
180