commit d83438d24104c5834cd0230a757b17a8e1941edb Author: Isis Lovecruft isis@torproject.org Date: Tue Apr 14 09:23:40 2015 +0000
Remove most "splitter"s — they're just crappy consistent hashrings. --- lib/bridgedb/Bridges.py | 2 +- lib/bridgedb/Dist.py | 60 ++++++++++++++-------------- lib/bridgedb/Main.py | 66 +++++++++++++++--------------- lib/bridgedb/test/legacy_Tests.py | 4 +- lib/bridgedb/test/test_Main.py | 80 ++++++++++++++++++------------------- lib/bridgedb/test/test_bridges.py | 24 +++++------ 6 files changed, 118 insertions(+), 118 deletions(-)
diff --git a/lib/bridgedb/Bridges.py b/lib/bridgedb/Bridges.py index c727c9a..b06ffc4 100644 --- a/lib/bridgedb/Bridges.py +++ b/lib/bridgedb/Bridges.py @@ -569,7 +569,7 @@ class FilteredBridgeSplitter(BridgeHolder): return
index = 0 - logging.debug("Inserting %s into splitter" + logging.debug("Inserting %s into hashring" % (logSafely(bridge.fingerprint))) for old_bridge in self.bridges[:]: if bridge.fingerprint == old_bridge.fingerprint: diff --git a/lib/bridgedb/Dist.py b/lib/bridgedb/Dist.py index 445d2d8..44cb526 100644 --- a/lib/bridgedb/Dist.py +++ b/lib/bridgedb/Dist.py @@ -81,14 +81,14 @@ class Distributor(object): >>> ipDist = Dist.IPBasedDistributor(5, 'fake-hmac-key') >>> ipDist.setDistributorName('HTTPS Distributor') >>> ipDist.prepopulateRings() - >>> hashrings = ipDist.splitter.filterRings + >>> hashrings = ipDist.hashring.filterRings >>> firstSubring = hashrings.items()[0][1][1] >>> assert firstSubring.name
:param str name: A name for this distributor. """ self.name = name - self.splitter.distributorName = name + self.hashring.distributorName = name
class IPBasedDistributor(Distributor): @@ -98,8 +98,8 @@ class IPBasedDistributor(Distributor): :type proxies: :class:`~bridgedb.proxies.ProxySet` :ivar proxies: All known proxies, which we treat differently. See :param:`proxies`. - :type splitter: :class:`bridgedb.Bridges.FixedBridgeSplitter` - :ivar splitter: A hashring that assigns bridges to subrings with fixed + :type hashring: :class:`bridgedb.Bridges.FixedBridgeSplitter` + :ivar hashring: A hashring that assigns bridges to subrings with fixed proportions. Used to assign bridges into the subrings of this distributor. """ @@ -150,9 +150,9 @@ class IPBasedDistributor(Distributor):
self._clientToPositionHMAC = getHMACFunc(key3, hex=False) self._subnetToSubringHMAC = getHMACFunc(key4, hex=True) - self.splitter = FilteredBridgeSplitter(key2, self.ringCacheSize) + self.hashring = FilteredBridgeSplitter(key2, self.ringCacheSize) logging.debug("Added %s to HTTPS distributor." % - self.splitter.__class__.__name__) + self.hashring.__class__.__name__)
self.setDistributorName('HTTPS')
@@ -311,16 +311,16 @@ class IPBasedDistributor(Distributor): # distributor's proxies: if subring == self.proxySubring: ring.setName('{0} Proxy Ring'.format(self.name)) - self.splitter.addRing(ring, filters, + self.hashring.addRing(ring, filters, filterBridgesByRules(filters), - populate_from=self.splitter.bridges) + populate_from=self.hashring.bridges)
def insert(self, bridge): """Assign a bridge to this distributor.""" - self.splitter.insert(bridge) + self.hashring.insert(bridge)
def _buildHashringFilters(self, previousFilters, subring): - f = filterAssignBridgesToRing(self.splitter.hmac, self.totalSubrings, subring) + f = filterAssignBridgesToRing(self.hashring.hmac, self.totalSubrings, subring) previousFilters.append(f) return frozenset(previousFilters)
@@ -343,8 +343,8 @@ class IPBasedDistributor(Distributor): logging.info("Attempting to return %d bridges to client %s..." % (N, bridgeRequest.client))
- if not len(self.splitter): - logging.warn("Bailing! Splitter has zero bridges!") + if not len(self.hashring): + logging.warn("Bailing! Hashring has zero bridges!") return []
usingProxy = False @@ -373,16 +373,16 @@ class IPBasedDistributor(Distributor): logging.debug("Bridge filters: %s" % ' '.join([x.func_name for x in filters]))
# Check wheth we have a cached copy of the hashring: - if filters in self.splitter.filterRings.keys(): + if filters in self.hashring.filterRings.keys(): logging.debug("Cache hit %s" % filters) - _, ring = self.splitter.filterRings[filters] + _, ring = self.hashring.filterRings[filters] # Otherwise, construct a new hashring and populate it: else: logging.debug("Cache miss %s" % filters) key1 = getHMAC(self.key, "Order-Bridges-In-Ring-%d" % subring) ring = bridgedb.Bridges.BridgeRing(key1, self.answerParameters) - self.splitter.addRing(ring, filters, filterBridgesByRules(filters), - populate_from=self.splitter.bridges) + self.hashring.addRing(ring, filters, filterBridgesByRules(filters), + populate_from=self.hashring.bridges)
# Determine the appropriate number of bridges to give to the client: returnNum = getNumBridgesPerAnswer(ring, max_bridges_per_answer=N) @@ -391,18 +391,18 @@ class IPBasedDistributor(Distributor): return answer
def __len__(self): - return len(self.splitter) + return len(self.hashring)
def dumpAssignments(self, f, description=""): - self.splitter.dumpAssignments(f, description) + self.hashring.dumpAssignments(f, description)
class EmailBasedDistributor(Distributor): """Object that hands out bridges based on the email address of an incoming request and the current time period.
- :type splitter: :class:`~bridgedb.Bridges.BridgeRing` - :ivar splitter: A hashring to hold all the bridges we hand out. + :type hashring: :class:`~bridgedb.Bridges.BridgeRing` + :ivar hashring: A hashring to hold all the bridges we hand out. """
def __init__(self, key, domainmap, domainrules, @@ -434,14 +434,14 @@ class EmailBasedDistributor(Distributor): self.answerParameters = answerParameters
#XXX cache options not implemented - self.splitter = bridgedb.Bridges.FilteredBridgeSplitter( + self.hashring = bridgedb.Bridges.FilteredBridgeSplitter( key2, max_cached_rings=5)
self.setDistributorName('Email')
def insert(self, bridge): """Assign a bridge to this distributor.""" - self.splitter.insert(bridge) + self.hashring.insert(bridge)
def getBridges(self, bridgeRequest, interval, N=1): """Return a list of bridges to give to a user. @@ -500,9 +500,9 @@ class EmailBasedDistributor(Distributor):
ring = None ruleset = frozenset(bridgeRequest.filters) - if ruleset in self.splitter.filterRings.keys(): + if ruleset in self.hashring.filterRings.keys(): logging.debug("Cache hit %s" % ruleset) - _, ring = self.splitter.filterRings[ruleset] + _, ring = self.hashring.filterRings[ruleset] else: # cache miss, add new ring logging.debug("Cache miss %s" % ruleset) @@ -510,9 +510,9 @@ class EmailBasedDistributor(Distributor): # add new ring key1 = getHMAC(self.key, "Order-Bridges-In-Ring") ring = bridgedb.Bridges.BridgeRing(key1, self.answerParameters) - self.splitter.addRing(ring, ruleset, + self.hashring.addRing(ring, ruleset, filterBridgesByRules(ruleset), - populate_from=self.splitter.bridges) + populate_from=self.hashring.bridges)
numBridgesToReturn = getNumBridgesPerAnswer(ring, max_bridges_per_answer=N) @@ -524,7 +524,7 @@ class EmailBasedDistributor(Distributor): return result
def __len__(self): - return len(self.splitter) + return len(self.hashring)
def cleanDatabase(self): with bridgedb.Storage.getDB() as db: @@ -538,7 +538,7 @@ class EmailBasedDistributor(Distributor): db.commit()
def dumpAssignments(self, f, description=""): - self.splitter.dumpAssignments(f, description) + self.hashring.dumpAssignments(f, description)
def prepopulateRings(self): # populate all rings (for dumping assignments and testing) @@ -546,6 +546,6 @@ class EmailBasedDistributor(Distributor): ruleset = frozenset([filterFn]) key1 = getHMAC(self.key, "Order-Bridges-In-Ring") ring = bridgedb.Bridges.BridgeRing(key1, self.answerParameters) - self.splitter.addRing(ring, ruleset, + self.hashring.addRing(ring, ruleset, filterBridgesByRules([filterFn]), - populate_from=self.splitter.bridges) + populate_from=self.hashring.bridges) diff --git a/lib/bridgedb/Main.py b/lib/bridgedb/Main.py index d2fd2da..53189fd 100644 --- a/lib/bridgedb/Main.py +++ b/lib/bridgedb/Main.py @@ -39,19 +39,19 @@ from bridgedb import Dist from bridgedb.Stability import updateBridgeHistory
-def load(state, splitter, clear=False): - """Read and parse all descriptors, and load into a bridge splitter. +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.splitter`` instance. The ``state`` will be + store them into our ``state.hashring`` instance. The ``state`` will be saved again at the end of this function.
- :type splitter: :class:`BridgeSplitter <bridgedb.Bridges.BridgeHolder>` - :param splitter: A class which provides a mechanism for HMACing + :type hashring: :class:`BridgeSplitter <bridgedb.Bridges.BridgeHolder>` + :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 - splitter before parsing for new ones. + hashring before parsing for new ones. """ if not state: logging.fatal("bridgedb.Main.load() could not retrieve state!") @@ -59,7 +59,7 @@ def load(state, splitter, clear=False):
if clear: logging.info("Clearing old bridges...") - splitter.clear() + hashring.clear()
logging.info("Loading bridges...")
@@ -137,7 +137,7 @@ def load(state, splitter, clear=False): % router.fingerprint)
inserted = 0 - logging.info("Inserting %d bridges into splitter..." % len(bridges)) + logging.info("Inserting %d bridges into hashring..." % len(bridges)) 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 @@ -148,9 +148,9 @@ def load(state, splitter, clear=False): else: # If the bridge is not running, then it is skipped during the # insertion process. - splitter.insert(bridge) + hashring.insert(bridge) inserted += 1 - logging.info("Done inserting %d bridges into splitter." % inserted) + logging.info("Done inserting %d bridges into hashring." % inserted)
if state.COLLECT_TIMESTAMPS: reactor.callInThread(updateBridgeHistory, bridges, timestamps) @@ -180,7 +180,7 @@ def _handleSIGUSR1(*args):
def replaceBridgeRings(current, replacement): """Replace the current thing with the new one""" - current.splitter = replacement.splitter + current.hashring = replacement.hashring
def createBridgeRings(cfg, proxyList, key): """Create the bridge distributors defined by the config file @@ -192,15 +192,15 @@ def createBridgeRings(cfg, proxyList, key): :type proxyList: :class:`~bridgedb.proxy.ProxySet` :param proxyList: The container for the IP addresses of any currently known open proxies. - :param bytes key: Splitter master key + :param bytes key: Hashring master key :rtype: tuple - :returns: A BridgeSplitter splitter, an IPBasedDistributor or None, + :returns: A BridgeSplitter hashring, an IPBasedDistributor or None, and an EmailBasedDistributor or None. """ # Create a BridgeSplitter to assign the bridges to the different # distributors. - splitter = Bridges.BridgeSplitter(crypto.getHMAC(key, "Splitter-Key")) - logging.debug("Created splitter: %r" % splitter) + hashring = Bridges.BridgeSplitter(crypto.getHMAC(key, "Hashring-Key")) + logging.debug("Created hashring: %r" % hashring)
# Create ring parameters. ringParams = Bridges.BridgeRingParameters(needPorts=cfg.FORCE_PORTS, @@ -215,7 +215,7 @@ def createBridgeRings(cfg, proxyList, key): crypto.getHMAC(key, "HTTPS-IP-Dist-Key"), proxyList, answerParameters=ringParams) - splitter.addRing(ipDistributor, "https", cfg.HTTPS_SHARE) + hashring.addRing(ipDistributor, "https", cfg.HTTPS_SHARE)
# As appropriate, create an email-based distributor. if cfg.EMAIL_DIST and cfg.EMAIL_SHARE: @@ -226,19 +226,19 @@ def createBridgeRings(cfg, proxyList, key): cfg.EMAIL_DOMAIN_RULES.copy(), answerParameters=ringParams, whitelist=cfg.EMAIL_WHITELIST.copy()) - splitter.addRing(emailDistributor, "email", cfg.EMAIL_SHARE) + hashring.addRing(emailDistributor, "email", cfg.EMAIL_SHARE)
- # As appropriate, tell the splitter to leave some bridges unallocated. + # As appropriate, tell the hashring to leave some bridges unallocated. if cfg.RESERVED_SHARE: - splitter.addRing(Bridges.UnallocatedHolder(), + hashring.addRing(Bridges.UnallocatedHolder(), "unallocated", cfg.RESERVED_SHARE)
- # Add pseudo distributors to splitter + # Add pseudo distributors to hashring for pseudoRing in cfg.FILE_BUCKETS.keys(): - splitter.addPseudoRing(pseudoRing) + hashring.addPseudoRing(pseudoRing)
- return splitter, emailDistributor, ipDistributor + return hashring, emailDistributor, ipDistributor
def run(options, reactor=reactor): """This is BridgeDB's main entry point and main runtime loop. @@ -314,7 +314,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``, ``splitter``, ``proxyList``, + The internal variables, ``cfg``, ``hashring``, ``proxyList``, ``ipDistributor``, and ``emailDistributor`` are all taken from a :class:`~bridgedb.persistent.State` instance, which has been saved to a statefile with :meth:`bridgedb.persistent.State.save`. @@ -323,8 +323,8 @@ 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 splitter: A :class:`bridgedb.Bridges.BridgeHolder` - :ivar splitter: A class which takes an HMAC key and splits bridges + :type hashring: A :class:`bridgedb.Bridges.BridgeHolder` + :ivar hashring: A class which takes an HMAC key and splits bridges into their hashring assignments. :type proxyList: :class:`~bridgedb.proxy.ProxySet` :ivar proxyList: The container for the IP addresses of any currently @@ -357,21 +357,21 @@ def run(options, reactor=reactor): proxy.loadProxiesFromFile(proxyfile, state.proxies, removeStale=True)
logging.info("Reparsing bridge descriptors...") - (splitter, + (hashring, emailDistributorTmp, ipDistributorTmp) = createBridgeRings(cfg, state.proxies, key) - logging.info("Bridges loaded: %d" % len(splitter)) + logging.info("Bridges loaded: %d" % len(hashring))
# Initialize our DB. bridgedb.Storage.initializeDBLock() bridgedb.Storage.setDBFilename(cfg.DB_FILE + ".sqlite") - load(state, splitter, clear=False) + load(state, hashring, clear=False)
if emailDistributorTmp is not None: emailDistributorTmp.prepopulateRings() # create default rings logging.info("Bridges allotted for %s distribution: %d" % (emailDistributorTmp.name, - len(emailDistributorTmp.splitter))) + len(emailDistributorTmp.hashring))) else: logging.warn("No email distributor created!")
@@ -380,15 +380,15 @@ def run(options, reactor=reactor):
logging.info("Bridges allotted for %s distribution: %d" % (ipDistributorTmp.name, - len(ipDistributorTmp.splitter))) + len(ipDistributorTmp.hashring))) logging.info("\tNum bridges:\tFilter set:")
nSubrings = 0 - ipSubrings = ipDistributorTmp.splitter.filterRings + ipSubrings = ipDistributorTmp.hashring.filterRings for (ringname, (filterFn, subring)) in ipSubrings.items(): nSubrings += 1 filterSet = ' '.join( - ipDistributorTmp.splitter.extractFilterNames(ringname)) + ipDistributorTmp.hashring.extractFilterNames(ringname)) logging.info("\t%2d bridges\t%s" % (len(subring), filterSet))
logging.info("Total subrings for %s: %d" @@ -403,7 +403,7 @@ def run(options, reactor=reactor): fh = open(state.ASSIGNMENTS_FILE, 'a') fh.write("bridge-pool-assignment %s\n" % time.strftime("%Y-%m-%d %H:%M:%S")) - splitter.dumpAssignments(fh) + hashring.dumpAssignments(fh) fh.flush() fh.close() except IOError: diff --git a/lib/bridgedb/test/legacy_Tests.py b/lib/bridgedb/test/legacy_Tests.py index 7d7d236..dc91c9b 100644 --- a/lib/bridgedb/test/legacy_Tests.py +++ b/lib/bridgedb/test/legacy_Tests.py @@ -311,7 +311,7 @@ class IPBridgeDistTests(unittest.TestCase): d.insert(fakeBridge6(or_addresses=True)) d.insert(fakeBridge(or_addresses=True))
- for b in d.splitter.bridges: + for b in d.hashring.bridges: # china blocks all :-( for pt in b.transports: key = "%s:%s" % (pt.address, pt.port) @@ -337,7 +337,7 @@ class IPBridgeDistTests(unittest.TestCase): d.insert(fakeBridge6(or_addresses=True, transports=True)) d.insert(fakeBridge(or_addresses=True, transports=True))
- for b in d.splitter.bridges: + for b in d.hashring.bridges: # china blocks some transports for pt in b.transports: if random.choice(xrange(2)) > 0: diff --git a/lib/bridgedb/test/test_Main.py b/lib/bridgedb/test/test_Main.py index 43e008c..ec3fdd2 100644 --- a/lib/bridgedb/test/test_Main.py +++ b/lib/bridgedb/test/test_Main.py @@ -111,18 +111,18 @@ class MainTests(unittest.TestCase): return updatedPaths
def _cbAssertFingerprints(self, d): - """Assert that there are some bridges in the splitter.""" - self.assertGreater(len(self.splitter), 0) + """Assert that there are some bridges in the hashring.""" + self.assertGreater(len(self.hashring), 0) return d
- def _cbCallUpdateBridgeHistory(self, d, splitter): - """Fake some timestamps for the bridges in the splitter, and then call + def _cbCallUpdateBridgeHistory(self, d, hashring): + """Fake some timestamps for the bridges in the hashring, and then call Main.updateBridgeHistory(). """ def timestamp(): return datetime.fromtimestamp(random.randint(1324285117, 1524285117))
- bridges = splitter._bridges + bridges = hashring._bridges timestamps = {}
for fingerprint, _ in bridges.items(): @@ -171,7 +171,7 @@ class MainTests(unittest.TestCase): self.key = base64.b64decode('TvPS1y36BFguBmSOvhChgtXB2Lt+BOw0mGfz9SZe12Y=')
# Create a BridgeSplitter - self.splitter = MockBridgeHolder() + self.hashring = MockBridgeHolder()
# Functions which some tests mock, which we'll need to re-replace # later in tearDown(): @@ -193,30 +193,30 @@ class MainTests(unittest.TestCase): # access the database: Main.updateBridgeHistory = mockUpdateBridgeHistory
- # Get the bridges into the mocked splitter - d = deferToThread(Main.load, self.state, self.splitter) + # 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.splitter) + 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.splitter) + d = deferToThread(Main.load, self.state, self.hashring) d.addCallback(self._cbAssertFingerprints) 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.splitter) + 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.splitter, clear=True) + d = deferToThread(Main.load, self.state, self.hashring, clear=True) d.addCallback(self._cbAssertFingerprints) d.addErrback(self._eb_Failure) return d @@ -234,14 +234,14 @@ class MainTests(unittest.TestCase): # 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.splitter) + 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.splitter) + self.assertRaises(ValueError, Main.load, self.state, self.hashring)
def test_Main_reloadFn(self): """Main._reloadFn() should return True.""" @@ -255,79 +255,79 @@ class MainTests(unittest.TestCase):
def test_Main_createBridgeRings(self): """Main.createBridgeRings() should add three hashrings to the - splitter. + hashring. """ proxyList = None - (splitter, emailDist, httpsDist) = Main.createBridgeRings(self.config, + (hashring, emailDist, httpsDist) = Main.createBridgeRings(self.config, proxyList, self.key) # Should have an IPBasedDistributor ring, an EmailDistributor ring, # and an UnallocatedHolder ring: - self.assertEqual(len(splitter.ringsByName.keys()), 3) + self.assertEqual(len(hashring.ringsByName.keys()), 3)
def test_Main_createBridgeRings_with_proxyList(self): """Main.createBridgeRings() should add three hashrings to the - splitter and add the proxyList to the IPBasedDistibutor. + hashring and 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) - (splitter, emailDist, httpsDist) = Main.createBridgeRings(self.config, + (hashring, emailDist, httpsDist) = Main.createBridgeRings(self.config, proxyList, self.key) # Should have an IPBasedDistributor ring, an EmailDistributor ring, # and an UnallocatedHolder ring: - self.assertEqual(len(splitter.ringsByName.keys()), 3) + self.assertEqual(len(hashring.ringsByName.keys()), 3) self.assertGreater(len(httpsDist.proxies), 0) self.assertItemsEqual(exitRelays, httpsDist.proxies)
def test_Main_createBridgeRings_no_https_dist(self): """When HTTPS_DIST=False, Main.createBridgeRings() should add only - two hashrings to the splitter. + two hashrings to the hashring. """ proxyList = Main.proxy.ProxySet() config = self.config config.HTTPS_DIST = False - (splitter, emailDist, httpsDist) = Main.createBridgeRings(config, + (hashring, emailDist, httpsDist) = Main.createBridgeRings(config, proxyList, self.key) # Should have an EmailDistributor ring, and an UnallocatedHolder ring: - self.assertEqual(len(splitter.ringsByName.keys()), 2) - self.assertNotIn('https', splitter.rings) - self.assertNotIn(httpsDist, splitter.ringsByName.values()) + self.assertEqual(len(hashring.ringsByName.keys()), 2) + 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 splitter. + two hashrings to the hashring. """ proxyList = Main.proxy.ProxySet() config = self.config config.EMAIL_DIST = False - (splitter, emailDist, httpsDist) = Main.createBridgeRings(config, + (hashring, emailDist, httpsDist) = Main.createBridgeRings(config, proxyList, self.key) # Should have an IPBasedDistributor ring, and an UnallocatedHolder ring: - self.assertEqual(len(splitter.ringsByName.keys()), 2) - self.assertNotIn('email', splitter.rings) - self.assertNotIn(emailDist, splitter.ringsByName.values()) + self.assertEqual(len(hashring.ringsByName.keys()), 2) + 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 splitter. + two hashrings to the hashring. """ proxyList = Main.proxy.ProxySet() config = self.config config.RESERVED_SHARE = 0 - (splitter, emailDist, httpsDist) = Main.createBridgeRings(config, + (hashring, emailDist, httpsDist) = Main.createBridgeRings(config, proxyList, self.key) # Should have an IPBasedDistributor ring, and an EmailDistributor ring: - self.assertEqual(len(splitter.ringsByName.keys()), 2) - self.assertNotIn('unallocated', splitter.rings) + self.assertEqual(len(hashring.ringsByName.keys()), 2) + self.assertNotIn('unallocated', hashring.rings)
def test_Main_createBridgeRings_two_file_buckets(self): """When FILE_BUCKETS has two filenames in it, Main.createBridgeRings() - should add three hashrings to the splitter, then add two + should add three hashrings to the hashring, then add two "pseudo-rings". """ proxyList = Main.proxy.ProxySet() @@ -336,17 +336,17 @@ class MainTests(unittest.TestCase): 'bridges-for-support-desk': 10, 'bridges-for-ooni-tests': 10, } - (splitter, emailDist, httpsDist) = Main.createBridgeRings(config, + (hashring, emailDist, httpsDist) = Main.createBridgeRings(config, proxyList, self.key) # Should have an IPBasedDistributor ring, an EmailDistributor, and an # UnallocatedHolder ring: - self.assertEqual(len(splitter.ringsByName.keys()), 3) + self.assertEqual(len(hashring.ringsByName.keys()), 3)
# Should have two pseudoRings: - self.assertEqual(len(splitter.pseudoRings), 2) - self.assertIn('pseudo_bridges-for-support-desk', splitter.pseudoRings) - self.assertIn('pseudo_bridges-for-ooni-tests', splitter.pseudoRings) + self.assertEqual(len(hashring.pseudoRings), 2) + self.assertIn('pseudo_bridges-for-support-desk', hashring.pseudoRings) + self.assertIn('pseudo_bridges-for-ooni-tests', hashring.pseudoRings)
def test_Main_run(self): """Main.run() should run and then finally raise SystemExit.""" diff --git a/lib/bridgedb/test/test_bridges.py b/lib/bridgedb/test/test_bridges.py index 88b858e..e48e20a 100644 --- a/lib/bridgedb/test/test_bridges.py +++ b/lib/bridgedb/test/test_bridges.py @@ -167,7 +167,7 @@ class BridgeIntegrationTests(unittest.TestCase): test_getConfigLine_vanilla_withoutFingerprint test_integration_getConfigLine_vanilla_withoutFingerprint test_getConfigLine_vanilla_withFingerprint test_integration_getConfigLine_vanilla_withFingerprint test_getConfigLine_scramblesuit_withFingeprint test_integration_getConfigLine_scramblesuit_withFingerprint - test_splitterBridgeInsertion test_integration_splitterBridgeInsertion + test_splitterBridgeInsertion test_integration_hashringBridgeInsertion ============================================== ======================== .. """ @@ -318,9 +318,9 @@ class BridgeIntegrationTests(unittest.TestCase): % (self.fingerprint, ptArgsList), bridgeLine)
- def test_integration_splitterBridgeInsertion(self): + def test_integration_hashringBridgeInsertion(self): key = "Testing-Bridges-To-Rings" - splitter = FilteredBridgeSplitter(key) + hashring = FilteredBridgeSplitter(key)
bridge1 = bridges.Bridge('unamed1', '1.2.3.5', 9100, 'a1cc8dfef1fa11af9c40af1054df9daf45250550') @@ -335,18 +335,18 @@ class BridgeIntegrationTests(unittest.TestCase): 'b1cc8dfef1fa11af9c40af1054df9daf45250552') bridge4.setStatus(running = True)
- self.failUnlessEqual(len(splitter), 0) - splitter.insert(bridge1) - splitter.insert(bridge2) - splitter.insert(bridge3) + self.failUnlessEqual(len(hashring), 0) + hashring.insert(bridge1) + hashring.insert(bridge2) + hashring.insert(bridge3) # Check that all were inserted - self.failUnlessEqual(len(splitter), 3) - splitter.insert(bridge1) + self.failUnlessEqual(len(hashring), 3) + hashring.insert(bridge1) # Check that the same bridge is not inserted twice - self.failUnlessEqual(len(splitter), 3) - splitter.insert(bridge4) + self.failUnlessEqual(len(hashring), 3) + hashring.insert(bridge4) # Check that identical bridges are not inserted twice - self.failUnlessEqual(len(splitter), 3) + self.failUnlessEqual(len(hashring), 3)
class FlagsTests(unittest.TestCase):