bool run(const string& dbname, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool fromRepl ) {
bool all = *cmdObj.firstElement().valuestrsafe() == '*';
int before = result.len();
if( all || cmdObj.hasElement("quiet") ) {
result.append("quiet", cmdLine.quiet );
}
if( all || cmdObj.hasElement("notablescan") ) {
result.append("notablescan", cmdLine.noTableScan);
}
if( all || cmdObj.hasElement("logLevel") ) {
result.append("logLevel", logLevel);
}
if( all || cmdObj.hasElement("syncdelay") ) {
result.append("syncdelay", cmdLine.syncdelay);
}
if( all || cmdObj.hasElement("replApplyBatchSize") ) {
result.append("replApplyBatchSize", replApplyBatchSize);
}
if ( before == result.len() ) {
errmsg = "no option found to get";
return false;
}
return true;
}
bool run(const string& dbname, BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result, bool fromRepl ) {
bool all = *cmdObj.firstElement().valuestrsafe() == '*';
int before = result.len();
// TODO: convert to ServerParameters -- SERVER-10515
if (isJournalingEnabled() && (all || cmdObj.hasElement("journalCommitInterval")) &&
!isMongos()) {
result.append("journalCommitInterval",
getJournalCommitInterval());
}
if( all || cmdObj.hasElement( "traceExceptions" ) ) {
result.append("traceExceptions",
DBException::traceExceptions);
}
if( all || cmdObj.hasElement( "replMonitorMaxFailedChecks" ) ) {
result.append("replMonitorMaxFailedChecks",
ReplicaSetMonitor::getMaxFailedChecks());
}
const ServerParameter::Map& m = ServerParameterSet::getGlobal()->getMap();
for ( ServerParameter::Map::const_iterator i = m.begin(); i != m.end(); ++i ) {
if ( all || cmdObj.hasElement( i->first.c_str() ) ) {
i->second->append( result, i->second->name() );
}
}
if ( before == result.len() ) {
errmsg = "no option found to get";
return false;
}
return true;
}
Copy(){
// putting it in a subobject to force copy on getOwned
BSONObjBuilder outer;
BSONObjBuilder b (outer.subobjStart("inner"));
while (b.len() < LEN)
b.append(BSONObjBuilder::numStr(b.len()), b.len());
b.done();
_base = outer.obj();
}
BSONObj IndexBounds::toBSON() const {
BSONObjBuilder bob;
vector<OrderedIntervalList>::const_iterator itField;
for (itField = fields.begin(); itField != fields.end(); ++itField) {
BSONArrayBuilder fieldBuilder(bob.subarrayStart(itField->name));
vector<Interval>::const_iterator itInterval;
for (itInterval = itField->intervals.begin(); itInterval != itField->intervals.end();
++itInterval) {
std::string intervalStr = itInterval->toString();
// Insulate against hitting BSON size limit.
if ((bob.len() + (int)intervalStr.size()) > BSONObjMaxUserSize) {
fieldBuilder.append("warning: bounds truncated due to BSON size limit");
fieldBuilder.doneFast();
return bob.obj();
}
fieldBuilder.append(intervalStr);
}
fieldBuilder.doneFast();
}
return bob.obj();
}
bool run(OperationContext* txn,
const string& dbname,
BSONObj& cmdObj,
int,
string& errmsg,
BSONObjBuilder& result) {
bool all = *cmdObj.firstElement().valuestrsafe() == '*';
int before = result.len();
const ServerParameter::Map& m = ServerParameterSet::getGlobal()->getMap();
for (ServerParameter::Map::const_iterator i = m.begin(); i != m.end(); ++i) {
if (all || cmdObj.hasElement(i->first.c_str())) {
i->second->append(txn, result, i->second->name());
}
}
if (before == result.len()) {
errmsg = "no option found to get";
return false;
}
return true;
}
BSONObj ObjectWrapper::toBSON() {
if (getScope(_context)->getProto<BSONInfo>().instanceOf(_object)) {
BSONObj* originalBSON = nullptr;
bool altered;
std::tie(originalBSON, altered) = BSONInfo::originalBSON(_context, _object);
if (originalBSON && !altered)
return *originalBSON;
}
JS::RootedId id(_context);
// INCREDIBLY SUBTLE BEHAVIOR:
//
// (jcarey): Be very careful about how the Rooting API is used in
// relationship to WriteFieldRecursionFrames. Mozilla'a API more or less
// demands that the rooting types are on the stack and only manipulated as
// regular objects, which we aren't doing here. The reason they do this is
// because the rooting types must be global created and destroyed in an
// entirely linear order. This is impossible to screw up in regular use,
// but our unwinding of the recursion frames makes it easy to do here.
//
// The roots above need to be before the first frame is emplaced (so
// they'll be destroyed after it) and none of the roots in the below code
// (or in ValueWriter::writeThis) can live longer than until the call to
// emplace() inside ValueWriter. The runtime asserts enabled by MozJS's
// debug mode will catch runtime errors, but be aware of how difficult this
// is to get right and what to look for if one of them bites you.
BSONObjBuilder b;
{
// NOTE: Keep the frames in a scope so that it is clear that
// we always destroy them before we destroy 'b'. It is
// important to do so: if 'b' is destroyed before the frames,
// and we don't pop all of the frames (say, due to an
// exeption), then the frame dtors would write to freed
// memory.
WriteFieldRecursionFrames frames;
frames.emplace(_context, _object, nullptr, StringData{});
// We special case the _id field in top-level objects and move it to the front.
// This matches other drivers behavior and makes finding the _id field quicker in BSON.
if (hasOwnField(InternedString::_id)) {
_writeField(&b, InternedString::_id, &frames, frames.top().originalBSON);
}
while (frames.size()) {
auto& frame = frames.top();
// If the index is the same as length, we've seen all the keys at this
// level and should go up a level
if (frame.idx == frame.ids.length()) {
frames.pop();
continue;
}
if (frame.idx == 0 && frame.originalBSON && !frame.altered) {
// If this is our first look at the object and it has an unaltered
// bson behind it, move idx to the end so we'll roll up on the next
// pass through the loop.
frame.subbob_or(&b)->appendElements(*frame.originalBSON);
frame.idx = frame.ids.length();
continue;
}
id.set(frame.ids[frame.idx++]);
if (frames.size() == 1) {
IdWrapper idw(_context, id);
// TODO: check if it's cheaper to just compare with an interned
// string of "_id" rather than with ascii
if (idw.isString() && idw.equalsAscii("_id")) {
continue;
}
}
// writeField invokes ValueWriter with the frame stack, which will push
// onto frames for subobjects, which will effectively recurse the loop.
_writeField(frame.subbob_or(&b), JS::HandleId(id), &frames, frame.originalBSON);
}
}
const int sizeWithEOO = b.len() + 1 /*EOO*/ - 4 /*BSONObj::Holder ref count*/;
uassert(17260,
str::stream() << "Converting from JavaScript to BSON failed: "
<< "Object size "
<< sizeWithEOO
<< " exceeds limit of "
<< BSONObjMaxInternalSize
<< " bytes.",
sizeWithEOO <= BSONObjMaxInternalSize);
return b.obj();
}