rm -rf instdir
create_dirs:
- mkdir -p queen-basedir
+ mkdir -p introducer_and_vdrive-basedir
mkdir -p client-basedir
mkdir -p client-basedir2
mkdir -p client-basedir/storage
directory, inside of which you can add files to configure and control the
node. Nodes also read and write files within that directory.
- A mesh consists of a single central 'introducer' node and a large number of
- 'client' nodes. If you are joining an existing mesh, the introducer node
- will already be running, and you'll just need to create a client node. If
- you're creating a brand new mesh, you'll need to create both an introducer
- and a client (and then invite other people to create their own client nodes
- and join your mesh).
-
- The introducer node is constructed by running 'allmydata-tahoe
+ A mesh consists of a single central 'introducer and vdrive' node and a large
+ number of 'client' nodes. If you are joining an existing mesh, the
+ introducer-and-vdrive node will already be running, and you'll just need to
+ create a client node. If you're creating a brand new mesh, you'll need to
+ create both an introducer-and-vdrive and a client (and then invite other
+ people to create their own client nodes and join your mesh).
+
+ The introducer (-and-vdrive) node is constructed by running 'allmydata-tahoe
create-introducer --basedir $HERE'. Once constructed, you can start the
introducer by running 'allmydata-tahoe start --basedir $HERE' (or, if you
are already in the introducer's base directory, just type 'allmydata-tahoe
The high-level view of this system consists of three layers: the mesh, the
virtual drive, and the application that sits on top.
-The lowest layer is the "mesh" or "cloud", basically a DHT (Distributed Hash
-Table) which maps URIs to data. The URIs are relatively short ascii strings
+The lowest layer is the "mesh", basically a DHT (Distributed Hash Table)
+which maps URIs to data. The URIs are relatively short ascii strings
(currently about 140 bytes), and each is used as references to an immutable
arbitrary-length sequence of data bytes. This data is distributed around the
-cloud in a large number of nodes, such that a statistically unlikely number
+mesh in a large number of nodes, such that a statistically unlikely number
of nodes would have to be unavailable for the data to become unavailable.
The middle layer is the virtual drive: a tree-shaped data structure in which
to get an idea of how much of this has been implemented so far.
-THE BIG CLOUD OF PEERS
+THE BIG MESH OF PEERS
-Underlying the mesh/cloud is a large collection of peer nodes. These are
-processes running on a wide variety of computers, all of which know about
-each other in some way or another. They establish TCP connections to one
-another using Foolscap, an encrypted+authenticated remote message passing
-library (using TLS connections and self-authenticating identifiers called
-"FURLs").
+Underlying the mesh is a large collection of peer nodes. These are processes
+running on a wide variety of computers, all of which know about each other in
+some way or another. They establish TCP connections to one another using
+Foolscap, an encrypted+authenticated remote message passing library (using
+TLS connections and self-authenticating identifiers called "FURLs").
Each peer offers certain services to the others. The primary service is the
StorageServer, which offers to hold data for a limited period of time (a
In this release, peers learn about each other through the "introducer". Each
peer connects to this central introducer at startup, and receives a list of
all other peers from it. Each peer then connects to all other peers, creating
-a full-mesh topology. Future versions will reduce the number of connections
-considerably, to enable the mesh to scale to larger sizes: the design target
-is one million nodes. In addition, future versions will offer relay and
-NAT-traversal services to allow nodes without full internet connectivity to
-participate. In the current release, only one node may be behind a NAT box
-and still permit the cloud to achieve full-mesh connectivity.
+a fully-connected topology. Future versions will reduce the number of
+connections considerably, to enable the mesh to scale to larger sizes: the
+design target is one million nodes. In addition, future versions will offer
+relay and NAT-traversal services to allow nodes without full internet
+connectivity to participate. In the current release, only one node may be
+behind a NAT box and still permit the mesh to achieve full connectivity.
FILE ENCODING
In the current version, the verifierid is used to consistently-permute the
set of all peers (by sorting the peers by HASH(verifierid+peerid)). Each file
gets a different permutation, which (on average) will evenly distribute
-shares among the cloud and avoid hotspots.
+shares among the mesh and avoid hotspots.
This permutation places the peers around a 2^256-sized ring, like the rim of
a big clock. The 100-or-so shares are then placed around the same ring (at 0,
node.py: the base Node, which handles connection establishment and
application startup
- client.py, queen.py: two specialized subclasses of Node, for users
+ client.py, introducer_and_vdrive.py: two specialized subclasses of Node, for users
and the central introducer/vdrive handler, respectively
introducer.py: node introduction handlers, client is used by client.py,
- server is used by queen.py
+ server is used by introducer_and_vdrive.py
storageserver.py: provides storage services to other nodes
filetable.py, vdrive.py: implements the current one-global-vdrive layer,
part runs on client nodes, part runs on the
- central vdrive handler (aka the 'queen')
+ central vdrive handler
webish.py, web/*.xhtml: provides the web frontend, using a Nevow server
test/*.py: unit tests
-Both the client and the central-queen node runs as a tree of
+Both the client and the central introducer-and-vdrive node runs as a tree of
(twisted.application.service) Service instances. The Foolscap "Tub" is one of
-these. Client nodes have an Uploader service and a Downloader service that
-turn data into URIs and back again. They also have a VDrive service which
-provides access to the single global shared filesystem.
+these. Client nodes have an Uploader service and a Downloader service that turn
+data into URIs and back again. They also have a VDrive service which provides
+access to the single global shared filesystem.
The Uploader is given an "upload source" (which could be an open filehandle,
a filename on local disk, or even a string), and returns a Deferred that
each node must maintain open (keep-alived) connections to something like
2*log2(N) peers. In tahoe2, this number is 0 (well, probably 1 for the
- queen).
+ introducer).
during upload, each node must actively use 100 connections to a random set
of peers to push data (just like tahoe2).
return os.urandom(20)
class Node:
- def __init__(self, nid, queen, simulator):
+ def __init__(self, nid, introducer_and_vdrive, simulator):
self.nid = nid
- self.queen = queen
+ self.introducer_and_vdrive = introducer_and_vdrive
self.simulator = simulator
self.shares = {}
self.capacity = random.randrange(1000)
def permute_peers(self, fileid):
permuted = [(sha(fileid+n.nid),n)
- for n in self.queen.get_all_nodes()]
+ for n in self.introducer_and_vdrive.get_all_nodes()]
permuted.sort()
return permuted
node.delete_share(fileid)
return False
self.files.append((fileid, numshares))
- self.queen.please_preserve(fileid, size, tried, last_givento)
+ self.introducer_and_vdrive.please_preserve(fileid, size, tried, last_givento)
return (True, tried)
def accept_share(self, fileid, sharesize):
which = random.choice(self.files)
self.files.remove(which)
fileid,numshares = which
- self.queen.delete(fileid)
+ self.introducer_and_vdrive.delete(fileid)
return True
-class Queen:
+class IntroducerAndVdrive:
def __init__(self, simulator):
self.living_files = {}
self.utilization = 0 # total size of all active files
self.rrd = RRD("/tmp/utilization.rrd", ds=[ds], rra=[rra], start=self.time)
self.rrd.create()
- self.queen = q = Queen(self)
+ self.introducer_and_vdrive = q = IntroducerAndVdrive(self)
self.all_nodes = [Node(randomid(), q, self)
for i in range(self.NUM_NODES)]
q.all_nodes = self.all_nodes
avg_tried = "NONE"
else:
avg_tried = sum(self.published_files) / len(self.published_files)
- print time, etype, self.added_data, self.failed_files, self.lost_data_bytes, avg_tried, len(self.queen.living_files), self.queen.utilization
+ print time, etype, self.added_data, self.failed_files, self.lost_data_bytes, avg_tried, len(self.introducer_and_vdrive.living_files), self.introducer_and_vdrive.utilization
global s
s = None
Other ways to access the filesystem are planned, as well as other structures
than the single globally-shared namespace implemented by this release: please
-see the roadmap.txt for some rough details.
+see the roadmap.txt [5] for some rough details.
HACKING AND COMMUNITY
['*' means complete]
Connection Management:
-*v1: foolscap, no relay, live=connected-to-queen, broadcast updates, full mesh
- v2: live != connected-to-queen, connect on demand
+*v1: foolscap, no relay, live=connected-to-introducer, broadcast updates, fully connected topology
+ v2: live != connected-to-introducer, connect on demand
v3: relay?
File Encoding:
v3: denver airport?
Filetable Maintenance:
-*v1: queen-based tree of MutableDirectoryNodes, persisted to queen's disk
+*v1: vdrive-based tree of MutableDirectoryNodes, persisted to vdrive's disk
no accounts
v2: move tree to client side, serialize to a file, upload,
- queen.set_filetable_uri (still no accounts, just one global tree)
+ vdrive.set_filetable_uri (still no accounts, just one global tree)
v3: break world up into accounts, separate mutable spaces. Maybe
implement SSKs
v4: filetree
v4: FUSE
Operations/Deployment/Doc/Free Software/Community:
- - tweak licence as per zfec's recent tweak
- - move this file into the wiki
- - Windows port and testing
- - Trac instance
- - extirpate all references to "queen" and "metatracker"
- - set up public trac, buildbot reports, mailing list, download page
+ - move this file into the wiki ?
back pocket ideas:
when nodes are unable to reach storage servers, make a note of it, inform
- queen eventually. queen then puts server under observation or otherwise
- looks for differences between their self-reported availability and the
- experiences of others
+ verifier/checker eventually. verifier/checker then puts server under
+ observation or otherwise looks for differences between their self-reported
+ availability and the experiences of others
store filetable URI in the first 10 peers that appear after your own nodeid
each entry has a sequence number, maybe a timestamp
Each subtree's populate_from_node() method is expected to use the
downloader to obtain a file with the subtree's serialized contents
- (probably by pulling data from some source, like the mesh, the queen,
- an HTTP server, or somewhere on the local filesystem), then
+ (probably by pulling data from some source, like the mesh, the vdrive
+ server, an HTTP server, or somewhere on the local filesystem), then
unserialize them and populate the subtree's state.
Return a Deferred that will fire (with self) when this subtree is
I accept an INode-providing specification of a subtree, and return a
Deferred that fires with an ISubTree-providing instance. I will
perform network IO and download the serialized data that the INode
- references, if necessary, or ask the queen (or other provider) for a
- pointer, or read it from local disk.
+ references, if necessary, or ask the vdrive server (or other provider)
+ for a pointer, or read it from local disk.
"""
file.CHKFileNode,
file.SSKFileNode,
redirect.LocalFileRedirectionNode,
- redirect.QueenRedirectionNode,
+ redirect.VdriveRedirectionNode,
redirect.HTTPRedirectionNode,
- redirect.QueenOrLocalFileRedirectionNode,
+ redirect.VdriveOrLocalFileRedirectionNode,
]
class NodeMaker(object):
self._update()
return None
-class QueenRedirectionNode(LocalFileRedirectionNode):
- prefix = "QueenRedirection"
+class VdriveRedirectionNode(LocalFileRedirectionNode):
+ prefix = "VdriveRedirection"
-class QueenRedirection(_BaseRedirection):
- node_class = QueenRedirectionNode
+class VdriveRedirection(_BaseRedirection):
+ node_class = VdriveRedirectionNode
def new(self, handle):
self.handle = handle
return self
def populate_from_node(self, node, parent_is_mutable, node_maker, downloader):
- # this specifies a handle for which the Queen maintains a serialized
+ # this specifies a handle for which the Vdrive maintains a serialized
# subtree specification.
- assert isinstance(node, QueenRedirectionNode)
+ assert isinstance(node, VdriveRedirectionNode)
self.handle = node.handle
- # TODO: queen?
- d = self._queen.callRemote("lookup_handle", self.handle)
+ # TODO: vdrive?
+ d = self._vdrive.callRemote("lookup_handle", self.handle)
d.addCallback(self._populate_from_data, node_maker)
return d
return True # TODO: maybe, maybe not
def create_node_now(self):
- return QueenRedirectionNode().new(self.handle)
+ return VdriveRedirectionNode().new(self.handle)
def update_now(self, uploader):
f = StringIO()
self.serialize_subtree_to_file(f)
- d = self._queen.callRemote("set_handle", self.handle, f.getvalue())
+ d = self._vdrive.callRemote("set_handle", self.handle, f.getvalue())
def _done(res):
return self.create_node_now()
d.addCallback(_done)
return d
def update(self, workqueue):
- f, filename = workqueue.create_tempfile(".toqueen")
+ f, filename = workqueue.create_tempfile(".tovdrive")
self.serialize_subtree_to_file(f)
f.close()
- workqueue.add_queen_update_handle(self.handle, filename)
+ workqueue.add_vdrive_update_handle(self.handle, filename)
workqueue.add_delete_tempfile(filename)
return None
-class QueenOrLocalFileRedirectionNode(LocalFileRedirectionNode):
- prefix = "QueenOrLocalFileRedirection"
+class VdriveOrLocalFileRedirectionNode(LocalFileRedirectionNode):
+ prefix = "VdriveOrLocalFileRedirection"
-class QueenOrLocalFileRedirection(_BaseRedirection):
- node_class = QueenOrLocalFileRedirectionNode
+class VdriveOrLocalFileRedirection(_BaseRedirection):
+ node_class = VdriveOrLocalFileRedirectionNode
def new(self, handle, child_node):
self.handle = handle
def populate_from_node(self, node, parent_is_mutable, node_maker, downloader):
# there is a local file which contains a bencoded serialized
- # subtree specification. The queen also has a copy. Whomever has
+ # subtree specification. The vdrive also has a copy. Whomever has
# the higher version number wins.
- assert isinstance(node, QueenOrLocalFileRedirectionNode)
+ assert isinstance(node, VdriveOrLocalFileRedirectionNode)
self.filename = self.handle = node.handle
f = open(self.filename, "rb")
local_version_and_data = f.read()
f.close()
- # TODO: queen?
- # TODO: pubsub so we can cache the queen's results
- d = self._queen.callRemote("lookup_handle", self.handle)
+ # TODO: vdrive?
+ # TODO: pubsub so we can cache the vdrive's results
+ d = self._vdrive.callRemote("lookup_handle", self.handle)
d.addCallback(self._choose_winner, local_version_and_data)
d.addCallback(self._populate_from_data, node_maker)
return d
- def _choose_winner(self, queen_version_and_data, local_version_and_data):
- queen_version, queen_data = bencode.bdecode(queen_version_and_data)
+ def _choose_winner(self, vdrive_version_and_data, local_version_and_data):
+ vdrive_version, vdrive_data = bencode.bdecode(vdrive_version_and_data)
local_version, local_data = bencode.bdecode(local_version_and_data)
- if queen_version > local_version:
- data = queen_data
- self.version = queen_version
+ if vdrive_version > local_version:
+ data = vdrive_data
+ self.version = vdrive_version
else:
data = local_data
self.version = local_version
return True
def create_node_now(self):
- return QueenOrLocalFileRedirectionNode().new(self.handle)
+ return VdriveOrLocalFileRedirectionNode().new(self.handle)
def _update(self):
self.version += 1
f.write(version_and_data)
f.close()
- d = self._queen.callRemote("set_handle", self.handle, version_and_data)
+ d = self._vdrive.callRemote("set_handle", self.handle, version_and_data)
def _done(res):
return self.create_node_now()
d.addCallback(_done)
f.write(version_and_data)
f.close()
- f, filename = workqueue.create_tempfile(".toqueen")
+ f, filename = workqueue.create_tempfile(".tovdrive")
self.serialize_subtree_to_file(f)
f.close()
- workqueue.add_queen_update_handle(self.handle, filename)
+ workqueue.add_vdrive_update_handle(self.handle, filename)
workqueue.add_delete_tempfile(filename)
return None
directory.CHKDirectorySubTree,
directory.SSKDirectorySubTree,
redirect.LocalFileRedirection,
- redirect.QueenRedirection,
- redirect.QueenOrLocalFileRedirection,
+ redirect.VdriveRedirection,
+ redirect.VdriveOrLocalFileRedirection,
redirect.HTTPRedirection,
]
class SubTreeMaker(object):
implements(ISubTreeMaker)
- def __init__(self, queen, downloader):
+ def __init__(self, downloader):
# this is created with everything it might need to download and
- # create subtrees. That means a Downloader and a reference to the
- # queen.
- self._queen = queen
+ # create subtrees. That means a Downloader and in the future (?) a
+ # reference to the vdrive.
assert IDownloader(downloader)
self._downloader = downloader
self._node_maker = NodeMaker()
workqueue.set_uploader(uploader)
self._downloader = downloader
self._uploader = uploader
- # TODO: queen?
- self.queen = None
self.root_node = root_node
- self.subtree_maker = SubTreeMaker(self.queen, downloader)
+ self.subtree_maker = SubTreeMaker(downloader)
# these methods are used to walk through our subtrees
# really say whether they're mutable or not. But we're pretty sure
# that the new subtree is supposed to be mutable, because we asserted
# that earlier (although I suppose perhaps someone could change a
- # QueenRedirection or an SSK file while we're offline in the middle
+ # VdriveRedirection or an SSK file while we're offline in the middle
# of our workqueue..). Tell the new subtree that their parent is
# mutable so we can be sure it will believe that it itself is
# mutable.
by the parent.
"""
- def add_queen_update_handle(handle, source_filename):
- """Arrange for a central queen to be notified that the given handle
+ def add_vdrive_update_handle(handle, source_filename):
+ """Arrange for a vdrive server to be notified that the given handle
has been updated with the contents of the given tempfile. This will
- send a set_handle() message to the queen."""
+ send a set_handle() message to the vdrive."""
def add_retain_ssk(read_capability):
"""Arrange for the given SSK to be kept alive."""
subtree with the contents.
If 'subtree_node' refers to a redirection subtree like
- LocalFileRedirection or QueenRedirection, then 'localpath' is
+ LocalFileRedirection or VdriveRedirection, then 'localpath' is
ignored, because redirection subtrees don't consume path components
and have no internal directory structure (they just have the one
redirection target). Redirection subtrees generally retain a constant
--- /dev/null
+
+import os.path
+from allmydata import node
+from allmydata.filetable import GlobalVirtualDrive
+from allmydata.introducer import Introducer
+
+
+class IntroducerAndVdrive(node.Node):
+ CERTFILE = "introducer.pem"
+ PORTNUMFILE = "introducer.port"
+ NODETYPE = "introducer"
+
+ def __init__(self, basedir="."):
+ node.Node.__init__(self, basedir)
+ self.urls = {}
+
+ def tub_ready(self):
+ r = self.add_service(Introducer())
+ self.urls["introducer"] = self.tub.registerReference(r, "introducer")
+ self.log(" introducer is at %s" % self.urls["introducer"])
+ f = open(os.path.join(self.basedir, "introducer.furl"), "w")
+ f.write(self.urls["introducer"] + "\n")
+ f.close()
+
+ gvd = self.add_service(GlobalVirtualDrive(self.basedir))
+ self.urls["vdrive"] = self.tub.registerReference(gvd.get_root(),
+ "vdrive")
+ self.log(" vdrive is at %s" % self.urls["vdrive"])
+ f = open(os.path.join(self.basedir, "vdrive.furl"), "w")
+ f.write(self.urls["vdrive"] + "\n")
+ f.close()
+
def makeNamespace():
# close over 'self' so we can get access to .parent later
from allmydata import debugshell
- debugshell.app = self.parent # make client/queen accesible via 'app'
+ debugshell.app = self.parent # make node accessible via 'app'
namespace = {}
for sym in dir(debugshell):
if sym.startswith('__') and sym.endswith('__'):
import foolscap
class Node(service.MultiService):
- # this implements common functionality of both Client nodes and the Queen
- # node.
+ # this implements common functionality of both Client nodes, Introducer
+ # nodes, and Vdrive nodes
NODETYPE = "unknown NODETYPE"
PORTNUMFILE = None
CERTFILE = None
+++ /dev/null
-
-import os.path
-from allmydata import node
-from allmydata.filetable import GlobalVirtualDrive
-from allmydata.introducer import Introducer
-
-
-class Queen(node.Node):
- CERTFILE = "introducer.pem"
- PORTNUMFILE = "introducer.port"
- NODETYPE = "introducer"
-
- def __init__(self, basedir="."):
- node.Node.__init__(self, basedir)
- self.urls = {}
-
- def tub_ready(self):
- r = self.add_service(Introducer())
- self.urls["introducer"] = self.tub.registerReference(r, "introducer")
- self.log(" introducer is at %s" % self.urls["introducer"])
- f = open(os.path.join(self.basedir, "introducer.furl"), "w")
- f.write(self.urls["introducer"] + "\n")
- f.close()
-
- gvd = self.add_service(GlobalVirtualDrive(self.basedir))
- self.urls["vdrive"] = self.tub.registerReference(gvd.get_root(),
- "vdrive")
- self.log(" vdrive is at %s" % self.urls["vdrive"])
- f = open(os.path.join(self.basedir, "vdrive.furl"), "w")
- f.write(self.urls["vdrive"] + "\n")
- f.close()
-
introducer_tac = """
# -*- python -*-
-from allmydata import queen
+from allmydata import introducer_and_vdrive
from twisted.application import service
-c = queen.Queen()
+c = introducer_and_vdrive.IntroducerAndVdrive()
application = service.Application("allmydata_introducer")
c.setServiceParent(application)
from twisted.internet import defer, reactor, protocol, error
from twisted.application import service
-from allmydata import client, queen
+from allmydata import client, introducer_and_vdrive
from allmydata.scripts import runner
from foolscap.eventual import eventually, flushEventualQueue
from twisted.python import log
def start(self):
print "STARTING"
- d = self.make_queen()
+ d = self.make_introducer_and_vdrive()
def _more(res):
self.make_nodes()
self.start_client()
s.setServiceParent(self.sparent)
return s
- def make_queen(self):
- queendir = os.path.join(self.basedir, "queen")
- os.mkdir(queendir)
- self.queen = self.add_service(queen.Queen(basedir=queendir))
- d = self.queen.when_tub_ready()
+ def make_introducer_and_vdrive(self):
+ introducer_and_vdrive_dir = os.path.join(self.basedir, "introducer_and_vdrive")
+ os.mkdir(introducer_and_vdrive_dir)
+ self.introducer_and_vdrive = self.add_service(introducer_and_vdrive.IntroducerAndVdrive(basedir=introducer_and_vdrive_dir))
+ d = self.introducer_and_vdrive.when_tub_ready()
return d
def make_nodes(self):
- q = self.queen
- self.queen_pburl = q.urls["introducer"]
+ q = self.introducer_and_vdrive
+ self.introducer_furl = q.urls["introducer"]
vdrive_furl = q.urls["vdrive"]
self.nodes = []
for i in range(self.numnodes):
nodedir = os.path.join(self.basedir, "node%d" % i)
os.mkdir(nodedir)
f = open(os.path.join(nodedir, "introducer.furl"), "w")
- f.write(self.queen_pburl)
+ f.write(self.introducer_furl)
f.close()
f = open(os.path.join(nodedir, "vdrive.furl"), "w")
f.write(vdrive_furl)
c = self.add_service(client.Client(basedir=nodedir))
self.nodes.append(c)
# the peers will start running, eventually they will connect to each
- # other and the queen
+ # other and the introducer_and_vdrive
def touch_keepalive(self):
f = open(self.keepalive_file, "w")
runner.create_client(config)
log.msg("DONE MAKING CLIENT")
f = open(os.path.join(clientdir, "introducer.furl"), "w")
- f.write(self.queen_pburl + "\n")
+ f.write(self.introducer_furl + "\n")
f.close()
self.keepalive_file = os.path.join(clientdir, "suicide_prevention_hotline")
self.touch_keepalive()
self.failUnlessEqual(c1a, c2a)
def testDirectory(self):
- stm = vdrive.SubTreeMaker(None, FakeMesh())
+ stm = vdrive.SubTreeMaker(FakeMesh())
# create an empty directory (stored locally)
subtree = directory.LocalFileSubTree()
--- /dev/null
+
+from twisted.trial import unittest
+from foolscap.eventual import flushEventualQueue
+
+from allmydata import introducer_and_vdrive
+from allmydata.util import testutil
+
+class Basic(testutil.SignalMixin, unittest.TestCase):
+ def test_loadable(self):
+ q = introducer_and_vdrive.IntroducerAndVdrive()
+ d = q.startService()
+ d.addCallback(lambda res: q.stopService())
+ d.addCallback(flushEventualQueue)
+ return d
+
+++ /dev/null
-
-from twisted.trial import unittest
-from foolscap.eventual import flushEventualQueue
-
-from allmydata import queen
-from allmydata.util import testutil
-
-class Basic(testutil.SignalMixin, unittest.TestCase):
- def test_loadable(self):
- q = queen.Queen()
- d = q.startService()
- d.addCallback(lambda res: q.stopService())
- d.addCallback(flushEventualQueue)
- return d
-
from twisted.trial import unittest
from twisted.internet import defer, reactor
from twisted.application import service
-from allmydata import client, queen, uri, download
+from allmydata import client, introducer_and_vdrive, uri, download
from allmydata.util import idlib, fileutil, testutil
from foolscap.eventual import flushEventualQueue
from twisted.python import log
def set_up_nodes(self, NUMCLIENTS=5):
self.numclients = NUMCLIENTS
- queendir = self.getdir("queen")
- if not os.path.isdir(queendir):
- fileutil.make_dirs(queendir)
- self.queen = self.add_service(queen.Queen(basedir=queendir))
- d = self.queen.when_tub_ready()
+ introducer_and_vdrive_dir = self.getdir("introducer_and_vdrive")
+ if not os.path.isdir(introducer_and_vdrive_dir):
+ fileutil.make_dirs(introducer_and_vdrive_dir)
+ self.introducer_and_vdrive = self.add_service(introducer_and_vdrive.IntroducerAndVdrive(basedir=introducer_and_vdrive_dir))
+ d = self.introducer_and_vdrive.when_tub_ready()
d.addCallback(self._set_up_nodes_2)
return d
def _set_up_nodes_2(self, res):
- q = self.queen
- self.queen_furl = q.urls["introducer"]
+ q = self.introducer_and_vdrive
+ self.introducer_furl = q.urls["introducer"]
self.vdrive_furl = q.urls["vdrive"]
self.clients = []
for i in range(self.numclients):
fileutil.make_dirs(basedir)
if i == 0:
open(os.path.join(basedir, "webport"), "w").write("tcp:0:interface=127.0.0.1")
- open(os.path.join(basedir, "introducer.furl"), "w").write(self.queen_furl)
+ open(os.path.join(basedir, "introducer.furl"), "w").write(self.introducer_furl)
open(os.path.join(basedir, "vdrive.furl"), "w").write(self.vdrive_furl)
c = self.add_service(client.Client(basedir=basedir))
self.clients.append(c)
basedir = self.getdir("client%d" % client_num)
if not os.path.isdir(basedir):
fileutil.make_dirs(basedir)
- open(os.path.join(basedir, "introducer.furl"), "w").write(self.queen_furl)
+ open(os.path.join(basedir, "introducer.furl"), "w").write(self.introducer_furl)
open(os.path.join(basedir, "vdrive.furl"), "w").write(self.vdrive_furl)
c = client.Client(basedir=basedir)
projects / tahoe-lafs / tahoe-lafs.git / commitdiff