Status ReplSetHeartbeatArgs::initialize(const BSONObj& argsObj) {
Status status =
bsonCheckOnlyHasFields("ReplSetHeartbeatArgs", argsObj, kLegalHeartbeatFieldNames);
if (!status.isOK())
return status;
status = bsonExtractBooleanFieldWithDefault(argsObj, kCheckEmptyFieldName, false, &_checkEmpty);
if (!status.isOK())
return status;
_hasCheckEmpty = true;
status = bsonExtractIntegerField(argsObj, kProtocolVersionFieldName, &_protocolVersion);
if (!status.isOK())
return status;
_hasProtocolVersion = true;
status = bsonExtractIntegerField(argsObj, kConfigVersionFieldName, &_configVersion);
if (!status.isOK())
return status;
_hasConfigVersion = true;
status = bsonExtractIntegerFieldWithDefault(argsObj, kSenderIdFieldName, -1, &_senderId);
if (!status.isOK())
return status;
_hasSenderId = true;
status = bsonExtractStringField(argsObj, kSetNameFieldName, &_setName);
if (!status.isOK())
return status;
_hasSetName = true;
std::string hostAndPortString;
status =
bsonExtractStringFieldWithDefault(argsObj, kSenderHostFieldName, "", &hostAndPortString);
if (!status.isOK())
return status;
if (!hostAndPortString.empty()) {
status = _senderHost.initialize(hostAndPortString);
if (!status.isOK())
return status;
_hasSenderHost = true;
}
return Status::OK();
}
StatusWith<ChangeLogType> ChangeLogType::fromBSON(const BSONObj& source) {
ChangeLogType changeLog;
{
std::string changeLogId;
Status status = bsonExtractStringField(source, changeId.name(), &changeLogId);
if (!status.isOK())
return status;
changeLog._changeId = changeLogId;
}
{
std::string changeLogServer;
Status status = bsonExtractStringField(source, server.name(), &changeLogServer);
if (!status.isOK())
return status;
changeLog._server = changeLogServer;
}
{
std::string changeLogShard;
Status status =
bsonExtractStringFieldWithDefault(source, shard.name(), "", &changeLogShard);
if (!status.isOK())
return status;
changeLog._shard = changeLogShard;
}
{
std::string changeLogClientAddr;
Status status = bsonExtractStringField(source, clientAddr.name(), &changeLogClientAddr);
if (!status.isOK())
return status;
changeLog._clientAddr = changeLogClientAddr;
}
{
BSONElement changeLogTimeElem;
Status status = bsonExtractTypedField(source, time.name(), Date, &changeLogTimeElem);
if (!status.isOK())
return status;
changeLog._time = changeLogTimeElem.date();
}
{
std::string changeLogWhat;
Status status = bsonExtractStringField(source, what.name(), &changeLogWhat);
if (!status.isOK())
return status;
changeLog._what = changeLogWhat;
}
{
std::string changeLogNs;
Status status = bsonExtractStringFieldWithDefault(source, ns.name(), "", &changeLogNs);
if (!status.isOK())
return status;
changeLog._ns = changeLogNs;
}
{
BSONElement changeLogDetailsElem;
Status status =
bsonExtractTypedField(source, details.name(), Object, &changeLogDetailsElem);
if (!status.isOK())
return status;
changeLog._details = changeLogDetailsElem.Obj().getOwned();
}
return changeLog;
}
StatusWith<BalancerSettingsType> BalancerSettingsType::fromBSON(const BSONObj& obj) {
BalancerSettingsType settings;
{
bool stopped;
Status status = bsonExtractBooleanFieldWithDefault(obj, kStopped, false, &stopped);
if (!status.isOK())
return status;
if (stopped) {
settings._mode = kOff;
} else {
std::string modeStr;
status = bsonExtractStringFieldWithDefault(obj, kMode, kBalancerModes[kFull], &modeStr);
if (!status.isOK())
return status;
auto it = std::find(std::begin(kBalancerModes), std::end(kBalancerModes), modeStr);
if (it == std::end(kBalancerModes)) {
return Status(ErrorCodes::BadValue, "Invalid balancer mode");
}
settings._mode = static_cast<BalancerMode>(it - std::begin(kBalancerModes));
}
}
{
BSONElement activeWindowElem;
Status status = bsonExtractTypedField(obj, kActiveWindow, Object, &activeWindowElem);
if (status.isOK()) {
const BSONObj balancingWindowObj = activeWindowElem.Obj();
if (balancingWindowObj.isEmpty()) {
return Status(ErrorCodes::BadValue, "activeWindow not specified");
}
// Check if both 'start' and 'stop' are present
const std::string start = balancingWindowObj.getField("start").str();
const std::string stop = balancingWindowObj.getField("stop").str();
if (start.empty() || stop.empty()) {
return Status(ErrorCodes::BadValue,
str::stream()
<< "must specify both start and stop of balancing window: "
<< balancingWindowObj);
}
// Check that both 'start' and 'stop' are valid time-of-day
boost::posix_time::ptime startTime;
boost::posix_time::ptime stopTime;
if (!toPointInTime(start, &startTime) || !toPointInTime(stop, &stopTime)) {
return Status(ErrorCodes::BadValue,
str::stream() << kActiveWindow << " format is "
<< " { start: \"hh:mm\" , stop: \"hh:mm\" }");
}
// Check that start and stop designate different time points
if (startTime == stopTime) {
return Status(ErrorCodes::BadValue,
str::stream() << "start and stop times must be different");
}
settings._activeWindowStart = startTime;
settings._activeWindowStop = stopTime;
} else if (status != ErrorCodes::NoSuchKey) {
return status;
}
}
{
auto secondaryThrottleStatus =
MigrationSecondaryThrottleOptions::createFromBalancerConfig(obj);
if (!secondaryThrottleStatus.isOK()) {
return secondaryThrottleStatus.getStatus();
}
settings._secondaryThrottle = std::move(secondaryThrottleStatus.getValue());
}
{
bool waitForDelete;
Status status =
bsonExtractBooleanFieldWithDefault(obj, kWaitForDelete, false, &waitForDelete);
if (!status.isOK())
return status;
settings._waitForDelete = waitForDelete;
}
return settings;
}
// TODO: The bulk of the implementation of this will need to change once we're using the
// new v2 authorization storage format.
bool run(const string& dbname,
BSONObj& cmdObj,
int options,
string& errmsg,
BSONObjBuilder& result,
bool fromRepl) {
std::string userName;
std::string password;
std::string userSource; // TODO: remove this.
bool readOnly; // TODO: remove this.
BSONElement extraData;
BSONElement roles;
if (cmdObj.hasField("pwd") && cmdObj.hasField("userSource")) {
errmsg = "User objects can't have both 'pwd' and 'userSource'";
return false;
}
if (!cmdObj.hasField("pwd") && !cmdObj.hasField("userSource")) {
errmsg = "User objects must have one of 'pwd' and 'userSource'";
return false;
}
if (cmdObj.hasField("roles") && cmdObj.hasField("readOnly")) {
errmsg = "User objects can't have both 'roles' and 'readOnly'";
return false;
}
Status status = bsonExtractStringField(cmdObj, "user", &userName);
if (!status.isOK()) {
addStatus(Status(ErrorCodes::UserModificationFailed,
"\"user\" string not specified"),
result);
return false;
}
status = bsonExtractStringFieldWithDefault(cmdObj, "pwd", "", &password);
if (!status.isOK()) {
addStatus(Status(ErrorCodes::UserModificationFailed,
"Invalid \"pwd\" string"),
result);
return false;
}
status = bsonExtractStringFieldWithDefault(cmdObj, "userSource", "", &userSource);
if (!status.isOK()) {
addStatus(Status(ErrorCodes::UserModificationFailed,
"Invalid \"userSource\" string"),
result);
return false;
}
status = bsonExtractBooleanFieldWithDefault(cmdObj, "readOnly", false, &readOnly);
if (!status.isOK()) {
addStatus(Status(ErrorCodes::UserModificationFailed,
"Invalid \"readOnly\" boolean"),
result);
return false;
}
if (cmdObj.hasField("extraData")) {
status = bsonExtractField(cmdObj, "extraData", &extraData);
if (!status.isOK()) {
addStatus(Status(ErrorCodes::UserModificationFailed,
"Invalid \"extraData\" object"),
result);
return false;
}
}
if (cmdObj.hasField("roles")) {
status = bsonExtractField(cmdObj, "roles", &roles);
if (!status.isOK()) {
addStatus(Status(ErrorCodes::UserModificationFailed,
"Invalid \"roles\" array"),
result);
return false;
}
}
BSONObjBuilder userObjBuilder;
userObjBuilder.append("user", userName);
if (cmdObj.hasField("pwd")) {
// TODO: hash password once we're receiving plaintext passwords here.
userObjBuilder.append("pwd", password);
}
if (cmdObj.hasField("userSource")) {
userObjBuilder.append("userSource", userSource);
}
if (cmdObj.hasField("readOnly")) {
userObjBuilder.append("readOnly", readOnly);
}
if (cmdObj.hasField("extraData")) {
userObjBuilder.append("extraData", extraData);
}
if (cmdObj.hasField("roles")) {
userObjBuilder.append(roles);
}
status = getGlobalAuthorizationManager()->insertPrivilegeDocument(dbname,
userObjBuilder.obj());
if (!status.isOK()) {
addStatus(status, result);
return false;
}
return true;
}
