Changeset ea35563 in trunk

Timestamp:

2016-06-02T16:47:58Z (9 years ago)

Author:

David Stainton <dstainton415@…>

Branches:

master

Children:

7feee8a2

Parents:

73b08d2

Message:

Remove v1 introducer code and fix tests

Fixed many of the test_introducer tests.
Work-in-progress.

Location:

src/allmydata

Files:

• introducer/client.py (modified) (8 diffs)
• introducer/interfaces.py (modified) (2 diffs)
• introducer/old.py (deleted)
• test/test_introducer.py (modified) (12 diffs)

src/allmydata/introducer/client.py ¶

@@ -3 +3 @@
 from zope.interface import implements
 from twisted.application import service
+from twisted.internet import defer
 from foolscap.api import Referenceable, eventually, RemoteInterface
 from allmydata.interfaces import InsufficientVersionError
 from allmydata.introducer.interfaces import IIntroducerClient, \
-     RIIntroducerSubscriberClient_v1, RIIntroducerSubscriberClient_v2
+     RIIntroducerSubscriberClient_v2
 from allmydata.introducer.common import sign_to_foolscap, unsign_from_foolscap,\
-     convert_announcement_v1_to_v2, convert_announcement_v2_to_v1, \
      make_index, get_tubid_string_from_ann, get_tubid_string
 from allmydata.util import log
@@ -16 +16 @@
 class InvalidCacheError(Exception):
     pass
-
-class WrapV2ClientInV1Interface(Referenceable): # for_v1
-    """I wrap a v2 IntroducerClient to make it look like a v1 client, so it
-    can be attached to an old server."""
-    implements(RIIntroducerSubscriberClient_v1)
-
-    def __init__(self, original):
-        self.original = original
-
-    def remote_announce(self, announcements):
-        lp = self.original.log("received %d announcements (v1)" %
-                               len(announcements))
-        anns_v1 = set([convert_announcement_v1_to_v2(ann_v1)
-                       for ann_v1 in announcements])
-        return self.original.got_announcements(anns_v1, lp)
-
-class RIStubClient(RemoteInterface): # for_v1
-    """Each client publishes a service announcement for a dummy object called
-    the StubClient. This object doesn't actually offer any services, but the
-    announcement helps the Introducer keep track of which clients are
-    subscribed (so the grid admin can keep track of things like the size of
-    the grid and the client versions in use. This is the (empty)
-    RemoteInterface for the StubClient."""
-
-class StubClient(Referenceable): # for_v1
-    implements(RIStubClient)
 
 V1 = "http://allmydata.org/tahoe/protocols/introducer/v1"
@@ -69 +43 @@
                                      "oldest-supported": self._oldest_supported,
                                      }
-        self._stub_client = None # for_v1
-        self._stub_client_furl = None
 
         self._outbound_announcements = {} # not signed
@@ -157 +129 @@
     def _got_introducer(self, publisher):
         self.log("connected to introducer, getting versions")
-        default = { "http://allmydata.org/tahoe/protocols/introducer/v1":
+        default = { "http://allmydata.org/tahoe/protocols/introducer/v2":
                     { },
                     "application-version": "unknown: no get_version()",
@@ -171 +143 @@
     def _got_versioned_introducer(self, publisher):
         self.log("got introducer version: %s" % (publisher.version,))
-        # we require an introducer that speaks at least one of (V1, V2)
-        if not (V1 in publisher.version or V2 in publisher.version):
-            raise InsufficientVersionError("V1 or V2", publisher.version)
+        # we require an introducer that speaks at least V2
+        if V2 not in publisher.version:
+            raise InsufficientVersionError("V2", publisher.version)
         self._publisher = publisher
         publisher.notifyOnDisconnect(self._disconnected)
@@ -214 +186 @@
                 d.addBoth(self._debug_retired)
             else:
-                d = self._subscribe_handle_v1(service_name) # for_v1
+                d = defer.fail(InsufficientVersionError("V2", self._publisher.version))
             d.addErrback(log.err, facility="tahoe.introducer.client",
                          level=log.WEIRD, umid="2uMScQ")
-
-    def _subscribe_handle_v1(self, service_name): # for_v1
-        # they don't speak V2: must be a v1 introducer. Fall back to the v1
-        # 'subscribe' method, using a client adapter.
-        ca = WrapV2ClientInV1Interface(self)
-        self._debug_outstanding += 1
-        d = self._publisher.callRemote("subscribe", ca, service_name)
-        d.addBoth(self._debug_retired)
-        # We must also publish an empty 'stub_client' object, so the
-        # introducer can count how many clients are connected and see what
-        # versions they're running.
-        if not self._stub_client_furl:
-            self._stub_client = sc = StubClient()
-            self._stub_client_furl = self._tub.registerReference(sc)
-        def _publish_stub_client(ignored):
-            furl = self._stub_client_furl
-            self.publish("stub_client",
-                         { "anonymous-storage-FURL": furl,
-                           "permutation-seed-base32": get_tubid_string(furl),
-                           })
-        d.addCallback(_publish_stub_client)
-        return d
 
     def create_announcement_dict(self, service_name, ann):
@@ -282 +232 @@
                 d.addBoth(self._debug_retired)
             else:
-                d = self._handle_v1_publisher(ann_t) # for_v1
+                d = defer.fail(InsufficientVersionError("V2", self._publisher.version))
             d.addErrback(log.err, ann_t=ann_t,
                          facility="tahoe.introducer.client",
                          level=log.WEIRD, umid="xs9pVQ")
 
-    def _handle_v1_publisher(self, ann_t): # for_v1
-        # they don't speak V2, so fall back to the old 'publish' method
-        # (which takes an unsigned tuple of bytestrings)
-        self.log("falling back to publish_v1",
-                 level=log.UNUSUAL, umid="9RCT1A")
-        ann_v1 = convert_announcement_v2_to_v1(ann_t)
-        self._debug_outstanding += 1
-        d = self._publisher.callRemote("publish", ann_v1)
-        d.addBoth(self._debug_retired)
-        return d
-
-
     def remote_announce_v2(self, announcements):
         lp = self.log("received %d announcements (v2)" % len(announcements))
@@ -304 +242 @@
 
     def got_announcements(self, announcements, lp=None):
-        # this is the common entry point for both v1 and v2 announcements
+        # this is the common entry point for announcements
         self._debug_counts["inbound_message"] += 1
         for ann_t in announcements:

src/allmydata/introducer/interfaces.py ¶

@@ -3 +3 @@
 from foolscap.api import StringConstraint, TupleOf, SetOf, DictOf, Any, \
     RemoteInterface, Referenceable
-from old import RIIntroducerSubscriberClient_v1
 FURL = StringConstraint(1000)
-
-# old introducer protocol (v1):
-#
-# Announcements are (FURL, service_name, remoteinterface_name,
-#                    nickname, my_version, oldest_supported)
-#  the (FURL, service_name, remoteinterface_name) refer to the service being
-#  announced. The (nickname, my_version, oldest_supported) refer to the
-#  client as a whole. The my_version/oldest_supported strings can be parsed
-#  by an allmydata.util.version.Version instance, and then compared. The
-#  first goal is to make sure that nodes are not confused by speaking to an
-#  incompatible peer. The second goal is to enable the development of
-#  backwards-compatibility code.
-
-Announcement_v1 = TupleOf(FURL, str, str,
-                          str, str, str)
 
 # v2 protocol over foolscap: Announcements are 3-tuples of (bytes, str, str)
@@ -42 +26 @@
     def get_version():
         return DictOf(str, Any())
-    def publish(announcement=Announcement_v1):
-        return None
     def publish_v2(announcement=Announcement_v2, canary=Referenceable):
-        return None
-    def subscribe(subscriber=RIIntroducerSubscriberClient_v1, service_name=str):
         return None
     def subscribe_v2(subscriber=RIIntroducerSubscriberClient_v2,

src/allmydata/test/test_introducer.py ¶

@@ -12 +12 @@
 from twisted.application import service
 from allmydata.interfaces import InsufficientVersionError
-from allmydata.introducer.client import IntroducerClient, \
-     WrapV2ClientInV1Interface
+from allmydata.introducer.client import IntroducerClient
 from allmydata.introducer.server import IntroducerService, FurlFileConflictError
 from allmydata.introducer.common import get_tubid_string_from_ann, \
      get_tubid_string, sign_to_foolscap, unsign_from_foolscap, \
      UnknownKeyError
-from allmydata.introducer import old
 # test compatibility with old introducer .tac files
 from allmydata.introducer import IntroducerNode
@@ -173 +171 @@
 
 class Client(unittest.TestCase):
-    def test_duplicate_receive_v1(self):
-        ic = IntroducerClient(None,
-                              "introducer.furl", u"my_nickname",
-                              "my_version", "oldest_version", {}, fakeseq,
-                              FilePath(self.mktemp()))
-        announcements = []
-        ic.subscribe_to("storage",
-                        lambda key_s,ann: announcements.append(ann))
-        furl1 = "pb://62ubehyunnyhzs7r6vdonnm2hpi52w6y@127.0.0.1:36106/gydnpigj2ja2qr2srq4ikjwnl7xfgbra"
-        ann1 = (furl1, "storage", "RIStorage", "nick1", "ver23", "ver0")
-        ann1b = (furl1, "storage", "RIStorage", "nick1", "ver24", "ver0")
-        ca = WrapV2ClientInV1Interface(ic)
-
-        ca.remote_announce([ann1])
-        d = fireEventually()
-        def _then(ign):
-            self.failUnlessEqual(len(announcements), 1)
-            self.failUnlessEqual(announcements[0]["nickname"], u"nick1")
-            self.failUnlessEqual(announcements[0]["my-version"], "ver23")
-            self.failUnlessEqual(ic._debug_counts["inbound_announcement"], 1)
-            self.failUnlessEqual(ic._debug_counts["new_announcement"], 1)
-            self.failUnlessEqual(ic._debug_counts["update"], 0)
-            self.failUnlessEqual(ic._debug_counts["duplicate_announcement"], 0)
-            # now send a duplicate announcement: this should not notify clients
-            ca.remote_announce([ann1])
-            return fireEventually()
-        d.addCallback(_then)
-        def _then2(ign):
-            self.failUnlessEqual(len(announcements), 1)
-            self.failUnlessEqual(ic._debug_counts["inbound_announcement"], 2)
-            self.failUnlessEqual(ic._debug_counts["new_announcement"], 1)
-            self.failUnlessEqual(ic._debug_counts["update"], 0)
-            self.failUnlessEqual(ic._debug_counts["duplicate_announcement"], 1)
-            # and a replacement announcement: same FURL, new other stuff.
-            # Clients should be notified.
-            ca.remote_announce([ann1b])
-            return fireEventually()
-        d.addCallback(_then2)
-        def _then3(ign):
-            self.failUnlessEqual(len(announcements), 2)
-            self.failUnlessEqual(ic._debug_counts["inbound_announcement"], 3)
-            self.failUnlessEqual(ic._debug_counts["new_announcement"], 1)
-            self.failUnlessEqual(ic._debug_counts["update"], 1)
-            self.failUnlessEqual(ic._debug_counts["duplicate_announcement"], 1)
-            # test that the other stuff changed
-            self.failUnlessEqual(announcements[-1]["nickname"], u"nick1")
-            self.failUnlessEqual(announcements[-1]["my-version"], "ver24")
-        d.addCallback(_then3)
-        return d
-
     def test_duplicate_receive_v2(self):
         ic1 = IntroducerClient(None,
@@ -331 +279 @@
         return d
 
-    def test_id_collision(self):
-        # test replacement case where tubid equals a keyid (one should
-        # not replace the other)
-        ic = IntroducerClient(None,
-                              "introducer.furl", u"my_nickname",
-                              "my_version", "oldest_version", {}, fakeseq,
-                              FilePath(self.mktemp()))
-        announcements = []
-        ic.subscribe_to("storage",
-                        lambda key_s,ann: announcements.append(ann))
-        sk_s, vk_s = keyutil.make_keypair()
-        sk, _ignored = keyutil.parse_privkey(sk_s)
-        keyid = keyutil.remove_prefix(vk_s, "pub-v0-")
-        furl1 = "pb://onug64tu@127.0.0.1:123/short" # base32("short")
-        furl2 = "pb://%s@127.0.0.1:36106/swissnum" % keyid
-        ann_t = make_ann_t(ic, furl1, sk, 1)
-        ic.remote_announce_v2([ann_t])
-        d = fireEventually()
-        def _then(ign):
-            # first announcement has been processed
-            self.failUnlessEqual(len(announcements), 1)
-            self.failUnlessEqual(announcements[0]["anonymous-storage-FURL"],
-                                 furl1)
-            # now submit a second one, with a tubid that happens to look just
-            # like the pubkey-based serverid we just processed. They should
-            # not overlap.
-            ann2 = (furl2, "storage", "RIStorage", "nick1", "ver23", "ver0")
-            ca = WrapV2ClientInV1Interface(ic)
-            ca.remote_announce([ann2])
-            return fireEventually()
-        d.addCallback(_then)
-        def _then2(ign):
-            # if they overlapped, the second announcement would be ignored
-            self.failUnlessEqual(len(announcements), 2)
-            self.failUnlessEqual(announcements[1]["anonymous-storage-FURL"],
-                                 furl2)
-        d.addCallback(_then2)
-        return d
-
 class Server(unittest.TestCase):
     def test_duplicate(self):
@@ -519 +428 @@
 class SystemTest(SystemTestMixin, unittest.TestCase):
 
-    def do_system_test(self, server_version):
+    def do_system_test(self):
         self.create_tub()
-        if server_version == V1:
-            introducer = old.IntroducerService_v1()
-        else:
-            introducer = IntroducerService()
+        introducer = IntroducerService()
         introducer.setServiceParent(self.parent)
         iff = os.path.join(self.basedir, "introducer.furl")
@@ -559 +465 @@
 
             log.msg("creating client %d: %s" % (i, tub.getShortTubID()))
-            if i == 0:
-                c = old.IntroducerClient_v1(tub, self.introducer_furl,
-                                            NICKNAME % str(i),
-                                            "version", "oldest")
-            else:
-                c = IntroducerClient(tub, self.introducer_furl,
-                                     NICKNAME % str(i),
-                                     "version", "oldest",
-                                     {"component": "component-v1"}, fakeseq,
-                                     FilePath(self.mktemp()))
+            c = IntroducerClient(tub, self.introducer_furl,
+                                 NICKNAME % str(i),
+                                 "version", "oldest",
+                                 {"component": "component-v1"}, fakeseq,
+                                 FilePath(self.mktemp()))
             received_announcements[c] = {}
             def got(key_s_or_tubid, ann, announcements, i):
@@ -583 +484 @@
             if i < NUM_STORAGE:
                 if i == 0:
-                    c.publish(node_furl, "storage", "ri_name")
-                    printable_serverids[i] = get_tubid_string(node_furl)
+                    # XXX wtf this makes no sense
+                    #c.publish(node_furl, "storage", "ri_name")
+                    #printable_serverids[i] = get_tubid_string(node_furl)
+                    pass
                 elif i == 1:
                     # sign the announcement
@@ -591 +494 @@
                     privkeys[c] = privkey
                     c.publish("storage", make_ann(node_furl), privkey)
-                    if server_version == V1:
-                        printable_serverids[i] = get_tubid_string(node_furl)
-                    else:
-                        assert pubkey_s.startswith("pub-")
-                        printable_serverids[i] = pubkey_s[len("pub-"):]
+                    assert pubkey_s.startswith("pub-")
+                    printable_serverids[i] = pubkey_s[len("pub-"):]
                 else:
                     c.publish("storage", make_ann(node_furl))
@@ -609 +509 @@
                 # 'storage' record), so the introducer could see their
                 # version. Match that behavior.
-                c.publish(node_furl, "stub_client", "stub_ri_name")
+                #c.publish(node_furl, "stub_client", "stub_ri_name")
+                pass
 
             if i == 2:
@@ -662 +563 @@
             log.msg("doing _check1")
             dc = self.the_introducer._debug_counts
-            if server_version == V1:
-                # each storage server publishes a record, and (after its
-                # 'subscribe' has been ACKed) also publishes a "stub_client".
-                # The non-storage client (which subscribes) also publishes a
-                # stub_client. There is also one "boring" service. The number
-                # of messages is higher, because the stub_clients aren't
-                # published until after we get the 'subscribe' ack (since we
-                # don't realize that we're dealing with a v1 server [which
-                # needs stub_clients] until then), and the act of publishing
-                # the stub_client causes us to re-send all previous
-                # announcements.
-                self.failUnlessEqual(dc["inbound_message"] - dc["inbound_duplicate"],
-                                     NUM_STORAGE + NUM_CLIENTS + 1)
-            else:
-                # each storage server publishes a record. There is also one
-                # "stub_client" and one "boring"
-                self.failUnlessEqual(dc["inbound_message"], NUM_STORAGE+2)
-                self.failUnlessEqual(dc["inbound_duplicate"], 0)
+            # each storage server publishes a record. There is also one
+            # "stub_client" and one "boring"
+            self.failUnlessEqual(dc["inbound_message"], NUM_STORAGE+2)
+            self.failUnlessEqual(dc["inbound_duplicate"], 0)
             self.failUnlessEqual(dc["inbound_update"], 0)
             self.failUnlessEqual(dc["inbound_subscribe"], NUM_CLIENTS)
@@ -707 +594 @@
                 self.failUnlessEqual(type(nick), unicode)
                 self.failUnlessEqual(nick, NICKNAME % "0")
-            if server_version == V1:
-                for c in publishing_clients:
-                    cdc = c._debug_counts
-                    expected = 1 # storage
-                    if c is clients[2]:
-                        expected += 1 # boring
-                    if c is not clients[0]:
-                        # the v2 client tries to call publish_v2, which fails
-                        # because the server is v1. It then re-sends
-                        # everything it has so far, plus a stub_client record
-                        expected = 2*expected + 1
-                    if c is clients[0]:
-                        # we always tell v1 client to send stub_client
-                        expected += 1
-                    self.failUnlessEqual(cdc["outbound_message"], expected)
-            else:
-                for c in publishing_clients:
-                    cdc = c._debug_counts
-                    expected = 1
-                    if c in [clients[0], # stub_client
-                             clients[2], # boring
-                             ]:
-                        expected = 2
-                    self.failUnlessEqual(cdc["outbound_message"], expected)
+            for c in publishing_clients:
+                cdc = c._debug_counts
+                expected = 1
+                if c in [clients[0], # stub_client
+                         clients[2], # boring
+                ]:
+                    expected = 2
+                self.failUnlessEqual(cdc["outbound_message"], expected)
             # now check the web status, make sure it renders without error
             ir = introweb.IntroducerRoot(self.parent)
@@ -826 +697 @@
                     c._debug_counts[k] = 0
             expected_announcements[i] += 1 # new 'storage' for everyone
-            if server_version == V1:
-                introducer = old.IntroducerService_v1()
-            else:
-                introducer = IntroducerService()
+            introducer = IntroducerService()
             self.the_introducer = introducer
             newfurl = self.central_tub.registerReference(self.the_introducer,
@@ -862 +730 @@
         self.basedir = "introducer/SystemTest/system_v2_server"
         os.makedirs(self.basedir)
-        return self.do_system_test(V2)
+        return self.do_system_test()
     test_system_v2_server.timeout = 480
-    # occasionally takes longer than 350s on "draco"
-
-    def test_system_v1_server(self):
-        self.basedir = "introducer/SystemTest/system_v1_server"
-        os.makedirs(self.basedir)
-        return self.do_system_test(V1)
-    test_system_v1_server.timeout = 480
     # occasionally takes longer than 350s on "draco"