v0.2.0

Release 0.2 "Time and noise". This is the state of 0.2.0-rc.1; the release only removes the notes that say it is a candidate.

A link can change while a run goes (a rate that drops, an outage, a link that goes down and up), and the same seed still gives the same lost packets. There are more impairments: burst loss (Gilbert-Elliott and four states), reordering, duplication and corruption, and a stream can be sent without the UDP checksum so that a damaged packet arrives and is counted. There is more traffic: Poisson, on/off and bursty streams. A node can run your own program, started in order, waited for, supervised, with its output and its metrics in the result, and a link can be captured as pcap files. A result has more statistics (the extent of reordering, the interarrival jitter, the runs of lost packets), a series by time bin in two views (what was sent and what arrived) and the time to recover after each event. Several runs with seeds derived from one seed give confidence intervals (a seeded bootstrap with its measured coverage, docs/STATISTICS.md), a run can be replayed from its directory, and reports are made as Markdown, JUnit and one HTML file (docs/REPORTS.md). All of it works from the command line, from Python and as pytest tests. The release files carry an attestation of their provenance, and the parsers of input that is not trusted are fuzzed every week. The README says what 0.2 does and does not do yet, and docs/ACCEPTANCE.md how each criterion of the release is proven.

Breaking. The format of the scenario file and of the result is version 0, which a minor release may change (docs/VERSIONING.md): the files of 0.1 still read and run, and the result has new fields. What breaks is the Rust API of netscenario-model and netscenario-core (#50, #52, #53, #55, #61, #76, #79, #80):

• The result types are non_exhaustive (#50), so that a new field is no longer a break from now on.
• Loss is an enum and not a struct (#52); Scenario has the fields timeline (#53) and measure (#80); Workload is an enum of the kinds and non_exhaustive (#55, #76); UdpCbr has udp_checksum (#61); Command has on_exit (#79).
• Feature and Workload have new variants; Backend has new methods with defaults (#79, #80).
• RunOptions lost bin, recovery and export_packets, which MeasureOverrides replaces (#80); series::Input takes a Schedule (#76).

In Python the arguments bin, recovery_*, capture and packets of run now replace a key of the section measure of the scenario (#80), and the properties that the pytest plugin writes to a JUnit file are text, so 0.0 is 0 (#85). A scenario with repetitions as a key is refused, because it is an option of a run (--repetitions, repetitions=). The command line exits with 1 for a replay that did not reproduce (#83). The wire format of the agent is version 2 (#61), so the programs of a run have to be of one release, which they are when they come from one installation.

Features

• Breaking: Mark the result types non-exhaustive (#50)
• Suggest the name that was meant for misspelled keys, values and units (#51)
• Breaking: Read burst loss, reordering, duplication and corruption in the scenario format (#52)
• Breaking: Read the timeline in the scenario format (#53)
• Breaking: Read workloads of kind command in the scenario format (#55)
• Apply the burst loss models, the reordering and the duplication in the Kernel backend (#59)
• Apply the corruption in the Kernel backend and account for every packet of a direction (#60)
• Breaking: Send a stream without the UDP checksum and count the packets that arrive damaged (#61)
• Name the packets that arrive damaged by sequence number with a tap in the receiving agent (#62)
• Report the extent of reordering, the interarrival jitter and the runs of lost packets (#63)
• Build the queues of a direction for every state of the timeline and write a state into them as a whole (#64)
• Do the steps of the timeline by the clock and record each one in the result (#65)
• Do a step of the timeline at a barrier of the workload, so that the same seed gives the same lost packets (#66)
• Change a link through one tc that lives for the run and let the backend add notes to the result (#68)
• Take links down and up and make an outage a window at the delivery as steps of the timeline, and leave refused packets out of the statistics (#69)
• Say that two workloads in a direction whose queue draws random numbers are not a repeatable experiment, and derive the bound of the corruption run test (#70)
• Stop the workloads and keep the result when the command line is interrupted with Ctrl-C (#71)
• Add a series by time bin for each workload and the time to recover after an event (#75)
• Breaking: Add the traffic kinds udp-poisson, udp-onoff and udp-bursty with a seeded schedule that the agent walks (#76)
• Breaking: Run programs of your own in the nodes, with readiness, supervision, logs and metrics (#79)
• Breaking: Add the section measure and the capture of the interfaces of a link as pcap files (#80)
• Add repetitions with derived seeds and bootstrap intervals (#81)
• Add repetitions to the Python package and the pytest plugin (#82)
• Add replay of a run from its result directory (#83)
• Add reports as Markdown, JUnit and HTML from result directories (#84)
• Add reports and replay to Python, and the report data of a run to the plugin (#85)

Fixes

• Wait for the queues of the links to empty before the receivers stop, so that packets in a queue do not count as lost (#72)
• Refuse what the kernel refuses before the network is built, by declaring the features from the probe of the machine and not from the version of tc alone (#73)