DurableCatalog maintains a _rand suffix converted from a random UInt64 (or Int64 before SERVER-67468). It also maintains an incrementing counter _next, although I doubt the usefulness of this counter since it's reset to 0 on server restart.

The idents are of the pattern collection-<_next>-<_rand> or index-<_next>-<_rand>. See DurableCatalog::generateUniqueIdent(), newInternalIdent() and newInternalResumableIndexBuildIdent(). StorageEngineImpl currently depends on the latter two, and to move DurableCatalog ownership to catalog, we should let storage own ident generation.

The StorageEngine public interface will have the following APIs:

std::string generateUniqueIdent(NamespaceString nss, const char* kind);
void sawIdent(const std::string& ident);

StorageEngineImpl will have the following private members:

mutable stdx::mutex _randLock;
uint64_t _rand;
unsigned long long _next;
stdx::unordered_set<uint64_t> _identSuffixesUsed;

At startup, StorageEngineImpl generates _rand. DurableCatalog::init() calls sawIdent() on every ident. DurableCatalog::importCollection() also calls sawIdent() on collectionIdent and indexIdents.

When sawIdent() is called, it uses rfind('-') to find the random part. If '-' is not found, or found at index 0, ignore this ident since new idents wouldn't conflict. Otherwise, peek at the character before the last '-', and if it's also '-', the random part is a negative number which can be ignored, since we now only generate unsigned numbers. Parse the random part as a number, add it to _identSuffixesUsed. If the random part is equal to _rand, regenerate _rand that's not in _identSuffixesUsed.

void _newRand(WithLock) {
    do {
        _rand = SecureRandom().nextUInt64();
    } while (_identSuffixesUsed.contains(_rand));
    _identSuffixesUsed.insert(_rand);
}

void sawIdent(const std::string& ident) {
    uint64_t suffix;
    auto suffixPos = ident.rfind('-');
    if (suffixPos == std::string::npos || suffixPos == 0 || ident[suffixPos - 1] == '-') {
        return;
    }
    if (NumberParser().base(10)(ident.substr(suffixPos + 1), &suffix).isOK()) {
        stdx::lock_guard<stdx::mutex> lk(_randLock);
        if (suffix == _rand) {
            _newRand(lk);
        } else {
            _identSuffixesUsed.insert(suffix);
        }
    }
}