1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/**
* Tests the setShardVersion logic on the this shard side, specifically when comparing
* against a major version of zero or incompatible epochs.
*/
(function() {
'use strict';
var st = new ShardingTest({shards: 2, mongos: 4});
var testDB_s0 = st.s.getDB('test');
assert.commandWorked(testDB_s0.adminCommand({enableSharding: 'test'}));
st.ensurePrimaryShard('test', 'shard0001');
assert.commandWorked(testDB_s0.adminCommand({shardCollection: 'test.user', key: {x: 1}}));
var checkShardMajorVersion = function(conn, expectedVersion) {
var shardVersionInfo = conn.adminCommand({getShardVersion: 'test.user'});
assert.eq(expectedVersion, shardVersionInfo.global.getTime());
};
///////////////////////////////////////////////////////
// Test shard with empty chunk
// shard0: 0|0|a
// shard1: 1|0|a, [-inf, inf)
// mongos0: 1|0|a
var testDB_s1 = st.s1.getDB('test');
assert.writeOK(testDB_s1.user.insert({x: 1}));
assert.commandWorked(
testDB_s1.adminCommand({moveChunk: 'test.user', find: {x: 0}, to: 'shard0000'}));
st.configRS.awaitLastOpCommitted();
// Official config:
// shard0: 2|0|a, [-inf, inf)
// shard1: 0|0|a
//
// Shard metadata:
// shard0: 0|0|a
// shard1: 0|0|a
// mongos0: 1|0|a
checkShardMajorVersion(st.d0, 0);
checkShardMajorVersion(st.d1, 0);
// mongos0 still thinks that { x: 1 } belong to shard0001, but should be able to
// refresh it's metadata correctly.
assert.neq(null, testDB_s0.user.findOne({x: 1}));
checkShardMajorVersion(st.d0, 2);
checkShardMajorVersion(st.d1, 0);
// Set mongos2 & mongos3 to version 2|0|a
var testDB_s2 = st.s2.getDB('test');
assert.neq(null, testDB_s2.user.findOne({x: 1}));
var testDB_s3 = st.s3.getDB('test');
assert.neq(null, testDB_s3.user.findOne({x: 1}));
///////////////////////////////////////////////////////
// Test unsharded collection
// mongos versions: s0, s2, s3: 2|0|a
testDB_s1.user.drop();
assert.writeOK(testDB_s1.user.insert({x: 10}));
// shard0: 0|0|0
// shard1: 0|0|0
// mongos0: 2|0|a
checkShardMajorVersion(st.d0, 0);
checkShardMajorVersion(st.d1, 0);
// mongos0 still thinks { x: 10 } belong to shard0000, but since coll is dropped,
// query should be routed to primary shard.
assert.neq(null, testDB_s0.user.findOne({x: 10}));
checkShardMajorVersion(st.d0, 0);
checkShardMajorVersion(st.d1, 0);
///////////////////////////////////////////////////////
// Test 2 shards with 1 chunk
// mongos versions: s0: 0|0|0, s2, s3: 2|0|a
testDB_s1.user.drop();
testDB_s1.adminCommand({shardCollection: 'test.user', key: {x: 1}});
testDB_s1.adminCommand({split: 'test.user', middle: {x: 0}});
// shard0: 0|0|b,
// shard1: 1|1|b, [-inf, 0), [0, inf)
testDB_s1.user.insert({x: 1});
testDB_s1.user.insert({x: -11});
assert.commandWorked(
testDB_s1.adminCommand({moveChunk: 'test.user', find: {x: -1}, to: 'shard0000'}));
st.configRS.awaitLastOpCommitted();
// Official config:
// shard0: 2|0|b, [-inf, 0)
// shard1: 2|1|b, [0, inf)
//
// Shard metadata:
// shard0: 0|0|b
// shard1: 2|1|b
//
// mongos2: 2|0|a
checkShardMajorVersion(st.d0, 0);
checkShardMajorVersion(st.d1, 2);
// mongos2 still thinks that { x: 1 } belong to shard0000, but should be able to
// refresh it's metadata correctly.
assert.neq(null, testDB_s2.user.findOne({x: 1}));
checkShardMajorVersion(st.d0, 2);
checkShardMajorVersion(st.d1, 2);
// Set shard metadata to 2|0|b
assert.neq(null, testDB_s2.user.findOne({x: -11}));
checkShardMajorVersion(st.d0, 2);
checkShardMajorVersion(st.d1, 2);
// Official config:
// shard0: 2|0|b, [-inf, 0)
// shard1: 2|1|b, [0, inf)
//
// Shard metadata:
// shard0: 2|0|b
// shard1: 2|1|b
//
// mongos3: 2|0|a
// 4th mongos still thinks that { x: 1 } belong to shard0000, but should be able to
// refresh it's metadata correctly.
assert.neq(null, testDB_s3.user.findOne({x: 1}));
///////////////////////////////////////////////////////
// Test mongos thinks unsharded when it's actually sharded
// mongos current versions: s0: 0|0|0, s2, s3: 2|0|b
// Set mongos0 to version 0|0|0
testDB_s0.user.drop();
checkShardMajorVersion(st.d0, 0);
checkShardMajorVersion(st.d1, 0);
assert.eq(null, testDB_s0.user.findOne({x: 1}));
// Needs to also set mongos1 to version 0|0|0, otherwise it'll complain that collection is
// already sharded.
assert.eq(null, testDB_s1.user.findOne({x: 1}));
assert.commandWorked(testDB_s1.adminCommand({shardCollection: 'test.user', key: {x: 1}}));
testDB_s1.user.insert({x: 1});
assert.commandWorked(
testDB_s1.adminCommand({moveChunk: 'test.user', find: {x: 0}, to: 'shard0000'}));
st.configRS.awaitLastOpCommitted();
// Official config:
// shard0: 2|0|c, [-inf, inf)
// shard1: 0|0|c
//
// Shard metadata:
// shard0: 0|0|c
// shard1: 0|0|c
//
// mongos0: 0|0|0
checkShardMajorVersion(st.d0, 0);
checkShardMajorVersion(st.d1, 0);
// 1st mongos thinks that collection is unshareded and will attempt to query primary shard.
assert.neq(null, testDB_s0.user.findOne({x: 1}));
checkShardMajorVersion(st.d0, 2);
checkShardMajorVersion(st.d1, 0);
st.stop();
})();
|
