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     quote_local_unicode_path
  15 from allmydata.util import fileutil
  16 from allmydata.util import configutil
  17 from allmydata import uri
  18
  19 INVITE_SEPARATOR = "+"
  20
  21 class CreateOptions(BasedirOptions):
  22     nickname = None
  23     local_dir = None
  24     synopsis = "MAGIC_ALIAS: [NICKNAME LOCAL_DIR]"
  25     def parseArgs(self, alias, nickname=None, local_dir=None):
  26         BasedirOptions.parseArgs(self)
  27         alias = argv_to_unicode(alias)
  28         if not alias.endswith(u':'):
  29             raise usage.UsageError("An alias must end with a ':' character.")
  30         self.alias = alias[:-1]
  31         self.nickname = None if nickname is None else argv_to_unicode(nickname)
  32
  33         # Expand the path relative to the current directory of the CLI command, not the node.
  34         self.local_dir = None if local_dir is None else argv_to_abspath(local_dir, long_path=False)
  35
  36         if self.nickname and not self.local_dir:
  37             raise usage.UsageError("If NICKNAME is specified then LOCAL_DIR must also be specified.")
  38         node_url_file = os.path.join(self['node-directory'], u"node.url")
  39         self['node-url'] = fileutil.read(node_url_file).strip()
  40
  41 def _delegate_options(source_options, target_options):
  42     target_options.aliases = get_aliases(source_options['node-directory'])
  43     target_options["node-url"] = source_options["node-url"]
  44     target_options["node-directory"] = source_options["node-directory"]
  45     target_options.stdin = StringIO("")
  46     target_options.stdout = StringIO()
  47     target_options.stderr = StringIO()
  48     return target_options
  49
  50 def create(options):
  51     precondition(isinstance(options.alias, unicode), alias=options.alias)
  52     precondition(isinstance(options.nickname, (unicode, NoneType)), nickname=options.nickname)
  53     precondition(isinstance(options.local_dir, (unicode, NoneType)), local_dir=options.local_dir)
  54
  55     from allmydata.scripts import tahoe_add_alias
  56     create_alias_options = _delegate_options(options, CreateAliasOptions())
  57     create_alias_options.alias = options.alias
  58
  59     rc = tahoe_add_alias.create_alias(create_alias_options)
  60     if rc != 0:
  61         print >>options.stderr, create_alias_options.stderr.getvalue()
  62         return rc
  63     print >>options.stdout, create_alias_options.stdout.getvalue()
  64
  65     if options.nickname is not None:
  66         invite_options = _delegate_options(options, InviteOptions())
  67         invite_options.alias = options.alias
  68         invite_options.nickname = options.nickname
  69         rc = invite(invite_options)
  70         if rc != 0:
  71             print >>options.stderr, "magic-folder: failed to invite after create\n"
  72             print >>options.stderr, invite_options.stderr.getvalue()
  73             return rc
  74         invite_code = invite_options.stdout.getvalue().strip()
  75         join_options = _delegate_options(options, JoinOptions())
  76         join_options.local_dir = options.local_dir
  77         join_options.invite_code = invite_code
  78         rc = join(join_options)
  79         if rc != 0:
  80             print >>options.stderr, "magic-folder: failed to join after create\n"
  81             print >>options.stderr, join_options.stderr.getvalue()
  82             return rc
  83     return 0
  84
  85 class InviteOptions(BasedirOptions):
  86     nickname = None
  87     synopsis = "MAGIC_ALIAS: NICKNAME"
  88     stdin = StringIO("")
  89     def parseArgs(self, alias, nickname=None):
  90         BasedirOptions.parseArgs(self)
  91         alias = argv_to_unicode(alias)
  92         if not alias.endswith(u':'):
  93             raise usage.UsageError("An alias must end with a ':' character.")
  94         self.alias = alias[:-1]
  95         self.nickname = argv_to_unicode(nickname)
  96         node_url_file = os.path.join(self['node-directory'], u"node.url")
  97         self['node-url'] = open(node_url_file, "r").read().strip()
  98         aliases = get_aliases(self['node-directory'])
  99         self.aliases = aliases
 100
 101 def invite(options):
 102     precondition(isinstance(options.alias, unicode), alias=options.alias)
 103     precondition(isinstance(options.nickname, unicode), nickname=options.nickname)
 104
 105     from allmydata.scripts import tahoe_mkdir
 106     mkdir_options = _delegate_options(options, MakeDirectoryOptions())
 107     mkdir_options.where = None
 108
 109     rc = tahoe_mkdir.mkdir(mkdir_options)
 110     if rc != 0:
 111         print >>options.stderr, "magic-folder: failed to mkdir\n"
 112         return rc
 113
 114     # FIXME this assumes caps are ASCII.
 115     dmd_write_cap = mkdir_options.stdout.getvalue().strip()
 116     dmd_readonly_cap = uri.from_string(dmd_write_cap).get_readonly().to_string()
 117     if dmd_readonly_cap is None:
 118         print >>options.stderr, "magic-folder: failed to diminish dmd write cap\n"
 119         return 1
 120
 121     magic_write_cap = get_aliases(options["node-directory"])[options.alias]
 122     magic_readonly_cap = uri.from_string(magic_write_cap).get_readonly().to_string()
 123
 124     # tahoe ln CLIENT_READCAP COLLECTIVE_WRITECAP/NICKNAME
 125     ln_options = _delegate_options(options, LnOptions())
 126     ln_options.from_file = unicode(dmd_readonly_cap, 'utf-8')
 127     ln_options.to_file = u"%s/%s" % (unicode(magic_write_cap, 'utf-8'), options.nickname)
 128     rc = tahoe_mv.mv(ln_options, mode="link")
 129     if rc != 0:
 130         print >>options.stderr, "magic-folder: failed to create link\n"
 131         print >>options.stderr, ln_options.stderr.getvalue()
 132         return rc
 133
 134     # FIXME: this assumes caps are ASCII.
 135     print >>options.stdout, "%s%s%s" % (magic_readonly_cap, INVITE_SEPARATOR, dmd_write_cap)
 136     return 0
 137
 138 class JoinOptions(BasedirOptions):
 139     synopsis = "INVITE_CODE LOCAL_DIR"
 140     dmd_write_cap = ""
 141     magic_readonly_cap = ""
 142     def parseArgs(self, invite_code, local_dir):
 143         BasedirOptions.parseArgs(self)
 144
 145         # Expand the path relative to the current directory of the CLI command, not the node.
 146         self.local_dir = None if local_dir is None else argv_to_abspath(local_dir, long_path=False)
 147         self.invite_code = to_str(argv_to_unicode(invite_code))
 148
 149 def join(options):
 150     fields = options.invite_code.split(INVITE_SEPARATOR)
 151     if len(fields) != 2:
 152         raise usage.UsageError("Invalid invite code.")
 153     magic_readonly_cap, dmd_write_cap = fields
 154
 155     dmd_cap_file = os.path.join(options["node-directory"], u"private", u"magic_folder_dircap")
 156     collective_readcap_file = os.path.join(options["node-directory"], u"private", u"collective_dircap")
 157     magic_folder_db_file = os.path.join(options["node-directory"], u"private", u"magicfolderdb.sqlite")
 158
 159     if os.path.exists(dmd_cap_file) or os.path.exists(collective_readcap_file) or os.path.exists(magic_folder_db_file):
 160         print >>options.stderr, ("\nThis client has already joined a magic folder."
 161                                  "\nUse the 'tahoe magic-folder leave' command first.\n")
 162         return 1
 163
 164     fileutil.write(dmd_cap_file, dmd_write_cap)
 165     fileutil.write(collective_readcap_file, magic_readonly_cap)
 166
 167     config = configutil.get_config(os.path.join(options["node-directory"], u"tahoe.cfg"))
 168     configutil.set_config(config, "magic_folder", "enabled", "True")
 169     configutil.set_config(config, "magic_folder", "local.directory", options.local_dir.encode('utf-8'))
 170     configutil.write_config(os.path.join(options["node-directory"], u"tahoe.cfg"), config)
 171     return 0
 172
 173 class LeaveOptions(BasedirOptions):
 174     synopsis = ""
 175     def parseArgs(self):
 176         BasedirOptions.parseArgs(self)
 177
 178 def leave(options):
 179     from ConfigParser import SafeConfigParser
 180
 181     dmd_cap_file = os.path.join(options["node-directory"], u"private", u"magic_folder_dircap")
 182     collective_readcap_file = os.path.join(options["node-directory"], u"private", u"collective_dircap")
 183     magic_folder_db_file = os.path.join(options["node-directory"], u"private", u"magicfolderdb.sqlite")
 184
 185     parser = SafeConfigParser()
 186     parser.read(os.path.join(options["node-directory"], u"tahoe.cfg"))
 187     parser.remove_section("magic_folder")
 188     f = open(os.path.join(options["node-directory"], u"tahoe.cfg"), "w")
 189     parser.write(f)
 190     f.close()
 191
 192     for f in [dmd_cap_file, collective_readcap_file, magic_folder_db_file]:
 193         try:
 194             fileutil.remove(f)
 195         except Exception as e:
 196             print >>options.stderr, ("Warning: unable to remove %s due to %s: %s"
 197                 % (quote_local_unicode_path(f), e.__class__.__name__, str(e)))
 198
 199     return 0
 200
 201 class MagicFolderCommand(BaseOptions):
 202     subCommands = [
 203         ["create", None, CreateOptions, "Create a Magic Folder."],
 204         ["invite", None, InviteOptions, "Invite someone to a Magic Folder."],
 205         ["join", None, JoinOptions, "Join a Magic Folder."],
 206         ["leave", None, LeaveOptions, "Leave a Magic Folder."],
 207     ]
 208     def postOptions(self):
 209         if not hasattr(self, 'subOptions'):
 210             raise usage.UsageError("must specify a subcommand")
 211     def getSynopsis(self):
 212         return "Usage: tahoe [global-options] magic SUBCOMMAND"
 213     def getUsage(self, width=None):
 214         t = BaseOptions.getUsage(self, width)
 215         t += """\
 216 Please run e.g. 'tahoe magic-folder create --help' for more details on each
 217 subcommand.
 218 """
 219         return t
 220
 221 subDispatch = {
 222     "create": create,
 223     "invite": invite,
 224     "join": join,
 225     "leave": leave,
 226 }
 227
 228 def do_magic_folder(options):
 229     so = options.subOptions
 230     so.stdout = options.stdout
 231     so.stderr = options.stderr
 232     f = subDispatch[options.subCommand]
 233     return f(so)
 234
 235 subCommands = [
 236     ["magic-folder", None, MagicFolderCommand,
 237      "Magic Folder subcommands: use 'tahoe magic-folder' for a list."],
 238 ]
 239
 240 dispatch = {
 241     "magic-folder": do_magic_folder,
 242 }