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, inotify=None,
323 service.MultiService.__init__(self)
325 self.upload_dircap = upload_dircap
326 self.collective_dircap = collective_dircap
327 self.local_dir = local_dir
329 self.inotify = inotify
334 self.patch(allmydata.frontends.magic_folder, 'MagicFolder', MockMagicFolder)
336 upload_dircap = "URI:DIR2:blah"
337 local_dir_u = self.unicode_or_fallback(u"loc\u0101l_dir", u"local_dir")
338 local_dir_utf8 = local_dir_u.encode('utf-8')
339 config = (BASECONFIG +
341 "enabled = false\n" +
345 basedir1 = "test_client.Basic.test_create_magic_folder_service1"
348 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
349 config + "local.directory = " + local_dir_utf8 + "\n")
350 self.failUnlessRaises(MissingConfigEntry, client.Client, basedir1)
352 fileutil.write(os.path.join(basedir1, "tahoe.cfg"), config)
353 fileutil.write(os.path.join(basedir1, "private", "magic_folder_dircap"), "URI:DIR2:blah")
354 fileutil.write(os.path.join(basedir1, "private", "collective_dircap"), "URI:DIR2:meow")
355 self.failUnlessRaises(MissingConfigEntry, client.Client, basedir1)
357 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
358 config.replace("[magic_folder]\n", "[drop_upload]\n"))
359 self.failUnlessRaises(OldConfigOptionError, client.Client, basedir1)
361 fileutil.write(os.path.join(basedir1, "tahoe.cfg"),
362 config + "local.directory = " + local_dir_utf8 + "\n")
363 c1 = client.Client(basedir1)
364 magicfolder = c1.getServiceNamed('magic-folder')
365 self.failUnless(isinstance(magicfolder, MockMagicFolder), magicfolder)
366 self.failUnlessReallyEqual(magicfolder.client, c1)
367 self.failUnlessReallyEqual(magicfolder.upload_dircap, upload_dircap)
368 self.failUnlessReallyEqual(os.path.basename(magicfolder.local_dir), local_dir_u)
369 self.failUnless(magicfolder.inotify is None, magicfolder.inotify)
370 self.failUnless(magicfolder.running)
372 class Boom(Exception):
374 def BoomMagicFolder(client, upload_dircap, collective_dircap, local_dir, dbfile,
375 inotify=None, pending_delay=1.0):
377 self.patch(allmydata.frontends.magic_folder, 'MagicFolder', BoomMagicFolder)
379 basedir2 = "test_client.Basic.test_create_magic_folder_service2"
381 os.mkdir(os.path.join(basedir2, "private"))
382 fileutil.write(os.path.join(basedir2, "tahoe.cfg"),
386 "local.directory = " + local_dir_utf8 + "\n")
387 fileutil.write(os.path.join(basedir2, "private", "magic_folder_dircap"), "URI:DIR2:blah")
388 fileutil.write(os.path.join(basedir2, "private", "collective_dircap"), "URI:DIR2:meow")
389 self.failUnlessRaises(Boom, client.Client, basedir2)
392 def flush_but_dont_ignore(res):
393 d = flushEventualQueue()
399 class Run(unittest.TestCase, testutil.StallMixin):
402 self.sparent = service.MultiService()
403 self.sparent.startService()
405 d = self.sparent.stopService()
406 d.addBoth(flush_but_dont_ignore)
409 def test_loadable(self):
410 basedir = "test_client.Run.test_loadable"
412 dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
413 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG_I % dummy)
414 fileutil.write(os.path.join(basedir, client.Client.EXIT_TRIGGER_FILE), "")
415 client.Client(basedir)
417 def test_reloadable(self):
418 basedir = "test_client.Run.test_reloadable"
420 dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
421 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG_I % dummy)
422 c1 = client.Client(basedir)
423 c1.setServiceParent(self.sparent)
425 # delay to let the service start up completely. I'm not entirely sure
427 d = self.stall(delay=2.0)
428 d.addCallback(lambda res: c1.disownServiceParent())
429 # the cygwin buildslave seems to need more time to let the old
430 # service completely shut down. When delay=0.1, I saw this test fail,
431 # probably due to the logport trying to reclaim the old socket
432 # number. This suggests that either we're dropping a Deferred
433 # somewhere in the shutdown sequence, or that cygwin is just cranky.
434 d.addCallback(self.stall, delay=2.0)
436 # TODO: pause for slightly over one second, to let
437 # Client._check_exit_trigger poll the file once. That will exercise
438 # another few lines. Then add another test in which we don't
439 # update the file at all, and watch to see the node shutdown.
440 # (To do this, use a modified node which overrides Node.shutdown(),
441 # also change _check_exit_trigger to use it instead of a raw
442 # reactor.stop, also instrument the shutdown event in an
443 # attribute that we can check.)
444 c2 = client.Client(basedir)
445 c2.setServiceParent(self.sparent)
446 return c2.disownServiceParent()
447 d.addCallback(_restart)
450 class NodeMaker(testutil.ReallyEqualMixin, unittest.TestCase):
451 def test_maker(self):
452 basedir = "client/NodeMaker/maker"
453 fileutil.make_dirs(basedir)
454 fileutil.write(os.path.join(basedir, "tahoe.cfg"), BASECONFIG)
455 c = client.Client(basedir)
457 n = c.create_node_from_uri("URI:CHK:6nmrpsubgbe57udnexlkiwzmlu:bjt7j6hshrlmadjyr7otq3dc24end5meo5xcr5xe5r663po6itmq:3:10:7277")
458 self.failUnless(IFilesystemNode.providedBy(n))
459 self.failUnless(IFileNode.providedBy(n))
460 self.failUnless(IImmutableFileNode.providedBy(n))
461 self.failIf(IMutableFileNode.providedBy(n))
462 self.failIf(IDirectoryNode.providedBy(n))
463 self.failUnless(n.is_readonly())
464 self.failIf(n.is_mutable())
466 # Testing #1679. There was a bug that would occur when downloader was
467 # downloading the same readcap more than once concurrently, so the
468 # filenode object was cached, and there was a failure from one of the
469 # servers in one of the download attempts. No subsequent download
470 # attempt would attempt to use that server again, which would lead to
471 # the file being undownloadable until the gateway was restarted. The
472 # current fix for this (hopefully to be superceded by a better fix
473 # eventually) is to prevent re-use of filenodes, so the NodeMaker is
474 # hereby required *not* to cache and re-use filenodes for CHKs.
475 other_n = c.create_node_from_uri("URI:CHK:6nmrpsubgbe57udnexlkiwzmlu:bjt7j6hshrlmadjyr7otq3dc24end5meo5xcr5xe5r663po6itmq:3:10:7277")
476 self.failIf(n is other_n, (n, other_n))
478 n = c.create_node_from_uri("URI:LIT:n5xgk")
479 self.failUnless(IFilesystemNode.providedBy(n))
480 self.failUnless(IFileNode.providedBy(n))
481 self.failUnless(IImmutableFileNode.providedBy(n))
482 self.failIf(IMutableFileNode.providedBy(n))
483 self.failIf(IDirectoryNode.providedBy(n))
484 self.failUnless(n.is_readonly())
485 self.failIf(n.is_mutable())
487 n = c.create_node_from_uri("URI:SSK:n6x24zd3seu725yluj75q5boaa:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
488 self.failUnless(IFilesystemNode.providedBy(n))
489 self.failUnless(IFileNode.providedBy(n))
490 self.failIf(IImmutableFileNode.providedBy(n))
491 self.failUnless(IMutableFileNode.providedBy(n))
492 self.failIf(IDirectoryNode.providedBy(n))
493 self.failIf(n.is_readonly())
494 self.failUnless(n.is_mutable())
496 n = c.create_node_from_uri("URI:SSK-RO:b7sr5qsifnicca7cbk3rhrhbvq:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
497 self.failUnless(IFilesystemNode.providedBy(n))
498 self.failUnless(IFileNode.providedBy(n))
499 self.failIf(IImmutableFileNode.providedBy(n))
500 self.failUnless(IMutableFileNode.providedBy(n))
501 self.failIf(IDirectoryNode.providedBy(n))
502 self.failUnless(n.is_readonly())
503 self.failUnless(n.is_mutable())
505 n = c.create_node_from_uri("URI:DIR2:n6x24zd3seu725yluj75q5boaa:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
506 self.failUnless(IFilesystemNode.providedBy(n))
507 self.failIf(IFileNode.providedBy(n))
508 self.failIf(IImmutableFileNode.providedBy(n))
509 self.failIf(IMutableFileNode.providedBy(n))
510 self.failUnless(IDirectoryNode.providedBy(n))
511 self.failIf(n.is_readonly())
512 self.failUnless(n.is_mutable())
514 n = c.create_node_from_uri("URI:DIR2-RO:b7sr5qsifnicca7cbk3rhrhbvq:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq")
515 self.failUnless(IFilesystemNode.providedBy(n))
516 self.failIf(IFileNode.providedBy(n))
517 self.failIf(IImmutableFileNode.providedBy(n))
518 self.failIf(IMutableFileNode.providedBy(n))
519 self.failUnless(IDirectoryNode.providedBy(n))
520 self.failUnless(n.is_readonly())
521 self.failUnless(n.is_mutable())
523 unknown_rw = "lafs://from_the_future"
524 unknown_ro = "lafs://readonly_from_the_future"
525 n = c.create_node_from_uri(unknown_rw, unknown_ro)
526 self.failUnless(IFilesystemNode.providedBy(n))
527 self.failIf(IFileNode.providedBy(n))
528 self.failIf(IImmutableFileNode.providedBy(n))
529 self.failIf(IMutableFileNode.providedBy(n))
530 self.failIf(IDirectoryNode.providedBy(n))
531 self.failUnless(n.is_unknown())
532 self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
533 self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
534 self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)
536 # Note: it isn't that we *intend* to deploy non-ASCII caps in
537 # the future, it is that we want to make sure older Tahoe-LAFS
538 # versions wouldn't choke on them if we were to do so. See
539 # #1051 and wiki:NewCapDesign for details.
540 unknown_rw = u"lafs://from_the_future_rw_\u263A".encode('utf-8')
541 unknown_ro = u"lafs://readonly_from_the_future_ro_\u263A".encode('utf-8')
542 n = c.create_node_from_uri(unknown_rw, unknown_ro)
543 self.failUnless(IFilesystemNode.providedBy(n))
544 self.failIf(IFileNode.providedBy(n))
545 self.failIf(IImmutableFileNode.providedBy(n))
546 self.failIf(IMutableFileNode.providedBy(n))
547 self.failIf(IDirectoryNode.providedBy(n))
548 self.failUnless(n.is_unknown())
549 self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
550 self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
551 self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)