nonce Security::getNonce() { static mongo::mutex m("getNonce"); scoped_lock lk(m); /* question/todo: /dev/random works on OS X. is it better to use that than random() / srandom()? */ nonce n; #if defined(__linux__) || defined(__sunos__) _devrandom->read((char*)&n, sizeof(n)); massert( 10355 , "devrandom failed", !_devrandom->fail()); #elif defined(_WIN32) unsigned a=0, b=0; assert( rand_s(&a) == 0 ); assert( rand_s(&b) == 0 ); n = (((unsigned long long)a)<<32) | b; #else n = (((unsigned long long)random())<<32) | random(); #endif return n; }
void ClientInfo::_setupAuth() { std::string adminNs = "admin"; DBConfigPtr config = grid.getDBConfig(adminNs); Shard shard = config->getShard(adminNs); scoped_ptr<ScopedDbConnection> connPtr( ScopedDbConnection::getInternalScopedDbConnection(shard.getConnString(), 30.0)); ScopedDbConnection& conn = *connPtr; // // Note: The connection mechanism here is *not* ideal, and should not be used elsewhere. // It is safe in this particular case because the admin database is always on the config // server and does not move. // AuthorizationManager* authManager = new AuthorizationManager(new AuthExternalStateImpl()); Status status = authManager->initialize(conn.get()); massert(16479, mongoutils::str::stream() << "Error initializing AuthorizationManager: " << status.reason(), status == Status::OK()); setAuthorizationManager(authManager); }
BtreeCursor::BtreeCursor( NamespaceDetails *_d, int _idxNo, const IndexDetails& _id, const shared_ptr< FieldRangeVector > &_bounds, int _direction, bool useFRVSpec ) : d(_d), idxNo(_idxNo), _endKeyInclusive( true ), _multikey( d->isMultikey( idxNo ) ), indexDetails( _id ), _order( _id.keyPattern() ), _ordering( Ordering::make( _order ) ), _direction( _direction ), _bounds( ( assert( _bounds.get() ), _bounds ) ), _boundsIterator( new FieldRangeVectorIterator( *_bounds ) ), _spec( useFRVSpec ? _bounds->getSpec() : _id.getSpec() ), _independentFieldRanges( true ), _nscanned( 0 ) { massert( 13384, "BtreeCursor FieldRangeVector constructor doesn't accept special indexes", !_spec.getType() ); audit(); startKey = _bounds->startKey(); _boundsIterator->advance( startKey ); // handles initialization _boundsIterator->prepDive(); bucket = indexDetails.head; keyOfs = 0; }
virtual bool run(OperationContext* txn, const string& dbname , BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result, bool fromRepl) { string coll = cmdObj[ "emptycapped" ].valuestrsafe(); uassert( 13428, "emptycapped must specify a collection", !coll.empty() ); NamespaceString nss( dbname, coll ); Client::WriteContext ctx( nss.ns() ); Database* db = ctx.ctx().db(); Collection* collection = db->getCollection( nss.ns() ); massert( 13429, "emptycapped no such collection", collection ); std::vector<BSONObj> indexes = stopIndexBuilds(db, cmdObj); Status status = collection->truncate(txn); if ( !status.isOK() ) return appendCommandStatus( result, status ); IndexBuilder::restoreIndexes(indexes); if (!fromRepl) logOp(txn, "c",(dbname + ".$cmd").c_str(), cmdObj); return true; }
void setupSignalHandlers(bool handleControlC) { setupSynchronousSignalHandlers(); #ifdef _WIN32 if (!handleControlC) { massert(10297, "Couldn't register Windows Ctrl-C handler", SetConsoleCtrlHandler(static_cast<PHANDLER_ROUTINE>(CtrlHandler), TRUE)); } #else // asyncSignals is a global variable listing the signals that should be handled by the // interrupt thread, once it is started via startSignalProcessingThread(). sigemptyset( &asyncSignals ); sigaddset( &asyncSignals, SIGHUP ); if (!handleControlC) { sigaddset( &asyncSignals, SIGINT ); } sigaddset( &asyncSignals, SIGTERM ); sigaddset( &asyncSignals, SIGQUIT ); sigaddset( &asyncSignals, SIGUSR1 ); sigaddset( &asyncSignals, SIGXCPU ); #endif }
DiskLoc MmapV1ExtentManager::_createExtentInFile( OperationContext* txn, int fileNo, DataFile* f, int size, bool enforceQuota ) { _checkQuota( enforceQuota, fileNo - 1 ); massert( 10358, "bad new extent size", size >= minSize() && size <= maxSize() ); DiskLoc loc = f->allocExtentArea( txn, size ); loc.assertOk(); Extent *e = getExtent( loc, false ); verify( e ); *txn->recoveryUnit()->writing(&e->magic) = Extent::extentSignature; *txn->recoveryUnit()->writing(&e->myLoc) = loc; *txn->recoveryUnit()->writing(&e->length) = size; return loc; }
int BucketBasics::fullValidate(const DiskLoc& thisLoc, const BSONObj &order) { { bool f = false; assert( f = true ); massert( 10281 , "assert is misdefined", f); } killCurrentOp.checkForInterrupt(); assertValid(order, true); // if( bt_fv==0 ) // return; if ( bt_dmp ) { out() << thisLoc.toString() << ' '; ((BtreeBucket *) this)->dump(); } // keycount int kc = 0; for ( int i = 0; i < n; i++ ) { _KeyNode& kn = k(i); if ( kn.isUsed() ) kc++; if ( !kn.prevChildBucket.isNull() ) { DiskLoc left = kn.prevChildBucket; BtreeBucket *b = left.btree(); wassert( b->parent == thisLoc ); kc += b->fullValidate(kn.prevChildBucket, order); } } if ( !nextChild.isNull() ) { BtreeBucket *b = nextChild.btree(); wassert( b->parent == thisLoc ); kc += b->fullValidate(nextChild, order); } return kc; }
void DBClientCursor::attach(AScopedConnection* conn) { verify(_scopedHost.size() == 0); verify(conn); verify(conn->get()); if (conn->get()->type() == ConnectionString::SET) { if (_lazyHost.size() > 0) _scopedHost = _lazyHost; else if (_client) _scopedHost = _client->getServerAddress(); else massert(14821, "No client or lazy client specified, cannot store multi-host connection.", false); } else { _scopedHost = conn->getHost(); } conn->done(); _client = 0; _lazyHost = ""; }
void AutoGetCollectionForRead::_init(const std::string& ns, StringData coll) { massert(28535, "need a non-empty collection name", !coll.empty()); // We have both the DB and collection locked, which the prerequisite to do a stable shard // version check. ensureShardVersionOKOrThrow(_txn->getClient(), ns); auto curOp = CurOp::get(_txn); stdx::lock_guard<Client> lk(*_txn->getClient()); // TODO: OldClientContext legacy, needs to be removed curOp->ensureStarted(); curOp->setNS_inlock(ns); // At this point, we are locked in shared mode for the database by the DB lock in the // constructor, so it is safe to load the DB pointer. if (_db.getDb()) { // TODO: OldClientContext legacy, needs to be removed curOp->enter_inlock(ns.c_str(), _db.getDb()->getProfilingLevel()); _coll = _db.getDb()->getCollection(ns); } }
Lock::DBLock::DBLock(Locker* locker, StringData db, LockMode mode) : _id(RESOURCE_DATABASE, db), _locker(locker), _mode(mode), _globalLock(locker, isSharedLockMode(_mode) ? MODE_IS : MODE_IX, UINT_MAX) { massert(28539, "need a valid database name", !db.empty() && nsIsDbOnly(db)); // Need to acquire the flush lock _locker->lockMMAPV1Flush(); if (supportsDocLocking() || enableCollectionLocking) { // The check for the admin db is to ensure direct writes to auth collections // are serialized (see SERVER-16092). if ((_id == resourceIdAdminDB) && !isSharedLockMode(_mode)) { _mode = MODE_X; } invariant(LOCK_OK == _locker->lock(_id, _mode)); } else { invariant(LOCK_OK == _locker->lock(_id, isSharedLockMode(_mode) ? MODE_S : MODE_X)); } }
intrusive_ptr<DocumentSource> DocumentSourceProject::createFromBson( BSONElement elem, const intrusive_ptr<ExpressionContext> &pExpCtx) { /* validate */ uassert(15969, str::stream() << projectName << " specification must be an object", elem.type() == Object); Expression::ObjectCtx objectCtx( Expression::ObjectCtx::DOCUMENT_OK | Expression::ObjectCtx::TOP_LEVEL | Expression::ObjectCtx::INCLUSION_OK ); VariablesIdGenerator idGenerator; VariablesParseState vps(&idGenerator); intrusive_ptr<Expression> parsed = Expression::parseObject(elem.Obj(), &objectCtx, vps); ExpressionObject* exprObj = dynamic_cast<ExpressionObject*>(parsed.get()); massert(16402, "parseObject() returned wrong type of Expression", exprObj); uassert(16403, "$projection requires at least one output field", exprObj->getFieldCount()); intrusive_ptr<DocumentSourceProject> pProject(new DocumentSourceProject(pExpCtx, exprObj)); pProject->_variables.reset(new Variables(idGenerator.getIdCount())); BSONObj projectObj = elem.Obj(); pProject->_raw = projectObj.getOwned(); #if defined(_DEBUG) if (exprObj->isSimple()) { DepsTracker deps; vector<string> path; exprObj->addDependencies(&deps, &path); pProject->_simpleProjection.init(deps.toProjection()); } #endif return pProject; }
HashedIndexType::HashedIndexType( const IndexPlugin* plugin , const IndexSpec* spec ) : IndexType( plugin , spec ) , _keyPattern( spec->keyPattern ) { //change these if single-field limitation lifted later uassert( 16241 , "Currently only single field hashed index supported." , _keyPattern.toBSON().nFields() == 1 ); uassert( 16242 , "Currently hashed indexes cannot guarantee uniqueness. Use a regular index." , ! (spec->info).getField("unique").booleanSafe() ); //Default _seed to 0 if "seed" is not included in the index spec //or if the value of "seed" is not a number _seed = (spec->info).getField("seed").numberInt(); //Default _isSparse to false if "sparse" is not included in the index spec //or if the value of "sparse" is not a boolean _isSparse = (spec->info).getField("sparse").booleanSafe(); //In case we have hashed indexes based on other hash functions in //the future, we store a hashVersion number. If hashVersion changes, // "makeSingleKey" will need to change accordingly. //Defaults to 0 if "hashVersion" is not included in the index spec //or if the value of "hashversion" is not a number _hashVersion = (spec->info).getField("hashVersion").numberInt(); //Get the hashfield name BSONElement firstElt = spec->keyPattern.firstElement(); massert( 16243 , "error: no hashed index field" , firstElt.str().compare( HASHED_INDEX_TYPE_IDENTIFIER ) == 0 ); _hashedField = firstElt.fieldName(); // Explicit null valued fields and missing fields are both represented in hashed indexes // using the hash value of the null BSONElement. This is partly for historical reasons // (hash of null was used in the initial release of hashed indexes and changing would alter // the data format). Additionally, in certain places the hashed index code and the index // bound calculation code assume null and missing are indexed identically. BSONObj nullObj = BSON( "" << BSONNULL ); _missingKey = BSON( "" << makeSingleKey( nullObj.firstElement(), _seed, _hashVersion ) ); }
/** write an op to the oplog that is already built. todo : make _logOpRS() call this so we don't repeat ourself? */ void _logOpObjRS(const BSONObj& op) { Lock::DBWrite lk("local"); const OpTime ts = op["ts"]._opTime(); long long h = op["h"].numberLong(); { const char *logns = rsoplog; if ( rsOplogDetails == 0 ) { Client::Context ctx(logns , dbpath); localDB = ctx.db(); verify( localDB ); rsOplogDetails = nsdetails(logns); massert(13389, "local.oplog.rs missing. did you drop it? if so restart server", rsOplogDetails); } Client::Context ctx(logns , localDB); { int len = op.objsize(); Record *r = theDataFileMgr.fast_oplog_insert(rsOplogDetails, logns, len); memcpy(getDur().writingPtr(r->data(), len), op.objdata(), len); } /* todo: now() has code to handle clock skew. but if the skew server to server is large it will get unhappy. this code (or code in now() maybe) should be improved. */ if( theReplSet ) { if( !(theReplSet->lastOpTimeWritten<ts) ) { log() << "replSet error possible failover clock skew issue? " << theReplSet->lastOpTimeWritten.toString() << ' ' << endl; } theReplSet->lastOpTimeWritten = ts; theReplSet->lastH = h; ctx.getClient()->setLastOp( ts ); replset::BackgroundSync::notify(); } } OpTime::setLast( ts ); }
HashAccessMethod::HashAccessMethod(IndexDescriptor* descriptor) : BtreeBasedAccessMethod(descriptor) { const string HASHED_INDEX_TYPE_IDENTIFIER = "hashed"; //change these if single-field limitation lifted later uassert(16763, "Currently only single field hashed index supported." , 1 == descriptor->getNumFields()); uassert(16764, "Currently hashed indexes cannot guarantee uniqueness. Use a regular index.", !descriptor->unique()); // Default _seed to DEFAULT_HASH_SEED if "seed" is not included in the index spec // or if the value of "seed" is not a number // *** WARNING *** // Choosing non-default seeds will invalidate hashed sharding // Changing the seed default will break existing indexes and sharded collections if ( descriptor->getInfoElement( "seed" ).eoo() ) { _seed = BSONElementHasher::DEFAULT_HASH_SEED; } else { _seed = descriptor->getInfoElement("seed").numberInt(); } //In case we have hashed indexes based on other hash functions in //the future, we store a hashVersion number. If hashVersion changes, // "makeSingleKey" will need to change accordingly. //Defaults to 0 if "hashVersion" is not included in the index spec //or if the value of "hashversion" is not a number _hashVersion = descriptor->getInfoElement("hashVersion").numberInt(); //Get the hashfield name BSONElement firstElt = descriptor->keyPattern().firstElement(); massert(16765, "error: no hashed index field", firstElt.str().compare(HASHED_INDEX_TYPE_IDENTIFIER) == 0); _hashedField = firstElt.fieldName(); }
bool SockAddr::operator==(const SockAddr& r) const { if (getType() != r.getType()) return false; if (getPort() != r.getPort()) return false; switch (getType()) { case AF_INET: return as<sockaddr_in>().sin_addr.s_addr == r.as<sockaddr_in>().sin_addr.s_addr; case AF_INET6: return memcmp(as<sockaddr_in6>().sin6_addr.s6_addr, r.as<sockaddr_in6>().sin6_addr.s6_addr, sizeof(in6_addr)) == 0; case AF_UNIX: return strcmp(as<sockaddr_un>().sun_path, r.as<sockaddr_un>().sun_path) == 0; case AF_UNSPEC: return true; // assume all unspecified addresses are the same default: massert(SOCK_FAMILY_UNKNOWN_ERROR, "unsupported address family", false); } return false; }
double IBMModelOne::distance( const Phrase& hu, const Phrase& en ) const { double val = log(1.0+hu.size()) / en.size() ; double huRatio = 1.0 / hu.size(); for ( int enPos=0; enPos<en.size(); ++enPos ) { double sum = 0; const Word& enWord = en[enPos]; for ( int huPos=0; huPos<hu.size(); ++huPos ) { sum += lookup( hu[huPos], enWord ); } massert( sum>0 ); val -= log(sum); } throw "unimplemented"; }
int main(int argc, int argv[]) { struct gameState G; struct gameState *p=&G; int k[10] = {adventurer, gardens, embargo, village, minion, mine, cutpurse, sea_hag, tribute, smithy}; printf ("Testing council_room card.\n"); int r = initializeGame(2, k, 5, p); massert (r == 0,"initializeGame failed\n"); int player = whoseTurn(p); int handPos = 0; int coin_bonus=0; G.handCount[player]=4; G.hand[player][0]=council_room; G.hand[player][1]=village; G.hand[player][2]=minion; G.hand[player][3]=mine; G.numBuys=0; int card = handCard(handPos,p); massert(card>=adventurer&&card<=treasure_map,"invalid card\n"); massert(card==council_room,"incorrect card\n"); int test=cardEffect(card,-1,-1,-1,p,handPos,&coin_bonus); massert(test==0,"cardEffect failed\n"); massert(G.handCount[player]==7,"incorrect had count\n"); massert(G.numBuys==1,"numBuys incorrect value\n"); massert(G.hand[player][0]!=council_room,"council_room is not discarded\n"); if(passed==0) printf("---Test Passed!\n"); return 0; }
intrusive_ptr<DocumentSource> DocumentSourceProject::createFromBson( BSONElement *pBsonElement, const intrusive_ptr<ExpressionContext> &pExpCtx) { /* validate */ uassert(15969, str::stream() << projectName << " specification must be an object", pBsonElement->type() == Object); intrusive_ptr<DocumentSourceProject> pProject(new DocumentSourceProject(pExpCtx)); BSONObj projectObj(pBsonElement->Obj()); pProject->_raw = projectObj.getOwned(); // probably not necessary, but better to be safe Expression::ObjectCtx objectCtx( Expression::ObjectCtx::DOCUMENT_OK | Expression::ObjectCtx::TOP_LEVEL | Expression::ObjectCtx::INCLUSION_OK ); intrusive_ptr<Expression> parsed = Expression::parseObject(pBsonElement, &objectCtx); ExpressionObject* exprObj = dynamic_cast<ExpressionObject*>(parsed.get()); massert(16402, "parseObject() returned wrong type of Expression", exprObj); uassert(16403, "$projection requires at least one output field", exprObj->getFieldCount()); pProject->pEO = exprObj; #if defined(_DEBUG) if (exprObj->isSimple()) { set<string> deps; vector<string> path; exprObj->addDependencies(deps, &path); pProject->_simpleProjection.init(depsToProjection(deps)); } #endif return pProject; }
Value DocumentSourceCursor::serialize(bool explain) const { // we never parse a documentSourceCursor, so we only serialize for explain if (!explain) return Value(); // Get planner-level explain info from the underlying PlanExecutor. BSONObjBuilder explainBuilder; { const NamespaceString nss(_ns); AutoGetCollectionForRead autoColl(pExpCtx->opCtx, nss); massert(17392, "No _exec. Were we disposed before explained?", _exec); _exec->restoreState(pExpCtx->opCtx); Explain::explainStages(_exec.get(), ExplainCommon::QUERY_PLANNER, &explainBuilder); _exec->saveState(); } MutableDocument out; out["query"] = Value(_query); if (!_sort.isEmpty()) out["sort"] = Value(_sort); if (_limit) out["limit"] = Value(_limit->getLimit()); if (!_projection.isEmpty()) out["fields"] = Value(_projection); // Add explain results from the query system into the agg explain output. BSONObj explainObj = explainBuilder.obj(); invariant(explainObj.hasField("queryPlanner")); out["queryPlanner"] = Value(explainObj["queryPlanner"]); return Value(DOC(getSourceName() << out.freezeToValue())); }
Database* DatabaseHolder::getOrCreate( const string& ns , const string& path , bool& justCreated ) { string dbname = _todb( ns ); { SimpleMutex::scoped_lock lk(_m); Lock::assertAtLeastReadLocked(ns); DBs& m = _paths[path]; { DBs::iterator i = m.find(dbname); if( i != m.end() ) { justCreated = false; return i->second; } } // todo: protect against getting sprayed with requests for different db names that DNE - // that would make the DBs map very large. not clear what to do to handle though, // perhaps just log it, which is what we do here with the "> 40" : bool cant = !Lock::isWriteLocked(ns); if( logLevel >= 1 || m.size() > 40 || cant || DEBUG_BUILD ) { log() << "opening db: " << (path==dbpath?"":path) << ' ' << dbname << endl; } massert(15927, "can't open database in a read lock. if db was just closed, consider retrying the query. might otherwise indicate an internal error", !cant); } // this locks _m for defensive checks, so we don't want to be locked right here : Database *db = new Database( dbname.c_str() , justCreated , path ); { SimpleMutex::scoped_lock lk(_m); DBs& m = _paths[path]; assert( m[dbname] == 0 ); m[dbname] = db; _size++; } return db; }
// Standard Btree implementation below. BtreeAccessMethod::BtreeAccessMethod(IndexCatalogEntry* btreeState) : BtreeBasedAccessMethod(btreeState) { // The key generation wants these values. vector<const char*> fieldNames; vector<BSONElement> fixed; BSONObjIterator it(_descriptor->keyPattern()); while (it.more()) { BSONElement elt = it.next(); fieldNames.push_back(elt.fieldName()); fixed.push_back(BSONElement()); } if (0 == _descriptor->version()) { _keyGenerator.reset(new BtreeKeyGeneratorV0(fieldNames, fixed, _descriptor->isSparse())); } else if (1 == _descriptor->version()) { _keyGenerator.reset(new BtreeKeyGeneratorV1(fieldNames, fixed, _descriptor->isSparse())); } else { massert(16745, "Invalid index version for key generation.", false ); } }
bool SyncSourceFeedback::replHandshake(OperationContext* txn) { ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator(); if (replCoord->getCurrentMemberState().primary()) { // primary has no one to handshake to return true; } // construct a vector of handshake obj for us as well as all chained members std::vector<BSONObj> handshakeObjs; replCoord->prepareReplSetUpdatePositionCommandHandshakes(txn, &handshakeObjs); LOG(1) << "handshaking upstream updater"; for (std::vector<BSONObj>::iterator it = handshakeObjs.begin(); it != handshakeObjs.end(); ++it) { BSONObj res; try { LOG(2) << "Sending to " << _connection.get()->toString() << " the replication " "handshake: " << *it; if (!_connection->runCommand("admin", *it, res)) { massert(17447, "upstream updater is not supported by the member from which we" " are syncing, please update all nodes to 2.6 or later.", res["errmsg"].str().find("no such cmd") == std::string::npos); log() << "replSet error while handshaking the upstream updater: " << res["errmsg"].valuestrsafe(); _resetConnection(); return false; } } catch (const DBException& e) { log() << "SyncSourceFeedback error sending handshake: " << e.what() << endl; _resetConnection(); return false; } } return true; }
BtreeCursor::BtreeCursor( NamespaceDetails *_d, int _idxNo, const IndexDetails& _id, const shared_ptr< FieldRangeVector > &_bounds, int _direction ) : d(_d), idxNo(_idxNo), endKeyInclusive_( true ), multikey( d->isMultikey( idxNo ) ), indexDetails( _id ), order( _id.keyPattern() ), _ordering( Ordering::make( order ) ), direction( _direction ), bounds_( ( assert( _bounds.get() ), _bounds ) ), _boundsIterator( new FieldRangeVector::Iterator( *bounds_ ) ), _spec( _id.getSpec() ), _independentFieldRanges( true ) { massert( 13384, "BtreeCursor FieldRangeVector constructor doesn't accept special indexes", !_spec.getType() ); audit(); startKey = bounds_->startKey(); bool found; _boundsIterator->advance( startKey ); // handles initialization bucket = indexDetails.head.btree()-> locate(indexDetails, indexDetails.head, startKey, _ordering, keyOfs, found, direction > 0 ? minDiskLoc : maxDiskLoc, direction); skipAndCheck(); DEV assert( dups.size() == 0 ); }
RecordId Helpers::findOne(OperationContext* opCtx, Collection* collection, std::unique_ptr<QueryRequest> qr, bool requireIndex) { if (!collection) return RecordId(); const ExtensionsCallbackReal extensionsCallback(opCtx, &collection->ns()); const boost::intrusive_ptr<ExpressionContext> expCtx; auto statusWithCQ = CanonicalQuery::canonicalize(opCtx, std::move(qr), expCtx, extensionsCallback, MatchExpressionParser::kAllowAllSpecialFeatures & ~MatchExpressionParser::AllowedFeatures::kIsolated); massertStatusOK(statusWithCQ.getStatus()); unique_ptr<CanonicalQuery> cq = std::move(statusWithCQ.getValue()); size_t options = requireIndex ? QueryPlannerParams::NO_TABLE_SCAN : QueryPlannerParams::DEFAULT; auto exec = uassertStatusOK( getExecutor(opCtx, collection, std::move(cq), PlanExecutor::NO_YIELD, options)); PlanExecutor::ExecState state; BSONObj obj; RecordId loc; if (PlanExecutor::ADVANCED == (state = exec->getNext(&obj, &loc))) { return loc; } massert(34427, "Plan executor error: " + WorkingSetCommon::toStatusString(obj), PlanExecutor::IS_EOF == state); return RecordId(); }
HashAccessMethod::HashAccessMethod(IndexDescriptor* descriptor) : BtreeBasedAccessMethod(descriptor) { const string HASHED_INDEX_TYPE_IDENTIFIER = "hashed"; //change these if single-field limitation lifted later uassert(16763, "Currently only single field hashed index supported." , 1 == descriptor->getNumFields()); uassert(16764, "Currently hashed indexes cannot guarantee uniqueness. Use a regular index.", !descriptor->unique()); //Default _seed to 0 if "seed" is not included in the index spec //or if the value of "seed" is not a number _seed = descriptor->getInfoElement("seed").numberInt(); //In case we have hashed indexes based on other hash functions in //the future, we store a hashVersion number. If hashVersion changes, // "makeSingleKey" will need to change accordingly. //Defaults to 0 if "hashVersion" is not included in the index spec //or if the value of "hashversion" is not a number _hashVersion = descriptor->getInfoElement("hashVersion").numberInt(); //Get the hashfield name BSONElement firstElt = descriptor->keyPattern().firstElement(); massert(16765, "error: no hashed index field", firstElt.str().compare(HASHED_INDEX_TYPE_IDENTIFIER) == 0); _hashedField = firstElt.fieldName(); // Explicit null valued fields and missing fields are both represented in hashed indexes // using the hash value of the null BSONElement. This is partly for historical reasons // (hash of null was used in the initial release of hashed indexes and changing would alter // the data format). Additionally, in certain places the hashed index code and the index // bound calculation code assume null and missing are indexed identically. BSONObj nullObj = BSON("" << BSONNULL); _missingKey = BSON("" << makeSingleKey(nullObj.firstElement(), _seed, _hashVersion)); }
int main (int argc, char** argv) { struct gameState G; int k[10] = {adventurer, gardens, embargo, village, minion, mine, cutpurse, sea_hag, tribute, smithy}; printf ("Testing gainCard.\n"); int r = initializeGame(2, k, 5, &G); massert(r == 0,"initializeGame failed\n"); int player=whoseTurn(&G); int supplyPos=3; int flag1=1; int flag2=2; int flag3=-293587678; int deck_count=G.deckCount[player]=3; int hand_count=G.handCount[player]=4; int discard_count=G.discardCount[player]=5; int gain_card=gainCard(supplyPos,&G,flag1,player); massert(gain_card==0,"incorrect value for gainCard\n"); massert(G.deckCount[player]==deck_count+1,"incorrect value for deckCount\n"); gain_card=gainCard(++supplyPos,&G,flag2,player); massert(gain_card==0,"incorrect value for gainCard\n"); massert(G.handCount[player]==hand_count+1,"incorrect value for handCount\n"); gain_card=gainCard(++supplyPos,&G,flag3,player); massert(gain_card==0,"incorrect value for gainCard\n"); massert(G.discardCount[player]==discard_count+1,"incorrect value for discardCount\n"); if(passed==0) printf("---Test Passed!\n"); return 0; }
void buildWordFromDOMTree_En( const DOMNode* parent, Word& word, bool lemma ) { massert( toString(parent->getNodeName()) == "w" ); const DOMNodeList* lst = parent->getChildNodes(); massert( lst->getLength() > 0 ); if (!lemma) { const DOMNode* wordTextNode = lst->item(0); massert( wordTextNode->getNodeType() == DOMNode::TEXT_NODE ); // std::cout << "FOUND WORD: " << wordTextNode->getNodeValue() << std::endl; word = toString(wordTextNode->getNodeValue()); } else { const char lemmaName[] = "l\0e\0m\0m\0a\0\0\0"; const DOMNamedNodeMap* attrMap = parent->getAttributes(); const DOMNode* lemmaNode = attrMap->getNamedItem((const unsigned short*)lemmaName); massert(lemmaNode); const DOMNodeList* lst = lemmaNode->getChildNodes(); massert( lst->getLength() > 0 ); const DOMNode* wordTextNode = lst->item(0); massert( wordTextNode->getNodeType() == DOMNode::TEXT_NODE ); // std::cout << "FOUND LEMMA: " << wordTextNode->getNodeValue() << std::endl; word = toString(wordTextNode->getNodeValue()); } }
virtual void connected( AbstractMessagingPort* p ) { ClientInfo *c = ClientInfo::get(); massert(15849, "client info not defined", c); if( p->remote().isLocalHost() ) c->getAuthenticationInfo()->setIsALocalHostConnectionWithSpecialAuthPowers(); }
bool handlePossibleShardedMessage( Message &m, DbResponse* dbresponse ) { if ( ! shardingState.enabled() ) return false; int op = m.operation(); if ( op < 2000 || op >= 3000 || op == dbGetMore // cursors are weird ) return false; DbMessage d(m); const char *ns = d.getns(); string errmsg; if ( shardVersionOk( ns , opIsWrite( op ) , errmsg ) ) { return false; } log(1) << "connection meta data too old - will retry ns:(" << ns << ") op:(" << opToString(op) << ") " << errmsg << endl; if ( doesOpGetAResponse( op ) ) { assert( dbresponse ); BufBuilder b( 32768 ); b.skip( sizeof( QueryResult ) ); { BSONObj obj = BSON( "$err" << errmsg ); b.appendBuf( obj.objdata() , obj.objsize() ); } QueryResult *qr = (QueryResult*)b.buf(); qr->_resultFlags() = ResultFlag_ErrSet | ResultFlag_ShardConfigStale; qr->len = b.len(); qr->setOperation( opReply ); qr->cursorId = 0; qr->startingFrom = 0; qr->nReturned = 1; b.decouple(); Message * resp = new Message(); resp->setData( qr , true ); dbresponse->response = resp; dbresponse->responseTo = m.header()->id; return true; } OID writebackID; writebackID.init(); lastError.getSafe()->writeback( writebackID ); const OID& clientID = ShardedConnectionInfo::get(false)->getID(); massert( 10422 , "write with bad shard config and no server id!" , clientID.isSet() ); log(1) << "got write with an old config - writing back ns: " << ns << endl; if ( logLevel ) log(1) << debugString( m ) << endl; BSONObjBuilder b; b.appendBool( "writeBack" , true ); b.append( "ns" , ns ); b.append( "id" , writebackID ); b.append( "connectionId" , cc().getConnectionId() ); b.appendTimestamp( "version" , shardingState.getVersion( ns ) ); b.appendTimestamp( "yourVersion" , ShardedConnectionInfo::get( true )->getVersion( ns ) ); b.appendBinData( "msg" , m.header()->len , bdtCustom , (char*)(m.singleData()) ); log(2) << "writing back msg with len: " << m.header()->len << " op: " << m.operation() << endl; writeBackManager.queueWriteBack( clientID.str() , b.obj() ); return true; }
int main() { int returnValGame, returnValEffect; int k[10] = {adventurer, gardens, embargo, village, minion, mine, cutpurse, sea_hag, tribute, smithy}; int i, j, n, players, player, handCount, deckCount, seed, address; //struct gameState state; struct gameState state; struct gameState stat; struct gameState sta; //printf("Running Random Adventurer Test\n"); /* --- Author's Note --- So, I had problems running out of memory when I used the same gameState variable more than 12 times, and I honestly don't know why. I momentarily solved this problem by adding more for loops and creating more gamestates; I was still able to get decent coverage, though not up to the amount of tests I originally had in mind. */ //Loops 12 times for first set of tests for (i = 0; i < MAX_TESTS; i++) { //Picks random # of players between 0 and 3 players = rand() % 4; //Pick random sed seed = rand(); //Initalizes game returnValGame = initializeGame(players, k, seed, &state); //Oracle for checking if the game is able to be initialized massert(returnValGame == 0, "The game was not able to be initialized\n"); //Initiate valid state variables //Pick a random deck size between 0 and 499 state.deckCount[player] = rand() % MAX_DECK; //Pick a random discard size between 0 and 499 state.discardCount[player] = rand() % MAX_DECK; //Pick a random hand size between 0 and 499 state.handCount[player] = rand() % MAX_HAND; //Copy state variables handCount = state.handCount[player]; deckCount = state.deckCount[player]; //1 in 3 chance of making empty deck for coverage if (seed % 3 == 0) { state.deckCount[player] = 0; } //Activates adventurer card effect returnValEffect = cardEffect(adventurer, 1, 1, 1, &state, 1, 1); //Oracle for checking if adventurer card effect worked massert(returnValEffect == 0, "The adventurer card effect did not work\n"); } //Loops 12 times for third set of tests for (i = 0; i < MAX_TESTS; i++) { //Picks number of players between 0 and 3 players = rand() % 4; //Pick random seed seed = rand(); //Initializes game returnValGame = initializeGame(players, k, seed, &stat); //Oracle for checking if the game is able to be initialized massert(returnValGame == 0, "The game was not able to be initialized\n"); //Initiate valid state variables //Picks a random deck size between 0 and 499 stat.deckCount[player] = rand() % MAX_DECK; //Picks a random discard size between 0 and 499 stat.discardCount[player] = rand() % MAX_DECK; //Picks a random hand size between 0 and 499 stat.handCount[player] = rand() % MAX_HAND; //Copy state variables handCount = stat.handCount[player]; deckCount = stat.deckCount[player]; //1 in 3 chance of making empty deck for coverage if (seed % 3 == 0) { stat.deckCount[player] = 0; } //Activates adventurer card effect cardEffect(adventurer, 1, 1, 1, &stat, 1, 1); //Oracle for checking if adventurer card effect worked massert(returnValEffect == 0, "The adventurer card effect did not work\n"); //AdventurerCardEffect(&stat, 0); } //Loops 12 times for third set of tests for (i = 0; i < MAX_TESTS; i++) { //Picks number of players between 0 and 3 players = rand() % 4; //Pick random seed seed = rand(); //Initializes game returnValGame = initializeGame(players, k, seed, &sta); //Oracle for checking if the game is able to be initialized massert(returnValGame == 0, "The game was not able to be initialized\n"); //Initiate valid state variables //Picks a random deck size between 0 and 499 sta.deckCount[player] = rand() % MAX_DECK; //Picks a random discard size between 0 and 499 sta.discardCount[player] = rand() % MAX_DECK; //Picks a random hand size between 0 and 499 sta.handCount[player] = rand() % MAX_HAND; //Copy state variables handCount = sta.handCount[player]; deckCount = sta.deckCount[player]; //1 in 3 chance of making empty deck for coverage if (seed % 3 == 0) { sta.deckCount[player] = 0; } //Activates adventurer card effect cardEffect(adventurer, 1, 1, 1, &stat, 1, 1); //Oracle for checking if adventurer card effect worked massert(returnValEffect == 0, "The adventurer card effect did not work\n"); } //printf("Tests Complete\n"); return 0; }