more shiz

contrib/py/pyllarp/hive.py

@@ -6,6 +6,7 @@ from shutil import rmtree
 from os import makedirs
 from socket import AF_INET, htons, inet_aton
 from pprint import pprint
+import sys
 
 tmpdir = "/tmp/lokinet_hive"
 
@@ -17,12 +18,19 @@ def RemoveTmpDir(dirname):
   else:
     print("not removing dir %s because it doesn't start with /tmp/" % dirname)
 
-def MakeEndpoint(router, idx, after):
-  ep = pyllarp.Endpoint("pyllarp-{}".format(idx), router)
+endpointName = "pyllarp"
+
+def MakeEndpoint(router, after):
+  if router.IsRelay():
+    print("discarding make endpoint")
+    return
+  ep = pyllarp.Endpoint(endpointName, router)
+  router.AddEndpoint(ep)
+  print("made endpoint: {}".format(ep.OurAddress()))
   if after is not None:
-    router.SafeCall(lambda : after(ep))
+    router.CallSafe(lambda : after(ep))
 
-def AddRouter(hive, index, gotEndpoint=None, netid="hive"):
+def AddRouter(hive, index, netid="hive"):
   dirname = "%s/routers/%d" % (tmpdir, index)
   makedirs("%s/netdb" % dirname, exist_ok=True)
 
@@ -38,6 +46,7 @@ def AddRouter(hive, index, gotEndpoint=None, netid="hive"):
   config.router.netid = netid
   config.router.nickname = "Router%d" % index
   config.router.publicOverride = True
+  config.router.overrideAddress("127.0.0.1", '{}'.format(port))
   """
   config.router.ip4addr.sin_family = AF_INET
   config.router.ip4addr.sin_port = htons(port)
@@ -61,13 +70,40 @@ def AddRouter(hive, index, gotEndpoint=None, netid="hive"):
     config.bootstrap.routers = ["%s/routers/1/rc.signed" % tmpdir]
 
   hive.AddRouter(config)
-  if index != 1:
-    hive.VisitRouter(index, lambda r : MakeEndpoint(r, index, gotEndpoint))
 
 
+def AddClient(hive, index, netid="hive"):
+  dirname = "%s/clients/%d" % (tmpdir, index)
+  makedirs("%s/netdb" % dirname, exist_ok=True)
 
-def main():
+  config = pyllarp.Config()
+
+  port = index + 40000
+  tunname = "lokihive%d" % index
+
+  config.router.encryptionKeyfile = "%s/encryption.key" % dirname
+  config.router.transportKeyfile = "%s/transport.key" % dirname
+  config.router.identKeyfile = "%s/identity.key" % dirname
+  config.router.ourRcFile = "%s/rc.signed" % dirname
+  config.router.netid = netid
+  config.router.blockBogons = False
 
+  config.network.enableProfiling = False
+  config.network.routerProfilesFile = "%s/profiles.dat" % dirname
+  config.network.netConfig = {"type": "null"}
+
+  config.netdb.nodedbDir = "%s/netdb" % dirname
+
+  config.system.pidfile = "%s/lokinet.pid" % dirname
+
+  config.dns.netConfig = {"local-dns": ("127.3.2.1:%d" % port)}
+
+  config.bootstrap.routers = ["%s/routers/1/rc.signed" % tmpdir]
+
+  hive.AddRouter(config)
+
+def main():
+  pyllarp.EnableDebug()
   running = True
   RemoveTmpDir(tmpdir)
 
@@ -83,6 +119,7 @@ def main():
   hive.StartAll()
   sleep(5)
 
+  print('stop')
   hive.StopAll()
 
   r = pyllarp.RouterContact()
@@ -96,28 +133,40 @@ def main():
   def onGotEndpoint(ep):
     addr = ep.OurAddress()
     print("got endpoint: {}".format(addr))
-    addrs.append(addr)
+    addrs.append(pyllarp.ServiceAddress(addr))
 
   def sendToAddress(router, toaddr, pkt):
-    print("sending {} bytes to {}".format(len(pkt), toaddr))
-    router.TrySendPacket(toaddr, pkt)
+    if router.IsRelay():
+      return
+    if router.TrySendPacket("default", toaddr, pkt):
+      print("sending {} bytes to {}".format(len(pkt), toaddr))
 
   def broadcastTo(addr, pkt):
-    hive.ForEach(lambda r : sendToAddress(r, addr, pkt))
+    hive.ForEachRouter(lambda r : sendToAddress(r, addr, pkt))
 
   for i in range(1, 11):
-    AddRouter(hive, i, onGotEndpoint)
+    AddRouter(hive, i)
+
+  for i in range(1, 11):
+    AddClient(hive, i)
 
   hive.StartAll()
+  sleep(1)
+  hive.ForEachRouter(lambda r: MakeEndpoint(r, onGotEndpoint))
+
 
   while running:
     event = hive.GetNextEvent()
     if event:
       print(event)
     for addr in addrs:
-      broadcastTo(addr, "packet lol")
+      broadcastTo(addr, b'packet lol')
 
+  print('stopping')
+  hive.ForEachRouter(lambda r : r.Stop())
+  print('stopped')
   hive.StopAll()
+  del hive
 
 if __name__ == '__main__':
   main()

llarp/service/context.cpp

@@ -196,6 +196,7 @@ namespace llarp
     void
     Context::InjectEndpoint(std::string name, std::shared_ptr<Endpoint> ep)
     {
+      ep->LoadKeyFile();
       if(ep->Start())
       {
         m_Endpoints.emplace(std::move(name), std::move(ep));

llarp/tooling/router_hive.cpp

@@ -29,13 +29,13 @@ namespace tooling
   }
 
   void
-  RouterHive::StartRouters()
+  RouterHive::StartRouters(std::function<void(llarp_main *)> runFunc)
   {
-    llarp_main_runtime_opts opts{false,false,false};
-
     for (llarp_main* ctx : routers)
     {
-      routerMainThreads.emplace_back([=](){ llarp_main_run(ctx, opts); });
+      routerMainThreads.emplace_back([runFunc, ctx](){ 
+        runFunc(ctx);
+      });
       std::this_thread::sleep_for(20ms);
     }
   }

llarp/tooling/router_hive.hpp

@@ -30,7 +30,7 @@ namespace tooling
     AddRouter(const std::shared_ptr<llarp::Config> & conf);
 
     void
-    StartRouters();
+    StartRouters(std::function<void(llarp_main*)> runit);
 
     void
     StopRouters();

llarp/util/logging/ostream_logger.hpp

@@ -16,7 +16,7 @@ namespace llarp
     PreLog(std::stringstream& s, LogLevel lvl, const char* fname, int lineno,
            const std::string& nodename) const override;
 
-    void
+    virtual void
     Print(LogLevel lvl, const char* tag, const std::string& msg) override;
 
     void

pybind/CMakeLists.txt

@@ -1,5 +1,6 @@
 
 set(PYTHON_EXECUTABLE "python3")
+find_package(pybind11 REQUIRED)
 set(LLARP_PYBIND_SRC
   module.cpp
   llarp/context.cpp

pybind/common.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
+#include <pybind11/functional.h>
 
 #include <nonstd/optional.hpp>
 

pybind/llarp/config.cpp

@@ -44,7 +44,10 @@ namespace llarp
     .def_readwrite("blockBogons", &RouterConfig::m_blockBogons)
     .def_readwrite("publicOverride", &RouterConfig::m_publicOverride)
     .def_readwrite("ip4addr", &RouterConfig::m_ip4addr)
-    .def_readwrite("addrInfo", &RouterConfig::m_addrInfo)
+    .def("overrideAddress", [](RouterConfig & self, std::string ip, std::string port) {
+      self.fromSection("public-ip", ip);
+      self.fromSection("public-port", port);
+    })
     .def_readwrite("workerThreads", &RouterConfig::m_workerThreads)
     .def_readwrite("numNetThreads", &RouterConfig::m_numNetThreads)
     .def_readwrite("JobQueueSize", &RouterConfig::m_JobQueueSize)

pybind/llarp/context.cpp

@@ -1,6 +1,7 @@
 #include "common.hpp"
 #include <llarp.hpp>
 #include <router/router.cpp>
+#include "llarp/handlers/pyhandler.hpp"
 namespace llarp
 {
   void
@@ -14,12 +15,24 @@ namespace llarp
              [](Context_ptr self) -> int {
                return self->Run(llarp_main_runtime_opts{});
              })
+        .def("Stop", [](Context_ptr self) {
+          self->CloseAsync();
+        })
         .def("IsUp", &Context::IsUp)
+        .def("IsRelay", [](Context_ptr self) -> bool {
+          return self->router->IsServiceNode();
+        })
         .def("LooksAlive", &Context::LooksAlive)
         .def("Configure", &Context::Configure)
-        .def("TrySendPacket", [](Context_ptr self, service::Address to, std::vector<byte_t> pkt) {
-          auto ep = self->router->hiddenServiceContext().GetDefault();
-          return ep->SendToServiceOrQueue(to, pkt, service::eProtocolControl);
+        .def("TrySendPacket", [](Context_ptr self, std::string from, service::Address to, std::string pkt) {
+          auto ep = self->router->hiddenServiceContext().GetEndpointByName(from);
+          std::vector<byte_t> buf;
+          buf.resize(pkt.size());
+          std::copy_n(pkt.c_str(), pkt.size(), buf.data());
+          return ep and ep->SendToServiceOrQueue(to, std::move(buf), service::eProtocolControl);
+        })
+        .def("AddEndpoint", [](Context_ptr self, handlers::PythonEndpoint_ptr ep) {
+          self->router->hiddenServiceContext().InjectEndpoint(ep->OurName, ep);
         })
         .def("CallSafe", &Context::CallSafe);
   }

pybind/llarp/handlers/pyhandler.cpp

@@ -1,82 +1,12 @@
-#include "common.hpp"
-#include "llarp.hpp"
-#include "service/context.hpp"
-#include "service/endpoint.hpp"
-#include "router/abstractrouter.hpp"
-
+#include "llarp/handlers/pyhandler.hpp"
 namespace llarp
 {
-  namespace handlers
+  namespace handlers 
   {
-    using Context_ptr = std::shared_ptr<llarp::Context>;
-
-    struct PythonEndpoint final
-        : public llarp::service::Endpoint,
-          public std::enable_shared_from_this< PythonEndpoint >
-    {
-
-      PythonEndpoint(std::string name, Context_ptr routerContext)
-          : llarp::service::Endpoint(name, routerContext->router.get(), &routerContext->router->hiddenServiceContext())
-      {
-        routerContext->router->hiddenServiceContext().InjectEndpoint(name, shared_from_this());
-      }
-
-      bool
-      HandleInboundPacket(const service::ConvoTag tag, const llarp_buffer_t & pktbuf,
-                          service::ProtocolType proto) override
-      {
-        if(handlePacket)
-        {
-          AlignedBuffer<32> addr;
-          bool isSnode = false;
-          if(not GetEndpointWithConvoTag(tag, addr, isSnode))
-            return false;
-          if(isSnode)
-            return true;
-          std::vector<byte_t> pkt;
-          pkt.resize(pktbuf.sz);
-          std::copy_n(pktbuf.base, pktbuf.sz, pkt.data());
-          handlePacket(service::Address(addr), std::move(pkt), proto);
-        }
-        return true;
-      }
-
-      path::PathSet_ptr
-      GetSelf() override
-      {
-        return shared_from_this();
-      }
-
-      bool
-      SupportsV6() const override
-      {
-        return false;
-      }
-
-      using PacketHandler_t = std::function<void(service::Address, std::vector<byte_t>, service::ProtocolType)>;
-
-      PacketHandler_t handlePacket;
-
-      void 
-      SendPacket(service::Address remote, std::vector<byte_t> pkt, service::ProtocolType proto)
-      {
-        LogicCall(m_router->logic(), [remote, pkt, proto, self=shared_from_this()]() {
-          self->SendToServiceOrQueue(remote, llarp_buffer_t(pkt), proto);
-        });
-      }
-
-      std::string 
-      GetOurAddress() const 
-      {
-        return m_Identity.pub.Addr().ToString();
-      }
-    };
-
-
     void 
     PyHandler_Init(py::module & mod)
     {
-      py::class_<PythonEndpoint, std::shared_ptr<PythonEndpoint> >(mod, "Endpoint")
+      py::class_<PythonEndpoint, PythonEndpoint_ptr >(mod, "Endpoint")
       .def(py::init<std::string, Context_ptr>())
       .def("SendTo", &PythonEndpoint::SendPacket)
       .def("OurAddress", &PythonEndpoint::GetOurAddress)

pybind/llarp/handlers/pyhandler.hpp

@@ -0,0 +1,79 @@
+#pragma once 
+#include "common.hpp"
+#include "llarp.hpp"
+#include "service/context.hpp"
+#include "service/endpoint.hpp"
+#include "router/abstractrouter.hpp"
+
+namespace llarp 
+{
+namespace handlers
+  {
+    using Context_ptr = std::shared_ptr<llarp::Context>;
+
+    struct PythonEndpoint final
+        : public llarp::service::Endpoint,
+          public std::enable_shared_from_this< PythonEndpoint >
+    {
+
+      PythonEndpoint(std::string name, Context_ptr routerContext)
+          : llarp::service::Endpoint(name, routerContext->router.get(), &routerContext->router->hiddenServiceContext())
+          , OurName(name)
+      {
+      }
+      const std::string OurName;
+
+      bool
+      HandleInboundPacket(const service::ConvoTag tag, const llarp_buffer_t & pktbuf,
+                          service::ProtocolType proto) override
+      {
+        if(handlePacket)
+        {
+          AlignedBuffer<32> addr;
+          bool isSnode = false;
+          if(not GetEndpointWithConvoTag(tag, addr, isSnode))
+            return false;
+          if(isSnode)
+            return true;
+          std::vector<byte_t> pkt;
+          pkt.resize(pktbuf.sz);
+          std::copy_n(pktbuf.base, pktbuf.sz, pkt.data());
+          handlePacket(service::Address(addr), std::move(pkt), proto);
+        }
+        return true;
+      }
+
+      path::PathSet_ptr
+      GetSelf() override
+      {
+        return shared_from_this();
+      }
+
+      bool
+      SupportsV6() const override
+      {
+        return false;
+      }
+
+      using PacketHandler_t = std::function<void(service::Address, std::vector<byte_t>, service::ProtocolType)>;
+
+      PacketHandler_t handlePacket;
+
+      void 
+      SendPacket(service::Address remote, std::vector<byte_t> pkt, service::ProtocolType proto)
+      {
+        LogicCall(m_router->logic(), [remote, pkt, proto, self=shared_from_this()]() {
+          self->SendToServiceOrQueue(remote, llarp_buffer_t(pkt), proto);
+        });
+      }
+
+      std::string 
+      GetOurAddress() const 
+      {
+        return m_Identity.pub.Addr().ToString();
+      }
+    };
+
+    using PythonEndpoint_ptr = std::shared_ptr<PythonEndpoint>;
+  }
+}

pybind/llarp/tooling/router_hive.cpp

@@ -1,6 +1,7 @@
 #include "common.hpp"
 #include <tooling/router_hive.hpp>
-
+#include "llarp.hpp"
+#include "pybind11/iostream.h"
 namespace tooling
 {
   void
@@ -10,7 +11,19 @@ namespace tooling
     py::class_< RouterHive, RouterHive_ptr >(mod, "RouterHive")
         .def(py::init<>())
         .def("AddRouter", &RouterHive::AddRouter)
-        .def("StartAll", &RouterHive::StartRouters)
+        .def("StartAll", [](RouterHive_ptr self) {
+          self->StartRouters([](llarp_main * ctx) {
+            py::scoped_ostream_redirect stream_0(
+              std::cout,                          
+              py::module::import("sys").attr("stdout")
+            );
+            py::scoped_ostream_redirect stream_1(
+              std::cerr,
+              py::module::import("sys").attr("stderr") 
+            );
+            llarp_main_run(ctx, llarp_main_runtime_opts{false, false, false});
+          });
+        })
         .def("StopAll", &RouterHive::StopRouters)
         .def("ForEachRouter", &RouterHive::ForEachRouter)
         .def("VisitRouter", &RouterHive::VisitRouter)

pybind/module.cpp

@@ -1,4 +1,5 @@
 #include "common.hpp"
+#include "util/logging/logger.hpp"
 
 PYBIND11_MODULE(pyllarp, m)
 {
@@ -10,4 +11,8 @@ PYBIND11_MODULE(pyllarp, m)
   llarp::Config_Init(m);
   llarp::handlers::PyHandler_Init(m);
   llarp::service::Address_Init(m);
+  m.def("EnableDebug", []() {
+    llarp::SetLogLevel(llarp::eLogDebug);
+  });
+  
 }