Move router config to be encapsulated

llarp/config/config.cpp

@@ -23,7 +23,7 @@ namespace llarp
     {
       if(val.size() <= NetID::size())
       {
-        netid.assign(val.begin(), val.end());
+        m_netId.assign(val.begin(), val.end());
       }
       else
       {
@@ -36,8 +36,8 @@ namespace llarp
       auto ival = atoi(sVal.c_str());
       if(ival > 0)
       {
-        maxConnectedRouters = ival;
-        LogInfo("max connections set to ", maxConnectedRouters);
+        m_maxConnectedRouters = ival;
+        LogInfo("max connections set to ", m_maxConnectedRouters);
       }
     }
     if(key == "min-connections")
@@ -46,31 +46,31 @@ namespace llarp
       auto ival = atoi(sVal.c_str());
       if(ival > 0)
       {
-        minConnectedRouters = ival;
-        LogInfo("min connections set to ", minConnectedRouters);
+        m_minConnectedRouters = ival;
+        LogInfo("min connections set to ", m_minConnectedRouters);
       }
     }
     if(key == "nickname")
     {
-      nickname.assign(val.begin(), val.end());
+      m_nickname.assign(val.begin(), val.end());
       // set logger name here
-      LogContext::Instance().nodeName = nickname;
+      LogContext::Instance().nodeName = nickname();
     }
     if(key == "encryption-privkey")
     {
-      encryption_keyfile.assign(val.begin(), val.end());
+      m_encryptionKeyfile.assign(val.begin(), val.end());
     }
     if(key == "contact-file")
     {
-      our_rc_file.assign(val.begin(), val.end());
+      m_ourRcFile.assign(val.begin(), val.end());
     }
     if(key == "transport-privkey")
     {
-      transport_keyfile.assign(val.begin(), val.end());
+      m_transportKeyfile.assign(val.begin(), val.end());
     }
     if((key == "identity-privkey" || key == "ident-privkey"))
     {
-      ident_keyfile.assign(val.begin(), val.end());
+      m_identKeyfile.assign(val.begin(), val.end());
     }
     if(key == "public-address" || key == "public-ip")
     {
@@ -80,28 +80,31 @@ namespace llarp
         // assume IPv4
         llarp::Addr a(val);
         llarp::LogInfo("setting public ipv4 ", a);
-        addrInfo.ip    = *a.addr6();
-        publicOverride = true;
+        m_addrInfo.ip    = *a.addr6();
+        m_publicOverride = true;
       }
     }
     if(key == "public-port")
     {
       llarp::LogInfo("Setting public port ", val);
       int p = atoi(std::string(val).c_str());
-      // Not needed to flip upside-down this is done in Addr(const AddressInfo&)
-      ip4addr.sin_port = p;
-      addrInfo.port    = p;
-      publicOverride   = true;
+      // Not needed to flip upside-down - this is done in llarp::Addr(const
+      // AddressInfo&)
+      m_ip4addr.sin_port = p;
+      m_addrInfo.port    = p;
+      m_publicOverride   = true;
     }
     if(key == "worker-threads")
     {
-      workerThreads = atoi(std::string(val).c_str());
+      m_workerThreads = atoi(std::string(val).c_str());
     }
     if(key == "net-threads")
     {
-      num_nethreads = atoi(std::string(val).c_str());
-      if(num_nethreads <= 0)
-        num_nethreads = 1;
+      m_numNethreads = atoi(std::string(val).c_str());
+      if(m_numNethreads <= 0)
+      {
+        m_numNethreads = 1;
+      }
     }
 
     return true;

llarp/config/config.hpp

@@ -14,34 +14,53 @@ namespace llarp
 {
   struct ConfigParser;
 
-  struct RouterConfig
+  class RouterConfig
   {
+   private:
     /// always maintain this many connections to other routers
-    size_t minConnectedRouters = 2;
+    size_t m_minConnectedRouters = 2;
 
     /// hard upperbound limit on the number of router to router connections
-    size_t maxConnectedRouters = 2000;
+    size_t m_maxConnectedRouters = 2000;
 
-    std::string netid;
-    std::string nickname;
+    std::string m_netId;
+    std::string m_nickname;
 
-    fs::path encryption_keyfile = "encryption.key";
+    fs::path m_encryptionKeyfile = "encryption.key";
 
     // path to write our self signed rc to
-    fs::path our_rc_file = "rc.signed";
+    fs::path m_ourRcFile = "rc.signed";
 
     // transient iwp encryption key
-    fs::path transport_keyfile = "transport.key";
+    fs::path m_transportKeyfile = "transport.key";
 
     // long term identity key
-    fs::path ident_keyfile = "identity.key";
+    fs::path m_identKeyfile = "identity.key";
+
+    bool m_publicOverride = false;
+    struct sockaddr_in m_ip4addr;
+    AddressInfo m_addrInfo;
 
-    bool publicOverride = false;
-    struct sockaddr_in ip4addr;
-    AddressInfo addrInfo;
+    int m_workerThreads;
+    int m_numNethreads;
 
-    int workerThreads;
-    int num_nethreads;
+   public:
+    // clang-format off
+    size_t minConnectedRouters() const        { return m_minConnectedRouters; }
+    size_t maxConnectedRouters() const        { return m_maxConnectedRouters; }
+    const fs::path& encryptionKeyfile() const { return m_encryptionKeyfile; }
+    const fs::path& ourRcFile() const         { return m_ourRcFile; }
+    const fs::path& transportKeyfile() const  { return m_transportKeyfile; }
+    const fs::path& identKeyfile() const      { return m_identKeyfile; }
+    const std::string& netId() const          { return m_netId; }
+    const std::string& nickname() const       { return m_nickname; }
+    bool publicOverride() const               { return m_publicOverride; }
+    const struct sockaddr_in& ip4addr() const { return m_ip4addr; }
+    const AddressInfo& addrInfo() const       { return m_addrInfo; }
+    int workerThreads() const                 { return m_workerThreads; }
+    int numNethreads() const                  { return m_numNethreads; }
+
+    // clang-format on
 
     bool
     fromSection(string_view key, string_view val);
@@ -151,7 +170,7 @@ namespace llarp
   struct LoggingConfig
   {
     bool m_LogJSON  = false;
-    FILE *m_LogFile = stdout;
+    FILE* m_LogFile = stdout;
 
     bool
     fromSection(string_view key, string_view val);
@@ -161,7 +180,7 @@ namespace llarp
   {
    private:
     bool
-    parse(const ConfigParser &parser);
+    parse(const ConfigParser& parser);
 
    public:
     RouterConfig router;
@@ -179,7 +198,7 @@ namespace llarp
     LoggingConfig logging;
 
     bool
-    Load(const char *fname);
+    Load(const char* fname);
 
     bool
     LoadFromString(string_view str);
@@ -188,12 +207,12 @@ namespace llarp
 }  // namespace llarp
 
 void
-llarp_generic_ensure_config(std::ofstream &f, std::string basepath);
+llarp_generic_ensure_config(std::ofstream& f, std::string basepath);
 
 void
-llarp_ensure_router_config(std::ofstream &f, std::string basepath);
+llarp_ensure_router_config(std::ofstream& f, std::string basepath);
 
 bool
-llarp_ensure_client_config(std::ofstream &f, std::string basepath);
+llarp_ensure_client_config(std::ofstream& f, std::string basepath);
 
 #endif

llarp/context.cpp

@@ -60,10 +60,10 @@ namespace llarp
     }
 
     // Router config
-    if(!singleThreaded && config->router.workerThreads > 0 && !worker)
+    if(!singleThreaded && config->router.workerThreads() > 0 && !worker)
     {
-      worker.reset(
-          llarp_init_threadpool(config->router.workerThreads, "llarp-worker"));
+      worker.reset(llarp_init_threadpool(config->router.workerThreads(),
+                                         "llarp-worker"));
     }
 
     if(singleThreaded)
@@ -72,7 +72,7 @@ namespace llarp
     }
     else
     {
-      num_nethreads = config->router.num_nethreads;
+      num_nethreads = config->router.numNethreads();
     }
 
     nodedb_dir = config->netdb.nodedb_dir;
@@ -81,8 +81,8 @@ namespace llarp
     {
       auto &metricsConfig = config->metrics;
       auto &tags          = metricsConfig.metricTags;
-      tags["netid"]       = config->router.netid;
-      tags["nickname"]    = config->router.nickname;
+      tags["netid"]       = config->router.netId();
+      tags["nickname"]    = config->router.nickname();
       setupMetrics(metricsConfig);
       if(!config->metrics.disableMetricLogs)
       {

llarp/router/router.cpp

@@ -770,9 +770,9 @@ namespace llarp
   Router::fromConfig(Config *conf)
   {
     // Set netid before anything else
-    if(!conf->router.netid.empty())
+    if(!conf->router.netId().empty())
     {
-      const auto &netid = conf->router.netid;
+      const auto &netid = conf->router.netId();
       llarp::LogWarn("!!!! you have manually set netid to be '", netid,
                      "' which does not equal '", Version::LLARP_NET_ID,
                      "' you will run as a different network, good luck "
@@ -942,19 +942,19 @@ namespace llarp
     }
 
     // Router config
-    _rc.SetNick(conf->router.nickname);
-    maxConnectedRouters = conf->router.maxConnectedRouters;
-    minConnectedRouters = conf->router.minConnectedRouters;
-    encryption_keyfile  = conf->router.encryption_keyfile;
-    our_rc_file         = conf->router.our_rc_file;
-    transport_keyfile   = conf->router.transport_keyfile;
-    addrInfo            = conf->router.addrInfo;
-    publicOverride      = conf->router.publicOverride;
-    ip4addr             = conf->router.ip4addr;
+    _rc.SetNick(conf->router.nickname());
+    maxConnectedRouters = conf->router.maxConnectedRouters();
+    minConnectedRouters = conf->router.minConnectedRouters();
+    encryption_keyfile  = conf->router.encryptionKeyfile();
+    our_rc_file         = conf->router.ourRcFile();
+    transport_keyfile   = conf->router.transportKeyfile();
+    addrInfo            = conf->router.addrInfo();
+    publicOverride      = conf->router.publicOverride();
+    ip4addr             = conf->router.ip4addr();
 
     if(!usingSNSeed)
     {
-      ident_keyfile = conf->router.ident_keyfile;
+      ident_keyfile = conf->router.identKeyfile();
     }
   }