Make earliest ledger sequence configurable

cfg/rippled-example.cfg

@@ -824,6 +824,10 @@
 #                           require administrative RPC call "can_delete"
 #                           to enable online deletion of ledger records.
 #
+#       earliest_seq        The default is 32570 to match the XRP ledger
+#                           network's earliest allowed sequence. Alternate
+#                           networks may set this value. Minimum value of 1. 
+#
 #   Notes:
 #       The 'node_db' entry configures the primary, persistent storage.
 #

src/ripple/app/ledger/impl/InboundLedger.cpp

@@ -111,7 +111,7 @@ InboundLedger::init(ScopedLockType& collectionLock)
             if (mFailed)
                 return;
         }
-        else if (shardStore && mSeq >= NodeStore::genesisSeq)
+        else if (shardStore && mSeq >= shardStore->earliestSeq())
         {
             if (auto l = shardStore->fetchLedger(mHash, mSeq))
             {

src/ripple/app/ledger/impl/LedgerMaster.cpp

@@ -1542,8 +1542,8 @@ LedgerMaster::fetchForHistory(
                 ledger = app_.getInboundLedgers().acquire(
                     *hash, missing, reason);
                 if (!ledger &&
-                    missing > NodeStore::genesisSeq &&
-                    missing != fetch_seq_)
+                    missing != fetch_seq_ &&
+                    missing > app_.getNodeStore().earliestSeq())
                 {
                     JLOG(m_journal.trace())
                         << "fetchForHistory want fetch pack " << missing;
@@ -1603,12 +1603,12 @@ LedgerMaster::fetchForHistory(
             if (reason == InboundLedger::Reason::SHARD)
                 // Do not fetch ledger sequences lower
                 // than the shard's first ledger sequence
-                fetchSz = NodeStore::DatabaseShard::firstSeq(
-                    NodeStore::DatabaseShard::seqToShardIndex(missing));
+                fetchSz = app_.getShardStore()->firstLedgerSeq(
+                    app_.getShardStore()->seqToShardIndex(missing));
             else
                 // Do not fetch ledger sequences lower
-                // than the genesis ledger sequence
-                fetchSz = NodeStore::genesisSeq;
+                // than the earliest ledger sequence
+                fetchSz = app_.getNodeStore().earliestSeq();
             fetchSz = missing >= fetchSz ?
                 std::min(ledger_fetch_size_, (missing - fetchSz) + 1) : 0;
             try
@@ -1666,7 +1666,8 @@ void LedgerMaster::doAdvance (ScopedLockType& sl)
                 {
                     ScopedLockType sl(mCompleteLock);
                     missing = prevMissing(mCompleteLedgers,
-                        mPubLedger->info().seq, NodeStore::genesisSeq);
+                        mPubLedger->info().seq,
+                        app_.getNodeStore().earliestSeq());
                 }
                 if (missing)
                 {

src/ripple/app/misc/SHAMapStoreImp.cpp

@@ -203,6 +203,20 @@ SHAMapStoreImp::SHAMapStoreImp (
     }
     if (! setup_.shardDatabase.empty())
     {
+        // The node and shard stores must use
+        // the same earliest ledger sequence
+        std::array<std::uint32_t, 2> seq;
+        if (get_if_exists<std::uint32_t>(
+            setup_.nodeDatabase, "earliest_seq", seq[0]))
+        {
+            if (get_if_exists<std::uint32_t>(
+                setup_.shardDatabase, "earliest_seq", seq[1]) &&
+                seq[0] != seq[1])
+            {
+                Throw<std::runtime_error>("earliest_seq set more than once");
+            }
+        }
+
         boost::filesystem::path dbPath =
             get<std::string>(setup_.shardDatabase, "path");
         if (dbPath.empty())
@@ -231,9 +245,6 @@ SHAMapStoreImp::SHAMapStoreImp (
             if (! setup_.standalone)
                 Throw<std::runtime_error>(
                     "ledgers_per_shard only honored in stand alone");
-            if (lps == 0 || lps % 256 != 0)
-                Throw<std::runtime_error>(
-                    "ledgers_per_shard must be a multiple of 256");
         }
     }
 }
@@ -259,7 +270,7 @@ SHAMapStoreImp::makeDatabase (std::string const& name,
         auto dbr = std::make_unique<NodeStore::DatabaseRotatingImp>(
             "NodeStore.main", scheduler_, readThreads, parent,
                 std::move(writableBackend), std::move(archiveBackend),
-                    nodeStoreJournal_);
+                    setup_.nodeDatabase, nodeStoreJournal_);
         fdlimit_ += dbr->fdlimit();
         dbRotating_ = dbr.get();
         db.reset(dynamic_cast<NodeStore::Database*>(dbr.release()));

src/ripple/nodestore/Database.h

@@ -27,6 +27,7 @@
 #include <ripple/nodestore/impl/Tuning.h>
 #include <ripple/nodestore/Scheduler.h>
 #include <ripple/nodestore/NodeObject.h>
+#include <ripple/protocol/SystemParameters.h>
 
 #include <thread>
 
@@ -63,7 +64,7 @@ class Database : public Stoppable
         @param journal Destination for logging output.
     */
     Database(std::string name, Stoppable& parent, Scheduler& scheduler,
-        int readThreads, beast::Journal j);
+        int readThreads, Section const& config, beast::Journal j);
 
     /** Destroy the node store.
         All pending operations are completed, pending writes flushed,
@@ -209,6 +210,14 @@ class Database : public Stoppable
     void
     onStop();
 
+    /** @return The earliest ledger sequence allowed
+    */
+    std::uint32_t
+    earliestSeq() const
+    {
+        return earliestSeq_;
+    }
+
 protected:
     beast::Journal j_;
     Scheduler& scheduler_;
@@ -265,6 +274,10 @@ class Database : public Stoppable
     // current read generation
     uint64_t readGen_ {0};
 
+    // The default is 32570 to match the XRP ledger network's earliest
+    // allowed sequence. Alternate networks may set this value.
+    std::uint32_t earliestSeq_ {XRP_LEDGER_EARLIEST_SEQ};
+
     virtual
     std::shared_ptr<NodeObject>
     fetchFrom(uint256 const& hash, std::uint32_t seq) = 0;

src/ripple/nodestore/DatabaseRotating.h

@@ -33,9 +33,14 @@ namespace NodeStore {
 class DatabaseRotating : public Database
 {
 public:
-    DatabaseRotating(std::string const& name, Stoppable& parent,
-        Scheduler& scheduler, int readThreads, beast::Journal journal)
-        : Database(name, parent, scheduler, readThreads, journal)
+    DatabaseRotating(
+        std::string const& name,
+        Stoppable& parent,
+        Scheduler& scheduler,
+        int readThreads,
+        Section const& config,
+        beast::Journal journal)
+        : Database(name, parent, scheduler, readThreads, config, journal)
     {}
 
     virtual

src/ripple/nodestore/DatabaseShard.h

@@ -45,12 +45,15 @@ class DatabaseShard : public Database
         @param config The configuration for the database
         @param journal Destination for logging output
     */
-    DatabaseShard(std::string const& name, Stoppable& parent,
-        Scheduler& scheduler, int readThreads,
-        Section const& config, beast::Journal journal)
-        : Database(name, parent, scheduler, readThreads, journal)
+    DatabaseShard(
+        std::string const& name,
+        Stoppable& parent,
+        Scheduler& scheduler,
+        int readThreads,
+        Section const& config,
+        beast::Journal journal)
+        : Database(name, parent, scheduler, readThreads, config, journal)
     {
-        get_if_exists<std::uint32_t>(config, "ledgers_per_shard", lps_);
     }
 
     /** Initialize the database
@@ -120,55 +123,47 @@ class DatabaseShard : public Database
     void
     validate() = 0;
 
-    /** @return The number of ledgers stored in a shard
+    /** @return The maximum number of ledgers stored in a shard
     */
-    static
+    virtual
     std::uint32_t
-    ledgersPerShard()
-    {
-        return lps_;
-    }
+    ledgersPerShard() const = 0;
+
+    /** @return The earliest shard index
+    */
+    virtual
+    std::uint32_t
+    earliestShardIndex() const = 0;
 
     /** Calculates the shard index for a given ledger sequence
 
         @param seq ledger sequence
         @return The shard index of the ledger sequence
     */
-    static
+    virtual
     std::uint32_t
-    seqToShardIndex(std::uint32_t seq)
-    {
-        assert(seq >= genesisSeq);
-        return (seq - 1) / lps_;
-    }
+    seqToShardIndex(std::uint32_t seq) const = 0;
 
     /** Calculates the first ledger sequence for a given shard index
 
         @param shardIndex The shard index considered
         @return The first ledger sequence pertaining to the shard index
     */
-    static
+    virtual
     std::uint32_t
-    firstSeq(std::uint32_t shardIndex)
-    {
-        return 1 + (shardIndex * lps_);
-    }
+    firstLedgerSeq(std::uint32_t shardIndex) const = 0;
 
     /** Calculates the last ledger sequence for a given shard index
 
         @param shardIndex The shard index considered
         @return The last ledger sequence pertaining to the shard index
     */
-    static
+    virtual
     std::uint32_t
-    lastSeq(std::uint32_t shardIndex)
-    {
-        return (shardIndex + 1) * lps_;
-    }
+    lastLedgerSeq(std::uint32_t shardIndex) const = 0;
 
-protected:
-    // The number of ledgers stored in a shard, default is 16384
-    static std::uint32_t lps_;
+    /** The number of ledgers in a shard */
+    static constexpr std::uint32_t ledgersPerShardDefault {16384u};
 };
 
 }

src/ripple/nodestore/Types.h

@@ -49,9 +49,6 @@ enum Status
 /** A batch of NodeObjects to write at once. */
 using Batch = std::vector <std::shared_ptr<NodeObject>>;
 
-// System constant/invariant
-static constexpr std::uint32_t genesisSeq {32570u};
-
 }
 }
 

src/ripple/nodestore/impl/Database.cpp

@@ -25,12 +25,25 @@
 namespace ripple {
 namespace NodeStore {
 
-Database::Database(std::string name, Stoppable& parent,
-    Scheduler& scheduler, int readThreads, beast::Journal journal)
+Database::Database(
+    std::string name,
+    Stoppable& parent,
+    Scheduler& scheduler,
+    int readThreads,
+    Section const& config,
+    beast::Journal journal)
     : Stoppable(name, parent)
     , j_(journal)
     , scheduler_(scheduler)
 {
+    std::uint32_t seq;
+    if (get_if_exists<std::uint32_t>(config, "earliest_seq", seq))
+    {
+        if (seq < 1)
+            Throw<std::runtime_error>("Invalid earliest_seq");
+        earliestSeq_ = seq;
+    }
+
     while (readThreads-- > 0)
         readThreads_.emplace_back(&Database::threadEntry, this);
 }

src/ripple/nodestore/impl/DatabaseNodeImp.h

@@ -33,10 +33,15 @@ class DatabaseNodeImp : public Database
     DatabaseNodeImp(DatabaseNodeImp const&) = delete;
     DatabaseNodeImp& operator=(DatabaseNodeImp const&) = delete;
 
-    DatabaseNodeImp(std::string const& name,
-        Scheduler& scheduler, int readThreads, Stoppable& parent,
-            std::unique_ptr<Backend> backend, beast::Journal j)
-        : Database(name, parent, scheduler, readThreads, j)
+    DatabaseNodeImp(
+        std::string const& name,
+        Scheduler& scheduler,
+        int readThreads,
+        Stoppable& parent,
+        std::unique_ptr<Backend> backend,
+        Section const& config,
+        beast::Journal j)
+        : Database(name, parent, scheduler, readThreads, config, j)
         , pCache_(std::make_shared<TaggedCache<uint256, NodeObject>>(
             name, cacheTargetSize, cacheTargetSeconds, stopwatch(), j))
         , nCache_(std::make_shared<KeyCache<uint256>>(

src/ripple/nodestore/impl/DatabaseRotatingImp.cpp

@@ -26,10 +26,15 @@ namespace ripple {
 namespace NodeStore {
 
 DatabaseRotatingImp::DatabaseRotatingImp(
-    std::string const& name, Scheduler& scheduler, int readThreads,
-        Stoppable& parent, std::unique_ptr<Backend> writableBackend,
-            std::unique_ptr<Backend> archiveBackend, beast::Journal j)
-    : DatabaseRotating(name, parent, scheduler, readThreads, j)
+    std::string const& name,
+    Scheduler& scheduler,
+    int readThreads,
+    Stoppable& parent,
+    std::unique_ptr<Backend> writableBackend,
+    std::unique_ptr<Backend> archiveBackend,
+    Section const& config,
+    beast::Journal j)
+    : DatabaseRotating(name, parent, scheduler, readThreads, config, j)
     , pCache_(std::make_shared<TaggedCache<uint256, NodeObject>>(
         name, cacheTargetSize, cacheTargetSeconds, stopwatch(), j))
     , nCache_(std::make_shared<KeyCache<uint256>>(

src/ripple/nodestore/impl/DatabaseRotatingImp.h

@@ -32,11 +32,15 @@ class DatabaseRotatingImp : public DatabaseRotating
     DatabaseRotatingImp(DatabaseRotatingImp const&) = delete;
     DatabaseRotatingImp& operator=(DatabaseRotatingImp const&) = delete;
 
-    DatabaseRotatingImp(std::string const& name,
-        Scheduler& scheduler, int readThreads, Stoppable& parent,
-            std::unique_ptr<Backend> writableBackend,
-                 std::unique_ptr<Backend> archiveBackend,
-                    beast::Journal j);
+    DatabaseRotatingImp(
+        std::string const& name,
+        Scheduler& scheduler,
+        int readThreads,
+        Stoppable& parent,
+        std::unique_ptr<Backend> writableBackend,
+        std::unique_ptr<Backend> archiveBackend,
+        Section const& config,
+        beast::Journal j);
 
     ~DatabaseRotatingImp() override
     {