bool run(OperationContext* txn,
const string& dbname,
BSONObj& jsobj,
int,
string& errmsg,
BSONObjBuilder& result,
bool /*fromRepl*/) {
Client::ReadContext ctx( txn, dbname );
const Database* d = ctx.ctx().db();
const DatabaseCatalogEntry* dbEntry = d->getDatabaseCatalogEntry();
list<string> names;
dbEntry->getCollectionNamespaces( &names );
BSONArrayBuilder arr;
for ( list<string>::const_iterator i = names.begin(); i != names.end(); ++i ) {
string ns = *i;
BSONObjBuilder b;
b.append( "name", nsToCollectionSubstring( ns ) );
CollectionOptions options =
dbEntry->getCollectionCatalogEntry( txn, ns )->getCollectionOptions();
b.append( "options", options.toBSON() );
arr.append( b.obj() );
}
result.append( "collections", arr.arr() );
return true;
}
void BitTestMatchExpression::serialize(BSONObjBuilder* out) const {
string opString = "";
switch (matchType()) {
case BITS_ALL_SET:
opString = "$bitsAllSet";
break;
case BITS_ALL_CLEAR:
opString = "$bitsAllClear";
break;
case BITS_ANY_SET:
opString = "$bitsAnySet";
break;
case BITS_ANY_CLEAR:
opString = "$bitsAnyClear";
break;
default:
invariant(false);
}
BSONArrayBuilder arrBob;
for (auto bitPosition : _bitPositions) {
arrBob.append(bitPosition);
}
arrBob.doneFast();
out->append(path(), BSON(opString << arrBob.arr()));
}
bool run(OperationContext* txn,
const string& dbname,
BSONObj& jsobj,
int,
string& errmsg,
BSONObjBuilder& result,
bool /*fromRepl*/) {
AutoGetDb autoDb(txn, dbname, MODE_S);
const Database* d = autoDb.getDb();
const DatabaseCatalogEntry* dbEntry = NULL;
list<string> names;
if ( d ) {
dbEntry = d->getDatabaseCatalogEntry();
dbEntry->getCollectionNamespaces( &names );
names.sort();
}
scoped_ptr<MatchExpression> matcher;
if ( jsobj["filter"].isABSONObj() ) {
StatusWithMatchExpression parsed =
MatchExpressionParser::parse( jsobj["filter"].Obj() );
if ( !parsed.isOK() ) {
return appendCommandStatus( result, parsed.getStatus() );
}
matcher.reset( parsed.getValue() );
}
BSONArrayBuilder arr;
for ( list<string>::const_iterator i = names.begin(); i != names.end(); ++i ) {
string ns = *i;
StringData collection = nsToCollectionSubstring( ns );
if ( collection == "system.namespaces" ) {
continue;
}
BSONObjBuilder b;
b.append( "name", collection );
CollectionOptions options =
dbEntry->getCollectionCatalogEntry( txn, ns )->getCollectionOptions(txn);
b.append( "options", options.toBSON() );
BSONObj maybe = b.obj();
if ( matcher && !matcher->matchesBSON( maybe ) ) {
continue;
}
arr.append( maybe );
}
result.append( "collections", arr.arr() );
return true;
}
static void handleCursorCommand(CursorId id, BSONObj& cmdObj, BSONObjBuilder& result) {
BSONElement batchSizeElem = cmdObj.getFieldDotted("cursor.batchSize");
const long long batchSize = batchSizeElem.isNumber()
? batchSizeElem.numberLong()
: 101; // same as query
ClientCursorPin pin(id);
ClientCursor* cursor = pin.c();
massert(16958, "Cursor shouldn't have been deleted",
cursor);
verify(cursor->isAggCursor);
PipelineRunner* runner = dynamic_cast<PipelineRunner*>(cursor->getRunner());
verify(runner);
try {
const string cursorNs = cursor->ns(); // we need this after cursor may have been deleted
// can't use result BSONObjBuilder directly since it won't handle exceptions correctly.
BSONArrayBuilder resultsArray;
const int byteLimit = MaxBytesToReturnToClientAtOnce;
BSONObj next;
for (int objCount = 0; objCount < batchSize; objCount++) {
// The initial getNext() on a PipelineRunner may be very expensive so we don't do it
// when batchSize is 0 since that indicates a desire for a fast return.
if (runner->getNext(&next, NULL) != Runner::RUNNER_ADVANCED) {
pin.deleteUnderlying();
id = 0;
cursor = NULL; // make it an obvious error to use cursor after this point
break;
}
if (resultsArray.len() + next.objsize() > byteLimit) {
// too big. next will be the first doc in the second batch
runner->pushBack(next);
break;
}
resultsArray.append(next);
}
if (cursor) {
// If a time limit was set on the pipeline, remaining time is "rolled over" to the
// cursor (for use by future getmore ops).
cursor->setLeftoverMaxTimeMicros( cc().curop()->getRemainingMaxTimeMicros() );
}
BSONObjBuilder cursorObj(result.subobjStart("cursor"));
cursorObj.append("id", id);
cursorObj.append("ns", cursorNs);
cursorObj.append("firstBatch", resultsArray.arr());
cursorObj.done();
}
catch (...) {
// Clean up cursor on way out of scope.
pin.deleteUnderlying();
throw;
}
}
BSONArrayBuilder DocumentStructureEnumerator::_getArrayBuilderFromArr(BSONArray arr) {
BSONArrayBuilder arrBuilder;
for (auto elem : arr) {
arrBuilder.append(elem);
}
return arrBuilder;
}
void Node::writeJointNames (const sm::JointState& m)
{
BSONArrayBuilder b;
BOOST_FOREACH (const string& name, m.name)
b.append(name);
BSONObj s = BSON("names" << b.arr());
conn_->update(joint_name_coll_, mongo::fromjson("{}"), s, 1);
}
StatusWith<LocksType> DistLockCatalogImpl::overtakeLock(StringData lockID,
const OID& lockSessionID,
const OID& currentHolderTS,
StringData who,
StringData processId,
Date_t time,
StringData why) {
BSONArrayBuilder orQueryBuilder;
orQueryBuilder.append(
BSON(LocksType::name() << lockID << LocksType::state(LocksType::UNLOCKED)));
orQueryBuilder.append(BSON(LocksType::name() << lockID << LocksType::lockID(currentHolderTS)));
BSONObj newLockDetails(BSON(LocksType::lockID(lockSessionID)
<< LocksType::state(LocksType::LOCKED) << LocksType::who() << who
<< LocksType::process() << processId << LocksType::when(time)
<< LocksType::why() << why));
auto request = FindAndModifyRequest::makeUpdate(
_locksNS, BSON("$or" << orQueryBuilder.arr()), BSON("$set" << newLockDetails));
request.setShouldReturnNew(true);
request.setWriteConcern(_writeConcern);
auto resultStatus = _client->runCommandWithNotMasterRetries(
"config", _locksNS.db().toString(), request.toBSON());
if (!resultStatus.isOK()) {
return resultStatus.getStatus();
}
BSONObj responseObj(resultStatus.getValue());
auto findAndModifyStatus = extractFindAndModifyNewObj(responseObj);
if (!findAndModifyStatus.isOK()) {
return findAndModifyStatus.getStatus();
}
BSONObj doc = findAndModifyStatus.getValue();
auto locksTypeResult = LocksType::fromBSON(doc);
if (!locksTypeResult.isOK()) {
return {ErrorCodes::FailedToParse,
str::stream() << "failed to parse: " << doc << " : "
<< locksTypeResult.getStatus().toString()};
}
return locksTypeResult.getValue();
}
Status doTxn(OperationContext* opCtx,
const std::string& dbName,
const BSONObj& doTxnCmd,
BSONObjBuilder* result) {
auto txnNumber = opCtx->getTxnNumber();
uassert(ErrorCodes::InvalidOptions, "doTxn can only be run with a transaction ID.", txnNumber);
auto txnParticipant = TransactionParticipant::get(opCtx);
uassert(ErrorCodes::InvalidOptions, "doTxn must be run within a transaction", txnParticipant);
invariant(txnParticipant->inMultiDocumentTransaction());
invariant(opCtx->getWriteUnitOfWork());
uassert(
ErrorCodes::InvalidOptions, "doTxn supports only CRUD opts.", _areOpsCrudOnly(doTxnCmd));
auto hasPrecondition = _hasPrecondition(doTxnCmd);
// Acquire global lock in IX mode so that the replication state check will remain valid.
Lock::GlobalLock globalLock(opCtx, MODE_IX);
auto replCoord = repl::ReplicationCoordinator::get(opCtx);
bool userInitiatedWritesAndNotPrimary =
opCtx->writesAreReplicated() && !replCoord->canAcceptWritesForDatabase(opCtx, dbName);
if (userInitiatedWritesAndNotPrimary)
return Status(ErrorCodes::NotMaster,
str::stream() << "Not primary while applying ops to database " << dbName);
int numApplied = 0;
try {
BSONObjBuilder intermediateResult;
// The transaction takes place in a global unit of work, so the precondition check
// and the writes will share the same snapshot.
if (hasPrecondition) {
uassertStatusOK(_checkPrecondition(opCtx, doTxnCmd, result));
}
numApplied = 0;
uassertStatusOK(_doTxn(opCtx, dbName, doTxnCmd, &intermediateResult, &numApplied));
txnParticipant->commitUnpreparedTransaction(opCtx);
result->appendElements(intermediateResult.obj());
} catch (const DBException& ex) {
txnParticipant->abortActiveUnpreparedOrStashPreparedTransaction(opCtx);
BSONArrayBuilder ab;
++numApplied;
for (int j = 0; j < numApplied; j++)
ab.append(false);
result->append("applied", numApplied);
result->append("code", ex.code());
result->append("codeName", ErrorCodes::errorString(ex.code()));
result->append("errmsg", ex.what());
result->append("results", ab.arr());
return Status(ErrorCodes::UnknownError, ex.what());
}
return Status::OK();
}
void MongoSchema::process(){
//std::cout << "Processing " << m_dbname << "." << m_col << std::endl;
std::string querystr;
querystr.clear();
querystr.append(m_dbname);
querystr.append(".");
querystr.append(m_col);
int recordscount = m_conn->count(querystr);
//std::cout << "count:" << recordscount << std::endl;
std::auto_ptr<mongo::DBClientCursor> cursor = m_conn->query(querystr, mongo::Query());
//std::set<std::string> fields;
while(cursor->more()){
mongo::BSONObj bo = cursor->next();
for( BSONObj::iterator i = bo.begin(); i.more(); ) {
BSONElement e = i.next();
if(skipField(e.fieldName())){
continue;
}
if(e.isSimpleType()){
hashmap::const_iterator keyexsit = m_map.find(e.fieldName());
SchemaModel* sm = new SchemaModel();
if(keyexsit != m_map.end()){
sm = &m_map[e.fieldName()];
sm->count ++;
}else{
sm->count = 1;
sm->datatype = getType(e);
m_map[e.fieldName()] = *sm;
}
}else if(e.isABSONObj()){
int depth = 0;
std::string parent = e.fieldName();
extractBSON(e.Obj(), depth, parent);
}
}
}
BSONObjBuilder bOb;
BSONArrayBuilder bArr;
std::tr1::hash<std::string> hashfunc = m_map.hash_function();
for( hashmap::const_iterator i = m_map.begin(), e = m_map.end() ; i != e ; ++i ) {
SchemaModel sm = i->second;
float percentage = (float)sm.count / (float)recordscount * 100.0;
std::cout.precision(4);
BSONObj bo = BSON( "field" << i->first << "percent" << percentage << "datatype" << sm.datatype );
bArr.append(bo);
//std::cout << i->first << " -> "<< "Percent: "<< percentage << " (hash = " << hashfunc( i->first ) << ")" << "\r\n";
}
bOb.append(m_col, bArr.arr());
m_schema = bOb.obj();
}
BSONObj IndexBounds::toBSON() const {
BSONObjBuilder builder;
if (isSimpleRange) {
// TODO
}
else {
for (vector<OrderedIntervalList>::const_iterator itField = fields.begin();
itField != fields.end();
++itField) {
BSONArrayBuilder fieldBuilder(builder.subarrayStart(itField->name));
for (vector<Interval>::const_iterator itInterval = itField->intervals.begin();
itInterval != itField->intervals.end();
++itInterval) {
BSONArrayBuilder intervalBuilder;
// Careful to output $minElement/$maxElement if we don't have bounds.
if (itInterval->start.eoo()) {
BSONObjBuilder minBuilder;
minBuilder.appendMinKey("");
BSONObj minKeyObj = minBuilder.obj();
intervalBuilder.append(minKeyObj.firstElement());
}
else {
intervalBuilder.append(itInterval->start);
}
if (itInterval->end.eoo()) {
BSONObjBuilder maxBuilder;
maxBuilder.appendMaxKey("");
BSONObj maxKeyObj = maxBuilder.obj();
intervalBuilder.append(maxKeyObj.firstElement());
}
else {
intervalBuilder.append(itInterval->end);
}
fieldBuilder.append(
static_cast<BSONArray>(intervalBuilder.arr().clientReadable()));
}
}
}
return builder.obj();
}
INT32 rtnCoordDelete::buildOpMsg( const CoordCataInfoPtr &cataInfo,
const CoordSubCLlist &subCLList,
CHAR *pSrcMsg, CHAR *&pDstMsg,
INT32 &bufferSize )
{
INT32 rc = SDB_OK;
INT32 flag;
CHAR *pCollectionName = NULL;
CHAR *pDeletor = NULL;
CHAR *pHint = NULL;
BSONObj boDeletor;
BSONObj boHint;
rc = msgExtractDelete( pSrcMsg, &flag, &pCollectionName,
&pDeletor, &pHint );
PD_RC_CHECK( rc, PDERROR,
"failed to parse delete request(rc=%d)",
rc );
try
{
boDeletor = BSONObj( pDeletor );
boHint = BSONObj( pHint );
BSONArrayBuilder babSubCL;
CoordSubCLlist::const_iterator iterCL = subCLList.begin();
while( iterCL != subCLList.end() )
{
babSubCL.append( *iterCL );
++iterCL;
}
BSONObjBuilder bobNewDeletor;
bobNewDeletor.appendElements( boDeletor );
bobNewDeletor.appendArray( CAT_SUBCL_NAME, babSubCL.arr() );
BSONObj boNewDeletor = bobNewDeletor.obj();
rc = msgBuildDeleteMsg( &pDstMsg, &bufferSize, pCollectionName,
flag, 0, &boNewDeletor, &boHint );
PD_RC_CHECK( rc, PDERROR,
"failed to build delete request(rc=%d)",
rc );
{
MsgOpDelete *pReqMsg = (MsgOpDelete *)pDstMsg;
MsgOpDelete *pSrcReq = (MsgOpDelete *)pSrcMsg;
pReqMsg->version = cataInfo->getVersion();
pReqMsg->w = pSrcReq->w;
}
}
catch ( std::exception &e )
{
PD_RC_CHECK( SDB_INVALIDARG, PDERROR,
"occur unexpected error:%s",
e.what() );
}
done:
return rc;
error:
goto done;
}
/* ****************************************************************************
*
* compoundValueBson (for arrays) -
*/
void compoundValueBson(std::vector<orion::CompoundValueNode*> children, BSONArrayBuilder& b)
{
for (unsigned int ix = 0; ix < children.size(); ++ix)
{
orion::CompoundValueNode* child = children[ix];
if (child->valueType == ValueTypeString)
{
b.append(child->stringValue);
}
else if (child->valueType == ValueTypeNumber)
{
b.append(child->numberValue);
}
else if (child->valueType == ValueTypeBoolean)
{
b.append(child->boolValue);
}
else if (child->valueType == ValueTypeNone)
{
b.appendNull();
}
else if (child->valueType == ValueTypeVector)
{
BSONArrayBuilder ba;
compoundValueBson(child->childV, ba);
b.append(ba.arr());
}
else if (child->valueType == ValueTypeObject)
{
BSONObjBuilder bo;
compoundValueBson(child->childV, bo);
b.append(bo.obj());
}
else
{
LM_E(("Runtime Error (Unknown type in compound value)"));
}
}
}
static BSONArray rolesToBSONArray(const User::RoleDataMap& roles) {
BSONArrayBuilder arrBuilder;
for (User::RoleDataMap::const_iterator it = roles.begin(); it != roles.end(); ++it) {
const User::RoleData& role = it->second;
arrBuilder.append(BSON("name" << role.name.getRole() <<
"source" << role.name.getDB() <<
"hasRole" << role.hasRole <<
"canDelegate" << role.canDelegate));
}
return arrBuilder.arr();
}
void ShardingMongodTestFixture::setUp() {
ServiceContextMongoDTest::setUp();
const auto service = getServiceContext();
_opCtx = makeOperationContext();
// Set up this node as part of a replica set.
repl::ReplSettings replSettings;
replSettings.setOplogSizeBytes(512'000);
replSettings.setReplSetString(ConnectionString::forReplicaSet(_setName, _servers).toString());
auto replCoordPtr = makeReplicationCoordinator(replSettings);
_replCoord = replCoordPtr.get();
BSONArrayBuilder serversBob;
for (size_t i = 0; i < _servers.size(); ++i) {
serversBob.append(BSON("host" << _servers[i].toString() << "_id" << static_cast<int>(i)));
}
repl::ReplSetConfig replSetConfig;
ASSERT_OK(replSetConfig.initialize(
BSON("_id" << _setName << "protocolVersion" << 1 << "version" << 3 << "members"
<< serversBob.arr())));
replCoordPtr->setGetConfigReturnValue(replSetConfig);
repl::ReplicationCoordinator::set(service, std::move(replCoordPtr));
auto storagePtr = stdx::make_unique<repl::StorageInterfaceMock>();
repl::DropPendingCollectionReaper::set(
service, stdx::make_unique<repl::DropPendingCollectionReaper>(storagePtr.get()));
repl::ReplicationProcess::set(service,
stdx::make_unique<repl::ReplicationProcess>(
storagePtr.get(),
stdx::make_unique<repl::ReplicationConsistencyMarkersMock>(),
stdx::make_unique<repl::ReplicationRecoveryMock>()));
ASSERT_OK(repl::ReplicationProcess::get(_opCtx.get())->initializeRollbackID(_opCtx.get()));
repl::StorageInterface::set(service, std::move(storagePtr));
auto opObserver = checked_cast<OpObserverRegistry*>(service->getOpObserver());
opObserver->addObserver(stdx::make_unique<OpObserverShardingImpl>());
opObserver->addObserver(stdx::make_unique<ConfigServerOpObserver>());
opObserver->addObserver(stdx::make_unique<ShardServerOpObserver>());
repl::setOplogCollectionName(service);
repl::createOplog(_opCtx.get());
// Set the highest FCV because otherwise it defaults to the lower FCV. This way we default to
// testing this release's code, not backwards compatibility code.
serverGlobalParams.featureCompatibility.setVersion(
ServerGlobalParams::FeatureCompatibility::Version::kFullyUpgradedTo42);
}
void TxnOplog::writeOpsDirectlyToOplog(GTID gtid, uint64_t timestamp, uint64_t hash) {
dassert(logTxnOpsForReplication());
dassert(_logTxnToOplog);
// build array of in memory ops
BSONArrayBuilder b;
for (deque<BSONObj>::iterator it = _m.begin(); it != _m.end(); it++) {
b.append(*it);
}
BSONArray a = b.arr();
// log ops
_logTxnToOplog(gtid, timestamp, hash, a);
}
static void handleCursorCommand(CursorId id, BSONObj& cmdObj, BSONObjBuilder& result) {
BSONElement batchSizeElem = cmdObj.getFieldDotted("cursor.batchSize");
const long long batchSize = batchSizeElem.isNumber()
? batchSizeElem.numberLong()
: 101; // same as query
// Using limited cursor API that ignores many edge cases. Should be sufficient for commands.
ClientCursor::Pin pin(id);
ClientCursor* cursor = pin.c();
massert(16958, "Cursor shouldn't have been deleted",
cursor);
// Make sure this cursor won't disappear on us
fassert(16959, !cursor->c()->shouldDestroyOnNSDeletion());
fassert(16960, !cursor->c()->requiresLock());
try {
// can't use result BSONObjBuilder directly since it won't handle exceptions correctly.
BSONArrayBuilder resultsArray;
const int byteLimit = MaxBytesToReturnToClientAtOnce;
for (int objs = 0;
objs < batchSize && cursor->ok() && resultsArray.len() <= byteLimit;
objs++) {
// TODO may need special logic if cursor->current() would cause results to be > 16MB
resultsArray.append(cursor->current());
cursor->advance();
}
// The initial ok() on a cursor may be very expensive so we don't do it when batchSize
// is 0 since that indicates a desire for a fast return.
if (batchSize != 0 && !cursor->ok()) {
// There is no more data. Kill the cursor.
pin.release();
ClientCursor::erase(id);
id = 0;
}
BSONObjBuilder cursorObj(result.subobjStart("cursor"));
cursorObj.append("id", id);
cursorObj.append("ns", cursor->ns());
cursorObj.append("firstBatch", resultsArray.arr());
cursorObj.done();
}
catch (...) {
// Clean up cursor on way out of scope.
pin.release();
ClientCursor::erase(id);
throw;
}
}
// See unit test for example outputs
static BSONArray _versionArray(const char* version){
// this is inefficient, but cached so it doesn't matter
BSONArrayBuilder b;
string curPart;
const char* c = version;
int finalPart = 0; // 0 = final release, -100 = pre, -10 to -1 = -10 + X for rcX
do { //walks versionString including NUL byte
if (!(*c == '.' || *c == '-' || *c == '\0')){
curPart += *c;
continue;
}
try {
unsigned num = stringToNum(curPart.c_str());
b.append((int) num);
}
catch (...){ // not a number
if (curPart.empty()){
assert(*c == '\0');
break;
}
else if (startsWith(curPart, "rc")){
finalPart = -10 + stringToNum(curPart.c_str()+2);
break;
}
else if (curPart == "pre"){
finalPart = -100;
break;
}
}
curPart = "";
} while (*c++);
b.append(finalPart);
return b.arr();
}
// See unit test for example outputs
BSONArray toVersionArray(const char* version){
// this is inefficient, but cached so it doesn't matter
BSONArrayBuilder b;
string curPart;
const char* c = version;
int finalPart = 0; // 0 = final release, -100 = pre, -10 to -1 = -10 + X for rcX
do { //walks versionString including NUL byte
if (!(*c == '.' || *c == '-' || *c == '\0')){
curPart += *c;
continue;
}
int num;
if ( parseNumberFromString( curPart, &num ).isOK() ) {
b.append(num);
}
else if (curPart.empty()){
verify(*c == '\0');
break;
}
else if (startsWith(curPart, "rc")){
num = 0;
verify( parseNumberFromString( curPart.substr(2), &num ).isOK() );
finalPart = -10 + num;
break;
}
else if (curPart == "pre"){
finalPart = -100;
break;
}
curPart = "";
} while (*c++);
b.append(finalPart);
return b.arr();
}
BSONObj rtnCoordDelete::_buildNewDeletor( const BSONObj &deletor,
const CoordSubCLlist &subCLList )
{
BSONObjBuilder builder ;
BSONArrayBuilder babSubCL ;
CoordSubCLlist::const_iterator iterCL = subCLList.begin();
while( iterCL != subCLList.end() )
{
babSubCL.append( *iterCL ) ;
++iterCL ;
}
builder.appendElements( deletor ) ;
builder.appendArray( CAT_SUBCL_NAME, babSubCL.arr() ) ;
return builder.obj() ;
}
bool run(OperationContext* txn,
const string& dbname,
BSONObj& cmdObj,
int,
string& errmsg,
BSONObjBuilder& result,
bool /*fromRepl*/) {
BSONElement first = cmdObj.firstElement();
uassert(
28528,
str::stream() << "Argument to listIndexes must be of type String, not "
<< typeName(first.type()),
first.type() == String);
const NamespaceString ns(parseNs(dbname, cmdObj));
uassert(
28529,
str::stream() << "Argument to listIndexes must be a collection name, "
<< "not the empty string",
!ns.coll().empty());
AutoGetCollectionForRead autoColl(txn, ns);
if (!autoColl.getDb()) {
return appendCommandStatus( result, Status( ErrorCodes::NamespaceNotFound,
"no database" ) );
}
const Collection* collection = autoColl.getCollection();
if (!collection) {
return appendCommandStatus( result, Status( ErrorCodes::NamespaceNotFound,
"no collection" ) );
}
const CollectionCatalogEntry* cce = collection->getCatalogEntry();
invariant(cce);
vector<string> indexNames;
cce->getAllIndexes( txn, &indexNames );
BSONArrayBuilder arr;
for ( size_t i = 0; i < indexNames.size(); i++ ) {
arr.append( cce->getIndexSpec( txn, indexNames[i] ) );
}
result.append( "indexes", arr.arr() );
return true;
}
virtual bool run(OperationContext* txn,
const string& dbname,
BSONObj& cmdObj,
int,
string& errmsg,
BSONObjBuilder& result) {
boost::optional<DisableDocumentValidation> maybeDisableValidation;
if (shouldBypassDocumentValidationforCommand(cmdObj))
maybeDisableValidation.emplace(txn);
string from = cmdObj.getStringField("clone");
if ( from.empty() )
return false;
CloneOptions opts;
opts.fromDB = dbname;
opts.slaveOk = cmdObj["slaveOk"].trueValue();
// See if there's any collections we should ignore
if( cmdObj["collsToIgnore"].type() == Array ){
BSONObjIterator it( cmdObj["collsToIgnore"].Obj() );
while( it.more() ){
BSONElement e = it.next();
if( e.type() == String ){
opts.collsToIgnore.insert( e.String() );
}
}
}
set<string> clonedColls;
ScopedTransaction transaction(txn, MODE_IX);
Lock::DBLock dbXLock(txn->lockState(), dbname, MODE_X);
Cloner cloner;
bool rval = cloner.go(txn, dbname, from, opts, &clonedColls, errmsg);
BSONArrayBuilder barr;
barr.append( clonedColls );
result.append( "clonedColls", barr.arr() );
return rval;
}
bo ReplSetConfig::asBson() const {
bob b;
b.append("_id", _id).append("version", version);
BSONArrayBuilder a;
for( unsigned i = 0; i < members.size(); i++ )
a.append( members[i].asBson() );
b.append("members", a.arr());
BSONObjBuilder settings;
bool empty = true;
if (!rules.empty()) {
bob modes;
for (map<string,TagRule*>::const_iterator it = rules.begin(); it != rules.end(); it++) {
bob clauses;
vector<TagClause*> r = (*it).second->clauses;
for (vector<TagClause*>::iterator it2 = r.begin(); it2 < r.end(); it2++) {
clauses << (*it2)->name << (*it2)->target;
}
modes << (*it).first << clauses.obj();
}
settings << "getLastErrorModes" << modes.obj();
empty = false;
}
if (!getLastErrorDefaults.isEmpty()) {
settings << "getLastErrorDefaults" << getLastErrorDefaults;
empty = false;
}
if (_heartbeatTimeout != DEFAULT_HB_TIMEOUT) {
settings << "heartbeatTimeoutSecs" << _heartbeatTimeout;
empty = false;
}
if (!_chainingAllowed) {
settings << "chainingAllowed" << _chainingAllowed;
empty = false;
}
if (!empty) {
b << "settings" << settings.obj();
}
return b.obj();
}
BSONArray buildOpPrecond(const string& ns,
const string& shardName,
const ChunkVersion& shardVersion) {
BSONArrayBuilder preCond;
BSONObjBuilder condB;
condB.append("ns", ChunkType::ConfigNS);
condB.append("q",
BSON("query" << BSON(ChunkType::ns(ns)) << "orderby"
<< BSON(ChunkType::DEPRECATED_lastmod() << -1)));
{
BSONObjBuilder resB(condB.subobjStart("res"));
shardVersion.addToBSON(resB, ChunkType::DEPRECATED_lastmod());
resB.done();
}
preCond.append(condB.obj());
return preCond.arr();
}
// SERVER-15899: test iteration using a path that generates no elements, but traverses a long
// array containing subdocuments with nested arrays.
TEST(Path, NonMatchingLongArrayOfSubdocumentsWithNestedArrays) {
ElementPath p;
ASSERT(p.init("a.b.x").isOK());
// Build the document {a: [{b: []}, {b: []}, {b: []}, ...]}.
BSONObj subdoc = BSON("b" << BSONArray());
BSONArrayBuilder builder;
for (int i = 0; i < 100 * 1000; ++i) {
builder.append(subdoc);
}
BSONObj doc = BSON("a" << builder.arr());
BSONElementIterator cursor(&p, doc);
// The path "a.b.x" matches no elements.
ASSERT(!cursor.more());
}
void Projection::transform( const BSONObj& in , BSONObjBuilder& b, const MatchDetails* details ) const {
const ArrayOpType& arrayOpType = getArrayOpType();
BSONObjIterator i(in);
while ( i.more() ) {
BSONElement e = i.next();
if ( mongoutils::str::equals( "_id" , e.fieldName() ) ) {
if ( _includeID )
b.append( e );
}
else {
Matchers::const_iterator matcher = _matchers.find( e.fieldName() );
if ( matcher == _matchers.end() ) {
// no array projection matchers for this field
append( b, e, details, arrayOpType );
} else {
// field has array projection with $elemMatch specified.
massert( 16348, "matchers are only supported for $elemMatch",
arrayOpType == ARRAY_OP_ELEM_MATCH );
MatchDetails arrayDetails;
arrayDetails.requestElemMatchKey();
if ( matcher->second->matches( in, &arrayDetails ) ) {
LOG(4) << "Matched array on field: " << matcher->first << endl
<< " from array: " << in.getField( matcher->first ) << endl
<< " in object: " << in << endl
<< " at position: " << arrayDetails.elemMatchKey() << endl;
FieldMap::const_iterator field = _fields.find( e.fieldName() );
massert( 16349, "$elemMatch specified, but projection field not found.",
field != _fields.end() );
BSONArrayBuilder a;
BSONObjBuilder o;
massert( 16350, "$elemMatch called on document element with eoo",
! in.getField( e.fieldName() ).eoo() );
massert( 16351, "$elemMatch called on array element with eoo",
! in.getField( e.fieldName() ).Obj().getField(
arrayDetails.elemMatchKey() ).eoo() );
a.append( in.getField( e.fieldName() ).Obj()
.getField( arrayDetails.elemMatchKey() ) );
o.appendArray( matcher->first, a.arr() );
append( b, o.done().firstElement(), details, arrayOpType );
}
}
}
}
}
BSONObj listFiles(const BSONObj& _args, void* data) {
BSONObj cd = BSON( "0" << "." );
BSONObj args = _args.isEmpty() ? cd : _args;
uassert( 10257 , "need to specify 1 argument to listFiles" , args.nFields() == 1 );
BSONArrayBuilder lst;
string rootname = args.firstElement().valuestrsafe();
boost::filesystem::path root( rootname );
stringstream ss;
ss << "listFiles: no such directory: " << rootname;
string msg = ss.str();
uassert( 12581, msg.c_str(), boost::filesystem::exists( root ) );
boost::filesystem::directory_iterator end;
boost::filesystem::directory_iterator i( root);
while ( i != end ) {
boost::filesystem::path p = *i;
BSONObjBuilder b;
#if BOOST_VERSION >= 104400
b << "name" << p.generic_string();
#else
b << "name" << p.string();
#endif
b.appendBool( "isDirectory", is_directory( p ) );
if ( ! boost::filesystem::is_directory( p ) ) {
try {
b.append( "size" , (double)boost::filesystem::file_size( p ) );
}
catch ( ... ) {
i++;
continue;
}
}
lst.append( b.obj() );
i++;
}
BSONObjBuilder ret;
ret.appendArray( "", lst.done() );
return ret.obj();
}
BSONArray storageEngineList() {
if (!hasGlobalEnvironment())
return BSONArray();
boost::scoped_ptr<StorageFactoriesIterator> sfi(
getGlobalEnvironment()->makeStorageFactoriesIterator());
if (!sfi)
return BSONArray();
BSONArrayBuilder engineArrayBuilder;
while (sfi->more()) {
engineArrayBuilder.append(sfi->next()->getCanonicalName());
}
return engineArrayBuilder.arr();
}
BSONArray storageEngineList() {
if (!hasGlobalServiceContext())
return BSONArray();
std::unique_ptr<StorageFactoriesIterator> sfi(
getGlobalServiceContext()->makeStorageFactoriesIterator());
if (!sfi)
return BSONArray();
BSONArrayBuilder engineArrayBuilder;
while (sfi->more()) {
engineArrayBuilder.append(sfi->next()->getCanonicalName());
}
return engineArrayBuilder.arr();
}
bo ReplSetConfig::MemberCfg::asBson() const {
bob b;
b << "_id" << _id;
b.append("host", h.toString());
if( votes != 1 ) b << "votes" << votes;
if( priority != 1.0 ) b << "priority" << priority;
if( arbiterOnly ) b << "arbiterOnly" << true;
if( slaveDelay ) b << "slaveDelay" << slaveDelay;
if( hidden ) b << "hidden" << hidden;
if( !buildIndexes ) b << "buildIndexes" << buildIndexes;
if( !tags.empty() ) {
BSONArrayBuilder a;
for( set<string>::const_iterator i = tags.begin(); i != tags.end(); i++ )
a.append(*i);
b.appendArray("tags", a.done());
}
return b.obj();
}
bool run(OperationContext* txn,
const string& dbname,
BSONObj& jsobj,
int,
string& errmsg,
BSONObjBuilder& result,
bool /*fromRepl*/) {
Lock::DBRead lk( txn->lockState(), dbname );
const Database* d = dbHolder().get( txn, dbname );
const DatabaseCatalogEntry* dbEntry = NULL;
list<string> names;
if ( d ) {
dbEntry = d->getDatabaseCatalogEntry();
dbEntry->getCollectionNamespaces( &names );
names.sort();
}
BSONArrayBuilder arr;
for ( list<string>::const_iterator i = names.begin(); i != names.end(); ++i ) {
string ns = *i;
StringData collection = nsToCollectionSubstring( ns );
if ( collection == "system.namespaces" ) {
continue;
}
BSONObjBuilder b;
b.append( "name", collection );
CollectionOptions options =
dbEntry->getCollectionCatalogEntry( txn, ns )->getCollectionOptions(txn);
b.append( "options", options.toBSON() );
arr.append( b.obj() );
}
result.append( "collections", arr.arr() );
return true;
}
