proper lokimq -> oxenmq refactor

llarp/config/config.cpp

@@ -21,8 +21,6 @@
 #include <iostream>
 #include "constants/version.hpp"
 
-namespace lokimq = oxenmq;
-
 namespace llarp
 {
   // constants for config file default values
@@ -883,7 +881,7 @@ namespace llarp
             "but can use (non-default) TCP if lokid is configured that way:",
             "    rpc=tcp://127.0.0.1:5678",
         },
-        [this](std::string arg) { lokidRPCAddr = lokimq::address(arg); });
+        [this](std::string arg) { lokidRPCAddr = oxenmq::address(arg); });
 
     // Deprecated options:
     conf.defineOption<std::string>("lokid", "username", Deprecated);

llarp/crypto/types.cpp

@@ -9,8 +9,6 @@
 
 #include <oxenmq/hex.h>
 
-namespace lokimq = oxenmq;
-
 #include <sodium/crypto_sign.h>
 #include <sodium/crypto_sign_ed25519.h>
 #include <sodium/crypto_scalarmult_ed25519.h>
@@ -22,14 +20,14 @@ namespace llarp
   {
     if (str.size() != 2 * size())
       return false;
-    lokimq::from_hex(str.begin(), str.end(), begin());
+    oxenmq::from_hex(str.begin(), str.end(), begin());
     return true;
   }
 
   std::string
   PubKey::ToString() const
   {
-    return lokimq::to_hex(begin(), end());
+    return oxenmq::to_hex(begin(), end());
   }
 
   bool

llarp/dht/messages/findname.cpp

@@ -7,8 +7,6 @@
 #include <path/path_context.hpp>
 #include <routing/dht_message.hpp>
 
-namespace lokimq = oxenmq;
-
 namespace llarp::dht
 {
   FindNameMessage::FindNameMessage(const Key_t& from, Key_t namehash, uint64_t txid)
@@ -18,8 +16,8 @@ namespace llarp::dht
   bool
   FindNameMessage::BEncode(llarp_buffer_t* buf) const
   {
-    const auto data = lokimq::bt_serialize(
-        lokimq::bt_dict{{"A", "N"sv},
+    const auto data = oxenmq::bt_serialize(
+        oxenmq::bt_dict{{"A", "N"sv},
                         {"H", std::string_view{(char*)NameHash.data(), NameHash.size()}},
                         {"T", TxID}});
     return buf->write(data.begin(), data.end());

llarp/dht/messages/gotname.cpp

@@ -4,8 +4,6 @@
 #include <router/abstractrouter.hpp>
 #include <path/path_context.hpp>
 
-namespace lokimq = oxenmq;
-
 namespace llarp::dht
 {
   constexpr size_t NameSizeLimit = 128;
@@ -21,8 +19,8 @@ namespace llarp::dht
   GotNameMessage::BEncode(llarp_buffer_t* buf) const
   {
     const std::string nonce((const char*)result.nonce.data(), result.nonce.size());
-    const auto data = lokimq::bt_serialize(
-        lokimq::bt_dict{{"A", "M"sv}, {"D", result.ciphertext}, {"N", nonce}, {"T", TxID}});
+    const auto data = oxenmq::bt_serialize(
+        oxenmq::bt_dict{{"A", "M"sv}, {"D", result.ciphertext}, {"N", nonce}, {"T", TxID}});
     return buf->write(data.begin(), data.end());
   }
 

llarp/peerstats/types.cpp

@@ -4,8 +4,6 @@
 #include <oxenmq/bt_serialize.h>
 #include <stdexcept>
 
-namespace lokimq = oxenmq;
-
 namespace llarp
 {
   constexpr auto RouterIdKey = "routerId";
@@ -105,7 +103,7 @@ namespace llarp
   {
     if (not buf)
       throw std::runtime_error("PeerStats: Can't use null buf");
-    const lokimq::bt_dict data = {
+    const oxenmq::bt_dict data = {
         {NumConnectionAttemptsKey, numConnectionAttempts},
         {NumConnectionSuccessesKey, numConnectionSuccesses},
         {NumConnectionRejectionsKey, numConnectionRejections},
@@ -122,7 +120,7 @@ namespace llarp
         {LeastRCRemainingLifetimeKey, leastRCRemainingLifetime.count()},
         {LastRCUpdatedKey, lastRCUpdated.count()},
     };
-    const auto serialized = lokimq::bt_serialize(data);
+    const auto serialized = oxenmq::bt_serialize(data);
     if (not buf->write(serialized.begin(), serialized.end()))
       throw std::runtime_error("PeerStats: buffer too small");
   }

llarp/router/router.cpp

@@ -270,11 +270,11 @@ namespace llarp
     auto& conf = *m_Config;
     whitelistRouters = conf.lokid.whitelistRouters;
     if (whitelistRouters)
-      lokidRPCAddr = lokimq::address(conf.lokid.lokidRPCAddr);
+      lokidRPCAddr = oxenmq::address(conf.lokid.lokidRPCAddr);
 
     enableRPCServer = conf.api.m_enableRPCServer;
     if (enableRPCServer)
-      rpcBindAddr = lokimq::address(conf.api.m_rpcBindAddr);
+      rpcBindAddr = oxenmq::address(conf.api.m_rpcBindAddr);
 
     if (not StartRpcServer())
       throw std::runtime_error("Failed to start rpc server");
@@ -455,7 +455,7 @@ namespace llarp
 
     // Lokid Config
     whitelistRouters = conf.lokid.whitelistRouters;
-    lokidRPCAddr = lokimq::address(conf.lokid.lokidRPCAddr);
+    lokidRPCAddr = oxenmq::address(conf.lokid.lokidRPCAddr);
 
     m_isServiceNode = conf.router.m_isRelay;
 

llarp/router/router.hpp

@@ -190,7 +190,7 @@ namespace llarp
     llarp_dht_context* _dht = nullptr;
     std::shared_ptr<NodeDB> _nodedb;
     llarp_time_t _startedAt;
-    const lokimq::TaggedThreadID m_DiskThread;
+    const oxenmq::TaggedThreadID m_DiskThread;
 
     llarp_time_t
     Uptime() const override;
@@ -270,16 +270,16 @@ namespace llarp
     void
     PumpLL() override;
 
-    const lokimq::address DefaultRPCBindAddr = lokimq::address::tcp("127.0.0.1", 1190);
+    const oxenmq::address DefaultRPCBindAddr = oxenmq::address::tcp("127.0.0.1", 1190);
     bool enableRPCServer = false;
-    lokimq::address rpcBindAddr = DefaultRPCBindAddr;
+    oxenmq::address rpcBindAddr = DefaultRPCBindAddr;
     std::unique_ptr<rpc::RpcServer> m_RPCServer;
 
     const llarp_time_t _randomStartDelay;
 
     std::shared_ptr<rpc::LokidRpcClient> m_lokidRpcClient;
 
-    lokimq::address lokidRPCAddr;
+    oxenmq::address lokidRPCAddr;
     Profiling _routerProfiling;
     fs::path _profilesFile;
     OutboundMessageHandler _outboundMessageHandler;

llarp/router_id.cpp

@@ -1,8 +1,6 @@
 #include <router_id.hpp>
 #include <oxenmq/base32z.h>
 
-namespace lokimq = oxenmq;
-
 namespace llarp
 {
   constexpr std::string_view SNODE_TLD = ".snode";
@@ -10,7 +8,7 @@ namespace llarp
   std::string
   RouterID::ToString() const
   {
-    std::string b32 = lokimq::to_base32z(begin(), end());
+    std::string b32 = oxenmq::to_base32z(begin(), end());
     b32 += SNODE_TLD;
     return b32;
   }
@@ -19,7 +17,7 @@ namespace llarp
   RouterID::ShortString() const
   {
     // 5 bytes produces exactly 8 base32z characters:
-    return lokimq::to_base32z(begin(), begin() + 5);
+    return oxenmq::to_base32z(begin(), begin() + 5);
   }
 
   util::StatusObject
@@ -40,9 +38,9 @@ namespace llarp
     // - must end in a 1-bit value: 'o' or 'y' (i.e. 10000 or 00000)
     // - must have 51 preceeding base32z chars
     // - thus we get 51*5+1 = 256 bits = 32 bytes of output
-    if (str.size() != 52 || !lokimq::is_base32z(str) || !(str.back() == 'o' || str.back() == 'y'))
+    if (str.size() != 52 || !oxenmq::is_base32z(str) || !(str.back() == 'o' || str.back() == 'y'))
       return false;
-    lokimq::from_base32z(str.begin(), str.end(), begin());
+    oxenmq::from_base32z(str.begin(), str.end(), begin());
     return true;
   }
 }  // namespace llarp

llarp/rpc/lokid_rpc_client.cpp

@@ -14,22 +14,22 @@ namespace llarp
 {
   namespace rpc
   {
-    static lokimq::LogLevel
+    static oxenmq::LogLevel
     toLokiMQLogLevel(llarp::LogLevel level)
     {
       switch (level)
       {
         case eLogError:
-          return lokimq::LogLevel::error;
+          return oxenmq::LogLevel::error;
         case eLogWarn:
-          return lokimq::LogLevel::warn;
+          return oxenmq::LogLevel::warn;
         case eLogInfo:
-          return lokimq::LogLevel::info;
+          return oxenmq::LogLevel::info;
         case eLogDebug:
-          return lokimq::LogLevel::debug;
+          return oxenmq::LogLevel::debug;
         case eLogNone:
         default:
-          return lokimq::LogLevel::trace;
+          return oxenmq::LogLevel::trace;
       }
     }
 
@@ -39,13 +39,13 @@ namespace llarp
       // m_lokiMQ->log_level(toLokiMQLogLevel(LogLevel::Instance().curLevel));
 
       // TODO: proper auth here
-      auto lokidCategory = m_lokiMQ->add_category("lokid", lokimq::Access{lokimq::AuthLevel::none});
+      auto lokidCategory = m_lokiMQ->add_category("lokid", oxenmq::Access{oxenmq::AuthLevel::none});
       lokidCategory.add_request_command(
-          "get_peer_stats", [this](lokimq::Message& m) { HandleGetPeerStats(m); });
+          "get_peer_stats", [this](oxenmq::Message& m) { HandleGetPeerStats(m); });
     }
 
     void
-    LokidRpcClient::ConnectAsync(lokimq::address url)
+    LokidRpcClient::ConnectAsync(oxenmq::address url)
     {
       if (not m_Router->IsServiceNode())
       {
@@ -54,8 +54,8 @@ namespace llarp
       LogInfo("connecting to lokid via LMQ at ", url);
       m_Connection = m_lokiMQ->connect_remote(
           url,
-          [self = shared_from_this()](lokimq::ConnectionID) { self->Connected(); },
-          [self = shared_from_this(), url](lokimq::ConnectionID, std::string_view f) {
+          [self = shared_from_this()](oxenmq::ConnectionID) { self->Connected(); },
+          [self = shared_from_this(), url](oxenmq::ConnectionID, std::string_view f) {
             llarp::LogWarn("Failed to connect to lokid: ", f);
             LogicCall(self->m_Router->logic(), [self, url]() { self->ConnectAsync(url); });
           });
@@ -236,8 +236,8 @@ namespace llarp
               {
                 service::EncryptedName result;
                 const auto j = nlohmann::json::parse(data[1]);
-                result.ciphertext = lokimq::from_hex(j["encrypted_value"].get<std::string>());
-                const auto nonce = lokimq::from_hex(j["nonce"].get<std::string>());
+                result.ciphertext = oxenmq::from_hex(j["encrypted_value"].get<std::string>());
+                const auto nonce = oxenmq::from_hex(j["nonce"].get<std::string>());
                 if (nonce.size() != result.nonce.size())
                 {
                   throw std::invalid_argument(stringify(
@@ -258,7 +258,7 @@ namespace llarp
     }
 
     void
-    LokidRpcClient::HandleGetPeerStats(lokimq::Message& msg)
+    LokidRpcClient::HandleGetPeerStats(oxenmq::Message& msg)
     {
       LogInfo("Got request for peer stats (size: ", msg.data.size(), ")");
       for (auto str : msg.data)
@@ -290,7 +290,7 @@ namespace llarp
         }
 
         std::vector<std::string> routerIdStrings;
-        lokimq::bt_deserialize(msg.data[0], routerIdStrings);
+        oxenmq::bt_deserialize(msg.data[0], routerIdStrings);
 
         std::vector<RouterID> routerIds;
         routerIds.reserve(routerIdStrings.size());

llarp/rpc/lokid_rpc_client.hpp

@@ -8,15 +8,13 @@
 #include <dht/key.hpp>
 #include <service/name.hpp>
 
-namespace lokimq = oxenmq;
-
 namespace llarp
 {
   struct AbstractRouter;
 
   namespace rpc
   {
-    using LMQ_ptr = std::shared_ptr<lokimq::OxenMQ>;
+    using LMQ_ptr = std::shared_ptr<oxenmq::OxenMQ>;
 
     /// The LokidRpcClient uses loki-mq to talk to make API requests to lokid.
     struct LokidRpcClient : public std::enable_shared_from_this<LokidRpcClient>
@@ -25,7 +23,7 @@ namespace llarp
 
       /// Connect to lokid async
       void
-      ConnectAsync(lokimq::address url);
+      ConnectAsync(oxenmq::address url);
 
       /// blocking request identity key from lokid
       /// throws on failure
@@ -68,9 +66,9 @@ namespace llarp
 
       // Handles request from lokid for peer stats on a specific peer
       void
-      HandleGetPeerStats(lokimq::Message& msg);
+      HandleGetPeerStats(oxenmq::Message& msg);
 
-      std::optional<lokimq::ConnectionID> m_Connection;
+      std::optional<oxenmq::ConnectionID> m_Connection;
       LMQ_ptr m_lokiMQ;
       std::string m_CurrentBlockHash;
 

llarp/rpc/rpc_server.cpp

@@ -17,7 +17,7 @@ namespace llarp::rpc
 
   /// maybe parse json from message paramter at index
   std::optional<nlohmann::json>
-  MaybeParseJSON(const lokimq::Message& msg, size_t index = 0)
+  MaybeParseJSON(const oxenmq::Message& msg, size_t index = 0)
   {
     try
     {

llarp/rpc/rpc_server.hpp

@@ -9,18 +9,16 @@ namespace llarp
   struct AbstractRouter;
 }
 
-namespace lokimq = oxenmq;
-
 namespace llarp::rpc
 {
-  using LMQ_ptr = std::shared_ptr<lokimq::OxenMQ>;
+  using LMQ_ptr = std::shared_ptr<oxenmq::OxenMQ>;
 
   struct RpcServer
   {
     explicit RpcServer(LMQ_ptr, AbstractRouter*);
     ~RpcServer() = default;
     void
-    AsyncServeRPC(lokimq::address addr);
+    AsyncServeRPC(oxenmq::address addr);
 
    private:
     LMQ_ptr m_LMQ;

llarp/service/address.cpp

@@ -3,8 +3,6 @@
 #include <oxenmq/base32z.h>
 #include <algorithm>
 
-namespace lokimq = oxenmq;
-
 namespace llarp::service
 {
   const std::set<std::string> Address::AllowedTLDs = {".loki", ".snode"};
@@ -28,7 +26,7 @@ namespace llarp::service
       str = subdomain;
       str += '.';
     }
-    str += lokimq::to_base32z(begin(), end());
+    str += oxenmq::to_base32z(begin(), end());
     str += tld;
     return str;
   }
@@ -58,10 +56,10 @@ namespace llarp::service
     // - must end in a 1-bit value: 'o' or 'y' (i.e. 10000 or 00000)
     // - must have 51 preceeding base32z chars
     // - thus we get 51*5+1 = 256 bits = 32 bytes of output
-    if (str.size() != 52 || !lokimq::is_base32z(str) || !(str.back() == 'o' || str.back() == 'y'))
+    if (str.size() != 52 || !oxenmq::is_base32z(str) || !(str.back() == 'o' || str.back() == 'y'))
       return false;
 
-    lokimq::from_base32z(str.begin(), str.end(), begin());
+    oxenmq::from_base32z(str.begin(), str.end(), begin());
     return true;
   }
 

llarp/service/intro_set.cpp

@@ -3,7 +3,6 @@
 #include <path/path.hpp>
 
 #include <oxenmq/bt_serialize.h>
-namespace lokimq = oxenmq;
 
 namespace llarp::service
 {
@@ -182,9 +181,9 @@ namespace llarp::service
 
       try
       {
-        lokimq::bt_deserialize(srvString, SRVs);
+        oxenmq::bt_deserialize(srvString, SRVs);
       }
-      catch (const lokimq::bt_deserialize_invalid& err)
+      catch (const oxenmq::bt_deserialize_invalid& err)
       {
         LogError("Error decoding SRV records from IntroSet: ", err.what());
         return false;
@@ -240,7 +239,7 @@ namespace llarp::service
 
     if (SRVs.size())
     {
-      std::string serial = lokimq::bt_serialize(SRVs);
+      std::string serial = oxenmq::bt_serialize(SRVs);
       if (!bencode_write_bytestring(buf, "s", 1))
         return false;
       if (!buf->write(serial.begin(), serial.end()))