This breaks backwards compatibility with Tahoe v0.2 -- the first public release of Tahoe.
information for the potential landlord to evaluate the lease, *and* to make a
connection back to the starting node:
- message = [verifierid, sharesize, requestor_pburl, starting_points]
+ message = [verifierid, sharesize, requestor_furl, starting_points]
The node looks through its list of finger connections and splits this message
into up to log2(N) smaller messages, each of which contains only the starting
While in "search" mode, each node interprets the message as a lease request.
It checks its storage pool to see if it can accomodate the reservation. If
-so, it uses requestor_pburl to contact the originator and announces its
+so, it uses requestor_furl to contact the originator and announces its
willingness to host the given sharenum. This message will include the
reliability measurement derived from the host's counterclockwise neighbors.
message-in-a-bottle for each share. Each message says "Dear Sir/Madam, I
would like to store X bytes of data for file Y (share #Z) on a system close
to (but not below) nodeid STARTING_POINT. If you find this amenable, please
-contact me at PBURL so we can make arrangements.". These messages are then
+contact me at FURL so we can make arrangements.". These messages are then
bundled together according to their rough destination (STARTING_POINT) and
sent somewhere in the right direction.
def __init__(self, basedir="."):
node.Node.__init__(self, basedir)
- self.my_pburl = None
+ self.my_furl = None
self.introducer_client = None
self.connected_to_vdrive = False
self.add_service(StorageServer(os.path.join(basedir, self.STOREDIR)))
def tub_ready(self):
self.log("tub_ready")
- self.my_pburl = self.tub.registerReference(self)
+ self.my_furl = self.tub.registerReference(self)
- ic = IntroducerClient(self.tub, self.introducer_furl, self.my_pburl)
+ ic = IntroducerClient(self.tub, self.introducer_furl, self.my_furl)
self.introducer_client = ic
ic.setServiceParent(self)
c = ControlServer()
c.setServiceParent(self)
control_url = self.tub.registerReference(c)
- f = open("control.pburl", "w")
+ f = open("control.furl", "w")
f.write(control_url + "\n")
f.close()
- os.chmod("control.pburl", 0600)
+ os.chmod("control.furl", 0600)
def _got_vdrive(self, vdrive_root):
# vdrive_root implements RIMutableDirectoryNode
minLength=HASH_SIZE)# binary format 32-byte SHA256 hash
Nodeid = StringConstraint(maxLength=20,
minLength=20) # binary format 20-byte SHA1 hash
-PBURL = StringConstraint(1000)
+FURL = StringConstraint(1000)
Verifierid = StringConstraint(20)
URI = StringConstraint(300) # kind of arbitrary
MAX_BUCKETS = 200 # per peer
ShareData = StringConstraint(100000)
class RIIntroducerClient(RemoteInterface):
- def new_peers(pburls=SetOf(PBURL)):
+ def new_peers(furls=SetOf(FURL)):
return None
class RIIntroducer(RemoteInterface):
- def hello(node=RIIntroducerClient, pburl=PBURL):
+ def hello(node=RIIntroducerClient, furl=FURL):
return None
class RIClient(RemoteInterface):
def __init__(self):
service.MultiService.__init__(self)
self.nodes = set()
- self.pburls = set()
+ self.furls = set()
- def remote_hello(self, node, pburl):
- log.msg("introducer: new contact at %s, node is %s" % (pburl, node))
+ def remote_hello(self, node, furl):
+ log.msg("introducer: new contact at %s, node is %s" % (furl, node))
def _remove():
- log.msg(" introducer: removing %s %s" % (node, pburl))
+ log.msg(" introducer: removing %s %s" % (node, furl))
self.nodes.remove(node)
- self.pburls.remove(pburl)
+ self.furls.remove(furl)
node.notifyOnDisconnect(_remove)
- self.pburls.add(pburl)
- node.callRemote("new_peers", self.pburls)
+ self.furls.add(furl)
+ node.callRemote("new_peers", self.furls)
for othernode in self.nodes:
- othernode.callRemote("new_peers", set([pburl]))
+ othernode.callRemote("new_peers", set([furl]))
self.nodes.add(node)
class IntroducerClient(service.Service, Referenceable):
implements(RIIntroducerClient)
- def __init__(self, tub, introducer_pburl, my_pburl):
+ def __init__(self, tub, introducer_furl, my_furl):
self.tub = tub
- self.introducer_pburl = introducer_pburl
- self.my_pburl = my_pburl
+ self.introducer_furl = introducer_furl
+ self.my_furl = my_furl
self.connections = {} # k: nodeid, v: ref
- self.reconnectors = {} # k: PBURL, v: reconnector
+ self.reconnectors = {} # k: FURL, v: reconnector
self.connection_observers = observer.ObserverList()
def startService(self):
- self.introducer_reconnector = self.tub.connectTo(self.introducer_pburl,
+ self.introducer_reconnector = self.tub.connectTo(self.introducer_furl,
self._got_introducer)
def log(self, msg):
self.parent.log(msg)
- def remote_new_peers(self, pburls):
- for pburl in pburls:
- self._new_peer(pburl)
+ def remote_new_peers(self, furls):
+ for furl in furls:
+ self._new_peer(furl)
def stopService(self):
service.Service.stopService(self)
for reconnector in self.reconnectors.itervalues():
reconnector.stopConnecting()
- def _new_peer(self, pburl):
- if pburl in self.reconnectors:
+ def _new_peer(self, furl):
+ if furl in self.reconnectors:
return
# TODO: rather than using the TubID as a nodeid, we should use
# something else. The thing that requires the least additional
# mappings is to use the foolscap "identifier" (the last component of
- # the pburl), since these are unguessable. Before we can do that,
+ # the furl), since these are unguessable. Before we can do that,
# though, we need a way to conveniently make these identifiers
# persist from one run of the client program to the next. Also, using
# the foolscap identifier would mean that anyone who knows the name
# of the node also has all the secrets they need to contact and use
# them, which may or may not be what we want.
- m = re.match(r'pb://(\w+)@', pburl)
+ m = re.match(r'pb://(\w+)@', furl)
assert m
nodeid = idlib.a2b(m.group(1))
def _got_peer(rref):
# not. Could this cause a problem?
del self.connections[nodeid]
rref.notifyOnDisconnect(_lost)
- self.log(" connecting to(%s)" % pburl)
- self.reconnectors[pburl] = self.tub.connectTo(pburl, _got_peer)
+ self.log(" connecting to(%s)" % furl)
+ self.reconnectors[furl] = self.tub.connectTo(furl, _got_peer)
def _got_introducer(self, introducer):
- self.log(" introducing ourselves: %s, %s" % (self, self.my_pburl))
+ self.log(" introducing ourselves: %s, %s" % (self, self.my_furl))
d = introducer.callRemote("hello",
node=self,
- pburl=self.my_pburl)
+ furl=self.my_furl)
def notify_on_new_connection(self, cb):
"""Register a callback that will be fired (with nodeid, rref) when
def test_create(self):
- ic = IntroducerClient(None, "introducer", "mypburl")
+ ic = IntroducerClient(None, "introducer", "myfurl")
def _ignore(nodeid, rref):
pass
ic.notify_on_new_connection(_ignore)
tub.setLocation("localhost:%d" % portnum)
n = MyNode()
- node_pburl = tub.registerReference(n)
- c = IntroducerClient(tub, iurl, node_pburl)
+ node_furl = tub.registerReference(n)
+ c = IntroducerClient(tub, iurl, node_furl)
c.notify_on_new_connection(_count)
c.setServiceParent(self.parent)
clients.append(c)
clients = []
for i in range(5):
n = MyNode()
- node_pburl = tub.registerReference(n)
- c = IntroducerClient(tub, iurl, node_pburl)
+ node_furl = tub.registerReference(n)
+ c = IntroducerClient(tub, iurl, node_furl)
c.setServiceParent(self.parent)
clients.append(c)
tub.setLocation("localhost:%d" % portnum)
n = MyNode()
- node_pburl = tub.registerReference(n)
- c = IntroducerClient(tub, iurl, node_pburl)
+ node_furl = tub.registerReference(n)
+ c = IntroducerClient(tub, iurl, node_furl)
c.setServiceParent(self.parent)
clients.append(c)
<h2>Grid Status</h2>
<div>My nodeid: <span n:render="string" n:data="my_nodeid" /></div>
-<div>Introducer: <span n:render="string" n:data="introducer_pburl" /></div>
+<div>Introducer: <span n:render="string" n:data="introducer_furl" /></div>
<div>Connected to introducer?: <span n:render="string" n:data="connected_to_introducer" /></div>
<div>Known+Connected Peers: <span n:render="string" n:data="num_peers" /></div>
def data_my_nodeid(self, ctx, data):
return idlib.b2a(IClient(ctx).nodeid)
- def data_introducer_pburl(self, ctx, data):
+ def data_introducer_furl(self, ctx, data):
return IClient(ctx).introducer_furl
def data_connected_to_introducer(self, ctx, data):
if IClient(ctx).connected_to_vdrive:
projects / tahoe-lafs / tahoe-lafs.git / commitdiff