mirror of
https://github.com/ZmnSCPxj/clboss.git
synced 2026-08-14 12:43:19 +02:00
383 lines
10 KiB
C++
383 lines
10 KiB
C++
#include"Boss/Mod/InternetConnectionMonitor.hpp"
|
|
#include"Boss/Mod/Rpc.hpp"
|
|
#include"Boss/Mod/Waiter.hpp"
|
|
#include"Boss/Msg/Init.hpp"
|
|
#include"Boss/Msg/InternetOnline.hpp"
|
|
#include"Boss/Msg/ListpeersAnalyzedResult.hpp"
|
|
#include"Boss/Msg/NeedsConnect.hpp"
|
|
#include"Boss/Msg/ProvideStatus.hpp"
|
|
#include"Boss/Msg/SolicitStatus.hpp"
|
|
#include"Boss/Msg/TaskCompletion.hpp"
|
|
#include"Boss/concurrent.hpp"
|
|
#include"Boss/log.hpp"
|
|
#include"Boss/random_engine.hpp"
|
|
#include"Ev/Io.hpp"
|
|
#include"Ev/ThreadPool.hpp"
|
|
#include"Ev/map.hpp"
|
|
#include"Jsmn/Object.hpp"
|
|
#include"Json/Out.hpp"
|
|
#include"Net/Connector.hpp"
|
|
#include"Net/SocketFd.hpp"
|
|
#include"S/Bus.hpp"
|
|
#include"Util/make_unique.hpp"
|
|
#include<algorithm>
|
|
#include<assert.h>
|
|
#include<iterator>
|
|
#include<random>
|
|
#include<string>
|
|
|
|
namespace {
|
|
|
|
/* How long before we timeout an LN-level ping attempt
|
|
* with a peer and consider it to have failed? */
|
|
auto const ln_ping_timeout = double(30.0);
|
|
|
|
/* List of servers that we try to connect to.
|
|
* When we think we might get disconnected, we select
|
|
* one of these by random and try to connect.
|
|
* If the connection succeeds we consider ourselves
|
|
* to be connected.
|
|
* If the connection fails we try *all* of the below
|
|
* and if at least one connects, we still consider
|
|
* ourselves to be connected.
|
|
*
|
|
* Note that we connect, then disconnect immediately.
|
|
* We just want to check the Internet, not spam these
|
|
* servers.
|
|
*
|
|
* It would probably be better to "just" IP-level `ping`
|
|
* the server, but that is suprisingly complicated.
|
|
* Either we require some kind of `ping` command and
|
|
* parse its output (including figuring out what
|
|
* exactly its arguments are, its version, the exact
|
|
* variant of the `ping` command, etc.), or we need to
|
|
* open an ICMP socket, which, depending on OS policies,
|
|
* might not be possible for non-root users (`ping` is
|
|
* traditionally a setuid program).
|
|
*/
|
|
auto const servers = std::vector<std::pair<std::string, int>>
|
|
{ {"www.duckduckgo.com", 443}
|
|
, {"www.google.com", 443}
|
|
, {"www.yahoo.com", 443}
|
|
, {"www.facebook.com", 443}
|
|
, {"www.amazon.com", 443}
|
|
, {"www.reddit.com", 443}
|
|
, {"www.twitter.com", 443}
|
|
, {"www.alibaba.com", 443}
|
|
, {"www.netflix.com", 443}
|
|
, {"www.baidu.com", 443}
|
|
, {"www.paypal.com", 443}
|
|
, {"www.microsoft.com", 443}
|
|
, {"www.mozilla.org", 443}
|
|
, {"1.1.1.1", 443}
|
|
, {"www.squareup.com", 443}
|
|
, {"wikipedia.org", 443}
|
|
, {"www.bitcoin.org", 443}
|
|
, {"bitcoinstats.com", 443}
|
|
, {"www.iana.org", 443}
|
|
, {"www.example.org", 443}
|
|
, {"github.com", 443}
|
|
, {"lightning.network", 443}
|
|
, {"www.blockstream.com", 443}
|
|
, {"acinq.co", 443}
|
|
};
|
|
auto dist = std::uniform_int_distribution<std::size_t>(
|
|
0, servers.size() - 1
|
|
);
|
|
|
|
}
|
|
|
|
namespace Boss { namespace Mod {
|
|
|
|
class InternetConnectionMonitor::Impl {
|
|
private:
|
|
S::Bus& bus;
|
|
Ev::ThreadPool& threadpool;
|
|
Boss::Mod::Waiter& waiter;
|
|
|
|
Net::Connector *connector;
|
|
Boss::Mod::Rpc *rpc;
|
|
|
|
bool online;
|
|
bool checking_connectivity;
|
|
|
|
void start() {
|
|
bus.subscribe< Msg::Init
|
|
>([this](Msg::Init const& init) {
|
|
connector = &init.connector;
|
|
rpc = &init.rpc;
|
|
checking_connectivity = true;
|
|
return Boss::concurrent(server_check());
|
|
});
|
|
bus.subscribe< Msg::ListpeersAnalyzedResult
|
|
>([this](Msg::ListpeersAnalyzedResult const& l) {
|
|
if (!connector || checking_connectivity)
|
|
return Ev::lift();
|
|
checking_connectivity = true;
|
|
|
|
/* Copy connected nodes. */
|
|
return periodic_check(l);
|
|
});
|
|
/* If the NeedsConnectSolicitor failed, it might be due to
|
|
* Internet connection problems. */
|
|
bus.subscribe< Msg::TaskCompletion
|
|
>([this](Msg::TaskCompletion const& comp) {
|
|
if (!connector || checking_connectivity)
|
|
return Ev::lift();
|
|
if (comp.comment != "NeedsConnectSolicitor")
|
|
return Ev::lift();
|
|
if (!comp.failed)
|
|
return Ev::lift();
|
|
checking_connectivity = true;
|
|
return server_check();
|
|
});
|
|
/* Report status. */
|
|
bus.subscribe< Msg::SolicitStatus
|
|
>([this](Msg::SolicitStatus const&) {
|
|
auto status = Json::Out()
|
|
.start_object()
|
|
.field( "connection"
|
|
, online ? std::string("online")
|
|
: std::string("offline")
|
|
)
|
|
.field( "checking_connectivity"
|
|
, checking_connectivity
|
|
)
|
|
.end_object()
|
|
;
|
|
return bus.raise(Msg::ProvideStatus{
|
|
"internet", std::move(status)
|
|
});
|
|
});
|
|
}
|
|
|
|
Ev::Io<void> server_check() {
|
|
/* No peers, so query connectivity via server connecting. */
|
|
return Ev::lift().then([this]() {
|
|
return check_server_connectivity()
|
|
.then([this](bool n_online) {
|
|
return set_online(n_online);
|
|
});
|
|
});
|
|
}
|
|
|
|
Ev::Io<bool> check_server_connectivity() {
|
|
assert(connector);
|
|
auto i = dist(Boss::random_engine);
|
|
return check_server(servers[i]).then([this, i](bool res) {
|
|
if (!res)
|
|
return Boss::log( bus, Debug
|
|
, "InternetConnectionMonitor: "
|
|
"Could not contact %s, "
|
|
"will contact other servers."
|
|
, servers[i].first.c_str()
|
|
).then([this]() {
|
|
return check_all_servers();
|
|
});
|
|
else
|
|
return Ev::lift(true);
|
|
});
|
|
}
|
|
Ev::Io<bool> check_all_servers() {
|
|
using std::placeholders::_1;
|
|
return Ev::map( std::bind(&Impl::check_server, this, _1)
|
|
, servers
|
|
).then([this](std::vector<bool> results) {
|
|
auto bitvector = std::string("");
|
|
/* If one of the servers passed, it turns out we
|
|
* are connected after all. */
|
|
auto res = false;
|
|
for (auto const& r : results) {
|
|
if (r) {
|
|
res = true;
|
|
bitvector += "1";
|
|
} else
|
|
bitvector += "0";
|
|
}
|
|
auto act = Ev::lift();
|
|
if (res)
|
|
act += Boss::log( bus, Debug
|
|
, "InternetConnectionMonitor: "
|
|
"Other server contacted, "
|
|
"we are online after all. "
|
|
"(%s)"
|
|
, bitvector.c_str()
|
|
);
|
|
else
|
|
act += Boss::log( bus, Debug
|
|
, "InternetConnectionMonitor: "
|
|
"Other servers also not "
|
|
"reached. (%s)"
|
|
, bitvector.c_str()
|
|
);
|
|
return std::move(act).then([res]() {
|
|
return Ev::lift(res);
|
|
});
|
|
});
|
|
}
|
|
Ev::Io<bool> check_server(std::pair<std::string, int> const& s) {
|
|
return threadpool.background<bool>([this, s]() {
|
|
auto fd = connector->connect(s.first, s.second);
|
|
return !!fd;
|
|
});
|
|
}
|
|
|
|
Ev::Io<void> set_online(bool n_online) {
|
|
auto was_online = online;
|
|
online = n_online;
|
|
|
|
auto act = Ev::lift();
|
|
act += Boss::log( bus, Info
|
|
, "InternetConnectionMonitor: %s."
|
|
, online ? "online" : "offline"
|
|
);
|
|
if (was_online != online)
|
|
act += bus.raise(Msg::InternetOnline{online});
|
|
if (online) {
|
|
checking_connectivity = false;
|
|
/* If we moved from offline->online,
|
|
* raise NeedsConnect to get us back
|
|
* to gossiping.
|
|
*/
|
|
if (!was_online)
|
|
act += bus.raise(Msg::NeedsConnect());
|
|
} else
|
|
act += offline_quick_loop();
|
|
return act;
|
|
}
|
|
|
|
/* If we are offline, we should keep trying to connect in a
|
|
* quick 5-second loop.
|
|
* This is not an attack on the rest of the Internet, because
|
|
* we are offline and cannot access it anyway. */
|
|
Ev::Io<void> offline_quick_loop() {
|
|
return waiter.wait(5.0).then([this]() {
|
|
return check_server_connectivity();
|
|
}).then([this](bool result) {
|
|
if (result)
|
|
return set_online(true);
|
|
else
|
|
return offline_quick_loop();
|
|
});
|
|
}
|
|
|
|
Ev::Io<void> periodic_check(Msg::ListpeersAnalyzedResult const& r) {
|
|
/* No connected peers?
|
|
* Query servers directly.
|
|
*/
|
|
if ( r.connected_channeled.empty()
|
|
&& r.connected_unchanneled.empty()
|
|
)
|
|
return Boss::concurrent(server_check());
|
|
|
|
/* Otherwise pick a random peer to ping. */
|
|
auto peers = std::vector<Ln::NodeId>();
|
|
std::copy( r.connected_channeled.begin()
|
|
, r.connected_channeled.end()
|
|
, std::back_inserter(peers)
|
|
);
|
|
std::copy( r.connected_unchanneled.begin()
|
|
, r.connected_unchanneled.end()
|
|
, std::back_inserter(peers)
|
|
);
|
|
auto dist_peers = std::uniform_int_distribution<std::size_t>(
|
|
0, peers.size() - 1
|
|
);
|
|
auto i = dist_peers(Boss::random_engine);
|
|
return Boss::concurrent(ln_ping_check(peers[i]));
|
|
}
|
|
|
|
Ev::Io<void> ln_ping_check(Ln::NodeId const& p) {
|
|
/* Prefer to check our connectivity by pinging a
|
|
* peer directly.
|
|
* Use a timeout from Mod::Waiter; on some systems,
|
|
* even if you are disconnected physically, TCP
|
|
* connections are still kept alive for some time,
|
|
* leading to long delays in the LN-level `ping`.
|
|
*/
|
|
return Ev::lift().then([this, p]() {
|
|
return waiter.timed( ln_ping_timeout
|
|
, do_ln_ping(p)
|
|
).catching< Waiter::TimedOut
|
|
>([](Waiter::TimedOut const& _) {
|
|
return Ev::lift(false);
|
|
});
|
|
}).then([this, p](bool online) {
|
|
if (online)
|
|
return Boss::log( bus, Debug
|
|
, "InternetConnectionMonitor: "
|
|
"ping %s success."
|
|
, std::string(p).c_str()
|
|
).then([this]() {
|
|
return set_online(true);
|
|
});
|
|
return Boss::log( bus, Debug
|
|
, "InternetConnectionMonitor: "
|
|
"ping %s failed."
|
|
, std::string(p).c_str()
|
|
).then([this]() {
|
|
/* Fall back to connecting to a server. */
|
|
return server_check();
|
|
});
|
|
});
|
|
}
|
|
|
|
Ev::Io<bool> do_ln_ping(Ln::NodeId const& p) {
|
|
return Ev::lift().then([this, p]() {
|
|
auto p_s = std::string(p);
|
|
auto presult = std::make_shared<bool>();
|
|
return rpc->command( "ping"
|
|
, Json::Out()
|
|
.start_object()
|
|
.field("id", p_s)
|
|
.end_object()
|
|
).then([](Jsmn::Object _) {
|
|
return Ev::lift(true);
|
|
}).catching<RpcError>([](RpcError const& e) {
|
|
return Ev::lift(false);
|
|
}).then([this, presult](bool result) {
|
|
*presult = result;
|
|
return Boss::log( bus, Debug
|
|
, "InternetConnectionMonitor: "
|
|
"do_ln_ping: ping %s."
|
|
, result ? "success" : "failed"
|
|
);
|
|
}).then([presult]() {
|
|
return Ev::lift(*presult);
|
|
});
|
|
});
|
|
}
|
|
|
|
public:
|
|
Impl() =delete;
|
|
explicit
|
|
Impl( S::Bus& bus_
|
|
, Ev::ThreadPool& threadpool_
|
|
, Boss::Mod::Waiter& waiter_
|
|
) : bus(bus_)
|
|
, threadpool(threadpool_)
|
|
, waiter(waiter_)
|
|
, connector(nullptr)
|
|
, online(false)
|
|
, checking_connectivity(false)
|
|
{ start(); }
|
|
|
|
bool is_online() const { return online; }
|
|
};
|
|
|
|
InternetConnectionMonitor::InternetConnectionMonitor
|
|
(InternetConnectionMonitor&& o)
|
|
: pimpl(std::move(o.pimpl)) { }
|
|
InternetConnectionMonitor::~InternetConnectionMonitor() { }
|
|
InternetConnectionMonitor::InternetConnectionMonitor
|
|
( S::Bus& bus
|
|
, Ev::ThreadPool& threadpool
|
|
, Boss::Mod::Waiter& waiter
|
|
) : pimpl(Util::make_unique<Impl>(bus, threadpool, waiter))
|
|
{ }
|
|
|
|
bool InternetConnectionMonitor::is_online() const {
|
|
return pimpl->is_online();
|
|
}
|
|
|
|
}}
|