Peer reservations

CMakeLists.txt

@@ -2176,6 +2176,7 @@ else ()
     src/ripple/overlay/impl/Message.cpp
     src/ripple/overlay/impl/OverlayImpl.cpp
     src/ripple/overlay/impl/PeerImp.cpp
+    src/ripple/overlay/impl/PeerReservationTable.cpp
     src/ripple/overlay/impl/PeerSet.cpp
     src/ripple/overlay/impl/TMHello.cpp
     src/ripple/overlay/impl/TrafficCount.cpp
@@ -2242,6 +2243,7 @@ else ()
     src/ripple/rpc/handlers/Ping.cpp
     src/ripple/rpc/handlers/Print.cpp
     src/ripple/rpc/handlers/Random.cpp
+    src/ripple/rpc/handlers/Reservations.cpp
     src/ripple/rpc/handlers/RipplePathFind.cpp
     src/ripple/rpc/handlers/ServerInfo.cpp
     src/ripple/rpc/handlers/ServerState.cpp

src/ripple/app/main/Application.cpp

@@ -52,6 +52,7 @@
 #include <ripple/json/json_reader.h>
 #include <ripple/nodestore/DummyScheduler.h>
 #include <ripple/overlay/Cluster.h>
+#include <ripple/overlay/PeerReservationTable.h>
 #include <ripple/overlay/make_Overlay.h>
 #include <ripple/protocol/BuildInfo.h>
 #include <ripple/protocol/Feature.h>
@@ -349,6 +350,7 @@ class ApplicationImp
     TaggedCache <uint256, AcceptedLedger> m_acceptedLedgerCache;
     std::unique_ptr <NetworkOPs> m_networkOPs;
     std::unique_ptr <Cluster> cluster_;
+    std::unique_ptr <PeerReservationTable> peerReservations_;
     std::unique_ptr <ManifestCache> validatorManifests_;
     std::unique_ptr <ManifestCache> publisherManifests_;
     std::unique_ptr <ValidatorList> validators_;
@@ -490,6 +492,8 @@ class ApplicationImp
         , cluster_ (std::make_unique<Cluster> (
             logs_->journal("Overlay")))
 
+        , peerReservations_(std::make_unique<PeerReservationTable>(logs_->journal("PeerReservationTable")))
+
         , validatorManifests_ (std::make_unique<ManifestCache> (
             logs_->journal("ManifestCache")))
 
@@ -765,6 +769,11 @@ class ApplicationImp
         return *cluster_;
     }
 
+    PeerReservationTable& peerReservations () override
+    {
+        return *peerReservations_;
+    }
+
     SHAMapStore& getSHAMapStore () override
     {
         return *m_shaMapStore;
@@ -1197,6 +1206,12 @@ bool ApplicationImp::setup()
         return false;
     }
 
+    if (!peerReservations_->load(getWalletDB()))
+    {
+        JLOG(m_journal.fatal()) << "Cannot find peer reservations!";
+        return false;
+    }
+
     if (validatorKeys_.publicKey.size())
         setMaxDisallowedLedger();
 

src/ripple/app/main/Application.h

@@ -26,6 +26,7 @@
 #include <ripple/core/Config.h>
 #include <ripple/protocol/Protocol.h>
 #include <ripple/beast/utility/PropertyStream.h>
+#include <ripple/overlay/PeerReservationTable.h>
 #include <boost/asio.hpp>
 #include <memory>
 #include <mutex>
@@ -139,6 +140,7 @@ class Application : public beast::PropertyStream::Source
     virtual ManifestCache&              validatorManifests () = 0;
     virtual ManifestCache&              publisherManifests () = 0;
     virtual Cluster&                    cluster () = 0;
+    virtual PeerReservationTable&       peerReservations () = 0;
     virtual RCLValidations&             getValidations () = 0;
     virtual NodeStore::Database&        getNodeStore () = 0;
     virtual NodeStore::DatabaseShard*   getShardStore() = 0;

src/ripple/app/main/DBInit.cpp

@@ -131,6 +131,12 @@ const char* WalletDBInit[] =
         PrivateKey      CHARACTER(52)               \
     );",
 
+    // Peer reservations.
+    "CREATE TABLE IF NOT EXISTS PeerReservations (     \
+        PublicKey       CHARACTER(53) UNIQUE NOT NULL, \
+        Description     CHARACTER(64) NOT NULL         \
+    );",
+
     // Validator Manifests
     "CREATE TABLE IF NOT EXISTS ValidatorManifests ( \
         RawData          BLOB NOT NULL               \

src/ripple/app/main/Main.cpp

@@ -149,6 +149,9 @@ void printHelp (const po::options_description& desc)
            "     peers\n"
            "     ping\n"
            "     random\n"
+           "     peer_reservations_add <public_key> [<description>]\n"
+           "     peer_reservations_del <public_key>\n"
+           "     peer_reservations_list\n"
            "     ripple ...\n"
            "     ripple_path_find <json> [<ledger>]\n"
            "     server_info [counters]\n"

src/ripple/core/impl/DatabaseCon.cpp

@@ -51,7 +51,8 @@ DatabaseCon::DatabaseCon (
         }
         catch (soci::soci_error&)
         {
-            // ignore errors
+            // TODO: We should at least log this error. It is annoying to wire
+            // a logger into every context, but there are other solutions.
         }
     }
 }

src/ripple/net/impl/RPCCall.cpp

@@ -849,6 +849,26 @@ class RPCParser
         return jvRequest;
     }
 
+    // peer_reservations_add <public_key> [<name>]
+    Json::Value parsePeerReservationsAdd (Json::Value const& jvParams)
+    {
+        Json::Value jvRequest;
+        jvRequest[jss::public_key] = jvParams[0u].asString();
+        if (jvParams.size() > 1)
+        {
+            jvRequest[jss::description] = jvParams[1u].asString();
+        }
+        return jvRequest;
+    }
+
+    // peer_reservations_del <public_key>
+    Json::Value parsePeerReservationsDel (Json::Value const& jvParams)
+    {
+        Json::Value jvRequest;
+        jvRequest[jss::public_key] = jvParams[0u].asString();
+        return jvRequest;
+    }
+
     // ripple_path_find <json> [<ledger>]
     Json::Value parseRipplePathFind (Json::Value const& jvParams)
     {
@@ -1127,6 +1147,9 @@ class RPCParser
             {   "print",                &RPCParser::parseAsIs,                  0,  1   },
     //      {   "profile",              &RPCParser::parseProfile,               1,  9   },
             {   "random",               &RPCParser::parseAsIs,                  0,  0   },
+            {   "peer_reservations_add",  &RPCParser::parsePeerReservationsAdd, 1,  2   },
+            {   "peer_reservations_del",  &RPCParser::parsePeerReservationsDel, 1,  1   },
+            {   "peer_reservations_list", &RPCParser::parseAsIs,                0,  0   },
             {   "ripple_path_find",     &RPCParser::parseRipplePathFind,        1,  2   },
             {   "sign",                 &RPCParser::parseSignSubmit,            2,  3   },
             {   "sign_for",             &RPCParser::parseSignFor,               3,  4   },

src/ripple/overlay/PeerReservationTable.h

@@ -0,0 +1,123 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2019 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_OVERLAY_PEER_RESERVATION_TABLE_H_INCLUDED
+#define RIPPLE_OVERLAY_PEER_RESERVATION_TABLE_H_INCLUDED
+
+#include <ripple/beast/hash/uhash.h>
+#include <ripple/beast/hash/hash_append.h>
+#include <ripple/beast/utility/Journal.h>
+#include <ripple/json/json_forwards.h>
+#include <ripple/protocol/PublicKey.h>
+
+#define SOCI_USE_BOOST
+#include <boost/optional.hpp>
+#include <soci/soci.h>
+
+#include <mutex>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+namespace ripple {
+
+class DatabaseCon;
+
+// Value type for reservations.
+struct PeerReservation final
+{
+public:
+    PublicKey nodeId;
+    std::string description;
+
+    auto
+    toJson() const -> Json::Value;
+
+    template <typename Hasher>
+    friend void hash_append(Hasher& h, PeerReservation const& x) noexcept
+    {
+        using beast::hash_append;
+        hash_append(h, x.nodeId);
+    }
+
+    friend bool operator<(PeerReservation const& a, PeerReservation const& b)
+    {
+        return a.nodeId < b.nodeId;
+    }
+};
+
+// TODO: When C++20 arrives, take advantage of "equivalence" instead of
+// "equality". Add an overload for `(PublicKey, PeerReservation)`, and just
+// pass a `PublicKey` directly to `unordered_set.find`.
+struct KeyEqual final
+{
+    bool operator() (
+            PeerReservation const& lhs, PeerReservation const& rhs) const
+    {
+        return lhs.nodeId == rhs.nodeId;
+    }
+};
+
+class PeerReservationTable final
+{
+public:
+    explicit PeerReservationTable(
+        beast::Journal journal = beast::Journal(beast::Journal::getNullSink()))
+        : journal_(journal)
+    {
+    }
+
+    std::vector<PeerReservation> list() const;
+
+    bool
+    contains(PublicKey const& nodeId)
+    {
+        std::lock_guard<std::mutex> lock(this->mutex_);
+        return table_.find({nodeId}) != table_.end();
+    }
+
+    // Because `ApplicationImp` has two-phase initialization, so must we.
+    // Our dependencies are not prepared until the second phase.
+    bool
+    load(DatabaseCon& connection);
+
+    /**
+     * @return the replaced reservation if it existed
+     * @throw soci::soci_error
+     */
+    auto
+    insert_or_assign(PeerReservation const& reservation)
+        -> boost::optional<PeerReservation>;
+
+    /**
+     * @return the erased reservation if it existed
+     */
+    auto
+    erase(PublicKey const& nodeId) -> boost::optional<PeerReservation>;
+
+private:
+    beast::Journal mutable journal_;
+    std::mutex mutable mutex_;
+    DatabaseCon* connection_;
+    std::unordered_set<PeerReservation, beast::uhash<>, KeyEqual> table_;
+};
+
+}  // namespace ripple
+
+#endif

src/ripple/overlay/impl/OverlayImpl.cpp

@@ -278,18 +278,25 @@ OverlayImpl::onHandoff (std::unique_ptr <beast::asio::ssl_bundle>&& ssl_bundle,
         return handoff;
     }
 
-    auto const result = m_peerFinder->activate (slot, *publicKey,
-        static_cast<bool>(app_.cluster().member(*publicKey)));
-    if (result != PeerFinder::Result::success)
     {
-        m_peerFinder->on_closed(slot);
-        JLOG(journal.debug()) <<
-            "Peer " << remote_endpoint << " redirected, slots full";
-        handoff.moved = false;
-        handoff.response = makeRedirectResponse(slot, request,
-            remote_endpoint.address());
-        handoff.keep_alive = beast::rfc2616::is_keep_alive(request);
-        return handoff;
+        // The node gets a reserved slot if it is in our cluster
+        // or if it has a reservation.
+        bool const reserved {
+            static_cast<bool>(app_.cluster().member(*publicKey))
+            || app_.peerReservations().contains(*publicKey)
+        };
+        auto const result = m_peerFinder->activate(slot, *publicKey, reserved);
+        if (result != PeerFinder::Result::success)
+        {
+            m_peerFinder->on_closed(slot);
+            JLOG(journal.debug())
+                << "Peer " << remote_endpoint << " redirected, slots full";
+            handoff.moved = false;
+            handoff.response = makeRedirectResponse(
+                    slot, request, remote_endpoint.address());
+            handoff.keep_alive = beast::rfc2616::is_keep_alive(request);
+            return handoff;
+        }
     }
 
     auto const peer = std::make_shared<PeerImp>(app_, id,

src/ripple/overlay/impl/PeerImp.cpp

@@ -254,6 +254,12 @@ PeerImp::crawl() const
     return boost::beast::detail::iequals(iter->value(), "public");
 }
 
+bool
+PeerImp::cluster() const
+{
+    return static_cast<bool>(app_.cluster().member(publicKey_));
+}
+
 std::string
 PeerImp::getVersion() const
 {
@@ -1614,7 +1620,7 @@ PeerImp::onMessage (std::shared_ptr <protocol::TMProposeSet> const& m)
 {
     protocol::TMProposeSet& set = *m;
 
-    if (set.has_hops() && ! slot_->cluster())
+    if (set.has_hops() && ! cluster())
         set.set_hops(set.hops() + 1);
 
     auto const sig = makeSlice(set.signature());
@@ -1983,7 +1989,7 @@ PeerImp::onMessage (std::shared_ptr <protocol::TMValidation> const& m)
 {
     auto const closeTime = app_.timeKeeper().closeTime();
 
-    if (m->has_hops() && ! slot_->cluster())
+    if (m->has_hops() && ! cluster())
         m->set_hops(m->hops() + 1);
 
     if (m->validation ().size () < 50)

src/ripple/overlay/impl/PeerImp.h

@@ -281,10 +281,7 @@ class PeerImp
     crawl() const;
 
     bool
-    cluster() const override
-    {
-        return slot_->cluster();
-    }
+    cluster() const override;
 
     void
     check();