21 files changed, 522 insertions, 68 deletions
diff --git a/jstests/filemd5.js b/jstests/filemd5.js
new file mode 100644
index 0000000..41d03a1
--- /dev/null
+++ b/jstests/filemd5.js
@@ -0,0 +1,11 @@
+
+db.fs.chunks.drop();
+db.fs.chunks.insert({files_id:1,n:0,data:new BinData(0,"test")})
+
+x = db.runCommand({"filemd5":1,"root":"fs"});
+assert( ! x.ok , tojson(x) )
+
+db.fs.chunks.ensureIndex({files_id:1,n:1})
+x = db.runCommand({"filemd5":1,"root":"fs"});
+assert( x.ok , tojson(x) )
+
diff --git a/jstests/profile1.js b/jstests/profile1.js
index 9654357..ba01d59 100644
--- a/jstests/profile1.js
+++ b/jstests/profile1.js
@@ -55,12 +55,18 @@ try {
 
     db.eval("sleep(1)") // pre-load system.js
 
-    db.setProfilingLevel(2);
-    before = db.system.profile.count();
+    function resetProfile( level , slowms ) {
+        db.setProfilingLevel(0);
+        db.system.profile.drop();
+        db.setProfilingLevel(level,slowms);
+    }
+
+    resetProfile(2);
+
     db.eval( "sleep(25)" )
     db.eval( "sleep(120)" )
-    after = db.system.profile.count()
-    assert.eq( before + 3 , after , "X1" )
+    
+    assert.eq( 2 , db.system.profile.find( { "command.$eval" : /^sleep/ } ).count() );
 
     /* sleep() could be inaccurate on certain platforms.  let's check */
     print("\nsleep 2 time actual:");
@@ -90,24 +96,20 @@ try {
         return actual >= max ? 1 : 0;
     }
 
-    db.setProfilingLevel(1,100);
-    before = db.system.profile.count();
+    resetProfile(1,100);
     var delta = 0;
     delta += evalSleepMoreThan( 15 , 100 );
     delta += evalSleepMoreThan( 120 , 100 );
-    after = db.system.profile.count()
-    assert.eq( before + delta , after , "X2 : " + getProfileAString() )
+    assert.eq( delta , db.system.profile.find( { "command.$eval" : /^sleep/ } ).count() , "X2 : " + getProfileAString() )
 
-    db.setProfilingLevel(1,20);
-    before = db.system.profile.count();
+    resetProfile(1,20);
     delta = 0;
     delta += evalSleepMoreThan( 5 , 20 );
     delta += evalSleepMoreThan( 120 , 20 );
-    after = db.system.profile.count()
-    assert.eq( before + delta , after , "X3 : " + getProfileAString() )
+    assert.eq( delta , db.system.profile.find( { "command.$eval" : /^sleep/ } ).count() , "X3 : " + getProfileAString() )
         
-    db.profile.drop();
-    db.setProfilingLevel(2)
+    resetProfile(2);
+    db.profile1.drop();
     var q = { _id : 5 };
     var u = { $inc : { x : 1 } };
     db.profile1.update( q , u );
diff --git a/jstests/replsets/auth1.js b/jstests/replsets/auth1.js
index 71ab2d9..40a131a 100644
--- a/jstests/replsets/auth1.js
+++ b/jstests/replsets/auth1.js
@@ -8,11 +8,11 @@ var path = "jstests/libs/";
 
 
 print("try starting mongod with auth");
-var m = runMongoProgram( "mongod", "--auth", "--port", port[4], "--dbpath", "/data/db/wrong-auth");
+var pargs = new MongodRunner( port[4], "/data/db/wrong-auth", false, false,
+                              ["--auth"], {no_bind : true} );
+var m = pargs.start();
 
-assert.throws(function() {
-    m.getDB("local").auth("__system", "");
-});
+assert.eq(m.getDB("local").auth("__system", ""), 0);
 
 stopMongod(port[4]);
 
@@ -25,7 +25,6 @@ run("chmod", "644", path+"key2");
 print("try starting mongod");
 m = runMongoProgram( "mongod", "--keyFile", path+"key1", "--port", port[0], "--dbpath", "/data/db/" + name);
 
-
 print("should fail with wrong permissions");
 assert.eq(m, 2, "mongod should exit w/ 2: permissions too open");
 stopMongod(port[0]);
diff --git a/jstests/replsets/auth2.js b/jstests/replsets/auth2.js
new file mode 100644
index 0000000..0fe1ae4
--- /dev/null
+++ b/jstests/replsets/auth2.js
@@ -0,0 +1,103 @@
+var name = "rs_auth2";
+var port = allocatePorts(3);
+var path = "jstests/libs/";
+
+print("change permissions on #1 & #2");
+run("chmod", "600", path+"key1");
+run("chmod", "600", path+"key2");
+
+var setupReplSet = function() {
+    print("start up rs");
+    var rs = new ReplSetTest({"name" : name, "nodes" : 3, "startPort" : port[0]});
+    rs.startSet();
+    rs.initiate();
+
+    print("getting master");
+    rs.getMaster();
+
+    print("getting secondaries");
+    assert.soon(function() {
+        var result1 = rs.nodes[1].getDB("admin").runCommand({isMaster: 1});
+        var result2 = rs.nodes[2].getDB("admin").runCommand({isMaster: 1});
+        return result1.secondary && result2.secondary;
+    });
+
+    return rs;
+};
+
+var checkNoAuth = function() {
+    print("without an admin user, things should work");
+
+    master.getDB("foo").bar.insert({x:1});
+    var result = master.getDB("admin").runCommand({getLastError:1});
+
+    printjson(result);
+    assert.eq(result.err, null);
+}
+
+var checkInvalidAuthStates = function() {
+    print("check that 0 is in recovering");
+    assert.soon(function() {
+        try {
+            var result = m.getDB("admin").runCommand({isMaster: 1});
+            return !result.ismaster && !result.secondary;
+        }
+        catch ( e ) {
+            print( e );
+        }
+    });
+
+    print("shut down 1, 0 still in recovering.");
+    rs.stop(1);
+    sleep(5);
+
+    assert.soon(function() {
+        var result = m.getDB("admin").runCommand({isMaster: 1});
+        return !result.ismaster && !result.secondary;
+    });
+
+    print("shut down 2, 0 becomes a secondary.");
+    rs.stop(2);
+
+    assert.soon(function() {
+        var result = m.getDB("admin").runCommand({isMaster: 1});
+        return result.secondary;
+    });
+
+    rs.restart(1, {"keyFile" : path+"key1"});
+    rs.restart(2, {"keyFile" : path+"key1"});
+};
+
+var checkValidAuthState = function() {
+    assert.soon(function() {
+        var result = m.getDB("admin").runCommand({isMaster : 1});
+        return result.secondary;
+    });
+};
+
+var rs = setupReplSet();
+var master = rs.getMaster();
+
+print("add an admin user");
+master.getDB("admin").addUser("foo","bar");
+m = rs.nodes[0];
+
+print("starting 1 and 2 with key file");
+rs.stop(1);
+rs.restart(1, {"keyFile" : path+"key1"});
+rs.stop(2);
+rs.restart(2, {"keyFile" : path+"key1"});
+
+checkInvalidAuthStates();
+
+print("restart mongod with bad keyFile");
+
+rs.stop(0);
+m = rs.restart(0, {"keyFile" : path+"key2"});
+
+checkInvalidAuthStates();
+
+rs.stop(0);
+m = rs.restart(0, {"keyFile" : path+"key1"});
+
+print("0 becomes a secondary");
diff --git a/jstests/replsets/initial_sync3.js b/jstests/replsets/initial_sync3.js
index 7f2af94..ef45581 100644
--- a/jstests/replsets/initial_sync3.js
+++ b/jstests/replsets/initial_sync3.js
@@ -1,11 +1,6 @@
 /* test initial sync options
  *
- * {state : 1}
- * {state : 2}
- * {name : host+":"+port}
- * {_id : 2}
- * {optime : now}
- * {optime : 1970}
+ * Make sure member can't sync from a member with a different buildIndexes setting.
  */
 
 load("jstests/replsets/rslib.js");
@@ -14,46 +9,44 @@ var host = getHostName();
 var port = allocatePorts(7);
 
 print("Start set with three nodes");
-var replTest = new ReplSetTest( {name: name, nodes: 7} );
+var replTest = new ReplSetTest( {name: name, nodes: 3} );
 var nodes = replTest.startSet();
 replTest.initiate({
     _id : name,
     members : [
-               {_id:0, host : host+":"+port[0]},
-               {_id:1, host : host+":"+port[1], initialSync : {state : 1}},
-               {_id:2, host : host+":"+port[2], initialSync : {state : 2}},
-               {_id:3, host : host+":"+port[3], initialSync : {name : host+":"+port[2]}},
-               {_id:4, host : host+":"+port[4], initialSync : {_id : 2}},
-               {_id:5, host : host+":"+port[5], initialSync : {optime : new Date()}},
-               {_id:6, host : host+":"+port[6], initialSync : {optime : new Date(0)}}
+        {_id:0, host : host+":"+port[0]},
+        {_id:1, host : host+":"+port[1]},
+        {_id:2, host : host+":"+port[2], priority : 0, buildIndexes : false},
                ]});
 
 var master = replTest.getMaster();
 
 print("Initial sync");
 master.getDB("foo").bar.baz.insert({x:1});
+replTest.awaitReplication();
 
-print("Make sure everyone's secondary");
-wait(function() {
-    var status = master.getDB("admin").runCommand({replSetGetStatus:1});
-    occasionally(function() {
-        printjson(status);
-      });
+replTest.stop(0);
+replTest.stop(1);
 
-    if (!status.members) {
-      return false;
-    }
+print("restart 1, clearing its data directory so it has to resync");
+replTest.start(1);
 
-    for (i=0; i<7; i++) {
-      if (status.members[i].state != 1 && status.members[i].state != 2) {
-        return false;
-      }
-    }
-    return true;
+print("make sure 1 does not become a secondary (because it cannot clone from 2)");
+sleep(10000);
+reconnect(nodes[1]);
+var result = nodes[1].getDB("admin").runCommand({isMaster : 1});
+assert(!result.ismaster, tojson(result));
+assert(!result.secondary, tojson(result));
 
-  });
+print("bring 0 back up");
+replTest.restart(0);
 
-replTest.awaitReplication();
+print("now 1 should be able to initial sync");
+assert.soon(function() {
+    var result = nodes[1].getDB("admin").runCommand({isMaster : 1});
+    printjson(result);
+    return result.secondary;
+});
 
 replTest.stopSet();
 
diff --git a/jstests/replsets/reconfig.js b/jstests/replsets/reconfig.js
index b7dca03..55ee505 100644
--- a/jstests/replsets/reconfig.js
+++ b/jstests/replsets/reconfig.js
@@ -64,6 +64,6 @@ result = nodes[0].getDB("admin").runCommand({replSetInitiate : {_id : "testSet2"
     {_id : 0, tags : ["member0"]}
    ]}});
 
-assert(result.errmsg.match(/bad or missing host field/));
+assert(result.errmsg.match(/bad or missing host field/) , "error message doesn't match, got result:" + tojson(result) );
 
 replTest2.stopSet();
diff --git a/jstests/replsets/stepdown.js b/jstests/replsets/stepdown.js
index 3a17b0e..67f10f9 100644
--- a/jstests/replsets/stepdown.js
+++ b/jstests/replsets/stepdown.js
@@ -36,12 +36,15 @@ printjson(result);
 assert.eq(result.ok, 0);
 
 print("\n do stepdown that should work");
+var threw = false;
 try {
     master.getDB("admin").runCommand({replSetStepDown: 50, force : true});
 }
 catch (e) {
     print(e);
+    threw = true;
 }
+assert(threw);
 
 var r2 = master.getDB("admin").runCommand({ismaster : 1});
 assert.eq(r2.ismaster, false);
diff --git a/jstests/sharding/auth.js b/jstests/sharding/auth.js
index 8d8d7d7..c9bf1e1 100644
--- a/jstests/sharding/auth.js
+++ b/jstests/sharding/auth.js
@@ -146,13 +146,17 @@ for (i=0; i<num; i++) {
     s.getDB("test").foo.insert({x:i, abc : "defg", date : new Date(), str : "all the talk on the market"});
 }
 
-var d1Chunks = s.getDB("config").chunks.count({shard : "d1"});
-var d2Chunks = s.getDB("config").chunks.count({shard : "d2"});
-var totalChunks = s.getDB("config").chunks.count({ns : "test.foo"});
+assert.soon( function(){
 
-print("chunks: " + d1Chunks+" "+d2Chunks+" "+totalChunks);
+        var d1Chunks = s.getDB("config").chunks.count({shard : "d1"});
+        var d2Chunks = s.getDB("config").chunks.count({shard : "d2"});
+        var totalChunks = s.getDB("config").chunks.count({ns : "test.foo"});
 
-assert(d1Chunks > 0 && d2Chunks > 0 && d1Chunks+d2Chunks == totalChunks);
+        print("chunks: " + d1Chunks+" "+d2Chunks+" "+totalChunks);
+
+        return d1Chunks > 0 && d2Chunks > 0 && d1Chunks+d2Chunks == totalChunks;
+    }
+    )
 
 assert.eq(s.getDB("test").foo.count(), num+1);
 
diff --git a/jstests/sharding/auto1.js b/jstests/sharding/auto1.js
index bdd43e9..57b0a00 100644
--- a/jstests/sharding/auto1.js
+++ b/jstests/sharding/auto1.js
@@ -58,7 +58,8 @@ counts.push( s.config.chunks.count() );
 
 assert( counts[counts.length-1] > counts[0] , "counts 1 : " + tojson( counts ) )
 sorted = counts.slice(0)
-sorted.sort();
+// Sort doesn't sort numbers correctly by default, resulting in fail
+sorted.sort( function(a, b){ return a - b } )
 assert.eq( counts , sorted , "counts 2 : " + tojson( counts ) )
 
 print( counts )
diff --git a/jstests/sharding/bouncing_count.js b/jstests/sharding/bouncing_count.js
new file mode 100644
index 0000000..d9630a4
--- /dev/null
+++ b/jstests/sharding/bouncing_count.js
@@ -0,0 +1,49 @@
+// Tests whether new sharding is detected on insert by mongos
+
+var st = new ShardingTest( name = "test", shards = 10, verbose = 0, mongos = 3 )
+
+var mongosA = st.s0
+var mongosB = st.s1
+var mongosC = st.s2
+
+var admin = mongosA.getDB("admin")
+var config = mongosA.getDB("config")
+
+var collA = mongosA.getCollection( "foo.bar" )
+var collB = mongosB.getCollection( "" + collA )
+var collC = mongosB.getCollection( "" + collA )
+
+admin.runCommand({ enableSharding : "" + collA.getDB() })
+admin.runCommand({ shardCollection : "" + collA, key : { _id : 1 } })
+
+var shards = config.shards.find().sort({ _id : 1 }).toArray()
+
+jsTestLog( "Splitting up the collection..." )
+
+// Split up the collection
+for( var i = 0; i < shards.length; i++ ){
+    printjson( admin.runCommand({ split : "" + collA, middle : { _id : i } }) )
+    printjson( admin.runCommand({ moveChunk : "" + collA, find : { _id : i }, to : shards[i]._id }) )
+}
+
+mongosB.getDB("admin").runCommand({ flushRouterConfig : 1 })
+mongosC.getDB("admin").runCommand({ flushRouterConfig : 1 })
+printjson( collB.count() )
+printjson( collC.count() )
+
+// Change up all the versions...
+for( var i = 0; i < shards.length; i++ ){
+    printjson( admin.runCommand({ moveChunk : "" + collA, find : { _id : i }, to : shards[ (i + 1) % shards.length ]._id }) )
+}
+
+// Make sure mongos A is up-to-date
+mongosA.getDB("admin").runCommand({ flushRouterConfig : 1 })
+
+config.printShardingStatus( true )
+
+jsTestLog( "Running count!" )
+
+printjson( collB.count() )
+printjson( collC.find().toArray() )
+
+st.stop()
+\ No newline at end of file
diff --git a/jstests/sharding/migrateBig.js b/jstests/sharding/migrateBig.js
index 917f152..1613f17 100644
--- a/jstests/sharding/migrateBig.js
+++ b/jstests/sharding/migrateBig.js
@@ -35,8 +35,16 @@ db.printShardingStatus()
 
 assert.throws( function(){  s.adminCommand( { movechunk : "test.foo" , find : { x : 50 } , to : s.getOther( s.getServer( "test" ) ).name } ); } , [] , "move should fail" )
 
-for ( i=0; i<20; i+= 2 )
-    s.adminCommand( { split : "test.foo" , middle : { x : i } } )
+for ( i=0; i<20; i+= 2 ) {
+    try {
+        s.adminCommand( { split : "test.foo" , middle : { x : i } } );
+    }
+    catch ( e ) {
+        // we may have auto split on some of these
+        // which is ok
+        print(e);
+    }
+}
 
 db.printShardingStatus()
 
diff --git a/jstests/sharding/reset_shard_version.js b/jstests/sharding/reset_shard_version.js
new file mode 100644
index 0000000..ea4a76c
--- /dev/null
+++ b/jstests/sharding/reset_shard_version.js
@@ -0,0 +1,51 @@
+// Tests whether a reset sharding version triggers errors
+
+jsTestLog( "Starting sharded cluster..." )
+
+var st = new ShardingTest( { shards : 1, mongos : 2 } )
+
+var mongosA = st.s0
+var mongosB = st.s1
+
+var collA = mongosA.getCollection( jsTestName() + ".coll" )
+collA.drop()
+var collB = mongosB.getCollection( "" + collA )
+
+st.shardColl( collA, { _id : 1 }, false )
+
+jsTestLog( "Inserting data..." )
+
+// Insert some data
+for ( var i = 0; i < 100; i++ ) {
+    collA.insert( { _id : i } )
+}
+
+jsTestLog( "Setting connection versions on both mongoses..." )
+
+assert.eq( collA.find().itcount(), 100 )
+assert.eq( collB.find().itcount(), 100 )
+
+jsTestLog( "Resetting connection version on shard..." )
+
+var admin = st.shard0.getDB( "admin" )
+
+printjson( admin.runCommand( {
+    setShardVersion : "" + collA, version : new Timestamp( 0, 0 ), configdb : st._configDB, serverID : new ObjectId(),
+    authoritative : true } ) )
+
+jsTestLog( "Querying with version reset..." )
+
+// This will cause a version check
+assert.eq(0, collA.findOne({_id:0})['_id'])
+
+jsTestLog( "Resetting connection version on shard again..." )
+
+printjson( admin.runCommand( {
+    setShardVersion : "" + collA, version : new Timestamp( 0, 0 ), configdb : st._configDB, serverID : new ObjectId(),
+    authoritative : true } ) )
+
+jsTestLog( "Doing count command with version reset..." )
+
+assert.eq(100, collA.count()) // Test for SERVER-4196
+
+st.stop()
+\ No newline at end of file
diff --git a/jstests/sharding/shard_existing.js b/jstests/sharding/shard_existing.js
new file mode 100644
index 0000000..315445e
--- /dev/null
+++ b/jstests/sharding/shard_existing.js
@@ -0,0 +1,33 @@
+
+s = new ShardingTest( "shard_existing" , 2 /* numShards */, 1 /* verboseLevel */, 1 /* numMongos */, { chunksize : 1 } )
+
+db = s.getDB( "test" )
+
+stringSize = 10000
+
+// we want a lot of data, so lets make a string to cheat :)
+bigString = "";
+while ( bigString.length < stringSize )
+    bigString += "this is a big string. ";
+
+dataSize = 20 * 1024 * 1024;
+
+numToInsert = dataSize / stringSize 
+print( "numToInsert: " + numToInsert )
+
+for ( i=0; i<(dataSize/stringSize); i++ ) {
+    db.data.insert( { _id : i , s : bigString } )
+}
+
+db.getLastError();
+
+assert.lt( dataSize , db.data.stats().size )
+
+s.adminCommand( { enablesharding : "test" } );
+res = s.adminCommand( { shardcollection : "test.data" , key : { _id : 1 } } );
+printjson( res );
+
+assert.eq( 40 , s.config.chunks.find().itcount() , "not right number of chunks" );
+
+
+s.stop();
diff --git a/jstests/sharding/sort1.js b/jstests/sharding/sort1.js
index e2b287e..235e5c0 100644
--- a/jstests/sharding/sort1.js
+++ b/jstests/sharding/sort1.js
@@ -22,11 +22,18 @@ s.adminCommand( { split : "test.data" , middle : { 'sub.num' : 66 } } )
 
 s.adminCommand( { movechunk : "test.data" , find : { 'sub.num' : 50 } , to : s.getOther( s.getServer( "test" ) ).name } );
 
-assert.eq( 3 , s.config.chunks.find().itcount() , "A1" );
+assert.lte( 3 , s.config.chunks.find().itcount() , "A1" );
 
 temp = s.config.chunks.find().sort( { min : 1 } ).toArray();
-assert.eq( temp[0].shard , temp[2].shard , "A2" );
-assert.neq( temp[0].shard , temp[1].shard , "A3" );
+temp.forEach( printjsononeline )
+
+z = 0;
+for ( ; z<temp.length; z++ ) 
+    if ( temp[z].min["sub.num"] <= 50 && temp[z].max["sub.num"] > 50 )
+        break;
+
+assert.eq( temp[z-1].shard , temp[z+1].shard , "A2" );
+assert.neq( temp[z-1].shard , temp[z].shard , "A3" );
 
 temp = db.data.find().sort( { 'sub.num' : 1 } ).toArray();
 assert.eq( N , temp.length , "B1" );
diff --git a/jstests/sharding/writeback_shard_version.js b/jstests/sharding/writeback_shard_version.js
new file mode 100644
index 0000000..34af1f0
--- /dev/null
+++ b/jstests/sharding/writeback_shard_version.js
@@ -0,0 +1,42 @@
+// Tests whether a newly sharded collection can be handled by the wbl
+
+jsTestLog( "Starting sharded cluster..." )
+
+// Need to start as a replica set here, just because there's no other way to trigger separate configs,
+// See SERVER-4222
+var st = new ShardingTest( { shards : 1, mongos : 2, verbose : 2, other : { rs : true } } )
+
+st.setBalancer( false )
+
+var mongosA = st.s0
+var mongosB = st.s1
+
+jsTestLog( "Adding new collections...")
+
+var collA = mongosA.getCollection( jsTestName() + ".coll" )
+collA.insert({ hello : "world" })
+assert.eq( null, collA.getDB().getLastError() )
+
+var collB = mongosB.getCollection( "" + collA )
+collB.insert({ hello : "world" })
+assert.eq( null, collB.getDB().getLastError() )
+
+jsTestLog( "Enabling sharding..." )
+
+printjson( mongosA.getDB( "admin" ).runCommand({ enableSharding : "" + collA.getDB() }) )
+printjson( mongosA.getDB( "admin" ).runCommand({ shardCollection : "" + collA, key : { _id : 1 } }) )
+
+// MongoD doesn't know about the config shard version *until* MongoS tells it
+collA.findOne()
+
+jsTestLog( "Trigger wbl..." )
+
+collB.insert({ goodbye : "world" })
+assert.eq( null, collB.getDB().getLastError() )
+
+print( "Inserted..." )
+
+assert.eq( 3, collA.find().itcount() )
+assert.eq( 3, collB.find().itcount() )
+
+st.stop()
+\ No newline at end of file
diff --git a/jstests/slowNightly/large_chunk.js b/jstests/slowNightly/large_chunk.js
index 6cf40e3..1f0b2e6 100644
--- a/jstests/slowNightly/large_chunk.js
+++ b/jstests/slowNightly/large_chunk.js
@@ -13,10 +13,6 @@ db = s.getDB( "test" );
 // Step 1 - Test moving a large chunk
 //
 
-// Turn on sharding on the 'test.foo' collection and generate a large chunk
-s.adminCommand( { enablesharding : "test" } );
-s.adminCommand( { shardcollection : "test.foo" , key : { _id : 1 } } );
-
 bigString = ""
 while ( bigString.length < 10000 )
     bigString += "asdasdasdasdadasdasdasdasdasdasdasdasda";
@@ -28,6 +24,11 @@ while ( inserted < ( 400 * 1024 * 1024 ) ){
     inserted += bigString.length;
 }
 db.getLastError();
+
+// Turn on sharding on the 'test.foo' collection and generate a large chunk
+s.adminCommand( { enablesharding : "test" } );
+s.adminCommand( { shardcollection : "test.foo" , key : { _id : 1 } } );
+
 assert.eq( 1 , s.config.chunks.count() , "step 1 - need one large chunk" );
 
 primary = s.getServer( "test" ).getDB( "test" );
@@ -48,4 +49,4 @@ assert.neq( before[0].shard , after[0].shard , "move chunk did not work" );
 
 s.config.changelog.find().forEach( printjson )
 
-s.stop();
-\ No newline at end of file
+s.stop();
diff --git a/jstests/slowNightly/replica_set_shard_version.js b/jstests/slowNightly/replica_set_shard_version.js
new file mode 100644
index 0000000..6221f4c
--- /dev/null
+++ b/jstests/slowNightly/replica_set_shard_version.js
@@ -0,0 +1,83 @@
+// Tests whether a Replica Set in a mongos cluster can cause versioning problems
+
+jsTestLog( "Starting sharded cluster..." )
+
+var st = new ShardingTest( { shards : 1, mongos : 2, other : { rs : true } } )
+
+var mongosA = st.s0
+var mongosB = st.s1
+var rs = st._rs[0].test
+var shard = st.shard0
+
+var sadmin = shard.getDB( "admin" )
+
+jsTestLog( "Stepping down replica set member..." )
+
+try{
+    sadmin.runCommand({ replSetStepDown : 3000, force : true })
+}
+catch( e ){
+    // stepdown errors out our conn to the shard
+    printjson( e )
+}
+
+jsTestLog( "Reconnecting..." )
+
+sadmin = new Mongo( st.shard0.host ).getDB("admin")
+
+assert.soon( 
+    function(){
+        var res = sadmin.runCommand( "replSetGetStatus" );
+        for ( var i=0; i<res.members.length; i++ ) {
+            if ( res.members[i].state == 1 )
+                return true;
+        }
+        return false;
+    }
+);
+
+jsTestLog( "New primary elected..." )
+
+coll = mongosA.getCollection( jsTestName() + ".coll" );
+
+start = new Date();
+
+ReplSetTest.awaitRSClientHosts( coll.getMongo(), rs.getPrimary(), { ismaster : true }, rs )
+
+try{
+    coll.findOne()
+}
+catch( e ){
+    printjson( e )
+    assert( false )
+}
+
+end = new Date();
+
+print( "time to work for primary: " + ( ( end.getTime() - start.getTime() ) / 1000 ) + " seconds" );
+
+jsTestLog( "Found data from collection..." )
+
+// now check secondary
+
+try{
+    sadmin.runCommand({ replSetStepDown : 3000, force : true })
+}
+catch( e ){
+    // expected, since all conns closed
+    printjson( e )
+}
+
+sadmin = new Mongo( st.shard0.host ).getDB("admin")
+
+jsTestLog( "Stepped down secondary..." )
+
+other = new Mongo( mongosA.host );
+other.setSlaveOk( true );
+other = other.getCollection( jsTestName() + ".coll" );
+
+print( "eliot: " + tojson( other.findOne() ) );
+
+
+
+st.stop()
diff --git a/jstests/slowNightly/sharding_migrateBigObject.js b/jstests/slowNightly/sharding_migrateBigObject.js
index 5ad9ed1..8bf6713 100644
--- a/jstests/slowNightly/sharding_migrateBigObject.js
+++ b/jstests/slowNightly/sharding_migrateBigObject.js
@@ -51,7 +51,7 @@ assert.soon(
         return res.length > 1 && Math.abs( res[0].nChunks - res[1].nChunks ) <= 3;
 
     } , 
-    "never migrated" , 180000 , 1000 );
+    "never migrated" , 9 * 60 * 1000 , 1000 );
 
 stopMongod( 30000 );
 stopMongod( 29999 );
diff --git a/jstests/slowNightly/sharding_rs2.js b/jstests/slowNightly/sharding_rs2.js
index 4de935b..162a9c6 100644
--- a/jstests/slowNightly/sharding_rs2.js
+++ b/jstests/slowNightly/sharding_rs2.js
@@ -71,6 +71,11 @@ for ( i=0; i<10; i++ )
     assert.eq( 17 , ts.findOne().x , "B1" )
 
 m.setSlaveOk()
+
+// Confusingly, v2.0 mongos does not actually update the secondary status of any members until after the first 
+// ReplicaSetMonitorWatcher round.  Wait for that here.
+ReplSetTest.awaitRSClientHosts( m, rs.test.getSecondaries()[0], { secondary : true } )
+
 for ( i=0; i<10; i++ )
     assert.eq( 17 , ts.findOne().x , "B2" )
 
diff --git a/jstests/tool/dumpsecondary.js b/jstests/tool/dumpsecondary.js
new file mode 100644
index 0000000..4edb3f1
--- /dev/null
+++ b/jstests/tool/dumpsecondary.js
@@ -0,0 +1,32 @@
+var replTest = new ReplSetTest( {name: 'testSet', nodes: 2} );
+
+var nodes = replTest.startSet();
+replTest.initiate();
+
+var master = replTest.getMaster();
+db = master.getDB("foo")
+db.foo.save({a: 1000});
+replTest.awaitReplication();
+replTest.awaitSecondaryNodes();
+
+assert.eq( 1 , db.foo.count() , "setup" );
+
+var slaves = replTest.liveNodes.slaves;
+assert( slaves.length == 1, "Expected 1 slave but length was " + slaves.length );
+slave = slaves[0];
+
+runMongoProgram.apply(null, ['mongodump', '-h', slave.host, '--out', '/data/db/jstests_tool_dumpsecondary_external/'])
+
+db.foo.drop()
+
+assert.eq( 0 , db.foo.count() , "after drop" );
+
+runMongoProgram.apply(null, ['mongorestore', '-h', master.host, '/data/db/jstests_tool_dumpsecondary_external/'])
+
+assert.soon( "db.foo.findOne()" , "no data after sleep" );
+assert.eq( 1 , db.foo.count() , "after restore" );
+assert.eq( 1000 , db.foo.findOne().a , "after restore 2" );
+
+resetDbpath('/data/db/jstests_tool_dumpsecondary_external')
+
+replTest.stopSet(15)
+\ No newline at end of file
diff --git a/jstests/tool/exportimport3.js b/jstests/tool/exportimport3.js
new file mode 100644
index 0000000..f18ba6c
--- /dev/null
+++ b/jstests/tool/exportimport3.js
@@ -0,0 +1,27 @@
+// exportimport3.js
+
+t = new ToolTest( "exportimport3" );
+
+c = t.startDB( "foo" );
+assert.eq( 0 , c.count() , "setup1" );
+c.save({a:1})
+c.save({a:2})
+c.save({a:3})
+c.save({a:4})
+c.save({a:5})
+
+assert.eq( 5 , c.count() , "setup2" );
+
+
+t.runTool( "export" , "--jsonArray" , "--out" , t.extFile , "-d" , t.baseName , "-c" , "foo" );
+
+c.drop();
+assert.eq( 0 , c.count() , "after drop" , "-d" , t.baseName , "-c" , "foo" );;
+
+t.runTool( "import" , "--jsonArray" , "--file" , t.extFile , "-d" , t.baseName , "-c" , "foo" );
+
+assert.soon( "c.findOne()" , "no data after sleep" );
+assert.eq( 5 , c.count() , "after restore 2" );
+
+
+t.stop();