src/allmydata/web/directory.py

   1
   2 import simplejson
   3 import urllib
   4
   5 from zope.interface import implements
   6 from twisted.internet import defer
   7 from twisted.internet.interfaces import IPushProducer
   8 from twisted.python.failure import Failure
   9 from twisted.web import http, html
  10 from nevow import url, rend, inevow, tags as T
  11 from nevow.inevow import IRequest
  12
  13 from foolscap.api import fireEventually
  14
  15 from allmydata.util import base32, time_format
  16 from allmydata.uri import from_string_dirnode
  17 from allmydata.interfaces import IDirectoryNode, IFileNode, IMutableFileNode, \
  18      IFilesystemNode, ExistingChildError, NoSuchChildError
  19 from allmydata.monitor import Monitor, OperationCancelledError
  20 from allmydata import dirnode
  21 from allmydata.web.common import text_plain, WebError, \
  22      IOpHandleTable, NeedOperationHandleError, \
  23      boolean_of_arg, get_arg, get_root, parse_replace_arg, \
  24      should_create_intermediate_directories, \
  25      getxmlfile, RenderMixin, humanize_failure, convert_children_json
  26 from allmydata.web.filenode import ReplaceMeMixin, \
  27      FileNodeHandler, PlaceHolderNodeHandler
  28 from allmydata.web.check_results import CheckResults, \
  29      CheckAndRepairResults, DeepCheckResults, DeepCheckAndRepairResults
  30 from allmydata.web.info import MoreInfo
  31 from allmydata.web.operations import ReloadMixin
  32 from allmydata.web.check_results import json_check_results, \
  33      json_check_and_repair_results
  34
  35 class BlockingFileError(Exception):
  36     # TODO: catch and transform
  37     """We cannot auto-create a parent directory, because there is a file in
  38     the way"""
  39
  40 def make_handler_for(node, client, parentnode=None, name=None):
  41     if parentnode:
  42         assert IDirectoryNode.providedBy(parentnode)
  43     if IMutableFileNode.providedBy(node):
  44         return FileNodeHandler(client, node, parentnode, name)
  45     if IFileNode.providedBy(node):
  46         return FileNodeHandler(client, node, parentnode, name)
  47     if IDirectoryNode.providedBy(node):
  48         return DirectoryNodeHandler(client, node, parentnode, name)
  49     return UnknownNodeHandler(client, node, parentnode, name)
  50
  51 class DirectoryNodeHandler(RenderMixin, rend.Page, ReplaceMeMixin):
  52     addSlash = True
  53
  54     def __init__(self, client, node, parentnode=None, name=None):
  55         rend.Page.__init__(self)
  56         self.client = client
  57         assert node
  58         self.node = node
  59         self.parentnode = parentnode
  60         self.name = name
  61
  62     def childFactory(self, ctx, name):
  63         req = IRequest(ctx)
  64         name = name.decode("utf-8")
  65         d = self.node.get(name)
  66         d.addBoth(self.got_child, ctx, name)
  67         # got_child returns a handler resource: FileNodeHandler or
  68         # DirectoryNodeHandler
  69         return d
  70
  71     def got_child(self, node_or_failure, ctx, name):
  72         DEBUG = False
  73         if DEBUG: print "GOT_CHILD", name, node_or_failure
  74         req = IRequest(ctx)
  75         method = req.method
  76         nonterminal = len(req.postpath) > 1
  77         t = get_arg(req, "t", "").strip()
  78         if isinstance(node_or_failure, Failure):
  79             f = node_or_failure
  80             f.trap(NoSuchChildError)
  81             # No child by this name. What should we do about it?
  82             if DEBUG: print "no child", name
  83             if DEBUG: print "postpath", req.postpath
  84             if nonterminal:
  85                 if DEBUG: print " intermediate"
  86                 if should_create_intermediate_directories(req):
  87                     # create intermediate directories
  88                     if DEBUG: print " making intermediate directory"
  89                     d = self.node.create_subdirectory(name)
  90                     d.addCallback(make_handler_for,
  91                                   self.client, self.node, name)
  92                     return d
  93             else:
  94                 if DEBUG: print " terminal"
  95                 # terminal node
  96                 if (method,t) in [ ("POST","mkdir"), ("PUT","mkdir"),
  97                                    ("POST", "mkdir-with-children"),
  98                                    ("POST", "mkdir-immutable") ]:
  99                     if DEBUG: print " making final directory"
 100                     # final directory
 101                     kids = {}
 102                     if t in ("mkdir-with-children", "mkdir-immutable"):
 103                         req.content.seek(0)
 104                         kids_json = req.content.read()
 105                         kids = convert_children_json(self.client.nodemaker,
 106                                                      kids_json)
 107                     mutable = True
 108                     if t == "mkdir-immutable":
 109                         mutable = False
 110                     d = self.node.create_subdirectory(name, kids,
 111                                                       mutable=mutable)
 112                     d.addCallback(make_handler_for,
 113                                   self.client, self.node, name)
 114                     return d
 115                 if (method,t) in ( ("PUT",""), ("PUT","uri"), ):
 116                     if DEBUG: print " PUT, making leaf placeholder"
 117                     # we were trying to find the leaf filenode (to put a new
 118                     # file in its place), and it didn't exist. That's ok,
 119                     # since that's the leaf node that we're about to create.
 120                     # We make a dummy one, which will respond to the PUT
 121                     # request by replacing itself.
 122                     return PlaceHolderNodeHandler(self.client, self.node, name)
 123             if DEBUG: print " 404"
 124             # otherwise, we just return a no-such-child error
 125             return f
 126
 127         node = node_or_failure
 128         if nonterminal and should_create_intermediate_directories(req):
 129             if not IDirectoryNode.providedBy(node):
 130                 # we would have put a new directory here, but there was a
 131                 # file in the way.
 132                 if DEBUG: print "blocking"
 133                 raise WebError("Unable to create directory '%s': "
 134                                "a file was in the way" % name,
 135                                http.CONFLICT)
 136         if DEBUG: print "good child"
 137         return make_handler_for(node, self.client, self.node, name)
 138
 139     def render_DELETE(self, ctx):
 140         assert self.parentnode and self.name
 141         d = self.parentnode.delete(self.name)
 142         d.addCallback(lambda res: self.node.get_uri())
 143         return d
 144
 145     def render_GET(self, ctx):
 146         req = IRequest(ctx)
 147         # This is where all of the directory-related ?t=* code goes.
 148         t = get_arg(req, "t", "").strip()
 149         if not t:
 150             # render the directory as HTML, using the docFactory and Nevow's
 151             # whole templating thing.
 152             return DirectoryAsHTML(self.node)
 153
 154         if t == "json":
 155             return DirectoryJSONMetadata(ctx, self.node)
 156         if t == "info":
 157             return MoreInfo(self.node)
 158         if t == "uri":
 159             return DirectoryURI(ctx, self.node)
 160         if t == "readonly-uri":
 161             return DirectoryReadonlyURI(ctx, self.node)
 162         if t == 'rename-form':
 163             return RenameForm(self.node)
 164
 165         raise WebError("GET directory: bad t=%s" % t)
 166
 167     def render_PUT(self, ctx):
 168         req = IRequest(ctx)
 169         t = get_arg(req, "t", "").strip()
 170         replace = parse_replace_arg(get_arg(req, "replace", "true"))
 171
 172         if t == "mkdir":
 173             # our job was done by the traversal/create-intermediate-directory
 174             # process that got us here.
 175             return text_plain(self.node.get_uri(), ctx) # TODO: urlencode
 176         if t == "uri":
 177             if not replace:
 178                 # they're trying to set_uri and that name is already occupied
 179                 # (by us).
 180                 raise ExistingChildError()
 181             d = self.replace_me_with_a_childcap(req, self.client, replace)
 182             # TODO: results
 183             return d
 184
 185         raise WebError("PUT to a directory")
 186
 187     def render_POST(self, ctx):
 188         req = IRequest(ctx)
 189         t = get_arg(req, "t", "").strip()
 190
 191         if t == "mkdir":
 192             d = self._POST_mkdir(req)
 193         elif t == "mkdir-with-children":
 194             d = self._POST_mkdir_with_children(req)
 195         elif t == "mkdir-immutable":
 196             d = self._POST_mkdir_immutable(req)
 197         elif t == "mkdir-p":
 198             # TODO: docs, tests
 199             d = self._POST_mkdir_p(req)
 200         elif t == "upload":
 201             d = self._POST_upload(ctx) # this one needs the context
 202         elif t == "uri":
 203             d = self._POST_uri(req)
 204         elif t == "delete":
 205             d = self._POST_delete(req)
 206         elif t == "rename":
 207             d = self._POST_rename(req)
 208         elif t == "check":
 209             d = self._POST_check(req)
 210         elif t == "start-deep-check":
 211             d = self._POST_start_deep_check(ctx)
 212         elif t == "stream-deep-check":
 213             d = self._POST_stream_deep_check(ctx)
 214         elif t == "start-manifest":
 215             d = self._POST_start_manifest(ctx)
 216         elif t == "start-deep-size":
 217             d = self._POST_start_deep_size(ctx)
 218         elif t == "start-deep-stats":
 219             d = self._POST_start_deep_stats(ctx)
 220         elif t == "stream-manifest":
 221             d = self._POST_stream_manifest(ctx)
 222         elif t == "set_children":
 223             d = self._POST_set_children(req)
 224         else:
 225             raise WebError("POST to a directory with bad t=%s" % t)
 226
 227         when_done = get_arg(req, "when_done", None)
 228         if when_done:
 229             d.addCallback(lambda res: url.URL.fromString(when_done))
 230         return d
 231
 232     def _POST_mkdir(self, req):
 233         name = get_arg(req, "name", "")
 234         if not name:
 235             # our job is done, it was handled by the code in got_child
 236             # which created the final directory (i.e. us)
 237             return defer.succeed(self.node.get_uri()) # TODO: urlencode
 238         name = name.decode("utf-8")
 239         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 240         kids = {}
 241         d = self.node.create_subdirectory(name, kids, overwrite=replace)
 242         d.addCallback(lambda child: child.get_uri()) # TODO: urlencode
 243         return d
 244
 245     def _POST_mkdir_with_children(self, req):
 246         name = get_arg(req, "name", "")
 247         if not name:
 248             # our job is done, it was handled by the code in got_child
 249             # which created the final directory (i.e. us)
 250             return defer.succeed(self.node.get_uri()) # TODO: urlencode
 251         name = name.decode("utf-8")
 252         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 253         req.content.seek(0)
 254         kids_json = req.content.read()
 255         kids = convert_children_json(self.client.nodemaker, kids_json)
 256         d = self.node.create_subdirectory(name, kids, overwrite=replace)
 257         d.addCallback(lambda child: child.get_uri()) # TODO: urlencode
 258         return d
 259
 260     def _POST_mkdir_immutable(self, req):
 261         name = get_arg(req, "name", "")
 262         if not name:
 263             # our job is done, it was handled by the code in got_child
 264             # which created the final directory (i.e. us)
 265             return defer.succeed(self.node.get_uri()) # TODO: urlencode
 266         name = name.decode("utf-8")
 267         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 268         req.content.seek(0)
 269         kids_json = req.content.read()
 270         kids = convert_children_json(self.client.nodemaker, kids_json)
 271         d = self.node.create_subdirectory(name, kids, mutable=False)
 272         d.addCallback(lambda child: child.get_uri()) # TODO: urlencode
 273         return d
 274
 275     def _POST_mkdir_p(self, req):
 276         path = get_arg(req, "path")
 277         if not path:
 278             raise WebError("mkdir-p requires a path")
 279         path_ = tuple([seg.decode("utf-8") for seg in path.split('/') if seg ])
 280         # TODO: replace
 281         d = self._get_or_create_directories(self.node, path_)
 282         d.addCallback(lambda node: node.get_uri())
 283         return d
 284
 285     def _get_or_create_directories(self, node, path):
 286         if not IDirectoryNode.providedBy(node):
 287             # unfortunately it is too late to provide the name of the
 288             # blocking directory in the error message.
 289             raise BlockingFileError("cannot create directory because there "
 290                                     "is a file in the way")
 291         if not path:
 292             return defer.succeed(node)
 293         d = node.get(path[0])
 294         def _maybe_create(f):
 295             f.trap(NoSuchChildError)
 296             return node.create_subdirectory(path[0])
 297         d.addErrback(_maybe_create)
 298         d.addCallback(self._get_or_create_directories, path[1:])
 299         return d
 300
 301     def _POST_upload(self, ctx):
 302         req = IRequest(ctx)
 303         charset = get_arg(req, "_charset", "utf-8")
 304         contents = req.fields["file"]
 305         assert contents.filename is None or isinstance(contents.filename, str)
 306         name = get_arg(req, "name")
 307         name = name or contents.filename
 308         if name is not None:
 309             name = name.strip()
 310         if not name:
 311             # this prohibts empty, missing, and all-whitespace filenames
 312             raise WebError("upload requires a name")
 313         assert isinstance(name, str)
 314         name = name.decode(charset)
 315         if "/" in name:
 316             raise WebError("name= may not contain a slash", http.BAD_REQUEST)
 317         assert isinstance(name, unicode)
 318
 319         # since POST /uri/path/file?t=upload is equivalent to
 320         # POST /uri/path/dir?t=upload&name=foo, just do the same thing that
 321         # childFactory would do. Things are cleaner if we only do a subset of
 322         # them, though, so we don't do: d = self.childFactory(ctx, name)
 323
 324         d = self.node.get(name)
 325         def _maybe_got_node(node_or_failure):
 326             if isinstance(node_or_failure, Failure):
 327                 f = node_or_failure
 328                 f.trap(NoSuchChildError)
 329                 # create a placeholder which will see POST t=upload
 330                 return PlaceHolderNodeHandler(self.client, self.node, name)
 331             else:
 332                 node = node_or_failure
 333                 return make_handler_for(node, self.client, self.node, name)
 334         d.addBoth(_maybe_got_node)
 335         # now we have a placeholder or a filenodehandler, and we can just
 336         # delegate to it. We could return the resource back out of
 337         # DirectoryNodeHandler.renderHTTP, and nevow would recurse into it,
 338         # but the addCallback() that handles when_done= would break.
 339         d.addCallback(lambda child: child.renderHTTP(ctx))
 340         return d
 341
 342     def _POST_uri(self, req):
 343         childcap = get_arg(req, "uri")
 344         if not childcap:
 345             raise WebError("set-uri requires a uri")
 346         name = get_arg(req, "name")
 347         if not name:
 348             raise WebError("set-uri requires a name")
 349         charset = get_arg(req, "_charset", "utf-8")
 350         name = name.decode(charset)
 351         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 352         d = self.node.set_uri(name, childcap, childcap, overwrite=replace)
 353         d.addCallback(lambda res: childcap)
 354         return d
 355
 356     def _POST_delete(self, req):
 357         name = get_arg(req, "name")
 358         if name is None:
 359             # apparently an <input type="hidden" name="name" value="">
 360             # won't show up in the resulting encoded form.. the 'name'
 361             # field is completely missing. So to allow deletion of an
 362             # empty file, we have to pretend that None means ''. The only
 363             # downide of this is a slightly confusing error message if
 364             # someone does a POST without a name= field. For our own HTML
 365             # thisn't a big deal, because we create the 'delete' POST
 366             # buttons ourselves.
 367             name = ''
 368         charset = get_arg(req, "_charset", "utf-8")
 369         name = name.decode(charset)
 370         d = self.node.delete(name)
 371         d.addCallback(lambda res: "thing deleted")
 372         return d
 373
 374     def _POST_rename(self, req):
 375         charset = get_arg(req, "_charset", "utf-8")
 376         from_name = get_arg(req, "from_name")
 377         if from_name is not None:
 378             from_name = from_name.strip()
 379             from_name = from_name.decode(charset)
 380             assert isinstance(from_name, unicode)
 381         to_name = get_arg(req, "to_name")
 382         if to_name is not None:
 383             to_name = to_name.strip()
 384             to_name = to_name.decode(charset)
 385             assert isinstance(to_name, unicode)
 386         if not from_name or not to_name:
 387             raise WebError("rename requires from_name and to_name")
 388         if from_name == to_name:
 389             return defer.succeed("redundant rename")
 390
 391         # allow from_name to contain slashes, so they can fix names that were
 392         # accidentally created with them. But disallow them in to_name, to
 393         # discourage the practice.
 394         if "/" in to_name:
 395             raise WebError("to_name= may not contain a slash", http.BAD_REQUEST)
 396
 397         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 398         d = self.node.move_child_to(from_name, self.node, to_name, replace)
 399         d.addCallback(lambda res: "thing renamed")
 400         return d
 401
 402     def _POST_check(self, req):
 403         # check this directory
 404         verify = boolean_of_arg(get_arg(req, "verify", "false"))
 405         repair = boolean_of_arg(get_arg(req, "repair", "false"))
 406         add_lease = boolean_of_arg(get_arg(req, "add-lease", "false"))
 407         if repair:
 408             d = self.node.check_and_repair(Monitor(), verify, add_lease)
 409             d.addCallback(lambda res: CheckAndRepairResults(self.client, res))
 410         else:
 411             d = self.node.check(Monitor(), verify, add_lease)
 412             d.addCallback(lambda res: CheckResults(self.client, res))
 413         return d
 414
 415     def _start_operation(self, monitor, renderer, ctx):
 416         table = IOpHandleTable(ctx)
 417         table.add_monitor(ctx, monitor, renderer)
 418         return table.redirect_to(ctx)
 419
 420     def _POST_start_deep_check(self, ctx):
 421         # check this directory and everything reachable from it
 422         if not get_arg(ctx, "ophandle"):
 423             raise NeedOperationHandleError("slow operation requires ophandle=")
 424         verify = boolean_of_arg(get_arg(ctx, "verify", "false"))
 425         repair = boolean_of_arg(get_arg(ctx, "repair", "false"))
 426         add_lease = boolean_of_arg(get_arg(ctx, "add-lease", "false"))
 427         if repair:
 428             monitor = self.node.start_deep_check_and_repair(verify, add_lease)
 429             renderer = DeepCheckAndRepairResults(self.client, monitor)
 430         else:
 431             monitor = self.node.start_deep_check(verify, add_lease)
 432             renderer = DeepCheckResults(self.client, monitor)
 433         return self._start_operation(monitor, renderer, ctx)
 434
 435     def _POST_stream_deep_check(self, ctx):
 436         verify = boolean_of_arg(get_arg(ctx, "verify", "false"))
 437         repair = boolean_of_arg(get_arg(ctx, "repair", "false"))
 438         add_lease = boolean_of_arg(get_arg(ctx, "add-lease", "false"))
 439         walker = DeepCheckStreamer(ctx, self.node, verify, repair, add_lease)
 440         monitor = self.node.deep_traverse(walker)
 441         walker.setMonitor(monitor)
 442         # register to hear stopProducing. The walker ignores pauseProducing.
 443         IRequest(ctx).registerProducer(walker, True)
 444         d = monitor.when_done()
 445         def _done(res):
 446             IRequest(ctx).unregisterProducer()
 447             return res
 448         d.addBoth(_done)
 449         def _cancelled(f):
 450             f.trap(OperationCancelledError)
 451             return "Operation Cancelled"
 452         d.addErrback(_cancelled)
 453         def _error(f):
 454             # signal the error as a non-JSON "ERROR:" line, plus exception
 455             msg = "ERROR: %s(%s)\n" % (f.value.__class__.__name__,
 456                                        ", ".join([str(a) for a in f.value.args]))
 457             msg += str(f)
 458             return msg
 459         d.addErrback(_error)
 460         return d
 461
 462     def _POST_start_manifest(self, ctx):
 463         if not get_arg(ctx, "ophandle"):
 464             raise NeedOperationHandleError("slow operation requires ophandle=")
 465         monitor = self.node.build_manifest()
 466         renderer = ManifestResults(self.client, monitor)
 467         return self._start_operation(monitor, renderer, ctx)
 468
 469     def _POST_start_deep_size(self, ctx):
 470         if not get_arg(ctx, "ophandle"):
 471             raise NeedOperationHandleError("slow operation requires ophandle=")
 472         monitor = self.node.start_deep_stats()
 473         renderer = DeepSizeResults(self.client, monitor)
 474         return self._start_operation(monitor, renderer, ctx)
 475
 476     def _POST_start_deep_stats(self, ctx):
 477         if not get_arg(ctx, "ophandle"):
 478             raise NeedOperationHandleError("slow operation requires ophandle=")
 479         monitor = self.node.start_deep_stats()
 480         renderer = DeepStatsResults(self.client, monitor)
 481         return self._start_operation(monitor, renderer, ctx)
 482
 483     def _POST_stream_manifest(self, ctx):
 484         walker = ManifestStreamer(ctx, self.node)
 485         monitor = self.node.deep_traverse(walker)
 486         walker.setMonitor(monitor)
 487         # register to hear stopProducing. The walker ignores pauseProducing.
 488         IRequest(ctx).registerProducer(walker, True)
 489         d = monitor.when_done()
 490         def _done(res):
 491             IRequest(ctx).unregisterProducer()
 492             return res
 493         d.addBoth(_done)
 494         def _cancelled(f):
 495             f.trap(OperationCancelledError)
 496             return "Operation Cancelled"
 497         d.addErrback(_cancelled)
 498         def _error(f):
 499             # signal the error as a non-JSON "ERROR:" line, plus exception
 500             msg = "ERROR: %s(%s)\n" % (f.value.__class__.__name__,
 501                                        ", ".join([str(a) for a in f.value.args]))
 502             msg += str(f)
 503             return msg
 504         d.addErrback(_error)
 505         return d
 506
 507     def _POST_set_children(self, req):
 508         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 509         req.content.seek(0)
 510         body = req.content.read()
 511         try:
 512             children = simplejson.loads(body)
 513         except ValueError, le:
 514             le.args = tuple(le.args + (body,))
 515             # TODO test handling of bad JSON
 516             raise
 517         cs = {}
 518         for name, (file_or_dir, mddict) in children.iteritems():
 519             name = unicode(name) # simplejson-2.0.1 returns str *or* unicode
 520             writecap = mddict.get('rw_uri')
 521             if writecap is not None:
 522                 writecap = str(writecap)
 523             readcap = mddict.get('ro_uri')
 524             if readcap is not None:
 525                 readcap = str(readcap)
 526             cs[name] = (writecap, readcap, mddict.get('metadata'))
 527         d = self.node.set_children(cs, replace)
 528         d.addCallback(lambda res: "Okay so I did it.")
 529         # TODO: results
 530         return d
 531
 532 def abbreviated_dirnode(dirnode):
 533     u = from_string_dirnode(dirnode.get_uri())
 534     return u.abbrev_si()
 535
 536 class DirectoryAsHTML(rend.Page):
 537     # The remainder of this class is to render the directory into
 538     # human+browser -oriented HTML.
 539     docFactory = getxmlfile("directory.xhtml")
 540     addSlash = True
 541
 542     def __init__(self, node):
 543         rend.Page.__init__(self)
 544         self.node = node
 545
 546     def beforeRender(self, ctx):
 547         # attempt to get the dirnode's children, stashing them (or the
 548         # failure that results) for later use
 549         d = self.node.list()
 550         def _good(children):
 551             # Deferreds don't optimize out tail recursion, and the way
 552             # Nevow's flattener handles Deferreds doesn't take this into
 553             # account. As a result, large lists of Deferreds that fire in the
 554             # same turn (i.e. the output of defer.succeed) will cause a stack
 555             # overflow. To work around this, we insert a turn break after
 556             # every 100 items, using foolscap's fireEventually(). This gives
 557             # the stack a chance to be popped. It would also work to put
 558             # every item in its own turn, but that'd be a lot more
 559             # inefficient. This addresses ticket #237, for which I was never
 560             # able to create a failing unit test.
 561             output = []
 562             for i,item in enumerate(sorted(children.items())):
 563                 if i % 100 == 0:
 564                     output.append(fireEventually(item))
 565                 else:
 566                     output.append(item)
 567             self.dirnode_children = output
 568             return ctx
 569         def _bad(f):
 570             text, code = humanize_failure(f)
 571             self.dirnode_children = None
 572             self.dirnode_children_error = text
 573             return ctx
 574         d.addCallbacks(_good, _bad)
 575         return d
 576
 577     def render_title(self, ctx, data):
 578         si_s = abbreviated_dirnode(self.node)
 579         header = ["Tahoe-LAFS - Directory SI=%s" % si_s]
 580         if self.node.is_readonly():
 581             header.append(" (read-only)")
 582         else:
 583             header.append(" (modifiable)")
 584         return ctx.tag[header]
 585
 586     def render_header(self, ctx, data):
 587         si_s = abbreviated_dirnode(self.node)
 588         header = ["Tahoe-LAFS Directory SI=", T.span(class_="data-chars")[si_s]]
 589         if self.node.is_readonly():
 590             header.append(" (read-only)")
 591         return ctx.tag[header]
 592
 593     def render_welcome(self, ctx, data):
 594         link = get_root(ctx)
 595         return T.div[T.a(href=link)["Return to Welcome page"]]
 596
 597     def render_show_readonly(self, ctx, data):
 598         if self.node.is_readonly():
 599             return ""
 600         rocap = self.node.get_readonly_uri()
 601         root = get_root(ctx)
 602         uri_link = "%s/uri/%s/" % (root, urllib.quote(rocap))
 603         return ctx.tag[T.a(href=uri_link)["Read-Only Version"]]
 604
 605     def render_try_children(self, ctx, data):
 606         # if the dirnode can be retrived, render a table of children.
 607         # Otherwise, render an apologetic error message.
 608         if self.dirnode_children is not None:
 609             return ctx.tag
 610         else:
 611             return T.div[T.p["Error reading directory:"],
 612                          T.p[self.dirnode_children_error]]
 613
 614     def data_children(self, ctx, data):
 615         return self.dirnode_children
 616
 617     def render_row(self, ctx, data):
 618         name, (target, metadata) = data
 619         name = name.encode("utf-8")
 620         assert not isinstance(name, unicode)
 621         nameurl = urllib.quote(name, safe="") # encode any slashes too
 622
 623         root = get_root(ctx)
 624         here = "%s/uri/%s/" % (root, urllib.quote(self.node.get_uri()))
 625         if self.node.is_readonly():
 626             delete = "-"
 627             rename = "-"
 628         else:
 629             # this creates a button which will cause our child__delete method
 630             # to be invoked, which deletes the file and then redirects the
 631             # browser back to this directory
 632             delete = T.form(action=here, method="post")[
 633                 T.input(type='hidden', name='t', value='delete'),
 634                 T.input(type='hidden', name='name', value=name),
 635                 T.input(type='hidden', name='when_done', value="."),
 636                 T.input(type='submit', value='del', name="del"),
 637                 ]
 638
 639             rename = T.form(action=here, method="get")[
 640                 T.input(type='hidden', name='t', value='rename-form'),
 641                 T.input(type='hidden', name='name', value=name),
 642                 T.input(type='hidden', name='when_done', value="."),
 643                 T.input(type='submit', value='rename', name="rename"),
 644                 ]
 645
 646         ctx.fillSlots("delete", delete)
 647         ctx.fillSlots("rename", rename)
 648
 649         times = []
 650         linkcrtime = metadata.get('tahoe', {}).get("linkcrtime")
 651         if linkcrtime is not None:
 652             times.append("lcr: " + time_format.iso_local(linkcrtime))
 653         else:
 654             # For backwards-compatibility with links last modified by Tahoe < 1.4.0:
 655             if "ctime" in metadata:
 656                 ctime = time_format.iso_local(metadata["ctime"])
 657                 times.append("c: " + ctime)
 658         linkmotime = metadata.get('tahoe', {}).get("linkmotime")
 659         if linkmotime is not None:
 660             if times:
 661                 times.append(T.br())
 662             times.append("lmo: " + time_format.iso_local(linkmotime))
 663         else:
 664             # For backwards-compatibility with links last modified by Tahoe < 1.4.0:
 665             if "mtime" in metadata:
 666                 mtime = time_format.iso_local(metadata["mtime"])
 667                 if times:
 668                     times.append(T.br())
 669                 times.append("m: " + mtime)
 670         ctx.fillSlots("times", times)
 671
 672         assert IFilesystemNode.providedBy(target), target
 673         writecap = target.get_uri() or ""
 674         quoted_uri = urllib.quote(writecap, safe="") # escape slashes too
 675
 676         if IMutableFileNode.providedBy(target):
 677             # to prevent javascript in displayed .html files from stealing a
 678             # secret directory URI from the URL, send the browser to a URI-based
 679             # page that doesn't know about the directory at all
 680             dlurl = "%s/file/%s/@@named=/%s" % (root, quoted_uri, nameurl)
 681
 682             ctx.fillSlots("filename",
 683                           T.a(href=dlurl)[html.escape(name)])
 684             ctx.fillSlots("type", "SSK")
 685
 686             ctx.fillSlots("size", "?")
 687
 688             info_link = "%s/uri/%s?t=info" % (root, quoted_uri)
 689
 690         elif IFileNode.providedBy(target):
 691             dlurl = "%s/file/%s/@@named=/%s" % (root, quoted_uri, nameurl)
 692
 693             ctx.fillSlots("filename",
 694                           T.a(href=dlurl)[html.escape(name)])
 695             ctx.fillSlots("type", "FILE")
 696
 697             ctx.fillSlots("size", target.get_size())
 698
 699             info_link = "%s/uri/%s?t=info" % (root, quoted_uri)
 700
 701         elif IDirectoryNode.providedBy(target):
 702             # directory
 703             uri_link = "%s/uri/%s/" % (root, urllib.quote(writecap))
 704             ctx.fillSlots("filename",
 705                           T.a(href=uri_link)[html.escape(name)])
 706             if not target.is_mutable():
 707                 dirtype = "DIR-IMM"
 708             elif target.is_readonly():
 709                 dirtype = "DIR-RO"
 710             else:
 711                 dirtype = "DIR"
 712             ctx.fillSlots("type", dirtype)
 713             ctx.fillSlots("size", "-")
 714             info_link = "%s/uri/%s/?t=info" % (root, quoted_uri)
 715
 716         else:
 717             # unknown
 718             ctx.fillSlots("filename", html.escape(name))
 719             ctx.fillSlots("type", "?")
 720             ctx.fillSlots("size", "-")
 721             # use a directory-relative info link, so we can extract both the
 722             # writecap and the readcap
 723             info_link = "%s?t=info" % urllib.quote(name)
 724
 725         ctx.fillSlots("info", T.a(href=info_link)["More Info"])
 726
 727         return ctx.tag
 728
 729     def render_forms(self, ctx, data):
 730         forms = []
 731
 732         if self.node.is_readonly():
 733             return T.div["No upload forms: directory is read-only"]
 734         if self.dirnode_children is None:
 735             return T.div["No upload forms: directory is unreadable"]
 736
 737         mkdir = T.form(action=".", method="post",
 738                        enctype="multipart/form-data")[
 739             T.fieldset[
 740             T.input(type="hidden", name="t", value="mkdir"),
 741             T.input(type="hidden", name="when_done", value="."),
 742             T.legend(class_="freeform-form-label")["Create a new directory in this directory"],
 743             "New directory name: ",
 744             T.input(type="text", name="name"), " ",
 745             T.input(type="submit", value="Create"),
 746             ]]
 747         forms.append(T.div(class_="freeform-form")[mkdir])
 748
 749         upload = T.form(action=".", method="post",
 750                         enctype="multipart/form-data")[
 751             T.fieldset[
 752             T.input(type="hidden", name="t", value="upload"),
 753             T.input(type="hidden", name="when_done", value="."),
 754             T.legend(class_="freeform-form-label")["Upload a file to this directory"],
 755             "Choose a file to upload: ",
 756             T.input(type="file", name="file", class_="freeform-input-file"),
 757             " ",
 758             T.input(type="submit", value="Upload"),
 759             " Mutable?:",
 760             T.input(type="checkbox", name="mutable"),
 761             ]]
 762         forms.append(T.div(class_="freeform-form")[upload])
 763
 764         mount = T.form(action=".", method="post",
 765                         enctype="multipart/form-data")[
 766             T.fieldset[
 767             T.input(type="hidden", name="t", value="uri"),
 768             T.input(type="hidden", name="when_done", value="."),
 769             T.legend(class_="freeform-form-label")["Add a link to a file or directory which is already in Tahoe-LAFS."],
 770             "New child name: ",
 771             T.input(type="text", name="name"), " ",
 772             "URI of new child: ",
 773             T.input(type="text", name="uri"), " ",
 774             T.input(type="submit", value="Attach"),
 775             ]]
 776         forms.append(T.div(class_="freeform-form")[mount])
 777         return forms
 778
 779     def render_results(self, ctx, data):
 780         req = IRequest(ctx)
 781         return get_arg(req, "results", "")
 782
 783
 784 def DirectoryJSONMetadata(ctx, dirnode):
 785     d = dirnode.list()
 786     def _got(children):
 787         kids = {}
 788         for name, (childnode, metadata) in children.iteritems():
 789             assert IFilesystemNode.providedBy(childnode), childnode
 790             rw_uri = childnode.get_uri()
 791             ro_uri = childnode.get_readonly_uri()
 792             if (IDirectoryNode.providedBy(childnode)
 793                 or IFileNode.providedBy(childnode)):
 794                 if childnode.is_readonly():
 795                     rw_uri = None
 796             if IFileNode.providedBy(childnode):
 797                 kiddata = ("filenode", {'size': childnode.get_size(),
 798                                         'mutable': childnode.is_mutable(),
 799                                         })
 800             elif IDirectoryNode.providedBy(childnode):
 801                 kiddata = ("dirnode", {'mutable': childnode.is_mutable(),
 802                                        })
 803             else:
 804                 kiddata = ("unknown", {})
 805             kiddata[1]["metadata"] = metadata
 806             if ro_uri:
 807                 kiddata[1]["ro_uri"] = ro_uri
 808             if rw_uri:
 809                 kiddata[1]["rw_uri"] = rw_uri
 810             verifycap = childnode.get_verify_cap()
 811             if verifycap:
 812                 kiddata[1]['verify_uri'] = verifycap.to_string()
 813             kids[name] = kiddata
 814         if dirnode.is_readonly():
 815             drw_uri = None
 816             dro_uri = dirnode.get_uri()
 817         else:
 818             drw_uri = dirnode.get_uri()
 819             dro_uri = dirnode.get_readonly_uri()
 820         contents = { 'children': kids }
 821         if dro_uri:
 822             contents['ro_uri'] = dro_uri
 823         if drw_uri:
 824             contents['rw_uri'] = drw_uri
 825         verifycap = dirnode.get_verify_cap()
 826         if verifycap:
 827             contents['verify_uri'] = verifycap.to_string()
 828         contents['mutable'] = dirnode.is_mutable()
 829         data = ("dirnode", contents)
 830         return simplejson.dumps(data, indent=1) + "\n"
 831     d.addCallback(_got)
 832     d.addCallback(text_plain, ctx)
 833     return d
 834
 835
 836
 837 def DirectoryURI(ctx, dirnode):
 838     return text_plain(dirnode.get_uri(), ctx)
 839
 840 def DirectoryReadonlyURI(ctx, dirnode):
 841     return text_plain(dirnode.get_readonly_uri(), ctx)
 842
 843 class RenameForm(rend.Page):
 844     addSlash = True
 845     docFactory = getxmlfile("rename-form.xhtml")
 846
 847     def render_title(self, ctx, data):
 848         return ctx.tag["Directory SI=%s" % abbreviated_dirnode(self.original)]
 849
 850     def render_header(self, ctx, data):
 851         header = ["Rename "
 852                   "in directory SI=%s" % abbreviated_dirnode(self.original),
 853                   ]
 854
 855         if self.original.is_readonly():
 856             header.append(" (readonly!)")
 857         header.append(":")
 858         return ctx.tag[header]
 859
 860     def render_when_done(self, ctx, data):
 861         return T.input(type="hidden", name="when_done", value=".")
 862
 863     def render_get_name(self, ctx, data):
 864         req = IRequest(ctx)
 865         name = get_arg(req, "name", "")
 866         ctx.tag.attributes['value'] = name
 867         return ctx.tag
 868
 869
 870 class ManifestResults(rend.Page, ReloadMixin):
 871     docFactory = getxmlfile("manifest.xhtml")
 872
 873     def __init__(self, client, monitor):
 874         self.client = client
 875         self.monitor = monitor
 876
 877     def renderHTTP(self, ctx):
 878         req = inevow.IRequest(ctx)
 879         output = get_arg(req, "output", "html").lower()
 880         if output == "text":
 881             return self.text(req)
 882         if output == "json":
 883             return self.json(req)
 884         return rend.Page.renderHTTP(self, ctx)
 885
 886     def slashify_path(self, path):
 887         if not path:
 888             return ""
 889         return "/".join([p.encode("utf-8") for p in path])
 890
 891     def text(self, req):
 892         req.setHeader("content-type", "text/plain")
 893         lines = []
 894         is_finished = self.monitor.is_finished()
 895         lines.append("finished: " + {True: "yes", False: "no"}[is_finished])
 896         for (path, cap) in self.monitor.get_status()["manifest"]:
 897             lines.append(self.slashify_path(path) + " " + cap)
 898         return "\n".join(lines) + "\n"
 899
 900     def json(self, req):
 901         req.setHeader("content-type", "text/plain")
 902         m = self.monitor
 903         s = m.get_status()
 904
 905         status = { "stats": s["stats"],
 906                    "finished": m.is_finished(),
 907                    "origin": base32.b2a(m.origin_si),
 908                    }
 909         if m.is_finished():
 910             # don't return manifest/verifycaps/SIs unless the operation is
 911             # done, to save on CPU/memory (both here and in the HTTP client
 912             # who has to unpack the JSON). Tests show that the ManifestWalker
 913             # needs about 1092 bytes per item, the JSON we generate here
 914             # requires about 503 bytes per item, and some internal overhead
 915             # (perhaps transport-layer buffers in twisted.web?) requires an
 916             # additional 1047 bytes per item.
 917             status.update({ "manifest": s["manifest"],
 918                             "verifycaps": [i for i in s["verifycaps"]],
 919                             "storage-index": [i for i in s["storage-index"]],
 920                             })
 921             # simplejson doesn't know how to serialize a set. We use a
 922             # generator that walks the set rather than list(setofthing) to
 923             # save a small amount of memory (4B*len) and a moderate amount of
 924             # CPU.
 925         return simplejson.dumps(status, indent=1)
 926
 927     def _si_abbrev(self):
 928         return base32.b2a(self.monitor.origin_si)[:6]
 929
 930     def render_title(self, ctx):
 931         return T.title["Manifest of SI=%s" % self._si_abbrev()]
 932
 933     def render_header(self, ctx):
 934         return T.p["Manifest of SI=%s" % self._si_abbrev()]
 935
 936     def data_items(self, ctx, data):
 937         return self.monitor.get_status()["manifest"]
 938
 939     def render_row(self, ctx, (path, cap)):
 940         ctx.fillSlots("path", self.slashify_path(path))
 941         root = get_root(ctx)
 942         # TODO: we need a clean consistent way to get the type of a cap string
 943         if cap:
 944             if cap.startswith("URI:CHK") or cap.startswith("URI:SSK"):
 945                 nameurl = urllib.quote(path[-1].encode("utf-8"))
 946                 uri_link = "%s/file/%s/@@named=/%s" % (root, urllib.quote(cap),
 947                                                        nameurl)
 948             else:
 949                 uri_link = "%s/uri/%s" % (root, urllib.quote(cap, safe=""))
 950             ctx.fillSlots("cap", T.a(href=uri_link)[cap])
 951         else:
 952             ctx.fillSlots("cap", "")
 953         return ctx.tag
 954
 955 class DeepSizeResults(rend.Page):
 956     def __init__(self, client, monitor):
 957         self.client = client
 958         self.monitor = monitor
 959
 960     def renderHTTP(self, ctx):
 961         req = inevow.IRequest(ctx)
 962         output = get_arg(req, "output", "html").lower()
 963         req.setHeader("content-type", "text/plain")
 964         if output == "json":
 965             return self.json(req)
 966         # plain text
 967         is_finished = self.monitor.is_finished()
 968         output = "finished: " + {True: "yes", False: "no"}[is_finished] + "\n"
 969         if is_finished:
 970             stats = self.monitor.get_status()
 971             total = (stats.get("size-immutable-files", 0)
 972                      + stats.get("size-mutable-files", 0)
 973                      + stats.get("size-directories", 0))
 974             output += "size: %d\n" % total
 975         return output
 976
 977     def json(self, req):
 978         status = {"finished": self.monitor.is_finished(),
 979                   "size": self.monitor.get_status(),
 980                   }
 981         return simplejson.dumps(status)
 982
 983 class DeepStatsResults(rend.Page):
 984     def __init__(self, client, monitor):
 985         self.client = client
 986         self.monitor = monitor
 987
 988     def renderHTTP(self, ctx):
 989         # JSON only
 990         inevow.IRequest(ctx).setHeader("content-type", "text/plain")
 991         s = self.monitor.get_status().copy()
 992         s["finished"] = self.monitor.is_finished()
 993         return simplejson.dumps(s, indent=1)
 994
 995 class ManifestStreamer(dirnode.DeepStats):
 996     implements(IPushProducer)
 997
 998     def __init__(self, ctx, origin):
 999         dirnode.DeepStats.__init__(self, origin)
1000         self.req = IRequest(ctx)
1001
1002     def setMonitor(self, monitor):
1003         self.monitor = monitor
1004     def pauseProducing(self):
1005         pass
1006     def resumeProducing(self):
1007         pass
1008     def stopProducing(self):
1009         self.monitor.cancel()
1010
1011     def add_node(self, node, path):
1012         dirnode.DeepStats.add_node(self, node, path)
1013         d = {"path": path,
1014              "cap": node.get_uri()}
1015
1016         if IDirectoryNode.providedBy(node):
1017             d["type"] = "directory"
1018         elif IFileNode.providedBy(node):
1019             d["type"] = "file"
1020         else:
1021             d["type"] = "unknown"
1022
1023         v = node.get_verify_cap()
1024         if v:
1025             v = v.to_string()
1026         d["verifycap"] = v
1027
1028         r = node.get_repair_cap()
1029         if r:
1030             r = r.to_string()
1031         d["repaircap"] = r
1032
1033         si = node.get_storage_index()
1034         if si:
1035             si = base32.b2a(si)
1036         d["storage-index"] = si
1037
1038         j = simplejson.dumps(d, ensure_ascii=True)
1039         assert "\n" not in j
1040         self.req.write(j+"\n")
1041
1042     def finish(self):
1043         stats = dirnode.DeepStats.get_results(self)
1044         d = {"type": "stats",
1045              "stats": stats,
1046              }
1047         j = simplejson.dumps(d, ensure_ascii=True)
1048         assert "\n" not in j
1049         self.req.write(j+"\n")
1050         return ""
1051
1052 class DeepCheckStreamer(dirnode.DeepStats):
1053     implements(IPushProducer)
1054
1055     def __init__(self, ctx, origin, verify, repair, add_lease):
1056         dirnode.DeepStats.__init__(self, origin)
1057         self.req = IRequest(ctx)
1058         self.verify = verify
1059         self.repair = repair
1060         self.add_lease = add_lease
1061
1062     def setMonitor(self, monitor):
1063         self.monitor = monitor
1064     def pauseProducing(self):
1065         pass
1066     def resumeProducing(self):
1067         pass
1068     def stopProducing(self):
1069         self.monitor.cancel()
1070
1071     def add_node(self, node, path):
1072         dirnode.DeepStats.add_node(self, node, path)
1073         data = {"path": path,
1074                 "cap": node.get_uri()}
1075
1076         if IDirectoryNode.providedBy(node):
1077             data["type"] = "directory"
1078         else:
1079             data["type"] = "file"
1080
1081         v = node.get_verify_cap()
1082         if v:
1083             v = v.to_string()
1084         data["verifycap"] = v
1085
1086         r = node.get_repair_cap()
1087         if r:
1088             r = r.to_string()
1089         data["repaircap"] = r
1090
1091         si = node.get_storage_index()
1092         if si:
1093             si = base32.b2a(si)
1094         data["storage-index"] = si
1095
1096         if self.repair:
1097             d = node.check_and_repair(self.monitor, self.verify, self.add_lease)
1098             d.addCallback(self.add_check_and_repair, data)
1099         else:
1100             d = node.check(self.monitor, self.verify, self.add_lease)
1101             d.addCallback(self.add_check, data)
1102         d.addCallback(self.write_line)
1103         return d
1104
1105     def add_check_and_repair(self, crr, data):
1106         data["check-and-repair-results"] = json_check_and_repair_results(crr)
1107         return data
1108
1109     def add_check(self, cr, data):
1110         data["check-results"] = json_check_results(cr)
1111         return data
1112
1113     def write_line(self, data):
1114         j = simplejson.dumps(data, ensure_ascii=True)
1115         assert "\n" not in j
1116         self.req.write(j+"\n")
1117
1118     def finish(self):
1119         stats = dirnode.DeepStats.get_results(self)
1120         d = {"type": "stats",
1121              "stats": stats,
1122              }
1123         j = simplejson.dumps(d, ensure_ascii=True)
1124         assert "\n" not in j
1125         self.req.write(j+"\n")
1126         return ""
1127
1128 class UnknownNodeHandler(RenderMixin, rend.Page):
1129
1130     def __init__(self, client, node, parentnode=None, name=None):
1131         rend.Page.__init__(self)
1132         assert node
1133         self.node = node
1134
1135     def render_GET(self, ctx):
1136         req = IRequest(ctx)
1137         t = get_arg(req, "t", "").strip()
1138         if t == "info":
1139             return MoreInfo(self.node)
1140         raise WebError("GET unknown URI type: can only do t=info, not t=%s" % t)
1141
1142