示例#1
0
int DictionaryDatabase::lookupNameFromID(OperationContext &context,
					 const NameID &id, Name &name) const
{
	int err = 0;
	nameId_t raw = id.raw() - 1; // id space is 1-based, not 0
	if (id == nidName_) {
		name = Name::dbxml_colon_name;
		return 0;
	} else if (id == nidRoot_) {
		name = Name::dbxml_colon_root;
		return 0;
	}
	
	if ((raw < DICTIONARY_RESERVE_SIZE) && usePreloads_) {
		name = preloadNames[raw];
	} else {
		err = lookupFromID(context, context.data(), id);
		if (err == 0) {
			name.setThisFromDbt(context.data());
		} else {
			name.reset();
		}
	}
	return err;
}
示例#2
0
void StructuralStatsDatabase::display(OperationContext &context, ostream &out, const DictionaryDatabase *ddb) const
{
	Cursor myCursor(const_cast<DbWrapper&>(db_), getTxn(context), CURSOR_WRITE, 0);
	if(myCursor.error() != 0) throw XmlException(myCursor.error());

	NameID id1;
	NameID id2;
	StructuralStats stats;

	int err = 0;
	while((err = myCursor.get(context.key(), context.data(), DB_NEXT)) == 0) {
		id1.reset();
		id2.reset();
		unmarshalKey(context.key(), id1, id2);
		stats.reset();
		stats.unmarshal(context.data());

		if(ddb) out << ddb->lookupName(context, id1);
		else out << id1;

		if(id2 != 0) {
			if(ddb) out << " -> " << ddb->lookupName(context, id2);
			else out << " -> " << id2;
		}

		out << ": ";

		stats.display(out);

		out << endl;
	}
}
OperationContext ClientCIMOMHandleRep::getResponseContext()
{
    OperationContext ctx;

    Thread* curThrd = Thread::getCurrent();
    if (curThrd == NULL)
    {
        ctx.insert(ContentLanguageListContainer(ContentLanguageList()));
    }
    else
    {
        ContentLanguageList* contentLangs = (ContentLanguageList*)
            curThrd->reference_tsd(TSD_CIMOM_HANDLE_CONTENT_LANGUAGES);
        curThrd->dereference_tsd();

        if (contentLangs == NULL)
        {
            ctx.insert(ContentLanguageListContainer(ContentLanguageList()));
        }
        else
        {
            ctx.insert(ContentLanguageListContainer(*contentLangs));
            // delete the old tsd to free the memory
            curThrd->delete_tsd(TSD_CIMOM_HANDLE_CONTENT_LANGUAGES);
        }
    }

    return ctx;
}
示例#4
0
SessionKiller::Result killSessionsLocalKillOps(OperationContext* opCtx,
                                               const SessionKiller::Matcher& matcher) {
    for (ServiceContext::LockedClientsCursor cursor(opCtx->getClient()->getServiceContext());
         Client* client = cursor.next();) {
        invariant(client);
        stdx::unique_lock<Client> lk(*client);

        OperationContext* opCtxToKill = client->getOperationContext();
        if (opCtxToKill) {
            const auto& lsid = opCtxToKill->getLogicalSessionId();

            if (lsid) {
                if (const KillAllSessionsByPattern* pattern = matcher.match(*lsid)) {
                    ScopedKillAllSessionsByPatternImpersonator impersonator(opCtx, *pattern);

                    log() << "killing op: " << opCtxToKill->getOpID()
                          << " as part of killing session: " << lsid->toBSON();

                    opCtx->getServiceContext()->killOperation(opCtxToKill);
                }
            }
        }
    }

    return {std::vector<HostAndPort>{}};
}
示例#5
0
int DocumentDatabase::getMetaData(OperationContext &context,
	DictionaryDatabase *dictionary, const Name &name,
	const DocID &did, XmlValue::Type &type, DbXmlDbt *metadata,
	u_int32_t flags) const
{
	NameID nid;
	int err = dictionary->lookupIDFromName(context, name,
					       nid, /*define=*/false);
	if(err == 0) {
		Cursor cursor(const_cast<SecondaryDatabase&>(secondary_),
			context.txn(), CURSOR_READ, "DocumentMetaData", flags);
		u_int32_t origFlags = DB_CURSOR_GET_MASK(const_cast<SecondaryDatabase&>(secondary_),flags);
		MetaDatum::setKeyDbt(did, nid, XmlValue::NONE, context.key());
		DbtIn none;
		none.set_flags(DB_DBT_PARTIAL); // Don't pull back the data.
		err = cursor.get(context.key(), none,
				 (flags | DB_SET_RANGE) & ~DB_RMW);
		if (err == 0) {
			DocID db_did;
			NameID db_nid;
			MetaDatum::decodeKeyDbt(context.key(), db_did,
						db_nid, type);
			if(db_did == did && db_nid == nid) {
				err = cursor.get(context.key(), *metadata,
						 origFlags|DB_CURRENT);
			} else {
				return DB_NOTFOUND;
			}
		}
	}

	return err;
}
示例#6
0
int StructuralStatsDatabase::getStats(OperationContext &context, StructuralStats &stats) const
{
	Cursor myCursor(const_cast<DbWrapper&>(db_), getTxn(context), CURSOR_READ, 0);
	if(myCursor.error() != 0) return myCursor.error();

	StructuralStats current;

	// Loop over every node and every node's descendant information
	int err;
	while((err = myCursor.get(context.key(), context.data(), DB_NEXT)) == 0) {
		current.reset();
		current.unmarshal(context.data());
		stats.add(current);
	}

	if(err != DB_NOTFOUND && err != 0) return err;

	if(stats.sumSize_ == 0 && stats.numberOfNodes_ != 0) {
		// Fill in an estimate for the missing size values that you get with DLS
		stats.sumSize_ = NODE_SIZE * stats.numberOfNodes_;
		stats.sumChildSize_ = NODE_SIZE * stats.sumNumberOfChildren_;
		stats.sumDescendantSize_ = NODE_SIZE * stats.sumNumberOfDescendants_;
	}

	return 0;
}
示例#7
0
void DictionaryDatabase::display(OperationContext &context, ostream &out) const
{
	{
	Cursor myCursor(const_cast<PrimaryDatabase&>(*primary_.get()), getTxn(context), CURSOR_READ, 0);
	if(myCursor.error() != 0) throw XmlException(myCursor.error());

	int err = 0;
	NameID id;
	while((err = myCursor.get(context.key(), context.data(), DB_NEXT)) == 0) {
		id.setThisFromDbtAsId(context.key());
		Buffer val(context.data().data, context.data().size, true);
		out << id << " -> " << val.asString(true) << endl;
	}
	}
	{
	Cursor myCursor(const_cast<SecondaryDatabase&>(*secondary_.get()), getTxn(context), CURSOR_READ, 0);
	if(myCursor.error() != 0) throw XmlException(myCursor.error());

	int err = 0;
	NameID id;
	while((err = myCursor.get(context.key(), context.data(), DB_NEXT)) == 0) {
		Buffer val(context.key().data, context.key().size, true);
		id.setThisFromDbt(context.data());
		out << val.asString(true) << " -> " << id << endl;
	}
	}
}
示例#8
0
int StructuralStatsDatabase::subtractStats(OperationContext &context, const NameID &id1, const NameID &id2,
	const StructuralStats &stats)
{
	DBXML_ASSERT(id1 != 0 || id2 == 0);

	Cursor myCursor(const_cast<DbWrapper&>(db_), getTxn(context), CURSOR_WRITE, 0);
	if(myCursor.error() != 0) return myCursor.error();

	marshalKey(id1, id2, context.key());
	int err = myCursor.get(context.key(), context.data(), DB_SET);
	if(err != DB_NOTFOUND && err != 0) return err;

	StructuralStats current;

	if(err == DB_NOTFOUND) {
		current.subtract(stats);

		current.marshal(context.data(), id2 == 0);
		err = myCursor.put(context.key(), context.data(), DB_KEYLAST);
	} else {
		current.unmarshal(context.data());
		current.subtract(stats);

		current.marshal(context.data(), id2 == 0);
		err = myCursor.put(context.key(), context.data(), DB_CURRENT);
	}

	return err;
}
示例#9
0
int DocumentDatabase::addMetaData(OperationContext &oc,
				  DictionaryDatabase *dictionary,
				  Document &document)
{
	int err = 0;
	MetaData::const_iterator end = document.metaDataEnd();
	MetaData::const_iterator i;
	for (i = document.metaDataBegin(); err == 0 && i != end; ++i) {
		NameID nid;
		err = dictionary->lookupIDFromName(oc,
						   (*i)->getName(),
						   nid, /*define=*/true);
		if(err == 0) {
			DbtIn value;
			MetaDatum::setKeyDbt(document.getID(),
					     nid, (*i)->getType(),
					     oc.key());
			(*i)->setValueDbtFromThis(value);
			// could throw on error
			err = secondary_.put(oc.txn(), &oc.key(),
					     &value, 0);
		}
	}
	if(err == 0)
		for(i = document.metaDataBegin(); i != end; ++i)
			(*i)->setModified(false);
	return err;
}
示例#10
0
int SyntaxDatabase::removeIndexEntries(OperationContext &context, DbWrapper &db,
				       void *buf, u_int32_t bufsize)
{
	unsigned char keybuf[10];
	// assert bufsize < 10;
	memcpy(keybuf, buf, bufsize);
	DbtIn key(keybuf, bufsize);
	key.ulen = (bufsize);
	key.dlen = (bufsize);
	key.doff = (0);
	key.set_flags(DB_DBT_PARTIAL);
	DbtIn data(0,0);
	data.set_flags(DB_DBT_PARTIAL);
	data.dlen = (0);
		
	u_int32_t flags = (context.txn() ? DB_RMW : 0);
	int err;

	// remove from index database
	Cursor cursor(db, context.txn(), CURSOR_WRITE);
	err = cursor.get(key, data, flags|DB_SET_RANGE);
	while ((err == 0) && (memcmp(key.data, buf, bufsize) == 0)) {
		cursor.del(0);
		err = cursor.get(key, data, flags|DB_NEXT);
		if (err == DB_NOTFOUND)
			break;
	}
	if (err == DB_NOTFOUND)
		err = 0;
	return err;
}
示例#11
0
    bool PlanYieldPolicy::yield(RecordFetcher* fetcher) {
        invariant(_planYielding);

        OperationContext* opCtx = _planYielding->getOpCtx();
        invariant(opCtx);

        // All YIELD_AUTO plans will get here eventually when the elapsed tracker triggers that it's
        // time to yield. Whether or not we will actually yield (doc-level locking systems won't),
        // we need to check if this operation has been interrupted. Throws if the interrupt flag is
        // set.
        opCtx->checkForInterrupt();

        if (supportsDocLocking()) {
            // Doc-level locking is supported, so no need to release locks.
            return true;
        }

        // No need to yield if the collection is NULL.
        if (NULL == _planYielding->collection()) {
            return true;
        }

        _planYielding->saveState();

        // Release and reacquire locks.
        QueryYield::yieldAllLocks(opCtx, fetcher);

        _elapsedTracker.resetLastTime();

        return _planYielding->restoreState(opCtx);
    }
示例#12
0
int StructuralStatsDatabase::addStats(OperationContext &context, const StructuralStatsWriteCache &cache)
{
	Cursor myCursor(db_, getTxn(context), CURSOR_WRITE, 0);
	if(myCursor.error() != 0) return myCursor.error();

	int err = 0;
	StructuralStats current;

	StructuralStatsWriteCache::Map::const_iterator it = cache.cache_.begin();
	for(; err == 0 && it != cache.cache_.end(); ++it) {

		StructuralStatsWriteCache::InnerMap::const_iterator it2 = it->second.begin();
		for(; it2 != it->second.end(); ++it2) {

			marshalKey(it->first, it2->first, context.key());

			err = myCursor.get(context.key(), context.data(), DB_SET);
			if(err == DB_NOTFOUND) {
				it2->second.marshal(context.data(), it2->first == 0);
				err = myCursor.put(context.key(), context.data(), DB_KEYLAST);
			} else if(err == 0) {
				current.unmarshal(context.data());
				current.add(it2->second);
				current.marshal(context.data(), it2->first == 0);
				err = myCursor.put(context.key(), context.data(), DB_CURRENT);
			} else break;
		}
	}

	if(err != DB_NOTFOUND) return err;

	return 0;
}
示例#13
0
int DocumentDatabase::reindex(const Document &document, OperationContext &oc,
		bool updateStats, bool forDelete)
{
        XmlManager mgr = document.getManager();
        ScopedContainer sc(mgr, document.getContainerID(), true);
        Container *cont = sc.getContainer();
        UpdateContext uc(mgr);
        Indexer &indexer = uc.getIndexer();
        IndexSpecification is;
        cont->getIndexSpecification(oc.txn(), is);
        indexer.resetContext(cont, &oc);
        KeyStash &ks = uc.getKeyStash();
        ks.reset();
        if (forDelete) is.set(Index::INDEXER_DELETE);
        // Index the document
	indexer.indexMetaData(is, document, ks, /*checkModified*/false);
	ScopedPtr<NsPushEventSource> source(document.
		getContentAsEventSource(oc.txn(), /*needsValidation*/false,
					indexer.getContainer()->nodesIndexed()));
	if (source.get()) {
		indexer.initIndexContent(is, document.getID(), source.get(),
			ks, updateStats, false, /*isDelete*/forDelete);
		source.get()->start();
	}
        ks.updateIndex(oc, cont);
        return 0;
}
示例#14
0
void MobileSessionPool::shutDown() {
    stdx::unique_lock<stdx::mutex> lk(_mutex);
    _shuttingDown = true;

    // Retrieve the operation context from the thread's client if the client exists.
    if (haveClient()) {
        OperationContext* opCtx = cc().getOperationContext();

        // Locks if the operation context still exists.
        if (opCtx) {
            opCtx->waitForConditionOrInterrupt(
                _releasedSessionNotifier, lk, [&] { return _sessions.size() == _curPoolSize; });
        }
    } else {
        _releasedSessionNotifier.wait(lk, [&] { return _sessions.size() == _curPoolSize; });
    }

    // Retry all the drops that have been queued on failure.
    // Create a new sqlite session to do so, all other sessions might have been closed already.
    if (!failedDropsQueue.isEmpty()) {
        sqlite3* session;

        int status = sqlite3_open(_path.c_str(), &session);
        embedded::checkStatus(status, SQLITE_OK, "sqlite3_open");
        std::unique_ptr<MobileSession> mobSession = stdx::make_unique<MobileSession>(session, this);
        LOG(MOBILE_LOG_LEVEL_LOW) << "MobileSE: Executing queued drops at shutdown";
        failedDropsQueue.execAndDequeueAllOps(mobSession.get());
        sqlite3_close(session);
    }

    for (auto&& session : _sessions) {
        sqlite3_close(session);
    }
}
void OperationContextTestCases::testStringData()
{
	OperationContext context;
	context.setStringData("key", "value");
	String val;
	unitAssertNoThrow(val = context.getStringData("key"));
	unitAssert(val == "value");
}
示例#16
0
// We assume that key has the correct endianness.
int IndexDatabase::getIndexEntry(OperationContext &context, const DbXmlDbt &key, IndexEntry &ie) const
{
	u_int32_t flags = (context.txn()) ? DB_READ_COMMITTED : 0;
	int err = get(context.txn(), &(const_cast<DbXmlDbt&>(key)), &context.data(), flags);
	if(err == 0) {
		ie.setThisFromDbt(context.data());
	}
	return err;
}
示例#17
0
svn_error_t *
OperationContext::clientName(void *baton, const char **name, apr_pool_t *pool)
{
  OperationContext *that = (OperationContext *) baton;

  *name = that->getClientName();

  return SVN_NO_ERROR;
}
示例#18
0
void RT_IndicationProvider::_checkOperationContext(const OperationContext& context,
                                                  const String &  funcName)
{
	 //
	 // Test the filter query container
	 //
	 SubscriptionFilterQueryContainer qContainer = context.get(SubscriptionFilterQueryContainer::NAME);
    if (qContainer.getFilterQuery() == String::EMPTY)
    {
      PEGASUS_STD(cout) << funcName << "- empty filter query" << PEGASUS_STD(endl);
      throw CIMOperationFailedException(funcName + "- empty filter query");
    }
    if (qContainer.getQueryLanguage() == String::EMPTY)
    {
      PEGASUS_STD(cout) << funcName << "- empty filter query lang" << PEGASUS_STD(endl);
      throw CIMOperationFailedException(funcName + "- empty filter query lang");
    }

    CIMNamespaceName tst("root/SampleProvider");
    if (!qContainer.getSourceNameSpace().equal(tst))
    {
      PEGASUS_STD(cout) << funcName << "- incorrect source namespace" << PEGASUS_STD(endl);
      throw CIMOperationFailedException(funcName + "- incorrect source namespace");
    }

    try
    {
      //
      // Try to parse the filter query from the filter query container
      //
      CIMOMHandleQueryContext ctx(qContainer.getSourceNameSpace(), _cimom);
      QueryExpression qe(qContainer.getQueryLanguage(),
                         qContainer.getFilterQuery(),
                         ctx);

      // Exercise the QueryExpression...this will cause repository access through
      // the CIMOMHandleQueryContext.
      qe.validate();
    }
    catch (Exception & e)
    {
      PEGASUS_STD(cout) << funcName << "- parse error: " << e.getMessage() << PEGASUS_STD(endl);
      throw CIMOperationFailedException(funcName + "- parse error: " + e.getMessage());
    }

    //
    // Test the filter condition container.
    // Note:  since this only contains the WHERE clause, the condition could be empty (and will
    // be for some testcases)
    //
    SubscriptionFilterConditionContainer cContainer = context.get(SubscriptionFilterConditionContainer::NAME);
	 if (cContainer.getQueryLanguage() == String::EMPTY)
    {
      PEGASUS_STD(cout) << funcName << "- empty filter condition lang" << PEGASUS_STD(endl);
      throw CIMOperationFailedException(funcName + "- empty filter condition lang");
    }
}
示例#19
0
int PrimaryDatabase::appendPrimary(OperationContext &context, NameID &id,
				   const DbXmlDbt &data, u_int32_t flags)
{
	int err = put(context.txn(), &context.key(), &(const_cast<DbXmlDbt&>(data)),
		      flags | DB_APPEND);
	if (err == 0)
		id.setThisFromDbtAsId(context.key());
	return err;
}
示例#20
0
Status PlanYieldPolicy::yield(stdx::function<void()> beforeYieldingFn,
                              stdx::function<void()> whileYieldingFn) {
    invariant(_planYielding);
    invariant(canAutoYield());

    // After we finish yielding (or in any early return), call resetTimer() to prevent yielding
    // again right away. We delay the resetTimer() call so that the clock doesn't start ticking
    // until after we return from the yield.
    ON_BLOCK_EXIT([this]() { resetTimer(); });

    _forceYield = false;

    OperationContext* opCtx = _planYielding->getOpCtx();
    invariant(opCtx);
    invariant(!opCtx->lockState()->inAWriteUnitOfWork());

    // Can't use writeConflictRetry since we need to call saveState before reseting the transaction.
    for (int attempt = 1; true; attempt++) {
        try {
            // All YIELD_AUTO plans will get here eventually when the elapsed tracker triggers
            // that it's time to yield. Whether or not we will actually yield, we need to check
            // if this operation has been interrupted.
            if (_policy == PlanExecutor::YIELD_AUTO) {
                MONGO_FAIL_POINT_PAUSE_WHILE_SET(setCheckForInterruptHang);

                auto interruptStatus = opCtx->checkForInterruptNoAssert();
                if (!interruptStatus.isOK()) {
                    return interruptStatus;
                }
            }

            try {
                _planYielding->saveState();
            } catch (const WriteConflictException&) {
                invariant(!"WriteConflictException not allowed in saveState");
            }

            if (_policy == PlanExecutor::WRITE_CONFLICT_RETRY_ONLY) {
                // Just reset the snapshot. Leave all LockManager locks alone.
                opCtx->recoveryUnit()->abandonSnapshot();
            } else {
                // Release and reacquire locks.
                if (beforeYieldingFn)
                    beforeYieldingFn();
                QueryYield::yieldAllLocks(opCtx, whileYieldingFn, _planYielding->nss());
            }

            return _planYielding->restoreStateWithoutRetrying();
        } catch (const WriteConflictException&) {
            CurOp::get(opCtx)->debug().writeConflicts++;
            WriteConflictException::logAndBackoff(
                attempt, "plan execution restoreState", _planYielding->nss().ns());
            // retry
        }
    }
}
示例#21
0
int DocumentDatabase::getAllMetaData(OperationContext &context,
				     DictionaryDatabase *dictionary,
				     Document *document,
				     u_int32_t flags) const
{
	int err = 0;
	u_int32_t orig_flags = flags;
	const DocID &did = document->getID();

	//
	// Read each of the meta-data items from the document secondary
	// database.  Content is no longer considered metadata
	//
	Cursor cursor(const_cast<SecondaryDatabase&>(secondary_),
		context.txn(), CURSOR_READ, "DocumentMetaData", flags);
	orig_flags = flags = DB_CURSOR_GET_MASK(const_cast<SecondaryDatabase&>(secondary_),flags);
	flags |= DB_SET_RANGE;
	bool done = false;
	while (!done) {
		did.setDbtFromThis(context.key());
		DbtIn none;
		none.set_flags(DB_DBT_PARTIAL); // Don't pull back the data.
		// if DB_RMW set, don't get locks on this get, wait for a match
		err = cursor.get(context.key(), none, flags & (~DB_RMW));
		if (err == 0) {
			DocID db_did;
			NameID db_nid;
			XmlValue::Type type;
			MetaDatum::decodeKeyDbt(context.key(), db_did,
						db_nid, type);
			if (did == db_did) {
				Name name;
				err = dictionary->lookupNameFromID(context, db_nid, name);
				if(err == 0 && !document->containsMetaData(name)) {
					DbtOut *data = new DbtOut();
					err = cursor.get(context.key(), *data,
							 DB_CURRENT);
					if(err == 0) document->setMetaData(
						name, type, &data,
						/*modified*/false);
					delete data; // If not consumed by setThis..
				}
				flags = orig_flags | DB_NEXT;
			} else {
				err = 0;
				done = true;
			}
		} else if (err == DB_NOTFOUND) {
			err = 0;
			done = true;
		} else {
			done = true;
		}
	}
	return err;
}
void EnableIndicationsResponseHandler::deliver(const CIMIndication & cimIndication)
{
    OperationContext context;

    Array<CIMObjectPath> subscriptionInstanceNames;

    context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));

    deliver(context, cimIndication);
}
示例#23
0
void
NsUpgradeReader::initDocInfo()
{
    // read doc node
    // read namespace info
    OperationContext oc;
    oc.set(NULL);
    const char metadataId[] =
    { NS_PROTOCOL_VERSION_COMPAT, NS_METADATA_ID, 0 };
    DbtOut data((void *)metadataId, strlen(metadataId) + 1);
    // reproduce old NsDocumentDatabase::getNodeRecord(), but
    // cannot deadlock -- no transaction
    DBXML_ASSERT(!oc.txn());
    id_.setDbtFromThis(oc.key());
    int ret = db_.get(oc.txn(), &oc.key(), &data, DB_GET_BOTH);
    uint32_t flags = 0;
    if (ret == 0) {
        const xmlbyte_t *ptr = (const xmlbyte_t *) data.data;
        ptr += 3;  // past version and id
        size_t len;
        ptr += NsFormat::unmarshalInt(ptr, &flags);
        if (flags & NSDOC_HASDECL) {
            ptr += NsFormat::unmarshalInt(ptr, &xmlDecl_);
            DBXML_ASSERT(xmlDecl_ == 0 || xmlDecl_ == 1);
        }
        if (flags & NSDOC_HASENCODE) {
            DBXML_ASSERT(!encStr_);
            encStr_ = NsUtil::nsStringDup(ptr, &len);
            ptr += len;
        }
        if (flags & NSDOC_HASSNIFF) {
            sniffStr_ = NsUtil::nsStringDup(ptr, &len);
            ptr += len;
        }
        if (flags & NSDOC_STANDYES)
            standStr_ = _standYes;
        if (flags & NSDOC_STANDNO)
            standStr_ = _standNo;
    }
    if (flags & NSDOC_NAMESPACE) {
        nsInfo_ = new NsNamespaceInfo();
        if (!nsInfo_)
            NsUtil::nsThrowException(XmlException::NO_MEMORY_ERROR,
                                     "new failed to allocate memory",
                                     __FILE__, __LINE__);
        nsInfo_->initialize();
        const char namespaceId[] =
        { NS_PROTOCOL_VERSION_COMPAT, NS_NAMESPACE_ID, 0 };

        DbtOut ndata((void *)namespaceId,
                     strlen(namespaceId) + 1);

        id_.setDbtFromThis(oc.key());
        ret = db_.get(oc.txn(), &oc.key(), &ndata, DB_GET_BOTH);
        if (ret == 0) {
            nsInfo_->load((const char*)
                          ((const char *)ndata.data)+3);
        }
    }
}
示例#24
0
svn_error_t *
OperationContext::checkCancel(void *cancelBaton)
{
  OperationContext *that = static_cast<OperationContext *>(cancelBaton);
  if (that->isCancelledOperation())
    return svn_error_create(SVN_ERR_CANCELLED, NULL, _("Operation cancelled"));
  else if (JNIUtil::isJavaExceptionThrown())
    return svn_error_create(SVN_ERR_CANCELLED, JNIUtil::wrapJavaException(),
                            _("Operation cancelled"));
  else
    return SVN_NO_ERROR;
}
示例#25
0
bool ServiceContextMongoD::_killOperationsAssociatedWithClientAndOpId_inlock(Client* client,
                                                                             unsigned int opId) {
    OperationContext* opCtx = client->getOperationContext();
    if (!opCtx) {
        return false;
    }
    if (opCtx->getOpID() != opId) {
        return false;
    }
    _killOperation_inlock(opCtx);
    return true;
}
示例#26
0
Status PlanYieldPolicy::yieldOrInterrupt(stdx::function<void()> beforeYieldingFn,
                                         stdx::function<void()> whileYieldingFn) {
    if (_policy == PlanExecutor::INTERRUPT_ONLY) {
        ON_BLOCK_EXIT([this]() { resetTimer(); });
        OperationContext* opCtx = _planYielding->getOpCtx();
        invariant(opCtx);
        MONGO_FAIL_POINT_PAUSE_WHILE_SET(setCheckForInterruptHang);
        return opCtx->checkForInterruptNoAssert();
    }

    return yield(beforeYieldingFn, whileYieldingFn);
}
示例#27
0
    bool PlanYieldPolicy::yield(RecordFetcher* fetcher) {
        invariant(_planYielding);
        invariant(allowedToYield());

        _forceYield = false;

        OperationContext* opCtx = _planYielding->getOpCtx();
        invariant(opCtx);
        invariant(!opCtx->lockState()->inAWriteUnitOfWork());

        // Can't use MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN/END since we need to call saveState
        // before reseting the transaction.
        for (int attempt = 1; true; attempt++) {
            try {
                // All YIELD_AUTO plans will get here eventually when the elapsed tracker triggers
                // that it's time to yield. Whether or not we will actually yield, we need to check
                // if this operation has been interrupted. Throws if the interrupt flag is set.
                if (_policy == PlanExecutor::YIELD_AUTO) {
                    opCtx->checkForInterrupt();
                }

                // No need to yield if the collection is NULL.
                if (NULL == _planYielding->collection()) {
                    return true;
                }

                try {
                    _planYielding->saveState();
                }
                catch (const WriteConflictException& wce) {
                    invariant(!"WriteConflictException not allowed in saveState");
                }

                if (_policy == PlanExecutor::WRITE_CONFLICT_RETRY_ONLY) {
                    // Just reset the snapshot. Leave all LockManager locks alone.
                    opCtx->recoveryUnit()->commitAndRestart();
                }
                else {
                    // Release and reacquire locks.
                    QueryYield::yieldAllLocks(opCtx, fetcher);
                }

                return _planYielding->restoreStateWithoutRetrying(opCtx);
            }
            catch (const WriteConflictException& wce) {
                opCtx->getCurOp()->debug().writeConflicts++;
                WriteConflictException::logAndBackoff(attempt,
                                                      "plan execution restoreState",
                                                      _planYielding->collection()->ns().ns());
                // retry
            }
        }
    }
示例#28
0
bool ServiceContextMongoD::killOperation(unsigned int opId) {
    for (LockedClientsCursor cursor(this); Client* client = cursor.next();) {
        stdx::lock_guard<Client> lk(*client);

        OperationContext* opCtx = client->getOperationContext();
        if (opCtx && opCtx->getOpID() == opId) {
            _killOperation_inlock(opCtx, ErrorCodes::Interrupted);
            return true;
        }
    }

    return false;
}
示例#29
0
void
AuthorizerManager::turnOff(
	OperationContext& context)
{
	context.setStringData(DISABLED_KEY, "1");

}
示例#30
0
int DictionaryDatabase::lookupStringNameFromID(
	OperationContext &context,
	const NameID &id, const char **name) const
{
	int err = 0;
	nameId_t raw = id.raw() - 1; // id space is 1-based, not 0
	if ((raw < DICTIONARY_RESERVE_SIZE) && usePreloads_) {
		*name = preloadNames[raw];
	} else {
		err = lookupFromID(context, context.data(), id);
		if (err == 0)
			*name = (const char *)context.data().data;
	}

	return err;
}