Archives
/
lokinet
mirror of https://github.com/oxen-io/lokinet
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

unbreak router hive

Browse Source 
llarp/config/config.cpp:
respect [network]:type option

llarp/handlers/exit.cpp:
when [network]:type is null dont init tun interface

llarp/service/context.cpp:
respect [network]:type option
change endpoint name back to "default"

llarp/tooling/router_hive.cpp:
dont use LogicCall for obtaining RCs from underlying relays, it crashes the mainloop and it's probably safe to readonly access RCs.

pybind/common.hpp:
remove typecasters as we use C++17 now

pybind/llarp/config.cpp:
remove SnappConfig
wire up NetworkConfig

pybind/llarp/handlers/pyhandler.hpp:
remove SnappConfig from constructor

pybind/llarp/handlers/pyhandler.cpp:
update constructor implementation to match header

test/hive/hive.py:
remove broke endpoint related code
wire up null endpoint option using NetworkConfig
use index at 0 for relays and clients instead of 1
dont add a python endpoint to all clients
pull/1258/head
Jeff Becker 4 years ago
parent ed27d39817
commit 635dc4fe13
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05
9 changed files with 31 additions and 122 deletions
Show Stats Download Patch File Download Diff File

3
llarp/config/config.cpp
Unescape Escape View File

@ -146,6 +146,9 @@ namespace llarp
static constexpr int HopsDefault = 4;
static constexpr int PathsDefault = 6;
conf.defineOption<std::string>(
"network", "type", false, "tun", AssignmentAcceptor(m_endpointType));
conf.defineOption<bool>(
"network",
"profiling",

4
llarp/handlers/exit.cpp
Unescape Escape View File

@ -543,6 +543,10 @@ namespace llarp
return true;
}
*/
if (networkConfig.m_endpointType == "null")
{
m_ShouldInitTun = false;
}
m_LocalResolverAddr = dnsConfig.m_bind;
m_UpstreamResolvers = dnsConfig.m_upstreamDNS;

9
llarp/service/context.cpp
Unescape Escape View File

@ -174,17 +174,14 @@ namespace llarp
void
Context::AddEndpoint(const Config& conf, bool autostart)
{
// TODO: refactor Context to only contain one endpoint
constexpr auto endpointName = "endpoint";
constexpr auto endpointName = "default";
if (m_Endpoints.find(endpointName) != m_Endpoints.end())
throw std::invalid_argument("service::Context only supports one endpoint now");
// TODO: make endpoint type configurable [again]
std::string endpointType = DefaultEndpointType();
const auto& endpointType = conf.network.m_endpointType;
// use factory to create endpoint
const auto itr = endpointConstructors.find(DefaultEndpointType());
const auto itr = endpointConstructors.find(endpointType);
if (itr == endpointConstructors.end())
throw std::invalid_argument(stringify("Endpoint type ", endpointType, " does not exist"));

30
llarp/tooling/router_hive.cpp
Unescape Escape View File

@ -218,42 +218,14 @@ namespace tooling
{
std::vector<llarp::RouterContact> results;
results.resize(relays.size());
std::mutex results_lock;
size_t i = 0;
size_t done_count = 0;
for (auto relay : relays)
{
auto ctx = llarp::Context::Get(relay);
LogicCall(ctx->logic, [&]() {
llarp::RouterContact rc = ctx->router->rc();
std::lock_guard<std::mutex> guard{results_lock};
results[i] = std::move(rc);
done_count++;
});
results[i] = ctx->router->rc();
i++;
}
int numTries = 0;
size_t read_done_count = 0;
while (numTries < 100)
{
{
std::lock_guard<std::mutex> guard{results_lock};
read_done_count = done_count;
}
if (read_done_count == relays.size())
break;
std::this_thread::sleep_for(100ms);
numTries++;
}
if (read_done_count != relays.size())
{
LogWarn("could not read all relays, last done_count: ", read_done_count);
}
return results;
}

25
pybind/common.hpp
Unescape Escape View File

@ -3,35 +3,10 @@
#include <pybind11/stl.h>
#include <pybind11/functional.h>
#include <nonstd/optional.hpp>
#include <unordered_map>
namespace py = pybind11;
namespace pybind11
{
namespace detail
{
template <typename Key, typename Value, typename Hash, typename Equal, typename Alloc>
struct type_caster<std::unordered_multimap<Key, Value, Hash, Equal, Alloc>>
: map_caster<std::unordered_multimap<Key, Value, Hash, Equal, Alloc>, Key, Value>
{
};
template <typename T>
struct type_caster<nonstd::optional<T>> : public optional_caster<nonstd::optional<T>>
{
};
/*
template <typename CharT, class Traits>
struct type_caster<simple_string_view>
: string_caster<simple_string_view, true> {};
*/
} // namespace detail
} // namespace pybind11
namespace llarp
{

36
pybind/llarp/config.cpp
Unescape Escape View File

@ -20,13 +20,11 @@ namespace llarp
.def_readwrite("router", &Config::router)
.def_readwrite("network", &Config::network)
.def_readwrite("connect", &Config::connect)
.def_readwrite("dns", &Config::dns)
.def_readwrite("links", &Config::links)
.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);
@ -65,16 +63,21 @@ namespace llarp
.def(py::init<>())
.def_readwrite("enableProfiling", &NetworkConfig::m_enableProfiling)
.def_readwrite("routerProfilesFile", &NetworkConfig::m_routerProfilesFile)
.def_readwrite("strictConnect", &NetworkConfig::m_strictConnect)
.def_readwrite("options", &NetworkConfig::m_options);
.def_readwrite("endpointType", &NetworkConfig::m_endpointType)
.def_readwrite("keyfile", &NetworkConfig::m_keyfile)
.def_readwrite("endpointType", &NetworkConfig::m_endpointType)
.def_readwrite("reachable", &NetworkConfig::m_reachable)
.def_readwrite("hops", &NetworkConfig::m_hops)
.def_readwrite("paths", &NetworkConfig::m_paths)
.def_readwrite("snodeBlacklist", &NetworkConfig::m_snodeBlacklist)
.def_readwrite("mapAddr", &NetworkConfig::m_mapAddr)
.def_readwrite("strictConnect", &NetworkConfig::m_strictConnect);
py::class_<ConnectConfig>(mod, "ConnectConfig")
.def(py::init<>())
.def_readwrite("routers", &ConnectConfig::routers);
py::class_<DnsConfig>(mod, "DnsConfig")
.def(py::init<>())
.def_readwrite("options", &DnsConfig::m_options);
py::class_<DnsConfig>(mod, "DnsConfig").def(py::init<>());
py::class_<LinksConfig>(mod, "LinksConfig")
.def(py::init<>())
@ -120,25 +123,6 @@ 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)

2
pybind/llarp/handlers/pyhandler.cpp
Unescape Escape View File

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

6
pybind/llarp/handlers/pyhandler.hpp
Unescape Escape View File

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

38
test/hive/hive.py
Unescape Escape View File

@ -47,13 +47,6 @@ class RouterHive(object):
return False
def MakeEndpoint(self, router, after):
if router.IsRelay():
return
ep = pyllarp.Endpoint(self.endpointName, router)
router.AddEndpoint(ep)
if after is not None:
router.CallSafe(lambda : after(ep))
def AddRelay(self, index):
dirname = "%s/relays/%d" % (self.tmpdir, index)
@ -79,12 +72,12 @@ class RouterHive(object):
config.network.enableProfiling = False
config.network.routerProfilesFile = "%s/profiles.dat" % dirname
config.network.options = {"type": "null"}
config.network.endpointType = 'null'
config.links.addInboundLink("lo", AF_INET, port);
config.links.setOutboundLink("lo", AF_INET, port + 10000);
config.dns.options = {"local-dns": ("127.3.2.1:%d" % port)}
# config.dns.options = {"local-dns": ("127.3.2.1:%d" % port)}
if index != 0:
config.bootstrap.routers = ["%s/relays/0/self.signed" % self.tmpdir]
@ -111,11 +104,11 @@ class RouterHive(object):
config.network.enableProfiling = False
config.network.routerProfilesFile = "%s/profiles.dat" % dirname
config.network.options = {"type": "null"}
config.network.endpointType = 'null'
config.links.setOutboundLink("lo", AF_INET, port + 10000);
config.dns.options = {"local-dns": ("127.3.2.1:%d" % port)}
# config.dns.options = {"local-dns": ("127.3.2.1:%d" % port)}
config.bootstrap.routers = ["%s/relays/0/self.signed" % self.tmpdir]
@ -123,19 +116,6 @@ class RouterHive(object):
self.hive.AddClient(config)
def onGotEndpoint(self, ep):
addr = ep.OurAddress()
self.addrs.append(pyllarp.ServiceAddress(addr))
def sendToAddress(self, router, toaddr, pkt):
if router.IsRelay():
return
if router.TrySendPacket("default", toaddr, pkt):
print("sending {} bytes to {}".format(len(pkt), toaddr))
def broadcastTo(self, addr, pkt):
self.hive.ForEachRouter(lambda r : sendToAddress(r, addr, pkt))
def InitFirstRC(self):
print("Starting first router to init its RC for bootstrap")
self.hive = pyllarp.RouterHive()
@ -154,18 +134,15 @@ class RouterHive(object):
self.hive = pyllarp.RouterHive()
for i in range(1, self.n_relays + 1):
for i in range(0, self.n_relays):
self.AddRelay(i)
for i in range(1, self.n_clients + 1):
for i in range(0, self.n_clients):
self.AddClient(i)
print("Starting relays")
self.hive.StartRelays()
sleep(0.2)
self.hive.ForEachRelay(lambda r: self.MakeEndpoint(r, self.onGotEndpoint))
print("Sleeping 2 seconds before starting clients")
sleep(2)
@ -173,9 +150,6 @@ class RouterHive(object):
self.hive.StartClients()
sleep(0.2)
self.hive.ForEachClient(lambda r: self.MakeEndpoint(r, self.onGotEndpoint))
def Stop(self):
self.hive.StopAll()

Write Preview
Loading…
Cancel
Save