commit d3a4cb06bf62dfa49d9a3850c76dfe6922f82089
Author: meskio <meskio(a)torproject.org>
Date: Thu Nov 4 20:00:26 2021 +0100
Use rdsys as bridgedb backend
Closes: #40031
---
bridgedb.conf | 6 +
bridgedb/bridges.py | 33 ++++-
bridgedb/main.py | 297 ++++--------------------------------------
bridgedb/rdsys.py | 100 ++++++++++++++
bridgedb/test/test_Storage.py | 55 --------
bridgedb/test/test_main.py | 145 +++------------------
6 files changed, 175 insertions(+), 461 deletions(-)
diff --git a/bridgedb.conf b/bridgedb.conf
index 6d4839d..9e1374a 100644
--- a/bridgedb.conf
+++ b/bridgedb.conf
@@ -150,6 +150,12 @@ STATUS_FILE = "networkstatus-bridges"
#
IGNORE_NETWORKSTATUS = True
+# The token to access the rdsys backend
+RDSYS_TOKEN = "ApiTokenPlaceholder"
+
+# The address of the rdsys backend
+RDSYS_ADDRESS = "localhost:7100"
+
#----------------
# Output Files \ Where to store created data
#------------------------------------------------------------------------------
diff --git a/bridgedb/bridges.py b/bridgedb/bridges.py
index 6ec864d..83d6e95 100644
--- a/bridgedb/bridges.py
+++ b/bridgedb/bridges.py
@@ -34,7 +34,6 @@ import codecs
import hashlib
import ipaddr
import logging
-import os
import warnings
from Crypto.Util import asn1
@@ -52,14 +51,12 @@ from bridgedb import safelog
from bridgedb import bridgerequest
from bridgedb.crypto import removePKCS1Padding
from bridgedb.parse.addr import isIPAddress
-from bridgedb.parse.addr import isIPv4
from bridgedb.parse.addr import isIPv6
from bridgedb.parse.addr import isValidIP
from bridgedb.parse.addr import PortList
from bridgedb.parse.fingerprint import isValidFingerprint
from bridgedb.parse.fingerprint import toHex
from bridgedb.parse.fingerprint import fromHex
-from bridgedb.parse.nickname import isValidRouterNickname
from bridgedb.util import isascii_noncontrol
@@ -1549,6 +1546,36 @@ class Bridge(BridgeBackwardsCompatibility):
"""
return list(set([pt.methodname for pt in self.transports]))
+ def updateFromResource(self, resource):
+ """Update this bridge's attributes from an rdsys resource
+
+ :type resource: dict
+ :param resource: The rdsys resource dict
+ """
+ self.fingerprint = resource["fingerprint"]
+ self.address = resource["address"]
+ self.orPort = resource["port"]
+
+ self.flags.running = resource["flags"]["running"]
+ self.flags.stable = resource["flags"]["stable"]
+ self.flags.valid = resource["flags"]["valid"]
+ self.flags.fast = resource["flags"]["fast"]
+
+ if resource["or-addresses"]:
+ for oa in resource["or-addresses"]:
+ validatedAddress = isIPAddress(oa["address"], compressed=False)
+ if validatedAddress:
+ self.orAddresses.append( (validatedAddress, oa["port"], oa["ip-version"],) )
+
+ transport = PluggableTransport(
+ fingerprint=self.fingerprint,
+ methodname=resource["type"],
+ address=self.address,
+ port=self.port,
+ arguments=resource.get("params", {})
+ )
+ self.transports = [transport]
+
def updateFromNetworkStatus(self, descriptor, ignoreNetworkstatus=False):
"""Update this bridge's attributes from a parsed networkstatus
document.
diff --git a/bridgedb/main.py b/bridgedb/main.py
index 8fdec23..72c1f0e 100644
--- a/bridgedb/main.py
+++ b/bridgedb/main.py
@@ -27,6 +27,7 @@ from bridgedb import runner
from bridgedb import util
from bridgedb import metrics
from bridgedb import antibot
+from bridgedb import rdsys
from bridgedb.bridges import MalformedBridgeInfo
from bridgedb.bridges import MissingServerDescriptorDigest
from bridgedb.bridges import ServerDescriptorDigestMismatch
@@ -57,24 +58,6 @@ def expandBridgeAuthDir(authdir, filename):
return path
-def writeAssignments(hashring, filename):
- """Dump bridge distributor assignments to disk.
-
- :type hashring: A :class:`~bridgedb.bridgerings.BridgeSplitter`
- :ivar hashring: A class which takes an HMAC key and splits bridges
- into their hashring assignments.
- :param str filename: The filename to write the assignments to.
- """
- logging.debug("Dumping pool assignments to file: '%s'" % filename)
-
- try:
- with open(filename, 'a') as fh:
- fh.write("bridge-pool-assignment %s\n" %
- time.strftime("%Y-%m-%d %H:%M:%S"))
- hashring.dumpAssignments(fh)
- except IOError:
- logging.info("I/O error while writing assignments to: '%s'" % filename)
-
def writeMetrics(filename, measurementInterval):
"""Dump usage metrics to disk.
@@ -91,178 +74,18 @@ def writeMetrics(filename, measurementInterval):
except IOError as err:
logging.error("Failed to write metrics to '%s': %s" % (filename, err))
-def load(state, hashring, clear=False):
- """Read and parse all descriptors, and load into a bridge hashring.
-
- Read all the appropriate bridge files from the saved
- :class:`~bridgedb.persistent.State`, parse and validate them, and then
- store them into our ``state.hashring`` instance. The ``state`` will be
- saved again at the end of this function.
+def load(cfg, proxyList, key):
+ """Load the configured distributors and their connections to rdsys
- :type hashring: :class:`~bridgedb.bridgerings.BridgeSplitter`
- :param hashring: A class which provides a mechanism for HMACing
- Bridges in order to assign them to hashrings.
- :param boolean clear: If True, clear all previous bridges from the
- hashring before parsing for new ones.
- """
- if not state:
- logging.fatal("bridgedb.main.load() could not retrieve state!")
- sys.exit(2)
-
- if clear:
- logging.info("Clearing old bridges...")
- hashring.clear()
-
- logging.info("Loading bridges...")
-
- ignoreNetworkstatus = state.IGNORE_NETWORKSTATUS
- if ignoreNetworkstatus:
- logging.info("Ignoring BridgeAuthority networkstatus documents.")
-
- for auth in state.BRIDGE_AUTHORITY_DIRECTORIES:
- logging.info("Processing descriptors in %s directory..." % auth)
-
- bridges = {}
- timestamps = {}
-
- fn = expandBridgeAuthDir(auth, state.STATUS_FILE)
- logging.info("Opening networkstatus file: %s" % fn)
- networkstatuses = descriptors.parseNetworkStatusFile(fn)
- logging.debug("Closing networkstatus file: %s" % fn)
-
- logging.info("Processing networkstatus descriptors...")
- for router in networkstatuses:
- bridge = Bridge()
- bridge.updateFromNetworkStatus(router, ignoreNetworkstatus)
- try:
- bridge.assertOK()
- except MalformedBridgeInfo as error:
- logging.warn(str(error))
- else:
- bridges[bridge.fingerprint] = bridge
-
- for filename in state.BRIDGE_FILES:
- fn = expandBridgeAuthDir(auth, filename)
- logging.info("Opening bridge-server-descriptor file: '%s'" % fn)
- serverdescriptors = descriptors.parseServerDescriptorsFile(fn)
- logging.debug("Closing bridge-server-descriptor file: '%s'" % fn)
-
- for router in serverdescriptors:
- try:
- bridge = bridges[router.fingerprint]
- except KeyError:
- logging.warn(
- ("Received server descriptor for bridge '%s' which wasn't "
- "in the networkstatus!") % router.fingerprint)
- if ignoreNetworkstatus:
- bridge = Bridge()
- else:
- continue
-
- try:
- bridge.updateFromServerDescriptor(router, ignoreNetworkstatus)
- except (ServerDescriptorWithoutNetworkstatus,
- MissingServerDescriptorDigest,
- ServerDescriptorDigestMismatch) as error:
- logging.warn(str(error))
- # Reject any routers whose server descriptors didn't pass
- # :meth:`~bridges.Bridge._checkServerDescriptor`, i.e. those
- # bridges who don't have corresponding networkstatus
- # documents, or whose server descriptor digests don't check
- # out:
- bridges.pop(router.fingerprint)
- continue
-
- if state.COLLECT_TIMESTAMPS:
- # Update timestamps from server descriptors, not from network
- # status descriptors (because networkstatus documents and
- # descriptors aren't authenticated in any way):
- if bridge.fingerprint in timestamps.keys():
- timestamps[bridge.fingerprint].append(router.published)
- else:
- timestamps[bridge.fingerprint] = [router.published]
-
- eifiles = [expandBridgeAuthDir(auth, fn) for fn in state.EXTRA_INFO_FILES]
- extrainfos = descriptors.parseExtraInfoFiles(*eifiles)
- for fingerprint, router in extrainfos.items():
- try:
- bridges[fingerprint].updateFromExtraInfoDescriptor(router)
- except MalformedBridgeInfo as error:
- logging.warn(str(error))
- except KeyError as error:
- logging.warn(("Received extrainfo descriptor for bridge '%s', "
- "but could not find bridge with that fingerprint.")
- % router.fingerprint)
-
- blacklist = parseBridgeBlacklistFile(state.NO_DISTRIBUTION_FILE)
-
- inserted = 0
- logging.info("Trying to insert %d bridges into hashring, %d of which "
- "have the 'Running' flag..." % (len(bridges),
- len(list(filter(lambda b: b.flags.running, bridges.values())))))
-
- for fingerprint, bridge in bridges.items():
- # Skip insertion of bridges which are geolocated to be in one of the
- # NO_DISTRIBUTION_COUNTRIES, a.k.a. the countries we don't distribute
- # bridges from:
- if bridge.country in state.NO_DISTRIBUTION_COUNTRIES:
- logging.warn("Not distributing Bridge %s %s:%s in country %s!" %
- (bridge, bridge.address, bridge.orPort, bridge.country))
- # Skip insertion of blacklisted bridges.
- elif bridge in blacklist.keys():
- logging.warn("Not distributing blacklisted Bridge %s %s:%s: %s" %
- (bridge, bridge.address, bridge.orPort, blacklist[bridge]))
- # Skip bridges that are running a blacklisted version of Tor.
- elif bridge.runsVersion(state.BLACKLISTED_TOR_VERSIONS):
- logging.warn("Not distributing bridge %s because it runs blacklisted "
- "Tor version %s." % (router.fingerprint, bridge.software))
- else:
- # If the bridge is not running, then it is skipped during the
- # insertion process.
- hashring.insert(bridge)
- inserted += 1
- logging.info("Tried to insert %d bridges into hashring. Resulting "
- "hashring is of length %d." % (inserted, len(hashring)))
-
- if state.COLLECT_TIMESTAMPS:
- reactor.callInThread(updateBridgeHistory, bridges, timestamps)
-
- state.save()
-
-def _reloadFn(*args):
- """Placeholder callback function for :func:`_handleSIGHUP`."""
- return True
-
-def _handleSIGHUP(*args):
- """Called when we receive a SIGHUP; invokes _reloadFn."""
- reactor.callInThread(_reloadFn)
-
-def replaceBridgeRings(current, replacement):
- """Replace the current thing with the new one"""
- current.hashring = replacement.hashring
-
-def createBridgeRings(cfg, proxyList, key):
- """Create the bridge distributors defined by the config file
-
- :type cfg: :class:`Conf`
- :param cfg: The current configuration, including any in-memory settings
- (i.e. settings whose values were not obtained from the config file,
- but were set via a function somewhere)
+ :type cfg: :class:`Conf`
+ :ivar cfg: The current configuration, including any in-memory
+ settings (i.e. settings whose values were not obtained from the
+ config file, but were set via a function somewhere)
:type proxyList: :class:`~bridgedb.proxy.ProxySet`
:param proxyList: The container for the IP addresses of any currently
known open proxies.
:param bytes key: Hashring master key
- :rtype: tuple
- :returns: A :class:`~bridgedb.bridgerings.BridgeSplitter` hashring, an
- :class:`~bridgedb.distributors.https.distributor.HTTPSDistributor` or None, and an
- :class:`~bridgedb.distributors.email.distributor.EmailDistributor` or None, and an
- :class:`~bridgedb.distributors.moat.distributor.MoatDistributor` or None.
"""
- # Create a BridgeSplitter to assign the bridges to the different
- # distributors.
- hashring = bridgerings.BridgeSplitter(crypto.getHMAC(key, "Hashring-Key"))
- logging.debug("Created hashring: %r" % hashring)
-
# Create ring parameters.
ringParams = bridgerings.BridgeRingParameters(needPorts=cfg.FORCE_PORTS,
needFlags=cfg.FORCE_FLAGS)
@@ -277,7 +100,8 @@ def createBridgeRings(cfg, proxyList, key):
crypto.getHMAC(key, "Moat-Dist-Key"),
proxyList,
answerParameters=ringParams)
- hashring.addRing(moatDistributor.hashring, "moat", cfg.MOAT_SHARE)
+ moatDistributor.prepopulateRings()
+ rdsys.start_stream("moat", cfg.RDSYS_TOKEN, cfg.RDSYS_ADDRESS, moatDistributor.hashring)
# As appropriate, create an IP-based distributor.
if cfg.HTTPS_DIST and cfg.HTTPS_SHARE:
@@ -287,7 +111,8 @@ def createBridgeRings(cfg, proxyList, key):
crypto.getHMAC(key, "HTTPS-IP-Dist-Key"),
proxyList,
answerParameters=ringParams)
- hashring.addRing(ipDistributor.hashring, "https", cfg.HTTPS_SHARE)
+ ipDistributor.prepopulateRings()
+ rdsys.start_stream("https", cfg.RDSYS_TOKEN, cfg.RDSYS_ADDRESS, ipDistributor.hashring)
# As appropriate, create an email-based distributor.
if cfg.EMAIL_DIST and cfg.EMAIL_SHARE:
@@ -298,40 +123,18 @@ def createBridgeRings(cfg, proxyList, key):
cfg.EMAIL_DOMAIN_RULES.copy(),
answerParameters=ringParams,
whitelist=cfg.EMAIL_WHITELIST.copy())
- hashring.addRing(emailDistributor.hashring, "email", cfg.EMAIL_SHARE)
-
- # As appropriate, tell the hashring to leave some bridges unallocated.
- if cfg.RESERVED_SHARE:
- hashring.addRing(bridgerings.UnallocatedHolder(),
- "unallocated",
- cfg.RESERVED_SHARE)
+ emailDistributor.prepopulateRings()
+ rdsys.start_stream("email", cfg.RDSYS_TOKEN, cfg.RDSYS_ADDRESS, emailDistributor.hashring)
- return hashring, emailDistributor, ipDistributor, moatDistributor
+ return emailDistributor, ipDistributor, moatDistributor
-def loadBlockedBridges(hashring):
- """Load bridge blocking info from our SQL database and add it to bridge
- objects."""
-
- blockedBridges = {}
- with bridgedb.Storage.getDB() as db:
- blockedBridges = db.getBlockedBridges()
-
- num_blocked = 0
- for name, ring in hashring.ringsByName.items():
- if name == "unallocated":
- continue
- for _, bridge in ring.bridges.items():
- l = []
- try:
- l = blockedBridges[bridge.fingerprint]
- except KeyError:
- continue
- for blocking_country, address, port in l:
- bridge.setBlockedIn(blocking_country, address, port)
- num_blocked += 1
-
- logging.info("Loaded blocking info for %d bridges.".format(num_blocked))
+def _reloadFn(*args):
+ """Placeholder callback function for :func:`_handleSIGHUP`."""
+ return True
+def _handleSIGHUP(*args):
+ """Called when we receive a SIGHUP; invokes _reloadFn."""
+ reactor.callInThread(_reloadFn)
def run(options, reactor=reactor):
"""This is BridgeDB's main entry point and main runtime loop.
@@ -416,7 +219,7 @@ def run(options, reactor=reactor):
State should be saved before calling this method, and will be saved
again at the end of it.
- The internal variables ``cfg`` and ``hashring`` are taken from a
+ The internal variables ``cfg`` is taken from a
:class:`~bridgedb.persistent.State` instance, which has been saved to a
statefile with :meth:`bridgedb.persistent.State.save`.
@@ -424,9 +227,6 @@ def run(options, reactor=reactor):
:ivar cfg: The current configuration, including any in-memory
settings (i.e. settings whose values were not obtained from the
config file, but were set via a function somewhere)
- :type hashring: A :class:`~bridgedb.bridgerings.BridgeSplitter`
- :ivar hashring: A class which takes an HMAC key and splits bridges
- into their hashring assignments.
"""
logging.debug("Caught SIGHUP")
logging.info("Reloading...")
@@ -455,71 +255,20 @@ def run(options, reactor=reactor):
logging.info("Reloading decoy bridges...")
antibot.loadDecoyBridges(config.DECOY_BRIDGES_FILE)
- (hashring,
- emailDistributorTmp,
- ipDistributorTmp,
- moatDistributorTmp) = createBridgeRings(cfg, proxies, key)
-
# Initialize our DB.
bridgedb.Storage.initializeDBLock()
bridgedb.Storage.setDBFilename(cfg.DB_FILE + ".sqlite")
- logging.info("Reparsing bridge descriptors...")
- load(state, hashring, clear=False)
- logging.info("Bridges loaded: %d" % len(hashring))
- loadBlockedBridges(hashring)
- if emailDistributorTmp is not None:
- emailDistributorTmp.prepopulateRings() # create default rings
- else:
- logging.warn("No email distributor created!")
-
- if ipDistributorTmp is not None:
- ipDistributorTmp.prepopulateRings() # create default rings
- else:
- logging.warn("No HTTP(S) distributor created!")
-
- if moatDistributorTmp is not None:
- moatDistributorTmp.prepopulateRings()
- else:
- logging.warn("No Moat distributor created!")
-
- metrix = metrics.InternalMetrics()
- logging.info("Logging bridge ring metrics for %d rings." %
- len(hashring.ringsByName))
- for ringName, ring in hashring.ringsByName.items():
- # Ring is of type FilteredBridgeSplitter or UnallocatedHolder.
- # FilteredBridgeSplitter splits bridges into subhashrings based on
- # filters.
- if hasattr(ring, "filterRings"):
- for (ringname, (filterFn, subring)) in ring.filterRings.items():
- subRingName = "-".join(ring.extractFilterNames(ringname))
- metrix.recordBridgesInHashring(ringName,
- subRingName,
- len(subring))
- elif hasattr(ring, "fingerprints"):
- metrix.recordBridgesInHashring(ringName, "unallocated",
- len(ring.fingerprints))
-
- # Dump bridge pool assignments to disk.
- writeAssignments(hashring, state.ASSIGNMENTS_FILE)
state.save()
if inThread:
# XXX shutdown the distributors if they were previously running
# and should now be disabled
- if moatDistributorTmp:
- reactor.callFromThread(replaceBridgeRings,
- moatDistributor, moatDistributorTmp)
- if ipDistributorTmp:
- reactor.callFromThread(replaceBridgeRings,
- ipDistributor, ipDistributorTmp)
- if emailDistributorTmp:
- reactor.callFromThread(replaceBridgeRings,
- emailDistributor, emailDistributorTmp)
+ pass
else:
# We're still starting up. Return these distributors so
# they are configured in the outer-namespace
- return emailDistributorTmp, ipDistributorTmp, moatDistributorTmp
+ return load(cfg, proxies, key)
global _reloadFn
_reloadFn = reload
diff --git a/bridgedb/rdsys.py b/bridgedb/rdsys.py
new file mode 100644
index 0000000..15c5ce2
--- /dev/null
+++ b/bridgedb/rdsys.py
@@ -0,0 +1,100 @@
+import json
+import secrets
+import logging
+from io import BytesIO
+from twisted.internet import reactor
+from twisted.internet.defer import Deferred
+from twisted.internet.protocol import Protocol
+from twisted.web.client import Agent, FileBodyProducer
+from twisted.web.http_headers import Headers
+
+from bridgedb.bridges import Bridge
+
+
+inter_message_delimiter = b"\r"
+
+
+class RdsysProtocol(Protocol):
+ def __init__(self, finished, hashring):
+ """
+ :type hashring: :class:`bridgedb.bridgerings.FilteredBridgeSplitter`
+ """
+ self.finished = finished
+ self.hashring = hashring
+ self.buff = b""
+
+ def dataReceived(self, data):
+ """
+ dataReceived is being called by twisted web client for each chunk it
+ does receives. One chunk might not be full message from rdsys but a
+ part of it, or the end of one and the beginning of the next, or
+ multiple messages. We don't expect to be multiple messages in one
+ chunk with rdsys, but anyway is implemented to support that usecase.
+
+ self.buff is the accumulator, where we aggregate the chunks and when
+ we find a inter_message_delimiter we update resources and reset
+ self.buff setting it to the first part of the next message if there
+ is one if not the data.split will anyway produce an empty bytes.
+ """
+ parts = data.split(inter_message_delimiter)
+ self.buff += parts[0]
+ for part in parts[1:]:
+ self._updateResources()
+ self.buff = part
+
+ def _updateResources(self):
+ jb = json.loads(self.buff)
+ for action, fn in [
+ ("gone", self.hashring.remove),
+ ("changed", self.hashring.insert),
+ ("new", self.hashring.insert),
+ ]:
+ if jb[action] is None:
+ continue
+
+ for rtype in jb[action]:
+ if jb[action][rtype] is None:
+ continue
+
+ for resource in jb[action][rtype]:
+ bridge = Bridge()
+ bridge.updateFromResource(resource)
+ fn(bridge)
+
+ def connectionLost(self, reason):
+ logging.info("Connection lost with rdsys backend:", reason.getErrorMessage())
+ self.finished.callback(None)
+
+
+def start_stream(distributor, token, rdsys_address, hashring):
+ headers = Headers(
+ {
+ "Content-Type": ["application/json"],
+ "Authorization": ["Bearer %s" % (token,)],
+ }
+ )
+ body = {
+ "request_origin": distributor,
+ "resource_types": ["obfs4", "vanilla"],
+ }
+ buff = BytesIO(bytes(json.dumps(body), "utf-8"))
+ body_producer = FileBodyProducer(buff)
+ agent = Agent(reactor)
+
+ def cbResponse(r):
+ finished = Deferred()
+ r.deliverBody(RdsysProtocol(finished, hashring))
+ return finished
+
+ def connect():
+ d = agent.request(
+ b"GET",
+ b"http://%s/resource-stream" % (rdsys_address.encode(),),
+ headers=headers,
+ bodyProducer=body_producer,
+ )
+ d.addCallback(cbResponse)
+ d.addErrback(lambda err: logging.warning("Error on the connection with rdsys: " + str(err)))
+ d.addCallback(connect)
+
+ connect()
diff --git a/bridgedb/test/test_Storage.py b/bridgedb/test/test_Storage.py
index a1eb7bd..c641058 100644
--- a/bridgedb/test/test_Storage.py
+++ b/bridgedb/test/test_Storage.py
@@ -155,61 +155,6 @@ class DatabaseTest(unittest.TestCase):
# Measurements that are "young enough" should be returned.
self.assertEquals(len(rows), 1)
- def test_main_loadBlockedBridges(self):
- Storage.initializeDBLock()
-
- # Mock configuration object that we use to initialize our bridge rings.
- class Cfg(object):
- def __init__(self):
- self.FORCE_PORTS = [(443, 1)]
- self.FORCE_FLAGS = [("Stable", 1)]
- self.MOAT_DIST = False
- self.HTTPS_DIST = True
- self.HTTPS_SHARE = 10
- self.N_IP_CLUSTERS = 1
- self.EMAIL_DIST = False
- self.RESERVED_SHARE = 0
-
- bridge = self.fakeBridges[0]
- addr, port, _ = bridge.orAddresses[0]
- cc= "de"
-
- # Mock object that we use to simulate a database connection.
- class DummyDB(object):
- def __init__(self):
- pass
- def __enter__(self):
- return self
- def __exit__(self, type, value, traceback):
- pass
- def getBlockedBridges(self):
- return {bridge.fingerprint: [(cc, addr, port)]}
- def getBridgeDistributor(self, bridge, validRings):
- return "https"
- def insertBridgeAndGetRing(self, bridge, setRing, seenAt, validRings, defaultPool="unallocated"):
- return "https"
- def commit(self):
- pass
-
- oldObj = Storage.getDB
- Storage.getDB = DummyDB
-
- hashring, _, _, _ = main.createBridgeRings(Cfg(), None, b'key')
- hashring.insert(bridge)
-
- self.assertEqual(len(hashring), 1)
- self.assertFalse(bridge.isBlockedIn(cc))
- self.assertFalse(bridge.isBlockedIn("ab"))
- self.assertFalse(bridge.addressIsBlockedIn(cc, addr, port))
-
- main.loadBlockedBridges(hashring)
-
- self.assertTrue(bridge.isBlockedIn(cc))
- self.assertFalse(bridge.isBlockedIn("ab"))
- self.assertTrue(bridge.addressIsBlockedIn(cc, addr, port))
-
- Storage.getDB = oldObj
-
def test_getBlockedBridgesFromSql(self):
elems = [(0, "0000000000000000000000000000000000000000", "obfs4",
diff --git a/bridgedb/test/test_main.py b/bridgedb/test/test_main.py
index 64b65a4..ae6ed9a 100644
--- a/bridgedb/test/test_main.py
+++ b/bridgedb/test/test_main.py
@@ -132,11 +132,6 @@ class BridgedbTests(unittest.TestCase):
return updatedPaths
- def _cbAssertFingerprints(self, d):
- """Assert that there are some bridges in the hashring."""
- self.assertGreater(len(self.hashring), 0)
- return d
-
def _cbCallUpdateBridgeHistory(self, d, hashring):
"""Fake some timestamps for the bridges in the hashring, and then call
main.updateBridgeHistory().
@@ -220,73 +215,6 @@ class BridgedbTests(unittest.TestCase):
for d in self._directories_created:
shutil.rmtree(d)
- def test_main_updateBridgeHistory(self):
- """main.updateBridgeHistory should update some timestamps for some
- bridges.
- """
- # Mock the updateBridgeHistory() function so that we don't try to
- # access the database:
- main.updateBridgeHistory = mockUpdateBridgeHistory
-
- # Get the bridges into the mocked hashring
- d = deferToThread(main.load, self.state, self.hashring)
- d.addCallback(self._cbAssertFingerprints)
- d.addErrback(self._eb_Failure)
- d.addCallback(self._cbCallUpdateBridgeHistory, self.hashring)
- d.addErrback(self._eb_Failure)
- return d
-
- def test_main_load(self):
- """main.load() should run without error."""
- d = deferToThread(main.load, self.state, self.hashring)
- d.addCallback(self._cbAssertFingerprints)
- d.addErrback(self._eb_Failure)
- return d
-
- def test_main_load_then_reload(self):
- """main.load() should run without error."""
- d = deferToThread(main.load, self.state, self.hashring)
- d.addCallback(self._cbAssertFingerprints)
- d.addErrback(self._eb_Failure)
- d.addCallback(main._reloadFn)
- d.addErrback(self._eb_Failure)
- return d
-
- def test_main_load_no_state(self):
- """main.load() should raise SystemExit without a state object."""
- self.assertRaises(SystemExit, main.load, None, self.hashring)
-
- def test_main_load_clear(self):
- """When called with clear=True, load() should run and clear the
- hashrings.
- """
- d = deferToThread(main.load, self.state, self.hashring, clear=True)
- d.addCallback(self._cbAssertFingerprints)
- d.addErrback(self._eb_Failure)
- return d
-
- def test_main_load_collect_timestamps(self):
- """When COLLECT_TIMESTAMPS=True, main.load() should call
- main.updateBridgeHistory().
- """
- # Mock the addOrUpdateBridgeHistory() function so that we don't try to
- # access the database:
- main.updateBridgeHistory = mockUpdateBridgeHistory
- state = self.state
- state.COLLECT_TIMESTAMPS = True
-
- # The reactor is deferring this to a thread, so the test execution
- # here isn't actually covering the Storage.updateBridgeHistory()
- # function:
- main.load(state, self.hashring)
-
- def test_main_load_malformed_networkstatus(self):
- """When called with a networkstatus file with an invalid descriptor,
- main.load() should raise a ValueError.
- """
- self._appendToFile(self.state.STATUS_FILE, NETWORKSTATUS_MALFORMED)
- self.assertRaises(ValueError, main.load, self.state, self.hashring)
-
def test_main_reloadFn(self):
"""main._reloadFn() should return True."""
self.assertTrue(main._reloadFn())
@@ -297,80 +225,39 @@ class BridgedbTests(unittest.TestCase):
self.assertTrue(main._handleSIGHUP())
- def test_main_createBridgeRings(self):
- """main.createBridgeRings() should add three hashrings to the
- hashring.
- """
- proxyList = None
- (hashring, emailDist, httpsDist, moatDist) = main.createBridgeRings(
- self.config, proxyList, self.key)
-
- # Should have an HTTPSDistributor ring, an EmailDistributor ring,
- # a MoatDistributor right, and an UnallocatedHolder ring:
- self.assertEqual(len(hashring.ringsByName.keys()), 4)
-
- def test_main_createBridgeRings_with_proxyList(self):
- """main.createBridgeRings() should add three hashrings to the
- hashring and add the proxyList to the IPBasedDistibutor.
+ def test_main_load_with_proxyList(self):
+ """main.load() should add the proxyList to the IPBasedDistibutor.
"""
exitRelays = ['1.1.1.1', '2.2.2.2', '3.3.3.3']
proxyList = main.proxy.ProxySet()
proxyList.addExitRelays(exitRelays)
- (hashring, emailDist, httpsDist, moatDist) = main.createBridgeRings(
+ (emailDist, httpsDist, moatDist) = main.load(
self.config, proxyList, self.key)
- # Should have an HTTPSDistributor ring, an EmailDistributor ring,
- # a MoatDistributor ring, and an UnallocatedHolder ring:
- self.assertEqual(len(hashring.ringsByName.keys()), 4)
self.assertGreater(len(httpsDist.proxies), 0)
self.assertCountEqual(exitRelays, httpsDist.proxies)
- def test_main_createBridgeRings_no_https_dist(self):
- """When HTTPS_DIST=False, main.createBridgeRings() should add only
- two hashrings to the hashring.
+ def test_main_load_no_https_dist(self):
+ """When HTTPS_DIST=False, main.load() should not create an http distributor.
"""
proxyList = main.proxy.ProxySet()
config = self.config
config.HTTPS_DIST = False
- (hashring, emailDist, httpsDist, moatDist) = main.createBridgeRings(
- config, proxyList, self.key)
-
- # Should have an EmailDistributor ring, a MoatDistributor ring, and an
- # UnallocatedHolder ring:
- self.assertEqual(len(hashring.ringsByName.keys()), 3)
- self.assertNotIn('https', hashring.rings)
- self.assertNotIn(httpsDist, hashring.ringsByName.values())
-
- def test_main_createBridgeRings_no_email_dist(self):
- """When EMAIL_DIST=False, main.createBridgeRings() should add only
- two hashrings to the hashring.
+ (emailDist, httpsDist, moatDist) = main.load(
+ self.config, proxyList, self.key)
+
+ self.assertEqual(httpsDist, None)
+
+ def test_main_load_no_email_dist(self):
+ """When EMAIL_DIST=False, main.load() should not create an email distributor.
"""
proxyList = main.proxy.ProxySet()
config = self.config
config.EMAIL_DIST = False
- (hashring, emailDist, httpsDist, moatDist) = main.createBridgeRings(
- config, proxyList, self.key)
-
- # Should have an HTTPSDistributor ring, a MoatDistributor ring, and an
- # UnallocatedHolder ring:
- self.assertEqual(len(hashring.ringsByName.keys()), 3)
- self.assertNotIn('email', hashring.rings)
- self.assertNotIn(emailDist, hashring.ringsByName.values())
-
- def test_main_createBridgeRings_no_reserved_share(self):
- """When RESERVED_SHARE=0, main.createBridgeRings() should add only
- two hashrings to the hashring.
- """
- proxyList = main.proxy.ProxySet()
- config = self.config
- config.RESERVED_SHARE = 0
- (hashring, emailDist, httpsDist, moatDist) = main.createBridgeRings(
- config, proxyList, self.key)
-
- # Should have an HTTPSDistributor ring, an EmailDistributor ring, and a
- # MoatDistributor ring:
- self.assertEqual(len(hashring.ringsByName.keys()), 3)
- self.assertNotIn('unallocated', hashring.rings)
+ (emailDist, httpsDist, moatDist) = main.load(
+ self.config, proxyList, self.key)
+
+ self.assertEqual(emailDist, None)
def test_main_run(self):
"""main.run() should run and then finally raise SystemExit."""
