src/allmydata/web/directory.py

   1
   2 import simplejson
   3 import urllib
   4 import time
   5
   6 from twisted.internet import defer
   7 from twisted.python.failure import Failure
   8 from twisted.web import http, html
   9 from nevow import url, rend, tags as T
  10 from nevow.inevow import IRequest
  11
  12 from foolscap.eventual import fireEventually
  13
  14 from allmydata.util import log, base32
  15 from allmydata.uri import from_string_verifier, from_string_dirnode, \
  16      CHKFileVerifierURI
  17 from allmydata.interfaces import IDirectoryNode, IFileNode, IMutableFileNode, \
  18      ExistingChildError
  19 from allmydata.web.common import text_plain, WebError, IClient, \
  20      boolean_of_arg, get_arg, should_create_intermediate_directories, \
  21      getxmlfile, RenderMixin
  22 from allmydata.web.filenode import ReplaceMeMixin, \
  23      FileNodeHandler, PlaceHolderNodeHandler
  24
  25 class BlockingFileError(Exception):
  26     # TODO: catch and transform
  27     """We cannot auto-create a parent directory, because there is a file in
  28     the way"""
  29
  30 def make_handler_for(node, parentnode=None, name=None):
  31     if parentnode:
  32         assert IDirectoryNode.providedBy(parentnode)
  33     if IFileNode.providedBy(node):
  34         return FileNodeHandler(node, parentnode, name)
  35     if IMutableFileNode.providedBy(node):
  36         return FileNodeHandler(node, parentnode, name)
  37     if IDirectoryNode.providedBy(node):
  38         return DirectoryNodeHandler(node, parentnode, name)
  39     raise WebError("Cannot provide handler for '%s'" % node)
  40
  41 class DirectoryNodeHandler(RenderMixin, rend.Page, ReplaceMeMixin):
  42     addSlash = True
  43
  44     def __init__(self, node, parentnode=None, name=None):
  45         rend.Page.__init__(self)
  46         assert node
  47         self.node = node
  48         self.parentnode = parentnode
  49         self.name = name
  50
  51     def childFactory(self, ctx, name):
  52         req = IRequest(ctx)
  53         name = name.decode("utf-8")
  54         d = self.node.get(name)
  55         d.addBoth(self.got_child, ctx, name)
  56         # got_child returns a handler resource: FileNodeHandler or
  57         # DirectoryNodeHandler
  58         return d
  59
  60     def got_child(self, node_or_failure, ctx, name):
  61         DEBUG = False
  62         if DEBUG: print "GOT_CHILD", name, node_or_failure
  63         req = IRequest(ctx)
  64         method = req.method
  65         nonterminal = len(req.postpath) > 1
  66         t = get_arg(req, "t", "").strip()
  67         if isinstance(node_or_failure, Failure):
  68             f = node_or_failure
  69             f.trap(KeyError)
  70             # No child by this name. What should we do about it?
  71             if DEBUG: print "no child", name
  72             if DEBUG: print "postpath", req.postpath
  73             if nonterminal:
  74                 if DEBUG: print " intermediate"
  75                 if should_create_intermediate_directories(req):
  76                     # create intermediate directories
  77                     if DEBUG: print " making intermediate directory"
  78                     d = self.node.create_empty_directory(name)
  79                     d.addCallback(make_handler_for, self.node, name)
  80                     return d
  81             else:
  82                 if DEBUG: print " terminal"
  83                 # terminal node
  84                 if (method,t) in [ ("POST","mkdir"), ("PUT","mkdir") ]:
  85                     if DEBUG: print " making final directory"
  86                     # final directory
  87                     d = self.node.create_empty_directory(name)
  88                     d.addCallback(make_handler_for, self.node, name)
  89                     return d
  90                 if (method,t) in ( ("PUT",""), ("PUT","uri"), ):
  91                     if DEBUG: print " PUT, making leaf placeholder"
  92                     # we were trying to find the leaf filenode (to put a new
  93                     # file in its place), and it didn't exist. That's ok,
  94                     # since that's the leaf node that we're about to create.
  95                     # We make a dummy one, which will respond to the PUT
  96                     # request by replacing itself.
  97                     return PlaceHolderNodeHandler(self.node, name)
  98             if DEBUG: print " 404"
  99             # otherwise, we just return a no-such-child error
 100             return rend.FourOhFour()
 101
 102         node = node_or_failure
 103         if nonterminal and should_create_intermediate_directories(req):
 104             if not IDirectoryNode.providedBy(node):
 105                 # we would have put a new directory here, but there was a
 106                 # file in the way.
 107                 if DEBUG: print "blocking"
 108                 raise WebError("Unable to create directory '%s': "
 109                                "a file was in the way" % name,
 110                                http.CONFLICT)
 111         if DEBUG: print "good child"
 112         return make_handler_for(node, self.node, name)
 113
 114     def render_DELETE(self, ctx):
 115         assert self.parentnode and self.name
 116         d = self.parentnode.delete(self.name)
 117         d.addCallback(lambda res: self.node.get_uri())
 118         return d
 119
 120     def render_GET(self, ctx):
 121         client = IClient(ctx)
 122         req = IRequest(ctx)
 123         # This is where all of the directory-related ?t=* code goes.
 124         t = get_arg(req, "t", "").strip()
 125         if not t:
 126             # render the directory as HTML, using the docFactory and Nevow's
 127             # whole templating thing.
 128             return DirectoryAsHTML(self.node)
 129
 130         if t == "json":
 131             return DirectoryJSONMetadata(ctx, self.node)
 132         if t == "uri":
 133             return DirectoryURI(ctx, self.node)
 134         if t == "readonly-uri":
 135             return DirectoryReadonlyURI(ctx, self.node)
 136         if t == "manifest":
 137             return Manifest(self.node)
 138         if t == "deep-size":
 139             return DeepSize(ctx, self.node)
 140         if t == "deep-stats":
 141             return DeepStats(ctx, self.node)
 142         if t == 'rename-form':
 143             return RenameForm(self.node)
 144
 145         raise WebError("GET directory: bad t=%s" % t)
 146
 147     def render_PUT(self, ctx):
 148         req = IRequest(ctx)
 149         t = get_arg(req, "t", "").strip()
 150         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 151         if t == "mkdir":
 152             # our job was done by the traversal/create-intermediate-directory
 153             # process that got us here.
 154             return text_plain(self.node.get_uri(), ctx) # TODO: urlencode
 155         if t == "uri":
 156             if not replace:
 157                 # they're trying to set_uri and that name is already occupied
 158                 # (by us).
 159                 raise ExistingChildError()
 160             d = self.parentnode.replace_me_with_a_childcap(ctx, replace)
 161             # TODO: results
 162             return d
 163
 164         raise WebError("PUT to a directory")
 165
 166     def render_POST(self, ctx):
 167         req = IRequest(ctx)
 168         t = get_arg(req, "t", "").strip()
 169         if t == "mkdir":
 170             d = self._POST_mkdir(req)
 171         elif t == "mkdir-p":
 172             # TODO: docs, tests
 173             d = self._POST_mkdir_p(req)
 174         elif t == "upload":
 175             d = self._POST_upload(ctx) # this one needs the context
 176         elif t == "uri":
 177             d = self._POST_uri(req)
 178         elif t == "delete":
 179             d = self._POST_delete(req)
 180         elif t == "rename":
 181             d = self._POST_rename(req)
 182         elif t == "check":
 183             d = self._POST_check(req)
 184         elif t == "set_children":
 185             # TODO: docs
 186             d = self._POST_set_children(req)
 187         else:
 188             raise WebError("POST to a directory with bad t=%s" % t)
 189
 190         when_done = get_arg(req, "when_done", None)
 191         if when_done:
 192             d.addCallback(lambda res: url.URL.fromString(when_done))
 193         return d
 194
 195     def _POST_mkdir(self, req):
 196         name = get_arg(req, "name", "")
 197         if not name:
 198             # our job is done, it was handled by the code in got_child
 199             # which created the final directory (i.e. us)
 200             return defer.succeed(self.node.get_uri()) # TODO: urlencode
 201         name = name.decode("utf-8")
 202         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 203         d = self.node.create_empty_directory(name, overwrite=replace)
 204         d.addCallback(lambda child: child.get_uri()) # TODO: urlencode
 205         return d
 206
 207     def _POST_mkdir_p(self, req):
 208         path = get_arg(req, "path")
 209         if not path:
 210             raise WebError("mkdir-p requires a path")
 211         path_ = tuple([seg.decode("utf-8") for seg in path.split('/') if seg ])
 212         # TODO: replace
 213         d = self._get_or_create_directories(self.node, path_)
 214         d.addCallback(lambda node: node.get_uri())
 215         return d
 216
 217     def _get_or_create_directories(self, node, path):
 218         if not IDirectoryNode.providedBy(node):
 219             # unfortunately it is too late to provide the name of the
 220             # blocking directory in the error message.
 221             raise BlockingFileError("cannot create directory because there "
 222                                     "is a file in the way")
 223         if not path:
 224             return defer.succeed(node)
 225         d = node.get(path[0])
 226         def _maybe_create(f):
 227             f.trap(KeyError)
 228             return node.create_empty_directory(path[0])
 229         d.addErrback(_maybe_create)
 230         d.addCallback(self._get_or_create_directories, path[1:])
 231         return d
 232
 233     def _POST_upload(self, ctx):
 234         req = IRequest(ctx)
 235         charset = get_arg(req, "_charset", "utf-8")
 236         contents = req.fields["file"]
 237         assert contents.filename is None or isinstance(contents.filename, str)
 238         name = get_arg(req, "name")
 239         name = name or contents.filename
 240         if name is not None:
 241             name = name.strip()
 242         if not name:
 243             # this prohibts empty, missing, and all-whitespace filenames
 244             raise WebError("upload requires a name")
 245         assert isinstance(name, str)
 246         name = name.decode(charset)
 247         if "/" in name:
 248             raise WebError("name= may not contain a slash", http.BAD_REQUEST)
 249         assert isinstance(name, unicode)
 250
 251         # since POST /uri/path/file?t=upload is equivalent to
 252         # POST /uri/path/dir?t=upload&name=foo, just do the same thing that
 253         # childFactory would do. Things are cleaner if we only do a subset of
 254         # them, though, so we don't do: d = self.childFactory(ctx, name)
 255
 256         d = self.node.get(name)
 257         def _maybe_got_node(node_or_failure):
 258             if isinstance(node_or_failure, Failure):
 259                 f = node_or_failure
 260                 f.trap(KeyError)
 261                 # create a placeholder which will see POST t=upload
 262                 return PlaceHolderNodeHandler(self.node, name)
 263             else:
 264                 node = node_or_failure
 265                 return make_handler_for(node, self.node, name)
 266         d.addBoth(_maybe_got_node)
 267         # now we have a placeholder or a filenodehandler, and we can just
 268         # delegate to it. We could return the resource back out of
 269         # DirectoryNodeHandler.renderHTTP, and nevow would recurse into it,
 270         # but the addCallback() that handles when_done= would break.
 271         d.addCallback(lambda child: child.renderHTTP(ctx))
 272         return d
 273
 274     def _POST_uri(self, req):
 275         childcap = get_arg(req, "uri")
 276         if not childcap:
 277             raise WebError("set-uri requires a uri")
 278         name = get_arg(req, "name")
 279         if not name:
 280             raise WebError("set-uri requires a name")
 281         charset = get_arg(req, "_charset", "utf-8")
 282         name = name.decode(charset)
 283         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 284         d = self.node.set_uri(name, childcap, overwrite=replace)
 285         d.addCallback(lambda res: childcap)
 286         return d
 287
 288     def _POST_delete(self, req):
 289         name = get_arg(req, "name")
 290         if name is None:
 291             # apparently an <input type="hidden" name="name" value="">
 292             # won't show up in the resulting encoded form.. the 'name'
 293             # field is completely missing. So to allow deletion of an
 294             # empty file, we have to pretend that None means ''. The only
 295             # downide of this is a slightly confusing error message if
 296             # someone does a POST without a name= field. For our own HTML
 297             # thisn't a big deal, because we create the 'delete' POST
 298             # buttons ourselves.
 299             name = ''
 300         charset = get_arg(req, "_charset", "utf-8")
 301         name = name.decode(charset)
 302         d = self.node.delete(name)
 303         d.addCallback(lambda res: "thing deleted")
 304         return d
 305
 306     def _POST_rename(self, req):
 307         charset = get_arg(req, "_charset", "utf-8")
 308         from_name = get_arg(req, "from_name")
 309         if from_name is not None:
 310             from_name = from_name.strip()
 311             from_name = from_name.decode(charset)
 312             assert isinstance(from_name, unicode)
 313         to_name = get_arg(req, "to_name")
 314         if to_name is not None:
 315             to_name = to_name.strip()
 316             to_name = to_name.decode(charset)
 317             assert isinstance(to_name, unicode)
 318         if not from_name or not to_name:
 319             raise WebError("rename requires from_name and to_name")
 320         for k,v in [ ('from_name', from_name), ('to_name', to_name) ]:
 321             if v and "/" in v:
 322                 raise WebError("%s= may not contain a slash" % k,
 323                                http.BAD_REQUEST)
 324
 325         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 326         d = self.node.move_child_to(from_name, self.node, to_name, replace)
 327         d.addCallback(lambda res: "thing renamed")
 328         return d
 329
 330     def _POST_check(self, req):
 331         # check this directory
 332         d = self.node.check()
 333         def _done(res):
 334             log.msg("checked %s, results %s" % (self.node, res),
 335                     facility="tahoe.webish", level=log.NOISY)
 336             return str(res)
 337         d.addCallback(_done)
 338         # TODO: results
 339         return d
 340
 341     def _POST_set_children(self, req):
 342         replace = boolean_of_arg(get_arg(req, "replace", "true"))
 343         req.content.seek(0)
 344         body = req.content.read()
 345         try:
 346             children = simplejson.loads(body)
 347         except ValueError, le:
 348             le.args = tuple(le.args + (body,))
 349             # TODO test handling of bad JSON
 350             raise
 351         cs = []
 352         for name, (file_or_dir, mddict) in children.iteritems():
 353             cap = str(mddict.get('rw_uri') or mddict.get('ro_uri'))
 354             cs.append((name, cap, mddict.get('metadata')))
 355         d = self.node.set_children(cs, replace)
 356         d.addCallback(lambda res: "Okay so I did it.")
 357         # TODO: results
 358         return d
 359
 360 def abbreviated_dirnode(dirnode):
 361     u = from_string_dirnode(dirnode.get_uri())
 362     si = u.get_filenode_uri().storage_index
 363     si_s = base32.b2a(si)
 364     return si_s[:6]
 365
 366 class DirectoryAsHTML(rend.Page):
 367     # The remainder of this class is to render the directory into
 368     # human+browser -oriented HTML.
 369     docFactory = getxmlfile("directory.xhtml")
 370     addSlash = True
 371
 372     def __init__(self, node):
 373         rend.Page.__init__(self)
 374         self.node = node
 375
 376     def render_title(self, ctx, data):
 377         si_s = abbreviated_dirnode(self.node)
 378         header = ["Directory SI=%s" % si_s]
 379         return ctx.tag[header]
 380
 381     def render_header(self, ctx, data):
 382         si_s = abbreviated_dirnode(self.node)
 383         header = ["Directory SI=%s" % si_s]
 384         if self.node.is_readonly():
 385             header.append(" (readonly)")
 386         return ctx.tag[header]
 387
 388     def render_welcome(self, ctx, data):
 389         depth = len(IRequest(ctx).path) + 2
 390         link = "/".join([".."] * depth)
 391         return T.div[T.a(href=link)["Return to Welcome page"]]
 392
 393     def data_children(self, ctx, data):
 394         d = self.node.list()
 395         d.addCallback(lambda dict: sorted(dict.items()))
 396         def _stall_some(items):
 397             # Deferreds don't optimize out tail recursion, and the way
 398             # Nevow's flattener handles Deferreds doesn't take this into
 399             # account. As a result, large lists of Deferreds that fire in the
 400             # same turn (i.e. the output of defer.succeed) will cause a stack
 401             # overflow. To work around this, we insert a turn break after
 402             # every 100 items, using foolscap's fireEventually(). This gives
 403             # the stack a chance to be popped. It would also work to put
 404             # every item in its own turn, but that'd be a lot more
 405             # inefficient. This addresses ticket #237, for which I was never
 406             # able to create a failing unit test.
 407             output = []
 408             for i,item in enumerate(items):
 409                 if i % 100 == 0:
 410                     output.append(fireEventually(item))
 411                 else:
 412                     output.append(item)
 413             return output
 414         d.addCallback(_stall_some)
 415         return d
 416
 417     def render_row(self, ctx, data):
 418         name, (target, metadata) = data
 419         name = name.encode("utf-8")
 420         assert not isinstance(name, unicode)
 421
 422         if self.node.is_readonly():
 423             delete = "-"
 424             rename = "-"
 425         else:
 426             # this creates a button which will cause our child__delete method
 427             # to be invoked, which deletes the file and then redirects the
 428             # browser back to this directory
 429             delete = T.form(action=url.here, method="post")[
 430                 T.input(type='hidden', name='t', value='delete'),
 431                 T.input(type='hidden', name='name', value=name),
 432                 T.input(type='hidden', name='when_done', value=url.here),
 433                 T.input(type='submit', value='del', name="del"),
 434                 ]
 435
 436             rename = T.form(action=url.here, method="get")[
 437                 T.input(type='hidden', name='t', value='rename-form'),
 438                 T.input(type='hidden', name='name', value=name),
 439                 T.input(type='hidden', name='when_done', value=url.here),
 440                 T.input(type='submit', value='rename', name="rename"),
 441                 ]
 442
 443         ctx.fillSlots("delete", delete)
 444         ctx.fillSlots("rename", rename)
 445         check = T.form(action=url.here.child(name), method="post")[
 446             T.input(type='hidden', name='t', value='check'),
 447             T.input(type='hidden', name='when_done', value=url.here),
 448             T.input(type='submit', value='check', name="check"),
 449             ]
 450         ctx.fillSlots("overwrite",
 451                       self.build_overwrite_form(ctx, name, target))
 452         ctx.fillSlots("check", check)
 453
 454         times = []
 455         TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
 456         if "ctime" in metadata:
 457             ctime = time.strftime(TIME_FORMAT,
 458                                   time.localtime(metadata["ctime"]))
 459             times.append("c: " + ctime)
 460         if "mtime" in metadata:
 461             mtime = time.strftime(TIME_FORMAT,
 462                                   time.localtime(metadata["mtime"]))
 463             if times:
 464                 times.append(T.br())
 465                 times.append("m: " + mtime)
 466         ctx.fillSlots("times", times)
 467
 468         assert (IFileNode.providedBy(target)
 469                 or IDirectoryNode.providedBy(target)
 470                 or IMutableFileNode.providedBy(target)), target
 471
 472         quoted_uri = urllib.quote(target.get_uri())
 473
 474         if IMutableFileNode.providedBy(target):
 475             # to prevent javascript in displayed .html files from stealing a
 476             # secret directory URI from the URL, send the browser to a URI-based
 477             # page that doesn't know about the directory at all
 478             dlurl = "/file/%s/@@named=/%s" % (quoted_uri, urllib.quote(name))
 479
 480             ctx.fillSlots("filename",
 481                           T.a(href=dlurl)[html.escape(name)])
 482             ctx.fillSlots("type", "SSK")
 483
 484             ctx.fillSlots("size", "?")
 485
 486             text_plain_url = "/file/%s/@@named=/foo.txt" % quoted_uri
 487             text_plain_tag = T.a(href=text_plain_url)["text/plain"]
 488
 489         elif IFileNode.providedBy(target):
 490             dlurl = "/file/%s/@@named=/%s" % (quoted_uri, urllib.quote(name))
 491
 492             ctx.fillSlots("filename",
 493                           T.a(href=dlurl)[html.escape(name)])
 494             ctx.fillSlots("type", "FILE")
 495
 496             ctx.fillSlots("size", target.get_size())
 497
 498             text_plain_url = "/file/%s/@@named=/foo.txt" % quoted_uri
 499             text_plain_tag = T.a(href=text_plain_url)["text/plain"]
 500
 501
 502         elif IDirectoryNode.providedBy(target):
 503             # directory
 504             uri_link = "/uri/" + urllib.quote(target.get_uri()) + "/"
 505             ctx.fillSlots("filename",
 506                           T.a(href=uri_link)[html.escape(name)])
 507             if target.is_readonly():
 508                 dirtype = "DIR-RO"
 509             else:
 510                 dirtype = "DIR"
 511             ctx.fillSlots("type", dirtype)
 512             ctx.fillSlots("size", "-")
 513             text_plain_tag = None
 514
 515         childdata = [T.a(href="%s?t=json" % name)["JSON"], ", ",
 516                      T.a(href="%s?t=uri" % name)["URI"], ", ",
 517                      T.a(href="%s?t=readonly-uri" % name)["readonly-URI"],
 518                      ]
 519         if text_plain_tag:
 520             childdata.extend([", ", text_plain_tag])
 521
 522         ctx.fillSlots("data", childdata)
 523
 524         try:
 525             checker = IClient(ctx).getServiceNamed("checker")
 526         except KeyError:
 527             checker = None
 528         if checker:
 529             d = defer.maybeDeferred(checker.checker_results_for,
 530                                     target.get_verifier())
 531             def _got(checker_results):
 532                 recent_results = reversed(checker_results[-5:])
 533                 if IFileNode.providedBy(target):
 534                     results = ("[" +
 535                                ", ".join(["%d/%d" % (found, needed)
 536                                           for (when,
 537                                                (needed, total, found, sharemap))
 538                                           in recent_results]) +
 539                                "]")
 540                 elif IDirectoryNode.providedBy(target):
 541                     results = ("[" +
 542                                "".join([{True:"+",False:"-"}[res]
 543                                         for (when, res) in recent_results]) +
 544                                "]")
 545                 else:
 546                     results = "%d results" % len(checker_results)
 547                 return results
 548             d.addCallback(_got)
 549             results = d
 550         else:
 551             results = "--"
 552         # TODO: include a link to see more results, including timestamps
 553         # TODO: use a sparkline
 554         ctx.fillSlots("checker_results", results)
 555
 556         return ctx.tag
 557
 558     def render_forms(self, ctx, data):
 559         if self.node.is_readonly():
 560             return T.div["No upload forms: directory is read-only"]
 561         mkdir = T.form(action=".", method="post",
 562                        enctype="multipart/form-data")[
 563             T.fieldset[
 564             T.input(type="hidden", name="t", value="mkdir"),
 565             T.input(type="hidden", name="when_done", value=url.here),
 566             T.legend(class_="freeform-form-label")["Create a new directory"],
 567             "New directory name: ",
 568             T.input(type="text", name="name"), " ",
 569             T.input(type="submit", value="Create"),
 570             ]]
 571
 572         upload = T.form(action=".", method="post",
 573                         enctype="multipart/form-data")[
 574             T.fieldset[
 575             T.input(type="hidden", name="t", value="upload"),
 576             T.input(type="hidden", name="when_done", value=url.here),
 577             T.legend(class_="freeform-form-label")["Upload a file to this directory"],
 578             "Choose a file to upload: ",
 579             T.input(type="file", name="file", class_="freeform-input-file"),
 580             " ",
 581             T.input(type="submit", value="Upload"),
 582             " Mutable?:",
 583             T.input(type="checkbox", name="mutable"),
 584             ]]
 585
 586         mount = T.form(action=".", method="post",
 587                         enctype="multipart/form-data")[
 588             T.fieldset[
 589             T.input(type="hidden", name="t", value="uri"),
 590             T.input(type="hidden", name="when_done", value=url.here),
 591             T.legend(class_="freeform-form-label")["Attach a file or directory"
 592                                                    " (by URI) to this"
 593                                                    " directory"],
 594             "New child name: ",
 595             T.input(type="text", name="name"), " ",
 596             "URI of new child: ",
 597             T.input(type="text", name="uri"), " ",
 598             T.input(type="submit", value="Attach"),
 599             ]]
 600         return [T.div(class_="freeform-form")[mkdir],
 601                 T.div(class_="freeform-form")[upload],
 602                 T.div(class_="freeform-form")[mount],
 603                 ]
 604
 605     def build_overwrite_form(self, ctx, name, target):
 606         if IMutableFileNode.providedBy(target) and not target.is_readonly():
 607             action = "/uri/" + urllib.quote(target.get_uri())
 608             overwrite = T.form(action=action, method="post",
 609                                enctype="multipart/form-data")[
 610                 T.fieldset[
 611                 T.input(type="hidden", name="t", value="upload"),
 612                 T.input(type='hidden', name='when_done', value=url.here),
 613                 T.legend(class_="freeform-form-label")["Overwrite"],
 614                 "Choose new file: ",
 615                 T.input(type="file", name="file", class_="freeform-input-file"),
 616                 " ",
 617                 T.input(type="submit", value="Overwrite")
 618                 ]]
 619             return [T.div(class_="freeform-form")[overwrite],]
 620         else:
 621             return []
 622
 623     def render_results(self, ctx, data):
 624         req = IRequest(ctx)
 625         return get_arg(req, "results", "")
 626
 627
 628 def DirectoryJSONMetadata(ctx, dirnode):
 629     d = dirnode.list()
 630     def _got(children):
 631         kids = {}
 632         for name, (childnode, metadata) in children.iteritems():
 633             if childnode.is_readonly():
 634                 rw_uri = None
 635                 ro_uri = childnode.get_uri()
 636             else:
 637                 rw_uri = childnode.get_uri()
 638                 ro_uri = childnode.get_readonly_uri()
 639             if IFileNode.providedBy(childnode):
 640                 kiddata = ("filenode", {'size': childnode.get_size(),
 641                                         'metadata': metadata,
 642                                         })
 643             else:
 644                 assert IDirectoryNode.providedBy(childnode), (childnode,
 645                                                               children,)
 646                 kiddata = ("dirnode", {'metadata': metadata})
 647             if ro_uri:
 648                 kiddata[1]["ro_uri"] = ro_uri
 649             if rw_uri:
 650                 kiddata[1]["rw_uri"] = rw_uri
 651             kiddata[1]['mutable'] = childnode.is_mutable()
 652             kids[name] = kiddata
 653         if dirnode.is_readonly():
 654             drw_uri = None
 655             dro_uri = dirnode.get_uri()
 656         else:
 657             drw_uri = dirnode.get_uri()
 658             dro_uri = dirnode.get_readonly_uri()
 659         contents = { 'children': kids }
 660         if dro_uri:
 661             contents['ro_uri'] = dro_uri
 662         if drw_uri:
 663             contents['rw_uri'] = drw_uri
 664         contents['mutable'] = dirnode.is_mutable()
 665         data = ("dirnode", contents)
 666         return simplejson.dumps(data, indent=1)
 667     d.addCallback(_got)
 668     d.addCallback(text_plain, ctx)
 669     return d
 670
 671 def DirectoryURI(ctx, dirnode):
 672     return text_plain(dirnode.get_uri(), ctx)
 673
 674 def DirectoryReadonlyURI(ctx, dirnode):
 675     return text_plain(dirnode.get_readonly_uri(), ctx)
 676
 677 class RenameForm(rend.Page):
 678     addSlash = True
 679     docFactory = getxmlfile("rename-form.xhtml")
 680
 681     def render_title(self, ctx, data):
 682         return ctx.tag["Directory SI=%s" % abbreviated_dirnode(self.original)]
 683
 684     def render_header(self, ctx, data):
 685         header = ["Rename "
 686                   "in directory SI=%s" % abbreviated_dirnode(self.original),
 687                   ]
 688
 689         if self.original.is_readonly():
 690             header.append(" (readonly!)")
 691         header.append(":")
 692         return ctx.tag[header]
 693
 694     def render_when_done(self, ctx, data):
 695         return T.input(type="hidden", name="when_done", value=url.here)
 696
 697     def render_get_name(self, ctx, data):
 698         req = IRequest(ctx)
 699         name = get_arg(req, "name", "")
 700         ctx.tag.attributes['value'] = name
 701         return ctx.tag
 702
 703
 704 class Manifest(rend.Page):
 705     docFactory = getxmlfile("manifest.xhtml")
 706
 707     def render_title(self, ctx):
 708         return T.title["Manifest of SI=%s" % abbreviated_dirnode(self.original)]
 709
 710     def render_header(self, ctx):
 711         return T.p["Manifest of SI=%s" % abbreviated_dirnode(self.original)]
 712
 713     def data_items(self, ctx, data):
 714         return self.original.build_manifest()
 715
 716     def render_row(self, ctx, refresh_cap):
 717         ctx.fillSlots("refresh_capability", refresh_cap)
 718         return ctx.tag
 719
 720 def DeepSize(ctx, dirnode):
 721     d = dirnode.build_manifest()
 722     def _measure_size(manifest):
 723         total = 0
 724         for verifiercap in manifest:
 725             u = from_string_verifier(verifiercap)
 726             if isinstance(u, CHKFileVerifierURI):
 727                 total += u.size
 728         return str(total)
 729     d.addCallback(_measure_size)
 730     d.addCallback(text_plain, ctx)
 731     return d
 732
 733 def DeepStats(ctx, dirnode):
 734     d = dirnode.deep_stats()
 735     d.addCallback(simplejson.dumps, indent=1)
 736     d.addCallback(text_plain, ctx)
 737     return d