lokinet/llarp/path/pathset.cpp

381 lines
8.8 KiB
C++
Raw Normal View History

2019-01-11 01:19:36 +00:00
#include <path/pathset.hpp>
2018-12-12 00:48:54 +00:00
#include <dht/messages/pubintro.hpp>
2019-01-11 01:19:36 +00:00
#include <path/path.hpp>
#include <routing/dht_message.hpp>
namespace llarp
{
namespace path
{
2019-07-18 16:28:17 +00:00
PathSet::PathSet(size_t num) : numPaths(num)
{
}
bool
2018-10-29 16:48:36 +00:00
PathSet::ShouldBuildMore(llarp_time_t now) const
{
2019-04-23 16:13:22 +00:00
(void)now;
2019-04-22 19:15:07 +00:00
const auto building = NumInStatus(ePathBuilding);
2019-07-18 16:28:17 +00:00
if(building > numPaths)
2019-04-22 19:15:07 +00:00
return false;
const auto established = NumInStatus(ePathEstablished);
2019-07-18 16:28:17 +00:00
return established <= numPaths;
}
2018-11-14 18:02:27 +00:00
bool
PathSet::ShouldBuildMoreForRoles(llarp_time_t now, PathRole roles) const
{
Lock_t l(&m_PathsMutex);
2018-11-14 18:02:27 +00:00
const size_t required = MinRequiredForRoles(roles);
size_t has = 0;
for(const auto& item : m_Paths)
{
2018-11-21 12:31:36 +00:00
if(item.second->SupportsAnyRoles(roles))
2018-11-14 18:02:27 +00:00
{
if(!item.second->ExpiresSoon(now))
++has;
}
}
return has < required;
}
size_t
PathSet::MinRequiredForRoles(PathRole roles) const
{
2018-11-19 16:48:35 +00:00
(void)roles;
return 0;
2018-11-14 18:02:27 +00:00
}
2018-11-26 13:30:03 +00:00
size_t
PathSet::NumPathsExistingAt(llarp_time_t futureTime) const
2018-11-25 16:58:27 +00:00
{
size_t num = 0;
Lock_t l(&m_PathsMutex);
2018-11-26 13:30:03 +00:00
for(const auto& item : m_Paths)
2018-11-25 16:58:27 +00:00
{
if(item.second->IsReady() && !item.second->Expired(futureTime))
2018-11-25 16:58:27 +00:00
++num;
}
return num;
}
void
2019-04-23 16:13:22 +00:00
PathSet::TickPaths(llarp_time_t now, AbstractRouter* r)
{
Lock_t l(&m_PathsMutex);
for(auto& item : m_Paths)
{
item.second->Tick(now, r);
}
}
void
PathSet::ExpirePaths(llarp_time_t now)
{
Lock_t l(&m_PathsMutex);
if(m_Paths.size() == 0)
return;
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
if(itr->second->Expired(now))
itr = m_Paths.erase(itr);
else
++itr;
}
}
Path_ptr
2018-12-18 18:36:19 +00:00
PathSet::GetEstablishedPathClosestTo(RouterID id, PathRole roles) const
2018-08-01 22:10:38 +00:00
{
Lock_t l(&m_PathsMutex);
Path_ptr path = nullptr;
AlignedBuffer< 32 > dist;
AlignedBuffer< 32 > to = id;
2018-08-01 22:10:38 +00:00
dist.Fill(0xff);
for(const auto& item : m_Paths)
{
if(!item.second->IsReady())
continue;
2018-11-21 12:31:36 +00:00
if(!item.second->SupportsAnyRoles(roles))
2018-11-14 18:02:27 +00:00
continue;
AlignedBuffer< 32 > localDist = item.second->Endpoint() ^ to;
2018-08-01 22:10:38 +00:00
if(localDist < dist)
{
dist = localDist;
path = item.second;
}
}
return path;
}
Path_ptr
2018-12-18 18:36:19 +00:00
PathSet::GetNewestPathByRouter(RouterID id, PathRole roles) const
{
Lock_t l(&m_PathsMutex);
Path_ptr chosen = nullptr;
2019-04-23 16:13:22 +00:00
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
2018-11-21 12:31:36 +00:00
if(itr->second->IsReady() && itr->second->SupportsAnyRoles(roles))
{
if(itr->second->Endpoint() == id)
{
if(chosen == nullptr)
chosen = itr->second;
else if(chosen->intro.expiresAt < itr->second->intro.expiresAt)
chosen = itr->second;
}
}
++itr;
}
return chosen;
}
Path_ptr
2018-12-18 18:36:19 +00:00
PathSet::GetPathByRouter(RouterID id, PathRole roles) const
2018-07-22 23:14:29 +00:00
{
Lock_t l(&m_PathsMutex);
Path_ptr chosen = nullptr;
2019-04-23 16:13:22 +00:00
auto itr = m_Paths.begin();
2018-07-22 23:14:29 +00:00
while(itr != m_Paths.end())
{
2018-11-21 12:31:36 +00:00
if(itr->second->IsReady() && itr->second->SupportsAnyRoles(roles))
{
if(itr->second->Endpoint() == id)
{
if(chosen == nullptr)
chosen = itr->second;
else if(chosen->intro.latency > itr->second->intro.latency)
chosen = itr->second;
}
}
2018-07-22 23:14:29 +00:00
++itr;
}
return chosen;
2018-07-22 23:14:29 +00:00
}
Path_ptr
2019-03-08 17:26:29 +00:00
PathSet::GetByEndpointWithID(RouterID ep, PathID_t id) const
{
Lock_t l(&m_PathsMutex);
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
if(itr->second->IsEndpoint(ep, id))
{
return itr->second;
}
++itr;
}
return nullptr;
}
Path_ptr
2018-12-18 18:36:19 +00:00
PathSet::GetPathByID(PathID_t id) const
2018-08-10 21:34:11 +00:00
{
Lock_t l(&m_PathsMutex);
2018-08-10 21:34:11 +00:00
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
if(itr->second->RXID() == id)
return itr->second;
++itr;
}
return nullptr;
}
2018-11-16 14:06:50 +00:00
size_t
PathSet::AvailablePaths(PathRole roles) const
{
Lock_t l(&m_PathsMutex);
2018-11-16 14:06:50 +00:00
size_t count = 0;
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
if(itr->second->Status() == ePathEstablished
2018-11-21 12:31:36 +00:00
&& itr->second->SupportsAnyRoles(roles))
2018-11-16 14:06:50 +00:00
++count;
++itr;
}
return count;
}
size_t
PathSet::NumInStatus(PathStatus st) const
{
Lock_t l(&m_PathsMutex);
size_t count = 0;
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
2018-11-14 18:02:27 +00:00
if(itr->second->Status() == st)
++count;
++itr;
}
return count;
}
void
PathSet::AddPath(Path_ptr path)
{
Lock_t l(&m_PathsMutex);
2018-11-03 13:19:18 +00:00
auto upstream = path->Upstream(); // RouterID
auto RXID = path->RXID(); // PathID
m_Paths.emplace(std::make_pair(upstream, RXID), std::move(path));
}
void
PathSet::RemovePath(Path_ptr path)
{
Lock_t l(&m_PathsMutex);
m_Paths.erase({path->Upstream(), path->RXID()});
}
Path_ptr
2018-12-18 18:36:19 +00:00
PathSet::GetByUpstream(RouterID remote, PathID_t rxid) const
{
Lock_t l(&m_PathsMutex);
auto itr = m_Paths.find({remote, rxid});
if(itr == m_Paths.end())
return nullptr;
return itr->second;
}
bool
PathSet::GetCurrentIntroductionsWithFilter(
std::set< service::Introduction >& intros,
std::function< bool(const service::Introduction&) > filter) const
{
intros.clear();
size_t count = 0;
Lock_t l(&m_PathsMutex);
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
if(itr->second->IsReady() && filter(itr->second->intro))
{
intros.insert(itr->second->intro);
++count;
}
++itr;
}
return count > 0;
}
2018-07-09 17:32:11 +00:00
bool
PathSet::GetCurrentIntroductions(
std::set< service::Introduction >& intros) const
{
2018-07-17 06:17:13 +00:00
intros.clear();
size_t count = 0;
Lock_t l(&m_PathsMutex);
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
if(itr->second->IsReady())
{
2018-07-19 04:58:39 +00:00
intros.insert(itr->second->intro);
++count;
}
++itr;
}
return count > 0;
}
void
PathSet::HandlePathBuildTimeout(Path_ptr p)
{
LogWarn(Name(), " path build ", p->HopsString(), " timed out");
2019-07-01 13:44:25 +00:00
m_BuildStats.timeouts++;
}
void
PathSet::HandlePathBuildFailed(Path_ptr p)
{
LogWarn(Name(), " path build ", p->HopsString(), " failed");
m_BuildStats.fails ++;
}
2019-07-01 13:44:25 +00:00
void
PathSet::PathBuildStarted(Path_ptr p)
{
LogInfo(Name(), " path build ", p->HopsString(), " started");
m_BuildStats.attempts++;
}
util::StatusObject
BuildStats::ExtractStatus() const
{
return util::StatusObject{{"success", success},
{"attempts", attempts},
{"timeouts", timeouts},
{"fails", fails}};
}
std::string
BuildStats::ToString() const
{
std::stringstream ss;
ss << (SuccsessRatio() * 100.0) << " percent success ";
2019-07-01 13:44:25 +00:00
ss << "(success=" << success << " ";
ss << "attempts=" << attempts << " ";
ss << "timeouts=" << timeouts << " ";
ss << "fails=" << fails << ")";
return ss.str();
}
double
BuildStats::SuccsessRatio() const
{
if(attempts)
return double(success) / double(attempts);
return 0.0;
}
bool
PathSet::GetNewestIntro(service::Introduction& intro) const
{
2018-09-27 11:03:01 +00:00
intro.Clear();
bool found = false;
Lock_t l(&m_PathsMutex);
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
if(itr->second->IsReady()
&& itr->second->intro.expiresAt > intro.expiresAt)
{
intro = itr->second->intro;
found = true;
}
++itr;
}
return found;
}
Path_ptr
2018-11-14 18:02:27 +00:00
PathSet::PickRandomEstablishedPath(PathRole roles) const
{
std::vector< Path_ptr > established;
Lock_t l(&m_PathsMutex);
auto itr = m_Paths.begin();
while(itr != m_Paths.end())
{
2018-11-21 12:31:36 +00:00
if(itr->second->IsReady() && itr->second->SupportsAnyRoles(roles))
established.push_back(itr->second);
++itr;
}
auto sz = established.size();
if(sz)
{
return established[randint() % sz];
}
2019-07-06 17:03:40 +00:00
return nullptr;
}
} // namespace path
} // namespace llarp