Eradicate service::Config

llarp/CMakeLists.txt

@@ -178,7 +178,6 @@ set(LIB_SRC
   rpc/rpc.cpp
   service/address.cpp
   service/async_key_exchange.cpp
-  service/config.cpp
   service/context.cpp
   service/endpoint_state.cpp
   service/endpoint_util.cpp

llarp/config/config.cpp

@@ -275,20 +275,6 @@ namespace llarp
         });
   }
 
-  void
-  ServicesConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params)
-  {
-    (void)params;
-
-    conf.addUndeclaredHandler(
-        "services",
-        [this](std::string_view section, std::string_view name, std::string_view value) {
-          (void)section;
-          services.emplace_back(name, value);
-          return true;
-        });
-  }
-
   void
   ApiConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params)
   {
@@ -401,6 +387,8 @@ namespace llarp
       m_keyfile = arg;
     });
 
+    // TODO: m_endpointType -- this is used downstream, but was it ever supported in config file?
+
     conf.defineOption<std::string>(section, "tag", false, "", [=](std::string arg) {
       if (arg.size() < service::Tag::size())
         throw std::invalid_argument(
@@ -582,7 +570,6 @@ namespace llarp
     connect.defineConfigOptions(conf, params);
     dns.defineConfigOptions(conf, params);
     links.defineConfigOptions(conf, params);
-    services.defineConfigOptions(conf, params);
     api.defineConfigOptions(conf, params);
     lokid.defineConfigOptions(conf, params);
     bootstrap.defineConfigOptions(conf, params);

llarp/config/config.hpp

@@ -114,13 +114,6 @@ namespace llarp
     defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params);
   };
 
-  struct ServicesConfig
-  {
-    std::vector<std::pair<std::string, std::string>> services;
-    void
-    defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params);
-  };
-
   struct ApiConfig
   {
     bool m_enableRPCServer;
@@ -164,6 +157,7 @@ namespace llarp
   {
     std::string m_name;
     std::string m_keyfile;
+    std::string m_endpointType;
     service::Tag m_tag;
     std::set<service::Tag> m_prefetchTags;
     std::set<service::Address> m_prefetchAddrs;
@@ -194,7 +188,6 @@ namespace llarp
     ConnectConfig connect;
     DnsConfig dns;
     LinksConfig links;
-    ServicesConfig services;
     ApiConfig api;
     LokidConfig lokid;
     BootstrapConfig bootstrap;

llarp/handlers/null.hpp

@@ -10,8 +10,8 @@ namespace llarp
     struct NullEndpoint final : public llarp::service::Endpoint,
                                 public std::enable_shared_from_this<NullEndpoint>
     {
-      NullEndpoint(const std::string& name, AbstractRouter* r, llarp::service::Context* parent)
-          : llarp::service::Endpoint(name, r, parent)
+      NullEndpoint(const SnappConfig& conf, AbstractRouter* r, llarp::service::Context* parent)
+          : llarp::service::Endpoint(conf, r, parent)
       {
       }
 

llarp/handlers/tun.cpp

@@ -50,10 +50,10 @@ namespace llarp
     }
 
     TunEndpoint::TunEndpoint(
-        const std::string& nickname, AbstractRouter* r, service::Context* parent, bool lazyVPN)
-        : service::Endpoint(nickname, r, parent)
-        , m_UserToNetworkPktQueue(nickname + "_sendq", r->netloop(), r->netloop())
-        , m_NetworkToUserPktQueue(nickname + "_recvq", r->netloop(), r->netloop())
+        const SnappConfig& conf, AbstractRouter* r, service::Context* parent, bool lazyVPN)
+        : service::Endpoint(conf, r, parent)
+        , m_UserToNetworkPktQueue(conf.m_name + "_sendq", r->netloop(), r->netloop())
+        , m_NetworkToUserPktQueue(conf.m_name + "_recvq", r->netloop(), r->netloop())
         , m_Resolver(std::make_shared<dns::Proxy>(
               r->netloop(), r->logic(), r->netloop(), r->logic(), this))
     {
@@ -105,8 +105,9 @@ namespace llarp
     }
 
     bool
-    TunEndpoint::SetOption(const std::string& k, const std::string& v)
+    TunEndpoint::Configure(SnappConfig conf)
     {
+      /*
       if (k == "reachable")
       {
         if (IsFalseValue(v))
@@ -315,7 +316,8 @@ namespace llarp
         strncpy(tunif->ifaddr, addr.c_str(), sizeof(tunif->ifaddr) - 1);
         return true;
       }
-      return Endpoint::SetOption(k, v);
+      */
+      return Endpoint::Configure(conf);
     }
 
     bool

llarp/handlers/tun.hpp

@@ -21,7 +21,7 @@ namespace llarp
                          public std::enable_shared_from_this<TunEndpoint>
     {
       TunEndpoint(
-          const std::string& nickname,
+          const SnappConfig& conf,
           AbstractRouter* r,
           llarp::service::Context* parent,
           bool lazyVPN = false);
@@ -34,7 +34,7 @@ namespace llarp
       }
 
       bool
-      SetOption(const std::string& k, const std::string& v) override;
+      Configure(SnappConfig conf) override;
 
       void
       Tick(llarp_time_t now) override;

llarp/router/router.cpp

@@ -583,17 +583,14 @@ namespace llarp
     enableRPCServer = conf->api.m_enableRPCServer;
     rpcBindAddr = conf->api.m_rpcBindAddr;
 
-    // Services config
-    for (const auto& service : conf->services.services)
+    // load SNApps
+    for (const auto& pairs : conf->snapps)
     {
-      if (LoadHiddenServiceConfig(service.second))
-      {
-        llarp::LogInfo("loaded hidden service config for ", service.first);
-      }
-      else
-      {
-        llarp::LogWarn("failed to load hidden service config for ", service.first);
-      }
+      // TODO: this was previously incorporating the "sane defaults" for netConfig
+      //       netConfig should be refactored to use strongly typed member variables
+      //       instead of an ad-hoc multimap
+      const SnappConfig& snappConfig = pairs.second;
+      hiddenServiceContext().AddEndpoint(snappConfig);
     }
 
     // Logging config
@@ -1258,24 +1255,6 @@ namespace llarp
     return hiddenServiceContext().AddDefaultEndpoint(netConfig);
   }
 
-  bool
-  Router::LoadHiddenServiceConfig(std::string_view fname)
-  {
-    LogDebug("opening hidden service config ", fname);
-    service::Config conf;
-    if (!conf.Load(fname))
-      return false;
-    for (const auto& config : conf.services)
-    {
-      service::Config::section_t filteredConfig;
-      mergeHiddenServiceConfig(config.second, filteredConfig.second);
-      filteredConfig.first = config.first;
-      if (!hiddenServiceContext().AddEndpoint(filteredConfig))
-        return false;
-    }
-    return true;
-  }
-
   void
   Router::MessageSent(const RouterID& remote, SendStatus status)
   {

llarp/router/router.hpp

@@ -333,12 +333,6 @@ namespace llarp
     void
     Close();
 
-    bool
-    LoadHiddenServiceConfig(std::string_view fname);
-
-    bool
-    AddHiddenService(const service::Config::section_t& config);
-
     bool
     Configure(Config* conf, llarp_nodedb* nodedb = nullptr) override;
 

llarp/service/config.cpp

@@ -1,26 +0,0 @@
-#include <service/config.hpp>
-
-#include <config/ini.hpp>
-
-namespace llarp
-{
-  namespace service
-  {
-    bool
-    Config::Load(std::string_view fname)
-    {
-      ConfigParser parser;
-      if (!parser.LoadFile(fname))
-        return false;
-      parser.IterAll([&](std::string_view name, const ConfigParser::SectionValues_t& section) {
-        Config::section_t values;
-        values.first.assign(name.begin(), name.end());
-        for (const auto& item : section)
-          values.second.emplace_back(item.first, item.second);
-        services.emplace_back(values);
-      });
-      return services.size() > 0;
-    }
-
-  }  // namespace service
-}  // namespace llarp

llarp/service/config.hpp

@@ -1,24 +0,0 @@
-#ifndef LLARP_SERVICE_CONFIG_HPP
-#define LLARP_SERVICE_CONFIG_HPP
-
-#include <list>
-#include <string>
-#include <string_view>
-
-namespace llarp
-{
-  namespace service
-  {
-    struct Config
-    {
-      using section_values_t = std::list<std::pair<std::string, std::string>>;
-      using section_t = std::pair<std::string, section_values_t>;
-
-      std::list<section_t> services;
-
-      bool
-      Load(std::string_view fname);
-    };
-  }  // namespace service
-}  // namespace llarp
-#endif

llarp/service/context.cpp

@@ -5,6 +5,7 @@
 #include <nodedb.hpp>
 #include <router/abstractrouter.hpp>
 #include <service/endpoint.hpp>
+#include <stdexcept>
 
 namespace llarp
 {
@@ -13,29 +14,24 @@ namespace llarp
     namespace
     {
       using EndpointConstructor = std::function<service::Endpoint_ptr(
-          const std::string&, AbstractRouter*, service::Context*)>;
+          const SnappConfig&, AbstractRouter*, service::Context*)>;
       using EndpointConstructors = std::map<std::string, EndpointConstructor>;
 
       static EndpointConstructors endpointConstructors = {
           {"tun",
-           [](const std::string& nick, AbstractRouter* r, service::Context* c)
-               -> service::Endpoint_ptr {
-             return std::make_shared<handlers::TunEndpoint>(nick, r, c, false);
+           [](const SnappConfig& conf, AbstractRouter* r, service::Context* c) {
+             return std::make_shared<handlers::TunEndpoint>(conf, r, c, false);
            }},
           {"android",
-           [](const std::string& nick, AbstractRouter* r, service::Context* c)
-               -> service::Endpoint_ptr {
-             return std::make_shared<handlers::TunEndpoint>(nick, r, c, true);
+           [](const SnappConfig& conf, AbstractRouter* r, service::Context* c) {
+             return std::make_shared<handlers::TunEndpoint>(conf, r, c, true);
            }},
           {"ios",
-           [](const std::string& nick, AbstractRouter* r, service::Context* c)
-               -> service::Endpoint_ptr {
-             return std::make_shared<handlers::TunEndpoint>(nick, r, c, true);
+           [](const SnappConfig& conf, AbstractRouter* r, service::Context* c) {
+             return std::make_shared<handlers::TunEndpoint>(conf, r, c, true);
            }},
-          {"null",
-           [](const std::string& nick, AbstractRouter* r, service::Context* c)
-               -> service::Endpoint_ptr {
-             return std::make_shared<handlers::NullEndpoint>(nick, r, c);
+          {"null", [](const SnappConfig& conf, AbstractRouter* r, service::Context* c) {
+             return std::make_shared<handlers::NullEndpoint>(conf, r, c);
            }}};
 
     }  // namespace
@@ -140,8 +136,10 @@ namespace llarp
     }
 
     bool
-    Context::AddDefaultEndpoint(const std::unordered_multimap<std::string, std::string>& opts)
+    Context::AddDefaultEndpoint(const std::unordered_multimap<std::string, std::string>&)
     {
+      throw std::runtime_error("FIXME");
+      /*
       Config::section_values_t configOpts;
       configOpts.push_back({"type", DefaultEndpointType()});
       // non reachable by default as this is the default endpoint
@@ -160,6 +158,7 @@ namespace llarp
         }
       }
       return AddEndpoint({"default", configOpts});
+      */
     }
 
     bool
@@ -198,86 +197,52 @@ namespace llarp
       }
     }
 
-    bool
-    Context::AddEndpoint(const Config::section_t& conf, bool autostart)
+    void
+    Context::AddEndpoint(const SnappConfig& conf, bool autostart)
     {
-      {
-        auto itr = m_Endpoints.find(conf.first);
-        if (itr != m_Endpoints.end())
-        {
-          LogError("cannot add hidden service with duplicate name: ", conf.first);
-          return false;
-        }
-      }
-      // extract type
-      std::string endpointType = DefaultEndpointType();
-      std::string keyfile;
-      for (const auto& option : conf.second)
-      {
-        if (option.first == "type")
-          endpointType = option.second;
-        if (option.first == "keyfile")
-          keyfile = option.second;
-      }
-
-      service::Endpoint_ptr service;
-
-      {
-        // detect type
-        const auto itr = endpointConstructors.find(endpointType);
-        if (itr == endpointConstructors.end())
-        {
-          LogError("no such endpoint type: ", endpointType);
-          return false;
-        }
-
-        // construct
-        service = itr->second(conf.first, m_Router, this);
-        if (service)
-        {
-          // if ephemeral, then we need to regen key
-          // if privkey file, then set it and load it
-          if (!keyfile.empty())
-          {
-            service->SetOption("keyfile", keyfile);
-            // load keyfile, so we have the correct name for logging
-          }
-          LogInfo("Establishing endpoint identity");
-          service->LoadKeyFile();  // only start endpoint not tun
-          // now Name() will be correct
-        }
-      }
-      if (service == nullptr)
-        return false;
-      // configure
-      for (const auto& option : conf.second)
-      {
-        auto& k = option.first;
-        if (k == "type")
-          continue;
-        auto& v = option.second;
-        if (!service->SetOption(k, v))
-        {
-          LogError("failed to set ", k, "=", v, " for hidden service endpoint ", conf.first);
-          return false;
-        }
-      }
+      if (m_Endpoints.find(conf.m_name) != m_Endpoints.end())
+        throw std::invalid_argument(stringify("Snapp ", conf.m_name, " already exists"));
+
+      // use specified type, fall back to default
+      std::string endpointType = conf.m_name;
+      if (endpointType.empty())
+        endpointType = DefaultEndpointType();
+
+      // use factory to create endpoint
+      const auto itr = endpointConstructors.find(endpointType);
+      if (itr == endpointConstructors.end())
+        throw std::invalid_argument(stringify("Endpoint type ", endpointType, " does not exist"));
+
+      auto service = itr->second(conf, m_Router, this);
+      if (not service)
+        throw std::runtime_error(stringify(
+            "Failed to create endpoint service for ",
+            conf.m_name,
+            "(type: ",
+            conf.m_endpointType,
+            ")"));
+
+      // pass conf to service
+      service->Configure(conf);
+
+      // autostart if requested
       if (autostart)
       {
         // start
         if (service->Start())
         {
           LogInfo("autostarting hidden service endpoint ", service->Name());
-          m_Endpoints.emplace(conf.first, service);
-          return true;
+          m_Endpoints.emplace(conf.m_name, service);
+        }
+        else
+        {
+          throw std::runtime_error(
+              stringify("failed to start hidden service endpoint ", conf.m_name));
         }
-        LogError("failed to start hidden service endpoint ", conf.first);
-        return false;
       }
 
       LogInfo("added hidden service endpoint ", service->Name());
-      m_Endpoints.emplace(conf.first, service);
-      return true;
+      m_Endpoints.emplace(conf.m_name, service);
     }
   }  // namespace service
 }  // namespace llarp

llarp/service/context.hpp

@@ -3,7 +3,7 @@
 
 #include <handlers/tun.hpp>
 #include <net/net.hpp>
-#include <service/config.hpp>
+#include <config/config.hpp>
 #include <service/endpoint.hpp>
 
 #include <unordered_map>
@@ -40,8 +40,8 @@ namespace llarp
       AddDefaultEndpoint(const std::unordered_multimap<std::string, std::string>& opts);
 
       /// add endpoint via config
-      bool
-      AddEndpoint(const Config::section_t& conf, bool autostart = false);
+      void
+      AddEndpoint(const SnappConfig& conf, bool autostart = false);
 
       /// inject endpoint instance
       void

llarp/service/endpoint.cpp

@@ -33,20 +33,22 @@ namespace llarp
 {
   namespace service
   {
-    Endpoint::Endpoint(const std::string& name, AbstractRouter* r, Context* parent)
+    Endpoint::Endpoint(const SnappConfig& conf, AbstractRouter* r, Context* parent)
         : path::Builder(r, 3, path::default_len), context(parent), m_RecvQueue(128)
     {
       m_state = std::make_unique<EndpointState>();
       m_state->m_Router = r;
-      m_state->m_Name = name;
+      m_state->m_Name = conf.m_name;
       m_state->m_Tag.Zero();
       m_RecvQueue.enable();
     }
 
     bool
-    Endpoint::SetOption(const std::string& k, const std::string& v)
+    Endpoint::Configure(SnappConfig conf)
     {
-      return m_state->SetOption(k, v, *this);
+      numPaths = conf.m_paths;
+      numHops = conf.m_hops;
+      return m_state->Configure(std::move(conf));
     }
 
     llarp_ev_loop_ptr

llarp/service/endpoint.hpp

@@ -69,7 +69,7 @@ namespace llarp
     {
       static const size_t MAX_OUTBOUND_CONTEXT_COUNT = 4;
 
-      Endpoint(const std::string& nickname, AbstractRouter* r, Context* parent);
+      Endpoint(const SnappConfig& conf, AbstractRouter* r, Context* parent);
       ~Endpoint() override;
 
       /// return true if we are ready to recv packets from the void
@@ -94,7 +94,7 @@ namespace llarp
       SetHandler(IDataHandler* h);
 
       virtual bool
-      SetOption(const std::string& k, const std::string& v);
+      Configure(SnappConfig conf);
 
       void
       Tick(llarp_time_t now) override;

llarp/service/endpoint_state.cpp

@@ -11,80 +11,27 @@ namespace llarp
   namespace service
   {
     bool
-    EndpointState::SetOption(const std::string& k, const std::string& v, Endpoint& ep)
+    EndpointState::Configure(SnappConfig conf)
     {
-      const auto name = ep.Name();
-      if (k == "keyfile")
-      {
-        m_Keyfile = v;
-      }
-      if (k == "tag")
-      {
-        m_Tag = v;
-        LogInfo("Setting tag to ", v);
-      }
-      if (k == "prefetch-tag")
-      {
-        m_PrefetchTags.insert(v);
-      }
-      if (k == "prefetch-addr")
-      {
-        Address addr;
-        if (addr.FromString(v))
-          m_PrefetchAddrs.insert(addr);
-      }
-      if (k == "min-latency")
-      {
-        const auto val = atoi(v.c_str());
-        if (val > 0)
-          m_MinPathLatency = std::chrono::milliseconds(val);
-      }
-      if (k == "paths")
-      {
-        const auto val = atoi(v.c_str());
-        if (val >= 1 && val <= static_cast<int>(path::PathSet::max_paths))
-        {
-          ep.numPaths = val;
-          LogInfo(name, " set number of paths to ", ep.numHops);
-        }
-        else
-        {
-          LogWarn(name, " invalid number of paths: ", v);
-        }
-      }
-      if (k == "hops")
-      {
-        const auto val = atoi(v.c_str());
-        if (val >= 1 && val <= static_cast<int>(path::max_len))
-        {
-          ep.numHops = val;
-          LogInfo(name, " set number of hops to ", ep.numHops);
-        }
-        else
-        {
-          LogWarn(name, " invalid number of hops: ", v);
-        }
-      }
-      if (k == "bundle-rc")
-      {
-        m_BundleRC = IsTrueValue(v.c_str());
-      }
-      if (k == "blacklist-snode")
+      m_Keyfile = std::move(conf.m_keyfile);
+      m_Tag = std::move(conf.m_tag);
+      m_PrefetchTags = std::move(conf.m_prefetchTags);
+      m_PrefetchAddrs = std::move(conf.m_prefetchAddrs);
+      m_MinPathLatency = conf.m_minLatency;
+      m_BundleRC = conf.m_bundleRC;
+
+      // TODO: update SnappConfig to treat these as RouterIDs and detect dupes
+      for (const auto& item : conf.m_snodeBlacklist)
       {
         RouterID snode;
-        if (!snode.FromString(v))
-        {
-          LogError(name, " invalid snode value: ", v);
-          return false;
-        }
-        const auto result = m_SnodeBlacklist.insert(snode);
-        if (!result.second)
-        {
-          LogError(name, " duplicate blacklist-snode: ", snode.ToString());
-          return false;
-        }
-        LogInfo(name, " adding ", snode.ToString(), " to blacklist");
+        if (not snode.FromString(item))
+          throw std::runtime_error(stringify("Invalide RouterID: ", item));
+
+        m_SnodeBlacklist.insert(snode);
       }
+
+      // TODO:
+      /*
       if (k == "on-up")
       {
         m_OnUp = hooks::ExecShellBackend(v);
@@ -109,6 +56,7 @@ namespace llarp
         else
           LogError(name, " failed to add on ready script");
       }
+      */
       return true;
     }
 

llarp/service/endpoint_state.hpp

@@ -98,7 +98,7 @@ namespace llarp
       util::DecayingHashSet<Address> m_RemoteLookupFilter;
 
       bool
-      SetOption(const std::string& k, const std::string& v, Endpoint& ep);
+      Configure(SnappConfig conf);
 
       util::StatusObject
       ExtractStatus(util::StatusObject& obj) const;

pybind/llarp/config.cpp

@@ -22,11 +22,11 @@ namespace llarp
         .def_readwrite("connect", &Config::connect)
         .def_readwrite("dns", &Config::dns)
         .def_readwrite("links", &Config::links)
-        .def_readwrite("services", &Config::services)
         .def_readwrite("api", &Config::api)
         .def_readwrite("lokid", &Config::lokid)
         .def_readwrite("bootstrap", &Config::bootstrap)
         .def_readwrite("logging", &Config::logging)
+        .def_readwrite("snapps", &Config::snapps)
         .def("LoadFile", &Config::Load)
         .def("LoadDefault", [](Config& self, bool isRelay, std::string dir) {
           return self.LoadDefault(isRelay, dir);
@@ -97,10 +97,6 @@ namespace llarp
               self.m_InboundLinks.push_back(info);
             });
 
-    py::class_<ServicesConfig>(mod, "ServicesConfig")
-        .def(py::init<>())
-        .def_readwrite("services", &ServicesConfig::services);
-
     py::class_<ApiConfig>(mod, "ApiConfig")
         .def(py::init<>())
         .def_readwrite("enableRPCServer", &ApiConfig::m_enableRPCServer)
@@ -124,6 +120,25 @@ namespace llarp
         .def_readwrite("m_logType", &LoggingConfig::m_logType)
         .def_readwrite("m_logFile", &LoggingConfig::m_logFile);
 
+    py::class_<SnappConfig>(mod, "SnappConfig")
+        .def(py::init<>())
+        .def_readwrite("name", &SnappConfig::m_name)
+        .def_readwrite("keyfile", &SnappConfig::m_keyfile)
+        .def_readwrite("endpointType", &SnappConfig::m_endpointType)
+        .def_readwrite("tag", &SnappConfig::m_tag)
+        .def_readwrite("prefetchTags", &SnappConfig::m_prefetchTags)
+        .def_readwrite("prefetchAddrs", &SnappConfig::m_prefetchAddrs)
+        .def_readwrite("minLatency", &SnappConfig::m_minLatency)
+        .def_readwrite("reachable", &SnappConfig::m_reachable)
+        .def_readwrite("hops", &SnappConfig::m_hops)
+        .def_readwrite("paths", &SnappConfig::m_paths)
+        .def_readwrite("bundleRC", &SnappConfig::m_bundleRC)
+        .def_readwrite("snodeBlacklist", &SnappConfig::m_snodeBlacklist)
+        .def_readwrite("exitNode", &SnappConfig::m_exitNode)
+        .def_readwrite("localDNS", &SnappConfig::m_localDNS)
+        .def_readwrite("upstreamDNS", &SnappConfig::m_upstreamDNS)
+        .def_readwrite("mapAddr", &SnappConfig::m_mapAddr);
+
     py::class_<sockaddr_in>(mod, "sockaddr_in")
         .def_readwrite("sin_family", &sockaddr_in::sin_family)
         .def_readwrite("sin_port", &sockaddr_in::sin_port)

pybind/llarp/handlers/pyhandler.cpp

@@ -7,7 +7,7 @@ namespace llarp
     PyHandler_Init(py::module& mod)
     {
       py::class_<PythonEndpoint, PythonEndpoint_ptr>(mod, "Endpoint")
-          .def(py::init<std::string, Context_ptr>())
+          .def(py::init<const SnappConfig&, Context_ptr>())
           .def("SendTo", &PythonEndpoint::SendPacket)
           .def("OurAddress", &PythonEndpoint::GetOurAddress)
           .def_readwrite("GotPacket", &PythonEndpoint::handlePacket);
@@ -15,4 +15,4 @@ namespace llarp
 
   }  // namespace handlers
 
-}  // namespace llarp
+}  // namespace llarp

pybind/llarp/handlers/pyhandler.hpp

@@ -14,10 +14,10 @@ namespace llarp
     struct PythonEndpoint final : public llarp::service::Endpoint,
                                   public std::enable_shared_from_this<PythonEndpoint>
     {
-      PythonEndpoint(std::string name, Context_ptr routerContext)
+      PythonEndpoint(const SnappConfig& conf, Context_ptr routerContext)
           : llarp::service::Endpoint(
-              name, routerContext->router.get(), &routerContext->router->hiddenServiceContext())
-          , OurName(name)
+              conf, routerContext->router.get(), &routerContext->router->hiddenServiceContext())
+          , OurName(conf.m_name)
       {
       }
       const std::string OurName;
@@ -78,4 +78,4 @@ namespace llarp
 
     using PythonEndpoint_ptr = std::shared_ptr<PythonEndpoint>;
   }  // namespace handlers
-}  // namespace llarp
+}  // namespace llarp