void Strategy::writeOp(OperationContext* txn, int op, Request& request) {
// make sure we have a last error
dassert(&LastError::get(cc()));
OwnedPointerVector<BatchedCommandRequest> commandRequestsOwned;
vector<BatchedCommandRequest*>& commandRequests = commandRequestsOwned.mutableVector();
msgToBatchRequests(request.m(), &commandRequests);
for (vector<BatchedCommandRequest*>::iterator it = commandRequests.begin();
it != commandRequests.end();
++it) {
// Multiple commands registered to last error as multiple requests
if (it != commandRequests.begin())
LastError::get(cc()).startRequest();
BatchedCommandRequest* commandRequest = *it;
// Adjust namespaces for command
NamespaceString fullNS(commandRequest->getNS());
string cmdNS = fullNS.getCommandNS();
// We only pass in collection name to command
commandRequest->setNS(fullNS);
BSONObjBuilder builder;
BSONObj requestBSON = commandRequest->toBSON();
{
// Disable the last error object for the duration of the write cmd
LastError::Disabled disableLastError(&LastError::get(cc()));
Command::runAgainstRegistered(txn, cmdNS.c_str(), requestBSON, builder, 0);
}
BatchedCommandResponse commandResponse;
bool parsed = commandResponse.parseBSON(builder.done(), NULL);
(void)parsed; // for compile
dassert(parsed && commandResponse.isValid(NULL));
// Populate the lastError object based on the write response
LastError::get(cc()).reset();
bool hadError =
batchErrorToLastError(*commandRequest, commandResponse, &LastError::get(cc()));
// Check if this is an ordered batch and we had an error which should stop processing
if (commandRequest->getOrdered() && hadError)
break;
}
}
Status DistLockCatalogImpl::unlockAll(OperationContext* opCtx, const std::string& processID) {
BatchedCommandRequest request([&] {
write_ops::Update updateOp(_locksNS);
updateOp.setUpdates({[&] {
write_ops::UpdateOpEntry entry;
entry.setQ(BSON(LocksType::process(processID)));
entry.setU(BSON("$set" << BSON(LocksType::state(LocksType::UNLOCKED))));
entry.setUpsert(false);
entry.setMulti(true);
return entry;
}()});
return updateOp;
}());
request.setWriteConcern(kLocalWriteConcern.toBSON());
BSONObj cmdObj = request.toBSON();
auto const shardRegistry = Grid::get(opCtx)->shardRegistry();
auto response = shardRegistry->getConfigShard()->runCommandWithFixedRetryAttempts(
opCtx,
ReadPreferenceSetting{ReadPreference::PrimaryOnly},
_locksNS.db().toString(),
cmdObj,
Shard::kDefaultConfigCommandTimeout,
Shard::RetryPolicy::kIdempotent);
if (!response.isOK()) {
return response.getStatus();
}
if (!response.getValue().commandStatus.isOK()) {
return response.getValue().commandStatus;
}
if (!response.getValue().writeConcernStatus.isOK()) {
return response.getValue().writeConcernStatus;
}
BatchedCommandResponse batchResponse;
std::string errmsg;
if (!batchResponse.parseBSON(response.getValue().response, &errmsg)) {
return Status(ErrorCodes::FailedToParse,
str::stream()
<< "Failed to parse config server response to batch request for "
"unlocking existing distributed locks"
<< causedBy(errmsg));
}
return batchResponse.toStatus();
}
Status DistLockCatalogImpl::unlockAll(OperationContext* txn, const std::string& processID) {
std::unique_ptr<BatchedUpdateDocument> updateDoc(new BatchedUpdateDocument());
updateDoc->setQuery(BSON(LocksType::process(processID)));
updateDoc->setUpdateExpr(BSON("$set" << BSON(LocksType::state(LocksType::UNLOCKED))));
updateDoc->setUpsert(false);
updateDoc->setMulti(true);
std::unique_ptr<BatchedUpdateRequest> updateRequest(new BatchedUpdateRequest());
updateRequest->addToUpdates(updateDoc.release());
BatchedCommandRequest request(updateRequest.release());
request.setNS(_locksNS);
request.setWriteConcern(kLocalWriteConcern.toBSON());
BSONObj cmdObj = request.toBSON();
auto response = _client->getConfigShard()->runCommandWithFixedRetryAttempts(
txn,
ReadPreferenceSetting{ReadPreference::PrimaryOnly},
_locksNS.db().toString(),
cmdObj,
Shard::kDefaultConfigCommandTimeout,
Shard::RetryPolicy::kIdempotent);
if (!response.isOK()) {
return response.getStatus();
}
if (!response.getValue().commandStatus.isOK()) {
return response.getValue().commandStatus;
}
if (!response.getValue().writeConcernStatus.isOK()) {
return response.getValue().writeConcernStatus;
}
BatchedCommandResponse batchResponse;
std::string errmsg;
if (!batchResponse.parseBSON(response.getValue().response, &errmsg)) {
return Status(ErrorCodes::FailedToParse,
str::stream()
<< "Failed to parse config server response to batch request for "
"unlocking existing distributed locks"
<< causedBy(errmsg));
}
return batchResponse.toStatus();
}
SessionsCollection::SendBatchFn SessionsCollection::makeSendFnForBatchWrite(
const NamespaceString& ns, DBClientBase* client) {
auto send = [client, ns](BSONObj batch) -> Status {
BSONObj res;
if (!client->runCommand(ns.db().toString(), batch, res)) {
return getStatusFromCommandResult(res);
}
BatchedCommandResponse response;
std::string errmsg;
if (!response.parseBSON(res, &errmsg)) {
return {ErrorCodes::FailedToParse, errmsg};
}
return response.toStatus();
};
return send;
}
