Add Shard pool management

src/ripple/nodestore/impl/DatabaseNodeImp.cpp

@@ -29,27 +29,28 @@ DatabaseNodeImp::store(
     NodeObjectType type,
     Blob&& data,
     uint256 const& hash,
-    std::uint32_t seq)
+    std::uint32_t)
 {
     auto nObj = NodeObject::createObject(type, std::move(data), hash);
     pCache_->canonicalize_replace_cache(hash, nObj);
     backend_->store(nObj);
     nCache_->erase(hash);
-    storeStats(nObj->getData().size());
+    storeStats(1, nObj->getData().size());
 }
 
 bool
 DatabaseNodeImp::asyncFetch(
     uint256 const& hash,
-    std::uint32_t seq,
-    std::shared_ptr<NodeObject>& object)
+    std::uint32_t ledgerSeq,
+    std::shared_ptr<NodeObject>& nodeObject)
 {
     // See if the object is in cache
-    object = pCache_->fetch(hash);
-    if (object || nCache_->touch_if_exists(hash))
+    nodeObject = pCache_->fetch(hash);
+    if (nodeObject || nCache_->touch_if_exists(hash))
         return true;
+
     // Otherwise post a read
-    Database::asyncFetch(hash, seq, pCache_, nCache_);
+    Database::asyncFetch(hash, ledgerSeq);
     return false;
 }
 
@@ -69,5 +70,69 @@ DatabaseNodeImp::sweep()
     nCache_->sweep();
 }
 
+std::shared_ptr<NodeObject>
+DatabaseNodeImp::fetchNodeObject(
+    uint256 const& hash,
+    std::uint32_t,
+    FetchReport& fetchReport)
+{
+    // See if the node object exists in the cache
+    auto nodeObject{pCache_->fetch(hash)};
+    if (!nodeObject && !nCache_->touch_if_exists(hash))
+    {
+        // Try the backend
+        fetchReport.wentToDisk = true;
+
+        Status status;
+        try
+        {
+            status = backend_->fetch(hash.data(), &nodeObject);
+        }
+        catch (std::exception const& e)
+        {
+            JLOG(j_.fatal()) << "Exception, " << e.what();
+            Rethrow();
+        }
+
+        switch (status)
+        {
+            case ok:
+                ++fetchHitCount_;
+                if (nodeObject)
+                    fetchSz_ += nodeObject->getData().size();
+                break;
+            case notFound:
+                break;
+            case dataCorrupt:
+                JLOG(j_.fatal()) << "Corrupt NodeObject #" << hash;
+                break;
+            default:
+                JLOG(j_.warn()) << "Unknown status=" << status;
+                break;
+        }
+
+        if (!nodeObject)
+        {
+            // Just in case a write occurred
+            nodeObject = pCache_->fetch(hash);
+            if (!nodeObject)
+                // We give up
+                nCache_->insert(hash);
+        }
+        else
+        {
+            fetchReport.wasFound = true;
+
+            // Ensure all threads get the same object
+            pCache_->canonicalize_replace_client(hash, nodeObject);
+
+            // Since this was a 'hard' fetch, we will log it
+            JLOG(j_.trace()) << "HOS: " << hash << " fetch: in shard db";
+        }
+    }
+
+    return nodeObject;
+}
+
 }  // namespace NodeStore
 }  // namespace ripple