commit 25072720b90f5f725c50ee7b645efc4777d68da6
Author: Karsten Loesing <karsten.loesing(a)gmx.net>
Date: Sat Apr 20 11:04:14 2019 +0200
Add BandwidthFile for parsed bandwidth files.
Implements #30216.
---
CHANGELOG.md | 6 +
.../org/torproject/descriptor/BandwidthFile.java | 249 +++++++++
.../descriptor/impl/BandwidthFileImpl.java | 431 +++++++++++++++
.../descriptor/impl/DescriptorParserImpl.java | 9 +
.../descriptor/impl/BandwidthFileImplTest.java | 596 +++++++++++++++++++++
.../descriptor/impl/TestDescriptorBuilder.java | 120 +++++
6 files changed, 1411 insertions(+)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3353a4c..d9cb62a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+# Changes in version 2.6.0 - 2019-04-??
+
+ * Medium changes
+ - Add new BandwidthFile descriptor for parsed bandwidth files.
+
+
# Changes in version 2.5.0 - 2018-09-25
* Medium changes
diff --git a/src/main/java/org/torproject/descriptor/BandwidthFile.java b/src/main/java/org/torproject/descriptor/BandwidthFile.java
new file mode 100644
index 0000000..34b9414
--- /dev/null
+++ b/src/main/java/org/torproject/descriptor/BandwidthFile.java
@@ -0,0 +1,249 @@
+/* Copyright 2019 The Tor Project
+ * See LICENSE for licensing information */
+
+package org.torproject.descriptor;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * A bandwidth file contains information on relays' bandwidth capacities and is
+ * produced by bandwidth generators, previously known as bandwidth scanners.
+ *
+ * @since 2.6.0
+ */
+public interface BandwidthFile extends Descriptor {
+
+ /**
+ * Time of the most recent generator bandwidth result.
+ *
+ * @since 2.6.0
+ */
+ LocalDateTime timestamp();
+
+ /**
+ * Document format version.
+ *
+ * @since 2.6.0
+ */
+ String version();
+
+ /**
+ * Name of the software that created the document.
+ *
+ * @since 2.6.0
+ */
+ String software();
+
+ /**
+ * Version of the software that created the document.
+ *
+ * @since 2.6.0
+ */
+ Optional<String> softwareVersion();
+
+ /**
+ * Timestamp in UTC time zone when the file was created.
+ *
+ * @since 2.6.0
+ */
+ Optional<LocalDateTime> fileCreated();
+
+ /**
+ * Timestamp in UTC time zone when the generator was started.
+ *
+ * @since 2.6.0
+ */
+ Optional<LocalDateTime> generatorStarted();
+
+ /**
+ * Timestamp in UTC time zone when the first relay bandwidth was obtained.
+ *
+ * @since 2.6.0
+ */
+ Optional<LocalDateTime> earliestBandwidth();
+
+ /**
+ * Timestamp in UTC time zone of the most recent generator bandwidth result.
+ *
+ * @since 2.6.0
+ */
+ Optional<LocalDateTime> latestBandwidth();
+
+ /**
+ * Number of relays that have enough measurements to be included in the
+ * bandwidth file.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> numberEligibleRelays();
+
+ /**
+ * Percentage of relays in the consensus that should be included in every
+ * generated bandwidth file.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> minimumPercentEligibleRelays();
+
+ /**
+ * Number of relays in the consensus.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> numberConsensusRelays();
+
+ /**
+ * The number of eligible relays, as a percentage of the number of relays in
+ * the consensus.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> percentEligibleRelays();
+
+ /**
+ * Minimum number of relays that should be included in the bandwidth file.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> minimumNumberEligibleRelays();
+
+ /**
+ * Country, as in political geolocation, where the generator is run.
+ *
+ * @since 2.6.0
+ */
+ Optional<String> scannerCountry();
+
+ /**
+ * Country, as in political geolocation, or countries where the destination
+ * web server(s) are located.
+ *
+ * @since 2.6.0
+ */
+ Optional<String[]> destinationsCountries();
+
+ /**
+ * Number of the different consensuses seen in the last data period.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentConsensusCount();
+
+ /**
+ * Number of times that a list with a subset of relays prioritized to be
+ * measured has been created in the last data period.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentPriorityListCount();
+
+ /**
+ * Number of relays that has been in in the list of relays prioritized to be
+ * measured in the last data period.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentPriorityRelayCount();
+
+ /**
+ * Number of times that any relay has been queued to be measured in the last
+ * data period.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentMeasurementAttemptCount();
+
+ /**
+ * Number of times that the scanner attempted to measure a relay in the last
+ * data period, but the relay has not been measured because of system, network
+ * or implementation issues.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentMeasurementFailureCount();
+
+ /**
+ * Number of relays that have no successful measurements in the last data
+ * period.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentMeasurementsExcludedErrorCount();
+
+ /**
+ * Number of relays that have some successful measurements in the last data
+ * period, but all those measurements were performed in a period of time that
+ * was too short.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentMeasurementsExcludedNearCount();
+
+ /**
+ * Number of relays that have some successful measurements, but all those
+ * measurements are too old.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentMeasurementsExcludedOldCount();
+
+ /**
+ * Number of relays that don't have enough recent successful measurements.
+ *
+ * @since 2.6.0
+ */
+ Optional<Integer> recentMeasurementsExcludedFewCount();
+
+ /**
+ * Time that it would take to report measurements about half of the network,
+ * given the number of eligible relays and the time it took in the last days.
+ *
+ * @since 2.6.0
+ */
+ Optional<Duration> timeToReportHalfNetwork();
+
+ /**
+ * List of zero or more {@link RelayLine}s containing relay identities and
+ * bandwidths in the order as they are contained in the bandwidth file.
+ *
+ * @since 2.6.0
+ */
+ List<RelayLine> relayLines();
+
+ interface RelayLine {
+
+ /**
+ * Fingerprint for the relay's RSA identity key.
+ *
+ * @since 2.6.0
+ */
+ Optional<String> nodeId();
+
+ /**
+ * Relays's master Ed25519 key, base64 encoded, without trailing "="s.
+ *
+ * @since 2.6.0
+ */
+ Optional<String> masterKeyEd25519();
+
+ /**
+ * Bandwidth of this relay in kilobytes per second.
+ *
+ * @since 2.6.0
+ */
+ int bw();
+
+ /**
+ * Additional relay key-value pairs, excluding the key value pairs already
+ * parsed for relay identities and bandwidths.
+ *
+ * @since 2.6.0
+ */
+ Map<String, String> additionalKeyValues();
+ }
+}
+
diff --git a/src/main/java/org/torproject/descriptor/impl/BandwidthFileImpl.java b/src/main/java/org/torproject/descriptor/impl/BandwidthFileImpl.java
new file mode 100644
index 0000000..5d661e4
--- /dev/null
+++ b/src/main/java/org/torproject/descriptor/impl/BandwidthFileImpl.java
@@ -0,0 +1,431 @@
+/* Copyright 2019 The Tor Project
+ * See LICENSE for licensing information */
+
+package org.torproject.descriptor.impl;
+
+import org.torproject.descriptor.BandwidthFile;
+import org.torproject.descriptor.DescriptorParseException;
+
+import java.io.File;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeParseException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Scanner;
+
+public class BandwidthFileImpl extends DescriptorImpl implements BandwidthFile {
+
+ private enum KeyWithStringValue {
+ version, software, software_version
+ }
+
+ private enum KeyWithLocalDateTimeValue {
+ file_created, generator_started, earliest_bandwidth, latest_bandwidth
+ }
+
+ private enum KeyWithIntValue {
+ number_eligible_relays, minimum_percent_eligible_relays,
+ number_consensus_relays, percent_eligible_relays,
+ minimum_number_eligible_relays, recent_consensus_count,
+ recent_priority_list_count, recent_priority_relay_count,
+ recent_measurement_attempt_count, recent_measurement_failure_count,
+ recent_measurements_excluded_error_count,
+ recent_measurements_excluded_near_count,
+ recent_measurements_excluded_old_count,
+ recent_measurements_excluded_few_count
+ }
+
+ BandwidthFileImpl(byte[] rawDescriptorBytes, File descriptorfile)
+ throws DescriptorParseException {
+ super(rawDescriptorBytes, new int[] { 0, rawDescriptorBytes.length },
+ descriptorfile, false);
+ Scanner scanner = this.newScanner().useDelimiter("\n");
+ this.parseTimestampLine(scanner.nextLine());
+ boolean haveFinishedParsingHeader = false;
+ while (scanner.hasNext()) {
+ String line = scanner.nextLine();
+ if (!haveFinishedParsingHeader) {
+ if (line.startsWith("bw=") || line.contains(" bw=")) {
+ haveFinishedParsingHeader = true;
+ } else if ("====".equals(line) || "=====".equals(line)) {
+ haveFinishedParsingHeader = true;
+ continue;
+ }
+ }
+ if (!haveFinishedParsingHeader) {
+ this.parseHeaderLine(line);
+ } else {
+ this.parseRelayLine(line);
+ }
+ }
+ }
+
+ private void parseTimestampLine(String line) throws DescriptorParseException {
+ try {
+ this.timestamp = LocalDateTime.ofInstant(Instant.ofEpochSecond(
+ Long.parseLong(line)), ZoneOffset.UTC);
+ } catch (NumberFormatException | DateTimeParseException e) {
+ throw new DescriptorParseException(String.format(
+ "Unable to parse timestamp in first line: '%s'.", line), e);
+ }
+ }
+
+ private void parseHeaderLine(String line) throws DescriptorParseException {
+ String[] keyValueParts = line.split("=", 2);
+ if (keyValueParts.length != 2) {
+ throw new DescriptorParseException(String.format(
+ "Unrecognized line '%s' without '=' character.", line));
+ }
+ String key = keyValueParts[0];
+ if (key.length() < 1) {
+ throw new DescriptorParseException(String.format(
+ "Unrecognized line '%s' starting with '=' character.", line));
+ }
+ String value = keyValueParts[1];
+ switch (key) {
+ case "version":
+ case "software":
+ case "software_version":
+ this.parsedStrings.put(KeyWithStringValue.valueOf(key), value);
+ break;
+ case "file_created":
+ case "generator_started":
+ case "earliest_bandwidth":
+ case "latest_bandwidth":
+ try {
+ this.parsedLocalDateTimes.put(KeyWithLocalDateTimeValue.valueOf(key),
+ LocalDateTime.parse(value));
+ } catch (DateTimeParseException e) {
+ throw new DescriptorParseException(String.format(
+ "Unable to parse date-time string: '%s'.", value), e);
+ }
+ break;
+ case "number_eligible_relays":
+ case "minimum_percent_eligible_relays":
+ case "number_consensus_relays":
+ case "percent_eligible_relays":
+ case "minimum_number_eligible_relays":
+ case "recent_consensus_count":
+ case "recent_priority_list_count":
+ case "recent_priority_relay_count":
+ case "recent_measurement_attempt_count":
+ case "recent_measurement_failure_count":
+ case "recent_measurements_excluded_error_count":
+ case "recent_measurements_excluded_near_count":
+ case "recent_measurements_excluded_old_count":
+ case "recent_measurements_excluded_few_count":
+ try {
+ this.parsedInts.put(KeyWithIntValue.valueOf(key),
+ Integer.parseInt(value));
+ } catch (NumberFormatException e) {
+ throw new DescriptorParseException(String.format(
+ "Unable to parse int: '%s'.", value), e);
+ }
+ break;
+ case "scanner_country":
+ if (!value.matches("[A-Z]{2}")) {
+ throw new DescriptorParseException(String.format(
+ "Invalid country code '%s'.", value));
+ }
+ this.scannerCountry = value;
+ break;
+ case "destinations_countries":
+ if (!value.matches("[A-Z]{2}(,[A-Z]{2})*")) {
+ throw new DescriptorParseException(String.format(
+ "Invalid country code list '%s'.", value));
+ }
+ this.destinationsCountries = value.split(",");
+ break;
+ case "time_to_report_half_network":
+ try {
+ this.timeToReportHalfNetwork
+ = Duration.ofSeconds(Long.parseLong(value));
+ } catch (NumberFormatException | DateTimeParseException e) {
+ throw new DescriptorParseException(String.format(
+ "Unable to parse duration: '%s'.", value), e);
+ }
+ break;
+ case "node_id":
+ case "master_key_ed25519":
+ case "bw":
+ throw new DescriptorParseException(String.format(
+ "Either additional header line must not use keywords specified in "
+ + "relay lines, or relay line is missing required keys: '%s'.",
+ line));
+ default:
+ /* Ignore additional header lines. */
+ }
+ }
+
+ private class RelayLineImpl implements RelayLine {
+
+ private String nodeId;
+
+ @Override
+ public Optional<String> nodeId() {
+ return Optional.ofNullable(this.nodeId);
+ }
+
+ private String masterKeyEd25519;
+
+ @Override
+ public Optional<String> masterKeyEd25519() {
+ return Optional.ofNullable(this.masterKeyEd25519);
+ }
+
+ private int bw;
+
+ @Override
+ public int bw() {
+ return this.bw;
+ }
+
+ private Map<String, String> additionalKeyValues;
+
+ @Override
+ public Map<String, String> additionalKeyValues() {
+ return null == this.additionalKeyValues ? Collections.emptyMap()
+ : Collections.unmodifiableMap(this.additionalKeyValues);
+ }
+
+ private RelayLineImpl(String nodeId, String masterKeyEd25519, int bw,
+ Map<String, String> additionalKeyValues) {
+ this.nodeId = nodeId;
+ this.masterKeyEd25519 = masterKeyEd25519;
+ this.bw = bw;
+ this.additionalKeyValues = additionalKeyValues;
+ }
+ }
+
+ private void parseRelayLine(String line) throws DescriptorParseException {
+ String[] spaceSeparatedLineParts = line.split(" ");
+ String nodeId = null;
+ String masterKeyEd25519 = null;
+ Integer bw = null;
+ Map<String, String> additionalKeyValues = new LinkedHashMap<>();
+ for (String spaceSeparatedLinePart : spaceSeparatedLineParts) {
+ String[] keyValueParts = spaceSeparatedLinePart.split("=", 2);
+ if (keyValueParts.length != 2) {
+ throw new DescriptorParseException(String.format(
+ "Unrecognized space-separated line part '%s' without '=' "
+ + "character in line '%s'.", spaceSeparatedLinePart, line));
+ }
+ String key = keyValueParts[0];
+ if (key.length() < 1) {
+ throw new DescriptorParseException(String.format(
+ "Unrecognized space-separated line part '%s' starting with '=' "
+ + "character in line '%s'.", spaceSeparatedLinePart, line));
+ }
+ String value = keyValueParts[1];
+ switch (key) {
+ case "node_id":
+ nodeId = value;
+ break;
+ case "master_key_ed25519":
+ masterKeyEd25519 = value;
+ break;
+ case "bw":
+ try {
+ bw = Integer.parseInt(value);
+ } catch (NumberFormatException e) {
+ throw new DescriptorParseException(String.format(
+ "Unable to parse bw '%s' in line '%s'.", value, line), e);
+ }
+ break;
+ default:
+ additionalKeyValues.put(key, value);
+ }
+ }
+ if (null == nodeId && null == masterKeyEd25519) {
+ throw new DescriptorParseException(String.format(
+ "Expected relay line, but line contains neither node_id nor "
+ + "master_key_ed25519: '%s'.", line));
+ }
+ if (null == bw) {
+ throw new DescriptorParseException(String.format(
+ "Expected relay line, but line does not contain bw: '%s'.", line));
+ }
+ this.relayLines.add(new RelayLineImpl(nodeId, masterKeyEd25519, bw,
+ additionalKeyValues.isEmpty() ? null : additionalKeyValues));
+ }
+
+ private LocalDateTime timestamp;
+
+ @Override
+ public LocalDateTime timestamp() {
+ return this.timestamp;
+ }
+
+ private EnumMap<KeyWithStringValue, String> parsedStrings
+ = new EnumMap<>(KeyWithStringValue.class);
+
+ @Override
+ public String version() {
+ return this.parsedStrings.getOrDefault(KeyWithStringValue.version,
+ "1.0.0");
+ }
+
+ @Override
+ public String software() {
+ return this.parsedStrings.getOrDefault(KeyWithStringValue.software,
+ "torflow");
+ }
+
+ @Override
+ public Optional<String> softwareVersion() {
+ return Optional.ofNullable(
+ this.parsedStrings.get(KeyWithStringValue.software_version));
+ }
+
+ private EnumMap<KeyWithLocalDateTimeValue, LocalDateTime> parsedLocalDateTimes
+ = new EnumMap<>(KeyWithLocalDateTimeValue.class);
+
+ @Override
+ public Optional<LocalDateTime> fileCreated() {
+ return Optional.ofNullable(this.parsedLocalDateTimes.get(
+ KeyWithLocalDateTimeValue.file_created));
+ }
+
+ @Override
+ public Optional<LocalDateTime> generatorStarted() {
+ return Optional.ofNullable(this.parsedLocalDateTimes.get(
+ KeyWithLocalDateTimeValue.generator_started));
+ }
+
+ @Override
+ public Optional<LocalDateTime> earliestBandwidth() {
+ return Optional.ofNullable(this.parsedLocalDateTimes.get(
+ KeyWithLocalDateTimeValue.earliest_bandwidth));
+ }
+
+ @Override
+ public Optional<LocalDateTime> latestBandwidth() {
+ return Optional.ofNullable(this.parsedLocalDateTimes.get(
+ KeyWithLocalDateTimeValue.latest_bandwidth));
+ }
+
+ private EnumMap<KeyWithIntValue, Integer> parsedInts
+ = new EnumMap<>(KeyWithIntValue.class);
+
+ @Override
+ public Optional<Integer> numberEligibleRelays() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.number_eligible_relays));
+ }
+
+ @Override
+ public Optional<Integer> minimumPercentEligibleRelays() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.minimum_percent_eligible_relays));
+ }
+
+ @Override
+ public Optional<Integer> numberConsensusRelays() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.number_consensus_relays));
+ }
+
+ @Override
+ public Optional<Integer> percentEligibleRelays() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.percent_eligible_relays));
+ }
+
+ @Override
+ public Optional<Integer> minimumNumberEligibleRelays() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.minimum_number_eligible_relays));
+ }
+
+ private String scannerCountry;
+
+ @Override
+ public Optional<String> scannerCountry() {
+ return Optional.ofNullable(this.scannerCountry);
+ }
+
+ private String[] destinationsCountries;
+
+ @Override
+ public Optional<String[]> destinationsCountries() {
+ return Optional.ofNullable(this.destinationsCountries);
+ }
+
+ @Override
+ public Optional<Integer> recentConsensusCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_consensus_count));
+ }
+
+ @Override
+ public Optional<Integer> recentPriorityListCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_priority_list_count));
+ }
+
+ @Override
+ public Optional<Integer> recentPriorityRelayCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_priority_relay_count));
+ }
+
+ @Override
+ public Optional<Integer> recentMeasurementAttemptCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_measurement_attempt_count));
+ }
+
+ @Override
+ public Optional<Integer> recentMeasurementFailureCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_measurement_failure_count));
+ }
+
+ @Override
+ public Optional<Integer> recentMeasurementsExcludedErrorCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_measurements_excluded_error_count));
+ }
+
+ @Override
+ public Optional<Integer> recentMeasurementsExcludedNearCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_measurements_excluded_near_count));
+ }
+
+ @Override
+ public Optional<Integer> recentMeasurementsExcludedOldCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_measurements_excluded_old_count));
+ }
+
+ @Override
+ public Optional<Integer> recentMeasurementsExcludedFewCount() {
+ return Optional.ofNullable(this.parsedInts.get(
+ KeyWithIntValue.recent_measurements_excluded_few_count));
+ }
+
+ private Duration timeToReportHalfNetwork;
+
+ @Override
+ public Optional<Duration> timeToReportHalfNetwork() {
+ return Optional.ofNullable(this.timeToReportHalfNetwork);
+ }
+
+ private List<RelayLine> relayLines = new ArrayList<>();
+
+ @Override
+ public List<RelayLine> relayLines() {
+ return this.relayLines.isEmpty() ? Collections.emptyList()
+ : Collections.unmodifiableList(this.relayLines);
+ }
+}
+
diff --git a/src/main/java/org/torproject/descriptor/impl/DescriptorParserImpl.java b/src/main/java/org/torproject/descriptor/impl/DescriptorParserImpl.java
index e8b8b08..119fe09 100644
--- a/src/main/java/org/torproject/descriptor/impl/DescriptorParserImpl.java
+++ b/src/main/java/org/torproject/descriptor/impl/DescriptorParserImpl.java
@@ -132,6 +132,15 @@ public class DescriptorParserImpl implements DescriptorParser {
sourceFile);
} else if (fileName.contains(LogDescriptorImpl.MARKER)) {
return LogDescriptorImpl.parse(rawDescriptorBytes, sourceFile, fileName);
+ } else if (firstLines.matches("^[0-9]{10}\\n")) {
+ /* Identifying bandwidth files by a 10-digit timestamp in the first line
+ * breaks with files generated before 2002 or after 2286 and when the next
+ * descriptor identifier starts with just a timestamp in the first line
+ * rather than a document type identifier. */
+ List<Descriptor> parsedDescriptors = new ArrayList<>();
+ parsedDescriptors.add(new BandwidthFileImpl(rawDescriptorBytes,
+ sourceFile));
+ return parsedDescriptors;
} else {
throw new DescriptorParseException("Could not detect descriptor "
+ "type in descriptor starting with '" + firstLines + "'.");
diff --git a/src/test/java/org/torproject/descriptor/impl/BandwidthFileImplTest.java b/src/test/java/org/torproject/descriptor/impl/BandwidthFileImplTest.java
new file mode 100644
index 0000000..d19b7e7
--- /dev/null
+++ b/src/test/java/org/torproject/descriptor/impl/BandwidthFileImplTest.java
@@ -0,0 +1,596 @@
+/* Copyright 2019 The Tor Project
+ * See LICENSE for licensing information */
+
+package org.torproject.descriptor.impl;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import org.torproject.descriptor.BandwidthFile;
+import org.torproject.descriptor.DescriptorParseException;
+
+import org.hamcrest.Matchers;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class BandwidthFileImplTest {
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ /**
+ * Example from bandwidth-file-spec.txt: Version 1.0.0, generated by Torflow.
+ */
+ private static final String[] specExample100 = new String[] {
+ "1523911758",
+ "node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80 bw=760 nick=Test "
+ + "measured_at=1523911725 updated_at=1523911725 "
+ + "pid_error=4.11374090719 pid_error_sum=4.11374090719 "
+ + "pid_bw=57136645 pid_delta=2.12168374577 circ_fail=0.2 "
+ + "scanner=/filepath",
+ "node_id=$96C15995F30895689291F455587BD94CA427B6FC bw=189 nick=Test2 "
+ + "measured_at=1523911623 updated_at=1523911623 "
+ + "pid_error=3.96703337994 pid_error_sum=3.96703337994 "
+ + "pid_bw=47422125 pid_delta=2.65469736988 circ_fail=0.0 "
+ + "scanner=/filepath" };
+
+ @Test
+ public void testSpecExample100() throws DescriptorParseException {
+ BandwidthFile bandwidthFile = new BandwidthFileImpl(
+ new TestDescriptorBuilder(specExample100).build(), null);
+ assertEquals(LocalDateTime.of(2018, 4, 16, 20, 49, 18),
+ bandwidthFile.timestamp());
+ assertEquals("1.0.0", bandwidthFile.version());
+ assertEquals("torflow", bandwidthFile.software());
+ assertFalse(bandwidthFile.softwareVersion().isPresent());
+ assertFalse(bandwidthFile.fileCreated().isPresent());
+ assertFalse(bandwidthFile.generatorStarted().isPresent());
+ assertFalse(bandwidthFile.earliestBandwidth().isPresent());
+ assertFalse(bandwidthFile.latestBandwidth().isPresent());
+ assertFalse(bandwidthFile.numberEligibleRelays().isPresent());
+ assertFalse(bandwidthFile.minimumPercentEligibleRelays().isPresent());
+ assertFalse(bandwidthFile.numberConsensusRelays().isPresent());
+ assertFalse(bandwidthFile.percentEligibleRelays().isPresent());
+ assertFalse(bandwidthFile.minimumNumberEligibleRelays().isPresent());
+ assertFalse(bandwidthFile.scannerCountry().isPresent());
+ assertFalse(bandwidthFile.destinationsCountries().isPresent());
+ assertFalse(bandwidthFile.recentConsensusCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityListCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityRelayCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementAttemptCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementFailureCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedErrorCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedNearCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedOldCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedFewCount().isPresent());
+ assertFalse(bandwidthFile.timeToReportHalfNetwork().isPresent());
+ assertEquals(2, bandwidthFile.relayLines().size());
+ BandwidthFile.RelayLine firstRelayLine = bandwidthFile.relayLines().get(0);
+ assertEquals(Optional.of("$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80"),
+ firstRelayLine.nodeId());
+ assertFalse(firstRelayLine.masterKeyEd25519().isPresent());
+ assertEquals(760, firstRelayLine.bw());
+ Map<String, String> expectedFirstAdditionalKeyValues
+ = new LinkedHashMap<>();
+ expectedFirstAdditionalKeyValues.put("nick", "Test");
+ expectedFirstAdditionalKeyValues.put("measured_at", "1523911725");
+ expectedFirstAdditionalKeyValues.put("updated_at", "1523911725");
+ expectedFirstAdditionalKeyValues.put("pid_error", "4.11374090719");
+ expectedFirstAdditionalKeyValues.put("pid_error_sum", "4.11374090719");
+ expectedFirstAdditionalKeyValues.put("pid_bw", "57136645");
+ expectedFirstAdditionalKeyValues.put("pid_delta", "2.12168374577");
+ expectedFirstAdditionalKeyValues.put("circ_fail", "0.2");
+ expectedFirstAdditionalKeyValues.put("scanner", "/filepath");
+ assertEquals(expectedFirstAdditionalKeyValues,
+ firstRelayLine.additionalKeyValues());
+ }
+
+ @Test
+ public void testTimestampAsKeyValue() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Unable to parse timestamp in first line"));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample100)
+ .replaceLineStartingWith("1523911758", "timestamp=1523911758")
+ .build(), null);
+ }
+
+ @Test
+ public void testEmptyLine() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Blank lines are not allowed."));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample100)
+ .appendLines("")
+ .build(), null);
+ }
+
+ @Test
+ public void testHeaderLineAtEnd() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Expected relay line, but line contains neither node_id nor "
+ + "master_key_ed25519"));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample100)
+ .appendLines("version=1.0.0")
+ .build(), null);
+ }
+
+ @Test
+ public void testRelayLineWithoutRelayId() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Either additional header line must not use keywords specified in "
+ + "relay lines, or relay line is missing required keys"));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample100)
+ .replaceLineStartingWith(
+ "node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80",
+ "node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80")
+ .build(), null);
+ }
+
+ @Test
+ public void testRelayLineWithoutBw() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Expected relay line, but line contains neither node_id nor "
+ + "master_key_ed25519"));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample100)
+ .replaceLineStartingWith(
+ "node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80", "bw=760")
+ .build(), null);
+ }
+
+ @Test
+ public void testBwNotANumber() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Unable to parse bw 'slow' in line"));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample100)
+ .replaceLineStartingWith(
+ "node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80",
+ "node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80 bw=slow")
+ .build(), null);
+ }
+
+ @Test
+ public void testRelayLineTrailingSpace() throws DescriptorParseException {
+ BandwidthFile bandwidthFile = new BandwidthFileImpl(
+ new TestDescriptorBuilder(specExample100)
+ .replaceLineStartingWith(
+ "node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80",
+ "node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80 bw=760 ")
+ .build(), null);
+ /* It's okay that this line ends with a space, we're parsing it anyway. */
+ assertEquals(2, bandwidthFile.relayLines().size());
+ BandwidthFile.RelayLine firstRelayLine = bandwidthFile.relayLines().get(0);
+ assertEquals(Optional.of("$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80"),
+ firstRelayLine.nodeId());
+ assertEquals(760, firstRelayLine.bw());
+ }
+
+ /**
+ * Example from bandwidth-file-spec.txt: Version 1.1.0, generated by sbws
+ * version 0.1.0.
+ */
+ private static final String[] specExample110 = new String[] {
+ "1523911758",
+ "version=1.1.0",
+ "software=sbws",
+ "software_version=0.1.0",
+ "latest_bandwidth=2018-04-16T20:49:18",
+ "file_created=2018-04-16T21:49:18",
+ "generator_started=2018-04-16T15:13:25",
+ "earliest_bandwidth=2018-04-16T15:13:26",
+ "====",
+ "bw=380 error_circ=0 error_misc=0 error_stream=1 "
+ + "master_key_ed25519=YaqV4vbvPYKucElk297eVdNArDz9HtIwUoIeo0+cVIpQ "
+ + "nick=Test node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80 "
+ + "rtt=380 success=1 time=2018-05-08T16:13:26",
+ "bw=189 error_circ=0 error_misc=0 error_stream=0 "
+ + "master_key_ed25519=a6a+dZadrQBtfSbmQkP7j2ardCmLnm5NJ4ZzkvDxbo0I "
+ + "nick=Test2 node_id=$96C15995F30895689291F455587BD94CA427B6FC "
+ + "rtt=378 success=1 time=2018-05-08T16:13:36" };
+
+ @Test
+ public void testSpecExample110() throws DescriptorParseException {
+ BandwidthFile bandwidthFile = new BandwidthFileImpl(
+ new TestDescriptorBuilder(specExample110).build(), null);
+ assertEquals(LocalDateTime.of(2018, 4, 16, 20, 49, 18),
+ bandwidthFile.timestamp());
+ assertEquals("1.1.0", bandwidthFile.version());
+ assertEquals("sbws", bandwidthFile.software());
+ assertEquals(Optional.of("0.1.0"), bandwidthFile.softwareVersion());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 21, 49, 18)),
+ bandwidthFile.fileCreated());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 15, 13, 25)),
+ bandwidthFile.generatorStarted());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 15, 13, 26)),
+ bandwidthFile.earliestBandwidth());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 20, 49, 18)),
+ bandwidthFile.latestBandwidth());
+ assertFalse(bandwidthFile.numberEligibleRelays().isPresent());
+ assertFalse(bandwidthFile.minimumPercentEligibleRelays().isPresent());
+ assertFalse(bandwidthFile.numberConsensusRelays().isPresent());
+ assertFalse(bandwidthFile.percentEligibleRelays().isPresent());
+ assertFalse(bandwidthFile.minimumNumberEligibleRelays().isPresent());
+ assertFalse(bandwidthFile.scannerCountry().isPresent());
+ assertFalse(bandwidthFile.destinationsCountries().isPresent());
+ assertFalse(bandwidthFile.recentConsensusCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityListCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityRelayCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementAttemptCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementFailureCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedErrorCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedNearCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedOldCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedFewCount().isPresent());
+ assertFalse(bandwidthFile.timeToReportHalfNetwork().isPresent());
+ }
+
+ @Test
+ public void testTerminatorLineTooShort() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Unrecognized line '===' starting with '=' character"));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample110)
+ .replaceLineStartingWith("====", "===").build(), null);
+ }
+
+ @Test
+ public void testDateTimeContainingSpace() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Unable to parse date-time string"));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample110)
+ .replaceLineStartingWith("earliest_bandwidth",
+ "earliest_bandwidth=2018-04-16 15:13:26")
+ .build(), null);
+ }
+
+ /**
+ * Example from bandwidth-file-spec.txt: Version 1.2.0, generated by sbws
+ * version 1.0.3.
+ */
+ private static final String[] specExample120 = new String[] {
+ "1523911758",
+ "version=1.2.0",
+ "latest_bandwidth=2018-04-16T20:49:18",
+ "file_created=2018-04-16T21:49:18",
+ "generator_started=2018-04-16T15:13:25",
+ "earliest_bandwidth=2018-04-16T15:13:26",
+ "minimum_number_eligible_relays=3862",
+ "minimum_percent_eligible_relays=60",
+ "number_consensus_relays=6436",
+ "number_eligible_relays=6000",
+ "percent_eligible_relays=93",
+ "software=sbws",
+ "software_version=1.0.3",
+ "=====",
+ "bw=38000 bw_mean=1127824 bw_median=1180062 desc_avg_bw=1073741824 "
+ + "desc_obs_bw_last=17230879 desc_obs_bw_mean=14732306 error_circ=0 "
+ + "error_misc=0 error_stream=1 "
+ + "master_key_ed25519=YaqV4vbvPYKucElk297eVdNArDz9HtIwUoIeo0+cVIpQ "
+ + "nick=Test node_id=$68A483E05A2ABDCA6DA5A3EF8DB5177638A27F80 "
+ + "rtt=380 success=1 time=2018-05-08T16:13:26",
+ "bw=1 bw_mean=199162 bw_median=185675 desc_avg_bw=409600 "
+ + "desc_obs_bw_last=836165 desc_obs_bw_mean=858030 error_circ=0 "
+ + "error_misc=0 error_stream=0 "
+ + "master_key_ed25519=a6a+dZadrQBtfSbmQkP7j2ardCmLnm5NJ4ZzkvDxbo0I "
+ + "nick=Test2 node_id=$96C15995F30895689291F455587BD94CA427B6FC "
+ + "rtt=378 success=1 time=2018-05-08T16:13:36" };
+
+ @Test
+ public void testSpecExample120() throws DescriptorParseException {
+ BandwidthFile bandwidthFile = new BandwidthFileImpl(
+ new TestDescriptorBuilder(specExample120).build(), null);
+ assertEquals(LocalDateTime.of(2018, 4, 16, 20, 49, 18),
+ bandwidthFile.timestamp());
+ assertEquals("1.2.0", bandwidthFile.version());
+ assertEquals("sbws", bandwidthFile.software());
+ assertEquals(Optional.of("1.0.3"), bandwidthFile.softwareVersion());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 21, 49, 18)),
+ bandwidthFile.fileCreated());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 15, 13, 25)),
+ bandwidthFile.generatorStarted());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 15, 13, 26)),
+ bandwidthFile.earliestBandwidth());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 20, 49, 18)),
+ bandwidthFile.latestBandwidth());
+ assertEquals(Optional.of(6000), bandwidthFile.numberEligibleRelays());
+ assertEquals(Optional.of(60), bandwidthFile.minimumPercentEligibleRelays());
+ assertEquals(Optional.of(6436), bandwidthFile.numberConsensusRelays());
+ assertEquals(Optional.of(93), bandwidthFile.percentEligibleRelays());
+ assertEquals(Optional.of(3862),
+ bandwidthFile.minimumNumberEligibleRelays());
+ assertFalse(bandwidthFile.scannerCountry().isPresent());
+ assertFalse(bandwidthFile.destinationsCountries().isPresent());
+ assertFalse(bandwidthFile.recentConsensusCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityListCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityRelayCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementAttemptCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementFailureCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedErrorCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedNearCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedOldCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedFewCount().isPresent());
+ assertFalse(bandwidthFile.timeToReportHalfNetwork().isPresent());
+ }
+
+ @Test
+ public void testNumberEligibleRelaysNotAnInt()
+ throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Unable to parse int"));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample120)
+ .replaceLineStartingWith("number_eligible_relays=6000",
+ "number_eligible_relays=sixthousand").build(), null);
+ }
+
+ /**
+ * Example from bandwidth-file-spec.txt: Version 1.2.0, generated by sbws
+ * version 1.0.3 when there are not enough eligible measured relays.
+ */
+ private static final String[] specExample120NotEnough = new String[] {
+ "1540496079",
+ "version=1.2.0",
+ "earliest_bandwidth=2018-10-20T19:35:52",
+ "file_created=2018-10-25T19:35:03",
+ "generator_started=2018-10-25T11:42:56",
+ "latest_bandwidth=2018-10-25T19:34:39",
+ "minimum_number_eligible_relays=3862",
+ "minimum_percent_eligible_relays=60",
+ "number_consensus_relays=6436",
+ "number_eligible_relays=2960",
+ "percent_eligible_relays=46",
+ "software=sbws",
+ "software_version=1.0.3",
+ "=====" };
+
+ @Test
+ public void testSpecExample120NotEnough() throws DescriptorParseException {
+ BandwidthFile bandwidthFile = new BandwidthFileImpl(
+ new TestDescriptorBuilder(specExample120NotEnough).build(), null);
+ assertEquals(LocalDateTime.of(2018, 10, 25, 19, 34, 39),
+ bandwidthFile.timestamp());
+ assertEquals("1.2.0", bandwidthFile.version());
+ assertEquals("sbws", bandwidthFile.software());
+ assertEquals(Optional.of("1.0.3"), bandwidthFile.softwareVersion());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 10, 25, 19, 35, 3)),
+ bandwidthFile.fileCreated());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 10, 25, 11, 42, 56)),
+ bandwidthFile.generatorStarted());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 10, 20, 19, 35, 52)),
+ bandwidthFile.earliestBandwidth());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 10, 25, 19, 34, 39)),
+ bandwidthFile.latestBandwidth());
+ assertEquals(Optional.of(2960), bandwidthFile.numberEligibleRelays());
+ assertEquals(Optional.of(60), bandwidthFile.minimumPercentEligibleRelays());
+ assertEquals(Optional.of(6436), bandwidthFile.numberConsensusRelays());
+ assertEquals(Optional.of(46), bandwidthFile.percentEligibleRelays());
+ assertEquals(Optional.of(3862),
+ bandwidthFile.minimumNumberEligibleRelays());
+ assertFalse(bandwidthFile.scannerCountry().isPresent());
+ assertFalse(bandwidthFile.destinationsCountries().isPresent());
+ assertFalse(bandwidthFile.recentConsensusCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityListCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityRelayCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementAttemptCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementFailureCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedErrorCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedNearCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedOldCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedFewCount().isPresent());
+ assertFalse(bandwidthFile.timeToReportHalfNetwork().isPresent());
+ }
+
+ /**
+ * Example from bandwidth-file-spec.txt: Version 1.3.0 headers generated by
+ * sbws version 1.0.4.
+ */
+ private static final String[] specExample130Headers = new String[] {
+ "1523911758",
+ "version=1.3.0",
+ "latest_bandwidth=2018-04-16T20:49:18",
+ "destinations_countries=TH,ZZ",
+ "file_created=2018-04-16T21:49:18",
+ "generator_started=2018-04-16T15:13:25",
+ "earliest_bandwidth=2018-04-16T15:13:26",
+ "minimum_number_eligible_relays=3862",
+ "minimum_percent_eligible_relays=60",
+ "number_consensus_relays=6436",
+ "number_eligible_relays=6000",
+ "percent_eligible_relays=93",
+ "scanner_country=SN",
+ "software=sbws",
+ "software_version=1.0.4",
+ "=====" };
+
+ @Test
+ public void testSpecExample130Headers() throws DescriptorParseException {
+ BandwidthFile bandwidthFile = new BandwidthFileImpl(
+ new TestDescriptorBuilder(specExample130Headers).build(), null);
+ assertEquals(LocalDateTime.of(2018, 4, 16, 20, 49, 18),
+ bandwidthFile.timestamp());
+ assertEquals("1.3.0", bandwidthFile.version());
+ assertEquals("sbws", bandwidthFile.software());
+ assertEquals(Optional.of("1.0.4"), bandwidthFile.softwareVersion());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 21, 49, 18)),
+ bandwidthFile.fileCreated());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 15, 13, 25)),
+ bandwidthFile.generatorStarted());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 15, 13, 26)),
+ bandwidthFile.earliestBandwidth());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 20, 49, 18)),
+ bandwidthFile.latestBandwidth());
+ assertEquals(Optional.of(6000), bandwidthFile.numberEligibleRelays());
+ assertEquals(Optional.of(60), bandwidthFile.minimumPercentEligibleRelays());
+ assertEquals(Optional.of(6436), bandwidthFile.numberConsensusRelays());
+ assertEquals(Optional.of(93), bandwidthFile.percentEligibleRelays());
+ assertEquals(Optional.of(3862),
+ bandwidthFile.minimumNumberEligibleRelays());
+ assertEquals(Optional.of("SN"), bandwidthFile.scannerCountry());
+ assertArrayEquals(new String[] { "TH", "ZZ" },
+ bandwidthFile.destinationsCountries().orElse(null));
+ assertFalse(bandwidthFile.recentConsensusCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityListCount().isPresent());
+ assertFalse(bandwidthFile.recentPriorityRelayCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementAttemptCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementFailureCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedErrorCount().isPresent());
+ assertFalse(
+ bandwidthFile.recentMeasurementsExcludedNearCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedOldCount().isPresent());
+ assertFalse(bandwidthFile.recentMeasurementsExcludedFewCount().isPresent());
+ assertFalse(bandwidthFile.timeToReportHalfNetwork().isPresent());
+ }
+
+ @Test
+ public void testScannerCountryLowerCase() throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Invalid country code 'sn'."));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample130Headers)
+ .replaceLineStartingWith("scanner_country", "scanner_country=sn")
+ .build(), null);
+ }
+
+ @Test
+ public void testDestinationsCountriesLowerCase()
+ throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Invalid country code list 'th,zz'."));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample130Headers)
+ .replaceLineStartingWith("destinations_countries",
+ "destinations_countries=th,zz")
+ .build(), null);
+ }
+
+ @Test
+ public void testDestinationsCountriesEndingWithComma()
+ throws DescriptorParseException {
+ this.thrown.expect(DescriptorParseException.class);
+ this.thrown.expectMessage(Matchers.containsString(
+ "Invalid country code list 'TH,'."));
+ new BandwidthFileImpl(new TestDescriptorBuilder(specExample130Headers)
+ .replaceLineStartingWith("destinations_countries",
+ "destinations_countries=TH,")
+ .build(), null);
+ }
+
+ /**
+ * Example from bandwidth-file-spec.txt: Version 1.4.0 generated by sbws
+ * version 1.1.0.
+ */
+ private static final String[] specExample140 = new String[] {
+ "1523911758",
+ "version=1.4.0",
+ "latest_bandwidth=2018-04-16T20:49:18",
+ "destinations_countries=TH,ZZ",
+ "file_created=2018-04-16T21:49:18",
+ "generator_started=2018-04-16T15:13:25",
+ "earliest_bandwidth=2018-04-16T15:13:26",
+ "minimum_number_eligible_relays=3862",
+ "minimum_percent_eligible_relays=60",
+ "number_consensus_relays=6436",
+ "number_eligible_relays=6000",
+ "percent_eligible_relays=93",
+ "recent_measurement_attempt_count=6243",
+ "recent_measurement_failure_count=732",
+ "recent_measurements_excluded_error_count=969",
+ "recent_measurements_excluded_few_count=3946",
+ "recent_measurements_excluded_near_count=90",
+ "recent_measurements_excluded_old_count=0",
+ "recent_priority_list_count=20",
+ "recent_priority_relay_count=6243",
+ "scanner_country=SN",
+ "software=sbws",
+ "software_version=1.1.0",
+ "time_to_report_half_network=57273",
+ "=====",
+ "bw=1 error_circ=1 error_destination=0 error_misc=0 error_second_relay=0 "
+ + "error_stream=0 "
+ + "master_key_ed25519=J3HQ24kOQWac3L1xlFLp7gY91qkb5NuKxjj1BhDi+m8 "
+ + "nick=snap269 node_id=$DC4D609F95A52614D1E69C752168AF1FCAE0B05F "
+ + "relay_recent_measurement_attempt_count=3 "
+ + "relay_recent_measurements_excluded_error_count=1 "
+ + "relay_recent_measurements_excluded_near_count=3 "
+ + "relay_recent_consensus_count=3 relay_recent_priority_list_count=3 "
+ + "success=3 time=2019-03-16T18:20:57 unmeasured=1 vote=0",
+ "bw=1 error_circ=0 error_destination=0 error_misc=0 error_second_relay=0 "
+ + "error_stream=2 "
+ + "master_key_ed25519=h6ZB1E1yBFWIMloUm9IWwjgaPXEpL5cUbuoQDgdSDKg "
+ + "nick=relay node_id=$C4544F9E209A9A9B99591D548B3E2822236C0503 "
+ + "relay_recent_measurement_attempt_count=3 "
+ + "relay_recent_measurements_excluded_error_count=2 "
+ + "relay_recent_measurements_excluded_few_count=1 "
+ + "relay_recent_consensus_count=3 relay_recent_priority_list_count=3 "
+ + "success=1 time=2019-03-17T06:50:58 unmeasured=1 vote=0" };
+
+ @Test
+ public void testSpecExample140() throws DescriptorParseException {
+ BandwidthFile bandwidthFile = new BandwidthFileImpl(
+ new TestDescriptorBuilder(specExample140).build(), null);
+ assertEquals(LocalDateTime.of(2018, 4, 16, 20, 49, 18),
+ bandwidthFile.timestamp());
+ assertEquals("1.4.0", bandwidthFile.version());
+ assertEquals("sbws", bandwidthFile.software());
+ assertEquals(Optional.of("1.1.0"), bandwidthFile.softwareVersion());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 21, 49, 18)),
+ bandwidthFile.fileCreated());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 15, 13, 25)),
+ bandwidthFile.generatorStarted());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 15, 13, 26)),
+ bandwidthFile.earliestBandwidth());
+ assertEquals(Optional.of(LocalDateTime.of(2018, 4, 16, 20, 49, 18)),
+ bandwidthFile.latestBandwidth());
+ assertEquals(Optional.of(6000), bandwidthFile.numberEligibleRelays());
+ assertEquals(Optional.of(60), bandwidthFile.minimumPercentEligibleRelays());
+ assertEquals(Optional.of(6436), bandwidthFile.numberConsensusRelays());
+ assertEquals(Optional.of(93), bandwidthFile.percentEligibleRelays());
+ assertEquals(Optional.of(3862),
+ bandwidthFile.minimumNumberEligibleRelays());
+ assertEquals(Optional.of("SN"), bandwidthFile.scannerCountry());
+ assertArrayEquals(new String[] { "TH", "ZZ" },
+ bandwidthFile.destinationsCountries().orElse(null));
+ assertFalse(bandwidthFile.recentConsensusCount().isPresent());
+ assertEquals(Optional.of(20),
+ bandwidthFile.recentPriorityListCount());
+ assertEquals(Optional.of(6243),
+ bandwidthFile.recentPriorityRelayCount());
+ assertEquals(Optional.of(6243),
+ bandwidthFile.recentMeasurementAttemptCount());
+ assertEquals(Optional.of(732),
+ bandwidthFile.recentMeasurementFailureCount());
+ assertEquals(Optional.of(969),
+ bandwidthFile.recentMeasurementsExcludedErrorCount());
+ assertEquals(Optional.of(90),
+ bandwidthFile.recentMeasurementsExcludedNearCount());
+ assertEquals(Optional.of(0),
+ bandwidthFile.recentMeasurementsExcludedOldCount());
+ assertEquals(Optional.of(3946),
+ bandwidthFile.recentMeasurementsExcludedFewCount());
+ assertEquals(Optional.of(Duration.ofSeconds(57273L)),
+ bandwidthFile.timeToReportHalfNetwork());
+ }
+}
+
diff --git a/src/test/java/org/torproject/descriptor/impl/TestDescriptorBuilder.java b/src/test/java/org/torproject/descriptor/impl/TestDescriptorBuilder.java
new file mode 100644
index 0000000..a596c9d
--- /dev/null
+++ b/src/test/java/org/torproject/descriptor/impl/TestDescriptorBuilder.java
@@ -0,0 +1,120 @@
+/* Copyright 2016--2019 The Tor Project
+ * See LICENSE for licensing information */
+
+package org.torproject.descriptor.impl;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Builds a test descriptor by concatenating the given lines with newlines and
+ * writing the output to a byte array.
+ */
+class TestDescriptorBuilder extends ArrayList<String> {
+
+ /**
+ * Initializes a new test descriptor builder with the given lines.
+ */
+ TestDescriptorBuilder(String ... lines) {
+ this.addAll(Arrays.asList(lines));
+ }
+
+ /**
+ * Appends the given line or lines.
+ */
+ TestDescriptorBuilder appendLines(String ... lines) {
+ this.addAll(Arrays.asList(lines));
+ return this;
+ }
+
+ /**
+ * Removes the given line, or fails if that line cannot be found.
+ */
+ TestDescriptorBuilder removeLine(String line) {
+ if (!this.remove(line)) {
+ fail("Line not contained: " + line);
+ }
+ return this;
+ }
+
+ /**
+ * Removes all but the given line, or fails if that line cannot be found.
+ */
+ TestDescriptorBuilder removeAllExcept(String line) {
+ assertTrue("Line not contained: " + line, this.contains(line));
+ this.retainAll(Arrays.asList(line));
+ return this;
+ }
+
+ /**
+ * Finds the first line that starts with the given line start and inserts the
+ * given lines before it, or fails if no line can be found with that line
+ * start.
+ */
+ TestDescriptorBuilder insertBeforeLineStartingWith(String lineStart,
+ String ... linesToInsert) {
+ for (int i = 0; i < this.size(); i++) {
+ if (this.get(i).startsWith(lineStart)) {
+ this.addAll(i, Arrays.asList(linesToInsert));
+ return this;
+ }
+ }
+ fail("Line start not found: " + lineStart);
+ return this;
+ }
+
+ /**
+ * Finds the first line that starts with the given line start and replaces
+ * that line and possibly subsequent lines, or fails if no line can be found
+ * with that line start or there are not enough lines left to replace.
+ */
+ TestDescriptorBuilder replaceLineStartingWith(String lineStart,
+ String ... linesToReplace) {
+ for (int i = 0; i < this.size(); i++) {
+ if (this.get(i).startsWith(lineStart)) {
+ for (int j = 0; j < linesToReplace.length; j++) {
+ assertTrue("Not enough lines left to replace.",
+ this.size() > i + j);
+ this.set(i + j, linesToReplace[j]);
+ }
+ return this;
+ }
+ }
+ fail("Line start not found: " + lineStart);
+ return this;
+ }
+
+ /**
+ * Finds the first line that starts with the given line start and truncates
+ * that line and possibly subsequent lines, or fails if no line can be found
+ * with that line start.
+ */
+ TestDescriptorBuilder truncateAtLineStartingWith(String lineStart) {
+ for (int i = 0; i < this.size(); i++) {
+ if (this.get(i).startsWith(lineStart)) {
+ while (this.size() > i) {
+ this.remove(i);
+ }
+ return this;
+ }
+ }
+ fail("Line start not found: " + lineStart);
+ return this;
+ }
+
+ /**
+ * Concatenates all descriptor lines with newlines and returns the raw
+ * descriptor bytes as byte array.
+ */
+ byte[] build() {
+ StringBuilder sb = new StringBuilder();
+ for (String line : this) {
+ sb.append(line).append('\n');
+ }
+ return sb.toString().getBytes();
+ }
+}
+
