3 from twisted.trial import unittest
4 from twisted.application import service
7 import allmydata.frontends.drop_upload
8 import allmydata.util.log
10 from allmydata.node import Node, OldConfigError, OldConfigOptionError, MissingConfigEntry, UnescapedHashError
11 from allmydata.frontends.auth import NeedRootcapLookupScheme
12 from allmydata import client
13 from allmydata.storage_client import StorageFarmBroker
14 from allmydata.manhole import AuthorizedKeysManhole
15 from allmydata.util import base32, fileutil
16 from allmydata.interfaces import IFilesystemNode, IFileNode, \
17 IImmutableFileNode, IMutableFileNode, IDirectoryNode
18 from foolscap.api import flushEventualQueue
19 import allmydata.test.common_util as testutil
22 BASECONFIG = ("[client]\n"
23 "introducer.furl = \n"
26 BASECONFIG_I = ("[client]\n"
27 "introducer.furl = %s\n"
30 class Basic(testutil.ReallyEqualMixin, unittest.TestCase):
31 def test_loadable(self):
32 basedir = "test_client.Basic.test_loadable"
34 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
36 client.Client(basedir)
38 def test_comment(self):
39 should_fail = [r"test#test", r"#testtest", r"test\\#test"]
40 should_not_fail = [r"test\#test", r"test\\\#test", r"testtest"]
42 basedir = "test_client.Basic.test_comment"
46 config = ("[client]\n"
47 "introducer.furl = %s\n" % s)
48 fileutil.write(os.path.join(basedir, "tahoe.cfg"), config)
51 self.failUnless(Node._contains_unescaped_hash(s))
53 self.failUnlessRaises(UnescapedHashError, client.Client, basedir)
55 for s in should_not_fail:
56 self.failIf(Node._contains_unescaped_hash(s))
58 client.Client(basedir)
61 def test_error_on_old_config_files(self):
62 basedir = "test_client.Basic.test_error_on_old_config_files"
64 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
68 "reserved_space = bogus\n")
69 fileutil.write(os.path.join(basedir, "introducer.furl"), "")
70 fileutil.write(os.path.join(basedir, "no_storage"), "")
71 fileutil.write(os.path.join(basedir, "readonly_storage"), "")
72 fileutil.write(os.path.join(basedir, "debug_discard_storage"), "")
75 self.patch(twisted.python.log, 'msg', logged_messages.append)
77 e = self.failUnlessRaises(OldConfigError, client.Client, basedir)
78 abs_basedir = fileutil.abspath_expanduser_unicode(unicode(basedir)).encode(sys.getfilesystemencoding())
79 self.failUnlessIn(os.path.join(abs_basedir, "introducer.furl"), e.args[0])
80 self.failUnlessIn(os.path.join(abs_basedir, "no_storage"), e.args[0])
81 self.failUnlessIn(os.path.join(abs_basedir, "readonly_storage"), e.args[0])
82 self.failUnlessIn(os.path.join(abs_basedir, "debug_discard_storage"), e.args[0])
84 for oldfile in ['introducer.furl', 'no_storage', 'readonly_storage',
85 'debug_discard_storage']:
86 logged = [ m for m in logged_messages if
87 ("Found pre-Tahoe-LAFS-v1.3 configuration file" in str(m) and oldfile in str(m)) ]
88 self.failUnless(logged, (oldfile, logged_messages))
91 'nickname', 'webport', 'keepalive_timeout', 'log_gatherer.furl',
92 'disconnect_timeout', 'advertised_ip_addresses', 'helper.furl',
93 'key_generator.furl', 'stats_gatherer.furl', 'sizelimit',
95 logged = [ m for m in logged_messages if
96 ("Found pre-Tahoe-LAFS-v1.3 configuration file" in str(m) and oldfile in str(m)) ]
97 self.failIf(logged, (oldfile, logged_messages))
99 def test_secrets(self):
100 basedir = "test_client.Basic.test_secrets"
102 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
104 c = client.Client(basedir)
105 secret_fname = os.path.join(basedir, "private", "secret")
106 self.failUnless(os.path.exists(secret_fname), secret_fname)
107 renew_secret = c.get_renewal_secret()
108 self.failUnless(base32.b2a(renew_secret))
109 cancel_secret = c.get_cancel_secret()
110 self.failUnless(base32.b2a(cancel_secret))
112 def test_nodekey_yes_storage(self):
113 basedir = "test_client.Basic.test_nodekey_yes_storage"
115 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
117 c = client.Client(basedir)
118 self.failUnless(c.get_long_nodeid().startswith("v0-"))
120 def test_nodekey_no_storage(self):
121 basedir = "test_client.Basic.test_nodekey_no_storage"
123 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
124 BASECONFIG + "[storage]\n" + "enabled = false\n")
125 c = client.Client(basedir)
126 self.failUnless(c.get_long_nodeid().startswith("v0-"))
128 def test_reserved_1(self):
129 basedir = "client.Basic.test_reserved_1"
131 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
134 "enabled = true\n" + \
135 "reserved_space = 1000\n")
136 c = client.Client(basedir)
137 self.failUnlessEqual(c.getServiceNamed("storage").reserved_space, 1000)
139 def test_reserved_2(self):
140 basedir = "client.Basic.test_reserved_2"
142 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
145 "enabled = true\n" + \
146 "reserved_space = 10K\n")
147 c = client.Client(basedir)
148 self.failUnlessEqual(c.getServiceNamed("storage").reserved_space, 10*1000)
150 def test_reserved_3(self):
151 basedir = "client.Basic.test_reserved_3"
153 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
156 "enabled = true\n" + \
157 "reserved_space = 5mB\n")
158 c = client.Client(basedir)
159 self.failUnlessEqual(c.getServiceNamed("storage").reserved_space,
162 def test_reserved_4(self):
163 basedir = "client.Basic.test_reserved_4"
165 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
168 "enabled = true\n" + \
169 "reserved_space = 78Gb\n")
170 c = client.Client(basedir)
171 self.failUnlessEqual(c.getServiceNamed("storage").reserved_space,
174 def test_reserved_bad(self):
175 basedir = "client.Basic.test_reserved_bad"
177 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
180 "enabled = true\n" + \
181 "reserved_space = bogus\n")
182 self.failUnlessRaises(ValueError, client.Client, basedir)
184 def test_web_staticdir(self):
185 basedir = u"client.Basic.test_web_staticdir"
187 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
190 "web.port = tcp:0:interface=127.0.0.1\n" +
191 "web.static = relative\n")
192 c = client.Client(basedir)
193 w = c.getServiceNamed("webish")
194 abs_basedir = fileutil.abspath_expanduser_unicode(basedir)
195 expected = fileutil.abspath_expanduser_unicode(u"relative", abs_basedir)
196 self.failUnlessReallyEqual(w.staticdir, expected)
198 def test_manhole_keyfile(self):
199 basedir = u"client.Basic.test_manhole_keyfile"
201 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
204 "ssh.port = tcp:0:interface=127.0.0.1\n" +
205 "ssh.authorized_keys_file = relative\n")
206 c = client.Client(basedir)
207 m = [s for s in c if isinstance(s, AuthorizedKeysManhole)][0]
208 abs_basedir = fileutil.abspath_expanduser_unicode(basedir)
209 expected = fileutil.abspath_expanduser_unicode(u"relative", abs_basedir)
210 self.failUnlessReallyEqual(m.keyfile, expected)
212 # TODO: also test config options for SFTP.
214 def test_ftp_auth_keyfile(self):
215 basedir = u"client.Basic.test_ftp_auth_keyfile"
217 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
221 "port = tcp:0:interface=127.0.0.1\n"
222 "accounts.file = private/accounts\n"))
223 os.mkdir(os.path.join(basedir, "private"))
224 fileutil.write(os.path.join(basedir, "private", "accounts"), "\n")
225 c = client.Client(basedir) # just make sure it can be instantiated
228 def test_ftp_auth_url(self):
229 basedir = u"client.Basic.test_ftp_auth_url"
231 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
235 "port = tcp:0:interface=127.0.0.1\n"
236 "accounts.url = http://0.0.0.0/\n"))
237 c = client.Client(basedir) # just make sure it can be instantiated
240 def test_ftp_auth_no_accountfile_or_url(self):
241 basedir = u"client.Basic.test_ftp_auth_no_accountfile_or_url"
243 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
247 "port = tcp:0:interface=127.0.0.1\n"))
248 self.failUnlessRaises(NeedRootcapLookupScheme, client.Client, basedir)
250 def _permute(self, sb, key):
251 return [ s.get_longname() for s in sb.get_servers_for_psi(key) ]
253 def test_permute(self):
254 sb = StorageFarmBroker(None, True)
255 for k in ["%d" % i for i in range(5)]:
256 ann = {"anonymous-storage-FURL": "pb://abcde@nowhere/fake",
257 "permutation-seed-base32": base32.b2a(k) }
258 sb.test_add_rref(k, "rref", ann)
260 self.failUnlessReallyEqual(self._permute(sb, "one"), ['3','1','0','4','2'])
261 self.failUnlessReallyEqual(self._permute(sb, "two"), ['0','4','2','1','3'])
263 self.failUnlessReallyEqual(self._permute(sb, "one"), [])
265 def test_versions(self):
266 basedir = "test_client.Basic.test_versions"
268 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
272 c = client.Client(basedir)
273 ss = c.getServiceNamed("storage")
274 verdict = ss.remote_get_version()
275 self.failUnlessReallyEqual(verdict["application-version"],
276 str(allmydata.__full_version__))
277 self.failIfEqual(str(allmydata.__version__), "unknown")
278 self.failUnless("." in str(allmydata.__full_version__),
279 "non-numeric version in '%s'" % allmydata.__version__)
280 all_versions = allmydata.get_package_versions_string()
281 self.failUnless(allmydata.__appname__ in all_versions)
283 stats = c.get_stats()
284 self.failUnless("node.uptime" in stats)
285 self.failUnless(isinstance(stats["node.uptime"], float))
287 def test_helper_furl(self):
288 basedir = "test_client.Basic.test_helper_furl"
291 def _check(config, expected_furl):
292 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
294 c = client.Client(basedir)
295 uploader = c.getServiceNamed("uploader")
296 furl, connected = uploader.get_helper_info()
297 self.failUnlessEqual(furl, expected_furl)
300 _check("helper.furl =\n", None)
301 _check("helper.furl = \n", None)
302 _check("helper.furl = None", None)
303 _check("helper.furl = pb://blah\n", "pb://blah")
305 def test_create_drop_uploader(self):
306 class MockDropUploader(service.MultiService):
309 def __init__(self, client, upload_dircap, local_dir_utf8, inotify=None):
310 service.MultiService.__init__(self)
312 self.upload_dircap = upload_dircap
313 self.local_dir_utf8 = local_dir_utf8
314 self.inotify = inotify
316 self.patch(allmydata.frontends.drop_upload, 'DropUploader', MockDropUploader)
318 upload_dircap = "URI:DIR2:blah"
319 local_dir_utf8 = u"loc\u0101l_dir".encode('utf-8')
320 config = (BASECONFIG +
322 "enabled = false\n" +
326 basedir1 = "test_client.Basic.test_create_drop_uploader1"
328 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
329 config + "local.directory = " + local_dir_utf8 + "\n")
330 self.failUnlessRaises(MissingConfigEntry, client.Client, basedir1)
332 fileutil.write(os.path.join(basedir1, "tahoe.cfg"), config)
333 fileutil.write(os.path.join(basedir1, "private", "drop_upload_dircap"), "URI:DIR2:blah")
334 self.failUnlessRaises(MissingConfigEntry, client.Client, basedir1)
336 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
337 config + "upload.dircap = " + upload_dircap + "\n")
338 self.failUnlessRaises(OldConfigOptionError, client.Client, basedir1)
340 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
341 config + "local.directory = " + local_dir_utf8 + "\n")
342 c1 = client.Client(basedir1)
343 uploader = c1.getServiceNamed('drop-upload')
344 self.failUnless(isinstance(uploader, MockDropUploader), uploader)
345 self.failUnlessReallyEqual(uploader.client, c1)
346 self.failUnlessReallyEqual(uploader.upload_dircap, upload_dircap)
347 self.failUnlessReallyEqual(uploader.local_dir_utf8, local_dir_utf8)
348 self.failUnless(uploader.inotify is None, uploader.inotify)
349 self.failUnless(uploader.running)
351 class Boom(Exception):
353 def BoomDropUploader(client, upload_dircap, local_dir_utf8, inotify=None):
357 def mock_log(*args, **kwargs):
358 logged_messages.append("%r %r" % (args, kwargs))
359 self.patch(allmydata.util.log, 'msg', mock_log)
360 self.patch(allmydata.frontends.drop_upload, 'DropUploader', BoomDropUploader)
362 basedir2 = "test_client.Basic.test_create_drop_uploader2"
364 os.mkdir(os.path.join(basedir2, "private"))
365 fileutil.write(os.path.join(basedir2, "tahoe.cfg"),
369 "local.directory = " + local_dir_utf8 + "\n")
370 fileutil.write(os.path.join(basedir2, "private", "drop_upload_dircap"), "URI:DIR2:blah")
371 c2 = client.Client(basedir2)
372 self.failUnlessRaises(KeyError, c2.getServiceNamed, 'drop-upload')
373 self.failUnless([True for arg in logged_messages if "Boom" in arg],
377 def flush_but_dont_ignore(res):
378 d = flushEventualQueue()
384 class Run(unittest.TestCase, testutil.StallMixin):
387 self.sparent = service.MultiService()
388 self.sparent.startService()
390 d = self.sparent.stopService()
391 d.addBoth(flush_but_dont_ignore)
394 def test_loadable(self):
395 basedir = "test_client.Run.test_loadable"
397 dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
398 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG_I % dummy)
399 fileutil.write(os.path.join(basedir, client.Client.EXIT_TRIGGER_FILE), "")
400 client.Client(basedir)
402 def test_reloadable(self):
403 basedir = "test_client.Run.test_reloadable"
405 dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
406 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG_I % dummy)
407 c1 = client.Client(basedir)
408 c1.setServiceParent(self.sparent)
410 # delay to let the service start up completely. I'm not entirely sure
412 d = self.stall(delay=2.0)
413 d.addCallback(lambda res: c1.disownServiceParent())
414 # the cygwin buildslave seems to need more time to let the old
415 # service completely shut down. When delay=0.1, I saw this test fail,
416 # probably due to the logport trying to reclaim the old socket
417 # number. This suggests that either we're dropping a Deferred
418 # somewhere in the shutdown sequence, or that cygwin is just cranky.
419 d.addCallback(self.stall, delay=2.0)
421 # TODO: pause for slightly over one second, to let
422 # Client._check_exit_trigger poll the file once. That will exercise
423 # another few lines. Then add another test in which we don't
424 # update the file at all, and watch to see the node shutdown.
425 # (To do this, use a modified node which overrides Node.shutdown(),
426 # also change _check_exit_trigger to use it instead of a raw
427 # reactor.stop, also instrument the shutdown event in an
428 # attribute that we can check.)
429 c2 = client.Client(basedir)
430 c2.setServiceParent(self.sparent)
431 return c2.disownServiceParent()
432 d.addCallback(_restart)
435 class NodeMaker(testutil.ReallyEqualMixin, unittest.TestCase):
436 def test_maker(self):
437 basedir = "client/NodeMaker/maker"
438 fileutil.make_dirs(basedir)
439 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG)
440 c = client.Client(basedir)
442 n = c.create_node_from_uri("URI:CHK:6nmrpsubgbe57udnexlkiwzmlu:bjt7j6hshrlmadjyr7otq3dc24end5meo5xcr5xe5r663po6itmq:3:10:7277")
443 self.failUnless(IFilesystemNode.providedBy(n))
444 self.failUnless(IFileNode.providedBy(n))
445 self.failUnless(IImmutableFileNode.providedBy(n))
446 self.failIf(IMutableFileNode.providedBy(n))
447 self.failIf(IDirectoryNode.providedBy(n))
448 self.failUnless(n.is_readonly())
449 self.failIf(n.is_mutable())
451 # Testing #1679. There was a bug that would occur when downloader was
452 # downloading the same readcap more than once concurrently, so the
453 # filenode object was cached, and there was a failure from one of the
454 # servers in one of the download attempts. No subsequent download
455 # attempt would attempt to use that server again, which would lead to
456 # the file being undownloadable until the gateway was restarted. The
457 # current fix for this (hopefully to be superceded by a better fix
458 # eventually) is to prevent re-use of filenodes, so the NodeMaker is
459 # hereby required *not* to cache and re-use filenodes for CHKs.
460 other_n = c.create_node_from_uri("URI:CHK:6nmrpsubgbe57udnexlkiwzmlu:bjt7j6hshrlmadjyr7otq3dc24end5meo5xcr5xe5r663po6itmq:3:10:7277")
461 self.failIf(n is other_n, (n, other_n))
463 n = c.create_node_from_uri("URI:LIT:n5xgk")
464 self.failUnless(IFilesystemNode.providedBy(n))
465 self.failUnless(IFileNode.providedBy(n))
466 self.failUnless(IImmutableFileNode.providedBy(n))
467 self.failIf(IMutableFileNode.providedBy(n))
468 self.failIf(IDirectoryNode.providedBy(n))
469 self.failUnless(n.is_readonly())
470 self.failIf(n.is_mutable())
472 n = c.create_node_from_uri("URI:SSK:n6x24zd3seu725yluj75q5boaa:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
473 self.failUnless(IFilesystemNode.providedBy(n))
474 self.failUnless(IFileNode.providedBy(n))
475 self.failIf(IImmutableFileNode.providedBy(n))
476 self.failUnless(IMutableFileNode.providedBy(n))
477 self.failIf(IDirectoryNode.providedBy(n))
478 self.failIf(n.is_readonly())
479 self.failUnless(n.is_mutable())
481 n = c.create_node_from_uri("URI:SSK-RO:b7sr5qsifnicca7cbk3rhrhbvq:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
482 self.failUnless(IFilesystemNode.providedBy(n))
483 self.failUnless(IFileNode.providedBy(n))
484 self.failIf(IImmutableFileNode.providedBy(n))
485 self.failUnless(IMutableFileNode.providedBy(n))
486 self.failIf(IDirectoryNode.providedBy(n))
487 self.failUnless(n.is_readonly())
488 self.failUnless(n.is_mutable())
490 n = c.create_node_from_uri("URI:DIR2:n6x24zd3seu725yluj75q5boaa:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
491 self.failUnless(IFilesystemNode.providedBy(n))
492 self.failIf(IFileNode.providedBy(n))
493 self.failIf(IImmutableFileNode.providedBy(n))
494 self.failIf(IMutableFileNode.providedBy(n))
495 self.failUnless(IDirectoryNode.providedBy(n))
496 self.failIf(n.is_readonly())
497 self.failUnless(n.is_mutable())
499 n = c.create_node_from_uri("URI:DIR2-RO:b7sr5qsifnicca7cbk3rhrhbvq:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
500 self.failUnless(IFilesystemNode.providedBy(n))
501 self.failIf(IFileNode.providedBy(n))
502 self.failIf(IImmutableFileNode.providedBy(n))
503 self.failIf(IMutableFileNode.providedBy(n))
504 self.failUnless(IDirectoryNode.providedBy(n))
505 self.failUnless(n.is_readonly())
506 self.failUnless(n.is_mutable())
508 unknown_rw = "lafs://from_the_future"
509 unknown_ro = "lafs://readonly_from_the_future"
510 n = c.create_node_from_uri(unknown_rw, unknown_ro)
511 self.failUnless(IFilesystemNode.providedBy(n))
512 self.failIf(IFileNode.providedBy(n))
513 self.failIf(IImmutableFileNode.providedBy(n))
514 self.failIf(IMutableFileNode.providedBy(n))
515 self.failIf(IDirectoryNode.providedBy(n))
516 self.failUnless(n.is_unknown())
517 self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
518 self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
519 self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)
521 # Note: it isn't that we *intend* to deploy non-ASCII caps in
522 # the future, it is that we want to make sure older Tahoe-LAFS
523 # versions wouldn't choke on them if we were to do so. See
524 # #1051 and wiki:NewCapDesign for details.
525 unknown_rw = u"lafs://from_the_future_rw_\u263A".encode('utf-8')
526 unknown_ro = u"lafs://readonly_from_the_future_ro_\u263A".encode('utf-8')
527 n = c.create_node_from_uri(unknown_rw, unknown_ro)
528 self.failUnless(IFilesystemNode.providedBy(n))
529 self.failIf(IFileNode.providedBy(n))
530 self.failIf(IImmutableFileNode.providedBy(n))
531 self.failIf(IMutableFileNode.providedBy(n))
532 self.failIf(IDirectoryNode.providedBy(n))
533 self.failUnless(n.is_unknown())
534 self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
535 self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
536 self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)