Ticket #531: sftp-all-darcspatch.txt

File sftp-all-darcspatch.txt, 115.5 KB (added by davidsarah, at 2010-05-12T06:18:21Z)

All patches needed for new SFTP implementation and tests

Line 
1Wed May 12 06:54:07 GMT Daylight Time 2010  david-sarah@jacaranda.org
2  * New SFTP implementation: mutable files, read/write support, streaming download, Unicode filenames, and more
3
4Wed May 12 07:05:52 GMT Daylight Time 2010  david-sarah@jacaranda.org
5  * Tests for new SFTP implementation
6
7Wed May 12 07:07:54 GMT Daylight Time 2010  david-sarah@jacaranda.org
8  * Change shouldFail to avoid Unicode errors when converting Failure to str
9
10New patches:
11
12[New SFTP implementation: mutable files, read/write support, streaming download, Unicode filenames, and more
13david-sarah@jacaranda.org**20100512055407
14 Ignore-this: 906f51c48d974ba9cf360c27845c55eb
15] {
16hunk ./src/allmydata/frontends/sftpd.py 2
17 
18-import tempfile
19+import os, tempfile, heapq, binascii, traceback, sys
20+from stat import S_IFREG, S_IFDIR
21+
22 from zope.interface import implements
23 from twisted.python import components
24 from twisted.application import service, strports
25hunk ./src/allmydata/frontends/sftpd.py 8
26-from twisted.internet import defer
27 from twisted.conch.ssh import factory, keys, session
28hunk ./src/allmydata/frontends/sftpd.py 9
29+from twisted.conch.ssh.filetransfer import FileTransferServer, SFTPError, \
30+     FX_NO_SUCH_FILE, FX_OP_UNSUPPORTED, FX_PERMISSION_DENIED, FX_EOF, \
31+     FX_BAD_MESSAGE, FX_FAILURE
32+from twisted.conch.ssh.filetransfer import FXF_READ, FXF_WRITE, FXF_APPEND, \
33+     FXF_CREAT, FXF_TRUNC, FXF_EXCL
34 from twisted.conch.interfaces import ISFTPServer, ISFTPFile, IConchUser
35 from twisted.conch.avatar import ConchUser
36 from twisted.conch.openssh_compat import primes
37hunk ./src/allmydata/frontends/sftpd.py 17
38-from twisted.conch import ls
39 from twisted.cred import portal
40 
41hunk ./src/allmydata/frontends/sftpd.py 19
42-from allmydata.interfaces import IDirectoryNode, ExistingChildError, \
43+from twisted.internet import defer
44+from twisted.python.failure import Failure
45+from twisted.internet.interfaces import IFinishableConsumer
46+from foolscap.api import eventually
47+from allmydata.util import deferredutil
48+
49+from allmydata.util.consumer import download_to_data
50+from allmydata.interfaces import IFileNode, IDirectoryNode, ExistingChildError, \
51      NoSuchChildError
52hunk ./src/allmydata/frontends/sftpd.py 28
53+from allmydata.mutable.common import NotWriteableError
54 from allmydata.immutable.upload import FileHandle
55hunk ./src/allmydata/frontends/sftpd.py 30
56-from allmydata.util.consumer import download_to_data
57 
58hunk ./src/allmydata/frontends/sftpd.py 31
59-class ReadFile:
60+from pycryptopp.cipher.aes import AES
61+
62+# twisted.conch.ssh.filetransfer generates this warning, but not when it is imported,
63+# only on an error.
64+import warnings
65+warnings.filterwarnings("ignore", category=DeprecationWarning,
66+    message="BaseException.message has been deprecated as of Python 2.6",
67+    module=".*filetransfer", append=True)
68+
69+debug = False
70+
71+if debug:
72+    def eventually_callback(d):
73+        s = traceback.format_stack()
74+        def _cb(res):
75+            try:
76+                print "CALLBACK %r %r" % (d, res)
77+                d.callback(res)
78+            except:  # pragma: no cover
79+                print "Failed to callback %r" % (d,)
80+                print "with %r" % (res,)
81+                print "Original stack:"
82+                print '!' + '!'.join(s)
83+                traceback.print_exc()
84+                raise
85+        return lambda res: eventually(_cb, res)
86+
87+    def eventually_errback(d):
88+        s = traceback.format_stack()
89+        def _eb(err):
90+            try:
91+                print "ERRBACK", d, err
92+                d.errback(err)
93+            except:  # pragma: no cover
94+                print "Failed to errback %r" % (d,)
95+                print "with %r" % (err,)
96+                print "Original stack:"
97+                print '!' + '!'.join(s)
98+                traceback.print_exc()
99+                raise
100+        return lambda err: eventually(_eb, err)
101+else:
102+    def eventually_callback(d):
103+        return lambda res: eventually(d.callback, res)
104+
105+    def eventually_errback(d):
106+        return lambda err: eventually(d.errback, err)
107+
108+
109+def _raise_error(err):
110+    if err is None:
111+        return None
112+    if debug:
113+        print "TRACEBACK %r" % (err,)
114+        #traceback.print_exc(err)
115+
116+    # The message argument to SFTPError must not reveal information that
117+    # might compromise anonymity.
118+
119+    if err.check(SFTPError):
120+        # original raiser of SFTPError has responsibility to ensure anonymity
121+        raise err
122+    if err.check(NoSuchChildError):
123+        childname = err.value.args[0].encode('utf-8')
124+        raise SFTPError(FX_NO_SUCH_FILE, childname)
125+    if err.check(ExistingChildError):
126+        msg = err.value.args[0].encode('utf-8')
127+        # later versions of SFTP define FX_FILE_ALREADY_EXISTS, but version 3 doesn't
128+        raise SFTPError(FX_PERMISSION_DENIED, msg)
129+    if err.check(NotWriteableError):
130+        msg = err.value.args[0].encode('utf-8')
131+        raise SFTPError(FX_PERMISSION_DENIED, msg)
132+    if err.check(NotImplementedError):
133+        raise SFTPError(FX_OP_UNSUPPORTED, str(err.value))
134+    if err.check(EOFError):
135+        raise SFTPError(FX_EOF, "end of file reached")
136+    if err.check(defer.FirstError):
137+        _raise_error(err.value.subFailure)
138+
139+    # We assume that the type of error is not anonymity-sensitive.
140+    raise SFTPError(FX_FAILURE, str(err.type))
141+
142+def _repr_flags(flags):
143+    return "|".join([f for f in
144+                     [(flags & FXF_READ) and "FXF_READ" or None,
145+                      (flags & FXF_WRITE) and "FXF_WRITE" or None,
146+                      (flags & FXF_APPEND) and "FXF_APPEND" or None,
147+                      (flags & FXF_CREAT) and "FXF_CREAT" or None,
148+                      (flags & FXF_TRUNC) and "FXF_TRUNC" or None,
149+                      (flags & FXF_EXCL) and "FXF_EXCL" or None,
150+                     ]
151+                     if f])
152+
153+def _populate_attrs(childnode, metadata, writeable, size=None):
154+    attrs = {}
155+
156+    # see webapi.txt for what these times mean
157+    if metadata:
158+        if "linkmotime" in metadata.get("tahoe", {}):
159+            attrs["mtime"] = int(metadata["tahoe"]["linkmotime"])
160+        elif "mtime" in metadata:
161+            attrs["mtime"] = int(metadata["mtime"])
162+
163+        if "linkcrtime" in metadata.get("tahoe", {}):
164+            attrs["createtime"] = int(metadata["tahoe"]["linkcrtime"])
165+
166+        if "ctime" in metadata:
167+            attrs["ctime"] = int(metadata["ctime"])
168+
169+        # We would prefer to omit atime, but SFTP version 3 can only
170+        # accept mtime if atime is also set.
171+        attrs["atime"] = attrs["mtime"]
172+
173+    # The permissions must have the extra bits (040000 or 0100000),
174+    # otherwise the client will not call openDirectory.
175+
176+    # Directories and unknown nodes have no size, and SFTP doesn't
177+    # require us to make one up.
178+    # childnode might be None, meaning that the file doesn't exist yet,
179+    # but we're going to write it later.
180+
181+    if childnode and childnode.is_unknown():
182+        perms = 0
183+    elif childnode and IDirectoryNode.providedBy(childnode):
184+        perms = S_IFDIR | 0770
185+    else:
186+        # For files, omit the size if we don't immediately know it.
187+        if childnode and size is None:
188+            size = childnode.get_size()
189+        if size is not None:
190+            assert isinstance(size, (int, long)), repr(size)
191+            attrs["size"] = size
192+        perms = S_IFREG | 0660
193+
194+    if not writeable:
195+        perms &= S_IFDIR | S_IFREG | 0555  # clear 'w' bits
196+
197+    attrs["permissions"] = perms
198+
199+    # We could set the SSH_FILEXFER_ATTR_FLAGS here:
200+    # ENCRYPTED would always be true ("The file is stored on disk
201+    # using file-system level transparent encryption.")
202+    # SYSTEM, HIDDEN, ARCHIVE and SYNC would always be false.
203+    # READONLY and IMMUTABLE would be set according to
204+    # childnode.is_readonly() and childnode.is_immutable()
205+    # for known nodes.
206+    # However, twisted.conch.ssh.filetransfer only implements
207+    # SFTP version 3, which doesn't include these flags.
208+
209+    return attrs
210+
211+
212+class EncryptedTemporaryFile:
213+    # not implemented: next, readline, readlines, xreadlines, writelines
214+
215+    def _crypt(self, offset, data):
216+        # FIXME: use random-access AES (pycryptopp ticket #18)
217+        offset_big = offset // 16
218+        offset_small = offset % 16
219+        iv = binascii.unhexlify("%032x" % offset_big)
220+        cipher = AES(self.key, iv=iv)
221+        cipher.process("\x00"*offset_small)
222+        return cipher.process(data)
223+
224+    def __init__(self):
225+        self.file = tempfile.TemporaryFile()
226+        self.key = os.urandom(16)  # AES-128
227+
228+    def close(self):
229+        self.file.close()
230+
231+    def flush(self):
232+        self.file.flush()
233+
234+    def seek(self, offset, whence=os.SEEK_SET):
235+        if debug: print ".seek(%r, %r)" % (offset, whence)
236+        self.file.seek(offset, whence)
237+
238+    def tell(self):
239+        offset = self.file.tell()
240+        if debug: print ".offset = %r" % (offset,)
241+        return offset
242+
243+    def read(self, size=-1):
244+        if debug: print ".read(%r)" % (size,)
245+        index = self.file.tell()
246+        ciphertext = self.file.read(size)
247+        plaintext = self._crypt(index, ciphertext)
248+        return plaintext
249+
250+    def write(self, plaintext):
251+        if debug: print ".write(%r)" % (plaintext,)
252+        index = self.file.tell()
253+        ciphertext = self._crypt(index, plaintext)
254+        self.file.write(ciphertext)
255+
256+    def truncate(self, newsize):
257+        if debug: print ".truncate(%r)" % (newsize,)
258+        self.file.truncate(newsize)
259+
260+
261+class OverwriteableFileConsumer:
262+    implements(IFinishableConsumer)
263+    """I act both as a consumer for the download of the original file contents, and as a
264+    wrapper for a temporary file that records the downloaded data and any overwrites.
265+    I use a priority queue to keep track of which regions of the file have been overwritten
266+    but not yet downloaded, so that the download does not clobber overwritten data.
267+    I use another priority queue to record milestones at which to make callbacks
268+    indicating that a given number of bytes have been downloaded.
269+
270+    The temporary file reflects the contents of the file that I represent, except that:
271+     - regions that have neither been downloaded nor overwritten, if present,
272+       contain zeroes.
273+     - the temporary file may be shorter than the represented file (it is never longer).
274+       The latter's current size is stored in self.current_size.
275+
276+    This abstraction is mostly independent of SFTP. Consider moving it, if it is found
277+    useful for other frontends."""
278+
279+    def __init__(self, check_abort, download_size, tempfile_maker):
280+        self.check_abort = check_abort
281+        self.download_size = download_size
282+        self.current_size = download_size
283+        self.f = tempfile_maker()
284+        self.downloaded = 0
285+        self.milestones = []  # empty heap of (offset, d)
286+        self.overwrites = []  # empty heap of (start, end)
287+        self.done = self.when_reached(download_size)  # adds a milestone
288+        self.producer = None
289+
290+    def get_file(self):
291+        return self.f
292+
293+    def get_current_size(self):
294+        return self.current_size
295+
296+    def set_current_size(self, size):
297+        if debug: print "set_current_size(%r), current_size = %r, downloaded = %r" % (size, self.current_size, self.downloaded)
298+        if size < self.current_size or size < self.downloaded:
299+            self.f.truncate(size)
300+        self.current_size = size
301+        if size < self.download_size:
302+            self.download_size = size
303+        if self.downloaded >= self.download_size:
304+            self.finish()
305+
306+    def registerProducer(self, p, streaming):
307+        self.producer = p
308+        if streaming:
309+            # call resumeProducing once to start things off
310+            p.resumeProducing()
311+        else:
312+            while not self.done:
313+                p.resumeProducing()
314+
315+    def write(self, data):
316+        if debug: print "write(%r)" % (data,)
317+        if self.check_abort():
318+            self.close()
319+            return
320+
321+        if self.downloaded >= self.download_size:
322+            return
323+
324+        next_downloaded = self.downloaded + len(data)
325+        if next_downloaded > self.download_size:
326+            data = data[:(self.download_size - self.downloaded)]
327+
328+        while len(self.overwrites) > 0:
329+            (start, end) = self.overwrites[0]
330+            if start >= next_downloaded:
331+                # This and all remaining overwrites are after the data we just downloaded.
332+                break
333+            if start > self.downloaded:
334+                # The data we just downloaded has been partially overwritten.
335+                # Write the prefix of it that precedes the overwritten region.
336+                self.f.seek(self.downloaded)
337+                self.f.write(data[:(start - self.downloaded)])
338+
339+            # This merges consecutive overwrites if possible, which allows us to detect the
340+            # case where the download can be stopped early because the remaining region
341+            # to download has already been fully overwritten.
342+            heapq.heappop(self.overwrites)
343+            while len(self.overwrites) > 0:
344+                (start1, end1) = self.overwrites[0]
345+                if start1 > end:
346+                    break
347+                end = end1
348+                heapq.heappop(self.overwrites)
349+
350+            if end >= next_downloaded:
351+                # This overwrite extends past the downloaded data, so there is no
352+                # more data to consider on this call.
353+                heapq.heappush(self.overwrites, (next_downloaded, end))
354+                self._update_downloaded(next_downloaded)
355+                return
356+            elif end >= self.downloaded:
357+                data = data[(end - self.downloaded):]
358+                self._update_downloaded(end)
359+
360+        self.f.seek(self.downloaded)
361+        self.f.write(data)
362+        self._update_downloaded(next_downloaded)
363+
364+    def _update_downloaded(self, new_downloaded):
365+        self.downloaded = new_downloaded
366+        milestone = new_downloaded
367+        if len(self.overwrites) > 0:
368+            (start, end) = self.overwrites[0]
369+            if start <= new_downloaded and end > milestone:
370+                milestone = end
371+
372+        while len(self.milestones) > 0:
373+            (next, d) = self.milestones[0]
374+            if next > milestone:
375+                return
376+            if debug: print "MILESTONE %r %r" % (next, d)
377+            heapq.heappop(self.milestones)
378+            eventually_callback(d)(None)
379+
380+        if milestone >= self.download_size:
381+            self.finish()
382+
383+    def overwrite(self, offset, data):
384+        if debug: print "overwrite(%r, %r)" % (offset, data)
385+        if offset > self.download_size and offset > self.current_size:
386+            # Normally writing at an offset beyond the current end-of-file
387+            # would leave a hole that appears filled with zeroes. However, an
388+            # EncryptedTemporaryFile doesn't behave like that (if there is a
389+            # hole in the file on disk, the zeroes that are read back will be
390+            # XORed with the keystream). So we must explicitly write zeroes in
391+            # the gap between the current EOF and the offset.
392+
393+            self.f.seek(self.current_size)
394+            self.f.write("\x00" * (offset - self.current_size))           
395+        else:
396+            self.f.seek(offset)
397+        self.f.write(data)
398+        end = offset + len(data)
399+        self.current_size = max(self.current_size, end)
400+        if end > self.downloaded:
401+            heapq.heappush(self.overwrites, (offset, end))
402+
403+    def read(self, offset, length):
404+        """When the data has been read, callback the Deferred that we return with this data.
405+        Otherwise errback the Deferred that we return.
406+        The caller must perform no more overwrites until the Deferred has fired."""
407+
408+        if debug: print "read(%r, %r), current_size = %r" % (offset, length, self.current_size)
409+        if offset >= self.current_size:
410+            def _eof(): raise EOFError("read past end of file")
411+            return defer.execute(_eof)
412+
413+        if offset + length > self.current_size:
414+            length = self.current_size - offset
415+
416+        needed = min(offset + length, self.download_size)
417+        d = self.when_reached(needed)
418+        def _reached(ign):
419+            # It is not necessarily the case that self.downloaded >= needed, because
420+            # the file might have been truncated (thus truncating the download) and
421+            # then extended.
422+
423+            assert self.current_size >= offset + length, (self.current_size, offset, length)
424+            if debug: print "!!! %r" % (self.f,)
425+            self.f.seek(offset)
426+            return self.f.read(length)
427+        d.addCallback(_reached)
428+        return d
429+
430+    def when_reached(self, index):
431+        if debug: print "when_reached(%r)" % (index,)
432+        if index <= self.downloaded:  # already reached
433+            if debug: print "already reached %r" % (index,)
434+            return defer.succeed(None)
435+        d = defer.Deferred()
436+        def _reached(ign):
437+            if debug: print "reached %r" % (index,)
438+            return ign
439+        d.addCallback(_reached)
440+        heapq.heappush(self.milestones, (index, d))
441+        return d
442+
443+    def when_done(self):
444+        return self.done
445+
446+    def finish(self):
447+        while len(self.milestones) > 0:
448+            (next, d) = self.milestones[0]
449+            if debug: print "MILESTONE FINISH %r %r" % (next, d)
450+            heapq.heappop(self.milestones)
451+            # The callback means that the milestone has been reached if
452+            # it is ever going to be. Note that the file may have been
453+            # truncated to before the milestone.
454+            eventually_callback(d)(None)
455+
456+        # FIXME: causes spurious failures
457+        #self.unregisterProducer()
458+
459+    def close(self):
460+        self.finish()
461+        self.f.close()
462+
463+    def unregisterProducer(self):
464+        if self.producer:
465+            self.producer.stopProducing()
466+            self.producer = None
467+
468+
469+SIZE_THRESHOLD = 1000
470+
471+def _make_sftp_file(check_abort, flags, convergence, parent=None, childname=None, filenode=None, metadata=None):
472+    if not (flags & (FXF_WRITE | FXF_CREAT)) and (flags & FXF_READ) and filenode and \
473+       not filenode.is_mutable() and filenode.get_size() <= SIZE_THRESHOLD:
474+        return ShortReadOnlySFTPFile(filenode, metadata)
475+    else:
476+        return GeneralSFTPFile(check_abort, flags, convergence,
477+                               parent=parent, childname=childname, filenode=filenode, metadata=metadata)
478+
479+
480+class ShortReadOnlySFTPFile:
481     implements(ISFTPFile)
482hunk ./src/allmydata/frontends/sftpd.py 453
483-    def __init__(self, node):
484-        self.node = node
485+    """I represent a file handle to a particular file on an SFTP connection.
486+    I am used only for short immutable files opened in read-only mode.
487+    The file contents are downloaded to memory when I am created."""
488+
489+    def __init__(self, filenode, metadata):
490+        assert IFileNode.providedBy(filenode), filenode
491+        self.filenode = filenode
492+        self.metadata = metadata
493+        self.async = download_to_data(filenode)
494+        self.closed = False
495+
496     def readChunk(self, offset, length):
497hunk ./src/allmydata/frontends/sftpd.py 465
498-        d = download_to_data(self.node, offset, length)
499-        def _got(data):
500+        if self.closed:
501+            def _closed(): raise SFTPError(FX_BAD_MESSAGE, "cannot read from a closed file handle")
502+            return defer.execute(_closed)
503+
504+        d = defer.Deferred()
505+        def _read(data):
506+            if debug: print "_read(%r) in readChunk(%r, %r)" % (data, offset, length)
507+
508+            # "In response to this request, the server will read as many bytes as it
509+            #  can from the file (up to 'len'), and return them in a SSH_FXP_DATA
510+            #  message.  If an error occurs or EOF is encountered before reading any
511+            #  data, the server will respond with SSH_FXP_STATUS.  For normal disk
512+            #  files, it is guaranteed that this will read the specified number of
513+            #  bytes, or up to end of file."
514+            #
515+            # i.e. we respond with an EOF error iff offset is already at EOF.
516+
517+            if offset >= len(data):
518+                eventually_errback(d)(SFTPError(FX_EOF, "read at or past end of file"))
519+            else:
520+                eventually_callback(d)(data[offset:min(offset+length, len(data))])
521             return data
522hunk ./src/allmydata/frontends/sftpd.py 487
523-        d.addCallback(_got)
524+        self.async.addCallbacks(_read, eventually_errback(d))
525         return d
526hunk ./src/allmydata/frontends/sftpd.py 489
527+
528+    def writeChunk(self, offset, data):
529+        def _denied(): raise SFTPError(FX_PERMISSION_DENIED, "file handle was not opened for writing")
530+        return defer.execute(_denied)
531+
532     def close(self):
533hunk ./src/allmydata/frontends/sftpd.py 495
534-        pass
535+        self.closed = True
536+        return defer.succeed(None)
537+
538     def getAttrs(self):
539hunk ./src/allmydata/frontends/sftpd.py 499
540-        print "GETATTRS(file)"
541-        raise NotImplementedError
542+        if debug: print "GETATTRS(file)"
543+        if self.closed:
544+            def _closed(): raise SFTPError(FX_BAD_MESSAGE, "cannot get attributes for a closed file handle")
545+            return defer.execute(_closed)
546+
547+        return defer.succeed(_populate_attrs(self.filenode, self.metadata, False))
548+
549     def setAttrs(self, attrs):
550hunk ./src/allmydata/frontends/sftpd.py 507
551-        print "SETATTRS(file)", attrs
552-        raise NotImplementedError
553+        if debug: print "SETATTRS(file) %r" % (attrs,)
554+        def _denied(): raise SFTPError(FX_PERMISSION_DENIED, "file handle was not opened for writing")
555+        return defer.execute(_denied)
556+
557 
558hunk ./src/allmydata/frontends/sftpd.py 512
559-class WriteFile:
560+class GeneralSFTPFile:
561     implements(ISFTPFile)
562hunk ./src/allmydata/frontends/sftpd.py 514
563+    """I represent a file handle to a particular file on an SFTP connection.
564+    I wrap an instance of OverwriteableFileConsumer, which is responsible for
565+    storing the file contents. In order to allow write requests to be satisfied
566+    immediately, there is effectively a FIFO queue between requests made to this
567+    file handle, and requests to my OverwriteableFileConsumer. This queue is
568+    implemented by the callback chain of self.async."""
569 
570hunk ./src/allmydata/frontends/sftpd.py 521
571-    def __init__(self, parent, childname, convergence):
572+    def __init__(self, check_abort, flags, convergence, parent=None, childname=None, filenode=None, metadata=None):
573+        self.check_abort = check_abort
574+        self.flags = flags
575+        self.convergence = convergence
576         self.parent = parent
577         self.childname = childname
578hunk ./src/allmydata/frontends/sftpd.py 527
579-        self.convergence = convergence
580-        self.f = tempfile.TemporaryFile()
581+        self.filenode = filenode
582+        self.metadata = metadata
583+        self.async = defer.succeed(None)
584+        self.closed = False
585+       
586+        # self.consumer should only be relied on in callbacks for self.async, since it might
587+        # not be set before then.
588+        self.consumer = None
589+
590+        if (flags & FXF_TRUNC) or not filenode:
591+            # We're either truncating or creating the file, so we don't need the old contents.
592+            assert flags & FXF_CREAT, flags
593+            self.consumer = OverwriteableFileConsumer(self.check_abort, 0,
594+                                                      tempfile_maker=EncryptedTemporaryFile)
595+            self.consumer.finish()
596+        else:
597+            assert IFileNode.providedBy(filenode), filenode
598+
599+            # TODO: use download interface described in #993 when implemented.
600+            if filenode.is_mutable():
601+                self.async.addCallback(lambda ign: filenode.download_best_version())
602+                def _downloaded(data):
603+                    self.consumer = OverwriteableFileConsumer(self.check_abort, len(data),
604+                                                              tempfile_maker=tempfile.TemporaryFile)
605+                    self.consumer.write(data)
606+                    self.consumer.finish()
607+                    return None
608+                self.async.addCallback(_downloaded)
609+            else:
610+                download_size = filenode.get_size()
611+                assert download_size is not None
612+                self.consumer = OverwriteableFileConsumer(self.check_abort, download_size,
613+                                                          tempfile_maker=tempfile.TemporaryFile)
614+                self.async.addCallback(lambda ign: filenode.read(self.consumer, 0, None))
615+
616+
617+    def readChunk(self, offset, length):
618+        if not (self.flags & FXF_READ):
619+            return defer.fail(SFTPError(FX_PERMISSION_DENIED, "file handle was not opened for reading"))
620+
621+        if self.closed:
622+            def _closed(): raise SFTPError(FX_BAD_MESSAGE, "cannot read from a closed file handle")
623+            return defer.execute(_closed)
624+
625+        d = defer.Deferred()
626+        def _read(ign):
627+            if debug: print "_read in readChunk(%r, %r)" % (offset, length)
628+            d2 = self.consumer.read(offset, length)
629+            d2.addErrback(_raise_error)
630+            d2.addCallbacks(eventually_callback(d), eventually_errback(d))
631+            # It is correct to drop d2 here.
632+            return None
633+        self.async.addCallbacks(_read, eventually_errback(d))
634+        return d
635+
636     def writeChunk(self, offset, data):
637hunk ./src/allmydata/frontends/sftpd.py 583
638-        self.f.seek(offset)
639-        self.f.write(data)
640+        if debug: print "writeChunk(%r, %r)" % (offset, data)
641+        if not (self.flags & FXF_WRITE):
642+            def _denied(): raise SFTPError(FX_PERMISSION_DENIED, "file handle was not opened for writing")
643+            return defer.execute(_denied)
644+
645+        if self.closed:
646+            def _closed(): raise SFTPError(FX_BAD_MESSAGE, "cannot write to a closed file handle")
647+            return defer.execute(_closed)
648+
649+        # Note that we return without waiting for the write to occur. Reads and
650+        # close wait for prior writes, and will fail if any prior operation failed.
651+        # This is ok because SFTP makes no guarantee that the request completes
652+        # before the write. In fact it explicitly allows write errors to be delayed
653+        # until close:
654+        #   "One should note that on some server platforms even a close can fail.
655+        #    This can happen e.g. if the server operating system caches writes,
656+        #    and an error occurs while flushing cached writes during the close."
657+
658+        def _write(ign):
659+            # FXF_APPEND means that we should always write at the current end of file.
660+            write_offset = offset
661+            if self.flags & FXF_APPEND:
662+                write_offset = self.consumer.get_current_size()
663+
664+            self.consumer.overwrite(write_offset, data)
665+            return None
666+        self.async.addCallback(_write)
667+        # don't addErrback to self.async, just allow subsequent async ops to fail.
668+        return defer.succeed(None)
669 
670     def close(self):
671hunk ./src/allmydata/frontends/sftpd.py 614
672-        u = FileHandle(self.f, self.convergence)
673-        d = self.parent.add_file(self.childname, u)
674+        if self.closed:
675+            return defer.succeed(None)
676+
677+        # This means that close has been called, not that the close has succeeded.
678+        self.closed = True
679+
680+        if not (self.flags & (FXF_WRITE | FXF_CREAT)):
681+            return defer.execute(self.consumer.close)
682+
683+        def _close(ign):
684+            d2 = self.consumer.when_done()
685+            if self.filenode and self.filenode.is_mutable():
686+                d2.addCallback(lambda ign: self.consumer.get_current_size())
687+                d2.addCallback(lambda size: self.consumer.read(0, size))
688+                d2.addCallback(lambda new_contents: self.filenode.overwrite(new_contents))
689+            else:
690+                def _add_file(ign):
691+                    u = FileHandle(self.consumer.get_file(), self.convergence)
692+                    return self.parent.add_file(self.childname, u)
693+                d2.addCallback(_add_file)
694+
695+            d2.addCallback(lambda ign: self.consumer.close())
696+            return d2
697+        self.async.addCallback(_close)
698+
699+        d = defer.Deferred()
700+        self.async.addCallbacks(eventually_callback(d), eventually_errback(d))
701         return d
702 
703     def getAttrs(self):
704hunk ./src/allmydata/frontends/sftpd.py 644
705-        print "GETATTRS(file)"
706-        raise NotImplementedError
707+        if debug: print "GETATTRS(file)"
708+
709+        if self.closed:
710+            def _closed(): raise SFTPError(FX_BAD_MESSAGE, "cannot get attributes for a closed file handle")
711+            return defer.execute(_closed)
712+
713+        # Optimization for read-only handles, when we already know the metadata.
714+        if not(self.flags & (FXF_WRITE | FXF_CREAT)) and self.metadata and self.filenode and not self.filenode.is_mutable():
715+            return defer.succeed(_populate_attrs(self.filenode, self.metadata, False))
716+
717+        d = defer.Deferred()
718+        def _get(ign):
719+            # FIXME: pass correct value for writeable
720+            # self.filenode might be None, but that's ok.
721+            attrs = _populate_attrs(self.filenode, self.metadata, False,
722+                                    size=self.consumer.get_current_size())
723+            eventually_callback(d)(attrs)
724+            return None
725+        self.async.addCallbacks(_get, eventually_errback(d))
726+        return d
727+
728     def setAttrs(self, attrs):
729hunk ./src/allmydata/frontends/sftpd.py 666
730-        print "SETATTRS(file)", attrs
731-        raise NotImplementedError
732+        if debug: print "SETATTRS(file) %r" % (attrs,)
733+        if not (self.flags & FXF_WRITE):
734+            def _denied(): raise SFTPError(FX_PERMISSION_DENIED, "file handle was not opened for writing")
735+            return defer.execute(_denied)
736 
737hunk ./src/allmydata/frontends/sftpd.py 671
738+        if self.closed:
739+            def _closed(): raise SFTPError(FX_BAD_MESSAGE, "cannot set attributes for a closed file handle")
740+            return defer.execute(_closed)
741 
742hunk ./src/allmydata/frontends/sftpd.py 675
743-class NoParentError(Exception):
744-    pass
745+        if not "size" in attrs:
746+            return defer.succeed(None)
747 
748hunk ./src/allmydata/frontends/sftpd.py 678
749-class PermissionError(Exception):
750-    pass
751+        size = attrs["size"]
752+        if not isinstance(size, (int, long)) or size < 0:
753+            def _bad(): raise SFTPError(FX_BAD_MESSAGE, "new size is not a valid nonnegative integer")
754+            return defer.execute(_bad)
755 
756hunk ./src/allmydata/frontends/sftpd.py 683
757-from twisted.conch.ssh.filetransfer import FileTransferServer, SFTPError, \
758-     FX_NO_SUCH_FILE, FX_FILE_ALREADY_EXISTS, FX_OP_UNSUPPORTED, \
759-     FX_PERMISSION_DENIED
760-from twisted.conch.ssh.filetransfer import FXF_READ, FXF_WRITE, FXF_APPEND, FXF_CREAT, FXF_TRUNC, FXF_EXCL
761+        d = defer.Deferred()
762+        def _resize(ign):
763+            self.consumer.set_current_size(size)
764+            eventually_callback(d)(None)
765+            return None
766+        self.async.addCallbacks(_resize, eventually_errback(d))
767+        return d
768 
769 class SFTPUser(ConchUser):
770hunk ./src/allmydata/frontends/sftpd.py 692
771-    def __init__(self, client, rootnode, username, convergence):
772+    def __init__(self, check_abort, client, rootnode, username, convergence):
773         ConchUser.__init__(self)
774         self.channelLookup["session"] = session.SSHSession
775         self.subsystemLookup["sftp"] = FileTransferServer
776hunk ./src/allmydata/frontends/sftpd.py 697
777 
778+        self.check_abort = check_abort
779         self.client = client
780         self.root = rootnode
781         self.username = username
782hunk ./src/allmydata/frontends/sftpd.py 712
783     def close(self):
784         pass
785 
786-class FakeStat:
787-    pass
788+import array
789+import stat
790+
791+from time import time, strftime, localtime
792+
793+def lsLine(name, attrs):
794+    st_uid = "tahoe"
795+    st_gid = "tahoe"
796+    st_mtime = attrs.get("mtime", 0)
797+    st_mode = attrs["permissions"]
798+    # TODO: check that clients are okay with this being a "?".
799+    # (They should be because the longname is intended for human
800+    # consumption.)
801+    st_size = attrs.get("size", "?")
802+    # We don't know how many links there really are to this object.
803+    st_nlink = 1
804+
805+    # From <http://twistedmatrix.com/trac/browser/trunk/twisted/conch/ls.py?rev=25412>.
806+    # We can't call the version in Twisted because we might have a version earlier than
807+    # <http://twistedmatrix.com/trac/changeset/25412> (released in Twisted 8.2).
808+
809+    mode = st_mode
810+    perms = array.array('c', '-'*10)
811+    ft = stat.S_IFMT(mode)
812+    if stat.S_ISDIR(ft): perms[0] = 'd'
813+    elif stat.S_ISCHR(ft): perms[0] = 'c'
814+    elif stat.S_ISBLK(ft): perms[0] = 'b'
815+    elif stat.S_ISREG(ft): perms[0] = '-'
816+    elif stat.S_ISFIFO(ft): perms[0] = 'f'
817+    elif stat.S_ISLNK(ft): perms[0] = 'l'
818+    elif stat.S_ISSOCK(ft): perms[0] = 's'
819+    else: perms[0] = '?'
820+    # user
821+    if mode&stat.S_IRUSR:perms[1] = 'r'
822+    if mode&stat.S_IWUSR:perms[2] = 'w'
823+    if mode&stat.S_IXUSR:perms[3] = 'x'
824+    # group
825+    if mode&stat.S_IRGRP:perms[4] = 'r'
826+    if mode&stat.S_IWGRP:perms[5] = 'w'
827+    if mode&stat.S_IXGRP:perms[6] = 'x'
828+    # other
829+    if mode&stat.S_IROTH:perms[7] = 'r'
830+    if mode&stat.S_IWOTH:perms[8] = 'w'
831+    if mode&stat.S_IXOTH:perms[9] = 'x'
832+    # suid/sgid never set
833+
834+    l = perms.tostring()
835+    l += str(st_nlink).rjust(5) + ' '
836+    un = str(st_uid)
837+    l += un.ljust(9)
838+    gr = str(st_gid)
839+    l += gr.ljust(9)
840+    sz = str(st_size)
841+    l += sz.rjust(8)
842+    l += ' '
843+    sixmo = 60 * 60 * 24 * 7 * 26
844+    if st_mtime + sixmo < time(): # last edited more than 6mo ago
845+        l += strftime("%b %d  %Y ", localtime(st_mtime))
846+    else:
847+        l += strftime("%b %d %H:%M ", localtime(st_mtime))
848+    l += name
849+    return l
850 
851hunk ./src/allmydata/frontends/sftpd.py 775
852-class BadRemoveRequest(Exception):
853-    pass
854 
855 class SFTPHandler:
856     implements(ISFTPServer)
857hunk ./src/allmydata/frontends/sftpd.py 779
858     def __init__(self, user):
859-        print "Creating SFTPHandler from", user
860+        if debug: print "Creating SFTPHandler from", user
861+        self.check_abort = user.check_abort
862         self.client = user.client
863         self.root = user.root
864         self.username = user.username
865hunk ./src/allmydata/frontends/sftpd.py 787
866         self.convergence = user.convergence
867 
868     def gotVersion(self, otherVersion, extData):
869+        if debug: print "GOTVERSION %r %r" % (otherVersion, extData)
870         return {}
871 
872hunk ./src/allmydata/frontends/sftpd.py 790
873-    def openFile(self, filename, flags, attrs):
874-        f = "|".join([f for f in
875-                      [(flags & FXF_READ) and "FXF_READ" or None,
876-                       (flags & FXF_WRITE) and "FXF_WRITE" or None,
877-                       (flags & FXF_APPEND) and "FXF_APPEND" or None,
878-                       (flags & FXF_CREAT) and "FXF_CREAT" or None,
879-                       (flags & FXF_TRUNC) and "FXF_TRUNC" or None,
880-                       (flags & FXF_EXCL) and "FXF_EXCL" or None,
881-                      ]
882-                      if f])
883-        print "OPENFILE", filename, flags, f, attrs
884+    def openFile(self, pathstring, flags, attrs):
885+        if debug: print "OPENFILE %r %r %r %r" % (pathstring, flags, _repr_flags(flags), attrs)
886         # this is used for both reading and writing.
887 
888hunk ./src/allmydata/frontends/sftpd.py 794
889-#        createPlease = False
890-#        exclusive = False
891-#        openFlags = 0
892-#
893-#        if flags & FXF_READ == FXF_READ and flags & FXF_WRITE == 0:
894-#            openFlags = os.O_RDONLY
895-#        if flags & FXF_WRITE == FXF_WRITE and flags & FXF_READ == 0:
896-#            createPlease = True
897-#            openFlags = os.O_WRONLY
898-#        if flags & FXF_WRITE == FXF_WRITE and flags & FXF_READ == FXF_READ:
899-#            createPlease = True
900-#            openFlags = os.O_RDWR
901-#        if flags & FXF_APPEND == FXF_APPEND:
902-#            createPlease = True
903-#            openFlags |= os.O_APPEND
904-#        if flags & FXF_CREAT == FXF_CREAT:
905-#            createPlease = True
906-#            openFlags |= os.O_CREAT
907-#        if flags & FXF_TRUNC == FXF_TRUNC:
908-#            openFlags |= os.O_TRUNC
909-#        if flags & FXF_EXCL == FXF_EXCL:
910-#            exclusive = True
911+        # First exclude invalid combinations of flags.
912 
913         # /usr/bin/sftp 'get' gives us FXF_READ, while 'put' on a new file
914hunk ./src/allmydata/frontends/sftpd.py 797
915-        # gives FXF_WRITE,FXF_CREAT,FXF_TRUNC . I'm guessing that 'put' on an
916+        # gives FXF_WRITE | FXF_CREAT | FXF_TRUNC. I'm guessing that 'put' on an
917         # existing file gives the same.
918 
919hunk ./src/allmydata/frontends/sftpd.py 800
920-        path = self._convert_sftp_path(filename)
921+        if not (flags & (FXF_READ | FXF_WRITE)):
922+            raise SFTPError(FX_BAD_MESSAGE,
923+                            "invalid file open flags: at least one of FXF_READ and FXF_WRITE must be set")
924 
925hunk ./src/allmydata/frontends/sftpd.py 804
926-        if flags & FXF_READ:
927-            if flags & FXF_WRITE:
928-                raise NotImplementedError
929-            d = self._get_node_and_metadata_for_path(path)
930-            d.addCallback(lambda (node,metadata): ReadFile(node))
931-            d.addErrback(self._convert_error)
932-            return d
933+        if not (flags & FXF_CREAT):
934+            if flags & FXF_TRUNC:
935+                raise SFTPError(FX_BAD_MESSAGE,
936+                                "invalid file open flags: FXF_TRUNC cannot be set without FXF_CREAT")
937+            if flags & FXF_EXCL:
938+                raise SFTPError(FX_BAD_MESSAGE,
939+                                "invalid file open flags: FXF_EXCL cannot be set without FXF_CREAT")
940+
941+        path = self._path_from_string(pathstring)
942+        if not path:
943+            raise SFTPError(FX_NO_SUCH_FILE, "path cannot be empty")
944 
945hunk ./src/allmydata/frontends/sftpd.py 816
946-        if flags & FXF_WRITE:
947-            if not (flags & FXF_CREAT) or not (flags & FXF_TRUNC):
948-                raise NotImplementedError
949+        # The combination of flags is potentially valid. Now there are two major cases:
950+        #
951+        #  1. The path is specified as /uri/FILECAP, with no parent directory.
952+        #     If the FILECAP is mutable and writeable, then we can open it in write-only
953+        #     or read/write mode (non-exclusively), otherwise we can only open it in
954+        #     read-only mode. The open should succeed immediately as long as FILECAP is
955+        #     a valid known filecap that grants the required permission.
956+        #
957+        #  2. The path is specified relative to a parent. We find the parent dirnode and
958+        #     get the child's URI and metadata if it exists. There are four subcases:
959+        #       a. the child does not exist: FXF_CREAT must be set, and we must be able
960+        #          to write to the parent directory.
961+        #       b. the child exists but is not a valid known filecap: fail
962+        #       c. the child is mutable: if we are trying to open it write-only or
963+        #          read/write, then we must be able to write to the file.
964+        #       d. the child is immutable: if we are trying to open it write-only or
965+        #          read/write, then we must be able to write to the parent directory.
966+        #
967+        # To reduce latency, open succeeds as soon as these conditions are met, even
968+        # though there might be a failure in downloading the existing file or uploading
969+        # a new one.
970+        #
971+        # Note that the permission checks below are for more precise error reporting on
972+        # the open call; later operations would fail even if we did not make these checks.
973+
974+        stash = {'parent': None}
975+        d = self._get_root(path)
976+        def _got_root((root, path)):
977+            if root.is_unknown():
978+                raise SFTPError(FX_PERMISSION_DENIED,
979+                                "cannot open an unknown cap (or child of an unknown directory). "
980+                                "Upgrading the gateway to a later Tahoe-LAFS version may help")
981             if not path:
982hunk ./src/allmydata/frontends/sftpd.py 849
983-                raise PermissionError("cannot STOR to root directory")
984-            childname = path[-1]
985-            d = self._get_root(path)
986-            def _got_root((root, path)):
987-                if not path:
988-                    raise PermissionError("cannot STOR to root directory")
989-                return root.get_child_at_path(path[:-1])
990-            d.addCallback(_got_root)
991-            def _got_parent(parent):
992-                return WriteFile(parent, childname, self.convergence)
993-            d.addCallback(_got_parent)
994-            return d
995-        raise NotImplementedError
996+                # case 1
997+                if not IFileNode.providedBy(root):
998+                    raise SFTPError(FX_PERMISSION_DENIED,
999+                                    "cannot open a directory cap")
1000+                if (flags & FXF_WRITE) and root.is_readonly():
1001+                    raise SFTPError(FX_PERMISSION_DENIED,
1002+                                    "cannot write to a non-writeable filecap without a parent directory")
1003+                if flags & FXF_EXCL:
1004+                    raise SFTPError(FX_PERMISSION_DENIED,
1005+                                    "cannot create a file exclusively when it already exists")
1006+
1007+                return _make_sftp_file(self.check_abort, flags, self.convergence, filenode=root)
1008+            else:
1009+                # case 2
1010+                childname = path[-1]
1011+                if debug: print "case 2: childname = %r, path[:-1] = %r" % (childname, path[:-1])
1012+                d2 = root.get_child_at_path(path[:-1])
1013+                def _got_parent(parent):
1014+                    if debug: print "_got_parent(%r)" % (parent,)
1015+                    stash['parent'] = parent
1016+
1017+                    if flags & FXF_EXCL:
1018+                        # FXF_EXCL means that the link to the file (not the file itself) must
1019+                        # be created atomically wrt updates by this storage client.
1020+                        # That is, we need to create the link before returning success to the
1021+                        # SFTP open request (and not just on close, as would normally be the
1022+                        # case). We make the link initially point to a zero-length LIT file,
1023+                        # which is consistent with what might happen on a POSIX filesystem.
1024+
1025+                        if parent.is_readonly():
1026+                            raise SFTPError(FX_PERMISSION_DENIED,
1027+                                            "cannot create a file exclusively when the parent directory is read-only")
1028+
1029+                        # 'overwrite=False' ensures failure if the link already exists.
1030+                        # FIXME: should use a single call to set_uri and return (child, metadata) (#1035)
1031+                        d3 = parent.set_uri(childname, None, "URI:LIT:", overwrite=False)
1032+                        def _seturi_done(child):
1033+                            stash['child'] = child
1034+                            return parent.get_metadata_for(childname)
1035+                        d3.addCallback(_seturi_done)
1036+                        d3.addCallback(lambda metadata: (stash['child'], metadata))
1037+                        return d3
1038+                    else:
1039+                        if debug: print "get_child_and_metadata"
1040+                        return parent.get_child_and_metadata(childname)
1041+                d2.addCallback(_got_parent)
1042+
1043+                def _got_child( (filenode, metadata) ):
1044+                    if debug: print "_got_child((%r, %r))" % (filenode, metadata)
1045+                    parent = stash['parent']
1046+                    if filenode.is_unknown():
1047+                        raise SFTPError(FX_PERMISSION_DENIED,
1048+                                        "cannot open an unknown cap. Upgrading the gateway "
1049+                                        "to a later Tahoe-LAFS version may help")
1050+                    if not IFileNode.providedBy(filenode):
1051+                        raise SFTPError(FX_PERMISSION_DENIED,
1052+                                        "cannot open a directory as if it were a file")
1053+                    if (flags & FXF_WRITE) and filenode.is_mutable() and filenode.is_readonly():
1054+                        raise SFTPError(FX_PERMISSION_DENIED,
1055+                                        "cannot open a read-only mutable file for writing")
1056+                    if (flags & FXF_WRITE) and parent.is_readonly():
1057+                        raise SFTPError(FX_PERMISSION_DENIED,
1058+                                        "cannot open a file for writing when the parent directory is read-only")
1059+
1060+                    return _make_sftp_file(self.check_abort, flags, self.convergence, parent=parent,
1061+                                           childname=childname, filenode=filenode, metadata=metadata)
1062+                def _no_child(f):
1063+                    if debug: print "_no_child(%r)" % (f,)
1064+                    f.trap(NoSuchChildError)
1065+                    parent = stash['parent']
1066+                    if parent is None:
1067+                        return f
1068+                    if not (flags & FXF_CREAT):
1069+                        raise SFTPError(FX_NO_SUCH_FILE,
1070+                                        "the file does not exist, and was not opened with the creation (CREAT) flag")
1071+                    if parent.is_readonly():
1072+                        raise SFTPError(FX_PERMISSION_DENIED,
1073+                                        "cannot create a file when the parent directory is read-only")
1074+
1075+                    return _make_sftp_file(self.check_abort, flags, self.convergence, parent=parent,
1076+                                           childname=childname)
1077+                d2.addCallbacks(_got_child, _no_child)
1078+                return d2
1079+        d.addCallback(_got_root)
1080+        d.addErrback(_raise_error)
1081+        return d
1082+
1083+    def removeFile(self, pathstring):
1084+        if debug: print "REMOVEFILE %r" % (pathstring,)
1085+        path = self._path_from_string(pathstring)
1086+        return self._remove_object(path, must_be_file=True)
1087 
1088hunk ./src/allmydata/frontends/sftpd.py 941
1089-    def removeFile(self, path):
1090-        print "REMOVEFILE", path
1091-        path = self._convert_sftp_path(path)
1092-        return self._remove_thing(path, must_be_file=True)
1093+    def renameFile(self, oldpathstring, newpathstring):
1094+        if debug: print "RENAMEFILE %r %r" % (oldpathstring, newpathstring)
1095+        fromPath = self._path_from_string(oldpathstring)
1096+        toPath = self._path_from_string(newpathstring)
1097 
1098hunk ./src/allmydata/frontends/sftpd.py 946
1099-    def renameFile(self, oldpath, newpath):
1100-        print "RENAMEFILE", oldpath, newpath
1101-        fromPath = self._convert_sftp_path(oldpath)
1102-        toPath = self._convert_sftp_path(newpath)
1103         # the target directory must already exist
1104hunk ./src/allmydata/frontends/sftpd.py 947
1105-        d = self._get_parent(fromPath)
1106-        def _got_from_parent( (fromparent, childname) ):
1107-            d = self._get_parent(toPath)
1108-            d.addCallback(lambda (toparent, tochildname):
1109-                          fromparent.move_child_to(childname,
1110-                                                   toparent, tochildname,
1111-                                                   overwrite=False))
1112+        d = deferredutil.gatherResults([self._get_parent(fromPath),
1113+                                        self._get_parent(toPath)])
1114+        def _got( (fromPair, toPair) ):
1115+            (fromParent, fromChildname) = fromPair
1116+            (toParent, toChildname) = toPair
1117+
1118+            # <http://tools.ietf.org/html/draft-ietf-secsh-filexfer-02#section-6.5>
1119+            # "It is an error if there already exists a file with the name specified
1120+            #  by newpath."
1121+            # FIXME: use move_child_to_path to avoid possible data loss due to #943
1122+            d = fromParent.move_child_to(fromChildname, toParent, toChildname, overwrite=False)
1123+            #d = parent.move_child_to_path(fromChildname, toRoot, toPath[:-1],
1124+            #                              toPath[-1], overwrite=False)
1125             return d
1126hunk ./src/allmydata/frontends/sftpd.py 961
1127-        d.addCallback(_got_from_parent)
1128-        d.addErrback(self._convert_error)
1129+        d.addCallback(_got)
1130+        d.addErrback(_raise_error)
1131         return d
1132 
1133hunk ./src/allmydata/frontends/sftpd.py 965
1134-    def makeDirectory(self, path, attrs):
1135-        print "MAKEDIRECTORY", path, attrs
1136-        # TODO: extract attrs["mtime"], use it to set the parent metadata.
1137-        # Maybe also copy attrs["ext_*"] .
1138-        path = self._convert_sftp_path(path)
1139+    def makeDirectory(self, pathstring, attrs):
1140+        if debug: print "MAKEDIRECTORY %r %r" % (pathstring, attrs)
1141+        path = self._path_from_string(pathstring)
1142+        metadata = self._attrs_to_metadata(attrs)
1143         d = self._get_root(path)
1144         d.addCallback(lambda (root,path):
1145hunk ./src/allmydata/frontends/sftpd.py 971
1146-                      self._get_or_create_directories(root, path))
1147+                      self._get_or_create_directories(root, path, metadata))
1148+        d.addErrback(_raise_error)
1149         return d
1150 
1151hunk ./src/allmydata/frontends/sftpd.py 975
1152-    def _get_or_create_directories(self, node, path):
1153+    def _get_or_create_directories(self, node, path, metadata):
1154         if not IDirectoryNode.providedBy(node):
1155             # unfortunately it is too late to provide the name of the
1156hunk ./src/allmydata/frontends/sftpd.py 978
1157-            # blocking directory in the error message.
1158-            raise ExistingChildError("cannot create directory because there "
1159-                                     "is a file in the way") # close enough
1160+            # blocking file in the error message.
1161+            raise SFTPError(FX_PERMISSION_DENIED,
1162+                            "cannot create directory because there "
1163+                            "is a file in the way") # close enough
1164         if not path:
1165             return defer.succeed(node)
1166         d = node.get(path[0])
1167hunk ./src/allmydata/frontends/sftpd.py 989
1168             f.trap(NoSuchChildError)
1169             return node.create_subdirectory(path[0])
1170         d.addErrback(_maybe_create)
1171-        d.addCallback(self._get_or_create_directories, path[1:])
1172+        d.addCallback(self._get_or_create_directories, path[1:], metadata)
1173+        d.addErrback(_raise_error)
1174         return d
1175 
1176hunk ./src/allmydata/frontends/sftpd.py 993
1177-    def removeDirectory(self, path):
1178-        print "REMOVEDIRECTORY", path
1179-        path = self._convert_sftp_path(path)
1180-        return self._remove_thing(path, must_be_directory=True)
1181+    def removeDirectory(self, pathstring):
1182+        if debug: print "REMOVEDIRECTORY %r" % (pathstring,)
1183+        path = self._path_from_string(pathstring)
1184+        return self._remove_object(path, must_be_directory=True)
1185 
1186hunk ./src/allmydata/frontends/sftpd.py 998
1187-    def _remove_thing(self, path, must_be_directory=False, must_be_file=False):
1188+    def _remove_object(self, path, must_be_directory=False, must_be_file=False):
1189         d = defer.maybeDeferred(self._get_parent, path)
1190hunk ./src/allmydata/frontends/sftpd.py 1000
1191-        def _convert_error(f):
1192-            f.trap(NoParentError)
1193-            raise PermissionError("cannot delete root directory")
1194-        d.addErrback(_convert_error)
1195         def _got_parent( (parent, childname) ):
1196hunk ./src/allmydata/frontends/sftpd.py 1001
1197-            d = parent.get(childname)
1198+            d2 = parent.get(childname)
1199             def _got_child(child):
1200hunk ./src/allmydata/frontends/sftpd.py 1003
1201-                if must_be_directory and not IDirectoryNode.providedBy(child):
1202-                    raise BadRemoveRequest("rmdir called on a file")
1203+                # Unknown children can be removed by either removeFile or removeDirectory.
1204+                if must_be_directory and IFileNode.providedBy(child):
1205+                    raise SFTPError(FX_PERMISSION_DENIED, "rmdir called on a file")
1206                 if must_be_file and IDirectoryNode.providedBy(child):
1207hunk ./src/allmydata/frontends/sftpd.py 1007
1208-                    raise BadRemoveRequest("rmfile called on a directory")
1209+                    raise SFTPError(FX_PERMISSION_DENIED, "rmfile called on a directory")
1210                 return parent.delete(childname)
1211hunk ./src/allmydata/frontends/sftpd.py 1009
1212-            d.addCallback(_got_child)
1213-            d.addErrback(self._convert_error)
1214-            return d
1215+            d2.addCallback(_got_child)
1216+            return d2
1217         d.addCallback(_got_parent)
1218hunk ./src/allmydata/frontends/sftpd.py 1012
1219+        d.addErrback(_raise_error)
1220         return d
1221 
1222hunk ./src/allmydata/frontends/sftpd.py 1015
1223-
1224-    def openDirectory(self, path):
1225-        print "OPENDIRECTORY", path
1226-        path = self._convert_sftp_path(path)
1227+    def openDirectory(self, pathstring):
1228+        if debug: print "OPENDIRECTORY %r" % (pathstring,)
1229+        path = self._path_from_string(pathstring)
1230+        if debug: print " PATH %r" % (path,)
1231         d = self._get_node_and_metadata_for_path(path)
1232hunk ./src/allmydata/frontends/sftpd.py 1020
1233-        d.addCallback(lambda (dirnode,metadata): dirnode.list())
1234-        def _render(children):
1235-            results = []
1236-            for filename, (node, metadata) in children.iteritems():
1237-                s = FakeStat()
1238-                if IDirectoryNode.providedBy(node):
1239-                    s.st_mode = 040700
1240-                    s.st_size = 0
1241-                else:
1242-                    s.st_mode = 0100600
1243-                    s.st_size = node.get_size()
1244-                s.st_nlink = 1
1245-                s.st_uid = 0
1246-                s.st_gid = 0
1247-                s.st_mtime = int(metadata.get("mtime", 0))
1248-                longname = ls.lsLine(filename.encode("utf-8"), s)
1249-                attrs = self._populate_attrs(node, metadata)
1250-                results.append( (filename.encode("utf-8"), longname, attrs) )
1251-            return StoppableList(results)
1252-        d.addCallback(_render)
1253+        def _list( (dirnode, metadata) ):
1254+            if dirnode.is_unknown():
1255+                raise SFTPError(FX_PERMISSION_DENIED,
1256+                                "cannot list an unknown cap as a directory. Upgrading the gateway "
1257+                                "to a later Tahoe-LAFS version may help")
1258+            if not IDirectoryNode.providedBy(dirnode):
1259+                raise SFTPError(FX_PERMISSION_DENIED,
1260+                                "cannot list a file as if it were a directory")
1261+            d2 = dirnode.list()
1262+            def _render(children):
1263+                parent_writeable = not dirnode.is_readonly()
1264+                results = []
1265+                for filename, (node, metadata) in children.iteritems():
1266+                    # The file size may be cached or absent.
1267+                    writeable = parent_writeable and (node.is_unknown() or
1268+                                                      not (node.is_mutable() and node.is_readonly()))
1269+                    attrs = _populate_attrs(node, metadata, writeable)
1270+                    filename_utf8 = filename.encode('utf-8')
1271+                    longname = lsLine(filename_utf8, attrs)
1272+                    results.append( (filename_utf8, longname, attrs) )
1273+                return StoppableList(results)
1274+            d2.addCallback(_render)
1275+            return d2
1276+        d.addCallback(_list)
1277+        d.addErrback(_raise_error)
1278         return d
1279 
1280hunk ./src/allmydata/frontends/sftpd.py 1047
1281-    def getAttrs(self, path, followLinks):
1282-        print "GETATTRS", path, followLinks
1283-        # from ftp.stat
1284-        d = self._get_node_and_metadata_for_path(self._convert_sftp_path(path))
1285-        def _render((node,metadata)):
1286-            return self._populate_attrs(node, metadata)
1287+    def getAttrs(self, pathstring, followLinks):
1288+        if debug: print "GETATTRS %r %r" % (pathstring, followLinks)
1289+        d = self._get_node_and_metadata_for_path(self._path_from_string(pathstring))
1290+        def _render( (node, metadata) ):
1291+            # When asked about a specific file, report its current size.
1292+            # TODO: the modification time for a mutable file should be
1293+            # reported as the update time of the best version. But that
1294+            # information isn't currently stored in mutable shares, I think.
1295+            d2 = node.get_current_size()
1296+            def _got_size(size):
1297+                # FIXME: pass correct value for writeable
1298+                attrs = _populate_attrs(node, metadata, False, size=size)
1299+                return attrs
1300+            d2.addCallback(_got_size)
1301+            return d2
1302         d.addCallback(_render)
1303hunk ./src/allmydata/frontends/sftpd.py 1063
1304-        d.addErrback(self._convert_error)
1305+        d.addErrback(_raise_error)
1306         def _done(res):
1307hunk ./src/allmydata/frontends/sftpd.py 1065
1308-            print " DONE", res
1309+            if debug: print " DONE %r" % (res,)
1310             return res
1311         d.addBoth(_done)
1312         return d
1313hunk ./src/allmydata/frontends/sftpd.py 1070
1314 
1315-    def _convert_sftp_path(self, pathstring):
1316-        assert pathstring[0] == "/"
1317+    def setAttrs(self, pathstring, attrs):
1318+        if debug: print "SETATTRS %r %r" % (pathstring, attrs)
1319+        if "size" in attrs:
1320+            # this would require us to download and re-upload the truncated/extended
1321+            # file contents
1322+            raise SFTPError(FX_OP_UNSUPPORTED, "setAttrs wth size attribute")
1323+        return None
1324+
1325+    def readLink(self, pathstring):
1326+        if debug: print "READLINK %r" % (pathstring,)
1327+        raise SFTPError(FX_OP_UNSUPPORTED, "readLink")
1328+
1329+    def makeLink(self, linkPathstring, targetPathstring):
1330+        if debug: print "MAKELINK %r %r" % (linkPathstring, targetPathstring)
1331+        raise SFTPError(FX_OP_UNSUPPORTED, "makeLink")
1332+
1333+    def extendedRequest(self, extendedName, extendedData):
1334+        if debug: print "EXTENDEDREQUEST %r %r" % (extendedName, extendedData)
1335+        # Client 'df' command requires 'statvfs@openssh.com' extension
1336+        # (but there's little point to implementing that since we would only
1337+        # have faked values to report).
1338+        raise SFTPError(FX_OP_UNSUPPORTED, "extendedRequest %r" % extendedName)
1339+
1340+    def realPath(self, pathstring):
1341+        if debug: print "REALPATH %r" % (pathstring,)
1342+        return "/" + "/".join(self._path_from_string(pathstring))
1343+
1344+    def _path_from_string(self, pathstring):
1345+        if debug: print "CONVERT %r" % (pathstring,)
1346+
1347+        # The home directory is the root directory.
1348         pathstring = pathstring.strip("/")
1349hunk ./src/allmydata/frontends/sftpd.py 1102
1350-        if pathstring == "":
1351-            path = []
1352+        if pathstring == "" or pathstring == ".":
1353+            path_utf8 = []
1354         else:
1355hunk ./src/allmydata/frontends/sftpd.py 1105
1356-            path = pathstring.split("/")
1357-        print "CONVERT", pathstring, path
1358-        path = [unicode(p) for p in path]
1359+            path_utf8 = pathstring.split("/")
1360+
1361+        # <http://tools.ietf.org/html/draft-ietf-secsh-filexfer-02#section-6.2>
1362+        # "Servers SHOULD interpret a path name component ".." as referring to
1363+        #  the parent directory, and "." as referring to the current directory."
1364+        path = []
1365+        for p_utf8 in path_utf8:
1366+            if p_utf8 == "..":
1367+                # ignore excess .. components at the root
1368+                if len(path) > 0:
1369+                    path = path[:-1]
1370+            elif p_utf8 != ".":
1371+                try:
1372+                    p = p_utf8.decode('utf-8', 'strict')
1373+                except UnicodeError:
1374+                    raise SFTPError(FX_NO_SUCH_FILE, "path could not be decoded as UTF-8")
1375+                path.append(p)
1376+
1377+        if debug: print " PATH %r" % (path,)
1378         return path
1379 
1380     def _get_node_and_metadata_for_path(self, path):
1381hunk ./src/allmydata/frontends/sftpd.py 1128
1382         d = self._get_root(path)
1383-        def _got_root((root,path)):
1384-            print "ROOT", root
1385-            print "PATH", path
1386+        def _got_root( (root, path) ):
1387+            if debug: print " ROOT %r" % (root,)
1388+            if debug: print " PATH %r" % (path,)
1389             if path:
1390                 return root.get_child_and_metadata_at_path(path)
1391             else:
1392hunk ./src/allmydata/frontends/sftpd.py 1140
1393 
1394     def _get_root(self, path):
1395         # return (root, remaining_path)
1396-        path = [unicode(p) for p in path]
1397-        if path and path[0] == "uri":
1398+        if path and path[0] == u"uri":
1399             d = defer.maybeDeferred(self.client.create_node_from_uri,
1400                                     str(path[1]))
1401             d.addCallback(lambda root: (root, path[2:]))
1402hunk ./src/allmydata/frontends/sftpd.py 1148
1403             d = defer.succeed((self.root,path))
1404         return d
1405 
1406-    def _populate_attrs(self, childnode, metadata):
1407-        attrs = {}
1408-        attrs["uid"] = 1000
1409-        attrs["gid"] = 1000
1410-        attrs["atime"] = 0
1411-        attrs["mtime"] = int(metadata.get("mtime", 0))
1412-        isdir = bool(IDirectoryNode.providedBy(childnode))
1413-        if isdir:
1414-            attrs["size"] = 1
1415-            # the permissions must have the extra bits (040000 or 0100000),
1416-            # otherwise the client will not call openDirectory
1417-            attrs["permissions"] = 040700 # S_IFDIR
1418-        else:
1419-            attrs["size"] = childnode.get_size()
1420-            attrs["permissions"] = 0100600 # S_IFREG
1421-        return attrs
1422-
1423-    def _convert_error(self, f):
1424-        if f.check(NoSuchChildError):
1425-            childname = f.value.args[0].encode("utf-8")
1426-            raise SFTPError(FX_NO_SUCH_FILE, childname)
1427-        if f.check(ExistingChildError):
1428-            msg = f.value.args[0].encode("utf-8")
1429-            raise SFTPError(FX_FILE_ALREADY_EXISTS, msg)
1430-        if f.check(PermissionError):
1431-            raise SFTPError(FX_PERMISSION_DENIED, str(f.value))
1432-        if f.check(NotImplementedError):
1433-            raise SFTPError(FX_OP_UNSUPPORTED, str(f.value))
1434-        return f
1435-
1436-
1437-    def setAttrs(self, path, attrs):
1438-        print "SETATTRS", path, attrs
1439-        # ignored
1440-        return None
1441-
1442-    def readLink(self, path):
1443-        print "READLINK", path
1444-        raise NotImplementedError
1445-
1446-    def makeLink(self, linkPath, targetPath):
1447-        print "MAKELINK", linkPath, targetPath
1448-        raise NotImplementedError
1449-
1450-    def extendedRequest(self, extendedName, extendedData):
1451-        print "EXTENDEDREQUEST", extendedName, extendedData
1452-        # client 'df' command requires 'statvfs@openssh.com' extension
1453-        raise NotImplementedError
1454-    def realPath(self, path):
1455-        print "REALPATH", path
1456-        if path == ".":
1457-            return "/"
1458-        return path
1459-
1460-
1461     def _get_parent(self, path):
1462         # fire with (parentnode, childname)
1463hunk ./src/allmydata/frontends/sftpd.py 1150
1464-        path = [unicode(p) for p in path]
1465         if not path:
1466hunk ./src/allmydata/frontends/sftpd.py 1151
1467-            raise NoParentError
1468+            def _nosuch(): raise SFTPError(FX_NO_SUCH_FILE, "path does not exist")
1469+            return defer.execute(_nosuch)
1470+
1471         childname = path[-1]
1472hunk ./src/allmydata/frontends/sftpd.py 1155
1473+        assert isinstance(childname, unicode), repr(childname)
1474         d = self._get_root(path)
1475hunk ./src/allmydata/frontends/sftpd.py 1157
1476-        def _got_root((root, path)):
1477+        def _got_root( (root, path) ):
1478             if not path:
1479hunk ./src/allmydata/frontends/sftpd.py 1159
1480-                raise NoParentError
1481+                raise SFTPError(FX_NO_SUCH_FILE, "path does not exist")
1482             return root.get_child_at_path(path[:-1])
1483         d.addCallback(_got_root)
1484         def _got_parent(parent):
1485hunk ./src/allmydata/frontends/sftpd.py 1167
1486         d.addCallback(_got_parent)
1487         return d
1488 
1489+    def _attrs_to_metadata(self, attrs):
1490+        metadata = {}
1491+
1492+        for key in attrs:
1493+            if key == "mtime" or key == "ctime" or key == "createtime":
1494+                metadata[key] = long(attrs[key])
1495+            elif key.startswith("ext_"):
1496+                metadata[key] = str(attrs[key])
1497+
1498+        return metadata
1499+
1500 
1501 # if you have an SFTPUser, and you want something that provides ISFTPServer,
1502 # then you get SFTPHandler(user)
1503hunk ./src/allmydata/frontends/sftpd.py 1183
1504 components.registerAdapter(SFTPHandler, SFTPUser, ISFTPServer)
1505 
1506-from auth import AccountURLChecker, AccountFileChecker, NeedRootcapLookupScheme
1507+from allmydata.frontends.auth import AccountURLChecker, AccountFileChecker, NeedRootcapLookupScheme
1508 
1509 class Dispatcher:
1510     implements(portal.IRealm)
1511hunk ./src/allmydata/frontends/sftpd.py 1194
1512         assert interface == IConchUser
1513         rootnode = self.client.create_node_from_uri(avatarID.rootcap)
1514         convergence = self.client.convergence
1515-        s = SFTPUser(self.client, rootnode, avatarID.username, convergence)
1516-        def logout(): pass
1517+        logged_out = {'flag': False}
1518+        def check_abort():
1519+            return logged_out['flag']
1520+        def logout():
1521+            logged_out['flag'] = True
1522+        s = SFTPUser(check_abort, self.client, rootnode, avatarID.username, convergence)
1523         return (interface, s, logout)
1524 
1525 class SFTPServer(service.MultiService):
1526}
1527[Tests for new SFTP implementation
1528david-sarah@jacaranda.org**20100512060552
1529 Ignore-this: 20308d4a59b3ebc868aad55ae0a7a981
1530] {
1531addfile ./src/allmydata/test/test_sftp.py
1532hunk ./src/allmydata/test/test_sftp.py 1
1533+
1534+import re
1535+from stat import S_IFREG, S_IFDIR
1536+
1537+from twisted.trial import unittest
1538+from twisted.internet import defer
1539+from twisted.python.failure import Failure
1540+
1541+sftp = None
1542+sftpd = None
1543+have_pycrypto = False
1544+try:
1545+    from Crypto import Util
1546+    Util  # hush pyflakes
1547+    have_pycrypto = True
1548+except ImportError:
1549+    pass
1550+
1551+if have_pycrypto:
1552+    from twisted.conch.ssh import filetransfer as sftp
1553+    from allmydata.frontends import sftpd
1554+
1555+# FIXME remove this
1556+#from twisted.internet.base import DelayedCall
1557+#DelayedCall.debug = True
1558+
1559+import sys, traceback
1560+
1561+"""
1562+def trace_exceptions(frame, event, arg):
1563+    if event != 'exception':
1564+        return
1565+    co = frame.f_code
1566+    func_name = co.co_name
1567+    line_no = frame.f_lineno
1568+    filename = co.co_filename
1569+    exc_type, exc_value, exc_traceback = arg
1570+    print 'Tracing exception: %r %r on line %r of %r in %r' % \
1571+        (exc_type.__name__, exc_value, line_no, func_name, filename)
1572+
1573+def trace_calls(frame, event, arg):
1574+    if event != 'call':
1575+        return
1576+    return trace_exceptions
1577+
1578+sys.settrace(trace_calls)
1579+"""
1580+
1581+timeout = 30
1582+
1583+from allmydata.interfaces import IDirectoryNode, ExistingChildError, NoSuchChildError
1584+from allmydata.mutable.common import NotWriteableError
1585+
1586+from allmydata.util.consumer import download_to_data
1587+from allmydata.immutable import upload
1588+from allmydata.test.no_network import GridTestMixin
1589+from allmydata.test.common import ShouldFailMixin
1590+
1591+class Handler(GridTestMixin, ShouldFailMixin, unittest.TestCase):
1592+    """This is a no-network unit test of the SFTPHandler class."""
1593+
1594+    if not have_pycrypto:
1595+        skip = "SFTP support requires pycrypto, which is not installed"
1596+
1597+    def shouldFailWithSFTPError(self, expected_code, which, callable, *args, **kwargs):
1598+        assert isinstance(expected_code, int), repr(expected_code)
1599+        assert isinstance(which, str), repr(which)
1600+        s = traceback.format_stack()
1601+        d = defer.maybeDeferred(callable, *args, **kwargs)
1602+        def _done(res):
1603+            if isinstance(res, Failure):
1604+                res.trap(sftp.SFTPError)
1605+                self.failUnlessEqual(res.value.code, expected_code,
1606+                                     "%s was supposed to raise SFTPError(%d), not SFTPError(%d): %s" %
1607+                                     (which, expected_code, res.value.code, res))
1608+            else:
1609+                print '@' + '@'.join(s)
1610+                self.fail("%s was supposed to raise SFTPError(%d), not get '%s'" %
1611+                          (which, expected_code, res))
1612+        d.addBoth(_done)
1613+        return d
1614+
1615+    def _set_up(self, basedir, num_clients=1, num_servers=10):
1616+        self.basedir = "sftp/" + basedir
1617+        self.set_up_grid(num_clients=num_clients, num_servers=num_servers)
1618+
1619+        def check_abort():
1620+            pass
1621+        self.client = self.g.clients[0]
1622+        self.username = "alice"
1623+        self.convergence = "convergence"
1624+
1625+        d = self.client.create_dirnode()
1626+        def _created_root(node):
1627+            self.root = node
1628+            self.root_uri = node.get_uri()
1629+            self.user = sftpd.SFTPUser(check_abort, self.client, self.root, self.username, self.convergence)
1630+            self.handler = sftpd.SFTPHandler(self.user)
1631+        d.addCallback(_created_root)
1632+        return d
1633+
1634+    def _set_up_tree(self):
1635+        d = self.client.create_mutable_file("mutable file contents")
1636+        d.addCallback(lambda node: self.root.set_node(u"mutable", node))
1637+        def _created_mutable(n):
1638+            self.mutable = n
1639+            self.mutable_uri = n.get_uri()
1640+        d.addCallback(_created_mutable)
1641+
1642+        d.addCallback(lambda ign:
1643+                      self.root._create_and_validate_node(None, self.mutable.get_readonly_uri(), name=u"readonly"))
1644+        d.addCallback(lambda node: self.root.set_node(u"readonly", node))
1645+        def _created_readonly(n):
1646+            self.readonly = n
1647+            self.readonly_uri = n.get_uri()
1648+        d.addCallback(_created_readonly)
1649+
1650+        gross = upload.Data("0123456789" * 101, None)
1651+        d.addCallback(lambda ign: self.root.add_file(u"gro\u00DF", gross))
1652+        def _created_gross(n):
1653+            self.gross = n
1654+            self.gross_uri = n.get_uri()
1655+        d.addCallback(_created_gross)
1656+
1657+        small = upload.Data("0123456789", None)
1658+        d.addCallback(lambda ign: self.root.add_file(u"small", small))
1659+        def _created_small(n):
1660+            self.small = n
1661+            self.small_uri = n.get_uri()
1662+        d.addCallback(_created_small)
1663+
1664+        small2 = upload.Data("Small enough for a LIT too", None)
1665+        d.addCallback(lambda ign: self.root.add_file(u"small2", small2))
1666+        def _created_small2(n):
1667+            self.small2 = n
1668+            self.small2_uri = n.get_uri()
1669+        d.addCallback(_created_small2)
1670+
1671+        empty_litdir_uri = "URI:DIR2-LIT:"
1672+
1673+        # contains one child which is itself also LIT:
1674+        tiny_litdir_uri = "URI:DIR2-LIT:gqytunj2onug64tufqzdcosvkjetutcjkq5gw4tvm5vwszdgnz5hgyzufqydulbshj5x2lbm"
1675+
1676+        unknown_uri = "x-tahoe-crazy://I_am_from_the_future."
1677+
1678+        d.addCallback(lambda ign: self.root._create_and_validate_node(None, empty_litdir_uri, name=u"empty_lit_dir"))
1679+        def _created_empty_lit_dir(n):
1680+            self.empty_lit_dir = n
1681+            self.empty_lit_dir_uri = n.get_uri()
1682+            self.root.set_node(u"empty_lit_dir", n)
1683+        d.addCallback(_created_empty_lit_dir)
1684+
1685+        d.addCallback(lambda ign: self.root._create_and_validate_node(None, tiny_litdir_uri, name=u"tiny_lit_dir"))
1686+        def _created_tiny_lit_dir(n):
1687+            self.tiny_lit_dir = n
1688+            self.tiny_lit_dir_uri = n.get_uri()
1689+            self.root.set_node(u"tiny_lit_dir", n)
1690+        d.addCallback(_created_tiny_lit_dir)
1691+
1692+        d.addCallback(lambda ign: self.root._create_and_validate_node(None, unknown_uri, name=u"unknown"))
1693+        def _created_unknown(n):
1694+            self.unknown = n
1695+            self.unknown_uri = n.get_uri()
1696+            self.root.set_node(u"unknown", n)
1697+        d.addCallback(_created_unknown)
1698+
1699+        d.addCallback(lambda ign: self.root.set_node(u"loop", self.root))
1700+        return d
1701+
1702+    def test_basic(self):
1703+        d = self._set_up("basic")
1704+        def _check(ign):
1705+            # Test operations that have no side-effects, and don't need the tree.
1706+
1707+            version = self.handler.gotVersion(3, {})
1708+            self.failUnless(isinstance(version, dict))
1709+
1710+            self.failUnlessEqual(self.handler._path_from_string(""), [])
1711+            self.failUnlessEqual(self.handler._path_from_string("/"), [])
1712+            self.failUnlessEqual(self.handler._path_from_string("."), [])
1713+            self.failUnlessEqual(self.handler._path_from_string("//"), [])
1714+            self.failUnlessEqual(self.handler._path_from_string("/."), [])
1715+            self.failUnlessEqual(self.handler._path_from_string("/./"), [])
1716+            self.failUnlessEqual(self.handler._path_from_string("foo"), [u"foo"])
1717+            self.failUnlessEqual(self.handler._path_from_string("/foo"), [u"foo"])
1718+            self.failUnlessEqual(self.handler._path_from_string("foo/"), [u"foo"])
1719+            self.failUnlessEqual(self.handler._path_from_string("/foo/"), [u"foo"])
1720+            self.failUnlessEqual(self.handler._path_from_string("foo/bar"), [u"foo", u"bar"])
1721+            self.failUnlessEqual(self.handler._path_from_string("/foo/bar"), [u"foo", u"bar"])
1722+            self.failUnlessEqual(self.handler._path_from_string("foo/bar//"), [u"foo", u"bar"])
1723+            self.failUnlessEqual(self.handler._path_from_string("/foo/bar//"), [u"foo", u"bar"])
1724+            self.failUnlessEqual(self.handler._path_from_string("foo/../bar"), [u"bar"])
1725+            self.failUnlessEqual(self.handler._path_from_string("/foo/../bar"), [u"bar"])
1726+            self.failUnlessEqual(self.handler._path_from_string("../bar"), [u"bar"])
1727+            self.failUnlessEqual(self.handler._path_from_string("/../bar"), [u"bar"])
1728+
1729+            self.failUnlessEqual(self.handler.realPath(""), "/")
1730+            self.failUnlessEqual(self.handler.realPath("/"), "/")
1731+            self.failUnlessEqual(self.handler.realPath("."), "/")
1732+            self.failUnlessEqual(self.handler.realPath("//"), "/")
1733+            self.failUnlessEqual(self.handler.realPath("/."), "/")
1734+            self.failUnlessEqual(self.handler.realPath("/./"), "/")
1735+            self.failUnlessEqual(self.handler.realPath("foo"), "/foo")
1736+            self.failUnlessEqual(self.handler.realPath("/foo"), "/foo")
1737+            self.failUnlessEqual(self.handler.realPath("foo/"), "/foo")
1738+            self.failUnlessEqual(self.handler.realPath("/foo/"), "/foo")
1739+            self.failUnlessEqual(self.handler.realPath("foo/bar"), "/foo/bar")
1740+            self.failUnlessEqual(self.handler.realPath("/foo/bar"), "/foo/bar")
1741+            self.failUnlessEqual(self.handler.realPath("foo/bar//"), "/foo/bar")
1742+            self.failUnlessEqual(self.handler.realPath("/foo/bar//"), "/foo/bar")
1743+            self.failUnlessEqual(self.handler.realPath("foo/../bar"), "/bar")
1744+            self.failUnlessEqual(self.handler.realPath("/foo/../bar"), "/bar")
1745+            self.failUnlessEqual(self.handler.realPath("../bar"), "/bar")
1746+            self.failUnlessEqual(self.handler.realPath("/../bar"), "/bar")
1747+        d.addCallback(_check)
1748+
1749+        d.addCallback(lambda ign:
1750+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "_path_from_string invalid UTF-8",
1751+                                         self.handler._path_from_string, "\xFF"))
1752+        d.addCallback(lambda ign:
1753+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "realPath invalid UTF-8",
1754+                                         self.handler.realPath, "\xFF"))
1755+
1756+        return d
1757+
1758+    def test_raise_error(self):
1759+        self.failUnlessEqual(sftpd._raise_error(None), None)
1760+       
1761+        d = defer.succeed(None)
1762+        d.addCallback(lambda ign:
1763+            self.shouldFailWithSFTPError(sftp.FX_FAILURE, "_raise_error SFTPError",
1764+                                         sftpd._raise_error, Failure(sftp.SFTPError(sftp.FX_FAILURE, "foo"))))
1765+        d.addCallback(lambda ign:
1766+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "_raise_error NoSuchChildError",
1767+                                         sftpd._raise_error, Failure(NoSuchChildError("foo"))))
1768+        d.addCallback(lambda ign:
1769+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "_raise_error ExistingChildError",
1770+                                         sftpd._raise_error, Failure(ExistingChildError("foo"))))
1771+        d.addCallback(lambda ign:
1772+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "_raise_error NotWriteableError",
1773+                                         sftpd._raise_error, Failure(NotWriteableError("foo"))))
1774+        d.addCallback(lambda ign:
1775+            self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "_raise_error NotImplementedError",
1776+                                         sftpd._raise_error, Failure(NotImplementedError("foo"))))
1777+        d.addCallback(lambda ign:
1778+            self.shouldFailWithSFTPError(sftp.FX_EOF, "_raise_error EOFError",
1779+                                         sftpd._raise_error, Failure(EOFError("foo"))))
1780+        d.addCallback(lambda ign:
1781+            self.shouldFailWithSFTPError(sftp.FX_EOF, "_raise_error defer.FirstError",
1782+                                         sftpd._raise_error, Failure(defer.FirstError(
1783+                                                               Failure(sftp.SFTPError(sftp.FX_EOF, "foo")), 0))))
1784+        d.addCallback(lambda ign:
1785+            self.shouldFailWithSFTPError(sftp.FX_FAILURE, "_raise_error AssertionError",
1786+                                         sftpd._raise_error, Failure(AssertionError("foo"))))
1787+
1788+        return d
1789+
1790+    def test_not_implemented(self):
1791+        d = self._set_up("not_implemented")
1792+
1793+        d.addCallback(lambda ign:
1794+            self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "readLink link",
1795+                                         self.handler.readLink, "link"))
1796+        d.addCallback(lambda ign:
1797+            self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "makeLink link file",
1798+                                         self.handler.makeLink, "link", "file"))
1799+        d.addCallback(lambda ign:
1800+            self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "extendedRequest foo bar",
1801+                                         self.handler.extendedRequest, "foo", "bar"))
1802+
1803+        return d
1804+
1805+    def _compareDirLists(self, actual, expected):
1806+       actual_list = sorted(actual)
1807+       expected_list = sorted(expected)
1808+       self.failUnlessEqual(len(actual_list), len(expected_list),
1809+                            "%r is wrong length, expecting %r" % (actual_list, expected_list))
1810+       for (a, b) in zip(actual_list, expected_list):
1811+           (name, text, attrs) = a
1812+           (expected_name, expected_text_re, expected_attrs) = b
1813+           self.failUnlessEqual(name, expected_name)
1814+           self.failUnless(re.match(expected_text_re, text), "%r does not match %r" % (text, expected_text_re))
1815+           # it is ok for there to be extra actual attributes
1816+           # TODO: check times
1817+           for e in expected_attrs:
1818+               self.failUnlessEqual(attrs[e], expected_attrs[e])
1819+
1820+    def test_openDirectory_and_attrs(self):
1821+        d = self._set_up("openDirectory")
1822+        d.addCallback(lambda ign: self._set_up_tree())
1823+
1824+        d.addCallback(lambda ign:
1825+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openDirectory small",
1826+                                         self.handler.openDirectory, "small"))
1827+        d.addCallback(lambda ign:
1828+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openDirectory unknown",
1829+                                         self.handler.openDirectory, "unknown"))
1830+        d.addCallback(lambda ign:
1831+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openDirectory nodir",
1832+                                         self.handler.openDirectory, "nodir"))
1833+        d.addCallback(lambda ign:
1834+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openDirectory nodir/nodir",
1835+                                         self.handler.openDirectory, "nodir/nodir"))
1836+
1837+        gross = u"gro\u00DF".encode("utf-8")
1838+        expected_root = [
1839+            ('empty_lit_dir', r'drwxrwx--- .* \? .* empty_lit_dir$', {'permissions': S_IFDIR | 0770}),
1840+            (gross,           r'-rw-rw---- .* 1010 .* '+gross+'$',   {'permissions': S_IFREG | 0660, 'size': 1010}),
1841+            ('loop',          r'drwxrwx--- .* \? .* loop$',          {'permissions': S_IFDIR | 0770}),
1842+            ('mutable',       r'-rw-rw---- .* \? .* mutable$',       {'permissions': S_IFREG | 0660}),
1843+            ('readonly',      r'-r--r----- .* \? .* readonly$',      {'permissions': S_IFREG | 0440}),
1844+            ('small',         r'-rw-rw---- .* 10 .* small$',         {'permissions': S_IFREG | 0660, 'size': 10}),
1845+            ('small2',        r'-rw-rw---- .* 26 .* small2$',        {'permissions': S_IFREG | 0660, 'size': 26}),
1846+            ('tiny_lit_dir',  r'drwxrwx--- .* \? .* tiny_lit_dir$',  {'permissions': S_IFDIR | 0770}),
1847+            ('unknown',       r'\?--------- .* \? .* unknown$',      {'permissions': 0}),
1848+        ]
1849+
1850+        d.addCallback(lambda ign: self.handler.openDirectory(""))
1851+        d.addCallback(lambda res: self._compareDirLists(res, expected_root))
1852+
1853+        d.addCallback(lambda ign: self.handler.openDirectory("loop"))
1854+        d.addCallback(lambda res: self._compareDirLists(res, expected_root))
1855+
1856+        d.addCallback(lambda ign: self.handler.openDirectory("loop/loop"))
1857+        d.addCallback(lambda res: self._compareDirLists(res, expected_root))
1858+
1859+        d.addCallback(lambda ign: self.handler.openDirectory("empty_lit_dir"))
1860+        d.addCallback(lambda res: self._compareDirLists(res, []))
1861+       
1862+        expected_tiny_lit = [
1863+            ('short', r'-r--r----- .* 8 Jan 01  1970 short$', {'permissions': S_IFREG | 0440, 'size': 8}),
1864+        ]
1865+
1866+        d.addCallback(lambda ign: self.handler.openDirectory("tiny_lit_dir"))
1867+        d.addCallback(lambda res: self._compareDirLists(res, expected_tiny_lit))
1868+
1869+        d.addCallback(lambda ign: self.handler.getAttrs("small", True))
1870+        def _check_attrs(attrs):
1871+            self.failUnlessEqual(attrs['permissions'], S_IFREG | 0440) #FIXME
1872+            self.failUnlessEqual(attrs['size'], 10)
1873+        d.addCallback(_check_attrs)
1874+
1875+        d.addCallback(lambda ign:
1876+            self.failUnlessEqual(self.handler.setAttrs("small", {}), None))
1877+
1878+        d.addCallback(lambda ign:
1879+            self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "setAttrs size",
1880+                                         self.handler.setAttrs, "small", {'size': 0}))
1881+
1882+        return d
1883+
1884+    def test_openFile_read(self):
1885+        d = self._set_up("openFile")
1886+        d.addCallback(lambda ign: self._set_up_tree())
1887+
1888+        d.addCallback(lambda ign:
1889+            self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "openFile small 0",
1890+                                         self.handler.openFile, "small", 0, {}))
1891+
1892+        # attempting to open a non-existent file should fail
1893+        d.addCallback(lambda ign:
1894+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile nofile READ",
1895+                                         self.handler.openFile, "nofile", sftp.FXF_READ, {}))
1896+        d.addCallback(lambda ign:
1897+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile nodir/file READ",
1898+                                         self.handler.openFile, "nodir/file", sftp.FXF_READ, {}))
1899+
1900+        d.addCallback(lambda ign:
1901+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown READ denied",
1902+                                         self.handler.openFile, "unknown", sftp.FXF_READ, {}))
1903+        d.addCallback(lambda ign:
1904+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir READ denied",
1905+                                         self.handler.openFile, "tiny_lit_dir", sftp.FXF_READ, {}))
1906+        d.addCallback(lambda ign:
1907+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown uri READ denied",
1908+                                         self.handler.openFile, "uri/"+self.unknown_uri, sftp.FXF_READ, {}))
1909+        d.addCallback(lambda ign:
1910+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir uri READ denied",
1911+                                         self.handler.openFile, "uri/"+self.tiny_lit_dir_uri, sftp.FXF_READ, {}))
1912+
1913+        # reading an existing file should succeed
1914+        d.addCallback(lambda ign: self.handler.openFile("small", sftp.FXF_READ, {}))
1915+        def _read_small(rf):
1916+            d2 = rf.readChunk(0, 10)
1917+            d2.addCallback(lambda data: self.failUnlessEqual(data, "0123456789"))
1918+
1919+            d2.addCallback(lambda ign: rf.readChunk(2, 6))
1920+            d2.addCallback(lambda data: self.failUnlessEqual(data, "234567"))
1921+
1922+            d2.addCallback(lambda ign: rf.readChunk(8, 4))  # read that starts before EOF is OK
1923+            d2.addCallback(lambda data: self.failUnlessEqual(data, "89"))
1924+
1925+            d2.addCallback(lambda ign:
1926+                self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF (0-byte)",
1927+                                             rf.readChunk, 10, 0))
1928+            d2.addCallback(lambda ign:
1929+                self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF",
1930+                                             rf.readChunk, 10, 1))
1931+            d2.addCallback(lambda ign:
1932+                self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting after EOF",
1933+                                             rf.readChunk, 11, 1))
1934+
1935+            d2.addCallback(lambda ign: rf.getAttrs())
1936+            def _check_attrs(attrs):
1937+                self.failUnlessEqual(attrs['permissions'], S_IFREG | 0440) #FIXME
1938+                self.failUnlessEqual(attrs['size'], 10)
1939+            d2.addCallback(_check_attrs)
1940+
1941+            d2.addCallback(lambda ign:
1942+                self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "writeChunk on read-only handle denied",
1943+                                             rf.writeChunk, 0, "a"))
1944+            d2.addCallback(lambda ign:
1945+                self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "setAttrs on read-only handle denied",
1946+                                             rf.setAttrs, {}))
1947+
1948+            d2.addCallback(lambda ign: rf.close())
1949+
1950+            d2.addCallback(lambda ign:
1951+                self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "readChunk on closed file",
1952+                                             rf.readChunk, 0, 1))
1953+            d2.addCallback(lambda ign:
1954+                self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "getAttrs on closed file",
1955+                                             rf.getAttrs))
1956+
1957+            d2.addCallback(lambda ign: rf.close()) # should be no-op
1958+            return d2
1959+        d.addCallback(_read_small)
1960+
1961+        # repeat for a large file
1962+        gross = u"gro\u00DF".encode("utf-8")
1963+        d.addCallback(lambda ign: self.handler.openFile(gross, sftp.FXF_READ, {}))
1964+        def _read_gross(rf):
1965+            d2 = rf.readChunk(0, 10)
1966+            d2.addCallback(lambda data: self.failUnlessEqual(data, "0123456789"))
1967+
1968+            d2.addCallback(lambda ign: rf.readChunk(2, 6))
1969+            d2.addCallback(lambda data: self.failUnlessEqual(data, "234567"))
1970+
1971+            d2.addCallback(lambda ign: rf.readChunk(1008, 4))  # read that starts before EOF is OK
1972+            d2.addCallback(lambda data: self.failUnlessEqual(data, "89"))
1973+
1974+            d2.addCallback(lambda ign:
1975+                self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF (0-byte)",
1976+                                             rf.readChunk, 1010, 0))
1977+            d2.addCallback(lambda ign:
1978+                self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF",
1979+                                             rf.readChunk, 1010, 1))
1980+            d2.addCallback(lambda ign:
1981+                self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting after EOF",
1982+                                             rf.readChunk, 1011, 1))
1983+
1984+            d2.addCallback(lambda ign: rf.getAttrs())
1985+            def _check_attrs(attrs):
1986+                self.failUnlessEqual(attrs['permissions'], S_IFREG | 0440) #FIXME
1987+                self.failUnlessEqual(attrs['size'], 1010)
1988+            d2.addCallback(_check_attrs)
1989+
1990+            d2.addCallback(lambda ign:
1991+                self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "writeChunk on read-only handle denied",
1992+                                             rf.writeChunk, 0, "a"))
1993+            d2.addCallback(lambda ign:
1994+                self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "setAttrs on read-only handle denied",
1995+                                             rf.setAttrs, {}))
1996+
1997+            d2.addCallback(lambda ign: rf.close())
1998+
1999+            d2.addCallback(lambda ign:
2000+                self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "readChunk on closed file",
2001+                                             rf.readChunk, 0, 1))
2002+            d2.addCallback(lambda ign:
2003+                self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "getAttrs on closed file",
2004+                                             rf.getAttrs))
2005+
2006+            d2.addCallback(lambda ign: rf.close()) # should be no-op
2007+            return d2
2008+        d.addCallback(_read_gross)
2009+
2010+        # reading an existing small file via uri/ should succeed
2011+        d.addCallback(lambda ign: self.handler.openFile("uri/"+self.small_uri, sftp.FXF_READ, {}))
2012+        def _read_small_uri(rf):
2013+            d2 = rf.readChunk(0, 10)
2014+            d2.addCallback(lambda data: self.failUnlessEqual(data, "0123456789"))
2015+            d2.addCallback(lambda ign: rf.close())
2016+            return d2
2017+        d.addCallback(_read_small_uri)
2018+
2019+        # repeat for a large file
2020+        d.addCallback(lambda ign: self.handler.openFile("uri/"+self.gross_uri, sftp.FXF_READ, {}))
2021+        def _read_gross_uri(rf):
2022+            d2 = rf.readChunk(0, 10)
2023+            d2.addCallback(lambda data: self.failUnlessEqual(data, "0123456789"))
2024+            d2.addCallback(lambda ign: rf.close())
2025+            return d2
2026+        d.addCallback(_read_gross_uri)
2027+
2028+        # repeat for a mutable file
2029+        d.addCallback(lambda ign: self.handler.openFile("uri/"+self.mutable_uri, sftp.FXF_READ, {}))
2030+        def _read_mutable_uri(rf):
2031+            d2 = rf.readChunk(0, 100)
2032+            d2.addCallback(lambda data: self.failUnlessEqual(data, "mutable file contents"))
2033+            d2.addCallback(lambda ign: rf.close())
2034+            return d2
2035+        d.addCallback(_read_mutable_uri)
2036+
2037+        return d
2038+
2039+    def test_openFile_write(self):
2040+        d = self._set_up("openFile")
2041+        d.addCallback(lambda ign: self._set_up_tree())
2042+
2043+        d.addCallback(lambda ign:
2044+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile '' WRITE|CREAT|TRUNC",
2045+                                             self.handler.openFile, "", sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
2046+        d.addCallback(lambda ign:
2047+            self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "openFile newfile WRITE|TRUNC",
2048+                                         self.handler.openFile, "newfile", sftp.FXF_WRITE | sftp.FXF_TRUNC, {}))
2049+        d.addCallback(lambda ign:
2050+            self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "openFile small WRITE|EXCL",
2051+                                         self.handler.openFile, "small", sftp.FXF_WRITE | sftp.FXF_EXCL, {}))
2052+        d.addCallback(lambda ign:
2053+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir WRITE",
2054+                                         self.handler.openFile, "tiny_lit_dir", sftp.FXF_WRITE, {}))
2055+        d.addCallback(lambda ign:
2056+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown WRITE",
2057+                                         self.handler.openFile, "unknown", sftp.FXF_WRITE, {}))
2058+        d.addCallback(lambda ign:
2059+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/newfile WRITE|CREAT|TRUNC",
2060+                                         self.handler.openFile, "tiny_lit_dir/newfile",
2061+                                         sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
2062+        d.addCallback(lambda ign:
2063+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/short WRITE",
2064+                                         self.handler.openFile, "tiny_lit_dir/short", sftp.FXF_WRITE, {}))
2065+        d.addCallback(lambda ign:
2066+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/short WRITE|CREAT|EXCL",
2067+                                         self.handler.openFile, "tiny_lit_dir/short",
2068+                                         sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
2069+        d.addCallback(lambda ign:
2070+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile readonly WRITE",
2071+                                         self.handler.openFile, "readonly", sftp.FXF_WRITE, {}))
2072+        d.addCallback(lambda ign:
2073+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small WRITE|CREAT|EXCL",
2074+                                         self.handler.openFile, "small",
2075+                                         sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
2076+        d.addCallback(lambda ign:
2077+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile readonly uri WRITE",
2078+                                         self.handler.openFile, "uri/"+self.readonly_uri, sftp.FXF_WRITE, {}))
2079+        d.addCallback(lambda ign:
2080+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small uri WRITE",
2081+                                         self.handler.openFile, "uri/"+self.small_uri, sftp.FXF_WRITE, {}))
2082+        d.addCallback(lambda ign:
2083+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small uri WRITE|CREAT|TRUNC",
2084+                                         self.handler.openFile, "uri/"+self.small_uri,
2085+                                         sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
2086+        d.addCallback(lambda ign:
2087+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile mutable uri WRITE|CREAT|EXCL",
2088+                                         self.handler.openFile, "uri/"+self.mutable_uri,
2089+                                         sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
2090+
2091+        d.addCallback(lambda ign:
2092+                      self.handler.openFile("newfile", sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
2093+        def _write(wf):
2094+            d2 = wf.writeChunk(0, "0123456789")
2095+            d2.addCallback(lambda res: self.failUnlessEqual(res, None))
2096+
2097+            d2.addCallback(lambda ign: wf.writeChunk(8, "0123"))
2098+            d2.addCallback(lambda ign: wf.writeChunk(13, "abc"))
2099+
2100+            d2.addCallback(lambda ign: wf.getAttrs())
2101+            def _check_attrs(attrs):
2102+                self.failUnlessEqual(attrs['permissions'], S_IFREG | 0440) #FIXME
2103+                self.failUnlessEqual(attrs['size'], 16)
2104+            d2.addCallback(_check_attrs)
2105+
2106+            d2.addCallback(lambda ign: wf.setAttrs({}))
2107+
2108+            d2.addCallback(lambda ign:
2109+                self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "setAttrs with negative size",
2110+                                             wf.setAttrs, {'size': -1}))
2111+
2112+            d2.addCallback(lambda ign: wf.setAttrs({'size': 14}))
2113+            d2.addCallback(lambda ign: wf.getAttrs())
2114+            d2.addCallback(lambda attrs: self.failUnlessEqual(attrs['size'], 14))
2115+
2116+            d2.addCallback(lambda ign:
2117+                self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "readChunk on write-only handle denied",
2118+                                             wf.readChunk, 0, 1))
2119+
2120+            d2.addCallback(lambda ign: wf.close())
2121+
2122+            d2.addCallback(lambda ign:
2123+                self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "writeChunk on closed file",
2124+                                             wf.writeChunk, 0, "a"))
2125+            d2.addCallback(lambda ign:
2126+                self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "setAttrs on closed file",
2127+                                             wf.setAttrs, {'size': 0}))
2128+
2129+            d2.addCallback(lambda ign: wf.close()) # should be no-op
2130+            return d2
2131+        d.addCallback(_write)
2132+        d.addCallback(lambda ign: self.root.get(u"newfile"))
2133+        d.addCallback(lambda node: download_to_data(node))
2134+        d.addCallback(lambda data: self.failUnlessEqual(data, "012345670123\x00a"))
2135+
2136+        # test APPEND flag, and also replacing an existing file ("newfile")
2137+        d.addCallback(lambda ign:
2138+                      self.handler.openFile("newfile", sftp.FXF_WRITE | sftp.FXF_CREAT |
2139+                                                       sftp.FXF_TRUNC | sftp.FXF_APPEND, {}))
2140+        def _write_append(wf):
2141+            d2 = wf.writeChunk(0, "0123456789")
2142+            d2.addCallback(lambda ign: wf.writeChunk(8, "0123"))
2143+            d2.addCallback(lambda ign: wf.close())
2144+            return d2
2145+        d.addCallback(_write_append)
2146+        d.addCallback(lambda ign: self.root.get(u"newfile"))
2147+        d.addCallback(lambda node: download_to_data(node))
2148+        d.addCallback(lambda data: self.failUnlessEqual(data, "01234567890123"))
2149+
2150+        # test EXCL flag
2151+        d.addCallback(lambda ign:
2152+                      self.handler.openFile("excl", sftp.FXF_WRITE | sftp.FXF_CREAT |
2153+                                                    sftp.FXF_TRUNC | sftp.FXF_EXCL, {}))
2154+        def _write_excl(wf):
2155+            d2 = self.root.get(u"excl")
2156+            d2.addCallback(lambda node: download_to_data(node))
2157+            d2.addCallback(lambda data: self.failUnlessEqual(data, ""))
2158+
2159+            d2.addCallback(lambda ign: wf.writeChunk(0, "0123456789"))
2160+            d2.addCallback(lambda ign: wf.close())
2161+            return d2
2162+        d.addCallback(_write_excl)
2163+        d.addCallback(lambda ign: self.root.get(u"excl"))
2164+        d.addCallback(lambda node: download_to_data(node))
2165+        d.addCallback(lambda data: self.failUnlessEqual(data, "0123456789"))
2166+
2167+        # test WRITE | CREAT without TRUNC
2168+        d.addCallback(lambda ign:
2169+                      self.handler.openFile("newfile2", sftp.FXF_WRITE | sftp.FXF_CREAT, {}))
2170+        def _write_notrunc(wf):
2171+            d2 =  wf.writeChunk(0, "0123456789")
2172+            d2.addCallback(lambda ign: wf.close())
2173+            return d2
2174+        d.addCallback(_write_notrunc)
2175+        d.addCallback(lambda ign: self.root.get(u"newfile2"))
2176+        d.addCallback(lambda node: download_to_data(node))
2177+        d.addCallback(lambda data: self.failUnlessEqual(data, "0123456789"))
2178+
2179+        # test writing to a mutable file
2180+        d.addCallback(lambda ign:
2181+                      self.handler.openFile("mutable", sftp.FXF_WRITE, {}))
2182+        def _write_mutable(wf):
2183+            d2 = wf.writeChunk(8, "new!")
2184+            d2.addCallback(lambda ign: wf.close())
2185+            return d2
2186+        d.addCallback(_write_mutable)
2187+        d.addCallback(lambda ign: self.root.get(u"mutable"))
2188+        def _check_same_file(node):
2189+            self.failUnless(node.is_mutable())
2190+            self.failUnlessEqual(node.get_uri(), self.mutable_uri)
2191+            return node.download_best_version()
2192+        d.addCallback(_check_same_file)
2193+        d.addCallback(lambda data: self.failUnlessEqual(data, "mutable new! contents"))
2194+
2195+        """
2196+        # test READ | WRITE without CREAT or TRUNC
2197+        d.addCallback(lambda ign:
2198+                      self.handler.openFile("small", sftp.FXF_READ | sftp.FXF_WRITE, {}))
2199+        def _read_write(rwf):
2200+            d2 =  rwf.writeChunk(8, "0123")
2201+            d2.addCallback(lambda ign: rwf.readChunk(0, 100))
2202+            d2.addCallback(lambda data: self.failUnlessEqual(data, "012345670123"))
2203+            d2.addCallback(lambda ign: rwf.close())
2204+            return d2
2205+        d.addCallback(_read_write)
2206+        d.addCallback(lambda ign: self.root.get(u"small"))
2207+        d.addCallback(lambda node: download_to_data(node))
2208+        d.addCallback(lambda data: self.failUnlessEqual(data, "012345670123"))
2209+        """
2210+        return d
2211+
2212+    def test_removeFile(self):
2213+        d = self._set_up("removeFile")
2214+        d.addCallback(lambda ign: self._set_up_tree())
2215+
2216+        d.addCallback(lambda ign:
2217+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nofile",
2218+                                         self.handler.removeFile, "nofile"))
2219+        d.addCallback(lambda ign:
2220+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nofile",
2221+                                         self.handler.removeFile, "nofile"))
2222+        d.addCallback(lambda ign:
2223+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nodir/file",
2224+                                         self.handler.removeFile, "nodir/file"))
2225+        d.addCallback(lambda ign:
2226+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removefile ''",
2227+                                         self.handler.removeFile, ""))
2228+           
2229+        # removing a directory should fail
2230+        d.addCallback(lambda ign:
2231+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "removeFile tiny_lit_dir",
2232+                                         self.handler.removeFile, "tiny_lit_dir"))
2233+
2234+        # removing a file should succeed
2235+        d.addCallback(lambda ign: self.root.get(u"gro\u00DF"))
2236+        d.addCallback(lambda ign: self.handler.removeFile(u"gro\u00DF".encode('utf-8')))
2237+        d.addCallback(lambda ign:
2238+                      self.shouldFail(NoSuchChildError, "removeFile gross", "gro\\xdf",
2239+                                      self.root.get, u"gro\u00DF"))
2240+
2241+        # removing an unknown should succeed
2242+        d.addCallback(lambda ign: self.root.get(u"unknown"))
2243+        d.addCallback(lambda ign: self.handler.removeFile("unknown"))
2244+        d.addCallback(lambda ign:
2245+                      self.shouldFail(NoSuchChildError, "removeFile unknown", "unknown",
2246+                                      self.root.get, u"unknown"))
2247+
2248+        # removing a link to an open file should not prevent it from being read
2249+        d.addCallback(lambda ign: self.handler.openFile("small", sftp.FXF_READ, {}))
2250+        def _remove_and_read_small(rf):
2251+            d2= self.handler.removeFile("small")
2252+            d2.addCallback(lambda ign:
2253+                           self.shouldFail(NoSuchChildError, "removeFile small", "small",
2254+                                           self.root.get, u"small"))
2255+            d2.addCallback(lambda ign: rf.readChunk(0, 10))
2256+            d2.addCallback(lambda data: self.failUnlessEqual(data, "0123456789"))
2257+            d2.addCallback(lambda ign: rf.close())
2258+            return d2
2259+        d.addCallback(_remove_and_read_small)
2260+
2261+        return d
2262+
2263+    def test_removeDirectory(self):
2264+        d = self._set_up("removeDirectory")
2265+        d.addCallback(lambda ign: self._set_up_tree())
2266+
2267+        d.addCallback(lambda ign:
2268+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory nodir",
2269+                                         self.handler.removeDirectory, "nodir"))
2270+        d.addCallback(lambda ign:
2271+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory nodir/nodir",
2272+                                         self.handler.removeDirectory, "nodir/nodir"))
2273+        d.addCallback(lambda ign:
2274+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory ''",
2275+                                         self.handler.removeDirectory, ""))
2276+
2277+        # removing a file should fail
2278+        d.addCallback(lambda ign:
2279+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "removeDirectory gross",
2280+                                         self.handler.removeDirectory, u"gro\u00DF".encode('utf-8')))
2281+
2282+        # removing a directory should succeed
2283+        d.addCallback(lambda ign: self.root.get(u"tiny_lit_dir"))
2284+        d.addCallback(lambda ign: self.handler.removeDirectory("tiny_lit_dir"))
2285+        d.addCallback(lambda ign:
2286+                      self.shouldFail(NoSuchChildError, "removeDirectory tiny_lit_dir", "tiny_lit_dir",
2287+                                      self.root.get, u"tiny_lit_dir"))
2288+
2289+        # removing an unknown should succeed
2290+        d.addCallback(lambda ign: self.root.get(u"unknown"))
2291+        d.addCallback(lambda ign: self.handler.removeDirectory("unknown"))
2292+        d.addCallback(lambda err:
2293+                      self.shouldFail(NoSuchChildError, "removeDirectory unknown", "unknown",
2294+                                      self.root.get, u"unknown"))
2295+
2296+        return d
2297+
2298+    def test_renameFile(self):
2299+        d = self._set_up("renameFile")
2300+        d.addCallback(lambda ign: self._set_up_tree())
2301+
2302+        # renaming a non-existent file should fail
2303+        d.addCallback(lambda ign:
2304+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile nofile newfile",
2305+                                         self.handler.renameFile, "nofile", "newfile"))
2306+        d.addCallback(lambda ign:
2307+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile '' newfile",
2308+                                         self.handler.renameFile, "", "newfile"))
2309+
2310+        # renaming a file to a non-existent path should fail
2311+        d.addCallback(lambda ign:
2312+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small nodir/small",
2313+                                         self.handler.renameFile, "small", "nodir/small"))
2314+
2315+        # renaming a file to an invalid UTF-8 name should fail
2316+        d.addCallback(lambda ign:
2317+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small invalid",
2318+                                         self.handler.renameFile, "small", "\xFF"))
2319+
2320+        # renaming a file to or from an URI should fail
2321+        d.addCallback(lambda ign:
2322+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small from uri",
2323+                                         self.handler.renameFile, "uri/"+self.small_uri, "new"))
2324+        d.addCallback(lambda ign:
2325+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small to uri",
2326+                                         self.handler.renameFile, "small", "uri/fake_uri"))
2327+
2328+        # renaming a file onto an existing file, directory or unknown should fail
2329+        d.addCallback(lambda ign:
2330+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small small2",
2331+                                         self.handler.renameFile, "small", "small2"))
2332+        d.addCallback(lambda ign:
2333+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small tiny_lit_dir",
2334+                                         self.handler.renameFile, "small", "tiny_lit_dir"))
2335+        d.addCallback(lambda ign:
2336+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small unknown",
2337+                                         self.handler.renameFile, "small", "unknown"))
2338+
2339+        # renaming a file to a correct path should succeed
2340+        d.addCallback(lambda ign: self.handler.renameFile("small", "new_small"))
2341+        d.addCallback(lambda ign: self.root.get(u"new_small"))
2342+        d.addCallback(lambda node: self.failUnlessEqual(node.get_uri(), self.small_uri))
2343+
2344+        # renaming a file into a subdirectory should succeed (also tests Unicode names)
2345+        d.addCallback(lambda ign: self.handler.renameFile(u"gro\u00DF".encode('utf-8'),
2346+                                                          u"loop/neue_gro\u00DF".encode('utf-8')))
2347+        d.addCallback(lambda ign: self.root.get(u"neue_gro\u00DF"))
2348+        d.addCallback(lambda node: self.failUnlessEqual(node.get_uri(), self.gross_uri))
2349+
2350+        # renaming a directory to a correct path should succeed
2351+        d.addCallback(lambda ign: self.handler.renameFile("tiny_lit_dir", "new_tiny_lit_dir"))
2352+        d.addCallback(lambda ign: self.root.get(u"new_tiny_lit_dir"))
2353+        d.addCallback(lambda node: self.failUnlessEqual(node.get_uri(), self.tiny_lit_dir_uri))
2354+
2355+        # renaming an unknown to a correct path should succeed
2356+        d.addCallback(lambda ign: self.handler.renameFile("unknown", "new_unknown"))
2357+        d.addCallback(lambda ign: self.root.get(u"new_unknown"))
2358+        d.addCallback(lambda node: self.failUnlessEqual(node.get_uri(), self.unknown_uri))
2359+
2360+        return d
2361+
2362+    def test_makeDirectory(self):
2363+        d = self._set_up("makeDirectory")
2364+        d.addCallback(lambda ign: self._set_up_tree())
2365+           
2366+        # making a directory at a correct path should succeed
2367+        d.addCallback(lambda ign: self.handler.makeDirectory("newdir", {'ext_foo': 'bar', 'ctime': 42}))
2368+
2369+        d.addCallback(lambda ign: self.root.get_child_and_metadata(u"newdir"))
2370+        def _got( (child, metadata) ):
2371+            self.failUnless(IDirectoryNode.providedBy(child))
2372+            self.failUnless(child.is_mutable())
2373+            # FIXME
2374+            #self.failUnless('ctime' in metadata, metadata)
2375+            #self.failUnlessEqual(metadata['ctime'], 42)
2376+            #self.failUnless('ext_foo' in metadata, metadata)
2377+            #self.failUnlessEqual(metadata['ext_foo'], 'bar')
2378+            # TODO: child should be empty
2379+        d.addCallback(_got)
2380+
2381+        # making intermediate directories should also succeed
2382+        d.addCallback(lambda ign: self.handler.makeDirectory("newparent/newchild", {}))
2383+
2384+        d.addCallback(lambda ign: self.root.get(u"newparent"))
2385+        def _got_newparent(newparent):
2386+            self.failUnless(IDirectoryNode.providedBy(newparent))
2387+            self.failUnless(newparent.is_mutable())
2388+            return newparent.get(u"newchild")
2389+        d.addCallback(_got_newparent)
2390+
2391+        def _got_newchild(newchild):
2392+            self.failUnless(IDirectoryNode.providedBy(newchild))
2393+            self.failUnless(newchild.is_mutable())
2394+        d.addCallback(_got_newchild)
2395+
2396+        d.addCallback(lambda ign:
2397+            self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "makeDirectory invalid UTF-8",
2398+                                         self.handler.makeDirectory, "\xFF", {}))
2399+
2400+        # should fail because there is an existing file "small"
2401+        d.addCallback(lambda ign:
2402+            self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "makeDirectory small",
2403+                                         self.handler.makeDirectory, "small", {}))
2404+        return d
2405}
2406[Change shouldFail to avoid Unicode errors when converting Failure to str
2407david-sarah@jacaranda.org**20100512060754
2408 Ignore-this: 86ed419d332d9c33090aae2cde1dc5df
2409] {
2410hunk ./src/allmydata/test/common.py 1090
2411         error message, if any, because Deferred chains frequently make it
2412         difficult to tell which assertion was tripped.
2413 
2414-        The substring= argument, if not None, must appear inside the
2415-        stringified Failure, or the test will fail.
2416+        The substring= argument, if not None, must appear in the 'repr'
2417+        of the message wrapped by this Failure, or the test will fail.
2418         """
2419 
2420         assert substring is None or isinstance(substring, str)
2421hunk ./src/allmydata/test/common.py 1100
2422             if isinstance(res, failure.Failure):
2423                 res.trap(expected_failure)
2424                 if substring:
2425-                    self.failUnless(substring in str(res),
2426+                    message = repr(res.value.args[0])
2427+                    self.failUnless(substring in message,
2428                                     "substring '%s' not in '%s'"
2429hunk ./src/allmydata/test/common.py 1103
2430-                                    % (substring, str(res)))
2431+                                    % (substring, message))
2432             else:
2433                 self.fail("%s was supposed to raise %s, not get '%s'" %
2434                           (which, expected_failure, res))
2435}
2436
2437Context:
2438
2439[Clarify quickstart instructions for installing pywin32
2440david-sarah@jacaranda.org**20100511180300
2441 Ignore-this: d4668359673600d2acbc7cd8dd44b93c
2442]
2443[web: add a simple test that you can load directory.xhtml
2444zooko@zooko.com**20100510063729
2445 Ignore-this: e49b25fa3c67b3c7a56c8b1ae01bb463
2446]
2447[setup: fix typos in misc/show-tool-versions.py
2448zooko@zooko.com**20100510063615
2449 Ignore-this: 2181b1303a0e288e7a9ebd4c4855628
2450]
2451[setup: show code-coverage tool versions in show-tools-versions.py
2452zooko@zooko.com**20100510062955
2453 Ignore-this: 4b4c68eb3780b762c8dbbd22b39df7cf
2454]
2455[docs: update README, mv it to README.txt, update setup.py
2456zooko@zooko.com**20100504094340
2457 Ignore-this: 40e28ca36c299ea1fd12d3b91e5b421c
2458]
2459[tests: pass z to tar so that BSD tar will know to ungzip
2460zooko@zooko.com**20100504090628
2461 Ignore-this: 1339e493f255e8fc0b01b70478f23a09
2462]
2463[setup: update comments and URLs in setup.cfg
2464zooko@zooko.com**20100504061653
2465 Ignore-this: f97692807c74bcab56d33100c899f829
2466]
2467[setup: reorder and extend the show-tool-versions script, the better to glean information about our new buildslaves
2468zooko@zooko.com**20100504045643
2469 Ignore-this: 836084b56b8d4ee8f1de1f4efb706d36
2470]
2471[Dependency on Windmill test framework is not needed yet.
2472david-sarah@jacaranda.org**20100504161043
2473 Ignore-this: be088712bec650d4ef24766c0026ebc8
2474]
2475[CLI: Support for https url in option --node-url
2476Francois Deppierraz <francois@ctrlaltdel.ch>**20100430185609
2477 Ignore-this: 1717176b4d27c877e6bc67a944d9bf34
2478 
2479 This patch modifies the regular expression used for verifying of '--node-url'
2480 parameter.  Support for accessing a Tahoe gateway over HTTPS was already
2481 present, thanks to Python's urllib.
2482 
2483]
2484[backupdb.did_create_directory: use REPLACE INTO, not INSERT INTO + ignore error
2485Brian Warner <warner@lothar.com>**20100428050803
2486 Ignore-this: 1fca7b8f364a21ae413be8767161e32f
2487 
2488 This handles the case where we upload a new tahoe directory for a
2489 previously-processed local directory, possibly creating a new dircap (if the
2490 metadata had changed). Now we replace the old dirhash->dircap record. The
2491 previous behavior left the old record in place (with the old dircap and
2492 timestamps), so we'd never stop creating new directories and never converge
2493 on a null backup.
2494]
2495["tahoe webopen": add --info flag, to get ?t=info
2496Brian Warner <warner@lothar.com>**20100424233003
2497 Ignore-this: 126b0bb6db340fabacb623d295eb45fa
2498 
2499 Also fix some trailing whitespace.
2500]
2501[docs: install.html http-equiv refresh to quickstart.html
2502zooko@zooko.com**20100421165708
2503 Ignore-this: 52b4b619f9dde5886ae2cd7f1f3b734b
2504]
2505[docs: install.html -> quickstart.html
2506zooko@zooko.com**20100421155757
2507 Ignore-this: 6084e203909306bed93efb09d0e6181d
2508 It is not called "installing" because that implies that it is going to change the configuration of your operating system. It is not called "building" because that implies that you need developer tools like a compiler. Also I added a stern warning against looking at the "InstallDetails" wiki page, which I have renamed to "AdvancedInstall".
2509]
2510[Fix another typo in tahoe_storagespace munin plugin
2511david-sarah@jacaranda.org**20100416220935
2512 Ignore-this: ad1f7aa66b554174f91dfb2b7a3ea5f3
2513]
2514[licensing: phrase the OpenSSL-exemption in the vocabulary of copyright instead of computer technology, and replicate the exemption from the GPL to the TGPPL
2515zooko@zooko.com**20100414232521
2516 Ignore-this: a5494b2f582a295544c6cad3f245e91
2517]
2518[munin-tahoe_storagespace
2519freestorm77@gmail.com**20100221203626
2520 Ignore-this: 14d6d6a587afe1f8883152bf2e46b4aa
2521 
2522 Plugin configuration rename
2523 
2524]
2525[Add dependency on windmill >= 1.3
2526david-sarah@jacaranda.org**20100416190404
2527 Ignore-this: 4437a7a464e92d6c9012926b18676211
2528]
2529[setup: add licensing declaration for setuptools (noticed by the FSF compliance folks)
2530zooko@zooko.com**20100309184415
2531 Ignore-this: 2dfa7d812d65fec7c72ddbf0de609ccb
2532]
2533[setup: fix error in licensing declaration from Shawn Willden, as noted by the FSF compliance division
2534zooko@zooko.com**20100309163736
2535 Ignore-this: c0623d27e469799d86cabf67921a13f8
2536]
2537[CREDITS to Jacob Appelbaum
2538zooko@zooko.com**20100304015616
2539 Ignore-this: 70db493abbc23968fcc8db93f386ea54
2540]
2541[desert-island-build-with-proper-versions
2542jacob@appelbaum.net**20100304013858]
2543[docs: a few small edits to try to guide newcomers through the docs
2544zooko@zooko.com**20100303231902
2545 Ignore-this: a6aab44f5bf5ad97ea73e6976bc4042d
2546 These edits were suggested by my watching over Jake Appelbaum's shoulder as he completely ignored/skipped/missed install.html and also as he decided that debian.txt wouldn't help him with basic installation. Then I threw in a few docs edits that have been sitting around in my sandbox asking to be committed for months.
2547]
2548[TAG allmydata-tahoe-1.6.1
2549david-sarah@jacaranda.org**20100228062314
2550 Ignore-this: eb5f03ada8ea953ee7780e7fe068539
2551]
2552Patch bundle hash:
2553af606a89f9b9e87a70e34177bdb8b84c8d25e4f4