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