src/allmydata/scripts/magic_folder_cli.py

   1
   2 import os
   3 import urllib
   4 from sys import stderr
   5 from types import NoneType
   6 from cStringIO import StringIO
   7 from datetime import datetime
   8
   9 import humanize
  10 import simplejson
  11
  12 from twisted.python import usage
  13
  14 from allmydata.util.assertutil import precondition
  15
  16 from .common import BaseOptions, BasedirOptions, get_aliases
  17 from .cli import MakeDirectoryOptions, LnOptions, CreateAliasOptions
  18 import tahoe_mv
  19 from allmydata.util.encodingutil import argv_to_abspath, argv_to_unicode, to_str, \
  20     quote_local_unicode_path
  21 from allmydata.scripts.common_http import do_http, format_http_success, \
  22     format_http_error, BadResponse
  23 from allmydata.util import fileutil
  24 from allmydata.util import configutil
  25 from allmydata import uri
  26
  27
  28 INVITE_SEPARATOR = "+"
  29
  30 class CreateOptions(BasedirOptions):
  31     nickname = None
  32     local_dir = None
  33     synopsis = "MAGIC_ALIAS: [NICKNAME LOCAL_DIR]"
  34     def parseArgs(self, alias, nickname=None, local_dir=None):
  35         BasedirOptions.parseArgs(self)
  36         alias = argv_to_unicode(alias)
  37         if not alias.endswith(u':'):
  38             raise usage.UsageError("An alias must end with a ':' character.")
  39         self.alias = alias[:-1]
  40         self.nickname = None if nickname is None else argv_to_unicode(nickname)
  41
  42         # Expand the path relative to the current directory of the CLI command, not the node.
  43         self.local_dir = None if local_dir is None else argv_to_abspath(local_dir, long_path=False)
  44
  45         if self.nickname and not self.local_dir:
  46             raise usage.UsageError("If NICKNAME is specified then LOCAL_DIR must also be specified.")
  47         node_url_file = os.path.join(self['node-directory'], u"node.url")
  48         self['node-url'] = fileutil.read(node_url_file).strip()
  49
  50 def _delegate_options(source_options, target_options):
  51     target_options.aliases = get_aliases(source_options['node-directory'])
  52     target_options["node-url"] = source_options["node-url"]
  53     target_options["node-directory"] = source_options["node-directory"]
  54     target_options.stdin = StringIO("")
  55     target_options.stdout = StringIO()
  56     target_options.stderr = StringIO()
  57     return target_options
  58
  59 def create(options):
  60     precondition(isinstance(options.alias, unicode), alias=options.alias)
  61     precondition(isinstance(options.nickname, (unicode, NoneType)), nickname=options.nickname)
  62     precondition(isinstance(options.local_dir, (unicode, NoneType)), local_dir=options.local_dir)
  63
  64     from allmydata.scripts import tahoe_add_alias
  65     create_alias_options = _delegate_options(options, CreateAliasOptions())
  66     create_alias_options.alias = options.alias
  67
  68     rc = tahoe_add_alias.create_alias(create_alias_options)
  69     if rc != 0:
  70         print >>options.stderr, create_alias_options.stderr.getvalue()
  71         return rc
  72     print >>options.stdout, create_alias_options.stdout.getvalue()
  73
  74     if options.nickname is not None:
  75         invite_options = _delegate_options(options, InviteOptions())
  76         invite_options.alias = options.alias
  77         invite_options.nickname = options.nickname
  78         rc = invite(invite_options)
  79         if rc != 0:
  80             print >>options.stderr, "magic-folder: failed to invite after create\n"
  81             print >>options.stderr, invite_options.stderr.getvalue()
  82             return rc
  83         invite_code = invite_options.stdout.getvalue().strip()
  84         join_options = _delegate_options(options, JoinOptions())
  85         join_options.local_dir = options.local_dir
  86         join_options.invite_code = invite_code
  87         rc = join(join_options)
  88         if rc != 0:
  89             print >>options.stderr, "magic-folder: failed to join after create\n"
  90             print >>options.stderr, join_options.stderr.getvalue()
  91             return rc
  92     return 0
  93
  94 class InviteOptions(BasedirOptions):
  95     nickname = None
  96     synopsis = "MAGIC_ALIAS: NICKNAME"
  97     stdin = StringIO("")
  98     def parseArgs(self, alias, nickname=None):
  99         BasedirOptions.parseArgs(self)
 100         alias = argv_to_unicode(alias)
 101         if not alias.endswith(u':'):
 102             raise usage.UsageError("An alias must end with a ':' character.")
 103         self.alias = alias[:-1]
 104         self.nickname = argv_to_unicode(nickname)
 105         node_url_file = os.path.join(self['node-directory'], u"node.url")
 106         self['node-url'] = open(node_url_file, "r").read().strip()
 107         aliases = get_aliases(self['node-directory'])
 108         self.aliases = aliases
 109
 110 def invite(options):
 111     precondition(isinstance(options.alias, unicode), alias=options.alias)
 112     precondition(isinstance(options.nickname, unicode), nickname=options.nickname)
 113
 114     from allmydata.scripts import tahoe_mkdir
 115     mkdir_options = _delegate_options(options, MakeDirectoryOptions())
 116     mkdir_options.where = None
 117
 118     rc = tahoe_mkdir.mkdir(mkdir_options)
 119     if rc != 0:
 120         print >>options.stderr, "magic-folder: failed to mkdir\n"
 121         return rc
 122
 123     # FIXME this assumes caps are ASCII.
 124     dmd_write_cap = mkdir_options.stdout.getvalue().strip()
 125     dmd_readonly_cap = uri.from_string(dmd_write_cap).get_readonly().to_string()
 126     if dmd_readonly_cap is None:
 127         print >>options.stderr, "magic-folder: failed to diminish dmd write cap\n"
 128         return 1
 129
 130     magic_write_cap = get_aliases(options["node-directory"])[options.alias]
 131     magic_readonly_cap = uri.from_string(magic_write_cap).get_readonly().to_string()
 132
 133     # tahoe ln CLIENT_READCAP COLLECTIVE_WRITECAP/NICKNAME
 134     ln_options = _delegate_options(options, LnOptions())
 135     ln_options.from_file = unicode(dmd_readonly_cap, 'utf-8')
 136     ln_options.to_file = u"%s/%s" % (unicode(magic_write_cap, 'utf-8'), options.nickname)
 137     rc = tahoe_mv.mv(ln_options, mode="link")
 138     if rc != 0:
 139         print >>options.stderr, "magic-folder: failed to create link\n"
 140         print >>options.stderr, ln_options.stderr.getvalue()
 141         return rc
 142
 143     # FIXME: this assumes caps are ASCII.
 144     print >>options.stdout, "%s%s%s" % (magic_readonly_cap, INVITE_SEPARATOR, dmd_write_cap)
 145     return 0
 146
 147 class JoinOptions(BasedirOptions):
 148     synopsis = "INVITE_CODE LOCAL_DIR"
 149     dmd_write_cap = ""
 150     magic_readonly_cap = ""
 151     def parseArgs(self, invite_code, local_dir):
 152         BasedirOptions.parseArgs(self)
 153
 154         # Expand the path relative to the current directory of the CLI command, not the node.
 155         self.local_dir = None if local_dir is None else argv_to_abspath(local_dir, long_path=False)
 156         self.invite_code = to_str(argv_to_unicode(invite_code))
 157
 158 def join(options):
 159     fields = options.invite_code.split(INVITE_SEPARATOR)
 160     if len(fields) != 2:
 161         raise usage.UsageError("Invalid invite code.")
 162     magic_readonly_cap, dmd_write_cap = fields
 163
 164     dmd_cap_file = os.path.join(options["node-directory"], u"private", u"magic_folder_dircap")
 165     collective_readcap_file = os.path.join(options["node-directory"], u"private", u"collective_dircap")
 166     magic_folder_db_file = os.path.join(options["node-directory"], u"private", u"magicfolderdb.sqlite")
 167
 168     if os.path.exists(dmd_cap_file) or os.path.exists(collective_readcap_file) or os.path.exists(magic_folder_db_file):
 169         print >>options.stderr, ("\nThis client has already joined a magic folder."
 170                                  "\nUse the 'tahoe magic-folder leave' command first.\n")
 171         return 1
 172
 173     fileutil.write(dmd_cap_file, dmd_write_cap)
 174     fileutil.write(collective_readcap_file, magic_readonly_cap)
 175
 176     config = configutil.get_config(os.path.join(options["node-directory"], u"tahoe.cfg"))
 177     configutil.set_config(config, "magic_folder", "enabled", "True")
 178     configutil.set_config(config, "magic_folder", "local.directory", options.local_dir.encode('utf-8'))
 179     configutil.write_config(os.path.join(options["node-directory"], u"tahoe.cfg"), config)
 180     return 0
 181
 182 class LeaveOptions(BasedirOptions):
 183     synopsis = ""
 184     def parseArgs(self):
 185         BasedirOptions.parseArgs(self)
 186
 187 def leave(options):
 188     from ConfigParser import SafeConfigParser
 189
 190     dmd_cap_file = os.path.join(options["node-directory"], u"private", u"magic_folder_dircap")
 191     collective_readcap_file = os.path.join(options["node-directory"], u"private", u"collective_dircap")
 192     magic_folder_db_file = os.path.join(options["node-directory"], u"private", u"magicfolderdb.sqlite")
 193
 194     parser = SafeConfigParser()
 195     parser.read(os.path.join(options["node-directory"], u"tahoe.cfg"))
 196     parser.remove_section("magic_folder")
 197     f = open(os.path.join(options["node-directory"], u"tahoe.cfg"), "w")
 198     parser.write(f)
 199     f.close()
 200
 201     for f in [dmd_cap_file, collective_readcap_file, magic_folder_db_file]:
 202         try:
 203             fileutil.remove(f)
 204         except Exception as e:
 205             print >>options.stderr, ("Warning: unable to remove %s due to %s: %s"
 206                 % (quote_local_unicode_path(f), e.__class__.__name__, str(e)))
 207
 208 class StatusOptions(BasedirOptions):
 209     nickname = None
 210     synopsis = ""
 211     stdin = StringIO("")
 212
 213     def parseArgs(self):
 214         BasedirOptions.parseArgs(self)
 215         node_url_file = os.path.join(self['node-directory'], u"node.url")
 216         with open(node_url_file, "r") as f:
 217             self['node-url'] = f.read().strip()
 218
 219
 220 def _get_json_for_fragment(options, fragment, method='GET'):
 221     nodeurl = options['node-url']
 222     if nodeurl.endswith('/'):
 223         nodeurl = nodeurl[:-1]
 224
 225     url = u'%s/%s' % (nodeurl, fragment)
 226     resp = do_http(method, url)
 227     if isinstance(resp, BadResponse):
 228         # specifically NOT using format_http_error() here because the
 229         # URL is pretty sensitive (we're doing /uri/<key>).
 230         raise RuntimeError(
 231             "Failed to get json from '%s': %s" % (nodeurl, resp.error)
 232         )
 233
 234     data = resp.read()
 235     parsed = simplejson.loads(data)
 236     if not parsed:
 237         raise RuntimeError("No data from '%s'" % (nodeurl,))
 238     return parsed
 239
 240
 241 def _get_json_for_cap(options, cap):
 242     return _get_json_for_fragment(
 243         options,
 244         'uri/%s?t=json' % urllib.quote(cap),
 245     )
 246
 247 def _print_item_status(item, now, longest):
 248     paddedname = (' ' * (longest - len(item['path']))) + item['path']
 249     if 'failure_at' in item:
 250         ts = datetime.fromtimestamp(item['started_at'])
 251         prog = 'Failed %s (%s)' % (humanize.naturaltime(now - ts), ts)
 252     elif item['percent_done'] < 100.0:
 253         if 'started_at' not in item:
 254             prog = 'not yet started'
 255         else:
 256             so_far = now - datetime.fromtimestamp(item['started_at'])
 257             if so_far.seconds > 0.0:
 258                 rate = item['percent_done'] / so_far.seconds
 259                 if rate != 0:
 260                     time_left = (100.0 - item['percent_done']) / rate
 261                     prog = '%2.1f%% done, around %s left' % (
 262                         item['percent_done'],
 263                         humanize.naturaldelta(time_left),
 264                     )
 265                 else:
 266                     time_left = None
 267                     prog = '%2.1f%% done' % (item['percent_done'],)
 268             else:
 269                 prog = 'just started'
 270     else:
 271         prog = ''
 272         for verb in ['finished', 'started', 'queued']:
 273             keyname = verb + '_at'
 274             if keyname in item:
 275                 when = datetime.fromtimestamp(item[keyname])
 276                 prog = '%s %s' % (verb, humanize.naturaltime(now - when))
 277                 break
 278
 279     print "  %s: %s" % (paddedname, prog)
 280
 281 def status(options):
 282     nodedir = options["node-directory"]
 283     with open(os.path.join(nodedir, u"private", u"magic_folder_dircap")) as f:
 284         dmd_cap = f.read().strip()
 285     with open(os.path.join(nodedir, u"private", u"collective_dircap")) as f:
 286         collective_readcap = f.read().strip()
 287
 288     try:
 289         captype, dmd = _get_json_for_cap(options, dmd_cap)
 290         if captype != 'dirnode':
 291             print >>stderr, "magic_folder_dircap isn't a directory capability"
 292             return 2
 293     except RuntimeError as e:
 294         print >>stderr, str(e)
 295         return 1
 296
 297     now = datetime.now()
 298
 299     print "Local files:"
 300     for (name, child) in dmd['children'].items():
 301         captype, meta = child
 302         status = 'good'
 303         size = meta['size']
 304         created = datetime.fromtimestamp(meta['metadata']['tahoe']['linkcrtime'])
 305         version = meta['metadata']['version']
 306         nice_size = humanize.naturalsize(size)
 307         nice_created = humanize.naturaltime(now - created)
 308         if captype != 'filenode':
 309             print "%20s: error, should be a filecap" % name
 310             continue
 311         print "  %s (%s): %s, version=%s, created %s" % (name, nice_size, status, version, nice_created)
 312
 313     captype, collective = _get_json_for_cap(options, collective_readcap)
 314     print
 315     print "Remote files:"
 316     for (name, data) in collective['children'].items():
 317         if data[0] != 'dirnode':
 318             print "Error: '%s': expected a dirnode, not '%s'" % (name, data[0])
 319         print "  %s's remote:" % name
 320         dmd = _get_json_for_cap(options, data[1]['ro_uri'])
 321         if dmd[0] != 'dirnode':
 322             print "Error: should be a dirnode"
 323             continue
 324         for (n, d) in dmd[1]['children'].items():
 325             if d[0] != 'filenode':
 326                 print "Error: expected '%s' to be a filenode." % (n,)
 327
 328             meta = d[1]
 329             status = 'good'
 330             size = meta['size']
 331             created = datetime.fromtimestamp(meta['metadata']['tahoe']['linkcrtime'])
 332             version = meta['metadata']['version']
 333             nice_size = humanize.naturalsize(size)
 334             nice_created = humanize.naturaltime(now - created)
 335             print "    %s (%s): %s, version=%s, created %s" % (n, nice_size, status, version, nice_created)
 336
 337     with open(os.path.join(nodedir, u'private', u'api_auth_token'), 'rb') as f:
 338         token = f.read()
 339     magicdata = _get_json_for_fragment(
 340         options,
 341         'magic_folder?t=json&token=' + token,
 342         method='POST',
 343     )
 344     if len(magicdata):
 345         uploads = [item for item in magicdata if item['kind'] == 'upload']
 346         downloads = [item for item in magicdata if item['kind'] == 'download']
 347         longest = max([len(item['path']) for item in magicdata])
 348
 349         if True: # maybe --show-completed option or something?
 350             uploads = [item for item in uploads if item['status'] != 'success']
 351             downloads = [item for item in downloads if item['status'] != 'success']
 352
 353         if len(uploads):
 354             print
 355             print "Uploads:"
 356             for item in uploads:
 357                 _print_item_status(item, now, longest)
 358
 359         if len(downloads):
 360             print
 361             print "Downloads:"
 362             for item in downloads:
 363                 _print_item_status(item, now, longest)
 364
 365         for item in magicdata:
 366             if item['status'] == 'failure':
 367                 print "Failed:", item
 368
 369     return 0
 370
 371
 372 class MagicFolderCommand(BaseOptions):
 373     subCommands = [
 374         ["create", None, CreateOptions, "Create a Magic Folder."],
 375         ["invite", None, InviteOptions, "Invite someone to a Magic Folder."],
 376         ["join", None, JoinOptions, "Join a Magic Folder."],
 377         ["leave", None, LeaveOptions, "Leave a Magic Folder."],
 378         ["status", None, StatusOptions, "Display stutus of uploads/downloads."],
 379     ]
 380     def postOptions(self):
 381         if not hasattr(self, 'subOptions'):
 382             raise usage.UsageError("must specify a subcommand")
 383     def getSynopsis(self):
 384         return "Usage: tahoe [global-options] magic SUBCOMMAND"
 385     def getUsage(self, width=None):
 386         t = BaseOptions.getUsage(self, width)
 387         t += """\
 388 Please run e.g. 'tahoe magic-folder create --help' for more details on each
 389 subcommand.
 390 """
 391         return t
 392
 393 subDispatch = {
 394     "create": create,
 395     "invite": invite,
 396     "join": join,
 397     "leave": leave,
 398     "status": status,
 399 }
 400
 401 def do_magic_folder(options):
 402     so = options.subOptions
 403     so.stdout = options.stdout
 404     so.stderr = options.stderr
 405     f = subDispatch[options.subCommand]
 406     return f(so)
 407
 408 subCommands = [
 409     ["magic-folder", None, MagicFolderCommand,
 410      "Magic Folder subcommands: use 'tahoe magic-folder' for a list."],
 411 ]
 412
 413 dispatch = {
 414     "magic-folder": do_magic_folder,
 415 }