C++ OperationContextImpl::lockState方法代码示例

    // This free function is used by the initial sync writer threads to apply each op
    void multiInitialSyncApply(const std::vector<BSONObj>& ops, SyncTail* st) {
        initializeWriterThread();
        for (std::vector<BSONObj>::const_iterator it = ops.begin();
             it != ops.end();
             ++it) {
            try {
                OperationContextImpl txn;

                if (!st->syncApply(&txn, *it)) {
                    bool status;
                    {
                        Lock::GlobalWrite lk(txn.lockState());
                        status = st->shouldRetry(&txn, *it);
                    }

                    if (status) {
                        // retry
                        if (!st->syncApply(&txn, *it)) {
                            fassertFailedNoTrace(15915);
                        }
                    }
                    // If shouldRetry() returns false, fall through.
                    // This can happen if the document that was moved and missed by Cloner
                    // subsequently got deleted and no longer exists on the Sync Target at all
                }
            }
            catch (const DBException& e) {
                error() << "exception: " << causedBy(e) << " on: " << it->toString() << endl;
                fassertFailedNoTrace(16361);
            }
        }
    }

    void ReplSetImpl::_assumePrimary() {
        LOG(1) << "replSet assuming primary" << endl;
        verify(iAmPotentiallyHot());

        // Wait for replication to stop and buffer to be consumed
        LOG(1) << "replSet waiting for replication to finish before becoming primary" << endl;
        BackgroundSync::get()->stopReplicationAndFlushBuffer();

        // Lock here to prevent stepping down & becoming primary from getting interleaved
        LOG(1) << "replSet waiting for global write lock";

        OperationContextImpl txn;   // XXX?
        Lock::GlobalWrite lk(txn.lockState());

        initOpTimeFromOplog(&txn, "local.oplog.rs");

        // Generate new election unique id
        elect.setElectionId(OID::gen());
        LOG(1) << "replSet truly becoming primary";
        changeState(MemberState::RS_PRIMARY);

        // This must be done after becoming primary but before releasing the write lock. This adds
        // the dropCollection entries for every temp collection to the opLog since we want it to be
        // replicated to secondaries.
        dropAllTempCollections(&txn);
    }

static void replMasterThread() {
    sleepsecs(4);
    Client::initThread("replmaster");
    int toSleep = 10;
    while (1) {
        sleepsecs(toSleep);

        // Write a keep-alive like entry to the log. This will make things like
        // printReplicationStatus() and printSlaveReplicationStatus() stay up-to-date even
        // when things are idle.
        OperationContextImpl txn;
        txn.getClient()->getAuthorizationSession()->grantInternalAuthorization();

        Lock::GlobalWrite globalWrite(txn.lockState(), 1);
        if (globalWrite.isLocked()) {
            toSleep = 10;

            try {
                WriteUnitOfWork wuow(&txn);
                logKeepalive(&txn);
                wuow.commit();
            } catch (...) {
                log() << "caught exception in replMasterThread()" << endl;
            }
        } else {
            LOG(5) << "couldn't logKeepalive" << endl;
            toSleep = 1;
        }
    }
}

    void run() {
        OperationContextImpl txn;
        DBDirectClient client(&txn);

        for ( int i = 0; i < 10; ++i ) {
            client.insert( ns, BSON( "_id" << i ) );
        }

        {
            // Remove _id range [_min, _max).
            Lock::DBWrite lk(txn.lockState(), ns);
            WriteUnitOfWork wunit(txn.recoveryUnit());
            Client::Context ctx(&txn,  ns );

            KeyRange range( ns,
                            BSON( "_id" << _min ),
                            BSON( "_id" << _max ),
                            BSON( "_id" << 1 ) );
            mongo::WriteConcernOptions dummyWriteConcern;
            Helpers::removeRange(&txn, range, false, dummyWriteConcern);
            wunit.commit();
        }

        // Check that the expected documents remain.
        ASSERT_EQUALS( expected(), docs(&txn) );
    }

    TEST(DBHelperTests, FindDiskLocsNoIndex) {
        OperationContextImpl txn;
        DBDirectClient client(&txn);

        client.remove( ns, BSONObj() );
        client.insert( ns, BSON( "_id" << OID::gen() ) );

        long long maxSizeBytes = 1024 * 1024 * 1024;

        set<DiskLoc> locs;
        long long numDocsFound;
        long long estSizeBytes;
        {
            Lock::DBRead lk(txn.lockState(), ns);

            // search invalid index range
            KeyRange range( ns,
                            BSON( "badIndex" << 0 ),
                            BSON( "badIndex" << 10 ),
                            BSON( "badIndex" << 1 ) );

            Status result = Helpers::getLocsInRange( &txn,
                                                     range,
                                                     maxSizeBytes,
                                                     &locs,
                                                     &numDocsFound,
                                                     &estSizeBytes );

            // Make sure we get the right error code
            ASSERT_EQUALS( result.code(), ErrorCodes::IndexNotFound );
            ASSERT_EQUALS( static_cast<long long>( locs.size() ), 0 );
            ASSERT_EQUALS( numDocsFound, 0 );
            ASSERT_EQUALS( estSizeBytes, 0 );
        }
    }

// This free function is used by the writer threads to apply each op
void multiSyncApply(const std::vector<BSONObj>& ops, SyncTail* st) {
    initializeWriterThread();

    OperationContextImpl txn;
    txn.setReplicatedWrites(false);
    DisableDocumentValidation validationDisabler(&txn);

    // allow us to get through the magic barrier
    txn.lockState()->setIsBatchWriter(true);

    bool convertUpdatesToUpserts = true;

    for (std::vector<BSONObj>::const_iterator it = ops.begin(); it != ops.end(); ++it) {
        try {
            const Status s = SyncTail::syncApply(&txn, *it, convertUpdatesToUpserts);
            if (!s.isOK()) {
                severe() << "Error applying operation (" << it->toString() << "): " << s;
                fassertFailedNoTrace(16359);
            }
        } catch (const DBException& e) {
            severe() << "writer worker caught exception: " << causedBy(e)
                     << " on: " << it->toString();

            if (inShutdown()) {
                return;
            }

            fassertFailedNoTrace(16360);
        }
    }
}

    static void logStartup() {
        BSONObjBuilder toLog;
        stringstream id;
        id << getHostNameCached() << "-" << jsTime();
        toLog.append( "_id", id.str() );
        toLog.append( "hostname", getHostNameCached() );

        toLog.appendTimeT( "startTime", time(0) );
        toLog.append( "startTimeLocal", dateToCtimeString(curTimeMillis64()) );

        toLog.append("cmdLine", serverGlobalParams.parsedOpts);
        toLog.append( "pid", ProcessId::getCurrent().asLongLong() );


        BSONObjBuilder buildinfo( toLog.subobjStart("buildinfo"));
        appendBuildInfo(buildinfo);
        buildinfo.doneFast();

        BSONObj o = toLog.obj();

        OperationContextImpl txn;

        Lock::GlobalWrite lk(txn.lockState());
        DBDirectClient c(&txn);

        static const char* name = "local.startup_log";
        c.createCollection( name, 10 * 1024 * 1024, true );
        c.insert( name, o);
    }

 OpTime ReplSetImpl::getEarliestOpTimeWritten() const {
     OperationContextImpl txn; // XXX?
     Lock::DBRead lk(txn.lockState(), rsoplog);
     BSONObj o;
     uassert(17347, "Problem reading earliest entry from oplog",
             Helpers::getFirst(&txn, rsoplog, o));
     return o["ts"]._opTime();
 }

 OpTime ReplSetImpl::getMinValid() {
     OperationContextImpl txn; // XXX?
     Lock::DBRead lk(txn.lockState(), "local.replset.minvalid");
     BSONObj mv;
     if (Helpers::getSingleton(&txn, "local.replset.minvalid", mv)) {
         return mv["ts"]._opTime();
     }
     return OpTime();
 }

        void run() {
            OperationContextImpl txn;
            Lock::DBWrite lk(txn.lockState(), _cappedNs);

            BSONObj op = updateFail();

            Sync s("");
            verify(!s.shouldRetry(&txn, op));
        }

 bool ReplSetImpl::getInitialSyncFlag() {
     OperationContextImpl txn; // XXX?
     Lock::DBRead lk (txn.lockState(), "local");
     BSONObj mv;
     if (Helpers::getSingleton(&txn, minvalidNS, mv)) {
         return mv[_initialSyncFlagString].trueValue();
     }
     return false;
 }

        ~IndexIteratorTests() {
            OperationContextImpl txn;
            Lock::DBLock lk(txn.lockState(), nsToDatabaseSubstring(_ns), MODE_X);
            Client::Context ctx(&txn, _ns);
            WriteUnitOfWork wuow(&txn);

            _db->dropCollection(&txn, _ns);
            wuow.commit();
        }

    void ReplSetImpl::setMinValid(BSONObj obj) {
        BSONObjBuilder builder;
        BSONObjBuilder subobj(builder.subobjStart("$set"));
        subobj.appendTimestamp("ts", obj["ts"].date());
        subobj.done();

        OperationContextImpl txn; // XXX?
        Lock::DBWrite lk(txn.lockState(), "local");
        Helpers::putSingleton(&txn, "local.replset.minvalid", builder.obj());
    }

 void ReplSetImpl::loadLastOpTimeWritten(bool quiet) {
     OperationContextImpl txn; // XXX?
     Lock::DBRead lk(txn.lockState(), rsoplog);
     BSONObj o;
     if (Helpers::getLast(&txn, rsoplog, o)) {
         lastH = o["h"].numberLong();
         lastOpTimeWritten = o["ts"]._opTime();
         uassert(13290, "bad replSet oplog entry?", quiet || !lastOpTimeWritten.isNull());
     }
 }

    void NetworkInterfaceImpl::runCallbackWithGlobalExclusiveLock(
            const stdx::function<void (OperationContext*)>& callback) {

        std::ostringstream sb;
        sb << "repl" << boost::this_thread::get_id();
        Client::initThreadIfNotAlready(sb.str().c_str());
        OperationContextImpl txn;
        Lock::GlobalWrite lk(txn.lockState());
        callback(&txn);
    }