|
|
|
#ifndef LLARP_NODEDB_HPP
|
|
|
|
#define LLARP_NODEDB_HPP
|
|
|
|
|
|
|
|
#include <router_contact.hpp>
|
|
|
|
#include <router_id.hpp>
|
|
|
|
#include <util/common.hpp>
|
|
|
|
#include <util/fs.hpp>
|
|
|
|
#include <util/thread/threading.hpp>
|
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
5 years ago
|
|
|
#include <util/thread/annotations.hpp>
|
|
|
|
#include <dht/key.hpp>
|
|
|
|
#include <crypto/crypto.hpp>
|
|
|
|
|
|
|
|
#include <set>
|
|
|
|
#include <optional>
|
|
|
|
#include <unordered_set>
|
|
|
|
#include <unordered_map>
|
|
|
|
#include <utility>
|
|
|
|
#include <atomic>
|
|
|
|
|
|
|
|
namespace llarp
|
|
|
|
{
|
|
|
|
class Logic;
|
|
|
|
|
|
|
|
class NodeDB
|
|
|
|
{
|
|
|
|
struct Entry
|
|
|
|
{
|
|
|
|
const RouterContact rc;
|
|
|
|
llarp_time_t insertedAt;
|
|
|
|
explicit Entry(RouterContact rc);
|
|
|
|
};
|
|
|
|
using NodeMap = std::unordered_map<RouterID, Entry>;
|
|
|
|
|
|
|
|
NodeMap m_Entries;
|
|
|
|
|
|
|
|
const fs::path m_Root;
|
|
|
|
|
|
|
|
const std::function<void(std::function<void()>)> disk;
|
|
|
|
|
|
|
|
llarp_time_t m_NextFlushAt;
|
|
|
|
|
|
|
|
mutable util::NullMutex m_Access;
|
|
|
|
|
|
|
|
/// asynchronously remove the files for a set of rcs on disk given their public ident key
|
|
|
|
void
|
|
|
|
AsyncRemoveManyFromDisk(std::unordered_set<RouterID> idents) const;
|
|
|
|
|
|
|
|
/// get filename of an RC file given its public ident key
|
|
|
|
fs::path
|
|
|
|
GetPathForPubkey(RouterID pk) const;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit NodeDB(fs::path rootdir, std::function<void(std::function<void()>)> diskCaller);
|
|
|
|
|
|
|
|
/// load all entries from disk syncrhonously
|
|
|
|
void
|
|
|
|
LoadFromDisk();
|
|
|
|
|
|
|
|
/// explicit save all RCs to disk synchronously
|
|
|
|
void
|
|
|
|
SaveToDisk() const;
|
|
|
|
|
|
|
|
/// the number of RCs that are loaded from disk
|
|
|
|
size_t
|
|
|
|
NumLoaded() const;
|
|
|
|
|
|
|
|
/// do periodic tasks like flush to disk and expiration
|
|
|
|
void
|
|
|
|
Tick(llarp_time_t now);
|
|
|
|
|
|
|
|
/// find the absolute closets router to a dht location
|
|
|
|
RouterContact
|
|
|
|
FindClosestTo(dht::Key_t location) const;
|
|
|
|
|
|
|
|
/// find many routers closest to dht key
|
|
|
|
std::vector<RouterContact>
|
|
|
|
FindManyClosestTo(dht::Key_t location, uint32_t numRouters) const;
|
|
|
|
|
|
|
|
/// return true if we have an rc by its ident pubkey
|
|
|
|
bool
|
|
|
|
Has(RouterID pk) const;
|
|
|
|
|
|
|
|
/// maybe get an rc by its ident pubkey
|
|
|
|
std::optional<RouterContact>
|
|
|
|
Get(RouterID pk) const;
|
|
|
|
|
|
|
|
template <typename Filter>
|
|
|
|
std::optional<RouterContact>
|
|
|
|
GetRandom(Filter visit) const
|
|
|
|
{
|
|
|
|
util::NullLock lock{m_Access};
|
|
|
|
const auto sz = m_Entries.size();
|
|
|
|
if (sz < 3)
|
|
|
|
return std::nullopt;
|
|
|
|
const auto begin = m_Entries.begin();
|
|
|
|
const auto middle = std::next(m_Entries.begin(), randint() % sz);
|
|
|
|
|
|
|
|
for (auto itr = middle; itr != m_Entries.end(); ++itr)
|
|
|
|
{
|
|
|
|
if (visit(itr->second.rc))
|
|
|
|
return itr->second.rc;
|
|
|
|
}
|
|
|
|
for (auto itr = begin; itr != middle; ++itr)
|
|
|
|
{
|
|
|
|
if (visit(itr->second.rc))
|
|
|
|
return itr->second.rc;
|
|
|
|
}
|
|
|
|
return std::nullopt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// visit all entries
|
|
|
|
template <typename Visit>
|
|
|
|
void
|
|
|
|
VisitAll(Visit visit) const
|
|
|
|
{
|
|
|
|
util::NullLock lock{m_Access};
|
|
|
|
for (const auto& item : m_Entries)
|
|
|
|
{
|
|
|
|
visit(item.second.rc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// visit all entries inserted before a timestamp
|
|
|
|
template <typename Visit>
|
|
|
|
void
|
|
|
|
VisitInsertedBefore(Visit visit, llarp_time_t insertedBefore)
|
|
|
|
{
|
|
|
|
util::NullLock lock{m_Access};
|
|
|
|
for (const auto& item : m_Entries)
|
|
|
|
{
|
|
|
|
if (item.second.insertedAt < insertedBefore)
|
|
|
|
visit(item.second.rc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// remove an entry via its ident pubkey
|
|
|
|
void
|
|
|
|
Remove(RouterID pk);
|
|
|
|
|
|
|
|
/// remove an entry given a filter that inspects the rc
|
|
|
|
template <typename Filter>
|
|
|
|
void
|
|
|
|
RemoveIf(Filter visit)
|
|
|
|
{
|
|
|
|
util::NullLock lock{m_Access};
|
|
|
|
std::unordered_set<RouterID> removed;
|
|
|
|
auto itr = m_Entries.begin();
|
|
|
|
while (itr != m_Entries.end())
|
|
|
|
{
|
|
|
|
if (visit(itr->second.rc))
|
|
|
|
{
|
|
|
|
removed.insert(itr->second.rc.pubkey);
|
|
|
|
itr = m_Entries.erase(itr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
++itr;
|
|
|
|
}
|
|
|
|
if (not removed.empty())
|
|
|
|
AsyncRemoveManyFromDisk(std::move(removed));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// remove rcs that are not in keep and have been inserted before cutoff
|
|
|
|
void
|
|
|
|
RemoveStaleRCs(std::unordered_set<RouterID> keep, llarp_time_t cutoff);
|
|
|
|
|
|
|
|
/// put this rc into the cache if it is not there or newer than the one there already
|
|
|
|
void
|
|
|
|
PutIfNewer(RouterContact rc);
|
|
|
|
|
|
|
|
/// unconditional put of rc into cache
|
|
|
|
void
|
|
|
|
Put(RouterContact rc);
|
|
|
|
};
|
|
|
|
} // namespace llarp
|
|
|
|
#endif
|