Neubot/ released

@neubotNeubot icon

Version is the latest generally-available stable release of Neubot, distributed for Ubuntu >= 12.04, MacOSX >= 10.6, Windows >= XP SP3 and FreeBSD, as well as in source format.

Here's what changed in less than 140 characters: new MPEG DASH test, support for tests as plugins, improved results.html, Lisp-like mini-language to gen. plots, fixes.

Install, upgrade instructions at <>. Read on for more details.

This release contains 237 commits by 2 authors. The diffstat says: 177 changed files with 14,148 additions and 7,721 deletions.

Here is the list of what changed and why:

  • New MPEG DASH test.

    This new test emulates the MPEG DASH HTTP-based streaming solution (and international standard); DASH is, in fact, the acronym of Dynamic Adaptive Streaming over HTTP.

    The server side of the DASH test emulates an HTTP server that exports a video resource composed of fifteen two-second segments of video, each encoded using a wide range of rates (from 100 Kbit/s to 20 Mbit/s). The client side requests all the segments of the video, and selects for each segment the highest available rate that is lower than the available bandwidth (estimated during the download of the previous segment). Therefore, the test should not create too much queue (and extra delay) at the bottleneck (typically the gateway).

    We will be more precise with a follow-up blog post dedicated to the impact of the DASH test on the Neubot user's quality of experience (QoE). Here it suffices to say that, as far as we can tell and as far as we experimented, such impact is low, unless one plays online games like WoW (in such case all the Neubot tests probably have an impact on the QoE, because all the tests generate extra delay every half an hour for 10-20 second).

  • Support for tests as plugins.

    The new DASH test is the first Neubot test written as a plugin (to be precise, the plugin is bundled with the Neubot distribution but not directly linked with the core of Neubot). To interact with the DASH code, in fact, Neubot does not cherry-pick functions, variables, and classes from the mod_dash directory with the import statement. Rather, Neubot calls the modprobe() function that asks the mod_load() function of the DASH plugin to perform certain actions (e.g., register the DASH test).

    The practical advantage of the modprobe() function is that Neubot is now more cleanly separated from its plugins. Therefore, it should be simpler to write new plugins, because the communication between a plugin and the core is now more formalized. Also, it should be possible to develop Neubot and its plugins separately (as long as the mod_load() interface remains the same).

  • Improved results.html (and /api/results).

    We rewrote the code that generates plots and tables in the results.html page. In particular we modified the implementation of the /api/results API, which now loads the specification of the tests from the www/test directory. Such directory contains an HTML and a JSON file for each test: the HTML file contains the description of the test, the JSON file contains the rules to transform the results of tests into plots and tables (see, for example, the HTML and the JSON file of the RAW test). To express the rules, we use the Lisp-like mini-language that is described next.

  • Lisp-like mini-language to generate plots.

    To express the rules that describe how to transform the result of a test into a plot or into a table, we designed a simple Lisp-like mini-language. The mini-language is similar to the Lisp, because a mini-language program is a possibly-nested list of instructions. We decided to pattern the mini-language after the Lisp, because we needed to embed the language into a JSON document. Therefore, a language in which everything is a list is a good choice, because the list is a native JSON type.

    The field that contains the mini-language program is called "recipe". To read more on the mini-language, please refer to the manual page and to the mini-language implementation itself.

  • Use pickle to save the DASH test results.

    We added code to the Neubot backend to store/load the results of a generic test using pickle (as opposed to sqlite3). The new DASH test is, for now, the only test that takes advantage of this opportunity, but we will switch to pickle all the other tests too.

    The advantages of using pickle, instead of sqlite3, are that we are not constrained by a rigid schema and that we can implement a circular buffer (which saves the result of the latest N tests only) in a more efficient way. The disadvantage of abandoning the sqlite3 implementation is that it will be more complex to perform queries, but we don't miss the querying capability that much, because we only and always query the most recent results.

    The idea of using pickle to implement a circular buffer was proposed and drafted by Dash Elhauge during his internship at the Nexa Center.

  • Add (on Linux and BSD systems) the /etc/neubot/api and the /etc/neubot/users new configuration files.

  • Make sure that all the tests have the same command line interface and optimize the options of the most frequently used subcommands (see the SUBCOMMANDS section of the manual page for more info).

  • Adapt Neubot to the new deployment process used by Measurement Lab.

  • Tweak the probability that a test is run to give the priority to the DASH test (see neubot/ for more info).

  • Improved FAQ and manual page.

  • Removed the unmaintained code to generate an ArchLinux package.

  • More cleanups and bug fixes.

- - -

Diff since previous version here:

Commit history here:

Errata here:

Data here:

Pubkey here:

Git repositories here: