src/allmydata/scripts/magic_folder_cli.py

   1
   2 import os
   3 from types import NoneType
   4 from cStringIO import StringIO
   5
   6 from twisted.python import usage
   7
   8 from allmydata.util.assertutil import precondition
   9
  10 from .common import BaseOptions, BasedirOptions, get_aliases
  11 from .cli import MakeDirectoryOptions, LnOptions, CreateAliasOptions
  12 import tahoe_mv
  13 from allmydata.util.encodingutil import argv_to_abspath, argv_to_unicode, to_str
  14 from allmydata.util import fileutil
  15 from allmydata import uri
  16
  17 INVITE_SEPARATOR = "+"
  18
  19 class CreateOptions(BasedirOptions):
  20     nickname = None
  21     local_dir = None
  22     synopsis = "MAGIC_ALIAS: [NICKNAME LOCAL_DIR]"
  23     def parseArgs(self, alias, nickname=None, local_dir=None):
  24         BasedirOptions.parseArgs(self)
  25         alias = argv_to_unicode(alias)
  26         if not alias.endswith(u':'):
  27             raise usage.UsageError("An alias must end with a ':' character.")
  28         self.alias = alias[:-1]
  29         self.nickname = None if nickname is None else argv_to_unicode(nickname)
  30         self.local_dir = None if local_dir is None else argv_to_abspath(local_dir)
  31         if self.nickname and not self.local_dir:
  32             raise usage.UsageError("If NICKNAME is specified then LOCAL_DIR must also be specified.")
  33         node_url_file = os.path.join(self['node-directory'], "node.url")
  34         self['node-url'] = fileutil.read(node_url_file).strip()
  35
  36 def _delegate_options(source_options, target_options):
  37     target_options.aliases = get_aliases(source_options['node-directory'])
  38     target_options["node-url"] = source_options["node-url"]
  39     target_options["node-directory"] = source_options["node-directory"]
  40     target_options.stdin = StringIO("")
  41     target_options.stdout = StringIO()
  42     target_options.stderr = StringIO()
  43     return target_options
  44
  45 def create(options):
  46     precondition(isinstance(options.alias, unicode), alias=options.alias)
  47     precondition(isinstance(options.nickname, (unicode, NoneType)), nickname=options.nickname)
  48     precondition(isinstance(options.local_dir, (unicode, NoneType)), local_dir=options.local_dir)
  49
  50     from allmydata.scripts import tahoe_add_alias
  51     create_alias_options = _delegate_options(options, CreateAliasOptions())
  52     create_alias_options.alias = options.alias
  53
  54     rc = tahoe_add_alias.create_alias(create_alias_options)
  55     if rc != 0:
  56         print >>options.stderr, create_alias_options.stderr.getvalue()
  57         return rc
  58     print >>options.stdout, create_alias_options.stdout.getvalue()
  59
  60     if options.nickname is not None:
  61         invite_options = _delegate_options(options, InviteOptions())
  62         invite_options.alias = options.alias
  63         invite_options.nickname = options.nickname
  64         rc = invite(invite_options)
  65         if rc != 0:
  66             print >>options.stderr, "magic-folder: failed to invite after create\n"
  67             print >>options.stderr, invite_options.stderr.getvalue()
  68             return rc
  69         invite_code = invite_options.stdout.getvalue().strip()
  70         join_options = _delegate_options(options, JoinOptions())
  71         join_options.local_dir = options.local_dir
  72         join_options.invite_code = invite_code
  73         rc = join(join_options)
  74         if rc != 0:
  75             print >>options.stderr, "magic-folder: failed to join after create\n"
  76             print >>options.stderr, join_options.stderr.getvalue()
  77             return rc
  78     return 0
  79
  80 class InviteOptions(BasedirOptions):
  81     nickname = None
  82     synopsis = "MAGIC_ALIAS: NICKNAME"
  83     stdin = StringIO("")
  84     def parseArgs(self, alias, nickname=None):
  85         BasedirOptions.parseArgs(self)
  86         alias = argv_to_unicode(alias)
  87         if not alias.endswith(u':'):
  88             raise usage.UsageError("An alias must end with a ':' character.")
  89         self.alias = alias[:-1]
  90         self.nickname = argv_to_unicode(nickname)
  91         node_url_file = os.path.join(self['node-directory'], "node.url")
  92         self['node-url'] = open(node_url_file, "r").read().strip()
  93         aliases = get_aliases(self['node-directory'])
  94         self.aliases = aliases
  95
  96 def invite(options):
  97     precondition(isinstance(options.alias, unicode), alias=options.alias)
  98     precondition(isinstance(options.nickname, unicode), nickname=options.nickname)
  99
 100     from allmydata.scripts import tahoe_mkdir
 101     mkdir_options = _delegate_options(options, MakeDirectoryOptions())
 102     mkdir_options.where = None
 103
 104     rc = tahoe_mkdir.mkdir(mkdir_options)
 105     if rc != 0:
 106         print >>options.stderr, "magic-folder: failed to mkdir\n"
 107         return rc
 108
 109     # FIXME this assumes caps are ASCII.
 110     dmd_write_cap = mkdir_options.stdout.getvalue().strip()
 111     dmd_readonly_cap = uri.from_string(dmd_write_cap).get_readonly().to_string()
 112     if dmd_readonly_cap is None:
 113         print >>options.stderr, "magic-folder: failed to diminish dmd write cap\n"
 114         return 1
 115
 116     magic_write_cap = get_aliases(options["node-directory"])[options.alias]
 117     magic_readonly_cap = uri.from_string(magic_write_cap).get_readonly().to_string()
 118
 119     # tahoe ln CLIENT_READCAP COLLECTIVE_WRITECAP/NICKNAME
 120     ln_options = _delegate_options(options, LnOptions())
 121     ln_options.from_file = unicode(dmd_readonly_cap, 'utf-8')
 122     ln_options.to_file = u"%s/%s" % (unicode(magic_write_cap, 'utf-8'), options.nickname)
 123     rc = tahoe_mv.mv(ln_options, mode="link")
 124     if rc != 0:
 125         print >>options.stderr, "magic-folder: failed to create link\n"
 126         print >>options.stderr, ln_options.stderr.getvalue()
 127         return rc
 128
 129     # FIXME: this assumes caps are ASCII.
 130     print >>options.stdout, "%s%s%s" % (magic_readonly_cap, INVITE_SEPARATOR, dmd_write_cap)
 131     return 0
 132
 133 class JoinOptions(BasedirOptions):
 134     synopsis = "INVITE_CODE LOCAL_DIR"
 135     dmd_write_cap = ""
 136     magic_readonly_cap = ""
 137     def parseArgs(self, invite_code, local_dir):
 138         BasedirOptions.parseArgs(self)
 139         self.local_dir = None if local_dir is None else argv_to_abspath(local_dir)
 140         self.invite_code = to_str(argv_to_unicode(invite_code))
 141
 142 def join(options):
 143     fields = options.invite_code.split(INVITE_SEPARATOR)
 144     if len(fields) != 2:
 145         raise usage.UsageError("Invalid invite code.")
 146     magic_readonly_cap, dmd_write_cap = fields
 147
 148     dmd_cap_file = os.path.join(options["node-directory"], u"private", u"magic_folder_dircap")
 149     collective_readcap_file = os.path.join(options["node-directory"], u"private", u"collective_dircap")
 150
 151     fileutil.write(dmd_cap_file, dmd_write_cap)
 152     fileutil.write(collective_readcap_file, magic_readonly_cap)
 153     fileutil.write(os.path.join(options["node-directory"], u"tahoe.cfg"),
 154                    "[magic_folder]\nenabled = True\nlocal.directory = %s\n"
 155                    % (options.local_dir.encode('utf-8'),), mode="ab")
 156     return 0
 157
 158 class MagicFolderCommand(BaseOptions):
 159     subCommands = [
 160         ["create", None, CreateOptions, "Create a Magic Folder."],
 161         ["invite", None, InviteOptions, "Invite someone to a Magic Folder."],
 162         ["join", None, JoinOptions, "Join a Magic Folder."],
 163     ]
 164     def postOptions(self):
 165         if not hasattr(self, 'subOptions'):
 166             raise usage.UsageError("must specify a subcommand")
 167     def getSynopsis(self):
 168         return "Usage: tahoe [global-options] magic SUBCOMMAND"
 169     def getUsage(self, width=None):
 170         t = BaseOptions.getUsage(self, width)
 171         t += """\
 172 Please run e.g. 'tahoe magic-folder create --help' for more details on each
 173 subcommand.
 174 """
 175         return t
 176
 177 subDispatch = {
 178     "create": create,
 179     "invite": invite,
 180     "join": join,
 181 }
 182
 183 def do_magic_folder(options):
 184     so = options.subOptions
 185     so.stdout = options.stdout
 186     so.stderr = options.stderr
 187     f = subDispatch[options.subCommand]
 188     return f(so)
 189
 190 subCommands = [
 191     ["magic-folder", None, MagicFolderCommand,
 192      "Magic Folder subcommands: use 'tahoe magic-folder' for a list."],
 193 ]
 194
 195 dispatch = {
 196     "magic-folder": do_magic_folder,
 197 }