DocumentSource::GetNextResult DocumentSourceCheckInvalidate::getNext() {
pExpCtx->checkForInterrupt();
invariant(!pExpCtx->inMongos);
if (_queuedInvalidate) {
const auto res = DocumentSource::GetNextResult(std::move(_queuedInvalidate.get()));
_queuedInvalidate.reset();
return res;
}
auto nextInput = pSource->getNext();
if (!nextInput.isAdvanced())
return nextInput;
auto doc = nextInput.getDocument();
const auto& kOperationTypeField = DSCS::kOperationTypeField;
DSCS::checkValueType(doc[kOperationTypeField], kOperationTypeField, BSONType::String);
auto operationType = doc[kOperationTypeField].getString();
// If this command should invalidate the stream, generate an invalidate entry and queue it up
// to be returned after the notification of this command. The new entry will have a nearly
// identical resume token to the notification for the command, except with an extra flag
// indicating that the token is from an invalidate. This flag is necessary to disambiguate
// the two tokens, and thus preserve a total ordering on the stream.
// As a special case, if a client receives an invalidate like this one and then wants to
// start a new stream after the invalidate, they can use the "startAfter" option, in which
// case '_ignoreFirstInvalidate' will be set, and we should ignore (AKA not generate) the
// very first invalidation.
if (isInvalidatingCommand(pExpCtx, operationType) && !_ignoreFirstInvalidate) {
auto resumeTokenData = ResumeToken::parse(doc[DSCS::kIdField].getDocument()).getData();
resumeTokenData.fromInvalidate = ResumeTokenData::FromInvalidate::kFromInvalidate;
MutableDocument result(Document{{DSCS::kIdField, ResumeToken(resumeTokenData).toDocument()},
{DSCS::kOperationTypeField, DSCS::kInvalidateOpType},
{DSCS::kClusterTimeField, doc[DSCS::kClusterTimeField]}});
// If we're in a sharded environment, we'll need to merge the results by their sort key, so
// add that as metadata.
result.copyMetaDataFrom(doc);
_queuedInvalidate = result.freeze();
}
// Regardless of whether the first document we see is an invalidating command, we only skip the
// first invalidate for streams with the 'startAfter' option, so we should not skip any
// invalidates that come after the first one.
_ignoreFirstInvalidate = false;
return nextInput;
}
DocumentSource::GetNextResult DocumentSourceCloseCursor::getNext() {
pExpCtx->checkForInterrupt();
// Close cursor if we have returned an invalidate entry.
if (_shouldCloseCursor) {
uasserted(ErrorCodes::CloseChangeStream, "Change stream has been invalidated");
}
if (_queuedInvalidate) {
_shouldCloseCursor = true;
return DocumentSource::GetNextResult(std::move(_queuedInvalidate.get()));
}
auto nextInput = pSource->getNext();
if (!nextInput.isAdvanced())
return nextInput;
auto doc = nextInput.getDocument();
const auto& kOperationTypeField = DocumentSourceChangeStream::kOperationTypeField;
DocumentSourceChangeStream::checkValueType(
doc[kOperationTypeField], kOperationTypeField, BSONType::String);
auto operationType = doc[kOperationTypeField].getString();
if (operationType == DocumentSourceChangeStream::kInvalidateOpType) {
// Pass the invalidation forward, so that it can be included in the results, or
// filtered/transformed by further stages in the pipeline, then throw an exception
// to close the cursor on the next call to getNext().
_shouldCloseCursor = true;
}
// Check if this is an invalidating command and the next entry should be an "invalidate".
if (isInvalidatingCommand(pExpCtx, operationType)) {
_queuedInvalidate = Document{
{DocumentSourceChangeStream::kIdField, doc[DocumentSourceChangeStream::kIdField]},
{DocumentSourceChangeStream::kClusterTimeField,
doc[DocumentSourceChangeStream::kClusterTimeField]},
{DocumentSourceChangeStream::kOperationTypeField, "invalidate"_sd}};
}
return nextInput;
}
