s = new ShardingTest( "features3" , 2 , 1 , 1 );
s.adminCommand( { enablesharding : "test" } );

a = s._connections[0].getDB( "test" );
b = s._connections[1].getDB( "test" );

db = s.getDB( "test" );

// ---------- load some data -----

s.adminCommand( { shardcollection : "test.foo" , key : { _id : 1 } } );
N = 10000;
s.adminCommand( { split : "test.foo" , middle : { _id : N/2 } } )
s.adminCommand( { moveChunk : "test.foo", find : { _id : 3 } ,to : s.getNonPrimaries( "test" )[0] } )

for ( i=0; i<N; i++ )
    db.foo.insert( { _id : i } )
db.getLastError();
x = db.foo.stats();
assert.eq( "test.foo" , x.ns , "basic1" )
assert( x.sharded , "basic2" )
assert.eq( N , x.count , "total count" )
assert.eq( N / 2 , x.shards.shard0000.count , "count on shard0000" )
assert.eq( N / 2 , x.shards.shard0001.count , "count on shard0001" )
assert( x.totalIndexSize > 0 )
assert( x.numExtents > 0 )

db.bar.insert( { x : 1 } )
x = db.bar.stats();
assert.eq( 1 , x.count , "XXX1" )
assert.eq( "test.bar" , x.ns , "XXX2" )
assert( ! x.sharded , "XXX3: " + tojson(x) )

// Fork shell and start pulling back data
start = new Date()

print( "about to fork shell: " + Date() )

// TODO:  Still potential problem when our sampling of current ops misses when $where is active - 
// solution is to increase sleep time
parallelCommand = "try { while(true){" +
                  " db.foo.find( function(){ x = ''; for ( i=0; i<10000; i++ ){ x+=i; } sleep( 1000 ); return true; } ).itcount() " +
                  "}} catch(e){ print('PShell execution ended:'); printjson( e ) }"

join = startParallelShell( parallelCommand )
print( "after forking shell: " + Date() )

// Get all current $where operations
function getMine( printInprog ){
    
    var inprog = db.currentOp().inprog;
    
    if ( printInprog )
        printjson( inprog )
    
    // Find all the where queries
    var mine = []
    for ( var x=0; x<inprog.length; x++ ){
        if ( inprog[x].query && inprog[x].query.$where ){
            mine.push( inprog[x] )
        }
    }
    
    return mine;
}

var state = 0; // 0 = not found, 1 = killed, 
var killTime = null;
var i = 0;

assert.soon( function(){
    
    // Get all the current operations
    mine = getMine( state == 0 && i > 20 );
    i++;
    
    // Wait for the queries to start
    if ( state == 0 && mine.length > 0 ){
        // Queries started
        state = 1;
        // Kill all $where
        mine.forEach( function(z){ printjson( db.getSisterDB( "admin" ).killOp( z.opid ) ); }  )
        killTime = new Date()
    }
    // Wait for killed queries to end
    else if ( state == 1 && mine.length == 0 ){
        // Queries ended
        state = 2;
        return true;
    }
    
}, "Couldn't kill the $where operations.", 2 * 60 * 1000 )

print( "after loop: " + Date() );
assert( killTime , "timed out waiting too kill last mine:" + tojson(mine) )

assert.eq( 2 , state , "failed killing" );

killTime = (new Date()).getTime() - killTime.getTime()
print( "killTime: " + killTime );

assert.gt( 10000 , killTime , "took too long to kill" )

join()

end = new Date()

print( "elapsed: " + ( end.getTime() - start.getTime() ) );


x = db.runCommand( "fsync" )
assert( ! x.ok , "fsync not on admin should fail : " + tojson( x ) );
assert( x.errmsg.indexOf( "access denied" ) >= 0 , "fsync not on admin should fail : " + tojson( x ) )

x = db._adminCommand( "fsync" )
assert( x.ok == 1 && x.numFiles > 0 , "fsync failed : " + tojson( x ) )

x = db._adminCommand( { "fsync" :1, lock:true } )
assert( ! x.ok , "lock should fail: " + tojson( x ) )

s.stop()