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