src/allmydata/test/test_cli_magic_folder.py

   1 import os.path
   2 import re
   3
   4 from twisted.trial import unittest
   5 from twisted.internet import defer
   6 from twisted.internet import reactor
   7 from twisted.python import usage
   8
   9 from allmydata.util.assertutil import precondition
  10 from allmydata.util import fileutil
  11 from allmydata.scripts.common import get_aliases
  12 from allmydata.test.no_network import GridTestMixin
  13 from .test_cli import CLITestMixin
  14 from allmydata.scripts import magic_folder_cli
  15 from allmydata.util.fileutil import abspath_expanduser_unicode
  16 from allmydata.util.encodingutil import unicode_to_argv
  17 from allmydata.frontends.magic_folder import MagicFolder
  18 from allmydata import uri
  19
  20
  21 class MagicFolderCLITestMixin(CLITestMixin, GridTestMixin):
  22     def do_create_magic_folder(self, client_num):
  23         d = self.do_cli("magic-folder", "create", "magic:", client_num=client_num)
  24         def _done((rc,stdout,stderr)):
  25             self.failUnlessEqual(rc, 0)
  26             self.failUnlessIn("Alias 'magic' created", stdout)
  27             self.failUnlessEqual(stderr, "")
  28             aliases = get_aliases(self.get_clientdir(i=client_num))
  29             self.failUnlessIn("magic", aliases)
  30             self.failUnless(aliases["magic"].startswith("URI:DIR2:"))
  31         d.addCallback(_done)
  32         return d
  33
  34     def do_invite(self, client_num, nickname):
  35         nickname_arg = unicode_to_argv(nickname)
  36         d = self.do_cli("magic-folder", "invite", "magic:", nickname_arg, client_num=client_num)
  37         def _done((rc, stdout, stderr)):
  38             self.failUnlessEqual(rc, 0)
  39             return (rc, stdout, stderr)
  40         d.addCallback(_done)
  41         return d
  42
  43     def do_join(self, client_num, local_dir, invite_code):
  44         precondition(isinstance(local_dir, unicode), local_dir=local_dir)
  45         precondition(isinstance(invite_code, str), invite_code=invite_code)
  46
  47         local_dir_arg = unicode_to_argv(local_dir)
  48         d = self.do_cli("magic-folder", "join", invite_code, local_dir_arg, client_num=client_num)
  49         def _done((rc, stdout, stderr)):
  50             self.failUnlessEqual(rc, 0)
  51             self.failUnlessEqual(stdout, "")
  52             self.failUnlessEqual(stderr, "")
  53             return (rc, stdout, stderr)
  54         d.addCallback(_done)
  55         return d
  56
  57     def do_leave(self, client_num):
  58         d = self.do_cli("magic-folder", "leave", client_num=client_num)
  59         def _done((rc, stdout, stderr)):
  60             self.failUnlessEqual(rc, 0)
  61             return (rc, stdout, stderr)
  62         d.addCallback(_done)
  63         return d
  64
  65     def check_joined_config(self, client_num, upload_dircap):
  66         """Tests that our collective directory has the readonly cap of
  67         our upload directory.
  68         """
  69         collective_readonly_cap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
  70                                                              u"private", u"collective_dircap"))
  71         d = self.do_cli("ls", "--json", collective_readonly_cap, client_num=client_num)
  72         def _done((rc, stdout, stderr)):
  73             self.failUnlessEqual(rc, 0)
  74             return (rc, stdout, stderr)
  75         d.addCallback(_done)
  76         def test_joined_magic_folder((rc,stdout,stderr)):
  77             readonly_cap = unicode(uri.from_string(upload_dircap).get_readonly().to_string(), 'utf-8')
  78             s = re.search(readonly_cap, stdout)
  79             self.failUnless(s is not None)
  80             return None
  81         d.addCallback(test_joined_magic_folder)
  82         return d
  83
  84     def get_caps_from_files(self, client_num):
  85         collective_dircap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
  86                                                        u"private", u"collective_dircap"))
  87         upload_dircap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
  88                                                    u"private", u"magic_folder_dircap"))
  89         self.failIf(collective_dircap is None or upload_dircap is None)
  90         return collective_dircap, upload_dircap
  91
  92     def check_config(self, client_num, local_dir):
  93         client_config = fileutil.read(os.path.join(self.get_clientdir(i=client_num), "tahoe.cfg"))
  94         local_dir_utf8 = local_dir.encode('utf-8')
  95         magic_folder_config = "[magic_folder]\nenabled = True\nlocal.directory = %s" % (local_dir_utf8,)
  96         self.failUnlessIn(magic_folder_config, client_config)
  97
  98     def create_invite_join_magic_folder(self, nickname, local_dir):
  99         nickname_arg = unicode_to_argv(nickname)
 100         local_dir_arg = unicode_to_argv(local_dir)
 101         d = self.do_cli("magic-folder", "create", "magic:", nickname_arg, local_dir_arg)
 102         def _done((rc, stdout, stderr)):
 103             self.failUnlessEqual(rc, 0)
 104
 105             client = self.get_client()
 106             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
 107             self.collective_dirnode = client.create_node_from_uri(self.collective_dircap)
 108             self.upload_dirnode     = client.create_node_from_uri(self.upload_dircap)
 109         d.addCallback(_done)
 110         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 111         d.addCallback(lambda ign: self.check_config(0, local_dir))
 112         return d
 113
 114     def cleanup(self, res):
 115         d = defer.succeed(None)
 116         if self.magicfolder is not None:
 117             d.addCallback(lambda ign: self.magicfolder.finish())
 118         d.addCallback(lambda ign: res)
 119         return d
 120
 121     def init_magicfolder(self, client_num, upload_dircap, collective_dircap, local_magic_dir, clock):
 122         dbfile = abspath_expanduser_unicode(u"magicfolderdb.sqlite", base=self.get_clientdir(i=client_num))
 123         magicfolder = MagicFolder(self.get_client(client_num), upload_dircap, collective_dircap, local_magic_dir,
 124                                        dbfile, 0077, pending_delay=0.2, clock=clock)
 125         magicfolder.downloader._turn_delay = 0
 126
 127         magicfolder.setServiceParent(self.get_client(client_num))
 128         magicfolder.ready()
 129         return magicfolder
 130
 131     def setup_alice_and_bob(self, alice_clock=reactor, bob_clock=reactor):
 132         self.set_up_grid(num_clients=2)
 133
 134         self.alice_magicfolder = None
 135         self.bob_magicfolder = None
 136
 137         alice_magic_dir = abspath_expanduser_unicode(u"Alice-magic", base=self.basedir)
 138         self.mkdir_nonascii(alice_magic_dir)
 139         bob_magic_dir = abspath_expanduser_unicode(u"Bob-magic", base=self.basedir)
 140         self.mkdir_nonascii(bob_magic_dir)
 141
 142         # Alice creates a Magic Folder,
 143         # invites herself then and joins.
 144         d = self.do_create_magic_folder(0)
 145         d.addCallback(lambda ign: self.do_invite(0, u"Alice\u00F8"))
 146         def get_invite_code(result):
 147             self.invite_code = result[1].strip()
 148         d.addCallback(get_invite_code)
 149         d.addCallback(lambda ign: self.do_join(0, alice_magic_dir, self.invite_code))
 150         def get_alice_caps(ign):
 151             self.alice_collective_dircap, self.alice_upload_dircap = self.get_caps_from_files(0)
 152         d.addCallback(get_alice_caps)
 153         d.addCallback(lambda ign: self.check_joined_config(0, self.alice_upload_dircap))
 154         d.addCallback(lambda ign: self.check_config(0, alice_magic_dir))
 155         def get_Alice_magicfolder(result):
 156             self.alice_magicfolder = self.init_magicfolder(0, self.alice_upload_dircap,
 157                                                            self.alice_collective_dircap,
 158                                                            alice_magic_dir, alice_clock)
 159             return result
 160         d.addCallback(get_Alice_magicfolder)
 161
 162         # Alice invites Bob. Bob joins.
 163         d.addCallback(lambda ign: self.do_invite(0, u"Bob\u00F8"))
 164         def get_invite_code(result):
 165             self.invite_code = result[1].strip()
 166         d.addCallback(get_invite_code)
 167         d.addCallback(lambda ign: self.do_join(1, bob_magic_dir, self.invite_code))
 168         def get_bob_caps(ign):
 169             self.bob_collective_dircap, self.bob_upload_dircap = self.get_caps_from_files(1)
 170         d.addCallback(get_bob_caps)
 171         d.addCallback(lambda ign: self.check_joined_config(1, self.bob_upload_dircap))
 172         d.addCallback(lambda ign: self.check_config(1, bob_magic_dir))
 173         def get_Bob_magicfolder(result):
 174             self.bob_magicfolder = self.init_magicfolder(1, self.bob_upload_dircap,
 175                                                          self.bob_collective_dircap,
 176                                                          bob_magic_dir, bob_clock)
 177             return result
 178         d.addCallback(get_Bob_magicfolder)
 179         return d
 180
 181
 182 class CreateMagicFolder(MagicFolderCLITestMixin, unittest.TestCase):
 183     def test_create_and_then_invite_join(self):
 184         self.basedir = "cli/MagicFolder/create-and-then-invite-join"
 185         self.set_up_grid()
 186         local_dir = os.path.join(self.basedir, "magic")
 187         abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
 188
 189         d = self.do_create_magic_folder(0)
 190         d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
 191         def get_invite_code_and_join((rc, stdout, stderr)):
 192             invite_code = stdout.strip()
 193             return self.do_join(0, unicode(local_dir), invite_code)
 194         d.addCallback(get_invite_code_and_join)
 195         def get_caps(ign):
 196             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
 197         d.addCallback(get_caps)
 198         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 199         d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
 200         return d
 201
 202     def test_create_error(self):
 203         self.basedir = "cli/MagicFolder/create-error"
 204         self.set_up_grid()
 205
 206         d = self.do_cli("magic-folder", "create", "m a g i c:", client_num=0)
 207         def _done((rc, stdout, stderr)):
 208             self.failIfEqual(rc, 0)
 209             self.failUnlessIn("Alias names cannot contain spaces.", stderr)
 210         d.addCallback(_done)
 211         return d
 212
 213     def test_create_invite_join(self):
 214         self.basedir = "cli/MagicFolder/create-invite-join"
 215         self.set_up_grid()
 216         local_dir = os.path.join(self.basedir, "magic")
 217         abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
 218
 219         d = self.do_cli("magic-folder", "create", "magic:", "Alice", local_dir)
 220         def _done((rc, stdout, stderr)):
 221             self.failUnlessEqual(rc, 0)
 222             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
 223         d.addCallback(_done)
 224         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 225         d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
 226         return d
 227
 228     def test_create_invite_join_failure(self):
 229         self.basedir = "cli/MagicFolder/create-invite-join-failure"
 230         os.makedirs(self.basedir)
 231
 232         o = magic_folder_cli.CreateOptions()
 233         o.parent = magic_folder_cli.MagicFolderCommand()
 234         o.parent['node-directory'] = self.basedir
 235         try:
 236             o.parseArgs("magic:", "Alice", "-foo")
 237         except usage.UsageError as e:
 238             self.failUnlessIn("cannot start with '-'", str(e))
 239         else:
 240             self.fail("expected UsageError")
 241
 242     def test_join_failure(self):
 243         self.basedir = "cli/MagicFolder/create-join-failure"
 244         os.makedirs(self.basedir)
 245
 246         o = magic_folder_cli.JoinOptions()
 247         o.parent = magic_folder_cli.MagicFolderCommand()
 248         o.parent['node-directory'] = self.basedir
 249         try:
 250             o.parseArgs("URI:invite+URI:code", "-foo")
 251         except usage.UsageError as e:
 252             self.failUnlessIn("cannot start with '-'", str(e))
 253         else:
 254             self.fail("expected UsageError")
 255
 256     def test_join_twice_failure(self):
 257         self.basedir = "cli/MagicFolder/create-join-twice-failure"
 258         os.makedirs(self.basedir)
 259         self.set_up_grid()
 260         local_dir = os.path.join(self.basedir, "magic")
 261         abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
 262
 263         d = self.do_create_magic_folder(0)
 264         d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
 265         def get_invite_code_and_join((rc, stdout, stderr)):
 266             self.invite_code = stdout.strip()
 267             return self.do_join(0, unicode(local_dir), self.invite_code)
 268         d.addCallback(get_invite_code_and_join)
 269         def get_caps(ign):
 270             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
 271         d.addCallback(get_caps)
 272         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 273         d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
 274         def join_again(ignore):
 275             return self.do_cli("magic-folder", "join", self.invite_code, local_dir, client_num=0)
 276         d.addCallback(join_again)
 277         def get_results(result):
 278             code = result[0]
 279             stdout = result[1]
 280             stderr = result[2]
 281             self.failUnlessEqual(stdout, "")
 282             self.failUnlessEqual(stderr, "\nThis client has already joined a magic folder."
 283                                  "\nUse the 'tahoe magic-folder leave' command first.\n\n")
 284             self.failIfEqual(code, 0)
 285         d.addCallback(get_results)
 286         return d
 287
 288     def test_join_leave_join(self):
 289         self.basedir = "cli/MagicFolder/create-join-leave-join"
 290         os.makedirs(self.basedir)
 291         self.set_up_grid()
 292         local_dir = os.path.join(self.basedir, "magic")
 293         abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
 294
 295         self.invite_code = None
 296         d = self.do_create_magic_folder(0)
 297         d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
 298         def get_invite_code_and_join((rc, stdout, stderr)):
 299             self.invite_code = stdout.strip()
 300             return self.do_join(0, unicode(local_dir), self.invite_code)
 301         d.addCallback(get_invite_code_and_join)
 302         def get_caps(ign):
 303             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
 304         d.addCallback(get_caps)
 305         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 306         d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
 307         d.addCallback(lambda ign: self.do_leave(0))
 308
 309         def check_join_again(invite_code):
 310             d2 = defer.succeed(None)
 311             def join_again(ignore):
 312                 return self.do_join(0, unicode(local_dir), self.invite_code)
 313             d2.addCallback(join_again)
 314             return d2
 315
 316         d.addCallback(lambda ign, invite_code: check_join_again(invite_code), self.invite_code)
 317         def get_caps(ign):
 318             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
 319         d.addCallback(get_caps)
 320         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 321         d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
 322
 323         return d
 324
 325     def test_join_failures(self):
 326         self.basedir = "cli/MagicFolder/create-join-failures"
 327         os.makedirs(self.basedir)
 328         self.set_up_grid()
 329         local_dir = os.path.join(self.basedir, "magic")
 330         abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
 331
 332         self.invite_code = None
 333         d = self.do_create_magic_folder(0)
 334         d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
 335         def get_invite_code_and_join((rc, stdout, stderr)):
 336             self.invite_code = stdout.strip()
 337             return self.do_join(0, unicode(local_dir), self.invite_code)
 338         d.addCallback(get_invite_code_and_join)
 339         def get_caps(ign):
 340             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
 341         d.addCallback(get_caps)
 342         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 343         d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
 344
 345         def leave(ignore):
 346             return self.do_cli("magic-folder", "leave", client_num=0)
 347         d.addCallback(leave)
 348
 349         collective_dircap_file = os.path.join(self.get_clientdir(i=0), u"private", u"collective_dircap")
 350         upload_dircap = os.path.join(self.get_clientdir(i=0), u"private", u"magic_folder_dircap")
 351         magic_folder_db_file = os.path.join(self.get_clientdir(i=0), u"private", u"magicfolderdb.sqlite")
 352
 353         def check_join_if_file(my_file):
 354             fileutil.write(my_file, "my file data")
 355             d2 = defer.succeed(None)
 356             def join_again(ignore):
 357                 return self.do_cli("magic-folder", "join", self.invite_code, local_dir, client_num=0)
 358             d2.addCallback(join_again)
 359             def get_results(result):
 360                 code = result[0]
 361                 self.failIfEqual(code, 0)
 362             d2.addCallback(get_results)
 363             return d2
 364
 365         for my_file in [collective_dircap_file, upload_dircap, magic_folder_db_file]:
 366             d.addCallback(lambda ign, my_file: check_join_if_file(my_file), my_file)
 367             d.addCallback(leave)
 368
 369         return d