Brendon Jones's blog
Finished adding the ability to set DSCP bits for all the amplet tests
individually as well as globally. Slightly tidied up the way the global
options are turned into individual test options now that there are a few
more of them.
Tidied up the management connections to try to reuse the existing SSL
connection that started the server, rather than always expecting a
separate connection (as is sometimes the case when run standalone). As
part of this, added SSL support to the standalone tests, so now they can
be run standalone with/without SSL, or using it to connect to a normal
Reworked the way watchdogs worked to make sure they will properly
monitor new server threads, or remotely scheduled tests. The central
watchdog management has now been replaced by a timer inside each
server/test process that will ensure the test completes on time.
Decided to start doing systemd scripts properly and wrote a service file
for the amplet client. Also slightly tweaked the debhelper scripts that
are run to make sure the client doesn't start without configuration and
end up reporting errors to systemd. Had to officially split the Debian
directories now for Wheezy and Jessie as they are starting to diverge
Started work on adding the ability to set the differentiated services
bits in the IP header for all of the AMP tests. This can be set at a
global level, or on a per test basis. So far only the icmp test will
obey the setting, I'll update the rest of the tests next week.
Spent some time trying to remove an unnecessary extra control connection
for tests involving servers started by a remote amplet client. It looks
like I should be able to reuse the connection used to start the server
as the ongoing control channel, but I'm not quite sure how to make this
work best with standalone tests (that expect the server to already be
running, and don't currently encrypt anything). I should be able to tell
if I have a secure control connection or not and take the appropriate
actions, but a bit more planning is required.
Finished moving the main control socket to use protocol buffers to start
test servers. Updated the control socket to accept multiple message
types and added the ability to run a one-off test remotely using the
control port on an amplet client. This needed a few more smarts to
decide where the results should be sent - to the broker, to a remote
user, or to stdout and to print them as appropriate.
Fixed a bug in the HTTP test where it couldn't match a URL with a
fetched object in the broken situation where the path was outside the
root (e.g. src="../images/foo.png" when already at the top level).
Updated the standalone tests to accept SSL options so that they can be
run targeting existing amplet2-clients, using the control socket to
start a test server.
Finished removing the test specific options from the main test
management protocol. Each test now deals with it's own options (if any)
that are embedded in the top level protocol buffer message.
Refactored the main loops of the throughput and udpstream tests to be a
lot more readable and to make it obvious what is going on for each of
the message types.
Lots of small fixes for things in the udpstream test - making sure
packet contents (timestamps etc) are sensible for both 32 and 64 bit
architectures, median/percentiles correctly calculated with small
numbers of packet delay variances.
Started work on moving the main control socket (used to start the test
servers, and soon, to run on-demand tests) to using protocol buffers.
Started to remove the test specific options that had crept into the
generic control message definitions. Unfortunately the protobuf-c
library doesn't appear to do extensions properly yet, so I've had to
work around that to embed test specific options inside the top level
Throughput test now uses protocol buffers for all of the messages
involved in arranging and reporting the test. This is all achieved
through the same functions used by the udpstream test, which should now
be generic enough that other tests requiring custom servers can be written.
Wrote a first pass at the save function for the udpstream test, which
may need some modification once database schemas for storing the results
Updated the UDP stream test to report on the different periods of lost
and received packets during the test, to show how any lost packets were
distributed (bursty, random, etc).
Updated the messaging to now include result packets to retrieve results
from the remote endpoint. These are combined with the local result set
so that results are reported for both test directions.
Lots of small fixes to make sure that the right things are happening -
packet sizes are correctly calculated, sockets are closed appropriately,
memory is tidied up.
Finished moving all the control connections to protocol buffers,
including sending a full set of test options to the server when the test
The udpstream test now calculates packet delay variation between
consecutive packets and reports summary statistics across the whole
stream. The test schedule (directions, sizes, etc) can now be controlled
properly on the client, which will inform the server of what it needs to
do and when.
Short week as I took two days off to move house.
Continued working on porting the udpstream test to the new amplet
client. Spent most of the time trying to combine the control protocol
from the throughput test and udpstream test into something nicely
generic that can be used with future test servers, instructing them on
when and how to send test flows. Also started to convert the control
channel to use protocol buffers so that interoperability is much easier.
Discovered that most of the extra latency and jitter I was observing is
being introduced by stateful firewalling along the path (and on the host
itself as well). I'm also possibly some overhead from routing lookups
for the first packet that uses a route but at that point the time scales
are getting quite small.
Started working on porting the udpstream test to the new amplet client.
The way it will work shares quite a few ideas with the existing
throughput test, so I'm also taking the time to move lots of code from
the throughput test into a library that both (and future) tests can use
to coordinate sending data and results.
Updated amplet client init scripts to return proper LSB error codes when
starting without configuration, so systemd no longer falsely believes
the client was started ok. Updated the key permissions for the puppet
configuration to enforce to match those of the amplet client packages.
Built new packages and deployed them for testing.
Spent some time investigating start-stop-daemon and killing process
groups. There doesn't appear to be any nice way to make this happen
without writing our own code to stop everything, which is starting to
look worthwhile to make sure everything is tidied up properly when using
Wrote functions to format raw AS traceroute and path length data for
download from the graph pages. Still need to do full IP path traceroutes.
Found some interesting results when comparing the amplet ICMP test with
a few other data sources. Something is introducing delay and jitter in
one that isn't present in the others. Spent some time looking at source
code and traces to try to figure out what is going on (unsuccessfully so
far, will continue on Monday).