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