Archives/lokinet
2
0
Fork 0
mirror of https://github.com/oxen-io/lokinet.git synced 2024-11-07 15:20:31 +00:00
Code Issues Projects Releases Wiki Activity
f35f7fe3f2
lokinet/llarp/router/rc_lookup_handler.cpp

457 lines
11 KiB
C++
Raw Normal View History

Lookup routers at maximum frequency of 10 minutes
2020-01-17 21:54:34 +00:00
#include <chrono>
standardize include format and pragma once All #ifndef guards on headers have been removed, I think, in favor of #pragma once Headers are now included as `#include "filename"` if the included file resides in the same directory as the file including it, or any subdirectory therein. Otherwise they are included as `#include <project/top/dir/relative/path/filename>` The above does not include system/os headers.
2021-03-09 22:24:35 +00:00
#include "rc_lookup_handler.hpp"
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
#include <llarp/link/contacts.hpp>
Nuked superfluous interface classes RIP: - i_link_manager - i_outbound_message_handler - i_gossiper - i_outbound_session_maker - i_rc_lookup_handler
2023-09-13 19:57:18 +00:00
#include <llarp/link/link_manager.hpp>
standardize include format and pragma once All #ifndef guards on headers have been removed, I think, in favor of #pragma once Headers are now included as `#include "filename"` if the included file resides in the same directory as the file including it, or any subdirectory therein. Otherwise they are included as `#include <project/top/dir/relative/path/filename>` The above does not include system/os headers.
2021-03-09 22:24:35 +00:00
#include <llarp/crypto/crypto.hpp>
#include <llarp/service/context.hpp>
#include <llarp/router_contact.hpp>
#include <llarp/util/types.hpp>
#include <llarp/util/thread/threading.hpp>
#include <llarp/nodedb.hpp>
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
#include "router.hpp"
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
#include <iterator>
#include <functional>
Randomize routers to explore in ExploreNetwork()
2020-01-16 02:16:18 +00:00
#include <random>
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
namespace llarp
{
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::add_valid_router(const RouterID& router)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
router_whitelist.insert(router);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::remove_valid_router(const RouterID& router)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
router_whitelist.erase(router);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
Oxend error ping + unfunded tracking Currently (from a recent PR) we aren't pinging oxend if not active, but that behaviour ended up being quite wrong because lokinet needs to ping even when decommissioned or deregistered (when decommissioned we need the ping to get commissioned again, and if not registered we need the ping to get past the "lokinet isn't pinging" nag screen to prepare a registration). This considerably revises the pinging behaviour: - We ping oxend *unless* there is a specific error with our connections (i.e. we *should* be establishing peer connections but don't have any) - If we do have such an error, we send a new oxend "error" ping to report the error to oxend and get oxend to hold off on sending uptime proofs. Along the way this also changes how we handle the current node state: instead of just tracking deregistered/decommissioned, we now track three states: - LooksRegistered -- which means the SN is known to the network (but not necessarily active or fully staked) - LooksFunded -- which means it is known *and* is fully funded, but not necessarily active - LooksDecommissioned -- which means it is known, funded, and not currently active (which implies decommissioned). The funded (or more precisely, unfunded) state is now tracked in rc_lookup_handler in a "greenlist" -- i.e. new SNs that are so new (i.e. "green") that they aren't even fully staked or active yet.
2022-10-14 23:55:21 +00:00
static void
loadColourList(std::unordered_set<RouterID>& beigelist, const std::vector<RouterID>& new_beige)
{
beigelist.clear();
beigelist.insert(new_beige.begin(), new_beige.end());
}
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::set_router_whitelist(
Oxend error ping + unfunded tracking Currently (from a recent PR) we aren't pinging oxend if not active, but that behaviour ended up being quite wrong because lokinet needs to ping even when decommissioned or deregistered (when decommissioned we need the ping to get commissioned again, and if not registered we need the ping to get past the "lokinet isn't pinging" nag screen to prepare a registration). This considerably revises the pinging behaviour: - We ping oxend *unless* there is a specific error with our connections (i.e. we *should* be establishing peer connections but don't have any) - If we do have such an error, we send a new oxend "error" ping to report the error to oxend and get oxend to hold off on sending uptime proofs. Along the way this also changes how we handle the current node state: instead of just tracking deregistered/decommissioned, we now track three states: - LooksRegistered -- which means the SN is known to the network (but not necessarily active or fully staked) - LooksFunded -- which means it is known *and* is fully funded, but not necessarily active - LooksDecommissioned -- which means it is known, funded, and not currently active (which implies decommissioned). The funded (or more precisely, unfunded) state is now tracked in rc_lookup_handler in a "greenlist" -- i.e. new SNs that are so new (i.e. "green") that they aren't even fully staked or active yet.
2022-10-14 23:55:21 +00:00
const std::vector<RouterID>& whitelist,
const std::vector<RouterID>& greylist,
const std::vector<RouterID>& greenlist)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
if (whitelist.empty())
use get_service_nodes rpc endpoint
2019-10-14 15:38:34 +00:00
return;
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
loadColourList(router_whitelist, whitelist);
loadColourList(router_greylist, greylist);
loadColourList(router_greenlist, greenlist);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
LogInfo("lokinet service node list now has ", router_whitelist.size(), " active routers");
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
Don't respect whitelist when we haven't received it yet
2020-01-16 04:12:38 +00:00
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::has_received_whitelist() const
Don't respect whitelist when we haven't received it yet
2020-01-16 04:12:38 +00:00
{
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
return not router_whitelist.empty();
Don't respect whitelist when we haven't received it yet
2020-01-16 04:12:38 +00:00
}
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::get_rc(const RouterID& router, RCRequestCallback callback, bool forceLookup)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
RouterContact remoteRC;
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (not forceLookup)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (const auto maybe = node_db->Get(router); maybe.has_value())
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
nodedb refactor * bump zmq static dep * lokimq -> oxenmq * llarp_nodedb -> llarp::NodeDB * remove all crufty api parts of NodeDB * make NodeDB rc selection api not suck * make path builder api not suck * propagate all above changes so that unit tests work and it all compiles
2021-02-02 14:35:40 +00:00
remoteRC = *maybe;
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (callback)
contrib/testnet: fix up testnet config generator to make super centralized topology llarp/context.cpp, llarp/nodedb.{h,c}pp: load netdb AFTER whitelist llarp/router/router.cpp: explore always llarp/router/{i,}rc_lookup_handler.{h,c}pp explore with whitelist, update routers with lookup before stale
2020-01-14 20:12:47 +00:00
{
callback(router, &remoteRC, RCRequestResult::Success);
}
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
finalize_request(router, &remoteRC, RCRequestResult::Success);
contrib/testnet: fix up testnet config generator to make super centralized topology llarp/context.cpp, llarp/nodedb.{h,c}pp: load netdb AFTER whitelist llarp/router/router.cpp: explore always llarp/router/{i,}rc_lookup_handler.{h,c}pp explore with whitelist, update routers with lookup before stale
2020-01-14 20:12:47 +00:00
return;
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
}
bool shouldDoLookup = false;
{
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
auto itr_pair = pending_callbacks.emplace(router, callback_que{});
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (callback)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
itr_pair.first->second.push_back(callback);
}
shouldDoLookup = itr_pair.second;
}
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (shouldDoLookup)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
auto fn = [this, router](const auto& res) { handle_dht_lookup_result(router, res); };
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
// if we are a client try using the hidden service endpoints
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (!isServiceNode)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
bool sent = false;
LogInfo("Lookup ", router, " anonymously");
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
hidden_service_context->ForEachService(
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
[&](const std::string&, const std::shared_ptr<service::Endpoint>& ep) -> bool {
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
const bool success = ep->LookupRouterAnon(router, fn);
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
sent = sent || success;
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return !success;
});
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (sent)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return;
LogWarn("cannot lookup ", router, " anonymously");
}
wawaweewa
2023-10-03 20:00:23 +00:00
if (not contacts->lookup_router(router))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
finalize_request(router, nullptr, RCRequestResult::RouterNotFound);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
Lookup routers at maximum frequency of 10 minutes
2020-01-17 21:54:34 +00:00
else
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
router_lookup_times[router] = std::chrono::steady_clock::now();
Lookup routers at maximum frequency of 10 minutes
2020-01-17 21:54:34 +00:00
}
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
}
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::is_grey_listed(const RouterID& remote) const
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (strict_connect_pubkeys.size() && strict_connect_pubkeys.count(remote) == 0
&& !is_remote_in_bootstrap(remote))
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
{
return false;
}
if (not useWhitelist)
return false;
util::Lock lock{_mutex};
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
return router_greylist.count(remote);
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
}
Oxend error ping + unfunded tracking Currently (from a recent PR) we aren't pinging oxend if not active, but that behaviour ended up being quite wrong because lokinet needs to ping even when decommissioned or deregistered (when decommissioned we need the ping to get commissioned again, and if not registered we need the ping to get past the "lokinet isn't pinging" nag screen to prepare a registration). This considerably revises the pinging behaviour: - We ping oxend *unless* there is a specific error with our connections (i.e. we *should* be establishing peer connections but don't have any) - If we do have such an error, we send a new oxend "error" ping to report the error to oxend and get oxend to hold off on sending uptime proofs. Along the way this also changes how we handle the current node state: instead of just tracking deregistered/decommissioned, we now track three states: - LooksRegistered -- which means the SN is known to the network (but not necessarily active or fully staked) - LooksFunded -- which means it is known *and* is fully funded, but not necessarily active - LooksDecommissioned -- which means it is known, funded, and not currently active (which implies decommissioned). The funded (or more precisely, unfunded) state is now tracked in rc_lookup_handler in a "greenlist" -- i.e. new SNs that are so new (i.e. "green") that they aren't even fully staked or active yet.
2022-10-14 23:55:21 +00:00
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::is_green_listed(const RouterID& remote) const
Oxend error ping + unfunded tracking Currently (from a recent PR) we aren't pinging oxend if not active, but that behaviour ended up being quite wrong because lokinet needs to ping even when decommissioned or deregistered (when decommissioned we need the ping to get commissioned again, and if not registered we need the ping to get past the "lokinet isn't pinging" nag screen to prepare a registration). This considerably revises the pinging behaviour: - We ping oxend *unless* there is a specific error with our connections (i.e. we *should* be establishing peer connections but don't have any) - If we do have such an error, we send a new oxend "error" ping to report the error to oxend and get oxend to hold off on sending uptime proofs. Along the way this also changes how we handle the current node state: instead of just tracking deregistered/decommissioned, we now track three states: - LooksRegistered -- which means the SN is known to the network (but not necessarily active or fully staked) - LooksFunded -- which means it is known *and* is fully funded, but not necessarily active - LooksDecommissioned -- which means it is known, funded, and not currently active (which implies decommissioned). The funded (or more precisely, unfunded) state is now tracked in rc_lookup_handler in a "greenlist" -- i.e. new SNs that are so new (i.e. "green") that they aren't even fully staked or active yet.
2022-10-14 23:55:21 +00:00
{
util::Lock lock{_mutex};
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
return router_greenlist.count(remote);
Oxend error ping + unfunded tracking Currently (from a recent PR) we aren't pinging oxend if not active, but that behaviour ended up being quite wrong because lokinet needs to ping even when decommissioned or deregistered (when decommissioned we need the ping to get commissioned again, and if not registered we need the ping to get past the "lokinet isn't pinging" nag screen to prepare a registration). This considerably revises the pinging behaviour: - We ping oxend *unless* there is a specific error with our connections (i.e. we *should* be establishing peer connections but don't have any) - If we do have such an error, we send a new oxend "error" ping to report the error to oxend and get oxend to hold off on sending uptime proofs. Along the way this also changes how we handle the current node state: instead of just tracking deregistered/decommissioned, we now track three states: - LooksRegistered -- which means the SN is known to the network (but not necessarily active or fully staked) - LooksFunded -- which means it is known *and* is fully funded, but not necessarily active - LooksDecommissioned -- which means it is known, funded, and not currently active (which implies decommissioned). The funded (or more precisely, unfunded) state is now tracked in rc_lookup_handler in a "greenlist" -- i.e. new SNs that are so new (i.e. "green") that they aren't even fully staked or active yet.
2022-10-14 23:55:21 +00:00
}
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::is_registered(const RouterID& remote) const
Oxend error ping + unfunded tracking Currently (from a recent PR) we aren't pinging oxend if not active, but that behaviour ended up being quite wrong because lokinet needs to ping even when decommissioned or deregistered (when decommissioned we need the ping to get commissioned again, and if not registered we need the ping to get past the "lokinet isn't pinging" nag screen to prepare a registration). This considerably revises the pinging behaviour: - We ping oxend *unless* there is a specific error with our connections (i.e. we *should* be establishing peer connections but don't have any) - If we do have such an error, we send a new oxend "error" ping to report the error to oxend and get oxend to hold off on sending uptime proofs. Along the way this also changes how we handle the current node state: instead of just tracking deregistered/decommissioned, we now track three states: - LooksRegistered -- which means the SN is known to the network (but not necessarily active or fully staked) - LooksFunded -- which means it is known *and* is fully funded, but not necessarily active - LooksDecommissioned -- which means it is known, funded, and not currently active (which implies decommissioned). The funded (or more precisely, unfunded) state is now tracked in rc_lookup_handler in a "greenlist" -- i.e. new SNs that are so new (i.e. "green") that they aren't even fully staked or active yet.
2022-10-14 23:55:21 +00:00
{
util::Lock lock{_mutex};
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
return router_whitelist.count(remote) || router_greylist.count(remote)
|| router_greenlist.count(remote);
Oxend error ping + unfunded tracking Currently (from a recent PR) we aren't pinging oxend if not active, but that behaviour ended up being quite wrong because lokinet needs to ping even when decommissioned or deregistered (when decommissioned we need the ping to get commissioned again, and if not registered we need the ping to get past the "lokinet isn't pinging" nag screen to prepare a registration). This considerably revises the pinging behaviour: - We ping oxend *unless* there is a specific error with our connections (i.e. we *should* be establishing peer connections but don't have any) - If we do have such an error, we send a new oxend "error" ping to report the error to oxend and get oxend to hold off on sending uptime proofs. Along the way this also changes how we handle the current node state: instead of just tracking deregistered/decommissioned, we now track three states: - LooksRegistered -- which means the SN is known to the network (but not necessarily active or fully staked) - LooksFunded -- which means it is known *and* is fully funded, but not necessarily active - LooksDecommissioned -- which means it is known, funded, and not currently active (which implies decommissioned). The funded (or more precisely, unfunded) state is now tracked in rc_lookup_handler in a "greenlist" -- i.e. new SNs that are so new (i.e. "green") that they aren't even fully staked or active yet.
2022-10-14 23:55:21 +00:00
}
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::is_path_allowed(const RouterID& remote) const
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (strict_connect_pubkeys.size() && strict_connect_pubkeys.count(remote) == 0
&& !is_remote_in_bootstrap(remote))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
return false;
}
if we look deregistered we will now: * not gossip our rc * not explore the network to prevent outbound session attempts * not establish sessions to other service nodes * close all open sessions we have to tell clients we don't want them * catch exceptions flushing peerdb in disk thread * don't connect out to non allowed routers * simplify logic in RCLookupHandler::RemoteIsAllowed() * add HaveReceivedWhitelist to I_RCLookupHandler base type * add LooksDeregistered to Router type that tells us if we think we are deregistered * don't allow building paths over us if we are deregistered
2021-05-11 13:10:16 +00:00
if (not useWhitelist)
return true;
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
if we look deregistered we will now: * not gossip our rc * not explore the network to prevent outbound session attempts * not establish sessions to other service nodes * close all open sessions we have to tell clients we don't want them * catch exceptions flushing peerdb in disk thread * don't connect out to non allowed routers * simplify logic in RCLookupHandler::RemoteIsAllowed() * add HaveReceivedWhitelist to I_RCLookupHandler base type * add LooksDeregistered to Router type that tells us if we think we are deregistered * don't allow building paths over us if we are deregistered
2021-05-11 13:10:16 +00:00
util::Lock lock{_mutex};
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
return router_whitelist.count(remote);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::is_session_allowed(const RouterID& remote) const
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (strict_connect_pubkeys.size() && strict_connect_pubkeys.count(remote) == 0
&& !is_remote_in_bootstrap(remote))
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
{
return false;
}
if (not useWhitelist)
return true;
util::Lock lock{_mutex};
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
return router_whitelist.count(remote) or router_greylist.count(remote);
separate white/grey list for active/decommissioned nodes. allow sessions to decommissioned nodes but not paths.
2021-06-07 14:57:33 +00:00
}
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::check_rc(const RouterContact& rc) const
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (not is_session_allowed(rc.pubkey))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
contacts->delete_rc_node_async(dht::Key_t{rc.pubkey});
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return false;
}
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
if (not rc.Verify(llarp::time_now_ms()))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
add short data fragments and rx replay filter
2019-08-28 11:02:00 +00:00
LogWarn("RC for ", RouterID(rc.pubkey), " is invalid");
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return false;
}
// update nodedb if required
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (rc.IsPublicRouter())
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
LogDebug("Adding or updating RC for ", RouterID(rc.pubkey), " to nodedb and dht.");
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
loop->call([rc, n = node_db] { n->PutIfNewer(rc); });
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
contacts->put_rc_node_async(rc);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
return true;
}
tracy lock contention testing and other fun things
2019-09-03 15:56:56 +00:00
size_t
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::num_strict_connect_routers() const
tracy lock contention testing and other fun things
2019-09-03 15:56:56 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
return strict_connect_pubkeys.size();
tracy lock contention testing and other fun things
2019-09-03 15:56:56 +00:00
}
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::get_random_whitelist_router(RouterID& router) const
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
const auto sz = router_whitelist.size();
auto itr = router_whitelist.begin();
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (sz == 0)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return false;
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (sz > 1)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
std::advance(itr, randint() % sz);
router = *itr;
return true;
}
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::check_renegotiate_valid(RouterContact newrc, RouterContact oldrc)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Miss Match demands her name be removed from the code (i.e. fix speeling mistack: missmatch -> mismatch)
2020-05-14 01:35:15 +00:00
// mismatch of identity ?
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (newrc.pubkey != oldrc.pubkey)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return false;
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (!is_session_allowed(newrc.pubkey))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return false;
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
auto func = [this, newrc] { check_rc(newrc); };
work_func(func);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
// update dht if required
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
if (contacts->rc_nodes()->HasNode(dht::Key_t{newrc.pubkey}))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
contacts->rc_nodes()->PutNode(newrc);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
// TODO: check for other places that need updating the RC
return true;
}
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::periodic_update(llarp_time_t now)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
// try looking up stale routers
nodedb refactor * bump zmq static dep * lokimq -> oxenmq * llarp_nodedb -> llarp::NodeDB * remove all crufty api parts of NodeDB * make NodeDB rc selection api not suck * make path builder api not suck * propagate all above changes so that unit tests work and it all compiles
2021-02-02 14:35:40 +00:00
std::unordered_set<RouterID> routersToLookUp;
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
node_db->VisitInsertedBefore(
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
[&](const RouterContact& rc) {
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (has_pending_lookup(rc.pubkey))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return;
routersToLookUp.insert(rc.pubkey);
},
now - RouterContact::UpdateInterval);
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
for (const auto& router : routersToLookUp)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
get_rc(router, nullptr, true);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
node_db->RemoveStaleRCs(boostrap_rid_list, now - RouterContact::StaleInsertionAge);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::explore_network()
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
const size_t known = node_db->NumLoaded();
if (bootstrap_rc_list.empty() && known == 0)
don't always use bootstrap when exploring
2020-01-23 17:49:33 +00:00
{
LogError("we have no bootstrap nodes specified");
}
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
else if (known <= bootstrap_rc_list.size())
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
for (const auto& rc : bootstrap_rc_list)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
LogInfo("Doing explore via bootstrap node: ", RouterID(rc.pubkey));
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
// TODO: replace this concept
// dht->ExploreNetworkVia(dht::Key_t{rc.pubkey});
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
}
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (useWhitelist)
contrib/testnet: fix up testnet config generator to make super centralized topology llarp/context.cpp, llarp/nodedb.{h,c}pp: load netdb AFTER whitelist llarp/router/router.cpp: explore always llarp/router/{i,}rc_lookup_handler.{h,c}pp explore with whitelist, update routers with lookup before stale
2020-01-14 20:12:47 +00:00
{
Lookup routers at maximum frequency of 10 minutes
2020-01-17 21:54:34 +00:00
static constexpr auto RerequestInterval = 10min;
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
static constexpr size_t LookupPerTick = 5;
Randomize routers to explore in ExploreNetwork()
2020-01-16 02:16:18 +00:00
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
std::vector<RouterID> lookupRouters;
Randomize routers to explore in ExploreNetwork()
2020-01-16 02:16:18 +00:00
lookupRouters.reserve(LookupPerTick);
Lookup routers at maximum frequency of 10 minutes
2020-01-17 21:54:34 +00:00
const auto now = std::chrono::steady_clock::now();
contrib/testnet: fix up testnet config generator to make super centralized topology llarp/context.cpp, llarp/nodedb.{h,c}pp: load netdb AFTER whitelist llarp/router/router.cpp: explore always llarp/router/{i,}rc_lookup_handler.{h,c}pp explore with whitelist, update routers with lookup before stale
2020-01-14 20:12:47 +00:00
{
// if we are using a whitelist look up a few routers we don't have
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
for (const auto& r : router_whitelist)
contrib/testnet: fix up testnet config generator to make super centralized topology llarp/context.cpp, llarp/nodedb.{h,c}pp: load netdb AFTER whitelist llarp/router/router.cpp: explore always llarp/router/{i,}rc_lookup_handler.{h,c}pp explore with whitelist, update routers with lookup before stale
2020-01-14 20:12:47 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (now > router_lookup_times[r] + RerequestInterval and not node_db->Has(r))
Lookup routers at maximum frequency of 10 minutes
2020-01-17 21:54:34 +00:00
{
lookupRouters.emplace_back(r);
}
contrib/testnet: fix up testnet config generator to make super centralized topology llarp/context.cpp, llarp/nodedb.{h,c}pp: load netdb AFTER whitelist llarp/router/router.cpp: explore always llarp/router/{i,}rc_lookup_handler.{h,c}pp explore with whitelist, update routers with lookup before stale
2020-01-14 20:12:47 +00:00
}
}
Randomize routers to explore in ExploreNetwork()
2020-01-16 02:16:18 +00:00
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (lookupRouters.size() > LookupPerTick)
Randomize routers to explore in ExploreNetwork()
2020-01-16 02:16:18 +00:00
{
fix issue #1562 * use csrng for std::shuffle
2021-03-18 21:36:53 +00:00
std::shuffle(lookupRouters.begin(), lookupRouters.end(), CSRNG{});
Randomize routers to explore in ExploreNetwork()
2020-01-16 02:16:18 +00:00
lookupRouters.resize(LookupPerTick);
}
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
for (const auto& r : lookupRouters)
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
get_rc(r, nullptr, true);
contrib/testnet: fix up testnet config generator to make super centralized topology llarp/context.cpp, llarp/nodedb.{h,c}pp: load netdb AFTER whitelist llarp/router/router.cpp: explore always llarp/router/{i,}rc_lookup_handler.{h,c}pp explore with whitelist, update routers with lookup before stale
2020-01-14 20:12:47 +00:00
return;
}
* get rid of dht explore for service nodes * add Time_t using std::chrono for future uses * make decaying hashset constructor with llarp_time_t explicit * add decaying hashset implicit constructor using Time_t * add timeouts for gossiper replay * allow regossip of our RC
2020-01-30 22:10:56 +00:00
// service nodes gossip, not explore
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
if (contacts->router()->IsServiceNode())
* get rid of dht explore for service nodes * add Time_t using std::chrono for future uses * make decaying hashset constructor with llarp_time_t explicit * add decaying hashset implicit constructor using Time_t * add timeouts for gossiper replay * allow regossip of our RC
2020-01-30 22:10:56 +00:00
return;
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
// explore via every connected peer
compiles, but does not link
2023-08-28 20:50:06 +00:00
/*
* TODO: DHT explore via libquic
*
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
_linkManager->ForEachPeer([&](ILinkSession* s) {
if (!s->IsEstablished())
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return;
const RouterContact rc = s->GetRemoteRC();
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (rc.IsPublicRouter() && (_bootstrapRCList.find(rc) == _bootstrapRCList.end()))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
s/LogInfo/LogDebug/ @ explore message
2020-02-06 18:57:39 +00:00
LogDebug("Doing explore via public node: ", RouterID(rc.pubkey));
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
_dht->impl->ExploreNetworkVia(dht::Key_t{rc.pubkey});
}
});
compiles, but does not link
2023-08-28 20:50:06 +00:00
*
*
*/
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::init(
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
std::shared_ptr<Contacts> c,
nodedb refactor * bump zmq static dep * lokimq -> oxenmq * llarp_nodedb -> llarp::NodeDB * remove all crufty api parts of NodeDB * make NodeDB rc selection api not suck * make path builder api not suck * propagate all above changes so that unit tests work and it all compiles
2021-02-02 14:35:40 +00:00
std::shared_ptr<NodeDB> nodedb,
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
EventLoop_ptr l,
worker_func dowork,
Nuked superfluous interface classes RIP: - i_link_manager - i_outbound_message_handler - i_gossiper - i_outbound_session_maker - i_rc_lookup_handler
2023-09-13 19:57:18 +00:00
LinkManager* linkManager,
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
service::Context* hiddenServiceContext,
nodedb refactor * bump zmq static dep * lokimq -> oxenmq * llarp_nodedb -> llarp::NodeDB * remove all crufty api parts of NodeDB * make NodeDB rc selection api not suck * make path builder api not suck * propagate all above changes so that unit tests work and it all compiles
2021-02-02 14:35:40 +00:00
const std::unordered_set<RouterID>& strictConnectPubkeys,
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
const std::set<RouterContact>& bootstrapRCList,
bool useWhitelist_arg,
bool isServiceNode_arg)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
contacts = c;
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
node_db = std::move(nodedb);
loop = std::move(l);
work_func = std::move(dowork);
hidden_service_context = hiddenServiceContext;
strict_connect_pubkeys = strictConnectPubkeys;
bootstrap_rc_list = bootstrapRCList;
link_manager = linkManager;
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
useWhitelist = useWhitelist_arg;
isServiceNode = isServiceNode_arg;
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
for (const auto& rc : bootstrap_rc_list)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
boostrap_rid_list.insert(rc.pubkey);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
}
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::handle_dht_lookup_result(
RouterID remote, const std::vector<RouterContact>& results)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (not results.size())
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
finalize_request(remote, nullptr, RCRequestResult::RouterNotFound);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return;
}
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (not is_session_allowed(remote))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
finalize_request(remote, &results[0], RCRequestResult::InvalidRouter);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return;
}
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (not check_rc(results[0]))
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
finalize_request(remote, &results[0], RCRequestResult::BadRC);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
return;
}
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
finalize_request(remote, &results[0], RCRequestResult::Success);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::has_pending_lookup(RouterID remote) const
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
return pending_callbacks.find(remote) != pending_callbacks.end();
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
bool
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::is_remote_in_bootstrap(const RouterID& remote) const
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
for (const auto& rc : bootstrap_rc_list)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
if (rc.pubkey == remote)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
return true;
}
}
return false;
}
void
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
RCLookupHandler::finalize_request(
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
const RouterID& router, const RouterContact* const rc, RCRequestResult result)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
callback_que movedCallbacks;
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
De-abseil, part 2: mutex, locks, (most) time - util::Mutex is now a std::shared_timed_mutex, which is capable of exclusive and shared locks. - util::Lock is still present as a std::lock_guard<util::Mutex>. - the locking annotations are preserved, but updated to the latest supported by clang rather than using abseil's older/deprecated ones. - ACQUIRE_LOCK macro is gone since we don't pass mutexes by pointer into locks anymore (WTF abseil). - ReleasableLock is gone. Instead there are now some llarp::util helper methods to obtain unique and/or shared locks: - `auto lock = util::unique_lock(mutex);` gets an RAII-but-also unlockable object (std::unique_lock<T>, with T inferred from `mutex`). - `auto lock = util::shared_lock(mutex);` gets an RAII shared (i.e. "reader") lock of the mutex. - `auto lock = util::unique_locks(mutex1, mutex2, mutex3);` can be used to atomically lock multiple mutexes at once (returning a tuple of the locks). This are templated on the mutex which makes them a bit more flexible than using a concrete type: they can be used for any type of lockable mutex, not only util::Mutex. (Some of the code here uses them for getting locks around a std::mutex). Until C++17, using the RAII types is painfully verbose: ```C++ // pre-C++17 - needing to figure out the mutex type here is annoying: std::unique_lock<util::Mutex> lock(mutex); // pre-C++17 and even more verbose (but at least the type isn't needed): std::unique_lock<decltype(mutex)> lock(mutex); // our compromise: auto lock = util::unique_lock(mutex); // C++17: std::unique_lock lock(mutex); ``` All of these functions will also warn (under gcc or clang) if you discard the return value. You can also do fancy things like `auto l = util::unique_lock(mutex, std::adopt_lock)` (which lets a lock take over an already-locked mutex). - metrics code is gone, which also removes a big pile of code that was only used by metrics: - llarp::util::Scheduler - llarp::thread::TimerQueue - llarp::util::Stopwatch
2020-02-21 17:21:11 +00:00
util::Lock l(_mutex);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
auto itr = pending_callbacks.find(router);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
if (itr != pending_callbacks.end())
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
movedCallbacks.splice(movedCallbacks.begin(), itr->second);
Deleted a lot - RIP llarp/iwp/* and most of llarp/link
2023-09-15 14:55:32 +00:00
pending_callbacks.erase(itr);
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
}
} // lock
The Great Wall of Blame This commit reflects changes to clang-format rules. Unfortunately, these rule changes create a massive change to the codebase, which causes an apparent rewrite of git history. Git blame's --ignore-rev flag can be used to ignore this commit when attempting to `git blame` some code.
2020-04-07 18:38:56 +00:00
for (const auto& callback : movedCallbacks)
Refactor Router code into more classes This commit refactors functionality from the Router class into separate, dedicated classes. There are a few behavior changes that came as a result of discussion on what the correct behavior should be. In addition, many things Router was previously doing can now be provided callback functions to alert the calling point when the asynchronous action completes, successfully or otherwise.
2019-06-26 21:39:29 +00:00
{
callback(router, rc, result);
}
}
} // namespace llarp
Reference in New Issue Copy Permalink