mongodb/jstests/sharding/lookup_stale_mongos.js

// Tests the behavior of a $lookup when the mongos contains stale routing information for the
// local and/or foreign collections.  This includes when mongos thinks the collection is sharded
// when it's not, and likewise when mongos thinks the collection is unsharded but is actually
// sharded.
(function() {
    "use strict";

    load("jstests/noPassthrough/libs/server_parameter_helpers.js");  // For setParameterOnAllHosts.
    load("jstests/libs/discover_topology.js");                       // For findDataBearingNodes.

    const testName = "lookup_stale_mongos";
    const st = new ShardingTest({
        shards: 2,
        mongos: 2,
    });
    setParameterOnAllHosts(DiscoverTopology.findNonConfigNodes(st.s0).concat([st.s1.host]),
                           "internalQueryAllowShardedLookup",
                           true);

    const mongos0DB = st.s0.getDB(testName);
    assert.commandWorked(mongos0DB.dropDatabase());
    const mongos0LocalColl = mongos0DB[testName + "_local"];
    const mongos0ForeignColl = mongos0DB[testName + "_foreign"];

    const mongos1DB = st.s1.getDB(testName);
    const mongos1LocalColl = mongos1DB[testName + "_local"];
    const mongos1ForeignColl = mongos1DB[testName + "_foreign"];

    const pipeline = [
        {
          $lookup:
              {localField: "a", foreignField: "b", from: mongos1ForeignColl.getName(), as: "same"}
        },
        {$sort: {_id: 1}}
    ];
    const expectedResults = [
        {_id: 0, a: 1, "same": [{_id: 0, b: 1}]},
        {_id: 1, a: null, "same": [{_id: 1, b: null}, {_id: 2}]},
        {_id: 2, "same": [{_id: 1, b: null}, {_id: 2}]}
    ];

    // Ensure that shard0 is the primary shard.
    assert.commandWorked(mongos0DB.adminCommand({enableSharding: mongos0DB.getName()}));
    st.ensurePrimaryShard(mongos0DB.getName(), st.shard0.shardName);

    assert.writeOK(mongos0LocalColl.insert({_id: 0, a: 1}));
    assert.writeOK(mongos0LocalColl.insert({_id: 1, a: null}));

    assert.writeOK(mongos0ForeignColl.insert({_id: 0, b: 1}));
    assert.writeOK(mongos0ForeignColl.insert({_id: 1, b: null}));

    // Send writes through mongos1 such that it's aware of the collections and believes they are
    // unsharded.
    assert.writeOK(mongos1LocalColl.insert({_id: 2}));
    assert.writeOK(mongos1ForeignColl.insert({_id: 2}));

    //
    // Test unsharded local and sharded foreign collections, with mongos unaware that the foreign
    // collection is sharded.
    //

    // Shard the foreign collection through mongos0.
    assert.commandWorked(
        mongos0DB.adminCommand({shardCollection: mongos0ForeignColl.getFullName(), key: {_id: 1}}));

    // Split the collection into 2 chunks: [MinKey, 1), [1, MaxKey).
    assert.commandWorked(
        mongos0DB.adminCommand({split: mongos0ForeignColl.getFullName(), middle: {_id: 1}}));

    // Move the [minKey, 1) chunk to shard1.
    assert.commandWorked(mongos0DB.adminCommand({
        moveChunk: mongos0ForeignColl.getFullName(),
        find: {_id: 0},
        to: st.shard1.shardName,
        _waitForDelete: true
    }));

    // Issue a $lookup through mongos1, which is unaware that the foreign collection is sharded.
    assert.eq(mongos1LocalColl.aggregate(pipeline).toArray(), expectedResults);

    //
    // Test sharded local and sharded foreign collections, with mongos unaware that the local
    // collection is sharded.
    //

    // Shard the local collection through mongos0.
    assert.commandWorked(
        mongos0DB.adminCommand({shardCollection: mongos0LocalColl.getFullName(), key: {_id: 1}}));

    // Split the collection into 2 chunks: [MinKey, 1), [1, MaxKey).
    assert.commandWorked(
        mongos0DB.adminCommand({split: mongos0LocalColl.getFullName(), middle: {_id: 1}}));

    // Move the [minKey, 1) chunk to shard1.
    assert.commandWorked(mongos0DB.adminCommand({
        moveChunk: mongos0LocalColl.getFullName(),
        find: {_id: 0},
        to: st.shard1.shardName,
        _waitForDelete: true
    }));

    // Issue a $lookup through mongos1, which is unaware that the local collection is sharded.
    assert.eq(mongos1LocalColl.aggregate(pipeline).toArray(), expectedResults);

    //
    // Test sharded local and unsharded foreign collections, with mongos unaware that the foreign
    // collection is unsharded.
    //

    // Recreate the foreign collection as unsharded through mongos0.
    mongos0ForeignColl.drop();
    assert.writeOK(mongos0ForeignColl.insert({_id: 0, b: 1}));
    assert.writeOK(mongos0ForeignColl.insert({_id: 1, b: null}));
    assert.writeOK(mongos0ForeignColl.insert({_id: 2}));

    // Issue a $lookup through mongos1, which is unaware that the foreign collection is now
    // unsharded.
    assert.eq(mongos1LocalColl.aggregate(pipeline).toArray(), expectedResults);

    //
    // Test unsharded local and foreign collections, with mongos unaware that the local
    // collection is unsharded.
    //

    // Recreate the local collection as unsharded through mongos0.
    mongos0LocalColl.drop();
    assert.writeOK(mongos0LocalColl.insert({_id: 0, a: 1}));
    assert.writeOK(mongos0LocalColl.insert({_id: 1, a: null}));
    assert.writeOK(mongos0LocalColl.insert({_id: 2}));

    // Issue a $lookup through mongos1, which is unaware that the local collection is now
    // unsharded.
    assert.eq(mongos1LocalColl.aggregate(pipeline).toArray(), expectedResults);

    st.stop();
})();