Merge branch '2784-remove-v1-introducer'

Closes PR #289
Closes ticket:2784

src/allmydata/introducer/client.py

@@ -2,47 +2,19 @@
 import time, yaml
 from zope.interface import implements
 from twisted.application import service
-from foolscap.api import Referenceable, eventually, RemoteInterface
+from foolscap.api import Referenceable, eventually
 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
+     get_tubid_string_from_ann
 from allmydata.util import log
 from allmydata.util.rrefutil import add_version_to_remote_reference
 from allmydata.util.keyutil import BadSignatureError
 
 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"
 V2 = "http://allmydata.org/tahoe/protocols/introducer/v2"
 
 class IntroducerClient(service.Service, Referenceable):
@@ -68,8 +40,6 @@ def __init__(self, tub, introducer_furl,
                                      "my-version": self._my_version,
                                      "oldest-supported": self._oldest_supported,
                                      }
-        self._stub_client = None # for_v1
-        self._stub_client_furl = None
 
         self._outbound_announcements = {} # not signed
         self._published_announcements = {} # signed
@@ -170,9 +140,9 @@ def _got_error(self, f):
 
     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)
         self._maybe_publish()
@@ -206,39 +176,14 @@ def _maybe_subscribe(self):
             if service_name in self._subscriptions:
                 continue
             self._subscriptions.add(service_name)
-            if V2 in self._publisher.version:
-                self._debug_outstanding += 1
-                d = self._publisher.callRemote("subscribe_v2",
-                                               self, service_name,
-                                               self._my_subscriber_info)
-                d.addBoth(self._debug_retired)
-            else:
-                d = self._subscribe_handle_v1(service_name) # for_v1
+            self._debug_outstanding += 1
+            d = self._publisher.callRemote("subscribe_v2",
+                                           self, service_name,
+                                           self._my_subscriber_info)
+            d.addBoth(self._debug_retired)
             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):
         ann_d = { "version": 0,
                   # "seqnum" and "nonce" will be populated with new values in
@@ -253,7 +198,7 @@ def create_announcement_dict(self, service_name, ann):
         ann_d.update(ann)
         return ann_d
 
-    def publish(self, service_name, ann, signing_key=None):
+    def publish(self, service_name, ann, signing_key):
         # we increment the seqnum every time we publish something new
         current_seqnum, current_nonce = self._sequencer()
 
@@ -275,35 +220,18 @@ def _maybe_publish(self):
         # this re-publishes everything. The Introducer ignores duplicates
         for ann_t in self._published_announcements.values():
             self._debug_counts["outbound_message"] += 1
-            if V2 in self._publisher.version:
-                self._debug_outstanding += 1
-                d = self._publisher.callRemote("publish_v2", ann_t,
-                                               self._canary)
-                d.addBoth(self._debug_retired)
-            else:
-                d = self._handle_v1_publisher(ann_t) # for_v1
+            self._debug_outstanding += 1
+            d = self._publisher.callRemote("publish_v2", ann_t, self._canary)
+            d.addBoth(self._debug_retired)
             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))
         return self.got_announcements(announcements, lp)
 
     def got_announcements(self, announcements, lp=None):
-        # this is the common entry point for both v1 and v2 announcements
         self._debug_counts["inbound_message"] += 1
         for ann_t in announcements:
             try:
@@ -343,7 +271,7 @@ def _process_announcement(self, ann, key_s):
         description = "/".join(desc_bits)
 
         # the index is used to track duplicates
-        index = make_index(ann, key_s)
+        index = (service_name, key_s)
 
         # is this announcement a duplicate?
         if (index in self._inbound_announcements

src/allmydata/introducer/common.py

@@ -2,20 +2,6 @@
 import re, simplejson
 from allmydata.util import keyutil, base32, rrefutil
 
-def make_index(ann, key_s):
-    """Return something that can be used as an index (e.g. a tuple of
-    strings), such that two messages that refer to the same 'thing' will have
-    the same index. This is a tuple of (service-name, signing-key, None) for
-    signed announcements, or (service-name, None, tubid_s) for unsigned
-    announcements."""
-
-    service_name = str(ann["service-name"])
-    if key_s:
-        return (service_name, key_s, None)
-    else:
-        tubid_s = get_tubid_string_from_ann(ann)
-        return (service_name, None, tubid_s)
-
 def get_tubid_string_from_ann(ann):
     return get_tubid_string(str(ann.get("anonymous-storage-FURL")
                                 or ann.get("FURL")))
@@ -25,52 +11,15 @@ def get_tubid_string(furl):
     assert m
     return m.group(1).lower()
 
-def convert_announcement_v1_to_v2(ann_t):
-    (furl, service_name, ri_name, nickname, ver, oldest) = ann_t
-    assert type(furl) is str
-    assert type(service_name) is str
-    # ignore ri_name
-    assert type(nickname) is str
-    assert type(ver) is str
-    assert type(oldest) is str
-    ann = {"version": 0,
-           "nickname": nickname.decode("utf-8", "replace"),
-           "app-versions": {},
-           "my-version": ver,
-           "oldest-supported": oldest,
-
-           "service-name": service_name,
-           "anonymous-storage-FURL": furl,
-           "permutation-seed-base32": get_tubid_string(furl),
-           }
-    msg = simplejson.dumps(ann).encode("utf-8")
-    return (msg, None, None)
-
-def convert_announcement_v2_to_v1(ann_v2):
-    (msg, sig, pubkey) = ann_v2
-    ann = simplejson.loads(msg)
-    assert ann["version"] == 0
-    ann_t = (str(ann["anonymous-storage-FURL"]),
-             str(ann["service-name"]),
-             "remoteinterface-name is unused",
-             ann["nickname"].encode("utf-8"),
-             str(ann["my-version"]),
-             str(ann["oldest-supported"]),
-             )
-    return ann_t
-
 
 def sign_to_foolscap(ann, sk):
-    # return (bytes, None, None) or (bytes, sig-str, pubkey-str). A future
-    # HTTP-based serialization will use JSON({msg:b64(JSON(msg).utf8),
-    # sig:v0-b64(sig), pubkey:v0-b64(pubkey)}) .
+    # return (bytes, sig-str, pubkey-str). A future HTTP-based serialization
+    # will use JSON({msg:b64(JSON(msg).utf8), sig:v0-b64(sig),
+    # pubkey:v0-b64(pubkey)}) .
     msg = simplejson.dumps(ann).encode("utf-8")
-    if sk:
-        sig = "v0-"+base32.b2a(sk.sign(msg))
-        vk_bytes = sk.get_verifying_key_bytes()
-        ann_t = (msg, sig, "v0-"+base32.b2a(vk_bytes))
-    else:
-        ann_t = (msg, None, None)
+    sig = "v0-"+base32.b2a(sk.sign(msg))
+    vk_bytes = sk.get_verifying_key_bytes()
+    ann_t = (msg, sig, "v0-"+base32.b2a(vk_bytes))
     return ann_t
 
 class UnknownKeyError(Exception):
@@ -144,8 +93,8 @@ def __init__(self, when, index, canary, ann_d):
         self.service_name = ann_d["service-name"]
         self.version = ann_d.get("my-version", "")
         self.nickname = ann_d.get("nickname", u"")
-        (service_name, key_s, tubid_s) = index
-        self.serverid = key_s or tubid_s
+        (service_name, key_s) = index
+        self.serverid = key_s
         furl = ann_d.get("anonymous-storage-FURL")
         if furl:
             self.connection_hints = rrefutil.connection_hints_for_furl(furl)

src/allmydata/introducer/interfaces.py

@@ -1,27 +1,30 @@
 
 from zope.interface import Interface
-from foolscap.api import StringConstraint, TupleOf, SetOf, DictOf, Any, \
+from foolscap.api import StringConstraint, 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)
-# or (bytes, none, none)
+# v2 protocol over foolscap: Announcements are 3-tuples of (msg, sig_vs,
+# claimed_key_vs):
+# * msg (bytes): UTF-8(json(ann_dict))
+#   * ann_dict has IntroducerClient-provided keys like "version", "nickname",
+#     "app-versions", "my-version", "oldest-supported", and "service-name".
+#     Plus service-specific keys like "anonymous-storage-FURL" and
+#     "permutation-seed-base32" (both for service="storage").
+# * sig_vs (str): "v0-"+base32(signature(msg))
+# * claimed_key_vs (str): "v0-"+base32(pubkey)
+
+# (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.
+
+# Note that old v1 clients (which are gone now) did not sign messages, so v2
+# servers would deliver v2-format messages with sig_vs=claimed_key_vs=None.
+# These days we should always get a signature and a pubkey.
+
 Announcement_v2 = Any()
 
 class RIIntroducerSubscriberClient_v2(RemoteInterface):
@@ -41,12 +44,8 @@ class RIIntroducerPublisherAndSubscriberService_v2(RemoteInterface):
     __remote_name__ = "RIIntroducerPublisherAndSubscriberService_v2.tahoe.allmydata.com"
     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,
                      service_name=str, subscriber_info=SubscriberInfo):
         """Give me a subscriber reference, and I will call its announce_v2()