Remove maintenance

Author: drebelsky

docs/quick-reference.md

@@ -59,18 +59,6 @@ You have some control over which peers you're connected to:
  * the `connect` command asks the instance to connect to a specific peer.
  * the `droppeer` command asks the instance to drop the connection with a specific peer.
 
-### Maintenance
-
-Core keeps historical data needed for publish (such as SCP history)
-
-Sometimes you need to clean up more than this (for example, if you have a large maintenance debt).
-In this case running the command `maintenance?count=100000000` (integer is a large number, bigger than your max backlog) will perform the full maintenance.
-
-Note that this may hang the instance for minutes (hours even).
-
-After performing such maintenance, you may issue a postgres `VACUUM FULL;` that will reclaim all
-disk space (note that this requires a lot of free disk space).
-
 ### Testing
 
 The `manualclose` command allows to close a ledger, this is used when the instance is

docs/software/commands.md

@@ -279,11 +279,6 @@ Most commands return their results in JSON format.
 * **logrotate**
   Rotate log files.
 
-* **maintenance**
-  `maintenance?[queue=true]`<br>
-  Performs maintenance tasks on the instance.
-   * `queue` performs deletion of queue data. See `setcursor` for more information.
-
 * **metrics**
   `metrics?[enable=PARTITION_1,PARTITION_2,...,PARTITION_N]`<br>
   Returns a snapshot of the metrics registry (for monitoring and debugging

docs/stellar-core_example.cfg

@@ -417,19 +417,6 @@ QUORUM_INTERSECTION_CHECKER=true
 # This limits the number that will be active at a time.
 MAX_CONCURRENT_SUBPROCESSES=16
 
-# AUTOMATIC_MAINTENANCE_PERIOD (integer, seconds) default 359
-# Interval between automatic maintenance executions
-# Set to 0 to disable automatic maintenance
-AUTOMATIC_MAINTENANCE_PERIOD=359
-
-# AUTOMATIC_MAINTENANCE_COUNT (integer) default 400
-# Number of unneeded ledgers in each table that will be removed during one
-# maintenance run.
-# NB: make sure that enough ledgers are deleted as to offset the growth of
-# data accumulated by closing ledgers (catchup and normal operation)
-# Set to 0 to disable automatic maintenance
-AUTOMATIC_MAINTENANCE_COUNT=400
-
 # AUTOMATIC_SELF_CHECK_PERIOD (integer, seconds) default 10800
 # Interval between automatic self-checks, including connectivity
 # and consistency checking against configured history archives.

src/bucket/test/BucketManagerTests.cpp

@@ -22,7 +22,6 @@
 #include "ledger/test/LedgerTestUtils.h"
 #include "main/Application.h"
 #include "main/Config.h"
-#include "main/Maintainer.h"
 #include "test/Catch2.h"
 #include "test/TestUtils.h"
 #include "test/test.h"
@@ -807,9 +806,6 @@ TEST_CASE_VERSIONS(
         while (hm.getPublishSuccessCount() < 5)
         {
             clock.crank(false);
-
-            // Trim history after publishing whenever possible.
-            app->getMaintainer().performMaintenance(50000);
         }
     });
 }

src/database/Database.cpp

@@ -323,6 +323,40 @@ dropMiscTablesFromMain(Application& app)
     }
 }
 
+void
+migrateLedgerHeadersToStoreState(Database& db)
+{
+    // Migrate LCL header from ledgerheaders table to storestate
+    std::string lclHash;
+
+    db.getRawSession() << "SELECT state FROM storestate WHERE statename = "
+                          "'lastclosedledger'",
+        soci::into(lclHash);
+    // When we're doing this migration for a new db, storestate will be empty.
+    // So, only try to set lastclosedledgerheader when the data is found
+    if (db.getRawSession().got_data())
+    {
+
+        if (lclHash.empty())
+        {
+            throw std::runtime_error(
+                "No reference in DB to any last closed ledger");
+        }
+
+        std::string headerData =
+            LedgerHeaderUtils::getHeaderDataForHash(db, hexToBin256(lclHash));
+
+        db.getRawSession() << "INSERT INTO storestate (statename, state) "
+                              "VALUES ('lastclosedledgerheader', :v)",
+            soci::use(headerData);
+
+        db.getRawSession()
+            << "DELETE FROM storestate WHERE statename = 'lastclosedledger'";
+    }
+
+    db.getRawSession() << "DROP TABLE ledgerheaders";
+}
+
 void
 Database::applySchemaUpgrade(unsigned long vers)
 {
@@ -343,6 +377,9 @@ Database::applySchemaUpgrade(unsigned long vers)
             dropMiscTablesFromMain(mApp);
         }
         break;
+    case 27:
+        migrateLedgerHeadersToStoreState(*this);
+        break;
     default:
         throw std::runtime_error("Unknown DB schema version");
     }

src/database/Database.h

@@ -29,7 +29,7 @@ class Application;
 
 // smallest schema version supported
 static constexpr unsigned long MIN_SCHEMA_VERSION = 25;
-static constexpr unsigned long SCHEMA_VERSION = 26;
+static constexpr unsigned long SCHEMA_VERSION = 27;
 static constexpr unsigned long FIRST_MAIN_VERSION_WITH_MISC = 26;
 // Misc schema version 0 means no misc table exists yet
 static constexpr unsigned long MIN_MISC_SCHEMA_VERSION = 0;

src/database/test/DatabaseTests.cpp

@@ -6,6 +6,7 @@
 #include "crypto/Hex.h"
 #include "crypto/KeyUtils.h"
 #include "database/Database.h"
+#include "ledger/LedgerHeaderUtils.h"
 #include "ledger/LedgerTxn.h"
 #include "ledger/test/LedgerTestUtils.h"
 #include "lib/util/stdrandom.h"
@@ -494,9 +495,18 @@ TEST_CASE("Database splitting migration works correctly", "[db]")
                 "('ledgerupgrades', 'testvalue')",
                 db.getSession());
 
+        LedgerHeader header = LedgerManager::genesisLedger();
+        // Change one value from the genesis ledger to ensure that we did
+        // actually migrate correctly
+        header.ledgerSeq = 12345;
+        LedgerHeaderUtils::storeInDatabase(db, header, db.getSession());
+        std::string hash;
+        std::string headerEncoded =
+            LedgerHeaderUtils::encodeHeader(header, hash);
+
         // Insert test data that should stay in main DB
-        execSQL("INSERT INTO storestate (statename, state) VALUES "
-                "('lastclosedledger', 'maintestvalue')",
+        execSQL("INSERT INTO storestate (statename, state) VALUES " +
+                    fmt::format("('lastclosedledger', '{}')", hash),
                 db.getSession());
 
         // Verify data exists in main before migration
@@ -515,13 +525,13 @@ TEST_CASE("Database splitting migration works correctly", "[db]")
             std::string result;
             auto prep = db.getPreparedStatement(
                 "SELECT state FROM storestate WHERE statename = "
-                "'lastclosedledger'",
+                "'lastclosedledgerheader'",
                 db.getSession());
             auto& st = prep.statement();
             st.exchange(soci::into(result));
             st.define_and_bind();
             st.execute(true);
-            REQUIRE(result == "maintestvalue");
+            REQUIRE(result == headerEncoded);
         }
 
         // Verify storestate table still exists in main DB
@@ -576,3 +586,85 @@ TEST_CASE("Database splitting migration works correctly", "[db]")
         }
     }
 }
+
+TEST_CASE("ledgerheaders migration works correctly", "[db]")
+{
+    Config::TestDbMode mode = GENERATE(Config::TESTDB_BUCKET_DB_PERSISTENT
+#ifdef USE_POSTGRES
+                                       ,
+                                       Config::TESTDB_POSTGRESQL
+#endif
+    );
+    Config cfg = getTestConfig(0, mode);
+    INFO("Testing mode: " << (mode == Config::TESTDB_POSTGRESQL
+                                  ? "PostgreSQL"
+                                  : "Persistent"));
+
+    VirtualClock clock;
+    // Set startApp to false to trigger migration manually
+    Application::pointer app = createTestApplication(
+        clock, cfg, /* newDB */ true, /* startApp */ false);
+
+    std::optional<std::string> expectedLCLHeader;
+    auto checkMigration = [&app](std::optional<std::string> expectedLCL) {
+        REQUIRE(app->getDatabase().getMainDBSchemaVersion() == SCHEMA_VERSION);
+        REQUIRE_THROWS(app->getDatabase().getRawSession()
+                       << "SELECT COUNT(1) FROM ledgerheaders");
+
+        {
+            // Check that lastclosedledger has been removed
+            auto& sess = app->getDatabase().getRawSession();
+            int i;
+            sess << "SELECT COUNT(1) FROM storestate WHERE statename = "
+                    "'lastclosedledger'",
+                soci::into(i);
+            REQUIRE(sess.got_data());
+            REQUIRE(i == 0);
+        }
+
+        std::string lclHeader = app->getPersistentState().getState(
+            PersistentState::kLastClosedLedgerHeader,
+            app->getDatabase().getSession());
+
+        if (expectedLCL)
+        {
+            REQUIRE(lclHeader == expectedLCL);
+        }
+        else
+        {
+            LedgerHeader lh = LedgerHeaderUtils::decodeFromData(lclHeader);
+            REQUIRE(
+                app->getLedgerManager().getLastClosedLedgerHeader().header ==
+                lh);
+        }
+    };
+
+    SECTION("Just running newdb")
+    {
+        checkMigration(std::nullopt);
+    }
+
+    SECTION("Migrate from old schema with LCL header")
+    {
+        auto& db = app->getDatabase();
+        db.initialize();
+
+        auto& lcl = app->getLedgerManager().getLastClosedLedgerHeader();
+        LedgerHeader header = lcl.header;
+        header.ledgerSeq++;
+        header.previousLedgerHash = lcl.hash;
+        LedgerHeaderUtils::storeInDatabase(db, header, db.getSession());
+
+        std::string hash;
+        std::string headerEncoded =
+            LedgerHeaderUtils::encodeHeader(header, hash);
+        db.getRawSession()
+            << "INSERT INTO storestate (statename, state) VALUES "
+               "('lastclosedledger', :h)",
+            soci::use(hash);
+
+        db.upgradeToCurrentSchema();
+
+        checkMigration(headerEncoded);
+    }
+}

src/herder/HerderImpl.cpp

@@ -1288,6 +1288,23 @@ HerderImpl::setupTriggerNextLedger()
 #endif
 }
 
+// Returns the ledger index of the oldest ledger that it is safe to delete while
+// still keeping all the information needed to publish checkpoints
+uint32_t
+getSafeLedgerToDelete(uint32_t ledger, Config const& cfg)
+{
+    // Calculate the minimum of *minSlot and/or any queued checkpoint.
+    uint32_t ql = HistoryManager::getMinLedgerQueuedToPublish(cfg);
+    uint32_t qmin = ql == 0 ? ledger : std::min(ql, ledger);
+
+    // Next calculate, given qmin, the first ledger it'd be _safe to delete_
+    // while still keeping everything required to publish. So if qmin is
+    // (for example) 0x7f = 127, then we want to keep 64 ledgers before
+    // that, and therefore can erase 0x3f = 63 and less.
+    uint32_t freq = HistoryManager::getCheckpointFrequency(cfg);
+    return qmin >= freq ? qmin - freq : 0;
+}
+
 void
 HerderImpl::eraseBelow(uint32 ledgerSeq)
 {
@@ -1296,6 +1313,14 @@ HerderImpl::eraseBelow(uint32 ledgerSeq)
     mPendingEnvelopes.eraseBelow(ledgerSeq, lastCheckpointSeq);
     auto lastIndex = trackingConsensusLedgerIndex();
     mApp.getOverlayManager().clearLedgersBelow(ledgerSeq, lastIndex);
+
+    uint32_t lmin = getSafeLedgerToDelete(ledgerSeq, mApp.getConfig());
+    // To avoid blocking too long, don't delete more than one checkpoint of
+    // history
+    uint32_t const ledgersToDelete =
+        HistoryManager::getCheckpointFrequency(mApp.getConfig());
+    HerderPersistence::deleteOldEntries(mApp.getDatabase().getRawMiscSession(),
+                                        lmin, ledgersToDelete);
 }
 
 bool

src/herder/test/HerderTests.cpp

@@ -24,7 +24,6 @@
 #include "crypto/SHA.h"
 #include "database/Database.h"
 #include "herder/HerderUtils.h"
-#include "ledger/LedgerHeaderUtils.h"
 #include "ledger/LedgerManager.h"
 #include "ledger/LedgerTxn.h"
 #include "ledger/LedgerTxnHeader.h"

src/history/HistoryManagerImpl.cpp

@@ -24,7 +24,6 @@
 #include "historywork/PutSnapshotFilesWork.h"
 #include "historywork/ResolveSnapshotWork.h"
 #include "historywork/WriteSnapshotWork.h"
-#include "ledger/LedgerHeaderUtils.h"
 #include "ledger/LedgerManager.h"
 #include "main/Application.h"
 #include "main/Config.h"