3 from types import NoneType
4 from cStringIO import StringIO
6 from twisted.python import usage
8 from allmydata.util.assertutil import precondition
10 from .common import BaseOptions, BasedirOptions, get_aliases
11 from .cli import MakeDirectoryOptions, LnOptions, CreateAliasOptions
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
17 INVITE_SEPARATOR = "+"
19 class CreateOptions(BasedirOptions):
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()
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()
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)
50 from allmydata.scripts import tahoe_add_alias
51 create_alias_options = _delegate_options(options, CreateAliasOptions())
52 create_alias_options.alias = options.alias
54 rc = tahoe_add_alias.create_alias(create_alias_options)
56 print >>options.stderr, create_alias_options.stderr.getvalue()
58 print >>options.stdout, create_alias_options.stdout.getvalue()
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)
66 print >>options.stderr, "magic-folder: failed to invite after create\n"
67 print >>options.stderr, invite_options.stderr.getvalue()
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)
75 print >>options.stderr, "magic-folder: failed to join after create\n"
76 print >>options.stderr, join_options.stderr.getvalue()
80 class InviteOptions(BasedirOptions):
82 synopsis = "MAGIC_ALIAS: NICKNAME"
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
97 precondition(isinstance(options.alias, unicode), alias=options.alias)
98 precondition(isinstance(options.nickname, unicode), nickname=options.nickname)
100 from allmydata.scripts import tahoe_mkdir
101 mkdir_options = _delegate_options(options, MakeDirectoryOptions())
102 mkdir_options.where = None
104 rc = tahoe_mkdir.mkdir(mkdir_options)
106 print >>options.stderr, "magic-folder: failed to mkdir\n"
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"
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()
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")
125 print >>options.stderr, "magic-folder: failed to create link\n"
126 print >>options.stderr, ln_options.stderr.getvalue()
129 # FIXME: this assumes caps are ASCII.
130 print >>options.stdout, "%s%s%s" % (magic_readonly_cap, INVITE_SEPARATOR, dmd_write_cap)
133 class JoinOptions(BasedirOptions):
134 synopsis = "INVITE_CODE LOCAL_DIR"
136 magic_readonly_cap = ""
137 def parseArgs(self, invite_code, local_dir):
138 BasedirOptions.parseArgs(self)
140 # Expand the path relative to the current directory of the CLI command, not the node.
141 self.local_dir = None if local_dir is None else argv_to_abspath(local_dir, long_path=False)
142 self.invite_code = to_str(argv_to_unicode(invite_code))
145 fields = options.invite_code.split(INVITE_SEPARATOR)
147 raise usage.UsageError("Invalid invite code.")
148 magic_readonly_cap, dmd_write_cap = fields
150 dmd_cap_file = os.path.join(options["node-directory"], u"private", u"magic_folder_dircap")
151 collective_readcap_file = os.path.join(options["node-directory"], u"private", u"collective_dircap")
153 fileutil.write(dmd_cap_file, dmd_write_cap)
154 fileutil.write(collective_readcap_file, magic_readonly_cap)
156 # FIXME: modify any existing [magic_folder] fields, rather than appending.
157 fileutil.write(os.path.join(options["node-directory"], u"tahoe.cfg"),
158 "[magic_folder]\nenabled = True\nlocal.directory = %s\n"
159 % (options.local_dir.encode('utf-8'),), mode="ab")
162 class MagicFolderCommand(BaseOptions):
164 ["create", None, CreateOptions, "Create a Magic Folder."],
165 ["invite", None, InviteOptions, "Invite someone to a Magic Folder."],
166 ["join", None, JoinOptions, "Join a Magic Folder."],
168 def postOptions(self):
169 if not hasattr(self, 'subOptions'):
170 raise usage.UsageError("must specify a subcommand")
171 def getSynopsis(self):
172 return "Usage: tahoe [global-options] magic SUBCOMMAND"
173 def getUsage(self, width=None):
174 t = BaseOptions.getUsage(self, width)
176 Please run e.g. 'tahoe magic-folder create --help' for more details on each
187 def do_magic_folder(options):
188 so = options.subOptions
189 so.stdout = options.stdout
190 so.stderr = options.stderr
191 f = subDispatch[options.subCommand]
195 ["magic-folder", None, MagicFolderCommand,
196 "Magic Folder subcommands: use 'tahoe magic-folder' for a list."],
200 "magic-folder": do_magic_folder,