SERVER-59148: Periodically refresh LDAP users in authorization user cache

2 files changed, 49 insertions, 0 deletions

diff --git a/src/mongo/util/invalidating_lru_cache.h b/src/mongo/util/invalidating_lru_cache.h
index f2307dc007f..d07eb12e0ec 100644
--- a/src/mongo/util/invalidating_lru_cache.h
+++ b/src/mongo/util/invalidating_lru_cache.h
@@ -535,6 +535,32 @@ public:
         }
     }
 
+    /**
+     * Returns a vector of ValueHandles for all of the entries that satisfy matchPredicate.
+     */
+    template <typename Pred>
+    std::vector<ValueHandle> getEntriesIf(Pred matchPredicate) {
+        std::vector<ValueHandle> entries;
+        entries.reserve(_cache.size() + _evictedCheckedOutValues.size());
+        {
+            stdx::lock_guard lg(_mutex);
+            for (const auto& entry : _cache) {
+                if (matchPredicate(entry.first, &entry.second->value)) {
+                    entries.push_back(ValueHandle(entry.second));
+                }
+            }
+
+            for (const auto& entry : _evictedCheckedOutValues) {
+                if (auto storedValue = entry.second.lock()) {
+                    if (matchPredicate(entry.first, &storedValue->value)) {
+                        entries.push_back(ValueHandle(std::move(storedValue)));
+                    }
+                }
+            }
+        }
+        return entries;
+    }
+
     struct CachedItemInfo {
         Key key;            // The key of the item in the cache
         long int useCount;  // The number of callers of 'get', which still have the item checked-out
diff --git a/src/mongo/util/read_through_cache.h b/src/mongo/util/read_through_cache.h
index 2fe230bdd41..65c5a39d96c 100644
--- a/src/mongo/util/read_through_cache.h
+++ b/src/mongo/util/read_through_cache.h
@@ -430,6 +430,29 @@ public:
     }
 
     /**
+     * Returns a vector of ValueHandles for all of the keys that satisfy matchPredicate.
+     */
+    template <typename Pred>
+    std::vector<ValueHandle> getValueHandlesIfKey(const Pred& matchPredicate) {
+        auto invalidatingCacheValues = [&]() {
+            stdx::lock_guard lg(_mutex);
+            return _cache.getEntriesIf(
+                [&](const Key& key, const StoredValue*) { return matchPredicate(key); });
+        }();
+
+        std::vector<ValueHandle> valueHandles;
+        valueHandles.reserve(invalidatingCacheValues.size());
+        std::transform(invalidatingCacheValues.begin(),
+                       invalidatingCacheValues.end(),
+                       std::back_inserter(valueHandles),
+                       [](auto& invalidatingCacheValue) {
+                           return ValueHandle(std::move(invalidatingCacheValue));
+                       });
+
+        return valueHandles;
+    }
+
+    /**
      * Returns statistics information about the cache for reporting purposes.
      */
     std::vector<typename Cache::CachedItemInfo> getCacheInfo() const {