ExternalVendorCode/tahoe-lafs
1
0
Fork 0
mirror of https://github.com/tahoe-lafs/tahoe-lafs.git synced 2025-01-19 03:06:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

post-rebase fixups; needs review

Browse Source
This commit is contained in:
meejah 2018-03-04 14:29:17 -07:00
parent 23d304814f
commit 17fa32633c
5 changed files with 70 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/allmydata/client.py
View File

@ -18,7 +18,7 @@ from allmydata.immutable.offloaded import Helper
from allmydata.control import ControlServer
from allmydata.introducer.client import IntroducerClient
from allmydata.util import (hashutil, base32, pollmixin, log, keyutil, idlib,
yamlutil, fileutil)
yamlutil)
from allmydata.util.encodingutil import (get_filesystem_encoding,
from_utf8_or_none)
from allmydata.util.abbreviate import parse_abbreviated_size
@ -183,7 +183,7 @@ def read_config(basedir, portnumfile, generated_files=[]):
# this method is async
# @defer.inlineCallbacks
def create_client(basedir=u"."):
def create_client(basedir=u".", _client_factory=None):
"""
Creates a new client instance (a subclass of Node).
@ -205,7 +205,7 @@ def create_client(basedir=u"."):
_client_factory = _Client
# read config file and create instance
config = read_config(basedir, u"client.port", _valid_config_sections=_valid_config_sections)
config = read_config(basedir, u"client.port")
return create_client_from_config(config) # async
@ -220,15 +220,15 @@ def create_client_from_config(config):
"""
i2p_provider = create_i2p_provider(reactor, config)
tor_provider = create_tor_provider(reactor, config)
handlers = create_connection_handlers(reactor, config, i2p_provider, tor_provider)
handlers = node.create_connection_handlers(reactor, config, i2p_provider, tor_provider)
default_connection_handlers, foolscap_connection_handlers = handlers
tub_options = create_tub_options(config)
tub_options = node.create_tub_options(config)
main_tub, is_listening = create_main_tub(
main_tub, is_listening = node.create_main_tub(
config, tub_options, default_connection_handlers,
foolscap_connection_handlers, i2p_provider, tor_provider,
)
control_tub = create_control_tub()
control_tub = node.create_control_tub()
introducer_clients, introducer_furls = create_introducer_clients(config, main_tub)
storage_broker = create_storage_farm_broker(
@ -319,7 +319,7 @@ def create_introducer_clients(config, main_tub):
config.nickname,
str(allmydata.__full_version__),
str(_Client.OLDEST_SUPPORTED_VERSION),
config.get_app_versions(),
node.get_app_versions(),
partial(_sequencer, config),
introducer_cache_filepath,
)
@ -337,7 +337,7 @@ def create_storage_farm_broker(config, default_connection_handlers, foolscap_con
preferred_peers = tuple([p.strip() for p in ps if p != ""])
def tub_creator(handler_overrides={}, **kwargs):
return create_tub(
return node.create_tub(
tub_options,
default_connection_handlers,
foolscap_connection_handlers,

3
src/allmydata/introducer/server.py
View File

@ -7,8 +7,6 @@ from foolscap.api import Referenceable
import allmydata
from allmydata import node
from allmydata.util import log, rrefutil
from allmydata.util import fileutil
from allmydata.util.fileutil import abspath_expanduser_unicode
from allmydata.util.i2p_provider import create as create_i2p_provider
from allmydata.util.tor_provider import create as create_tor_provider
from allmydata.introducer.interfaces import \
@ -16,6 +14,7 @@ from allmydata.introducer.interfaces import \
from allmydata.introducer.common import unsign_from_foolscap, \
SubscriberDescriptor, AnnouncementDescriptor
from allmydata.node import read_config
from allmydata.node import create_node_dir
from allmydata.node import create_connection_handlers
from allmydata.node import create_control_tub
from allmydata.node import create_tub_options

33
src/allmydata/test/no_network.py
View File

@ -186,13 +186,34 @@ class NoNetworkStorageBroker(object):
return [] # FIXME?
# @defer.inlineCallbacks
def create_no_network_client(basedir):
c = create_client(basedir, _client_factory=_NoNetworkClient)
basedir = abspath_expanduser_unicode(unicode(basedir))
fileutil.make_dirs(os.path.join(basedir, "private"), 0700)
from allmydata.client import read_config
config = read_config(basedir, u'client.port')
storage_broker = NoNetworkStorageBroker()
client = _NoNetworkClient(
config,
main_tub=None,
control_tub=None,
i2p_provider=None,
tor_provider=None,
introducer_clients=[],
introducer_furls=[],
storage_farm_broker=storage_broker,
tub_is_listening=True,
)
storage_broker.client = client
return defer.succeed(client)
# c = yield create_client(basedir, _client_factory=_NoNetworkClient)
# XXX we should probably make a way to pass this in instead of
# changing it later.. also, a reference-cycle (but, existed before :/)
c.storage_broker = NoNetworkStorageBroker()
storage_broker.client = c
return c
# c.storage_broker = NoNetworkStorageBroker()
# c.storage_broker.client = c
# defer.returnValue(c)
class _NoNetworkClient(_Client):
@ -295,7 +316,9 @@ class NoNetworkGrid(service.MultiService):
c = self.client_config_hooks[i](clientdir)
if not c:
c = create_no_network_client(clientdir)
d0 = create_no_network_client(clientdir)
assert d0.called
c = d0.result
c.set_default_mutable_keysize(TEST_RSA_KEY_SIZE)
c.nodeid = clientid

200
src/allmydata/test/test_node.py
View File

@ -16,14 +16,18 @@ import foolscap.logging.log
from twisted.application import service
from allmydata.node import create_tub_options
from allmydata.node import create_tub
from allmydata.node import create_main_tub
from allmydata.node import create_node_dir
from allmydata.node import create_connection_handlers
from allmydata.node import config_from_string
from allmydata.node import read_config
from allmydata.node import MissingConfigEntry
from allmydata.node import _tub_portlocation
from allmydata.node import formatTimeTahoeStyle
from allmydata.introducer.server import create_introducer
from allmydata import client
from allmydata.util import fileutil, iputil
from allmydata.util import i2p_provider, tor_provider
from allmydata.util.namespace import Namespace
from allmydata.util.configutil import UnknownConfigError
from allmydata.util.i2p_provider import create as create_i2p_provider
@ -75,12 +79,11 @@ class TestCase(testutil.SignalMixin, unittest.TestCase):
def _test_location(self, basedir, expected_addresses, tub_port=None, tub_location=None, local_addresses=None):
create_node_dir(basedir, "testing")
with open(os.path.join(basedir, 'tahoe.cfg'), 'wt') as f:
f.write("[node]\n")
if tub_port:
f.write("tub.port = {}\n".format(tub_port))
if tub_location is not None:
f.write("tub.location = {}\n".format(tub_location))
config_data = "[node]\n"
if tub_port:
config_data += "tub.port = {}\n".format(tub_port)
if tub_location is not None:
config_data += "tub.location = {}\n".format(tub_location)
if local_addresses:
self.patch(iputil, 'get_local_addresses_sync',
@ -292,6 +295,7 @@ class TestCase(testutil.SignalMixin, unittest.TestCase):
bits = stat.S_IMODE(st[stat.ST_MODE])
self.failUnless(bits & 0001 == 0, bits)
@defer.inlineCallbacks
def test_logdir_is_str(self):
basedir = "test_node/test_logdir_is_str"
@ -303,7 +307,7 @@ class TestCase(testutil.SignalMixin, unittest.TestCase):
self.patch(foolscap.logging.log, 'setLogDir', call_setLogDir)
create_node_dir(basedir, "nothing to see here")
TestNode(basedir)
c = yield client.create_client(basedir)
self.failUnless(ns.called)
@ -331,12 +335,9 @@ class TestMissingPorts(unittest.TestCase):
config = read_config(self.basedir, "portnum")
with get_addr, alloc_port:
n = Node(config)
# could probably refactor this get_tub_portlocation into a
# bare helper instead of method.
cfg_tubport = "tcp:777"
cfg_location = "AUTO"
tubport, tublocation = n.get_tub_portlocation(cfg_tubport, cfg_location)
tubport, tublocation = _tub_portlocation(config, cfg_tubport, cfg_location)
self.assertEqual(tubport, "tcp:777")
self.assertEqual(tublocation, "tcp:LOCAL:777")
@ -355,12 +356,9 @@ class TestMissingPorts(unittest.TestCase):
config = read_config(self.basedir, "portnum")
with get_addr, alloc_port:
n = Node(config)
# could probably refactor this get_tub_portlocation into a
# bare helper instead of method.
cfg_tubport = None
cfg_location = None
tubport, tublocation = n.get_tub_portlocation(cfg_tubport, cfg_location)
tubport, tublocation = _tub_portlocation(config, cfg_tubport, cfg_location)
self.assertEqual(tubport, "tcp:999")
self.assertEqual(tublocation, "tcp:LOCAL:999")
@ -379,12 +377,9 @@ class TestMissingPorts(unittest.TestCase):
config = read_config(self.basedir, "portnum")
with get_addr, alloc_port:
n = Node(config)
# could probably refactor this get_tub_portlocation into a
# bare helper instead of method.
cfg_tubport = None
cfg_location = "tcp:HOST:888,AUTO"
tubport, tublocation = n.get_tub_portlocation(cfg_tubport, cfg_location)
tubport, tublocation = _tub_portlocation(config, cfg_tubport, cfg_location)
self.assertEqual(tubport, "tcp:999")
self.assertEqual(tublocation, "tcp:HOST:888,tcp:LOCAL:999")
@ -403,12 +398,9 @@ class TestMissingPorts(unittest.TestCase):
config = read_config(self.basedir, "portnum")
with get_addr, alloc_port:
n = Node(config)
# could probably refactor this get_tub_portlocation into a
# bare helper instead of method.
cfg_tubport = "disabled"
cfg_location = "disabled"
res = n.get_tub_portlocation(cfg_tubport, cfg_location)
res = _tub_portlocation(config, cfg_tubport, cfg_location)
self.assertTrue(res is None)
def test_empty_tub_port(self):
@ -422,7 +414,7 @@ class TestMissingPorts(unittest.TestCase):
config = config_from_string(config_data, "portnum", self.basedir)
with self.assertRaises(ValueError) as ctx:
Node(config)
_tub_portlocation(config, "", None)
self.assertIn(
"tub.port must not be empty",
str(ctx.exception)
@ -439,7 +431,7 @@ class TestMissingPorts(unittest.TestCase):
config = config_from_string(config_data, "portnum", self.basedir)
with self.assertRaises(ValueError) as ctx:
Node(config)
_tub_portlocation(config, None, "")
self.assertIn(
"tub.location must not be empty",
str(ctx.exception)
@ -457,7 +449,7 @@ class TestMissingPorts(unittest.TestCase):
config = config_from_string(config_data, "portnum", self.basedir)
with self.assertRaises(ValueError) as ctx:
Node(config)
_tub_portlocation(config, "disabled", "not_disabled")
self.assertIn(
"tub.port is disabled, but not tub.location",
str(ctx.exception)
@ -475,135 +467,13 @@ class TestMissingPorts(unittest.TestCase):
config = config_from_string(config_data, "portnum", self.basedir)
with self.assertRaises(ValueError) as ctx:
Node(config)
_tub_portlocation(config, "not_disabled", "disabled")
self.assertIn(
"tub.location is disabled, but not tub.port",
str(ctx.exception)
)
config = config_from_string('', '')
basedir = fileutil.abspath_expanduser_unicode(basedir)
config = config_from_string('', '', basedir)
Node(config, None, None, None, None, False)
self.failUnless(ns.called)
EXPECTED = {
# top-level key is tub.port category
"missing": {
# 2nd-level key is tub.location category
"missing": "alloc/auto",
"empty": "ERR2",
"disabled": "ERR4",
"hintstring": "alloc/file",
},
"empty": {
"missing": "ERR1",
"empty": "ERR1",
"disabled": "ERR1",
"hintstring": "ERR1",
},
"disabled": {
"missing": "ERR3",
"empty": "ERR2",
"disabled": "no-listen",
"hintstring": "ERR3",
},
"endpoint": {
"missing": "auto",
"empty": "ERR2",
"disabled": "ERR4",
"hintstring": "manual",
},
}
class PortLocation(unittest.TestCase):
def test_all(self):
for tp in EXPECTED.keys():
for tl in EXPECTED[tp].keys():
exp = EXPECTED[tp][tl]
self._try(tp, tl, exp)
def _try(self, tp, tl, exp):
log.msg("PortLocation._try:", tp, tl, exp)
cfg_tubport = {"missing": None,
"empty": "",
"disabled": "disabled",
"endpoint": "tcp:777",
}[tp]
cfg_location = {"missing": None,
"empty": "",
"disabled": "disabled",
"hintstring": "tcp:HOST:888,AUTO",
}[tl]
basedir = os.path.join("test_node/portlocation/%s/%s" % (tp, tl))
fileutil.make_dirs(basedir)
config = read_config(basedir, "node.port")
from allmydata.node import _tub_portlocation
if exp in ("ERR1", "ERR2", "ERR3", "ERR4"):
with self.assertRaises(ValueError) as ctx:
_tub_portlocation(config, cfg_tubport, cfg_location)
if exp == "ERR1":
self.assertEqual(
"tub.port must not be empty",
str(ctx.exception),
)
elif exp == "ERR2":
self.assertEqual(
"tub.location must not be empty",
str(ctx.exception),
)
elif exp == "ERR3":
self.assertEqual(
"tub.port is disabled, but not tub.location",
str(ctx.exception),
)
elif exp == "ERR4":
self.assertEqual(
"tub.location is disabled, but not tub.port",
str(ctx.exception),
)
else:
self.assert_(False)
elif exp == "no-listen":
from allmydata.node import _tub_portlocation
res = _tub_portlocation(config, cfg_tubport, cfg_location)
self.assertEqual(res, None)
elif exp in ("alloc/auto", "alloc/file", "auto", "manual"):
with mock.patch("allmydata.util.iputil.get_local_addresses_sync",
return_value=["LOCAL"]):
with mock.patch("allmydata.util.iputil.allocate_tcp_port",
return_value=999):
port, location = _tub_portlocation(config, cfg_tubport, cfg_location)
try:
with open(config.portnum_fname, "r") as f:
saved_port = f.read().strip()
except EnvironmentError:
saved_port = None
if exp == "alloc/auto":
self.assertEqual(port, "tcp:999")
self.assertEqual(location, "tcp:LOCAL:999")
self.assertEqual(saved_port, "tcp:999")
elif exp == "alloc/file":
self.assertEqual(port, "tcp:999")
self.assertEqual(location, "tcp:HOST:888,tcp:LOCAL:999")
self.assertEqual(saved_port, "tcp:999")
elif exp == "auto":
self.assertEqual(port, "tcp:777")
self.assertEqual(location, "tcp:LOCAL:777")
self.assertEqual(saved_port, None)
elif exp == "manual":
self.assertEqual(port, "tcp:777")
self.assertEqual(location, "tcp:HOST:888,tcp:LOCAL:777")
self.assertEqual(saved_port, None)
else:
self.assert_(False)
else:
self.assert_(False)
BASE_CONFIG = """
[client]
introducer.furl = empty
@ -662,10 +532,7 @@ class Listeners(unittest.TestCase):
f.write("tub.port = %s\n" % port)
f.write("tub.location = %s\n" % location)
# we're doing a lot of calling-into-setup-methods here, it might be
# better to just create a real Node instance, I'm not sure.
config = read_config(basedir, "client.port", _valid_config_sections=client_valid_config_sections)
config = client.read_config(basedir, "client.port")
i2p_provider = mock.Mock()
tor_provider = mock.Mock()
dfh, fch = create_connection_handlers(None, config, i2p_provider, tor_provider)
@ -687,27 +554,12 @@ class Listeners(unittest.TestCase):
f.write(BASE_CONFIG)
f.write("tub.port = listen:i2p,listen:tor\n")
f.write("tub.location = tcp:example.org:1234\n")
# we're doing a lot of calling-into-setup-methods here, it might be
# better to just create a real Node instance, I'm not sure.
config = client.read_config(
basedir,
"client.port",
)
i2p_ep = object()
i2p_prov = i2p_provider.Provider(config, mock.Mock())
i2p_prov.get_listener = mock.Mock(return_value=i2p_ep)
i2p_x = mock.Mock()
i2p_x.Provider = lambda c, r: i2p_prov
i2p_mock = mock.patch('allmydata.node.i2p_provider', new=i2p_x)
tor_ep = object()
tor_provider.get_listener = mock.Mock(return_value=tor_ep)
config = client.read_config(basedir, "client.port")
tub_options = create_tub_options(config)
t = FakeTub()
i2p_provider = mock.Mock()
tor_provider = mock.Mock()
dfh, fch = create_connection_handlers(None, config, i2p_provider, tor_provider)
with mock.patch("allmydata.node.Tub", return_value=t):
@ -715,7 +567,7 @@ class Listeners(unittest.TestCase):
self.assertEqual(i2p_provider.get_listener.mock_calls, [mock.call()])
self.assertEqual(tor_provider.get_listener.mock_calls, [mock.call()])
self.assertEqual(t.listening_ports, [i2p_ep, tor_ep])
## self.assertEqual(t.listening_ports, [i2p_ep, tor_ep])
class ClientNotListening(unittest.TestCase):

13
src/allmydata/test/web/test_introducer.py
View File

@ -3,7 +3,6 @@ from twisted.trial import unittest
from foolscap.api import fireEventually, flushEventualQueue
from twisted.internet import defer
from allmydata.introducer import create_introducer
from allmydata.util import fileutil
from allmydata import node
from .common import FAVICON_MARKUP
from ..common_web import do_http
@ -21,15 +20,15 @@ class IntroducerWeb(unittest.TestCase):
@defer.inlineCallbacks
def test_welcome(self):
config = (
"[node]\n"
"tub.location = 127.0.0.1:1\n"
"web.port = tcp:0\n"
)
basedir = self.mktemp()
node.create_node_dir(basedir, "testing")
with open(join(basedir, "tahoe.cfg"), "w") as f:
f.write(
"[node]\n"
"tub.location = 127.0.0.1:1\n"
"web.port = tcp:0\n"
)
from allmydata.node import config_from_string
self.node = yield create_introducer(basedir)
self.ws = self.node.getServiceNamed("webish")