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