3 from twisted.trial import unittest
4 from twisted.application import service
7 import allmydata.frontends.magic_folder
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, testutil.NonASCIIPathMixin, 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, 0, None)
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_permute_with_preferred(self):
266 sb = StorageFarmBroker(None, True, ['1','4'])
267 for k in ["%d" % i for i in range(5)]:
268 ann = {"anonymous-storage-FURL": "pb://abcde@nowhere/fake",
269 "permutation-seed-base32": base32.b2a(k) }
270 sb.test_add_rref(k, "rref", ann)
272 self.failUnlessReallyEqual(self._permute(sb, "one"), ['1','4','3','0','2'])
273 self.failUnlessReallyEqual(self._permute(sb, "two"), ['4','1','0','2','3'])
275 self.failUnlessReallyEqual(self._permute(sb, "one"), [])
277 def test_versions(self):
278 basedir = "test_client.Basic.test_versions"
280 fileutil.write(os.path.join(basedir, "tahoe.cfg"), \
284 c = client.Client(basedir)
285 ss = c.getServiceNamed("storage")
286 verdict = ss.remote_get_version()
287 self.failUnlessReallyEqual(verdict["application-version"],
288 str(allmydata.__full_version__))
289 self.failIfEqual(str(allmydata.__version__), "unknown")
290 self.failUnless("." in str(allmydata.__full_version__),
291 "non-numeric version in '%s'" % allmydata.__version__)
292 all_versions = allmydata.get_package_versions_string()
293 self.failUnless(allmydata.__appname__ in all_versions)
295 stats = c.get_stats()
296 self.failUnless("node.uptime" in stats)
297 self.failUnless(isinstance(stats["node.uptime"], float))
299 def test_helper_furl(self):
300 basedir = "test_client.Basic.test_helper_furl"
303 def _check(config, expected_furl):
304 fileutil.write(os.path.join(basedir, "tahoe.cfg"),
306 c = client.Client(basedir)
307 uploader = c.getServiceNamed("uploader")
308 furl, connected = uploader.get_helper_info()
309 self.failUnlessEqual(furl, expected_furl)
312 _check("helper.furl =\n", None)
313 _check("helper.furl = \n", None)
314 _check("helper.furl = None", None)
315 _check("helper.furl = pb://blah\n", "pb://blah")
317 def test_create_magic_folder_service(self):
318 class MockMagicFolder(service.MultiService):
319 name = 'magic-folder'
321 def __init__(self, client, upload_dircap, collective_dircap, local_dir, dbfile, umask, inotify=None,
323 service.MultiService.__init__(self)
326 self.upload_dircap = upload_dircap
327 self.collective_dircap = collective_dircap
328 self.local_dir = local_dir
330 self.inotify = inotify
335 self.patch(allmydata.frontends.magic_folder, 'MagicFolder', MockMagicFolder)
337 upload_dircap = "URI:DIR2:blah"
338 local_dir_u = self.unicode_or_fallback(u"loc\u0101l_dir", u"local_dir")
339 local_dir_utf8 = local_dir_u.encode('utf-8')
340 config = (BASECONFIG +
342 "enabled = false\n" +
346 basedir1 = "test_client.Basic.test_create_magic_folder_service1"
349 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
350 config + "local.directory = " + local_dir_utf8 + "\n")
351 self.failUnlessRaises(MissingConfigEntry, client.Client, basedir1)
353 fileutil.write(os.path.join(basedir1, "tahoe.cfg"), config)
354 fileutil.write(os.path.join(basedir1, "private", "magic_folder_dircap"), "URI:DIR2:blah")
355 fileutil.write(os.path.join(basedir1, "private", "collective_dircap"), "URI:DIR2:meow")
356 self.failUnlessRaises(MissingConfigEntry, client.Client, basedir1)
358 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
359 config.replace("[magic_folder]\n", "[drop_upload]\n"))
360 self.failUnlessRaises(OldConfigOptionError, client.Client, basedir1)
362 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
363 config + "local.directory = " + local_dir_utf8 + "\n")
364 c1 = client.Client(basedir1)
365 magicfolder = c1.getServiceNamed('magic-folder')
366 self.failUnless(isinstance(magicfolder, MockMagicFolder), magicfolder)
367 self.failUnlessReallyEqual(magicfolder.client, c1)
368 self.failUnlessReallyEqual(magicfolder.upload_dircap, upload_dircap)
369 self.failUnlessReallyEqual(os.path.basename(magicfolder.local_dir), local_dir_u)
370 self.failUnless(magicfolder.inotify is None, magicfolder.inotify)
371 self.failUnless(magicfolder.running)
373 class Boom(Exception):
375 def BoomMagicFolder(client, upload_dircap, collective_dircap, local_dir, dbfile,
376 inotify=None, pending_delay=1.0):
378 self.patch(allmydata.frontends.magic_folder, 'MagicFolder', BoomMagicFolder)
380 basedir2 = "test_client.Basic.test_create_magic_folder_service2"
382 os.mkdir(os.path.join(basedir2, "private"))
383 fileutil.write(os.path.join(basedir2, "tahoe.cfg"),
387 "local.directory = " + local_dir_utf8 + "\n")
388 fileutil.write(os.path.join(basedir2, "private", "magic_folder_dircap"), "URI:DIR2:blah")
389 fileutil.write(os.path.join(basedir2, "private", "collective_dircap"), "URI:DIR2:meow")
390 self.failUnlessRaises(Boom, client.Client, basedir2)
393 def flush_but_dont_ignore(res):
394 d = flushEventualQueue()
400 class Run(unittest.TestCase, testutil.StallMixin):
403 self.sparent = service.MultiService()
404 self.sparent.startService()
406 d = self.sparent.stopService()
407 d.addBoth(flush_but_dont_ignore)
410 def test_loadable(self):
411 basedir = "test_client.Run.test_loadable"
413 dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
414 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG_I % dummy)
415 fileutil.write(os.path.join(basedir, client.Client.EXIT_TRIGGER_FILE), "")
416 client.Client(basedir)
418 def test_reloadable(self):
419 basedir = "test_client.Run.test_reloadable"
421 dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
422 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG_I % dummy)
423 c1 = client.Client(basedir)
424 c1.setServiceParent(self.sparent)
426 # delay to let the service start up completely. I'm not entirely sure
428 d = self.stall(delay=2.0)
429 d.addCallback(lambda res: c1.disownServiceParent())
430 # the cygwin buildslave seems to need more time to let the old
431 # service completely shut down. When delay=0.1, I saw this test fail,
432 # probably due to the logport trying to reclaim the old socket
433 # number. This suggests that either we're dropping a Deferred
434 # somewhere in the shutdown sequence, or that cygwin is just cranky.
435 d.addCallback(self.stall, delay=2.0)
437 # TODO: pause for slightly over one second, to let
438 # Client._check_exit_trigger poll the file once. That will exercise
439 # another few lines. Then add another test in which we don't
440 # update the file at all, and watch to see the node shutdown.
441 # (To do this, use a modified node which overrides Node.shutdown(),
442 # also change _check_exit_trigger to use it instead of a raw
443 # reactor.stop, also instrument the shutdown event in an
444 # attribute that we can check.)
445 c2 = client.Client(basedir)
446 c2.setServiceParent(self.sparent)
447 return c2.disownServiceParent()
448 d.addCallback(_restart)
451 class NodeMaker(testutil.ReallyEqualMixin, unittest.TestCase):
452 def test_maker(self):
453 basedir = "client/NodeMaker/maker"
454 fileutil.make_dirs(basedir)
455 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG)
456 c = client.Client(basedir)
458 n = c.create_node_from_uri("URI:CHK:6nmrpsubgbe57udnexlkiwzmlu:bjt7j6hshrlmadjyr7otq3dc24end5meo5xcr5xe5r663po6itmq:3:10:7277")
459 self.failUnless(IFilesystemNode.providedBy(n))
460 self.failUnless(IFileNode.providedBy(n))
461 self.failUnless(IImmutableFileNode.providedBy(n))
462 self.failIf(IMutableFileNode.providedBy(n))
463 self.failIf(IDirectoryNode.providedBy(n))
464 self.failUnless(n.is_readonly())
465 self.failIf(n.is_mutable())
467 # Testing #1679. There was a bug that would occur when downloader was
468 # downloading the same readcap more than once concurrently, so the
469 # filenode object was cached, and there was a failure from one of the
470 # servers in one of the download attempts. No subsequent download
471 # attempt would attempt to use that server again, which would lead to
472 # the file being undownloadable until the gateway was restarted. The
473 # current fix for this (hopefully to be superceded by a better fix
474 # eventually) is to prevent re-use of filenodes, so the NodeMaker is
475 # hereby required *not* to cache and re-use filenodes for CHKs.
476 other_n = c.create_node_from_uri("URI:CHK:6nmrpsubgbe57udnexlkiwzmlu:bjt7j6hshrlmadjyr7otq3dc24end5meo5xcr5xe5r663po6itmq:3:10:7277")
477 self.failIf(n is other_n, (n, other_n))
479 n = c.create_node_from_uri("URI:LIT:n5xgk")
480 self.failUnless(IFilesystemNode.providedBy(n))
481 self.failUnless(IFileNode.providedBy(n))
482 self.failUnless(IImmutableFileNode.providedBy(n))
483 self.failIf(IMutableFileNode.providedBy(n))
484 self.failIf(IDirectoryNode.providedBy(n))
485 self.failUnless(n.is_readonly())
486 self.failIf(n.is_mutable())
488 n = c.create_node_from_uri("URI:SSK:n6x24zd3seu725yluj75q5boaa:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
489 self.failUnless(IFilesystemNode.providedBy(n))
490 self.failUnless(IFileNode.providedBy(n))
491 self.failIf(IImmutableFileNode.providedBy(n))
492 self.failUnless(IMutableFileNode.providedBy(n))
493 self.failIf(IDirectoryNode.providedBy(n))
494 self.failIf(n.is_readonly())
495 self.failUnless(n.is_mutable())
497 n = c.create_node_from_uri("URI:SSK-RO:b7sr5qsifnicca7cbk3rhrhbvq:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
498 self.failUnless(IFilesystemNode.providedBy(n))
499 self.failUnless(IFileNode.providedBy(n))
500 self.failIf(IImmutableFileNode.providedBy(n))
501 self.failUnless(IMutableFileNode.providedBy(n))
502 self.failIf(IDirectoryNode.providedBy(n))
503 self.failUnless(n.is_readonly())
504 self.failUnless(n.is_mutable())
506 n = c.create_node_from_uri("URI:DIR2:n6x24zd3seu725yluj75q5boaa:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
507 self.failUnless(IFilesystemNode.providedBy(n))
508 self.failIf(IFileNode.providedBy(n))
509 self.failIf(IImmutableFileNode.providedBy(n))
510 self.failIf(IMutableFileNode.providedBy(n))
511 self.failUnless(IDirectoryNode.providedBy(n))
512 self.failIf(n.is_readonly())
513 self.failUnless(n.is_mutable())
515 n = c.create_node_from_uri("URI:DIR2-RO:b7sr5qsifnicca7cbk3rhrhbvq:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
516 self.failUnless(IFilesystemNode.providedBy(n))
517 self.failIf(IFileNode.providedBy(n))
518 self.failIf(IImmutableFileNode.providedBy(n))
519 self.failIf(IMutableFileNode.providedBy(n))
520 self.failUnless(IDirectoryNode.providedBy(n))
521 self.failUnless(n.is_readonly())
522 self.failUnless(n.is_mutable())
524 unknown_rw = "lafs://from_the_future"
525 unknown_ro = "lafs://readonly_from_the_future"
526 n = c.create_node_from_uri(unknown_rw, unknown_ro)
527 self.failUnless(IFilesystemNode.providedBy(n))
528 self.failIf(IFileNode.providedBy(n))
529 self.failIf(IImmutableFileNode.providedBy(n))
530 self.failIf(IMutableFileNode.providedBy(n))
531 self.failIf(IDirectoryNode.providedBy(n))
532 self.failUnless(n.is_unknown())
533 self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
534 self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
535 self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)
537 # Note: it isn't that we *intend* to deploy non-ASCII caps in
538 # the future, it is that we want to make sure older Tahoe-LAFS
539 # versions wouldn't choke on them if we were to do so. See
540 # #1051 and wiki:NewCapDesign for details.
541 unknown_rw = u"lafs://from_the_future_rw_\u263A".encode('utf-8')
542 unknown_ro = u"lafs://readonly_from_the_future_ro_\u263A".encode('utf-8')
543 n = c.create_node_from_uri(unknown_rw, unknown_ro)
544 self.failUnless(IFilesystemNode.providedBy(n))
545 self.failIf(IFileNode.providedBy(n))
546 self.failIf(IImmutableFileNode.providedBy(n))
547 self.failIf(IMutableFileNode.providedBy(n))
548 self.failIf(IDirectoryNode.providedBy(n))
549 self.failUnless(n.is_unknown())
550 self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
551 self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
552 self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)