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