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     # if this doesn't return 0, then the CLI stuff fails
 208     return 0
 209
 210 class StatusOptions(BasedirOptions):
 211     nickname = None
 212     synopsis = ""
 213     stdin = StringIO("")
 214
 215     def parseArgs(self):
 216         BasedirOptions.parseArgs(self)
 217         node_url_file = os.path.join(self['node-directory'], u"node.url")
 218         with open(node_url_file, "r") as f:
 219             self['node-url'] = f.read().strip()
 220
 221
 222 def _get_json_for_fragment(options, fragment, method='GET'):
 223     nodeurl = options['node-url']
 224     if nodeurl.endswith('/'):
 225         nodeurl = nodeurl[:-1]
 226
 227     url = u'%s/%s' % (nodeurl, fragment)
 228     resp = do_http(method, url)
 229     if isinstance(resp, BadResponse):
 230         # specifically NOT using format_http_error() here because the
 231         # URL is pretty sensitive (we're doing /uri/<key>).
 232         raise RuntimeError(
 233             "Failed to get json from '%s': %s" % (nodeurl, resp.error)
 234         )
 235
 236     data = resp.read()
 237     parsed = simplejson.loads(data)
 238     if not parsed:
 239         raise RuntimeError("No data from '%s'" % (nodeurl,))
 240     return parsed
 241
 242
 243 def _get_json_for_cap(options, cap):
 244     return _get_json_for_fragment(
 245         options,
 246         'uri/%s?t=json' % urllib.quote(cap),
 247     )
 248
 249 def _print_item_status(item, now, longest):
 250     paddedname = (' ' * (longest - len(item['path']))) + item['path']
 251     if 'failure_at' in item:
 252         ts = datetime.fromtimestamp(item['started_at'])
 253         prog = 'Failed %s (%s)' % (humanize.naturaltime(now - ts), ts)
 254     elif item['percent_done'] < 100.0:
 255         if 'started_at' not in item:
 256             prog = 'not yet started'
 257         else:
 258             so_far = now - datetime.fromtimestamp(item['started_at'])
 259             if so_far.seconds > 0.0:
 260                 rate = item['percent_done'] / so_far.seconds
 261                 if rate != 0:
 262                     time_left = (100.0 - item['percent_done']) / rate
 263                     prog = '%2.1f%% done, around %s left' % (
 264                         item['percent_done'],
 265                         humanize.naturaldelta(time_left),
 266                     )
 267                 else:
 268                     time_left = None
 269                     prog = '%2.1f%% done' % (item['percent_done'],)
 270             else:
 271                 prog = 'just started'
 272     else:
 273         prog = ''
 274         for verb in ['finished', 'started', 'queued']:
 275             keyname = verb + '_at'
 276             if keyname in item:
 277                 when = datetime.fromtimestamp(item[keyname])
 278                 prog = '%s %s' % (verb, humanize.naturaltime(now - when))
 279                 break
 280
 281     print "  %s: %s" % (paddedname, prog)
 282
 283 def status(options):
 284     nodedir = options["node-directory"]
 285     with open(os.path.join(nodedir, u"private", u"magic_folder_dircap")) as f:
 286         dmd_cap = f.read().strip()
 287     with open(os.path.join(nodedir, u"private", u"collective_dircap")) as f:
 288         collective_readcap = f.read().strip()
 289
 290     try:
 291         captype, dmd = _get_json_for_cap(options, dmd_cap)
 292         if captype != 'dirnode':
 293             print >>stderr, "magic_folder_dircap isn't a directory capability"
 294             return 2
 295     except RuntimeError as e:
 296         print >>stderr, str(e)
 297         return 1
 298
 299     now = datetime.now()
 300
 301     print "Local files:"
 302     for (name, child) in dmd['children'].items():
 303         captype, meta = child
 304         status = 'good'
 305         size = meta['size']
 306         created = datetime.fromtimestamp(meta['metadata']['tahoe']['linkcrtime'])
 307         version = meta['metadata']['version']
 308         nice_size = humanize.naturalsize(size)
 309         nice_created = humanize.naturaltime(now - created)
 310         if captype != 'filenode':
 311             print "%20s: error, should be a filecap" % name
 312             continue
 313         print "  %s (%s): %s, version=%s, created %s" % (name, nice_size, status, version, nice_created)
 314
 315     captype, collective = _get_json_for_cap(options, collective_readcap)
 316     print
 317     print "Remote files:"
 318     for (name, data) in collective['children'].items():
 319         if data[0] != 'dirnode':
 320             print "Error: '%s': expected a dirnode, not '%s'" % (name, data[0])
 321         print "  %s's remote:" % name
 322         dmd = _get_json_for_cap(options, data[1]['ro_uri'])
 323         if dmd[0] != 'dirnode':
 324             print "Error: should be a dirnode"
 325             continue
 326         for (n, d) in dmd[1]['children'].items():
 327             if d[0] != 'filenode':
 328                 print "Error: expected '%s' to be a filenode." % (n,)
 329
 330             meta = d[1]
 331             status = 'good'
 332             size = meta['size']
 333             created = datetime.fromtimestamp(meta['metadata']['tahoe']['linkcrtime'])
 334             version = meta['metadata']['version']
 335             nice_size = humanize.naturalsize(size)
 336             nice_created = humanize.naturaltime(now - created)
 337             print "    %s (%s): %s, version=%s, created %s" % (n, nice_size, status, version, nice_created)
 338
 339     with open(os.path.join(nodedir, u'private', u'api_auth_token'), 'rb') as f:
 340         token = f.read()
 341     magicdata = _get_json_for_fragment(
 342         options,
 343         'magic_folder?t=json&token=' + token,
 344         method='POST',
 345     )
 346     if len(magicdata):
 347         uploads = [item for item in magicdata if item['kind'] == 'upload']
 348         downloads = [item for item in magicdata if item['kind'] == 'download']
 349         longest = max([len(item['path']) for item in magicdata])
 350
 351         if True: # maybe --show-completed option or something?
 352             uploads = [item for item in uploads if item['status'] != 'success']
 353             downloads = [item for item in downloads if item['status'] != 'success']
 354
 355         if len(uploads):
 356             print
 357             print "Uploads:"
 358             for item in uploads:
 359                 _print_item_status(item, now, longest)
 360
 361         if len(downloads):
 362             print
 363             print "Downloads:"
 364             for item in downloads:
 365                 _print_item_status(item, now, longest)
 366
 367         for item in magicdata:
 368             if item['status'] == 'failure':
 369                 print "Failed:", item
 370
 371     return 0
 372
 373
 374 class MagicFolderCommand(BaseOptions):
 375     subCommands = [
 376         ["create", None, CreateOptions, "Create a Magic Folder."],
 377         ["invite", None, InviteOptions, "Invite someone to a Magic Folder."],
 378         ["join", None, JoinOptions, "Join a Magic Folder."],
 379         ["leave", None, LeaveOptions, "Leave a Magic Folder."],
 380         ["status", None, StatusOptions, "Display stutus of uploads/downloads."],
 381     ]
 382     def postOptions(self):
 383         if not hasattr(self, 'subOptions'):
 384             raise usage.UsageError("must specify a subcommand")
 385     def getSynopsis(self):
 386         return "Usage: tahoe [global-options] magic SUBCOMMAND"
 387     def getUsage(self, width=None):
 388         t = BaseOptions.getUsage(self, width)
 389         t += """\
 390 Please run e.g. 'tahoe magic-folder create --help' for more details on each
 391 subcommand.
 392 """
 393         return t
 394
 395 subDispatch = {
 396     "create": create,
 397     "invite": invite,
 398     "join": join,
 399     "leave": leave,
 400     "status": status,
 401 }
 402
 403 def do_magic_folder(options):
 404     so = options.subOptions
 405     so.stdout = options.stdout
 406     so.stderr = options.stderr
 407     f = subDispatch[options.subCommand]
 408     return f(so)
 409
 410 subCommands = [
 411     ["magic-folder", None, MagicFolderCommand,
 412      "Magic Folder subcommands: use 'tahoe magic-folder' for a list."],
 413 ]
 414
 415 dispatch = {
 416     "magic-folder": do_magic_folder,
 417 }