import re, simplejson
-from foolscap.api import SturdyRef
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) for unsigned
+ 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 = get_tubid_string_from_ann(ann)
- return (service_name, None, tubid)
+ 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")
.service_name: which service they are announcing (string)
.version: 'my-version' portion of announcement (string)
.nickname: their self-provided nickname, or "" (unicode)
-
- The following attributes will be empty ([] for lists, "" for strings)
- unless the announcement included an 'anonymous-storage-FURL'.
-
+ .serverid: the server identifier. This is a pubkey (for V2 clients),
+ or a tubid (for V1 clients).
.advertised_addresses: which hosts they listen on (list of strings)
- .tubid: their tubid (string)
+ if the announcement included a key for
+ 'anonymous-storage-FURL', else an empty list.
"""
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
furl = ann_d.get("anonymous-storage-FURL")
if furl:
self.advertised_addresses = rrefutil.hosts_for_furl(furl)
- self.tubid = SturdyRef(furl).tubID
else:
self.advertised_addresses = []
- self.tubid = ""
"service-name": service_name,
"anonymous-storage-FURL": furl,
}
- ad = AnnouncementDescriptor(when, index, None, ann_d)
+ # the V2 introducer uses (service_name, key_s, tubid_s) as an
+ # index, so match that format for AnnouncementDescriptor
+ new_index = (index[0], None, idlib.nodeid_b2a(index[1]))
+ ad = AnnouncementDescriptor(when, new_index, None, ann_d)
announcements.append(ad)
return announcements
# test compatibility with old introducer .tac files
from allmydata.introducer import IntroducerNode
from allmydata.web import introweb
-from allmydata.util import pollmixin, keyutil
+from allmydata.util import pollmixin, keyutil, idlib
import allmydata.test.common_util as testutil
class LoggingMultiService(service.MultiService):
received_announcements = {}
subscribing_clients = []
publishing_clients = []
+ printable_serverids = {}
self.the_introducer = introducer
privkeys = {}
expected_announcements = [0 for c in range(NUM_CLIENTS)]
if i < NUM_STORAGE:
if i == 0:
c.publish(node_furl, "storage", "ri_name")
+ printable_serverids[i] = get_tubid_string(node_furl)
elif i == 1:
# sign the announcement
privkey_s, pubkey_s = keyutil.make_keypair()
privkey, _ignored = keyutil.parse_privkey(privkey_s)
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-"):]
else:
c.publish("storage", make_ann(node_furl))
+ printable_serverids[i] = get_tubid_string(node_furl)
publishing_clients.append(c)
else:
# the last one does not publish anything
text = ir.renderSynchronously().decode("utf-8")
self.failUnlessIn(NICKNAME % "0", text) # the v1 client
self.failUnlessIn(NICKNAME % "1", text) # a v2 client
+ for i in range(NUM_STORAGE):
+ self.failUnlessIn(printable_serverids[i], text,
+ (i,printable_serverids[i],text))
+ # make sure there isn't a double-base32ed string too
+ self.failIfIn(idlib.nodeid_b2a(printable_serverids[i]), text,
+ (i,printable_serverids[i],text))
log.msg("_check1 done")
d.addCallback(_check1)
<tr n:pattern="header">
<th class="nickname-and-peerid">
<div class="service-nickname">Nickname</div>
- <div class="nodeid data-chars">PeerID</div></th>
+ <div class="nodeid data-chars">ServerID</div></th>
<th>Advertised IPs</th>
<th>Announced</th>
<th>Version</th>
<tr n:pattern="item" n:render="service_row">
<td class="nickname-and-peerid">
<div class="nickname"><n:slot name="nickname"/></div>
- <div class="nodeid data-chars"><n:slot name="peerid"/></div></td>
+ <div class="nodeid data-chars"><n:slot name="serverid"/></div></td>
<td><n:slot name="advertised"/></td>
<td class="service-announced"><n:slot name="announced"/></td>
<td class="service-version"><n:slot name="version"/></td>
return services
def render_service_row(self, ctx, ad):
- ctx.fillSlots("peerid", ad.tubid)
+ ctx.fillSlots("serverid", ad.serverid)
ctx.fillSlots("nickname", ad.nickname)
ctx.fillSlots("advertised", " ".join(ad.advertised_addresses))
ctx.fillSlots("connected", "?")