The base image can get out of date.

Add python packages to ci images

Installs just the base tools (which are quite substantial), but not the
deps (which get installed as part of the build).

Shows statuses that "fill in" when run interactively.

Bionic is broken and needs a hack to create some dumb pgm include
directory.

Add --distro cli argument so that you can rebuild just one distro.

bump libunbound static dep hashpin

…-10-22

check for intersecting ip ranges correctly, add unit test

Generate CI images with much DRY-er Python dockerfile generating script

… them marked as failing anymore

…021-10-29

exclude fully failed nodes from service node testing list

call_soon wakes up the mainloop and is often reentrant, we dont want to
ever way up the event loop but we also want to always defer the call so
we always use the workers

If full happens we are going to trigger a bunch of flushes which
probably isn't very useful, so drop instead.

- Modernize some iterator loops
- Simplify a couple places by using `if (init; ...)`
- Replace various std::binds with lambdas

This redoes how/when we pump so that we should only be calling the
idempotent PumpLL() when we actually have (or may have) something to
pump.

We trigger a pump immediately, but this is racey because we add to our
plaintext data in a worker thread; if the worker thread runs after the
pump then it ends up leaving plaintext to be handled, but there's no
wakeup until the next one.

This was the cause of seeing a random +1s and bunching added to ping
responses sometimes: it wasn't until the *next* ping goes through the
network that the plaintext queue gets processed, at which point it
flushes the old one and often the new one together.

The fix here gets rid of the map of sessions needing wakeups and instead
adds an atomic flag to all of them to let us figure out which ones
need to be flushed.

If something needs to wake up the event loop it should be using an
async, as we are now with PumpLL(); but we had various code triggering a
wakeup, expecting that PumpLL gets called on every wakeup, which isn't
true anymore.

And rename the actual pump implementation back to PumpLL.

In testing we were sometimes hitting a full queue error, which makes
sense because the queue size seems really small.

Increase it to 512.

- Make the main PumpLL also pump hidden services, rather than using
  separate wakers in each TunEndpoint.  It seems there is some
  interactions that just one or the other is not enough.

- Eliminate TunEndpoint send queue -- it isn't needed as we can just
  send directly.

This has to happen before pumping links because it is putting things on
links.

The TriggerPump just below this is *already* going to trigger a flush,
so the extra flush call here can't do anything useful (and in
particular, it won't clear up the queue *immediately*, which is what
this code looks like it was aimed at doing).

- Replace m_FlushWakeup with a call to the router's god mode pump
  method.  m_FlushWakeup apparently isn't enough to get things out, and
  we can end up with incoming packets that don't get properly handled
  right away without it.

- The shared_ptr around the ihophandler queues isn't needed and is just
  adding a layer of obfuscation; instead just exchange the list directly
  into the lambda.

- Use std::exchange rather than swap

- A couple other small code cleanups.

This test isn't very useful, but also broken with the other changes on
this branch.

…11-09

make PumpLL idempotent to reduce cpu use a bit

We're seeing overhead here of the std::function invocation, which we can
easily avoid in this case by not using a std::function around the
callback.

Avoid std::function in hot pump code

We have a few cases where we're making an extra shared_ptr which we copy
into a lambda, which then results in an extra unnecessary refcount
decrement in the parent; this changes them to give an rvalue reference
to the lambda to avoid the extra incr/decr instead.

The one in Session::Pump is particularly noticeable and shows up in
profiling.

We are calling time_now() a huge amount, and it is a major consumer of
CPU cycles, but we don't need it: most of the time the current event
loop time is enough.

Random optimizations

…ndle a bootstrap.signed

…otstrap-2021-11-16

disable lokinet-bootstrap in static linux ci pipeline