void ClusterCursorManager::PinnedCursor::returnCursor(CursorState cursorState) {
invariant(_cursor);
// Note that unpinning a cursor transfers ownership of the underlying ClusterClientCursor object
// back to the manager.
_manager->checkInCursor(std::move(_cursor), _nss, _cursorId, cursorState);
*this = PinnedCursor();
}
StatusWith<ClusterCursorManager::PinnedCursor> ClusterCursorManager::checkOutCursor(
const NamespaceString& nss, CursorId cursorId) {
// Read the clock out of the lock.
const auto now = _clockSource->now();
stdx::lock_guard<stdx::mutex> lk(_mutex);
if (_inShutdown) {
return Status(ErrorCodes::ShutdownInProgress,
"Cannot check out cursor as we are in the process of shutting down");
}
CursorEntry* entry = getEntry_inlock(nss, cursorId);
if (!entry) {
return cursorNotFoundStatus(nss, cursorId);
}
if (entry->getKillPending()) {
return cursorNotFoundStatus(nss, cursorId);
}
std::unique_ptr<ClusterClientCursor> cursor = entry->releaseCursor();
if (!cursor) {
return cursorInUseStatus(nss, cursorId);
}
entry->setLastActive(now);
// Note that pinning a cursor transfers ownership of the underlying ClusterClientCursor object
// to the pin; the CursorEntry is left with a null ClusterClientCursor.
return PinnedCursor(this, std::move(cursor), nss, cursorId);
}
ClusterCursorManager::PinnedCursor ClusterCursorManager::registerCursor(
std::unique_ptr<ClusterClientCursor> cursor,
const NamespaceString& nss,
CursorType cursorType,
CursorLifetime cursorLifetime) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
invariant(cursor);
// Find the CursorEntryContainer for this namespace. If none exists, create one.
auto nsToContainerIt = _namespaceToContainerMap.find(nss);
if (nsToContainerIt == _namespaceToContainerMap.end()) {
uint32_t containerPrefix = 0;
do {
// The server has always generated positive values for CursorId (which is a signed
// type), so we use std::abs() here on the prefix for consistency with this historical
// behavior.
containerPrefix = static_cast<uint32_t>(std::abs(_pseudoRandom.nextInt32()));
} while (_cursorIdPrefixToNamespaceMap.count(containerPrefix) > 0);
_cursorIdPrefixToNamespaceMap[containerPrefix] = nss;
auto emplaceResult =
_namespaceToContainerMap.emplace(nss, CursorEntryContainer(containerPrefix));
invariant(emplaceResult.second);
invariant(_namespaceToContainerMap.size() == _cursorIdPrefixToNamespaceMap.size());
nsToContainerIt = emplaceResult.first;
} else {
invariant(!nsToContainerIt->second.entryMap.empty()); // If exists, shouldn't be empty.
}
CursorEntryContainer& container = nsToContainerIt->second;
// Generate a CursorId (which can't be the invalid value zero).
CursorEntryMap& entryMap = container.entryMap;
CursorId cursorId = 0;
do {
const uint32_t cursorSuffix = static_cast<uint32_t>(_pseudoRandom.nextInt32());
cursorId = createCursorId(container.containerPrefix, cursorSuffix);
} while (cursorId == 0 || entryMap.count(cursorId) > 0);
// Create a new CursorEntry and register it in the CursorEntryContainer's map.
auto emplaceResult = entryMap.emplace(
cursorId, CursorEntry(std::move(cursor), cursorType, cursorLifetime, _clockSource->now()));
invariant(emplaceResult.second);
// Pin and return the cursor. Note that pinning a cursor transfers ownership of the underlying
// ClusterClientCursor object to the pin; the CursorEntry is left with a null
// ClusterClientCursor.
CursorEntry& entry = emplaceResult.first->second;
return PinnedCursor(this, entry.releaseCursor(), nss, cursorId);
}
StatusWith<ClusterCursorManager::PinnedCursor> ClusterCursorManager::checkOutCursor(
const NamespaceString& nss, CursorId cursorId) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
CursorEntry* entry = getEntry_inlock(nss, cursorId);
if (!entry) {
return cursorNotFoundStatus(nss, cursorId);
}
if (entry->getKillPending()) {
return cursorNotFoundStatus(nss, cursorId);
}
std::unique_ptr<ClusterClientCursor> cursor = entry->releaseCursor();
if (!cursor) {
return cursorInUseStatus(nss, cursorId);
}
entry->setLastActive(_clockSource->now());
// Note that pinning a cursor transfers ownership of the underlying ClusterClientCursor object
// to the pin; the CursorEntry is left with a null ClusterClientCursor.
return PinnedCursor(this, std::move(cursor), nss, cursorId);
}
