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