virtual bool run(OperationContext* txn, const string&, BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result) { string fromhost = cmdObj.getStringField("fromhost"); if (fromhost.empty()) { /* copy from self */ stringstream ss; ss << "localhost:" << serverGlobalParams.port; fromhost = ss.str(); } const ConnectionString cs(uassertStatusOK(ConnectionString::parse(fromhost))); auto& authConn = CopyDbAuthConnection::forClient(txn->getClient()); authConn.reset(cs.connect(errmsg)); if (!authConn) { return false; } BSONObj ret; if (!authConn->runCommand("admin", BSON("getnonce" << 1), ret)) { errmsg = "couldn't get nonce " + ret.toString(); authConn.reset(); return false; } result.appendElements(ret); return true; }
BSONObj Sync::getMissingDoc(const BSONObj& o) { OplogReader missingObjReader; const char *ns = o.getStringField("ns"); // capped collections NamespaceDetails *nsd = nsdetails(ns); if ( nsd && nsd->isCapped() ) { log() << "replication missing doc, but this is okay for a capped collection (" << ns << ")" << endl; return BSONObj(); } uassert(15916, str::stream() << "Can no longer connect to initial sync source: " << hn, missingObjReader.connect(hn)); // might be more than just _id in the update criteria BSONObj query = BSONObjBuilder().append(o.getObjectField("o2")["_id"]).obj(); BSONObj missingObj; try { missingObj = missingObjReader.findOne(ns, query); } catch(DBException& e) { log() << "replication assertion fetching missing object: " << e.what() << endl; throw; } return missingObj; }
void CMISProductNotificationAPI::Convert2JSON(CNotificationModel* pData, BSONObj &boRecord) { //{"data":[{"request_code":"RP130314/004","operation_department":"BO6"}],"source":"SDK"} BSONArrayBuilder babElement; BSONObjBuilder bobProductInfo; map<string, string>::iterator mit; map<string, string> mapAPIField; mapAPIField["department_alias"] = "operation_department"; mapAPIField["request_code"] = "request_code"; BSONObj boTemp = *pData; for (mit = mapAPIField.begin(); mit != mapAPIField.end(); mit++) { if (boTemp.hasField(mit->first)){ bobProductInfo.append(mit->second, boTemp.getStringField(mit->first.c_str())); } else{ bobProductInfo.append(mit->second, ""); } } babElement << bobProductInfo.obj(); boRecord = BSON( "data" << babElement.arr() << "source" << "SDK" ); }
bool CmdAuthenticate::getUserObj(const string& dbname, const string& user, BSONObj& userObj, string& pwd) { if (user == internalSecurity.user) { pwd = internalSecurity.pwd; } else { string systemUsers = dbname + ".system.users"; DBConfigPtr config = grid.getDBConfig( systemUsers ); Shard s = config->getShard( systemUsers ); static BSONObj userPattern = BSON("user" << 1); ShardConnection conn( s, systemUsers ); OCCASIONALLY conn->ensureIndex(systemUsers, userPattern, false, "user_1"); { BSONObjBuilder b; b << "user" << user; BSONObj query = b.done(); userObj = conn->findOne(systemUsers, query); if( userObj.isEmpty() ) { log() << "auth: couldn't find user " << user << ", " << systemUsers << endl; return false; } } pwd = userObj.getStringField("pwd"); } return true; }
BSONObj SyncTail::getMissingDoc(OperationContext* txn, Database* db, const BSONObj& o) { OplogReader missingObjReader; // why are we using OplogReader to run a non-oplog query? const char* ns = o.getStringField("ns"); // capped collections Collection* collection = db->getCollection(ns); if (collection && collection->isCapped()) { log() << "missing doc, but this is okay for a capped collection (" << ns << ")"; return BSONObj(); } const int retryMax = 3; for (int retryCount = 1; retryCount <= retryMax; ++retryCount) { if (retryCount != 1) { // if we are retrying, sleep a bit to let the network possibly recover sleepsecs(retryCount * retryCount); } try { bool ok = missingObjReader.connect(HostAndPort(_hostname)); if (!ok) { warning() << "network problem detected while connecting to the " << "sync source, attempt " << retryCount << " of " << retryMax << endl; continue; // try again } } catch (const SocketException&) { warning() << "network problem detected while connecting to the " << "sync source, attempt " << retryCount << " of " << retryMax << endl; continue; // try again } // get _id from oplog entry to create query to fetch document. const BSONElement opElem = o.getField("op"); const bool isUpdate = !opElem.eoo() && opElem.str() == "u"; const BSONElement idElem = o.getObjectField(isUpdate ? "o2" : "o")["_id"]; if (idElem.eoo()) { severe() << "cannot fetch missing document without _id field: " << o.toString(); fassertFailedNoTrace(28742); } BSONObj query = BSONObjBuilder().append(idElem).obj(); BSONObj missingObj; try { missingObj = missingObjReader.findOne(ns, query); } catch (const SocketException&) { warning() << "network problem detected while fetching a missing document from the " << "sync source, attempt " << retryCount << " of " << retryMax << endl; continue; // try again } catch (DBException& e) { error() << "assertion fetching missing object: " << e.what() << endl; throw; } // success! return missingObj; } // retry count exceeded msgasserted(15916, str::stream() << "Can no longer connect to initial sync source: " << _hostname); }
bool Sync::shouldRetry(const BSONObj& o) { // should already have write lock const char *ns = o.getStringField("ns"); Client::Context ctx(ns); // we don't have the object yet, which is possible on initial sync. get it. log() << "replication info adding missing object" << endl; // rare enough we can log BSONObj missingObj = getMissingDoc(o); if( missingObj.isEmpty() ) { log() << "replication missing object not found on source. presumably deleted later in oplog" << endl; log() << "replication o2: " << o.getObjectField("o2").toString() << endl; log() << "replication o firstfield: " << o.getObjectField("o").firstElementFieldName() << endl; return false; } else { Collection* collection = ctx.db()->getOrCreateCollection( ns ); verify( collection ); // should never happen StatusWith<DiskLoc> result = collection->insertDocument( missingObj, true ); uassert(15917, str::stream() << "failed to insert missing doc: " << result.toString(), result.isOK() ); LOG(1) << "replication inserted missing doc: " << missingObj.toString() << endl; return true; } }
void CUpdateAlertSttProcessor::UpdateAlertStatus(AlertInfo sAlertInf) { string strCurrStatus, strTicketId, strItsmId, strLog; int iItsmSttNoti; BSONObj boRecord; auto_ptr<DBClientCursor> ptrResultCursor = auto_ptr<DBClientCursor>(); m_pAlertModel->Load(sAlertInf); if (m_pAlertController->Find(ptrResultCursor, m_pAlertModel->GetObjectIdQuery())){ if (ptrResultCursor->more()) { boRecord = ptrResultCursor->nextSafe(); m_pAlertModel->Load(boRecord); // ============================Outage-End is empty========================== if (m_pAlertController->UpdateINCStatus(m_pAlertModel->GetRecordBson())) // API Update Status from Inc { m_pAlertController->Update(m_pAlertModel->GetAlertStatus(), m_pAlertModel->GetObjectIdQuery()); strCurrStatus = boRecord.hasField("itsm_status") ? boRecord.getStringField("itsm_status") : ""; strLog = CUtilities::FormatLog(INFO_MSG, "UpdateAlertStt", "ProcessCSUpdate_Call_API", sAlertInf.strSourceId + ": " + strCurrStatus + " -> " + sAlertInf.strStatus); CUtilities::WriteInfoLog(INFO_MSG, strLog); } } } }
void printIfAge(DBClientConnection& c, int age) { auto_ptr<DBClientCursor> cursor = c.query("tutorial.persons", QUERY( "age" << age ).sort("name") ); while( cursor->more() ) { BSONObj p = cursor->next(); cout << p.getStringField("name") << endl; } }
void DBConfig::unserialize(const BSONObj& from){ _name = from.getStringField("name"); _partitioned = from.getBoolField("partitioned"); _primary = from.getStringField("primary"); _sharded.clear(); BSONObj sharded = from.getObjectField( "sharded" ); if ( ! sharded.isEmpty() ){ BSONObjIterator i(sharded); while ( i.more() ){ BSONElement e = i.next(); uassert( "sharded things have to be objects" , e.type() == Object ); _sharded[e.fieldName()] = e.embeddedObject(); } } }
virtual bool run(OperationContext* txn, const string&, BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result, bool fromRepl) { string fromhost = cmdObj.getStringField("fromhost"); if (fromhost.empty()) { /* copy from self */ stringstream ss; ss << "localhost:" << serverGlobalParams.port; fromhost = ss.str(); } BSONObj ret; ConnectionString cs = ConnectionString::parse(fromhost, errmsg); if (!cs.isValid()) { return false; } authConn_.reset(cs.connect(errmsg)); if (!authConn_.get()) { return false; } if (!authConn_->runCommand("admin", BSON("getnonce" << 1), ret)) { errmsg = "couldn't get nonce " + ret.toString(); return false; } result.appendElements(ret); return true; }
bool Sync::shouldRetry(const BSONObj& o) { // should already have write lock const char *ns = o.getStringField("ns"); Client::Context ctx(ns); // we don't have the object yet, which is possible on initial sync. get it. log() << "replication info adding missing object" << endl; // rare enough we can log BSONObj missingObj = getMissingDoc(o); if( missingObj.isEmpty() ) { log() << "replication missing object not found on source. presumably deleted later in oplog" << endl; log() << "replication o2: " << o.getObjectField("o2").toString() << endl; log() << "replication o firstfield: " << o.getObjectField("o").firstElementFieldName() << endl; return false; } else { DiskLoc d = theDataFileMgr.insert(ns, (void*) missingObj.objdata(), missingObj.objsize()); uassert(15917, "Got bad disk location when attempting to insert", !d.isNull()); LOG(1) << "replication inserted missing doc: " << missingObj.toString() << endl; return true; } }
virtual bool run(OperationContext* txn, const string&, BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result) { const string fromDb = cmdObj.getStringField("fromdb"); string fromHost = cmdObj.getStringField("fromhost"); if (fromHost.empty()) { /* copy from self */ stringstream ss; ss << "localhost:" << serverGlobalParams.port; fromHost = ss.str(); } const ConnectionString cs(uassertStatusOK(ConnectionString::parse(fromHost))); BSONElement mechanismElement; Status status = bsonExtractField(cmdObj, saslCommandMechanismFieldName, &mechanismElement); if (!status.isOK()) { return appendCommandStatus(result, status); } BSONElement payloadElement; status = bsonExtractField(cmdObj, saslCommandPayloadFieldName, &payloadElement); if (!status.isOK()) { log() << "Failed to extract payload: " << status; return false; } auto& authConn = CopyDbAuthConnection::forClient(txn->getClient()); authConn.reset(cs.connect(StringData(), errmsg)); if (!authConn.get()) { return false; } BSONObj ret; if (!authConn->runCommand( fromDb, BSON("saslStart" << 1 << mechanismElement << payloadElement), ret)) { authConn.reset(); return appendCommandStatus(result, getStatusFromCommandResult(ret)); } result.appendElements(ret); return true; }
bool run(OperationContext* opCtx, const std::string& ns, const BSONObj& cmdObj, BSONObjBuilder& result) { log() << "test only command sleep invoked"; long long millis = 0; if (cmdObj["secs"] || cmdObj["seconds"] || cmdObj["millis"]) { uassert(51153, "Only one of 'secs' and 'seconds' may be specified", !(cmdObj["secs"] && cmdObj["seconds"])); if (auto secsElem = cmdObj["secs"]) { uassert(34344, "'secs' must be a number.", secsElem.isNumber()); millis += secsElem.numberLong() * 1000; } else if (auto secondsElem = cmdObj["seconds"]) { uassert(51154, "'seconds' must be a number.", secondsElem.isNumber()); millis += secondsElem.numberLong() * 1000; } if (auto millisElem = cmdObj["millis"]) { uassert(34345, "'millis' must be a number.", millisElem.isNumber()); millis += millisElem.numberLong(); } } else { millis = 10 * 1000; } StringData lockTarget; if (cmdObj["lockTarget"]) { lockTarget = cmdObj["lockTarget"].checkAndGetStringData(); } if (!cmdObj["lock"]) { // Legacy implementation if (cmdObj.getBoolField("w")) { _sleepInLock(opCtx, millis, MODE_X, lockTarget); } else { _sleepInLock(opCtx, millis, MODE_S, lockTarget); } } else { uassert(34346, "Only one of 'w' and 'lock' may be set.", !cmdObj["w"]); std::string lock(cmdObj.getStringField("lock")); if (lock == "none") { opCtx->sleepFor(Milliseconds(millis)); } else if (lock == "w") { _sleepInLock(opCtx, millis, MODE_X, lockTarget); } else { uassert(34347, "'lock' must be one of 'r', 'w', 'none'.", lock == "r"); _sleepInLock(opCtx, millis, MODE_S, lockTarget); } } // Interrupt point for testing (e.g. maxTimeMS). opCtx->checkForInterrupt(); return true; }
// static std::string WorkingSetCommon::toStatusString(const BSONObj& obj) { if (!isValidStatusMemberObject(obj)) { Status unknownStatus(ErrorCodes::UnknownError, "no details available"); return unknownStatus.toString(); } Status status(ErrorCodes::fromInt(obj.getIntField("code")), obj.getStringField("errmsg")); return status.toString(); }
bool run(const string& dbname, BSONObj& jsobj, int, string& errmsg, BSONObjBuilder& result, bool fromRepl ) { string from = jsobj.getStringField( "cloneCollectionAsCapped" ); string to = jsobj.getStringField( "toCollection" ); double size = jsobj.getField( "size" ).number(); bool temp = jsobj.getField( "temp" ).trueValue(); if ( from.empty() || to.empty() || size == 0 ) { errmsg = "invalid command spec"; return false; } Lock::DBWrite dbXLock(dbname); Client::Context ctx(dbname); Status status = cloneCollectionAsCapped( ctx.db(), from, to, size, temp, true ); return appendCommandStatus( result, status ); }
BSONObj CCentralizeSO6AlertProcessor::GetAdditionInfo(BSONObj boRecord) { auto_ptr<DBClientCursor> ptrMapProductCursor; BSONObj boAddtionInfo, boMapProductRecord; string strProduct, strContent, strDescription, strTmp, strMsgAlert; vector<string> vInformation; /*-- Get Map Product Info --*/ strProduct = GetSO6Product(boRecord.getStringField("servername")); Query queryCondition = QUERY("source" << "SO6" << "src_product" << strProduct); ptrMapProductCursor = m_pMapProductController->Find(queryCondition); if ((ptrMapProductCursor.get() != NULL) && (ptrMapProductCursor->more())) { boMapProductRecord = ptrMapProductCursor->nextSafe(); if (boMapProductRecord.hasField("itsm_product")) { strProduct = boMapProductRecord.getStringField("itsm_product"); //==================================== strContent = boRecord.getStringField("content"); strContent = CUtilities::StripTags(strContent); strContent = CUtilities::ReplaceString(strContent, "\r\n", "\n"); strContent = CUtilities::ReplaceString(strContent, "\n\r", "\n"); strDescription = strContent; vInformation = CUtilities::SplitString(strContent, "\n"); if (vInformation.size() > 1) { strTmp = vInformation[1]; std::remove(strTmp.begin(), strTmp.end(), ' '); if (!strTmp.empty()) strMsgAlert = CUtilities::ReplaceString(vInformation[1], ",", "\n"); else strMsgAlert = CUtilities::ReplaceString(vInformation[0], ",", "\n"); } else strMsgAlert = CUtilities::ReplaceString(vInformation[0], ",", "\n"); strMsgAlert = "[" + strProduct + "] " + strMsgAlert; } } boAddtionInfo = BSON( "product" << strProduct << "description" << strDescription << "alert_message" << strMsgAlert ); return boAddtionInfo.copy(); }
Status checkAuthForRenameCollectionCommand(ClientBasic* client, const std::string& dbname, const BSONObj& cmdObj) { NamespaceString sourceNS = NamespaceString(cmdObj.getStringField("renameCollection")); NamespaceString targetNS = NamespaceString(cmdObj.getStringField("to")); bool dropTarget = cmdObj["dropTarget"].trueValue(); if (sourceNS.db() == targetNS.db() && !sourceNS.isSystem() && !targetNS.isSystem()) { bool authed1 = client->getAuthorizationSession()->isAuthorizedForActionsOnResource( ResourcePattern::forDatabaseName(sourceNS.db()), ActionType::renameCollectionSameDB); bool authed2 = true; if (dropTarget) { authed2 = client->getAuthorizationSession()->isAuthorizedForActionsOnResource( ResourcePattern::forExactNamespace(targetNS), ActionType::dropCollection); } if (authed1 && authed2) { return Status::OK(); } } // Check privileges on source collection ActionSet actions; actions.addAction(ActionType::find); actions.addAction(ActionType::dropCollection); if (!client->getAuthorizationSession()->isAuthorizedForActionsOnResource( ResourcePattern::forExactNamespace(sourceNS), actions)) { return Status(ErrorCodes::Unauthorized, "Unauthorized"); } // Check privileges on dest collection actions.removeAllActions(); actions.addAction(ActionType::insert); actions.addAction(ActionType::createIndex); if (dropTarget) { actions.addAction(ActionType::dropCollection); } if (!client->getAuthorizationSession()->isAuthorizedForActionsOnResource( ResourcePattern::forExactNamespace(targetNS), actions)) { return Status(ErrorCodes::Unauthorized, "Unauthorized"); } return Status::OK(); }
/** * Parses a count command object, 'cmdObj'. * * On success, fills in the out-parameter 'request' and returns an OK status. * * Returns a failure status if 'cmdObj' is not well formed. */ Status parseRequest(const std::string& dbname, const BSONObj& cmdObj, CountRequest* request) const { long long skip = 0; if (cmdObj["skip"].isNumber()) { skip = cmdObj["skip"].numberLong(); if (skip < 0) { return Status(ErrorCodes::BadValue, "skip value is negative in count query"); } } else if (cmdObj["skip"].ok()) { return Status(ErrorCodes::BadValue, "skip value is not a valid number"); } long long limit = 0; if (cmdObj["limit"].isNumber()) { limit = cmdObj["limit"].numberLong(); } else if (cmdObj["limit"].ok()) { return Status(ErrorCodes::BadValue, "limit value is not a valid number"); } // For counts, limit and -limit mean the same thing. if (limit < 0) { limit = -limit; } // We don't validate that "query" is a nested object due to SERVER-15456. BSONObj query = cmdObj.getObjectField("query"); BSONObj hintObj; if (Object == cmdObj["hint"].type()) { hintObj = cmdObj["hint"].Obj(); } else if (String == cmdObj["hint"].type()) { const std::string hint = cmdObj.getStringField("hint"); hintObj = BSON("$hint" << hint); } std::string ns = parseNs(dbname, cmdObj); if (!nsIsFull(ns)) { return Status(ErrorCodes::BadValue, "collection name missing"); } // Parsed correctly. Fill out 'request' with the results. request->ns = ns; request->query = query; request->hint = hintObj; request->limit = limit; request->skip = skip; // By default, count requests are regular count not explain of count. request->explain = false; return Status::OK(); }
void MDistor::checkSize() { int count = 0; while((count) > -1) { map<string, ChunkInfo>::iterator chunks_it ; { boost::mutex::scoped_lock sl(distor_mutex); chunks_it = chunkInfos.begin(); while(chunks_it != chunkInfos.end()){ cout<<"Something in chunkInfos"<<endl; string mdistor_ns = MDIS::CHUNKS + chunks_it->first; //query for all the chunks auto_ptr<DBClientCursor> cursor = dbConn->query(mdistor_ns, BSONObj()); while(cursor->more()){ BSONObj b = cursor->next(); string host = b.getStringField("host"); string db = b.getStringField("db"); string coll = b.getStringField("collection"); mongo::BSONElement range = b.getField("key"); BSONObj result; //cout<<"Start to runCommand"<<endl; workers[host]->runCommand(db, BSON("collStats" << coll), result); //cout<<"result is "<<result<<endl; int dbSize = result.getField("size").Int(); cout<<"db size is-----"<<dbSize<<endl; //cout<<"range.Obj() : "<<range.Obj()<<endl; dbConn->update(mdistor_ns, BSON("key" << range.Obj()), BSON("$set" << BSON("size"<< dbSize))); if(dbSize > MDIS::MAX_CHUNK_SIZE){ BSONObj newHost = getAvailableWorker(); //TODO: is it possible to get rid of this query? //since we have the cursor here. string newHostStr = newHost.getStringField("host"); BSONObj _range = range.Obj(); dbConn->update(mdistor_ns, _range, BSON("$set" << BSON("host" << newHostStr))); } } chunks_it++; } } boost::this_thread::sleep(boost::posix_time::seconds(1)); } }
virtual bool run(const char *ns, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool fromRepl) { string from = cmdObj.getStringField("clone"); if ( from.empty() ) return false; /* replication note: we must logOp() not the command, but the cloned data -- if the slave were to clone it would get a different point-in-time and not match. */ return cloneFrom(from.c_str(), errmsg, database->name, /*logForReplication=*/!fromRepl, /*slaveok*/false, /*usereplauth*/false); }
bool run(OperationContext* txn, const string& dbname, BSONObj& jsobj, int, string& errmsg, BSONObjBuilder& result, bool fromRepl ) { // calls renamecollection which does a global lock, so we must too: // Lock::GlobalWrite globalWriteLock(txn->lockState()); WriteUnitOfWork wunit(txn->recoveryUnit()); Client::Context ctx(txn, dbname); Database* db = ctx.db(); stopIndexBuilds(txn, db, jsobj); BackgroundOperation::assertNoBgOpInProgForDb(dbname.c_str()); string shortSource = jsobj.getStringField( "convertToCapped" ); string longSource = dbname + "." + shortSource; double size = jsobj.getField( "size" ).number(); if ( shortSource.empty() || size == 0 ) { errmsg = "invalid command spec"; return false; } string shortTmpName = str::stream() << "tmp.convertToCapped." << shortSource; string longTmpName = str::stream() << dbname << "." << shortTmpName; if ( db->getCollection( txn, longTmpName ) ) { Status status = db->dropCollection( txn, longTmpName ); if ( !status.isOK() ) return appendCommandStatus( result, status ); } Status status = cloneCollectionAsCapped( txn, db, shortSource, shortTmpName, size, true, false ); if ( !status.isOK() ) return appendCommandStatus( result, status ); verify( db->getCollection( txn, longTmpName ) ); status = db->dropCollection( txn, longSource ); if ( !status.isOK() ) return appendCommandStatus( result, status ); status = db->renameCollection( txn, longTmpName, longSource, false ); if ( !status.isOK() ) return appendCommandStatus( result, status ); if (!fromRepl) repl::logOp(txn, "c",(dbname + ".$cmd").c_str(), jsobj); wunit.commit(); return true; }
BSONObj Sync::getMissingDoc(OperationContext* txn, Database* db, const BSONObj& o) { OplogReader missingObjReader; // why are we using OplogReader to run a non-oplog query? const char *ns = o.getStringField("ns"); // capped collections Collection* collection = db->getCollection(ns); if ( collection && collection->isCapped() ) { log() << "replication missing doc, but this is okay for a capped collection (" << ns << ")" << endl; return BSONObj(); } const int retryMax = 3; for (int retryCount = 1; retryCount <= retryMax; ++retryCount) { if (retryCount != 1) { // if we are retrying, sleep a bit to let the network possibly recover sleepsecs(retryCount * retryCount); } try { bool ok = missingObjReader.connect(HostAndPort(hn)); if (!ok) { warning() << "network problem detected while connecting to the " << "sync source, attempt " << retryCount << " of " << retryMax << endl; continue; // try again } } catch (const SocketException&) { warning() << "network problem detected while connecting to the " << "sync source, attempt " << retryCount << " of " << retryMax << endl; continue; // try again } // might be more than just _id in the update criteria BSONObj query = BSONObjBuilder().append(o.getObjectField("o2")["_id"]).obj(); BSONObj missingObj; try { missingObj = missingObjReader.findOne(ns, query); } catch (const SocketException&) { warning() << "network problem detected while fetching a missing document from the " << "sync source, attempt " << retryCount << " of " << retryMax << endl; continue; // try again } catch (DBException& e) { log() << "replication assertion fetching missing object: " << e.what() << endl; throw; } // success! return missingObj; } // retry count exceeded msgasserted(15916, str::stream() << "Can no longer connect to initial sync source: " << hn); }
bool CCSAlertController::UpdateINCStatus(BSONObj bsonRecord) { int iResult; string strResponse, strItsmStatus, strLog, strRejectMess; char *cINCCode, *cITSMCode, *cITSMCloseDate, *cCreatedBy, *cComment; short iINCStatusID = 99; short *p_iINCStatusID; if (bsonRecord.isEmpty()) { return false; } strItsmStatus = bsonRecord.hasField("itsm_status") ? bsonRecord.getStringField("itsm_status") : ""; strRejectMess = bsonRecord.hasField("msg") ? bsonRecord.getStringField("msg") : ""; cINCCode = new char[100]; cITSMCode = new char[100]; cITSMCloseDate = new char[100]; cCreatedBy = new char[100]; cComment = new char[strRejectMess.size() + 1]; // ========= Get Inc Status =========== if (strItsmStatus.compare("open") == 0) iINCStatusID = 24; else if (strItsmStatus.compare("closed") == 0) iINCStatusID = 26; else if (strItsmStatus.compare("reopen") == 0) iINCStatusID = 28; else if (strItsmStatus.compare("rejected") == 0) iINCStatusID = 27; else if (strItsmStatus.compare("resolved") == 0) iINCStatusID = 25; strcpy(cINCCode, bsonRecord.getStringField("ticket_id")); strcpy(cITSMCode, bsonRecord.getStringField("itsm_id")); strcpy(cCreatedBy, "sdk"); memcpy(cComment, strRejectMess.c_str(), strRejectMess.size() + 1); strcpy(cITSMCloseDate, bsonRecord.getStringField("outage_end")); p_iINCStatusID = &iINCStatusID; iResult = CAPIUtilities::CallUpdateINCStatusAPI(cINCCode, p_iINCStatusID, cITSMCode, cCreatedBy, cComment, cITSMCloseDate, strResponse); //============================Write Log========================== strLog = CUtilities::FormatLog(INFO_MSG, "UpdateAlertStt", "CSAlertController", "UpdateCSStatusINC:" + strResponse); CUtilities::WriteInfoLog(INFO_MSG, strLog); //============================Destroy========================== delete[] cINCCode; delete[] cITSMCode; delete[] cITSMCloseDate; delete[] cCreatedBy; delete[] cComment; if (API_ACTION_ERROR == iResult || CODE_ERROR_INIT == strResponse || CODE_ERROR_UPDATE_STATUS_INC == strResponse || CODE_ERROR_SSL_CLIENT_CONTEXT == strResponse || strResponse.find(RESPONSE_UNSUCCESS) != std::string::npos || strResponse.find("fail") != std::string::npos) { string strSourceId = bsonRecord.hasField("_id") ? CUtilities::GetMongoObjId(bsonRecord["_id"]) : ""; string strStatus = bsonRecord.hasField("itsm_status") ? bsonRecord.getStringField("itsm_status") : ""; string strCurrStatus = bsonRecord.hasField("prev_itsm_status") ? bsonRecord.getStringField("prev_itsm_status") : ""; string strLog = CUtilities::FormatLog(INFO_MSG, "CCSAlertController", "UpdateINCStatus", "FAIL:" + strSourceId + ": " + strCurrStatus + " -> " + strStatus); CUtilities::WriteInfoLog(INFO_MSG, strLog); return false; } return true; }
void MDistor::addChunk(string ns, int range) { BSONObjBuilder chunk; //cout<<"Starting to set keys"<<endl; size_t p_db = ns.find('.'); string db = ns.substr(0,p_db); size_t p_coll = ns.find('.', p_db + 1); string coll = ns.substr(p_db + 1, (p_coll - p_db - 1)); cout<<"addChunk: adding chunk for "<<ns<<endl; string chunkColl = MDIS::CHUNKS + ns; cout<<"db is "<<db<<"; coll is "<<coll<<endl; map<string, ChunkInfo>::iterator info_iter; { boost::mutex::scoped_lock ls(distor_mutex); info_iter = chunkInfos.find(ns); } if(info_iter != chunkInfos.end()) { ChunkInfo &info = (*info_iter).second; chunk.append("type", "chunk"); chunk.append("ns", ns); chunk.append("collection", coll); chunk.append("db", db); chunk.append("range", range); int start = info.getCurrentMax() + 1; int end = info.getCurrentMax() + range; info.setCurrentMax(end); chunk.append("key", BSON("min" << start << "max" << end)); BSONObj worker = getAvailableWorker(); chunk.append("worker", worker.getStringField("worker")); chunk.append("host" , worker.getStringField("host")); chunk.append("size", 0); dbConn->ensureIndex(chunkColl, BSON("ns" << 1 << "key" << 1), true); dbConn->insert(chunkColl, chunk.obj()); } else { cout<<"addChunk: did not add chunk"<<endl; } }
virtual bool run(const char *ns, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool fromRepl) { string fromhost = cmdObj.getStringField("fromhost"); if ( fromhost.empty() ) { /* copy from self */ stringstream ss; ss << "localhost:" << cmdLine.port; fromhost = ss.str(); } string fromdb = cmdObj.getStringField("fromdb"); string todb = cmdObj.getStringField("todb"); if ( fromhost.empty() || todb.empty() || fromdb.empty() ) { errmsg = "parms missing - {copydb: 1, fromhost: <hostname>, fromdb: <db>, todb: <db>}"; return false; } setClient(todb.c_str()); bool res = cloneFrom(fromhost.c_str(), errmsg, fromdb, /*logForReplication=*/!fromRepl, /*slaveok*/false, /*replauth*/false, /*snapshot*/true); cc().clearns(); return res; }
void DBConfig::unserialize(const BSONObj& from){ _name = from.getStringField("name"); _shardingEnabled = from.getBoolField("partitioned"); _primary = from.getStringField("primary"); _sharded.clear(); BSONObj sharded = from.getObjectField( "sharded" ); if ( ! sharded.isEmpty() ){ BSONObjIterator i(sharded); while ( i.more() ){ BSONElement e = i.next(); uassert( 10182 , "sharded things have to be objects" , e.type() == Object ); BSONObj c = e.embeddedObject(); uassert( 10183 , "key has to be an object" , c["key"].type() == Object ); _sharded[e.fieldName()] = CollectionInfo( c["key"].embeddedObject() , c["unique"].trueValue() ); } } }
virtual bool run(OperationContext* txn, const string&, BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result) { const auto fromdbElt = cmdObj["fromdb"]; uassert(ErrorCodes::TypeMismatch, "'renameCollection' must be of type String", fromdbElt.type() == BSONType::String); const string fromDb = fromdbElt.str(); uassert( ErrorCodes::InvalidNamespace, str::stream() << "Invalid 'fromdb' name: " << fromDb, NamespaceString::validDBName(fromDb, NamespaceString::DollarInDbNameBehavior::Allow)); string fromHost = cmdObj.getStringField("fromhost"); if (fromHost.empty()) { /* copy from self */ stringstream ss; ss << "localhost:" << serverGlobalParams.port; fromHost = ss.str(); } const ConnectionString cs(uassertStatusOK(ConnectionString::parse(fromHost))); BSONElement mechanismElement; Status status = bsonExtractField(cmdObj, saslCommandMechanismFieldName, &mechanismElement); if (!status.isOK()) { return appendCommandStatus(result, status); } BSONElement payloadElement; status = bsonExtractField(cmdObj, saslCommandPayloadFieldName, &payloadElement); if (!status.isOK()) { log() << "Failed to extract payload: " << status; return false; } auto& authConn = CopyDbAuthConnection::forClient(txn->getClient()); authConn.reset(cs.connect(StringData(), errmsg)); if (!authConn.get()) { return false; } BSONObj ret; if (!authConn->runCommand( fromDb, BSON("saslStart" << 1 << mechanismElement << payloadElement), ret)) { authConn.reset(); return appendCommandStatus(result, getStatusFromCommandResult(ret)); } result.appendElements(ret); return true; }
Status CmdCount::parseRequest(const std::string& dbname, const BSONObj& cmdObj, CountRequest* request) const { const string ns = parseNs(dbname, cmdObj); long long skip = 0; if (cmdObj["skip"].isNumber()) { skip = cmdObj["skip"].numberLong(); if (skip < 0) { return Status(ErrorCodes::BadValue, "skip value is negative in count query"); } } else if (cmdObj["skip"].ok()) { return Status(ErrorCodes::BadValue, "skip value is not a valid number"); } long long limit = 0; if (cmdObj["limit"].isNumber()) { limit = cmdObj["limit"].numberLong(); } else if (cmdObj["limit"].ok()) { return Status(ErrorCodes::BadValue, "limit value is not a valid number"); } // For counts, limit and -limit mean the same thing. if (limit < 0) { limit = -limit; } BSONObj query; if (!cmdObj["query"].eoo()) { if (Object != cmdObj["query"].type()) { return Status(ErrorCodes::BadValue, "query field for count must be an object"); } query = cmdObj.getObjectField("query"); } BSONObj hintObj; if (Object == cmdObj["hint"].type()) { hintObj = cmdObj["hint"].Obj(); } else if (String == cmdObj["hint"].type()) { const std::string hint = cmdObj.getStringField("hint"); hintObj = BSON("$hint" << hint); } // Parsed correctly. Fill out 'request' with the results. request->ns = ns; request->query = query; request->hint = hintObj; request->limit = limit; request->skip = skip; return Status::OK(); }
void doWork() { if ( !theReplSet ) { LOG(2) << "replSet not initialized yet, skipping health poll this round" << rsLog; return; } HeartbeatInfo mem = m; HeartbeatInfo old = mem; bool needsNewStateChecked = false; try { BSONObj info; int theirConfigVersion = -10000; bool ok = _requestHeartbeat(mem, info, theirConfigVersion); // weight new ping with old pings // on the first ping, just use the ping value if (old.ping != 0) { mem.ping = (unsigned int)((old.ping * .8) + (mem.ping * .2)); } if( ok ) { up(info, mem, &needsNewStateChecked); } else if (!info["errmsg"].eoo() && info["errmsg"].str() == "unauthorized") { authIssue(mem); } else { down(mem, info.getStringField("errmsg")); } } catch (const DBException& e) { log() << "replSet health poll task caught a DBException: " << e.what(); down(mem, e.what()); } catch (const std::exception& e) { log() << "replSet health poll task caught an exception: " << e.what(); down(mem, e.what()); } m = mem; theReplSet->mgr->send( boost::bind(&ReplSet::msgUpdateHBInfo, theReplSet, mem) ); static time_t last = 0; time_t now = time(0); bool changed = mem.changed(old); if( changed ) { if( old.hbstate != mem.hbstate ) log() << "replSet member " << h.toString() << " is now in state " << mem.hbstate.toString() << rsLog; } if( needsNewStateChecked || changed || now-last>4 ) { last = now; theReplSet->mgr->send( boost::bind(&Manager::msgCheckNewState, theReplSet->mgr) ); } }
/* Generally replAuthenticate will only be called within system threads to fully authenticate * connections to other nodes in the cluster that will be used as part of internal operations. * If a user-initiated action results in needing to call replAuthenticate, you can call it * with skipAuthCheck set to false. Only do this if you are certain that the proper auth * checks have already run to ensure that the user is authorized to do everything that this * connection will be used for! */ bool replAuthenticate(DBClientBase *conn, bool skipAuthCheck) { if( noauth ) { return true; } if (!skipAuthCheck && !cc().getAuthorizationManager()->hasInternalAuthorization()) { log() << "replauthenticate: requires internal authorization, failing" << endl; return false; } string u; string p; if (internalSecurity.pwd.length() > 0) { u = internalSecurity.user; p = internalSecurity.pwd; } else { BSONObj user; { StringData ns("local.system.users"); LOCK_REASON(lockReason, "repl: authenticating with local db"); Client::ReadContext ctx(ns, lockReason); if (!Collection::findOne(ns, userReplQuery, user) || // try the first user in local !Collection::findOne(ns, BSONObj(), user)) { log() << "replauthenticate: no user in local.system.users to use for authentication\n"; return false; } } u = user.getStringField("user"); p = user.getStringField("pwd"); massert( 10392 , "bad user object? [1]", !u.empty()); massert( 10393 , "bad user object? [2]", !p.empty()); } string err; if( !conn->auth("local", u.c_str(), p.c_str(), err, false) ) { log() << "replauthenticate: can't authenticate to master server, user:" << u << endl; return false; } return true; }