5 from types import NoneType
6 from cStringIO import StringIO
7 from datetime import datetime
12 from twisted.python import usage
14 from allmydata.util.assertutil import precondition
16 from .common import BaseOptions, BasedirOptions, get_aliases
17 from .cli import MakeDirectoryOptions, LnOptions, CreateAliasOptions
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
28 INVITE_SEPARATOR = "+"
30 class CreateOptions(BasedirOptions):
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)
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)
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()
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()
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)
64 from allmydata.scripts import tahoe_add_alias
65 create_alias_options = _delegate_options(options, CreateAliasOptions())
66 create_alias_options.alias = options.alias
68 rc = tahoe_add_alias.create_alias(create_alias_options)
70 print >>options.stderr, create_alias_options.stderr.getvalue()
72 print >>options.stdout, create_alias_options.stdout.getvalue()
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)
80 print >>options.stderr, "magic-folder: failed to invite after create\n"
81 print >>options.stderr, invite_options.stderr.getvalue()
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)
89 print >>options.stderr, "magic-folder: failed to join after create\n"
90 print >>options.stderr, join_options.stderr.getvalue()
94 class InviteOptions(BasedirOptions):
96 synopsis = "MAGIC_ALIAS: NICKNAME"
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
111 precondition(isinstance(options.alias, unicode), alias=options.alias)
112 precondition(isinstance(options.nickname, unicode), nickname=options.nickname)
114 from allmydata.scripts import tahoe_mkdir
115 mkdir_options = _delegate_options(options, MakeDirectoryOptions())
116 mkdir_options.where = None
118 rc = tahoe_mkdir.mkdir(mkdir_options)
120 print >>options.stderr, "magic-folder: failed to mkdir\n"
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"
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()
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")
139 print >>options.stderr, "magic-folder: failed to create link\n"
140 print >>options.stderr, ln_options.stderr.getvalue()
143 # FIXME: this assumes caps are ASCII.
144 print >>options.stdout, "%s%s%s" % (magic_readonly_cap, INVITE_SEPARATOR, dmd_write_cap)
147 class JoinOptions(BasedirOptions):
148 synopsis = "INVITE_CODE LOCAL_DIR"
150 magic_readonly_cap = ""
151 def parseArgs(self, invite_code, local_dir):
152 BasedirOptions.parseArgs(self)
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))
159 fields = options.invite_code.split(INVITE_SEPARATOR)
161 raise usage.UsageError("Invalid invite code.")
162 magic_readonly_cap, dmd_write_cap = fields
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")
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")
173 fileutil.write(dmd_cap_file, dmd_write_cap)
174 fileutil.write(collective_readcap_file, magic_readonly_cap)
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)
182 class LeaveOptions(BasedirOptions):
185 BasedirOptions.parseArgs(self)
188 from ConfigParser import SafeConfigParser
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")
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")
201 for f in [dmd_cap_file, collective_readcap_file, magic_folder_db_file]:
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
210 class StatusOptions(BasedirOptions):
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()
222 def _get_json_for_fragment(options, fragment, method='GET'):
223 nodeurl = options['node-url']
224 if nodeurl.endswith('/'):
225 nodeurl = nodeurl[:-1]
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>).
233 "Failed to get json from '%s': %s" % (nodeurl, resp.error)
237 parsed = simplejson.loads(data)
239 raise RuntimeError("No data from '%s'" % (nodeurl,))
243 def _get_json_for_cap(options, cap):
244 return _get_json_for_fragment(
246 'uri/%s?t=json' % urllib.quote(cap),
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'
258 so_far = now - datetime.fromtimestamp(item['started_at'])
259 if so_far.seconds > 0.0:
260 rate = item['percent_done'] / so_far.seconds
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),
269 prog = '%2.1f%% done' % (item['percent_done'],)
271 prog = 'just started'
274 for verb in ['finished', 'started', 'queued']:
275 keyname = verb + '_at'
277 when = datetime.fromtimestamp(item[keyname])
278 prog = '%s %s' % (verb, humanize.naturaltime(now - when))
281 print " %s: %s" % (paddedname, prog)
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()
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"
295 except RuntimeError as e:
296 print >>stderr, str(e)
302 for (name, child) in dmd['children'].items():
303 captype, meta = child
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
313 print " %s (%s): %s, version=%s, created %s" % (name, nice_size, status, version, nice_created)
315 captype, collective = _get_json_for_cap(options, collective_readcap)
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"
326 for (n, d) in dmd[1]['children'].items():
327 if d[0] != 'filenode':
328 print "Error: expected '%s' to be a filenode." % (n,)
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)
339 with open(os.path.join(nodedir, u'private', u'api_auth_token'), 'rb') as f:
341 magicdata = _get_json_for_fragment(
343 'magic_folder?t=json&token=' + token,
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])
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']
359 _print_item_status(item, now, longest)
364 for item in downloads:
365 _print_item_status(item, now, longest)
367 for item in magicdata:
368 if item['status'] == 'failure':
369 print "Failed:", item
374 class MagicFolderCommand(BaseOptions):
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."],
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)
390 Please run e.g. 'tahoe magic-folder create --help' for more details on each
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]
411 ["magic-folder", None, MagicFolderCommand,
412 "Magic Folder subcommands: use 'tahoe magic-folder' for a list."],
416 "magic-folder": do_magic_folder,