Revert "SERVER-45599 Backport of SERVER-32198: Split CollectionShardingState::getMetadata into three methods"

This reverts commit a414e4ceafb45dc6ebf4daeb9198f0a7f3fb189c.

3 files changed, 80 insertions, 57 deletions

diff --git a/jstests/sharding/cursor_valid_after_shard_stepdown.js b/jstests/sharding/cursor_valid_after_shard_stepdown.js
index 01e7ee57c30..ea0dd72338f 100644
--- a/jstests/sharding/cursor_valid_after_shard_stepdown.js
+++ b/jstests/sharding/cursor_valid_after_shard_stepdown.js
@@ -38,11 +38,10 @@ TestData.skipCheckingUUIDsConsistentAcrossCluster = true;
     assert.eq(0, getMoreCursor.id);
     assert.eq(2, getMoreCursor.nextBatch[0].x);
 
-    // After stepdown, the shard version will be reset
     var shardVersionAfterStepdown =
         assert.commandWorked(st.rs0.getPrimary().adminCommand({getShardVersion: 'TestDB.TestColl'}))
             .global;
-    assert.eq("UNKNOWN", shardVersionAfterStepdown);
+    assert.eq(Timestamp(0, 0), shardVersionAfterStepdown);
 
     st.stop();
 })();
diff --git a/jstests/sharding/dump_coll_metadata.js b/jstests/sharding/dump_coll_metadata.js
index c1254985dd6..30726f4746d 100644
--- a/jstests/sharding/dump_coll_metadata.js
+++ b/jstests/sharding/dump_coll_metadata.js
@@ -25,13 +25,13 @@
 
     assert.eq(metadata.chunks.length, 1);
     assert.eq(metadata.pending.length, 0);
-    assert.eq(metadata.chunks[0][0]._id, MinKey);
-    assert.eq(metadata.chunks[0][1]._id, MaxKey);
-    assert.eq(metadata.shardVersion, result.global);
+    assert(metadata.chunks[0][0]._id + "" == MinKey + "");
+    assert(metadata.chunks[0][1]._id + "" == MaxKey + "");
+    assert(metadata.shardVersion + "" == result.global + "");
 
     // Make sure a collection with no metadata still returns the metadata field
-    assert.neq(shardAdmin.runCommand({getShardVersion: coll + "xyz", fullMetadata: true}).metadata,
-               undefined);
+    assert(shardAdmin.runCommand({getShardVersion: coll + "xyz", fullMetadata: true}).metadata !=
+           undefined);
 
     // Make sure we get multiple chunks after a split and refresh -- splits by themselves do not
     // cause the shard to refresh.
diff --git a/jstests/sharding/features1.js b/jstests/sharding/features1.js
index 2fabc5a514b..4f36d5675d6 100644
--- a/jstests/sharding/features1.js
+++ b/jstests/sharding/features1.js
@@ -1,63 +1,81 @@
 (function() {
-    'use strict';
 
     var s = new ShardingTest({name: "features1", shards: 2, mongos: 1});
-    assert.commandWorked(s.s0.adminCommand({enablesharding: "test"}));
+
+    s.adminCommand({enablesharding: "test"});
     s.ensurePrimaryShard('test', s.shard1.shardName);
 
     // ---- can't shard system namespaces ----
-    assert.commandFailed(s.s0.adminCommand({shardcollection: "test.system.blah", key: {num: 1}}),
-                         "shard system namespace");
+
+    assert(!s.admin.runCommand({shardcollection: "test.system.blah", key: {num: 1}}).ok,
+           "shard system namespace");
 
     // ---- setup test.foo -----
-    assert.commandWorked(s.s0.adminCommand({shardcollection: "test.foo", key: {num: 1}}));
-    let db = s.s0.getDB("test");
 
-    assert.commandWorked(db.foo.createIndex({y: 1}));
+    s.adminCommand({shardcollection: "test.foo", key: {num: 1}});
+
+    db = s.getDB("test");
+
+    a = s._connections[0].getDB("test");
+    b = s._connections[1].getDB("test");
 
-    assert.commandWorked(s.s0.adminCommand({split: "test.foo", middle: {num: 10}}));
-    assert.commandWorked(s.s0.adminCommand(
-        {movechunk: "test.foo", find: {num: 20}, to: s.getOther(s.getPrimaryShard("test")).name}));
+    db.foo.ensureIndex({y: 1});
 
-    assert.writeOK(db.foo.insert({num: 5}));
-    assert.writeOK(db.foo.save({num: 15}));
+    s.adminCommand({split: "test.foo", middle: {num: 10}});
+    s.adminCommand(
+        {movechunk: "test.foo", find: {num: 20}, to: s.getOther(s.getPrimaryShard("test")).name});
 
-    let a = s.rs0.getPrimary().getDB("test");
-    let b = s.rs1.getPrimary().getDB("test");
+    db.foo.save({num: 5});
+    db.foo.save({num: 15});
+
+    s.sync();
 
     // ---- make sure shard key index is everywhere ----
+
     assert.eq(3, a.foo.getIndexKeys().length, "a index 1");
     assert.eq(3, b.foo.getIndexKeys().length, "b index 1");
 
     // ---- make sure if you add an index it goes everywhere ------
-    assert.commandWorked(db.foo.createIndex({x: 1}));
+
+    db.foo.ensureIndex({x: 1});
+
+    s.sync();
+
     assert.eq(4, a.foo.getIndexKeys().length, "a index 2");
     assert.eq(4, b.foo.getIndexKeys().length, "b index 2");
 
-    // ---- no unique indexes allowed that do not include the shard key ------
-    assert.commandFailed(db.foo.createIndex({z: 1}, true));
+    // ---- no unique indexes ------
+
+    db.foo.ensureIndex({z: 1}, true);
+
+    s.sync();
+
     assert.eq(4, a.foo.getIndexKeys().length, "a index 3");
     assert.eq(4, b.foo.getIndexKeys().length, "b index 3");
 
-    // ---- unique indexes that include the shard key are allowed ------
-    assert.commandWorked(db.foo.createIndex({num: 1, bar: 1}, true));
+    db.foo.ensureIndex({num: 1, bar: 1}, true);
+    s.sync();
     assert.eq(5, b.foo.getIndexKeys().length, "c index 3");
 
-    // ---- can't shard thing with unique indexes ------
-    assert.commandWorked(db.foo2.createIndex({a: 1}));
+    // ---- can't shard thing with unique indexes
+
+    db.foo2.ensureIndex({a: 1});
+    s.sync();
     printjson(db.foo2.getIndexes());
-    assert.commandWorked(s.s0.adminCommand({shardcollection: "test.foo2", key: {num: 1}}),
-                         "shard with index");
+    assert(s.admin.runCommand({shardcollection: "test.foo2", key: {num: 1}}).ok,
+           "shard with index");
 
-    assert.commandWorked(db.foo3.createIndex({a: 1}, true));
+    db.foo3.ensureIndex({a: 1}, true);
+    s.sync();
     printjson(db.foo3.getIndexes());
-    assert.commandFailed(s.s0.adminCommand({shardcollection: "test.foo3", key: {num: 1}}),
-                         "shard with unique index");
+    assert(!s.admin.runCommand({shardcollection: "test.foo3", key: {num: 1}}).ok,
+           "shard with unique index");
 
-    assert.commandWorked(db.foo7.createIndex({num: 1, a: 1}, true));
+    db.foo7.ensureIndex({num: 1, a: 1}, true);
+    s.sync();
     printjson(db.foo7.getIndexes());
-    assert.commandWorked(s.s0.adminCommand({shardcollection: "test.foo7", key: {num: 1}}),
-                         "shard with ok unique index");
+    assert(s.admin.runCommand({shardcollection: "test.foo7", key: {num: 1}}).ok,
+           "shard with ok unique index");
 
     // ----- eval -----
 
@@ -106,16 +124,17 @@
     assert.eq(0, result.ok, "eval should not work for sharded collection in cluster");
 
     // ---- unique shard key ----
-    assert.commandWorked(
-        s.s0.adminCommand({shardcollection: "test.foo4", key: {num: 1}, unique: true}),
-        "shard with index and unique");
-    assert.commandWorked(s.s0.adminCommand({split: "test.foo4", middle: {num: 10}}));
-    assert.commandWorked(s.s0.adminCommand(
-        {movechunk: "test.foo4", find: {num: 20}, to: s.getOther(s.getPrimaryShard("test")).name}));
 
-    assert.writeOK(db.foo4.insert({num: 5}));
-    assert.writeOK(db.foo4.insert({num: 15}));
+    assert(s.admin.runCommand({shardcollection: "test.foo4", key: {num: 1}, unique: true}).ok,
+           "shard with index and unique");
+    s.adminCommand({split: "test.foo4", middle: {num: 10}});
+
+    s.admin.runCommand(
+        {movechunk: "test.foo4", find: {num: 20}, to: s.getOther(s.getPrimaryShard("test")).name});
 
+    assert.writeOK(db.foo4.save({num: 5}));
+    assert.writeOK(db.foo4.save({num: 15}));
+    s.sync();
     assert.eq(1, a.foo4.count(), "ua1");
     assert.eq(1, b.foo4.count(), "ub1");
 
@@ -126,17 +145,16 @@
     assert(b.foo4.getIndexes()[1].unique, "ub3");
 
     assert.eq(2, db.foo4.count(), "uc1");
-    assert.writeOK(db.foo4.insert({num: 7}));
+    db.foo4.save({num: 7});
     assert.eq(3, db.foo4.count(), "uc2");
-    assert.writeError(db.foo4.insert({num: 7}));
+    assert.writeError(db.foo4.save({num: 7}));
     assert.eq(3, db.foo4.count(), "uc4");
 
     // --- don't let you convertToCapped ----
     assert(!db.foo4.isCapped(), "ca1");
     assert(!a.foo4.isCapped(), "ca2");
     assert(!b.foo4.isCapped(), "ca3");
-
-    assert.commandFailed(db.foo4.convertToCapped(30000), "ca30");
+    assert(!db.foo4.convertToCapped(30000).ok, "ca30");
     assert(!db.foo4.isCapped(), "ca4");
     assert(!a.foo4.isCapped(), "ca5");
     assert(!b.foo4.isCapped(), "ca6");
@@ -148,9 +166,11 @@
     assert(db.foo4a.isCapped(), "ca8");
 
     // --- don't let you shard a capped collection
+
     db.createCollection("foo5", {capped: true, size: 30000});
     assert(db.foo5.isCapped(), "cb1");
-    assert.commandFailed(s.s0.adminCommand({shardcollection: "test.foo5", key: {num: 1}}));
+    var res = s.admin.runCommand({shardcollection: "test.foo5", key: {num: 1}});
+    assert(!res.ok, "shard capped: " + tojson(res));
 
     // ----- group ----
 
@@ -200,18 +220,21 @@
     });
 
     // ---- can't shard non-empty collection without index -----
-    assert.writeOK(db.foo8.insert({a: 1}));
-    assert.commandFailed(s.s0.adminCommand({shardcollection: "test.foo8", key: {a: 1}}),
-                         "non-empty collection");
+
+    assert.writeOK(db.foo8.save({a: 1}));
+    assert(!s.admin.runCommand({shardcollection: "test.foo8", key: {a: 1}}).ok,
+           "non-empty collection");
 
     // ---- can't shard non-empty collection with null values in shard key ----
-    assert.writeOK(db.foo9.insert({b: 1}));
-    assert.commandWorked(db.foo9.createIndex({a: 1}));
-    assert.commandFailed(s.s0.adminCommand({shardcollection: "test.foo9", key: {a: 1}}),
-                         "entry with null value");
+
+    assert.writeOK(db.foo9.save({b: 1}));
+    db.foo9.ensureIndex({a: 1});
+    assert(!s.admin.runCommand({shardcollection: "test.foo9", key: {a: 1}}).ok,
+           "entry with null value");
 
     // --- listDatabases ---
-    var r = db.getMongo().getDBs();
+
+    r = db.getMongo().getDBs();
     assert.eq(3, r.databases.length, tojson(r));
     assert.eq("number", typeof(r.totalSize), "listDatabases 3 : " + tojson(r));
 
@@ -222,4 +245,5 @@
     assert.commandWorked(s.s0.adminCommand({flushRouterConfig: 'TestDB.TestColl'}));
 
     s.stop();
+
 })();