int main(int argc, char** argv)
{
int ret = 0;
int err = 0;
int enable = 0;
bool exit = false;
char buf;
char ethDev[16];
strcpy(ethDev, "eth0");
struct duv060_ethernet_module_t *module;
struct duv060_ethernet_device_t *device;
printf("alex_ethtest::start!\r\n");
err = hw_get_module(DUV060_ETHERNET_MODULE_ID, (hw_module_t const**)&module);
if (err != 0)
{
printf("alex_ethtest::hw_get_module(%s) failed (%s)\n", DUV060_ETHERNET_MODULE_ID, strerror(-err));
ret = -1;
goto finish;
}
err = libethernet_open(&module->common, &device);
if (err != 0)
{
printf("alex_ethtest::libethernet_open() failed (%s)\n", strerror(-err));
ret = -1;
goto finish;
}
while (!exit)
{
enable = libethernet_getInterfaceState(device, ethDev);
if (enable == -1)
{
printf("alex_ethtest::no %s device!\n", ethDev);
ret = -1;
goto finish;
}
printf("\n+++ alex_ethtest +++\n");
if (enable == 1)
{
printf("[1] Disable eth0\n");
printf("[2] Enable DHCP\n");
printf("[3] Renew DHCP\n");
printf("[4] Set IP\n");
printf("[5] Get Net Status\n");
printf("\n");
printf("[Q] Quit\n");
}
else
{
printf("[1] Enable eth0\n");
printf("\n");
printf("[Q] Quit\n");
}
printf("--- alex_ethtest ---\n\n");
buf = getchar();
if (enable == 1)
{
switch (buf)
{
case '1':
err = libethernet_disableInterface(device, ethDev);
break;
case '2':
err = doDhcp(device, ethDev);
break;
case '3':
err = doDhcpRenew(device, ethDev);
break;
case '4':
err = setIP(device, ethDev);
break;
case '5':
err = getStatus(device, ethDev);
break;
case 'q':
case 'Q':
exit = true;
goto finish;
break;
}
}
else
{
switch (buf)
{
case '1':
err = libethernet_enableInterface(device, ethDev);
break;
case 'q':
case 'Q':
exit = true;
goto finish;
break;
}
}
}
finish:
if (ret != 0)
printf("alex_ethtest::failed!\r\n");
err = libethernet_close(device);
if (err != 0)
printf("alex_ethtest::libethernet_close() failed (%s)\n", strerror(-err));
printf("alex_ethtest::leave!\r\n");
return ret;
}
void AbstractOplogFetcher::_callback(const Fetcher::QueryResponseStatus& result,
BSONObjBuilder* getMoreBob) {
Status responseStatus =
_checkForShutdownAndConvertStatus(result.getStatus(), "error in fetcher batch callback");
if (ErrorCodes::CallbackCanceled == responseStatus) {
LOG(1) << _getComponentName() << " oplog query cancelled to " << _getSource() << ": "
<< redact(responseStatus);
_finishCallback(responseStatus);
return;
}
// If target cut connections between connecting and querying (for
// example, because it stepped down) we might not have a cursor.
if (!responseStatus.isOK()) {
BSONObj findCommandObj =
_makeFindCommandObject(_nss, _getLastOpTimeWithHashFetched().opTime);
BSONObj metadataObj = _makeMetadataObject();
{
stdx::lock_guard<stdx::mutex> lock(_mutex);
if (_fetcherRestarts == _maxFetcherRestarts) {
log() << "Error returned from oplog query (no more query restarts left): "
<< redact(responseStatus);
} else {
log() << "Restarting oplog query due to error: " << redact(responseStatus)
<< ". Last fetched optime (with hash): " << _lastFetched
<< ". Restarts remaining: " << (_maxFetcherRestarts - _fetcherRestarts);
_fetcherRestarts++;
// Destroying current instance in _shuttingDownFetcher will possibly block.
_shuttingDownFetcher.reset();
// Move the old fetcher into the shutting down instance.
_shuttingDownFetcher.swap(_fetcher);
// Create and start fetcher with current term and new starting optime.
_fetcher = _makeFetcher(findCommandObj, metadataObj);
auto scheduleStatus = _scheduleFetcher_inlock();
if (scheduleStatus.isOK()) {
log() << "Scheduled new oplog query " << _fetcher->toString();
return;
}
error() << "Error scheduling new oplog query: " << redact(scheduleStatus)
<< ". Returning current oplog query error: " << redact(responseStatus);
}
}
_finishCallback(responseStatus);
return;
}
// Reset fetcher restart counter on successful response.
{
stdx::lock_guard<stdx::mutex> lock(_mutex);
invariant(_isActive_inlock());
_fetcherRestarts = 0;
}
if (_isShuttingDown()) {
_finishCallback(
Status(ErrorCodes::CallbackCanceled, _getComponentName() + " shutting down"));
return;
}
// At this point we have a successful batch and can call the subclass's _onSuccessfulBatch.
const auto& queryResponse = result.getValue();
auto batchResult = _onSuccessfulBatch(queryResponse);
if (!batchResult.isOK()) {
// The stopReplProducer fail point expects this to return successfully. If another fail
// point wants this to return unsuccessfully, it should use a different error code.
if (batchResult.getStatus() == ErrorCodes::FailPointEnabled) {
_finishCallback(Status::OK());
return;
}
_finishCallback(batchResult.getStatus());
return;
}
// No more data. Stop processing and return Status::OK.
if (!getMoreBob) {
_finishCallback(Status::OK());
return;
}
// We have now processed the batch and should move forward our view of _lastFetched. Note that
// the _lastFetched value will not be updated until the _onSuccessfulBatch function is
// completed.
const auto& documents = queryResponse.documents;
if (documents.size() > 0) {
auto lastDocRes = AbstractOplogFetcher::parseOpTimeWithHash(documents.back());
if (!lastDocRes.isOK()) {
_finishCallback(lastDocRes.getStatus());
return;
}
auto lastDoc = lastDocRes.getValue();
LOG(3) << _getComponentName()
<< " setting last fetched optime ahead after batch: " << lastDoc.opTime
<< "; hash: " << lastDoc.value;
stdx::lock_guard<stdx::mutex> lock(_mutex);
_lastFetched = lastDoc;
}
// Check for shutdown to save an unnecessary `getMore` request.
if (_isShuttingDown()) {
_finishCallback(
Status(ErrorCodes::CallbackCanceled, _getComponentName() + " shutting down"));
return;
}
// The _onSuccessfulBatch function returns the `getMore` command we want to send.
getMoreBob->appendElements(batchResult.getValue());
}
int PietteTech_DHT::acquireAndWait() {
acquire();
while(acquiring()) ;
return getStatus();
}
void RS_ActionDrawImage::commandEvent(RS_CommandEvent* e) {
QString c = e->getCommand().toLower();
if (checkCommand("help", c)) {
RS_DIALOGFACTORY->commandMessage(msgAvailableCommands()
+ getAvailableCommands().join(", "));
return;
}
switch (getStatus()) {
case SetTargetPoint:
if (checkCommand("angle", c)) {
deletePreview();
lastStatus = (Status)getStatus();
setStatus(SetAngle);
} else if (checkCommand("factor", c)) {
deletePreview();
lastStatus = (Status)getStatus();
setStatus(SetFactor);
} else if (checkCommand("dpi",c)) {
deletePreview();
lastStatus =(Status)getStatus();
setStatus(SetDPI);
}
break;
case SetAngle: {
bool ok;
double a = RS_Math::eval(c, &ok);
if (ok) {
setAngle(RS_Math::deg2rad(a));
} else {
RS_DIALOGFACTORY->commandMessage(tr("Not a valid expression"));
}
RS_DIALOGFACTORY->requestOptions(this, true, true);
setStatus(lastStatus);
}
break;
case SetFactor: {
bool ok;
double f = RS_Math::eval(c, &ok);
if (ok) {
setFactor(f);
} else {
RS_DIALOGFACTORY->commandMessage(tr("Not a valid expression"));
}
RS_DIALOGFACTORY->requestOptions(this, true, true);
setStatus(lastStatus);
}
break;
case SetDPI : {
bool ok;
double dpi = RS_Math::eval(c, &ok);
if(ok) {
setFactor(RS_Units::dpiToScale(dpi, document->getGraphicUnit()));
} else {
RS_DIALOGFACTORY->commandMessage(tr("Not a valid expression"));
}
RS_DIALOGFACTORY->requestOptions(this, true, true);
setStatus(lastStatus);
}
break;
default:
break;
}
}
Status ClusterAggregate::runAggregate(OperationContext* txn,
const Namespaces& namespaces,
BSONObj cmdObj,
int options,
BSONObjBuilder* result) {
auto scopedShardDbStatus = ScopedShardDatabase::getExisting(txn, namespaces.executionNss.db());
if (!scopedShardDbStatus.isOK()) {
appendEmptyResultSet(
*result, scopedShardDbStatus.getStatus(), namespaces.requestedNss.ns());
return Status::OK();
}
auto request = AggregationRequest::parseFromBSON(namespaces.executionNss, cmdObj);
if (!request.isOK()) {
return request.getStatus();
}
const auto conf = scopedShardDbStatus.getValue().db();
// Determine the appropriate collation and 'resolve' involved namespaces to make the
// ExpressionContext.
// We won't try to execute anything on a mongos, but we still have to populate this map so that
// any $lookups, etc. will be able to have a resolved view definition. It's okay that this is
// incorrect, we will repopulate the real resolved namespace map on the mongod. Note that we
// need to check if any involved collections are sharded before forwarding an aggregation
// command on an unsharded collection.
StringMap<ExpressionContext::ResolvedNamespace> resolvedNamespaces;
LiteParsedPipeline liteParsedPipeline(request.getValue());
for (auto&& ns : liteParsedPipeline.getInvolvedNamespaces()) {
uassert(28769, str::stream() << ns.ns() << " cannot be sharded", !conf->isSharded(ns.ns()));
resolvedNamespaces[ns.coll()] = {ns, std::vector<BSONObj>{}};
}
if (!conf->isSharded(namespaces.executionNss.ns())) {
return aggPassthrough(txn, namespaces, conf, cmdObj, result, options);
}
auto chunkMgr = conf->getChunkManager(txn, namespaces.executionNss.ns());
std::unique_ptr<CollatorInterface> collation;
if (!request.getValue().getCollation().isEmpty()) {
collation = uassertStatusOK(CollatorFactoryInterface::get(txn->getServiceContext())
->makeFromBSON(request.getValue().getCollation()));
} else if (chunkMgr->getDefaultCollator()) {
collation = chunkMgr->getDefaultCollator()->clone();
}
boost::intrusive_ptr<ExpressionContext> mergeCtx = new ExpressionContext(
txn, request.getValue(), std::move(collation), std::move(resolvedNamespaces));
mergeCtx->inRouter = true;
// explicitly *not* setting mergeCtx->tempDir
// Parse and optimize the pipeline specification.
auto pipeline = Pipeline::parse(request.getValue().getPipeline(), mergeCtx);
if (!pipeline.isOK()) {
return pipeline.getStatus();
}
pipeline.getValue()->optimizePipeline();
// If the first $match stage is an exact match on the shard key (with a simple collation or
// no string matching), we only have to send it to one shard, so send the command to that
// shard.
BSONObj firstMatchQuery = pipeline.getValue()->getInitialQuery();
BSONObj shardKeyMatches;
shardKeyMatches = uassertStatusOK(
chunkMgr->getShardKeyPattern().extractShardKeyFromQuery(txn, firstMatchQuery));
bool singleShard = false;
if (!shardKeyMatches.isEmpty()) {
auto chunk = chunkMgr->findIntersectingChunk(
txn, shardKeyMatches, request.getValue().getCollation());
if (chunk.isOK()) {
singleShard = true;
}
}
// Don't need to split pipeline if the first $match is an exact match on shard key, unless
// there is a stage that needs to be run on the primary shard.
const bool needPrimaryShardMerger = pipeline.getValue()->needsPrimaryShardMerger();
const bool needSplit = !singleShard || needPrimaryShardMerger;
// Split the pipeline into pieces for mongod(s) and this mongos. If needSplit is true,
// 'pipeline' will become the merger side.
boost::intrusive_ptr<Pipeline> shardPipeline(needSplit ? pipeline.getValue()->splitForSharded()
: pipeline.getValue());
// Create the command for the shards. The 'fromRouter' field means produce output to be
// merged.
MutableDocument commandBuilder(request.getValue().serializeToCommandObj());
commandBuilder[AggregationRequest::kPipelineName] = Value(shardPipeline->serialize());
if (needSplit) {
commandBuilder[AggregationRequest::kFromRouterName] = Value(true);
commandBuilder[AggregationRequest::kCursorName] =
Value(DOC(AggregationRequest::kBatchSizeName << 0));
}
// These fields are not part of the AggregationRequest since they are not handled by the
// aggregation subsystem, so we serialize them separately.
const std::initializer_list<StringData> fieldsToPropagateToShards = {
"$queryOptions", "readConcern", QueryRequest::cmdOptionMaxTimeMS,
};
for (auto&& field : fieldsToPropagateToShards) {
commandBuilder[field] = Value(cmdObj[field]);
}
BSONObj shardedCommand = commandBuilder.freeze().toBson();
BSONObj shardQuery = shardPipeline->getInitialQuery();
// Run the command on the shards
// TODO need to make sure cursors are killed if a retry is needed
std::vector<Strategy::CommandResult> shardResults;
Strategy::commandOp(txn,
namespaces.executionNss.db().toString(),
shardedCommand,
options,
namespaces.executionNss.ns(),
shardQuery,
request.getValue().getCollation(),
&shardResults);
if (mergeCtx->isExplain) {
// This must be checked before we start modifying result.
uassertAllShardsSupportExplain(shardResults);
if (needSplit) {
*result << "needsPrimaryShardMerger" << needPrimaryShardMerger << "splitPipeline"
<< DOC("shardsPart" << shardPipeline->writeExplainOps() << "mergerPart"
<< pipeline.getValue()->writeExplainOps());
} else {
*result << "splitPipeline" << BSONNULL;
}
BSONObjBuilder shardExplains(result->subobjStart("shards"));
for (size_t i = 0; i < shardResults.size(); i++) {
shardExplains.append(shardResults[i].shardTargetId,
BSON("host" << shardResults[i].target.toString() << "stages"
<< shardResults[i].result["stages"]));
}
return Status::OK();
}
if (!needSplit) {
invariant(shardResults.size() == 1);
invariant(shardResults[0].target.getServers().size() == 1);
auto executorPool = Grid::get(txn)->getExecutorPool();
const BSONObj reply =
uassertStatusOK(storePossibleCursor(shardResults[0].target.getServers()[0],
shardResults[0].result,
namespaces.requestedNss,
executorPool->getArbitraryExecutor(),
Grid::get(txn)->getCursorManager()));
result->appendElements(reply);
return getStatusFromCommandResult(reply);
}
pipeline.getValue()->addInitialSource(
DocumentSourceMergeCursors::create(parseCursors(shardResults), mergeCtx));
MutableDocument mergeCmd(request.getValue().serializeToCommandObj());
mergeCmd["pipeline"] = Value(pipeline.getValue()->serialize());
mergeCmd["cursor"] = Value(cmdObj["cursor"]);
if (cmdObj.hasField("$queryOptions")) {
mergeCmd["$queryOptions"] = Value(cmdObj["$queryOptions"]);
}
if (cmdObj.hasField(QueryRequest::cmdOptionMaxTimeMS)) {
mergeCmd[QueryRequest::cmdOptionMaxTimeMS] =
Value(cmdObj[QueryRequest::cmdOptionMaxTimeMS]);
}
mergeCmd.setField("writeConcern", Value(cmdObj["writeConcern"]));
mergeCmd.setField("readConcern", Value(cmdObj["readConcern"]));
// If the user didn't specify a collation already, make sure there's a collation attached to
// the merge command, since the merging shard may not have the collection metadata.
if (mergeCmd.peek()["collation"].missing()) {
mergeCmd.setField("collation",
mergeCtx->getCollator()
? Value(mergeCtx->getCollator()->getSpec().toBSON())
: Value(Document{CollationSpec::kSimpleSpec}));
}
std::string outputNsOrEmpty;
if (DocumentSourceOut* out =
dynamic_cast<DocumentSourceOut*>(pipeline.getValue()->getSources().back().get())) {
outputNsOrEmpty = out->getOutputNs().ns();
}
// Run merging command on random shard, unless a stage needs the primary shard. Need to use
// ShardConnection so that the merging mongod is sent the config servers on connection init.
auto& prng = txn->getClient()->getPrng();
const auto& mergingShardId =
(needPrimaryShardMerger || internalQueryAlwaysMergeOnPrimaryShard.load())
? conf->getPrimaryId()
: shardResults[prng.nextInt32(shardResults.size())].shardTargetId;
const auto mergingShard =
uassertStatusOK(Grid::get(txn)->shardRegistry()->getShard(txn, mergingShardId));
ShardConnection conn(mergingShard->getConnString(), outputNsOrEmpty);
BSONObj mergedResults =
aggRunCommand(txn, conn.get(), namespaces, mergeCmd.freeze().toBson(), options);
conn.done();
if (auto wcErrorElem = mergedResults["writeConcernError"]) {
appendWriteConcernErrorToCmdResponse(mergingShardId, wcErrorElem, *result);
}
// Copy output from merging (primary) shard to the output object from our command.
// Also, propagates errmsg and code if ok == false.
result->appendElementsUnique(mergedResults);
return getStatusFromCommandResult(result->asTempObj());
}
const IArchTaskBarReceiver::Icon
MSWindowsServerTaskBarReceiver::getIcon() const
{
return reinterpret_cast<Icon>(m_icon[getStatus()]);
}
/** Constructor for mythen driver; most parameters are simply passed to ADDriver::ADDriver.
* After calling the base class constructor this method creates a thread to collect the detector data,
* and sets reasonable default values for the parameters defined in this class, asynNDArrayDriver, and ADDriver.
* \param[in] portName The name of the asyn port driver to be created.
* \param[in] IPPortName The asyn network port connection to the Mythen
* \param[in] maxBuffers The maximum number of NDArray buffers that the NDArrayPool for this driver is
* allowed to allocate. Set this to -1 to allow an unlimited number of buffers.
* \param[in] maxMemory The maximum amount of memory that the NDArrayPool for this driver is
* allowed to allocate. Set this to -1 to allow an unlimited amount of memory.
* \param[in] priority The thread priority for the asyn port driver thread if ASYN_CANBLOCK is set in asynFlags.
* \param[in] stackSize The stack size for the asyn port driver thread if ASYN_CANBLOCK is set in asynFlags.
*/
mythen::mythen(const char *portName, const char *IPPortName,
int maxBuffers, size_t maxMemory,
int priority, int stackSize)
: ADDriver(portName, 1, NUM_SD_PARAMS, maxBuffers, maxMemory,
0, 0, /* No interfaces beyond those set in ADDriver.cpp */
ASYN_CANBLOCK | ASYN_MULTIDEVICE, 1, /* ASYN_CANBLOCK=1, ASYN_MULTIDEVICE=1, autoConnect=1 */
priority, stackSize)
// , pDetector(NULL)
{
int status = asynSuccess;
// NDArray *pData;
const char *functionName = "mythen";
IPPortName_ = epicsStrDup(IPPortName);
isBigEndian_ = EPICS_BYTE_ORDER == EPICS_ENDIAN_BIG;
/* Create the epicsEvents for signaling to the mythen task when acquisition starts and stops */
this->startEventId_ = epicsEventCreate(epicsEventEmpty);
if (!this->startEventId_) {
printf("%s:%s epicsEventCreate failure for start event\n",
driverName, functionName);
return;
}
// Connect to the server
status = pasynOctetSyncIO->connect(IPPortName, 0, &pasynUserMeter_, NULL);
if (status) {
printf("%s:%s: error calling pasynOctetSyncIO->connect, status=%d, error=%s\n",
driverName, functionName, status, pasynUserMeter_->errorMessage);
return;
}
createParam(SDSettingString, asynParamInt32, &SDSetting);
createParam(SDDelayTimeString, asynParamFloat64, &SDDelayTime);
createParam(SDThresholdString, asynParamFloat64, &SDThreshold);
createParam(SDEnergyString, asynParamFloat64, &SDEnergy);
createParam(SDUseFlatFieldString, asynParamInt32, &SDUseFlatField);
createParam(SDUseCountRateString, asynParamInt32, &SDUseCountRate);
createParam(SDUseBadChanIntrplString, asynParamInt32, &SDUseBadChanIntrpl);
createParam(SDBitDepthString, asynParamInt32, &SDBitDepth);
createParam(SDUseGatesString, asynParamInt32, &SDUseGates);
createParam(SDNumGatesString, asynParamInt32, &SDNumGates);
createParam(SDNumFramesString, asynParamInt32, &SDNumFrames);
createParam(SDTriggerString, asynParamInt32, &SDTrigger);
createParam(SDResetString, asynParamInt32, &SDReset);
createParam(SDTauString, asynParamFloat64, &SDTau);
createParam(SDNModulesString, asynParamInt32, &SDNModules);
createParam(SDFirmwareVersionString, asynParamOctet, &SDFirmwareVersion);
createParam(SDReadModeString, asynParamInt32, &SDReadMode);
status = setStringParam (ADManufacturer, "Dectris");
status |= setStringParam (ADModel, "Mythen");
status |= getFirmware();
status |= setStringParam (SDFirmwareVersion, firmwareVersion_);
int sensorSizeX = MAX_DIMS;
int sensorSizeY = 1;
status |= setIntegerParam(ADMaxSizeX, sensorSizeX);
status |= setIntegerParam(ADMaxSizeY, sensorSizeY);
int minX, minY, sizeX, sizeY;
minX = 1; minY = 1; sizeX = MAX_DIMS; sizeY = 1;
status |= setIntegerParam(ADMinX, minX);
status |= setIntegerParam(ADMinY, minY);
status |= setIntegerParam(ADSizeX, sizeX);
status |= setIntegerParam(ADSizeY, sizeY);
status |= setIntegerParam(NDArraySize, 0);
status |= setIntegerParam(NDDataType, NDInt32);
status |= setIntegerParam(ADImageMode, ADImageSingle);
/* NOTE: these char type waveform record could not be initialized in iocInit
* Instead use autosave to restore their values.
* It is left here only for references.
* */
status |= setIntegerParam(ADStatus, getStatus());
//Get Firmware version
// Read the current settings from the device. This will set parameters in the parameter library.
getSettings();
int aux;
//get nmodules and check for errors
strcpy(outString_, "-get nmodules");
status |= writeReadMeter();
aux = stringToInt32(this->inString_);
if (aux < 0) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: error, outString=%s, inString=%s\n",
driverName, functionName, outString_, inString_);
return;
}
this->nmodules=aux;
status |= setIntegerParam(SDNModules, aux);
detArray_ = (epicsInt32*) calloc(this->nmodules*1280, sizeof(epicsInt32));
tmpArray_ = (epicsUInt32*) calloc(this->nmodules*1280, sizeof(epicsInt32));
callParamCallbacks();
if (status) {
printf("%s: unable to read camera parameters\n", functionName);
return;
}
/* Register the shutdown function for epicsAtExit */
// epicsAtExit(c_shutdown, (void*)this);
/* Create the thread that runs acquisition */
status = (epicsThreadCreate("acquisitionTask",
epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)acquisitionTaskC,
this) == NULL);
/* Create the thread that polls status */
// status = (epicsThreadCreate("pollTask",
// epicsThreadPriorityMedium,
// epicsThreadGetStackSize(epicsThreadStackMedium),
// (EPICSTHREADFUNC)pollTaskC,
// this) == NULL);
}
void DccTransferRecv::setFileName( const QString& fileName )
{
if ( getStatus() == Configuring )
m_fileName = fileName;
}
void DccTransferRecv::setFileURL( const KURL& url )
{
if ( getStatus() == Configuring || getStatus() == Queued )
m_fileURL = url;
}
void DccTransferRecv::setPartnerPort( const QString& port )
{
if ( getStatus() == Configuring )
m_partnerPort = port;
}
void DccTransferRecv::setFileSize( unsigned long fileSize )
{
if ( getStatus() == Configuring )
m_fileSize = fileSize;
}
void DccTransferRecv::setPartnerIp( const QString& ip )
{
if ( getStatus() == Configuring )
m_partnerIp = ip;
}
void RS_ActionSelect::mouseReleaseEvent(RS_MouseEvent* e) {
if (RS2::qtToRsButtonState(e->button())==RS2::RightButton) {
init(getStatus()-1);
}
}
BSONObj RollbackSourceMock::getLastOperation() const {
auto iter = _oplog->makeIterator();
auto result = iter->next();
ASSERT_OK(result.getStatus());
return result.getValue().first;
}
void run() {
AutoGetCollectionForRead ctx(&_txn, nss.ns());
Collection* collection = ctx.getCollection();
ASSERT(collection);
// Query can be answered by either index on "a" or index on "b".
auto statusWithCQ = CanonicalQuery::canonicalize(nss, fromjson("{a: {$gte: 8}, b: 1}"));
ASSERT_OK(statusWithCQ.getStatus());
const std::unique_ptr<CanonicalQuery> cq = std::move(statusWithCQ.getValue());
// We shouldn't have anything in the plan cache for this shape yet.
PlanCache* cache = collection->infoCache()->getPlanCache();
ASSERT(cache);
CachedSolution* rawCachedSolution;
ASSERT_NOT_OK(cache->get(*cq, &rawCachedSolution));
// Get planner params.
QueryPlannerParams plannerParams;
fillOutPlannerParams(&_txn, collection, cq.get(), &plannerParams);
// Set up queued data stage to take a long time before returning EOF. Should be long
// enough to trigger a replan.
const size_t decisionWorks = 10;
const size_t mockWorks =
1U + static_cast<size_t>(internalQueryCacheEvictionRatio * decisionWorks);
auto mockChild = stdx::make_unique<QueuedDataStage>(&_txn, &_ws);
for (size_t i = 0; i < mockWorks; i++) {
mockChild->pushBack(PlanStage::NEED_TIME);
}
CachedPlanStage cachedPlanStage(
&_txn, collection, &_ws, cq.get(), plannerParams, decisionWorks, mockChild.release());
// This should succeed after triggering a replan.
PlanYieldPolicy yieldPolicy(nullptr, PlanExecutor::YIELD_MANUAL);
ASSERT_OK(cachedPlanStage.pickBestPlan(&yieldPolicy));
// Make sure that we get 2 legit results back.
size_t numResults = 0;
PlanStage::StageState state = PlanStage::NEED_TIME;
while (state != PlanStage::IS_EOF) {
WorkingSetID id = WorkingSet::INVALID_ID;
state = cachedPlanStage.work(&id);
ASSERT_NE(state, PlanStage::FAILURE);
ASSERT_NE(state, PlanStage::DEAD);
if (state == PlanStage::ADVANCED) {
WorkingSetMember* member = _ws.get(id);
ASSERT(cq->root()->matchesBSON(member->obj.value()));
numResults++;
}
}
ASSERT_EQ(numResults, 2U);
// This time we expect to find something in the plan cache. Replans after hitting the
// works threshold result in a cache entry.
ASSERT_OK(cache->get(*cq, &rawCachedSolution));
const std::unique_ptr<CachedSolution> cachedSolution(rawCachedSolution);
}
bool DccTransferRecv::queue()
{
kdDebug() << "DccTransferRecv::queue()" << endl;
if ( getStatus() != Configuring )
return false;
if ( m_partnerIp.isEmpty() || m_partnerPort.isEmpty() )
return false;
if (!kapp->authorize("allow_downloading"))
{
//note we have this after the initialisations so that item looks okay
//Do not have the rights to send the file. Shouldn't have gotten this far anyway
failed(i18n("The admin has restricted the right to receive files"));
return false;
}
// check if the sender IP is valid
if ( m_partnerIp == "0.0.0.0" )
{
failed( i18n( "Invalid sender address (%1)" ).arg( m_partnerIp ) );
return false;
}
// TODO: should we support it?
if ( m_fileSize == 0 )
{
failed( i18n( "Unsupported negotiation (filesize=0)" ) );
return false;
}
if ( m_fileName.isEmpty() )
{
m_fileName = "unnamed_file";
}
if ( m_fileURL.isEmpty() )
{
// determine default incoming file URL
// set default folder
if ( !Preferences::dccPath().isEmpty() )
m_fileURL = KURL( Preferences::dccPath() );
else
m_fileURL.setPath( KUser( KUser::UseRealUserID ).homeDir() ); // default folder is *not* specified
// add a slash if there is none
m_fileURL.adjustPath( 1 );
// Append folder with partner's name if wanted
if ( Preferences::dccCreateFolder() )
m_fileURL.addPath( m_partnerNick + '/' );
// Just incase anyone tries to do anything nasty
QString fileNameSanitized = sanitizeFileName( m_fileName );
// Append partner's name to file name if wanted
if ( Preferences::dccAddPartner() )
m_fileURL.addPath( m_partnerNick + '.' + fileNameSanitized );
else
m_fileURL.addPath( fileNameSanitized );
}
return DccTransfer::queue();
}
bool run(OperationContext* txn,
const string& dbname,
BSONObj& cmdObj,
int,
string& errmsg,
BSONObjBuilder& result) {
BSONElement first = cmdObj.firstElement();
uassert(28528,
str::stream() << "Argument to listIndexes must be of type String, not "
<< typeName(first.type()),
first.type() == String);
StringData collectionName = first.valueStringData();
uassert(28529,
str::stream() << "Argument to listIndexes must be a collection name, "
<< "not the empty string",
!collectionName.empty());
const NamespaceString ns(dbname, collectionName);
const long long defaultBatchSize = std::numeric_limits<long long>::max();
long long batchSize;
Status parseCursorStatus = parseCommandCursorOptions(cmdObj, defaultBatchSize, &batchSize);
if (!parseCursorStatus.isOK()) {
return appendCommandStatus(result, parseCursorStatus);
}
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;
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
indexNames.clear();
cce->getAllIndexes(txn, &indexNames);
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "listIndexes", ns.ns());
auto ws = make_unique<WorkingSet>();
auto root = make_unique<QueuedDataStage>(txn, ws.get());
for (size_t i = 0; i < indexNames.size(); i++) {
BSONObj indexSpec;
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
indexSpec = cce->getIndexSpec(txn, indexNames[i]);
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "listIndexes", ns.ns());
WorkingSetID id = ws->allocate();
WorkingSetMember* member = ws->get(id);
member->keyData.clear();
member->loc = RecordId();
member->obj = Snapshotted<BSONObj>(SnapshotId(), indexSpec.getOwned());
member->transitionToOwnedObj();
root->pushBack(id);
}
std::string cursorNamespace = str::stream() << dbname << ".$cmd." << name << "."
<< ns.coll();
dassert(NamespaceString(cursorNamespace).isValid());
dassert(NamespaceString(cursorNamespace).isListIndexesCursorNS());
dassert(ns == NamespaceString(cursorNamespace).getTargetNSForListIndexes());
auto statusWithPlanExecutor = PlanExecutor::make(
txn, std::move(ws), std::move(root), cursorNamespace, PlanExecutor::YIELD_MANUAL);
if (!statusWithPlanExecutor.isOK()) {
return appendCommandStatus(result, statusWithPlanExecutor.getStatus());
}
unique_ptr<PlanExecutor> exec = std::move(statusWithPlanExecutor.getValue());
BSONArrayBuilder firstBatch;
const int byteLimit = FindCommon::kMaxBytesToReturnToClientAtOnce;
for (long long objCount = 0; objCount < batchSize && firstBatch.len() < byteLimit;
objCount++) {
BSONObj next;
PlanExecutor::ExecState state = exec->getNext(&next, NULL);
if (state == PlanExecutor::IS_EOF) {
break;
}
invariant(state == PlanExecutor::ADVANCED);
firstBatch.append(next);
}
CursorId cursorId = 0LL;
if (!exec->isEOF()) {
exec->saveState();
exec->detachFromOperationContext();
ClientCursor* cursor =
new ClientCursor(CursorManager::getGlobalCursorManager(),
exec.release(),
cursorNamespace,
txn->recoveryUnit()->isReadingFromMajorityCommittedSnapshot());
cursorId = cursor->cursorid();
}
appendCursorResponseObject(cursorId, cursorNamespace, firstBatch.arr(), &result);
return true;
}
void DccTransferRecv::slotSocketClosed()
{
finishTransferLogger();
if ( getStatus() == Transferring )
failed( i18n( "Remote user disconnected" ) );
}
void CCharGeneration::Events(int key){
std::cout << "status: " << getStatus() << " Key: " << key << std::endl;
if(getStatus()==1){ // check select character classes
if(key==TK_UP){
m_menu_index--;
}
if(key==TK_DOWN){
m_menu_index++;
}
if(m_menu_index>=(int)CharClasses.size()){
m_menu_index=0;
}
if(m_menu_index<0){
m_menu_index=CharClasses.size()-1;
}
if ((key >= TK_A && key <= TK_Z) || key==TK_ENTER){
int index;
if(key==TK_ENTER){
index = m_menu_index;
}else{
index = key-TK_A;
}
if(index < (int) CharClasses.size() && index >= 0){
SelectCharClass(CharClasses[index].id);
setStatus(2);
}
}
}else if(getStatus()==2){
//std::cout << "menu iotems count: " << m_class_skills.size() << std::endl;
if(key==TK_UP){
m_menu_index--;
}
if(key==TK_DOWN){
m_menu_index++;
}
if(key==TK_RIGHT){
m_menu_index+=10;
if(m_menu_index>(int)m_class_skills.size()-1){
m_menu_index=m_class_skills.size()-1;
}
}
if(key==TK_LEFT){
m_menu_index-=10;
if(m_menu_index<0){
m_menu_index=0;
}
}
if(m_menu_index>=(int)m_class_skills.size()){
m_menu_index=0;
}
if(m_menu_index<0){
m_menu_index=m_class_skills.size()-1;
}
if ((key >= TK_A && key <= TK_Z) || key == TK_ENTER){
int index;
if(key==TK_ENTER){
index = m_menu_index;
}else{
index = key-TK_A;
}
if(index < (int)m_class_skills.size() && index >= 0){
if(!isSkillSelected(m_class_skills[index].id)){ // if skill not selected
m_selected_skills.push_back(m_class_skills[index]);
if(m_selected_skills.size() == 4){
setStatus(3);
}
}
}
}
}else if(getStatus()==3){
if (key == TK_N ){
std::cout << "Recreate character! " << std::endl;
setStatus(0);
}else if (key == TK_Y ){
std::cout << "Start game!" << std::endl;
setStatus(4); // inform for start game
}
}
}
void DatabasesCloner::_onListDatabaseFinish(
const executor::TaskExecutor::RemoteCommandCallbackArgs& cbd) {
Status respStatus = cbd.response.status;
if (respStatus.isOK()) {
respStatus = getStatusFromCommandResult(cbd.response.data);
}
UniqueLock lk(_mutex);
if (!respStatus.isOK()) {
LOG(1) << "'listDatabases' failed: " << respStatus;
_fail_inlock(&lk, respStatus);
return;
}
// There should not be any cloners yet.
invariant(_databaseCloners.size() == 0);
const auto respBSON = cbd.response.data;
auto databasesArray = _parseListDatabasesResponse(respBSON);
if (!databasesArray.isOK()) {
LOG(1) << "'listDatabases' returned a malformed response: "
<< databasesArray.getStatus().toString();
_fail_inlock(&lk, databasesArray.getStatus());
return;
}
auto dbsArray = databasesArray.getValue();
// Ensure that the 'admin' database is the first element in the array of databases so that it
// will be the first to be cloned. This allows users to authenticate against a database while
// initial sync is occurring.
_setAdminAsFirst(dbsArray);
for (BSONElement arrayElement : dbsArray) {
const BSONObj dbBSON = arrayElement.Obj();
// Check to see if we want to exclude this db from the clone.
if (!_includeDbFn(dbBSON)) {
LOG(1) << "Excluding database from the 'listDatabases' response: " << dbBSON;
continue;
}
if (!dbBSON.hasField("name")) {
LOG(1) << "Excluding database due to the 'listDatabases' response not containing a "
"'name' field for this entry: "
<< dbBSON;
}
const std::string dbName = dbBSON["name"].str();
std::shared_ptr<DatabaseCloner> dbCloner{nullptr};
// filters for DatabasesCloner.
const auto collectionFilterPred = [dbName](const BSONObj& collInfo) {
const auto collName = collInfo["name"].str();
const NamespaceString ns(dbName, collName);
if (ns.isSystem() && !ns.isLegalClientSystemNS()) {
LOG(1) << "Skipping 'system' collection: " << ns.ns();
return false;
}
if (!ns.isNormal()) {
LOG(1) << "Skipping non-normal collection: " << ns.ns();
return false;
}
LOG(2) << "Allowing cloning of collectionInfo: " << collInfo;
return true;
};
const auto onCollectionFinish = [](const Status& status, const NamespaceString& srcNss) {
if (status.isOK()) {
LOG(1) << "collection clone finished: " << srcNss;
} else {
error() << "collection clone for '" << srcNss << "' failed due to "
<< status.toString();
}
};
const auto onDbFinish = [this, dbName](const Status& status) {
_onEachDBCloneFinish(status, dbName);
};
Status startStatus = Status::OK();
try {
dbCloner.reset(new DatabaseCloner(
_exec,
_dbWorkThreadPool,
_source,
dbName,
BSONObj(), // do not filter collections out during listCollections call.
collectionFilterPred,
_storage, // use storage provided.
onCollectionFinish,
onDbFinish));
if (_scheduleDbWorkFn) {
dbCloner->setScheduleDbWorkFn_forTest(_scheduleDbWorkFn);
}
if (_startCollectionClonerFn) {
dbCloner->setStartCollectionClonerFn(_startCollectionClonerFn);
}
// Start first database cloner.
if (_databaseCloners.empty()) {
startStatus = dbCloner->startup();
}
} catch (...) {
startStatus = exceptionToStatus();
}
if (!startStatus.isOK()) {
std::string err = str::stream() << "could not create cloner for database: " << dbName
<< " due to: " << startStatus.toString();
_setStatus_inlock({ErrorCodes::InitialSyncFailure, err});
error() << err;
break; // exit for_each loop
}
// add cloner to list.
_databaseCloners.push_back(dbCloner);
}
if (_databaseCloners.size() == 0) {
if (_status.isOK()) {
_succeed_inlock(&lk);
} else {
_fail_inlock(&lk, _status);
}
}
}
void mythen::acquisitionTask()
{
size_t nread, nread_expect;
size_t nwrite;
int eventStatus;
int imageMode;
epicsInt32 acquire, eomReason;
double acquireTime;
asynStatus status = asynSuccess;
int dataOK;
static const char *functionName = "acquisitionTask";
this->lock();
while (1) {
/* Is acquisition active? */
getIntegerParam(ADAcquire, &acquire);
/* If we are not acquiring then wait for a semaphore that is given when acquisition is started */
if (!acquire || !acquiring_) {
setIntegerParam(ADStatus, ADStatusIdle);
callParamCallbacks();
/* Release the lock while we wait for an event that says acquire has started, then lock again */
asynPrint(this->pasynUserSelf, ASYN_TRACE_FLOW,
"%s:%s: waiting for acquire to start\n", driverName, functionName);
this->unlock();
eventStatus = epicsEventWait(this->startEventId_);
// setStringParam(ADStatusMessage, "Acquiring data");
// setIntegerParam(ADNumImagesCounter, 0);
// getIntegerParam(ADAcquire, &acquire);
//printf("Read Mode: %d\tnModules: %d\t chanperline: %d\n", readmode_,this->nmodules,chanperline_);
if (readmode_==0) //Raw Mode
nread_expect = sizeof(epicsInt32)*this->nmodules*(1280/chanperline_);
else
nread_expect = sizeof(epicsInt32)*this->nmodules*(1280);
dataOK = 1;
eventStatus = getStatus();
setIntegerParam(ADStatus, eventStatus);
if (eventStatus!=ADStatusError) {
getDoubleParam(ADAcquireTime,&acquireTime);
// printf("Acquisition start - expect %d\n",nread_expect);
// Work on the cases of what are you getting from getstatus
do {
nread=0;
if (readmode_==0)
strcpy(outString_, "-readoutraw");
else
strcpy(outString_, "-readout");
status = pasynOctetSyncIO->writeRead(pasynUserMeter_, outString_, strlen(outString_), (char *)detArray_,
nread_expect, M1K_TIMEOUT+acquireTime, &nwrite, &nread, &eomReason); //Timeout is M1K_TIMEOUT + AcquireTime
//printf("nread_expected = %d\tnread = %d\n", nread_expect,nread);
if(nread == nread_expect) {
this->lock();
dataOK = dataCallback(detArray_);
this->unlock();
if (!dataOK) {
eventStatus = getStatus();
setIntegerParam(ADStatus, eventStatus);
}
}
else {
eventStatus = getStatus();
setIntegerParam(ADStatus, eventStatus);
//printf("Data not size expected ADStatus: %d\n",eventStatus);
}
if(status != asynSuccess) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: error using readout command status=%d, nRead=%d, eomReason=%d\n",
driverName, functionName, status, (int)nread, eomReason);
}
}
while (status == asynSuccess && (eventStatus==ADStatusAcquire||eventStatus==ADStatusReadout) && acquiring_);
}
this->lock();
}
if (eventStatus!=ADStatusError ) {
printf("Acquisition finish\n");
getIntegerParam(ADImageMode, &imageMode);
if (imageMode == ADImageSingle || imageMode == ADImageMultiple) {
printf("ADAcquire Callback\n");
acquiring_ = 0;
setIntegerParam(ADAcquire, 0);
callParamCallbacks();
}
}
else {
//Abort read
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: error timed out waiting for data\n",
driverName, functionName);
acquiring_ = 0;
setAcquire(0);
setIntegerParam(ADAcquire, 0);
callParamCallbacks();
}
}
}
void BackgroundSync::_fetcherCallback(const StatusWith<Fetcher::QueryResponse>& result,
BSONObjBuilder* bob,
const HostAndPort& source,
OpTime lastOpTimeFetched,
long long lastFetchedHash,
Status* remoteOplogStartStatus) {
// if target cut connections between connecting and querying (for
// example, because it stepped down) we might not have a cursor
if (!result.isOK()) {
return;
}
if (inShutdown()) {
return;
}
// Check if we have been paused.
if (isPaused()) {
return;
}
const auto& queryResponse = result.getValue();
// Forward metadata (containing liveness information) to replication coordinator.
bool receivedMetadata =
queryResponse.otherFields.metadata.hasElement(rpc::kReplSetMetadataFieldName);
if (receivedMetadata) {
auto metadataResult =
rpc::ReplSetMetadata::readFromMetadata(queryResponse.otherFields.metadata);
if (!metadataResult.isOK()) {
error() << "invalid replication metadata from sync source " << source << ": "
<< metadataResult.getStatus() << ": " << queryResponse.otherFields.metadata;
return;
}
_replCoord->processReplSetMetadata(metadataResult.getValue());
}
const auto& documents = queryResponse.documents;
auto documentBegin = documents.cbegin();
auto documentEnd = documents.cend();
// Check start of remote oplog and, if necessary, stop fetcher to execute rollback.
if (queryResponse.first) {
auto getNextOperation = [&documentBegin, documentEnd]() -> StatusWith<BSONObj> {
if (documentBegin == documentEnd) {
return Status(ErrorCodes::OplogStartMissing, "remote oplog start missing");
}
return *(documentBegin++);
};
*remoteOplogStartStatus =
checkRemoteOplogStart(getNextOperation, lastOpTimeFetched, lastFetchedHash);
if (!remoteOplogStartStatus->isOK()) {
// Stop fetcher and execute rollback.
return;
}
// If this is the first batch and no rollback is needed, we should have advanced
// the document iterator.
invariant(documentBegin != documents.cbegin());
}
// process documents
int currentBatchMessageSize = 0;
for (auto documentIter = documentBegin; documentIter != documentEnd; ++documentIter) {
if (inShutdown()) {
return;
}
// If we are transitioning to primary state, we need to leave
// this loop in order to go into bgsync-pause mode.
if (_replCoord->isWaitingForApplierToDrain() || _replCoord->getMemberState().primary()) {
LOG(1) << "waiting for draining or we are primary, not adding more ops to buffer";
return;
}
// At this point, we are guaranteed to have at least one thing to read out
// of the fetcher.
const BSONObj& o = *documentIter;
currentBatchMessageSize += o.objsize();
opsReadStats.increment();
if (MONGO_FAIL_POINT(stepDownWhileDrainingFailPoint)) {
sleepsecs(20);
}
{
stdx::unique_lock<stdx::mutex> lock(_mutex);
_appliedBuffer = false;
}
OCCASIONALLY {
LOG(2) << "bgsync buffer has " << _buffer.size() << " bytes";
}
bufferCountGauge.increment();
bufferSizeGauge.increment(getSize(o));
_buffer.push(o);
{
stdx::unique_lock<stdx::mutex> lock(_mutex);
_lastFetchedHash = o["h"].numberLong();
_lastOpTimeFetched = fassertStatusOK(28770, OpTime::parseFromBSON(o));
LOG(3) << "lastOpTimeFetched: " << _lastOpTimeFetched;
}
}
// record time for each batch
getmoreReplStats.recordMillis(durationCount<Milliseconds>(queryResponse.elapsedMillis));
networkByteStats.increment(currentBatchMessageSize);
// Check some things periodically
// (whenever we run out of items in the
// current cursor batch)
if (currentBatchMessageSize > 0 && currentBatchMessageSize < BatchIsSmallish) {
// on a very low latency network, if we don't wait a little, we'll be
// getting ops to write almost one at a time. this will both be expensive
// for the upstream server as well as potentially defeating our parallel
// application of batches on the secondary.
//
// the inference here is basically if the batch is really small, we are
// "caught up".
//
sleepmillis(SleepToAllowBatchingMillis);
}
// If we are transitioning to primary state, we need to leave
// this loop in order to go into bgsync-pause mode.
if (_replCoord->isWaitingForApplierToDrain() || _replCoord->getMemberState().primary()) {
return;
}
// re-evaluate quality of sync target
if (_shouldChangeSyncSource(source)) {
return;
}
// Check if we have been paused.
if (isPaused()) {
return;
}
// We fill in 'bob' to signal the fetcher to process with another getMore.
invariant(bob);
bob->append("getMore", queryResponse.cursorId);
bob->append("collection", queryResponse.nss.coll());
bob->append("maxTimeMS", durationCount<Milliseconds>(fetcherMaxTimeMS));
if (receivedMetadata) {
bob->append("term", _replCoord->getTerm());
}
}
void RS_ActionPolylineTrim::mouseReleaseEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
RS_Vector cPoint;
switch (getStatus()) {
case ChooseEntity:
delEntity = catchEntity(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (delEntity->rtti()!=RS2::EntityPolyline) {
RS_DIALOGFACTORY->commandMessage(
tr("Entity must be a polyline."));
} else {
delEntity->setHighlighted(true);
graphicView->drawEntity(delEntity);
setStatus(SetSegment1);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
}
break;
case SetSegment1:
cPoint = snapPoint(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (!cPoint.valid) {
RS_DIALOGFACTORY->commandMessage(tr("Specifying point is invalid."));
} else if (!delEntity->isPointOnEntity(cPoint)) {
RS_DIALOGFACTORY->commandMessage(
tr("No Segment found on entity."));
}else{
Segment1 = NULL;
double dist = graphicView->toGraphDX(snapRange)*0.9;
Segment1 = (RS_AtomicEntity*)((RS_Polyline*)delEntity)->getNearestEntity( RS_Vector(graphicView->toGraphX(e->x()),
graphicView->toGraphY(e->y())), &dist, RS2::ResolveNone);
if(Segment1 == NULL)
break;
setStatus(SetSegment2);
}
break;
case SetSegment2:
cPoint = snapPoint(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (!cPoint.valid) {
RS_DIALOGFACTORY->commandMessage(tr("Specifying point is invalid."));
} else if (!delEntity->isPointOnEntity(cPoint)) {
RS_DIALOGFACTORY->commandMessage(
tr("No Segment found on entity."));
}else{
Segment2 = NULL;
double dist = graphicView->toGraphDX(snapRange)*0.9;
Segment2 = (RS_AtomicEntity*)((RS_Polyline*)delEntity)->getNearestEntity( RS_Vector(graphicView->toGraphX(e->x()),
graphicView->toGraphY(e->y())), &dist, RS2::ResolveNone);
if(Segment2 == NULL)
break;
deleteSnapper();
trigger();
}
break;
default:
break;
}
} else if (e->button()==Qt::RightButton) {
deleteSnapper();
if (delEntity) {
delEntity->setHighlighted(false);
graphicView->drawEntity(delEntity);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
}
init(getStatus()-1);
}
}
StatusWith<MoveChunkRequest> MoveChunkRequest::createFromCommand(NamespaceString nss,
const BSONObj& obj) {
auto secondaryThrottleStatus = MigrationSecondaryThrottleOptions::createFromCommand(obj);
if (!secondaryThrottleStatus.isOK()) {
return secondaryThrottleStatus.getStatus();
}
auto rangeStatus = ChunkRange::fromBSON(obj);
if (!rangeStatus.isOK()) {
return rangeStatus.getStatus();
}
MoveChunkRequest request(std::move(nss),
std::move(rangeStatus.getValue()),
std::move(secondaryThrottleStatus.getValue()));
{
std::string configServerConnectionString;
Status status = bsonExtractStringField(
obj, kConfigServerConnectionString, &configServerConnectionString);
if (!status.isOK()) {
return status;
}
auto statusConfigServerCS = ConnectionString::parse(configServerConnectionString);
if (!statusConfigServerCS.isOK()) {
return statusConfigServerCS.getStatus();
}
request._configServerCS = std::move(statusConfigServerCS.getValue());
}
{
std::string shardStr;
Status status = bsonExtractStringField(obj, kFromShardId, &shardStr);
request._fromShardId = shardStr;
if (!status.isOK()) {
return status;
}
}
{
std::string shardStr;
Status status = bsonExtractStringField(obj, kToShardId, &shardStr);
request._toShardId = shardStr;
if (!status.isOK()) {
return status;
}
}
{
auto statusWithChunkVersion =
ChunkVersion::parseFromBSONWithFieldForCommands(obj, kChunkVersion);
if (statusWithChunkVersion.isOK()) {
request._chunkVersion = std::move(statusWithChunkVersion.getValue());
} else if (statusWithChunkVersion != ErrorCodes::NoSuchKey) {
return statusWithChunkVersion.getStatus();
}
}
{
Status status =
bsonExtractBooleanFieldWithDefault(obj, kWaitForDelete, false, &request._waitForDelete);
if (!status.isOK()) {
return status;
}
}
{
long long maxChunkSizeBytes;
Status status = bsonExtractIntegerField(obj, kMaxChunkSizeBytes, &maxChunkSizeBytes);
if (!status.isOK()) {
return status;
}
request._maxChunkSizeBytes = static_cast<int64_t>(maxChunkSizeBytes);
}
{
Status status =
bsonExtractBooleanFieldWithDefault(obj, kTakeDistLock, true, &request._takeDistLock);
if (!status.isOK()) {
return status;
}
}
return request;
}
auto clone = expr.getValue()->shallowClone();
ASSERT_TRUE(expr.getValue()->equivalent(clone.get()));
}
TEST(InternalSchemaMatchArrayIndexMatchExpression, HasSingleChild) {
auto query = fromjson(
"{foo: {$_internalSchemaMatchArrayIndex:"
"{index: 0, namePlaceholder: 'i', expression: {i: {$type: 'number'}}}}}");
boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest());
auto objMatch = MatchExpressionParser::parse(query, expCtx);
ASSERT_OK(objMatch.getStatus());
ASSERT_EQ(objMatch.getValue()->numChildren(), 1U);
ASSERT(objMatch.getValue()->getChild(0));
}
DEATH_TEST(InternalSchemaMatchArrayIndexMatchExpression,
GetChildFailsIndexGreaterThanZero,
"Invariant failure i == 0") {
auto query = fromjson(
"{foo: {$_internalSchemaMatchArrayIndex:"
"{index: 0, namePlaceholder: 'i', expression: {i: {$type: 'number'}}}}}");
boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest());
auto objMatch = MatchExpressionParser::parse(query, expCtx);
ASSERT_OK(objMatch.getStatus());
objMatch.getValue()->getChild(1);
}
} // namespace
} // namespace mongo
void openCatalog(OperationContext* opCtx, const MinVisibleTimestampMap& minVisibleTimestampMap) {
invariant(opCtx->lockState()->isW());
// Load the catalog in the storage engine.
log() << "openCatalog: loading storage engine catalog";
auto storageEngine = opCtx->getServiceContext()->getStorageEngine();
storageEngine->loadCatalog(opCtx);
log() << "openCatalog: reconciling catalog and idents";
auto indexesToRebuild = storageEngine->reconcileCatalogAndIdents(opCtx);
fassert(40688, indexesToRebuild.getStatus());
// Determine which indexes need to be rebuilt. rebuildIndexesOnCollection() requires that all
// indexes on that collection are done at once, so we use a map to group them together.
StringMap<IndexNameObjs> nsToIndexNameObjMap;
for (auto indexNamespace : indexesToRebuild.getValue()) {
NamespaceString collNss(indexNamespace.first);
auto indexName = indexNamespace.second;
auto dbCatalogEntry = storageEngine->getDatabaseCatalogEntry(opCtx, collNss.db());
invariant(dbCatalogEntry,
str::stream() << "couldn't get database catalog entry for database "
<< collNss.db());
auto collCatalogEntry = dbCatalogEntry->getCollectionCatalogEntry(collNss.toString());
invariant(collCatalogEntry,
str::stream() << "couldn't get collection catalog entry for collection "
<< collNss.toString());
auto indexSpecs = getIndexNameObjs(
opCtx, dbCatalogEntry, collCatalogEntry, [&indexName](const std::string& name) {
return name == indexName;
});
if (!indexSpecs.isOK() || indexSpecs.getValue().first.empty()) {
fassert(40689,
{ErrorCodes::InternalError,
str::stream() << "failed to get index spec for index " << indexName
<< " in collection "
<< collNss.toString()});
}
auto indexesToRebuild = indexSpecs.getValue();
invariant(
indexesToRebuild.first.size() == 1,
str::stream() << "expected to find a list containing exactly 1 index name, but found "
<< indexesToRebuild.first.size());
invariant(
indexesToRebuild.second.size() == 1,
str::stream() << "expected to find a list containing exactly 1 index spec, but found "
<< indexesToRebuild.second.size());
auto& ino = nsToIndexNameObjMap[collNss.ns()];
ino.first.emplace_back(std::move(indexesToRebuild.first.back()));
ino.second.emplace_back(std::move(indexesToRebuild.second.back()));
}
for (const auto& entry : nsToIndexNameObjMap) {
NamespaceString collNss(entry.first);
auto dbCatalogEntry = storageEngine->getDatabaseCatalogEntry(opCtx, collNss.db());
invariant(dbCatalogEntry,
str::stream() << "couldn't get database catalog entry for database "
<< collNss.db());
auto collCatalogEntry = dbCatalogEntry->getCollectionCatalogEntry(collNss.toString());
invariant(collCatalogEntry,
str::stream() << "couldn't get collection catalog entry for collection "
<< collNss.toString());
for (const auto& indexName : entry.second.first) {
log() << "openCatalog: rebuilding index: collection: " << collNss.toString()
<< ", index: " << indexName;
}
std::vector<BSONObj> indexSpecs = entry.second.second;
fassert(40690,
rebuildIndexesOnCollection(opCtx, dbCatalogEntry, collCatalogEntry, indexSpecs));
}
// Open all databases and repopulate the UUID catalog.
log() << "openCatalog: reopening all databases";
auto databaseHolder = DatabaseHolder::get(opCtx);
std::vector<std::string> databasesToOpen;
storageEngine->listDatabases(&databasesToOpen);
for (auto&& dbName : databasesToOpen) {
LOG(1) << "openCatalog: dbholder reopening database " << dbName;
auto db = databaseHolder->openDb(opCtx, dbName);
invariant(db, str::stream() << "failed to reopen database " << dbName);
std::list<std::string> collections;
db->getDatabaseCatalogEntry()->getCollectionNamespaces(&collections);
for (auto&& collName : collections) {
// Note that the collection name already includes the database component.
NamespaceString collNss(collName);
auto collection = db->getCollection(opCtx, collName);
invariant(collection,
str::stream() << "failed to get valid collection pointer for namespace "
<< collName);
auto uuid = collection->uuid();
invariant(uuid);
if (minVisibleTimestampMap.count(*uuid) > 0) {
collection->setMinimumVisibleSnapshot(minVisibleTimestampMap.find(*uuid)->second);
}
// If this is the oplog collection, re-establish the replication system's cached pointer
// to the oplog.
if (collNss.isOplog()) {
log() << "openCatalog: updating cached oplog pointer";
collection->establishOplogCollectionForLogging(opCtx);
}
}
}
// Opening UUID Catalog: The UUID catalog is now in sync with the storage engine catalog. Clear
// the pre-closing state.
UUIDCatalog::get(opCtx).onOpenCatalog(opCtx);
LOG(1) << "openCatalog: finished reloading UUID catalog";
}
void AsyncResultsMerger::handleBatchResponse(
const executor::TaskExecutor::RemoteCommandCallbackArgs& cbData, size_t remoteIndex) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
auto& remote = _remotes[remoteIndex];
// Clear the callback handle. This indicates that we are no longer waiting on a response from
// 'remote'.
remote.cbHandle = executor::TaskExecutor::CallbackHandle();
// If we're in the process of shutting down then there's no need to process the batch.
if (_lifecycleState != kAlive) {
invariant(_lifecycleState == kKillStarted);
// Make sure to wake up anyone waiting on '_currentEvent' if we're shutting down.
signalCurrentEvent_inlock();
// If we're killed and we're not waiting on any more batches to come back, then we are ready
// to kill the cursors on the remote hosts and clean up this cursor. Schedule the
// killCursors command and signal that this cursor is safe now safe to destroy. We have to
// promise not to touch any members of this class because 'this' could become invalid as
// soon as we signal the event.
if (!haveOutstandingBatchRequests_inlock()) {
// If the event handle is invalid, then the executor is in the middle of shutting down,
// and we can't schedule any more work for it to complete.
if (_killCursorsScheduledEvent.isValid()) {
scheduleKillCursors_inlock();
_executor->signalEvent(_killCursorsScheduledEvent);
}
_lifecycleState = kKillComplete;
}
return;
}
// Early return from this point on signal anyone waiting on an event, if ready() is true.
ScopeGuard signaller = MakeGuard(&AsyncResultsMerger::signalCurrentEvent_inlock, this);
if (!cbData.response.isOK()) {
_remotes[remoteIndex].status = cbData.response.getStatus();
return;
}
auto getMoreParseStatus = GetMoreResponse::parseFromBSON(cbData.response.getValue().data);
if (!getMoreParseStatus.isOK()) {
_remotes[remoteIndex].status = getMoreParseStatus.getStatus();
return;
}
auto getMoreResponse = getMoreParseStatus.getValue();
// If we have a cursor established, and we get a non-zero cursorid that is not equal to the
// established cursorid, we will fail the operation.
if (remote.cursorId && getMoreResponse.cursorId != 0 &&
*remote.cursorId != getMoreResponse.cursorId) {
_remotes[remoteIndex].status =
Status(ErrorCodes::BadValue,
str::stream() << "Expected cursorid " << *remote.cursorId << " but received "
<< getMoreResponse.cursorId);
return;
}
remote.cursorId = getMoreResponse.cursorId;
for (const auto& obj : getMoreResponse.batch) {
remote.docBuffer.push(obj);
}
// If we're doing a sorted merge, then we have to make sure to put this remote onto the
// merge queue.
if (!_params.sort.isEmpty() && !getMoreResponse.batch.empty()) {
_mergeQueue.push(remoteIndex);
}
// ScopeGuard requires dismiss on success, but we want waiter to be signalled on success as
// well as failure.
signaller.Dismiss();
signalCurrentEvent_inlock();
}
/**
* Runs a query using the following steps:
* --Parsing.
* --Acquire locks.
* --Plan query, obtaining an executor that can run it.
* --Generate the first batch.
* --Save state for getMore, transferring ownership of the executor to a ClientCursor.
* --Generate response to send to the client.
*/
bool run(OperationContext* txn,
const std::string& dbname,
BSONObj& cmdObj,
int options,
std::string& errmsg,
BSONObjBuilder& result) override {
const NamespaceString nss(parseNs(dbname, cmdObj));
if (!nss.isValid() || nss.isCommand() || nss.isSpecialCommand()) {
return appendCommandStatus(result,
{ErrorCodes::InvalidNamespace,
str::stream() << "Invalid collection name: " << nss.ns()});
}
// Although it is a command, a find command gets counted as a query.
globalOpCounters.gotQuery();
if (txn->getClient()->isInDirectClient()) {
return appendCommandStatus(
result,
Status(ErrorCodes::IllegalOperation, "Cannot run find command from eval()"));
}
// Parse the command BSON to a QueryRequest.
const bool isExplain = false;
auto qrStatus = QueryRequest::makeFromFindCommand(nss, cmdObj, isExplain);
if (!qrStatus.isOK()) {
return appendCommandStatus(result, qrStatus.getStatus());
}
auto& qr = qrStatus.getValue();
// Validate term before acquiring locks, if provided.
if (auto term = qr->getReplicationTerm()) {
auto replCoord = repl::ReplicationCoordinator::get(txn);
Status status = replCoord->updateTerm(txn, *term);
// Note: updateTerm returns ok if term stayed the same.
if (!status.isOK()) {
return appendCommandStatus(result, status);
}
}
// Fill out curop information.
//
// We pass negative values for 'ntoreturn' and 'ntoskip' to indicate that these values
// should be omitted from the log line. Limit and skip information is already present in the
// find command parameters, so these fields are redundant.
const int ntoreturn = -1;
const int ntoskip = -1;
beginQueryOp(txn, nss, cmdObj, ntoreturn, ntoskip);
// Finish the parsing step by using the QueryRequest to create a CanonicalQuery.
ExtensionsCallbackReal extensionsCallback(txn, &nss);
auto statusWithCQ = CanonicalQuery::canonicalize(txn, std::move(qr), extensionsCallback);
if (!statusWithCQ.isOK()) {
return appendCommandStatus(result, statusWithCQ.getStatus());
}
std::unique_ptr<CanonicalQuery> cq = std::move(statusWithCQ.getValue());
// Acquire locks.
AutoGetCollectionForRead ctx(txn, nss);
Collection* collection = ctx.getCollection();
// Get the execution plan for the query.
auto statusWithPlanExecutor =
getExecutorFind(txn, collection, nss, std::move(cq), PlanExecutor::YIELD_AUTO);
if (!statusWithPlanExecutor.isOK()) {
return appendCommandStatus(result, statusWithPlanExecutor.getStatus());
}
std::unique_ptr<PlanExecutor> exec = std::move(statusWithPlanExecutor.getValue());
{
stdx::lock_guard<Client>(*txn->getClient());
CurOp::get(txn)->setPlanSummary_inlock(Explain::getPlanSummary(exec.get()));
}
if (!collection) {
// No collection. Just fill out curop indicating that there were zero results and
// there is no ClientCursor id, and then return.
const long long numResults = 0;
const CursorId cursorId = 0;
endQueryOp(txn, collection, *exec, numResults, cursorId);
appendCursorResponseObject(cursorId, nss.ns(), BSONArray(), &result);
return true;
}
const QueryRequest& originalQR = exec->getCanonicalQuery()->getQueryRequest();
// Stream query results, adding them to a BSONArray as we go.
CursorResponseBuilder firstBatch(/*isInitialResponse*/ true, &result);
BSONObj obj;
PlanExecutor::ExecState state = PlanExecutor::ADVANCED;
long long numResults = 0;
while (!FindCommon::enoughForFirstBatch(originalQR, numResults) &&
PlanExecutor::ADVANCED == (state = exec->getNext(&obj, NULL))) {
// If we can't fit this result inside the current batch, then we stash it for later.
if (!FindCommon::haveSpaceForNext(obj, numResults, firstBatch.bytesUsed())) {
exec->enqueue(obj);
break;
}
// Add result to output buffer.
firstBatch.append(obj);
numResults++;
}
// Throw an assertion if query execution fails for any reason.
if (PlanExecutor::FAILURE == state || PlanExecutor::DEAD == state) {
firstBatch.abandon();
error() << "Plan executor error during find command: " << PlanExecutor::statestr(state)
<< ", stats: " << Explain::getWinningPlanStats(exec.get());
return appendCommandStatus(result,
Status(ErrorCodes::OperationFailed,
str::stream()
<< "Executor error during find command: "
<< WorkingSetCommon::toStatusString(obj)));
}
// Before saving the cursor, ensure that whatever plan we established happened with the
// expected collection version
auto css = CollectionShardingState::get(txn, nss);
css->checkShardVersionOrThrow(txn);
// Set up the cursor for getMore.
CursorId cursorId = 0;
if (shouldSaveCursor(txn, collection, state, exec.get())) {
// Register the execution plan inside a ClientCursor. Ownership of the PlanExecutor is
// transferred to the ClientCursor.
//
// First unregister the PlanExecutor so it can be re-registered with ClientCursor.
exec->deregisterExec();
// Create a ClientCursor containing this plan executor. We don't have to worry about
// leaking it as it's inserted into a global map by its ctor.
ClientCursor* cursor =
new ClientCursor(collection->getCursorManager(),
exec.release(),
nss.ns(),
txn->recoveryUnit()->isReadingFromMajorityCommittedSnapshot(),
originalQR.getOptions(),
cmdObj.getOwned());
cursorId = cursor->cursorid();
invariant(!exec);
PlanExecutor* cursorExec = cursor->getExecutor();
// State will be restored on getMore.
cursorExec->saveState();
cursorExec->detachFromOperationContext();
cursor->setLeftoverMaxTimeMicros(txn->getRemainingMaxTimeMicros());
cursor->setPos(numResults);
// Fill out curop based on the results.
endQueryOp(txn, collection, *cursorExec, numResults, cursorId);
} else {
endQueryOp(txn, collection, *exec, numResults, cursorId);
}
// Generate the response object to send to the client.
firstBatch.done(cursorId, nss.ns());
return true;
}
StatusWith<Shard::CommandResponse> ShardingCatalogManagerImpl::_runCommandForAddShard(
OperationContext* opCtx,
RemoteCommandTargeter* targeter,
const std::string& dbName,
const BSONObj& cmdObj) {
auto swHost = targeter->findHost(opCtx, ReadPreferenceSetting{ReadPreference::PrimaryOnly});
if (!swHost.isOK()) {
return swHost.getStatus();
}
auto host = std::move(swHost.getValue());
executor::RemoteCommandRequest request(
host, dbName, cmdObj, rpc::makeEmptyMetadata(), nullptr, Seconds(30));
executor::RemoteCommandResponse response =
Status(ErrorCodes::InternalError, "Internal error running command");
auto swCallbackHandle = _executorForAddShard->scheduleRemoteCommand(
request, [&response](const executor::TaskExecutor::RemoteCommandCallbackArgs& args) {
response = args.response;
});
if (!swCallbackHandle.isOK()) {
return swCallbackHandle.getStatus();
}
// Block until the command is carried out
_executorForAddShard->wait(swCallbackHandle.getValue());
if (response.status == ErrorCodes::ExceededTimeLimit) {
LOG(0) << "Operation timed out with status " << redact(response.status);
}
if (!response.isOK()) {
if (!Shard::shouldErrorBePropagated(response.status.code())) {
return {ErrorCodes::OperationFailed,
str::stream() << "failed to run command " << cmdObj
<< " when attempting to add shard "
<< targeter->connectionString().toString()
<< causedBy(response.status)};
}
return response.status;
}
BSONObj result = response.data.getOwned();
Status commandStatus = getStatusFromCommandResult(result);
if (!Shard::shouldErrorBePropagated(commandStatus.code())) {
commandStatus = {ErrorCodes::OperationFailed,
str::stream() << "failed to run command " << cmdObj
<< " when attempting to add shard "
<< targeter->connectionString().toString()
<< causedBy(commandStatus)};
}
Status writeConcernStatus = getWriteConcernStatusFromCommandResult(result);
if (!Shard::shouldErrorBePropagated(writeConcernStatus.code())) {
writeConcernStatus = {ErrorCodes::OperationFailed,
str::stream() << "failed to satisfy writeConcern for command "
<< cmdObj
<< " when attempting to add shard "
<< targeter->connectionString().toString()
<< causedBy(writeConcernStatus)};
}
return Shard::CommandResponse(std::move(host),
std::move(result),
response.metadata.getOwned(),
std::move(commandStatus),
std::move(writeConcernStatus));
}
StatusWith<DistLockManager::ScopedDistLock> ReplSetDistLockManager::lock(
OperationContext* txn,
StringData name,
StringData whyMessage,
milliseconds waitFor,
milliseconds lockTryInterval) {
Timer timer(_serviceContext->getTickSource());
Timer msgTimer(_serviceContext->getTickSource());
// Counts how many attempts have been made to grab the lock, which have failed with network
// error. This value is reset for each lock acquisition attempt because these are
// independent write operations.
int networkErrorRetries = 0;
// Distributed lock acquisition works by tring to update the state of the lock to 'taken'. If
// the lock is currently taken, we will back off and try the acquisition again, repeating this
// until the lockTryInterval has been reached. If a network error occurs at each lock
// acquisition attempt, the lock acquisition will be retried immediately.
while (waitFor <= milliseconds::zero() || milliseconds(timer.millis()) < waitFor) {
const OID lockSessionID = OID::gen();
const string who = str::stream() << _processID << ":" << getThreadName();
auto lockExpiration = _lockExpiration;
MONGO_FAIL_POINT_BLOCK(setDistLockTimeout, customTimeout) {
const BSONObj& data = customTimeout.getData();
lockExpiration = stdx::chrono::milliseconds(data["timeoutMs"].numberInt());
}
LOG(1) << "trying to acquire new distributed lock for " << name
<< " ( lock timeout : " << durationCount<Milliseconds>(lockExpiration)
<< " ms, ping interval : " << durationCount<Milliseconds>(_pingInterval)
<< " ms, process : " << _processID << " )"
<< " with lockSessionID: " << lockSessionID << ", why: " << whyMessage;
auto lockResult = _catalog->grabLock(
txn, name, lockSessionID, who, _processID, Date_t::now(), whyMessage);
auto status = lockResult.getStatus();
if (status.isOK()) {
// Lock is acquired since findAndModify was able to successfully modify
// the lock document.
log() << "distributed lock '" << name << "' acquired for '" << whyMessage
<< "', ts : " << lockSessionID;
return ScopedDistLock(txn, lockSessionID, this);
}
// If a network error occurred, unlock the lock synchronously and try again
if (ShardRegistry::kAllRetriableErrors.count(status.code()) &&
networkErrorRetries < kMaxNumLockAcquireRetries) {
LOG(1) << "Failed to acquire distributed lock because of retriable error. Retrying "
"acquisition by first unlocking the stale entry, which possibly exists now"
<< causedBy(status);
networkErrorRetries++;
status = _catalog->unlock(txn, lockSessionID);
if (status.isOK()) {
// We certainly do not own the lock, so we can retry
continue;
}
// Fall-through to the error checking logic below
invariant(status != ErrorCodes::LockStateChangeFailed);
LOG(1)
<< "Failed to retry acqusition of distributed lock. No more attempts will be made"
<< causedBy(status);
}
if (status != ErrorCodes::LockStateChangeFailed) {
// An error occurred but the write might have actually been applied on the
// other side. Schedule an unlock to clean it up just in case.
queueUnlock(lockSessionID);
return status;
}
// Get info from current lock and check if we can overtake it.
auto getLockStatusResult = _catalog->getLockByName(txn, name);
const auto& getLockStatus = getLockStatusResult.getStatus();
if (!getLockStatusResult.isOK() && getLockStatus != ErrorCodes::LockNotFound) {
return getLockStatus;
}
// Note: Only attempt to overtake locks that actually exists. If lock was not
// found, use the normal grab lock path to acquire it.
if (getLockStatusResult.isOK()) {
auto currentLock = getLockStatusResult.getValue();
auto canOvertakeResult = canOvertakeLock(txn, currentLock, lockExpiration);
if (!canOvertakeResult.isOK()) {
return canOvertakeResult.getStatus();
}
if (canOvertakeResult.getValue()) {
auto overtakeResult = _catalog->overtakeLock(txn,
name,
lockSessionID,
currentLock.getLockID(),
who,
_processID,
Date_t::now(),
whyMessage);
const auto& overtakeStatus = overtakeResult.getStatus();
if (overtakeResult.isOK()) {
// Lock is acquired since findAndModify was able to successfully modify
// the lock document.
LOG(0) << "lock '" << name << "' successfully forced";
LOG(0) << "distributed lock '" << name << "' acquired, ts : " << lockSessionID;
return ScopedDistLock(txn, lockSessionID, this);
}
if (overtakeStatus != ErrorCodes::LockStateChangeFailed) {
// An error occurred but the write might have actually been applied on the
// other side. Schedule an unlock to clean it up just in case.
queueUnlock(lockSessionID);
return overtakeStatus;
}
}
}
LOG(1) << "distributed lock '" << name << "' was not acquired.";
if (waitFor == milliseconds::zero()) {
break;
}
// Periodically message for debugging reasons
if (msgTimer.seconds() > 10) {
LOG(0) << "waited " << timer.seconds() << "s for distributed lock " << name << " for "
<< whyMessage;
msgTimer.reset();
}
// A new lock acquisition attempt will begin now (because the previous found the lock to be
// busy, so reset the retries counter)
networkErrorRetries = 0;
const milliseconds timeRemaining =
std::max(milliseconds::zero(), waitFor - milliseconds(timer.millis()));
sleepFor(std::min(lockTryInterval, timeRemaining));
}
return {ErrorCodes::LockBusy, str::stream() << "timed out waiting for " << name};
}