2 import re, struct, traceback, time, calendar
3 from stat import S_IFREG, S_IFDIR
5 from twisted.trial import unittest
6 from twisted.internet import defer, reactor
7 from twisted.python.failure import Failure
8 from twisted.internet.error import ProcessDone, ProcessTerminated
9 from allmydata.util import deferredutil
11 conch_interfaces = None
16 from Crypto import Util
23 from twisted.conch import interfaces as conch_interfaces
24 from twisted.conch.ssh import filetransfer as sftp
25 from allmydata.frontends import sftpd
27 from allmydata.interfaces import IDirectoryNode, ExistingChildError, NoSuchChildError
28 from allmydata.mutable.common import NotWriteableError
30 from allmydata.util.consumer import download_to_data
31 from allmydata.immutable import upload
32 from allmydata.mutable import publish
33 from allmydata.test.no_network import GridTestMixin
34 from allmydata.test.common import ShouldFailMixin
35 from allmydata.test.common_util import ReallyEqualMixin
39 #defer.setDebugging(True)
40 #from twisted.internet import base
41 #base.DelayedCall.debug = True
43 class Handler(GridTestMixin, ShouldFailMixin, ReallyEqualMixin, unittest.TestCase):
44 """This is a no-network unit test of the SFTPUserHandler and the abstractions it uses."""
47 skip = "SFTP support requires pycrypto, which is not installed"
49 def shouldFailWithSFTPError(self, expected_code, which, callable, *args, **kwargs):
50 assert isinstance(expected_code, int), repr(expected_code)
51 assert isinstance(which, str), repr(which)
52 s = traceback.format_stack()
53 d = defer.maybeDeferred(callable, *args, **kwargs)
55 if isinstance(res, Failure):
56 res.trap(sftp.SFTPError)
57 self.failUnlessReallyEqual(res.value.code, expected_code,
58 "%s was supposed to raise SFTPError(%r), not SFTPError(%r): %s" %
59 (which, expected_code, res.value.code, res))
61 print '@' + '@'.join(s)
62 self.fail("%s was supposed to raise SFTPError(%r), not get %r" %
63 (which, expected_code, res))
67 def _set_up(self, basedir, num_clients=1, num_servers=10):
68 self.basedir = "sftp/" + basedir
69 self.set_up_grid(num_clients=num_clients, num_servers=num_servers)
71 self.client = self.g.clients[0]
72 self.username = "alice"
74 d = self.client.create_dirnode()
75 def _created_root(node):
77 self.root_uri = node.get_uri()
79 self.handler = sftpd.SFTPUserHandler(self.client, self.root, self.username)
80 d.addCallback(_created_root)
83 def _set_up_tree(self):
84 u = publish.MutableData("mutable file contents")
85 d = self.client.create_mutable_file(u)
86 d.addCallback(lambda node: self.root.set_node(u"mutable", node))
87 def _created_mutable(n):
89 self.mutable_uri = n.get_uri()
90 d.addCallback(_created_mutable)
92 d.addCallback(lambda ign:
93 self.root._create_and_validate_node(None, self.mutable.get_readonly_uri(), name=u"readonly"))
94 d.addCallback(lambda node: self.root.set_node(u"readonly", node))
95 def _created_readonly(n):
97 self.readonly_uri = n.get_uri()
98 d.addCallback(_created_readonly)
100 gross = upload.Data("0123456789" * 101, None)
101 d.addCallback(lambda ign: self.root.add_file(u"gro\u00DF", gross))
102 def _created_gross(n):
104 self.gross_uri = n.get_uri()
105 d.addCallback(_created_gross)
107 small = upload.Data("0123456789", None)
108 d.addCallback(lambda ign: self.root.add_file(u"small", small))
109 def _created_small(n):
111 self.small_uri = n.get_uri()
112 d.addCallback(_created_small)
114 small2 = upload.Data("Small enough for a LIT too", None)
115 d.addCallback(lambda ign: self.root.add_file(u"small2", small2))
116 def _created_small2(n):
118 self.small2_uri = n.get_uri()
119 d.addCallback(_created_small2)
121 empty_litdir_uri = "URI:DIR2-LIT:"
123 # contains one child which is itself also LIT:
124 tiny_litdir_uri = "URI:DIR2-LIT:gqytunj2onug64tufqzdcosvkjetutcjkq5gw4tvm5vwszdgnz5hgyzufqydulbshj5x2lbm"
126 unknown_uri = "x-tahoe-crazy://I_am_from_the_future."
128 d.addCallback(lambda ign: self.root._create_and_validate_node(None, empty_litdir_uri, name=u"empty_lit_dir"))
129 def _created_empty_lit_dir(n):
130 self.empty_lit_dir = n
131 self.empty_lit_dir_uri = n.get_uri()
132 self.root.set_node(u"empty_lit_dir", n)
133 d.addCallback(_created_empty_lit_dir)
135 d.addCallback(lambda ign: self.root._create_and_validate_node(None, tiny_litdir_uri, name=u"tiny_lit_dir"))
136 def _created_tiny_lit_dir(n):
137 self.tiny_lit_dir = n
138 self.tiny_lit_dir_uri = n.get_uri()
139 self.root.set_node(u"tiny_lit_dir", n)
140 d.addCallback(_created_tiny_lit_dir)
142 d.addCallback(lambda ign: self.root._create_and_validate_node(None, unknown_uri, name=u"unknown"))
143 def _created_unknown(n):
145 self.unknown_uri = n.get_uri()
146 self.root.set_node(u"unknown", n)
147 d.addCallback(_created_unknown)
149 fall_of_the_Berlin_wall = calendar.timegm(time.strptime("1989-11-09 20:00:00 UTC", "%Y-%m-%d %H:%M:%S %Z"))
150 md = {'mtime': fall_of_the_Berlin_wall, 'tahoe': {'linkmotime': fall_of_the_Berlin_wall}}
151 d.addCallback(lambda ign: self.root.set_node(u"loop", self.root, metadata=md))
154 def test_basic(self):
155 d = self._set_up("basic")
157 # Test operations that have no side-effects, and don't need the tree.
159 version = self.handler.gotVersion(3, {})
160 self.failUnless(isinstance(version, dict))
162 self.failUnlessReallyEqual(self.handler._path_from_string(""), [])
163 self.failUnlessReallyEqual(self.handler._path_from_string("/"), [])
164 self.failUnlessReallyEqual(self.handler._path_from_string("."), [])
165 self.failUnlessReallyEqual(self.handler._path_from_string("//"), [])
166 self.failUnlessReallyEqual(self.handler._path_from_string("/."), [])
167 self.failUnlessReallyEqual(self.handler._path_from_string("/./"), [])
168 self.failUnlessReallyEqual(self.handler._path_from_string("foo"), [u"foo"])
169 self.failUnlessReallyEqual(self.handler._path_from_string("/foo"), [u"foo"])
170 self.failUnlessReallyEqual(self.handler._path_from_string("foo/"), [u"foo"])
171 self.failUnlessReallyEqual(self.handler._path_from_string("/foo/"), [u"foo"])
172 self.failUnlessReallyEqual(self.handler._path_from_string("foo/bar"), [u"foo", u"bar"])
173 self.failUnlessReallyEqual(self.handler._path_from_string("/foo/bar"), [u"foo", u"bar"])
174 self.failUnlessReallyEqual(self.handler._path_from_string("foo/bar//"), [u"foo", u"bar"])
175 self.failUnlessReallyEqual(self.handler._path_from_string("/foo/bar//"), [u"foo", u"bar"])
176 self.failUnlessReallyEqual(self.handler._path_from_string("foo/./bar"), [u"foo", u"bar"])
177 self.failUnlessReallyEqual(self.handler._path_from_string("./foo/./bar"), [u"foo", u"bar"])
178 self.failUnlessReallyEqual(self.handler._path_from_string("foo/../bar"), [u"bar"])
179 self.failUnlessReallyEqual(self.handler._path_from_string("/foo/../bar"), [u"bar"])
180 self.failUnlessReallyEqual(self.handler._path_from_string("../bar"), [u"bar"])
181 self.failUnlessReallyEqual(self.handler._path_from_string("/../bar"), [u"bar"])
183 self.failUnlessReallyEqual(self.handler.realPath(""), "/")
184 self.failUnlessReallyEqual(self.handler.realPath("/"), "/")
185 self.failUnlessReallyEqual(self.handler.realPath("."), "/")
186 self.failUnlessReallyEqual(self.handler.realPath("//"), "/")
187 self.failUnlessReallyEqual(self.handler.realPath("/."), "/")
188 self.failUnlessReallyEqual(self.handler.realPath("/./"), "/")
189 self.failUnlessReallyEqual(self.handler.realPath("foo"), "/foo")
190 self.failUnlessReallyEqual(self.handler.realPath("/foo"), "/foo")
191 self.failUnlessReallyEqual(self.handler.realPath("foo/"), "/foo")
192 self.failUnlessReallyEqual(self.handler.realPath("/foo/"), "/foo")
193 self.failUnlessReallyEqual(self.handler.realPath("foo/bar"), "/foo/bar")
194 self.failUnlessReallyEqual(self.handler.realPath("/foo/bar"), "/foo/bar")
195 self.failUnlessReallyEqual(self.handler.realPath("foo/bar//"), "/foo/bar")
196 self.failUnlessReallyEqual(self.handler.realPath("/foo/bar//"), "/foo/bar")
197 self.failUnlessReallyEqual(self.handler.realPath("foo/./bar"), "/foo/bar")
198 self.failUnlessReallyEqual(self.handler.realPath("./foo/./bar"), "/foo/bar")
199 self.failUnlessReallyEqual(self.handler.realPath("foo/../bar"), "/bar")
200 self.failUnlessReallyEqual(self.handler.realPath("/foo/../bar"), "/bar")
201 self.failUnlessReallyEqual(self.handler.realPath("../bar"), "/bar")
202 self.failUnlessReallyEqual(self.handler.realPath("/../bar"), "/bar")
203 d.addCallback(_check)
205 d.addCallback(lambda ign:
206 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "_path_from_string invalid UTF-8",
207 self.handler._path_from_string, "\xFF"))
208 d.addCallback(lambda ign:
209 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "realPath invalid UTF-8",
210 self.handler.realPath, "\xFF"))
214 def test_convert_error(self):
215 self.failUnlessReallyEqual(sftpd._convert_error(None, "request"), None)
217 d = defer.succeed(None)
218 d.addCallback(lambda ign:
219 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "_convert_error SFTPError",
220 sftpd._convert_error, Failure(sftp.SFTPError(sftp.FX_FAILURE, "foo")), "request"))
221 d.addCallback(lambda ign:
222 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "_convert_error NoSuchChildError",
223 sftpd._convert_error, Failure(NoSuchChildError("foo")), "request"))
224 d.addCallback(lambda ign:
225 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "_convert_error ExistingChildError",
226 sftpd._convert_error, Failure(ExistingChildError("foo")), "request"))
227 d.addCallback(lambda ign:
228 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "_convert_error NotWriteableError",
229 sftpd._convert_error, Failure(NotWriteableError("foo")), "request"))
230 d.addCallback(lambda ign:
231 self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "_convert_error NotImplementedError",
232 sftpd._convert_error, Failure(NotImplementedError("foo")), "request"))
233 d.addCallback(lambda ign:
234 self.shouldFailWithSFTPError(sftp.FX_EOF, "_convert_error EOFError",
235 sftpd._convert_error, Failure(EOFError("foo")), "request"))
236 d.addCallback(lambda ign:
237 self.shouldFailWithSFTPError(sftp.FX_EOF, "_convert_error defer.FirstError",
238 sftpd._convert_error, Failure(defer.FirstError(
239 Failure(sftp.SFTPError(sftp.FX_EOF, "foo")), 0)), "request"))
240 d.addCallback(lambda ign:
241 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "_convert_error AssertionError",
242 sftpd._convert_error, Failure(AssertionError("foo")), "request"))
246 def test_not_implemented(self):
247 d = self._set_up("not_implemented")
249 d.addCallback(lambda ign:
250 self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "readLink link",
251 self.handler.readLink, "link"))
252 d.addCallback(lambda ign:
253 self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "makeLink link file",
254 self.handler.makeLink, "link", "file"))
258 def _compareDirLists(self, actual, expected):
259 actual_list = sorted(actual)
260 expected_list = sorted(expected)
261 self.failUnlessReallyEqual(len(actual_list), len(expected_list),
262 "%r is wrong length, expecting %r" % (actual_list, expected_list))
263 for (a, b) in zip(actual_list, expected_list):
264 (name, text, attrs) = a
265 (expected_name, expected_text_re, expected_attrs) = b
266 self.failUnlessReallyEqual(name, expected_name)
267 self.failUnless(re.match(expected_text_re, text),
268 "%r does not match %r in\n%r" % (text, expected_text_re, actual_list))
269 self._compareAttributes(attrs, expected_attrs)
271 def _compareAttributes(self, attrs, expected_attrs):
272 # It is ok for there to be extra actual attributes.
274 for e in expected_attrs:
275 self.failUnless(e in attrs, "%r is not in\n%r" % (e, attrs))
276 self.failUnlessReallyEqual(attrs[e], expected_attrs[e],
277 "%r:%r is not %r in\n%r" % (e, attrs[e], expected_attrs[e], attrs))
279 def test_openDirectory_and_attrs(self):
280 d = self._set_up("openDirectory_and_attrs")
281 d.addCallback(lambda ign: self._set_up_tree())
283 d.addCallback(lambda ign:
284 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openDirectory small",
285 self.handler.openDirectory, "small"))
286 d.addCallback(lambda ign:
287 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openDirectory unknown",
288 self.handler.openDirectory, "unknown"))
289 d.addCallback(lambda ign:
290 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openDirectory nodir",
291 self.handler.openDirectory, "nodir"))
292 d.addCallback(lambda ign:
293 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openDirectory nodir/nodir",
294 self.handler.openDirectory, "nodir/nodir"))
296 gross = u"gro\u00DF".encode("utf-8")
298 ('empty_lit_dir', r'dr-xr-xr-x .* 0 .* empty_lit_dir$', {'permissions': S_IFDIR | 0555}),
299 (gross, r'-rw-rw-rw- .* 1010 .* '+gross+'$', {'permissions': S_IFREG | 0666, 'size': 1010}),
300 # The fall of the Berlin wall may have been on 9th or 10th November 1989 depending on the gateway's timezone.
301 #('loop', r'drwxrwxrwx .* 0 Nov (09|10) 1989 loop$', {'permissions': S_IFDIR | 0777}),
302 ('loop', r'drwxrwxrwx .* 0 .* loop$', {'permissions': S_IFDIR | 0777}),
303 ('mutable', r'-rw-rw-rw- .* 0 .* mutable$', {'permissions': S_IFREG | 0666}),
304 ('readonly', r'-r--r--r-- .* 0 .* readonly$', {'permissions': S_IFREG | 0444}),
305 ('small', r'-rw-rw-rw- .* 10 .* small$', {'permissions': S_IFREG | 0666, 'size': 10}),
306 ('small2', r'-rw-rw-rw- .* 26 .* small2$', {'permissions': S_IFREG | 0666, 'size': 26}),
307 ('tiny_lit_dir', r'dr-xr-xr-x .* 0 .* tiny_lit_dir$', {'permissions': S_IFDIR | 0555}),
308 ('unknown', r'\?--------- .* 0 .* unknown$', {'permissions': 0}),
311 d.addCallback(lambda ign: self.handler.openDirectory(""))
312 d.addCallback(lambda res: self._compareDirLists(res, expected_root))
314 d.addCallback(lambda ign: self.handler.openDirectory("loop"))
315 d.addCallback(lambda res: self._compareDirLists(res, expected_root))
317 d.addCallback(lambda ign: self.handler.openDirectory("loop/loop"))
318 d.addCallback(lambda res: self._compareDirLists(res, expected_root))
320 d.addCallback(lambda ign: self.handler.openDirectory("empty_lit_dir"))
321 d.addCallback(lambda res: self._compareDirLists(res, []))
323 # The UTC epoch may either be in Jan 1 1970 or Dec 31 1969 depending on the gateway's timezone.
324 expected_tiny_lit = [
325 ('short', r'-r--r--r-- .* 8 (Jan 01 1970|Dec 31 1969) short$', {'permissions': S_IFREG | 0444, 'size': 8}),
328 d.addCallback(lambda ign: self.handler.openDirectory("tiny_lit_dir"))
329 d.addCallback(lambda res: self._compareDirLists(res, expected_tiny_lit))
331 d.addCallback(lambda ign: self.handler.getAttrs("small", True))
332 d.addCallback(lambda attrs: self._compareAttributes(attrs, {'permissions': S_IFREG | 0666, 'size': 10}))
334 d.addCallback(lambda ign: self.handler.setAttrs("small", {}))
335 d.addCallback(lambda res: self.failUnlessReallyEqual(res, None))
337 d.addCallback(lambda ign: self.handler.getAttrs("small", True))
338 d.addCallback(lambda attrs: self._compareAttributes(attrs, {'permissions': S_IFREG | 0666, 'size': 10}))
340 d.addCallback(lambda ign:
341 self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "setAttrs size",
342 self.handler.setAttrs, "small", {'size': 0}))
344 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
345 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
348 def test_openFile_read(self):
349 d = self._set_up("openFile_read")
350 d.addCallback(lambda ign: self._set_up_tree())
352 d.addCallback(lambda ign:
353 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "openFile small 0 bad",
354 self.handler.openFile, "small", 0, {}))
356 # attempting to open a non-existent file should fail
357 d.addCallback(lambda ign:
358 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile nofile READ nosuch",
359 self.handler.openFile, "nofile", sftp.FXF_READ, {}))
360 d.addCallback(lambda ign:
361 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile nodir/file READ nosuch",
362 self.handler.openFile, "nodir/file", sftp.FXF_READ, {}))
364 d.addCallback(lambda ign:
365 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown READ denied",
366 self.handler.openFile, "unknown", sftp.FXF_READ, {}))
367 d.addCallback(lambda ign:
368 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown/file READ denied",
369 self.handler.openFile, "unknown/file", sftp.FXF_READ, {}))
370 d.addCallback(lambda ign:
371 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir READ denied",
372 self.handler.openFile, "tiny_lit_dir", sftp.FXF_READ, {}))
373 d.addCallback(lambda ign:
374 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown uri READ denied",
375 self.handler.openFile, "uri/"+self.unknown_uri, sftp.FXF_READ, {}))
376 d.addCallback(lambda ign:
377 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir uri READ denied",
378 self.handler.openFile, "uri/"+self.tiny_lit_dir_uri, sftp.FXF_READ, {}))
379 # FIXME: should be FX_NO_SUCH_FILE?
380 d.addCallback(lambda ign:
381 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile noexist uri READ denied",
382 self.handler.openFile, "uri/URI:noexist", sftp.FXF_READ, {}))
383 d.addCallback(lambda ign:
384 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile invalid UTF-8 uri READ denied",
385 self.handler.openFile, "uri/URI:\xFF", sftp.FXF_READ, {}))
387 # reading an existing file should succeed
388 d.addCallback(lambda ign: self.handler.openFile("small", sftp.FXF_READ, {}))
390 d2 = rf.readChunk(0, 10)
391 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
393 d2.addCallback(lambda ign: rf.readChunk(2, 6))
394 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "234567"))
396 d2.addCallback(lambda ign: rf.readChunk(1, 0))
397 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
399 d2.addCallback(lambda ign: rf.readChunk(8, 4)) # read that starts before EOF is OK
400 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "89"))
402 d2.addCallback(lambda ign:
403 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF (0-byte)",
404 rf.readChunk, 10, 0))
405 d2.addCallback(lambda ign:
406 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF",
407 rf.readChunk, 10, 1))
408 d2.addCallback(lambda ign:
409 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting after EOF",
410 rf.readChunk, 11, 1))
412 d2.addCallback(lambda ign: rf.getAttrs())
413 d2.addCallback(lambda attrs: self._compareAttributes(attrs, {'permissions': S_IFREG | 0666, 'size': 10}))
415 d2.addCallback(lambda ign: self.handler.getAttrs("small", followLinks=0))
416 d2.addCallback(lambda attrs: self._compareAttributes(attrs, {'permissions': S_IFREG | 0666, 'size': 10}))
418 d2.addCallback(lambda ign:
419 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "writeChunk on read-only handle denied",
420 rf.writeChunk, 0, "a"))
421 d2.addCallback(lambda ign:
422 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "setAttrs on read-only handle denied",
425 d2.addCallback(lambda ign: rf.close())
427 d2.addCallback(lambda ign:
428 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "readChunk on closed file bad",
430 d2.addCallback(lambda ign:
431 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "getAttrs on closed file bad",
434 d2.addCallback(lambda ign: rf.close()) # should be no-op
436 d.addCallback(_read_small)
438 # repeat for a large file
439 gross = u"gro\u00DF".encode("utf-8")
440 d.addCallback(lambda ign: self.handler.openFile(gross, sftp.FXF_READ, {}))
442 d2 = rf.readChunk(0, 10)
443 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
445 d2.addCallback(lambda ign: rf.readChunk(2, 6))
446 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "234567"))
448 d2.addCallback(lambda ign: rf.readChunk(1, 0))
449 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
451 d2.addCallback(lambda ign: rf.readChunk(1008, 4)) # read that starts before EOF is OK
452 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "89"))
454 d2.addCallback(lambda ign:
455 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF (0-byte)",
456 rf.readChunk, 1010, 0))
457 d2.addCallback(lambda ign:
458 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF",
459 rf.readChunk, 1010, 1))
460 d2.addCallback(lambda ign:
461 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting after EOF",
462 rf.readChunk, 1011, 1))
464 d2.addCallback(lambda ign: rf.getAttrs())
465 d2.addCallback(lambda attrs: self._compareAttributes(attrs, {'permissions': S_IFREG | 0666, 'size': 1010}))
467 d2.addCallback(lambda ign: self.handler.getAttrs(gross, followLinks=0))
468 d2.addCallback(lambda attrs: self._compareAttributes(attrs, {'permissions': S_IFREG | 0666, 'size': 1010}))
470 d2.addCallback(lambda ign:
471 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "writeChunk on read-only handle denied",
472 rf.writeChunk, 0, "a"))
473 d2.addCallback(lambda ign:
474 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "setAttrs on read-only handle denied",
477 d2.addCallback(lambda ign: rf.close())
479 d2.addCallback(lambda ign:
480 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "readChunk on closed file",
482 d2.addCallback(lambda ign:
483 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "getAttrs on closed file",
486 d2.addCallback(lambda ign: rf.close()) # should be no-op
488 d.addCallback(_read_gross)
490 # reading an existing small file via uri/ should succeed
491 d.addCallback(lambda ign: self.handler.openFile("uri/"+self.small_uri, sftp.FXF_READ, {}))
492 def _read_small_uri(rf):
493 d2 = rf.readChunk(0, 10)
494 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
495 d2.addCallback(lambda ign: rf.close())
497 d.addCallback(_read_small_uri)
499 # repeat for a large file
500 d.addCallback(lambda ign: self.handler.openFile("uri/"+self.gross_uri, sftp.FXF_READ, {}))
501 def _read_gross_uri(rf):
502 d2 = rf.readChunk(0, 10)
503 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
504 d2.addCallback(lambda ign: rf.close())
506 d.addCallback(_read_gross_uri)
508 # repeat for a mutable file
509 d.addCallback(lambda ign: self.handler.openFile("uri/"+self.mutable_uri, sftp.FXF_READ, {}))
510 def _read_mutable_uri(rf):
511 d2 = rf.readChunk(0, 100)
512 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "mutable file contents"))
513 d2.addCallback(lambda ign: rf.close())
515 d.addCallback(_read_mutable_uri)
517 # repeat for a file within a directory referenced by URI
518 d.addCallback(lambda ign: self.handler.openFile("uri/"+self.tiny_lit_dir_uri+"/short", sftp.FXF_READ, {}))
520 d2 = rf.readChunk(0, 100)
521 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "The end."))
522 d2.addCallback(lambda ign: rf.close())
524 d.addCallback(_read_short)
526 # check that failed downloads cause failed reads
527 d.addCallback(lambda ign: self.handler.openFile("uri/"+self.gross_uri, sftp.FXF_READ, {}))
528 def _read_broken(rf):
529 d2 = defer.succeed(None)
530 d2.addCallback(lambda ign: self.g.nuke_from_orbit())
531 d2.addCallback(lambda ign:
532 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "read broken",
533 rf.readChunk, 0, 100))
534 # close shouldn't fail
535 d2.addCallback(lambda ign: rf.close())
536 d2.addCallback(lambda res: self.failUnlessReallyEqual(res, None))
538 d.addCallback(_read_broken)
540 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
541 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
544 def test_openFile_read_error(self):
545 # The check at the end of openFile_read tested this for large files, but it trashed
546 # the grid in the process, so this needs to be a separate test.
547 small = upload.Data("0123456789"*10, None)
548 d = self._set_up("openFile_read_error")
549 d.addCallback(lambda ign: self.root.add_file(u"small", small))
550 d.addCallback(lambda n: self.handler.openFile("/uri/"+n.get_uri(), sftp.FXF_READ, {}))
551 def _read_broken(rf):
552 d2 = defer.succeed(None)
553 d2.addCallback(lambda ign: self.g.nuke_from_orbit())
554 d2.addCallback(lambda ign:
555 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "read broken",
556 rf.readChunk, 0, 100))
557 # close shouldn't fail
558 d2.addCallback(lambda ign: rf.close())
559 d2.addCallback(lambda res: self.failUnlessReallyEqual(res, None))
561 d.addCallback(_read_broken)
563 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
564 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
567 def test_openFile_write(self):
568 d = self._set_up("openFile_write")
569 d.addCallback(lambda ign: self._set_up_tree())
571 # '' is an invalid filename
572 d.addCallback(lambda ign:
573 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile '' WRITE|CREAT|TRUNC nosuch",
574 self.handler.openFile, "", sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
576 # TRUNC is not valid without CREAT if the file does not already exist
577 d.addCallback(lambda ign:
578 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile newfile WRITE|TRUNC nosuch",
579 self.handler.openFile, "newfile", sftp.FXF_WRITE | sftp.FXF_TRUNC, {}))
581 # EXCL is not valid without CREAT
582 d.addCallback(lambda ign:
583 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "openFile small WRITE|EXCL bad",
584 self.handler.openFile, "small", sftp.FXF_WRITE | sftp.FXF_EXCL, {}))
586 # cannot write to an existing directory
587 d.addCallback(lambda ign:
588 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir WRITE denied",
589 self.handler.openFile, "tiny_lit_dir", sftp.FXF_WRITE, {}))
591 # cannot write to an existing unknown
592 d.addCallback(lambda ign:
593 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown WRITE denied",
594 self.handler.openFile, "unknown", sftp.FXF_WRITE, {}))
596 # cannot create a child of an unknown
597 d.addCallback(lambda ign:
598 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown/newfile WRITE|CREAT denied",
599 self.handler.openFile, "unknown/newfile",
600 sftp.FXF_WRITE | sftp.FXF_CREAT, {}))
602 # cannot write to a new file in an immutable directory
603 d.addCallback(lambda ign:
604 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/newfile WRITE|CREAT|TRUNC denied",
605 self.handler.openFile, "tiny_lit_dir/newfile",
606 sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
608 # cannot write to an existing immutable file in an immutable directory (with or without CREAT and EXCL)
609 d.addCallback(lambda ign:
610 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/short WRITE denied",
611 self.handler.openFile, "tiny_lit_dir/short", sftp.FXF_WRITE, {}))
612 d.addCallback(lambda ign:
613 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/short WRITE|CREAT denied",
614 self.handler.openFile, "tiny_lit_dir/short",
615 sftp.FXF_WRITE | sftp.FXF_CREAT, {}))
617 # cannot write to a mutable file via a readonly cap (by path or uri)
618 d.addCallback(lambda ign:
619 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile readonly WRITE denied",
620 self.handler.openFile, "readonly", sftp.FXF_WRITE, {}))
621 d.addCallback(lambda ign:
622 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile readonly uri WRITE denied",
623 self.handler.openFile, "uri/"+self.readonly_uri, sftp.FXF_WRITE, {}))
625 # cannot create a file with the EXCL flag if it already exists
626 d.addCallback(lambda ign:
627 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "openFile small WRITE|CREAT|EXCL failure",
628 self.handler.openFile, "small",
629 sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
630 d.addCallback(lambda ign:
631 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "openFile mutable WRITE|CREAT|EXCL failure",
632 self.handler.openFile, "mutable",
633 sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
634 d.addCallback(lambda ign:
635 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "openFile mutable uri WRITE|CREAT|EXCL failure",
636 self.handler.openFile, "uri/"+self.mutable_uri,
637 sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
638 d.addCallback(lambda ign:
639 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "openFile tiny_lit_dir/short WRITE|CREAT|EXCL failure",
640 self.handler.openFile, "tiny_lit_dir/short",
641 sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
643 # cannot write to an immutable file if we don't have its parent (with or without CREAT, TRUNC, or EXCL)
644 d.addCallback(lambda ign:
645 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small uri WRITE denied",
646 self.handler.openFile, "uri/"+self.small_uri, sftp.FXF_WRITE, {}))
647 d.addCallback(lambda ign:
648 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small uri WRITE|CREAT denied",
649 self.handler.openFile, "uri/"+self.small_uri,
650 sftp.FXF_WRITE | sftp.FXF_CREAT, {}))
651 d.addCallback(lambda ign:
652 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small uri WRITE|CREAT|TRUNC denied",
653 self.handler.openFile, "uri/"+self.small_uri,
654 sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
655 d.addCallback(lambda ign:
656 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small uri WRITE|CREAT|EXCL denied",
657 self.handler.openFile, "uri/"+self.small_uri,
658 sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
660 # test creating a new file with truncation and extension
661 d.addCallback(lambda ign:
662 self.handler.openFile("newfile", sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
664 d2 = wf.writeChunk(0, "0123456789")
665 d2.addCallback(lambda res: self.failUnlessReallyEqual(res, None))
667 d2.addCallback(lambda ign: wf.writeChunk(8, "0123"))
668 d2.addCallback(lambda ign: wf.writeChunk(13, "abc"))
670 d2.addCallback(lambda ign: wf.getAttrs())
671 d2.addCallback(lambda attrs: self._compareAttributes(attrs, {'permissions': S_IFREG | 0666, 'size': 16}))
673 d2.addCallback(lambda ign: self.handler.getAttrs("newfile", followLinks=0))
674 d2.addCallback(lambda attrs: self._compareAttributes(attrs, {'permissions': S_IFREG | 0666, 'size': 16}))
676 d2.addCallback(lambda ign: wf.setAttrs({}))
678 d2.addCallback(lambda ign:
679 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "setAttrs with negative size bad",
680 wf.setAttrs, {'size': -1}))
682 d2.addCallback(lambda ign: wf.setAttrs({'size': 14}))
683 d2.addCallback(lambda ign: wf.getAttrs())
684 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['size'], 14))
686 d2.addCallback(lambda ign: wf.setAttrs({'size': 14}))
687 d2.addCallback(lambda ign: wf.getAttrs())
688 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['size'], 14))
690 d2.addCallback(lambda ign: wf.setAttrs({'size': 17}))
691 d2.addCallback(lambda ign: wf.getAttrs())
692 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['size'], 17))
693 d2.addCallback(lambda ign: self.handler.getAttrs("newfile", followLinks=0))
694 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['size'], 17))
696 d2.addCallback(lambda ign:
697 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "readChunk on write-only handle denied",
700 d2.addCallback(lambda ign: wf.close())
702 d2.addCallback(lambda ign:
703 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "writeChunk on closed file bad",
704 wf.writeChunk, 0, "a"))
705 d2.addCallback(lambda ign:
706 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "setAttrs on closed file bad",
707 wf.setAttrs, {'size': 0}))
709 d2.addCallback(lambda ign: wf.close()) # should be no-op
711 d.addCallback(_write)
712 d.addCallback(lambda ign: self.root.get(u"newfile"))
713 d.addCallback(lambda node: download_to_data(node))
714 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345670123\x00a\x00\x00\x00"))
716 # test APPEND flag, and also replacing an existing file ("newfile" created by the previous test)
717 d.addCallback(lambda ign:
718 self.handler.openFile("newfile", sftp.FXF_WRITE | sftp.FXF_CREAT |
719 sftp.FXF_TRUNC | sftp.FXF_APPEND, {}))
720 def _write_append(wf):
721 d2 = wf.writeChunk(0, "0123456789")
722 d2.addCallback(lambda ign: wf.writeChunk(8, "0123"))
724 d2.addCallback(lambda ign: wf.setAttrs({'size': 17}))
725 d2.addCallback(lambda ign: wf.getAttrs())
726 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['size'], 17))
728 d2.addCallback(lambda ign: wf.writeChunk(0, "z"))
729 d2.addCallback(lambda ign: wf.close())
731 d.addCallback(_write_append)
732 d.addCallback(lambda ign: self.root.get(u"newfile"))
733 d.addCallback(lambda node: download_to_data(node))
734 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "01234567890123\x00\x00\x00z"))
736 # test WRITE | TRUNC without CREAT, when the file already exists
737 # This is invalid according to section 6.3 of the SFTP spec, but required for interoperability,
738 # since POSIX does allow O_WRONLY | O_TRUNC.
739 d.addCallback(lambda ign:
740 self.handler.openFile("newfile", sftp.FXF_WRITE | sftp.FXF_TRUNC, {}))
741 def _write_trunc(wf):
742 d2 = wf.writeChunk(0, "01234")
743 d2.addCallback(lambda ign: wf.close())
745 d.addCallback(_write_trunc)
746 d.addCallback(lambda ign: self.root.get(u"newfile"))
747 d.addCallback(lambda node: download_to_data(node))
748 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "01234"))
750 # test WRITE | TRUNC with permissions: 0
751 d.addCallback(lambda ign:
752 self.handler.openFile("newfile", sftp.FXF_WRITE | sftp.FXF_TRUNC, {'permissions': 0}))
753 d.addCallback(_write_trunc)
754 d.addCallback(lambda ign: self.root.get(u"newfile"))
755 d.addCallback(lambda node: download_to_data(node))
756 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "01234"))
757 d.addCallback(lambda ign: self.root.get_metadata_for(u"newfile"))
758 d.addCallback(lambda metadata: self.failIf(metadata.get('no-write', False), metadata))
761 d.addCallback(lambda ign:
762 self.handler.openFile("excl", sftp.FXF_WRITE | sftp.FXF_CREAT |
763 sftp.FXF_TRUNC | sftp.FXF_EXCL, {}))
765 d2 = self.root.get(u"excl")
766 d2.addCallback(lambda node: download_to_data(node))
767 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
769 d2.addCallback(lambda ign: wf.writeChunk(0, "0123456789"))
770 d2.addCallback(lambda ign: wf.close())
772 d.addCallback(_write_excl)
773 d.addCallback(lambda ign: self.root.get(u"excl"))
774 d.addCallback(lambda node: download_to_data(node))
775 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
777 # test that writing a zero-length file with EXCL only updates the directory once
778 d.addCallback(lambda ign:
779 self.handler.openFile("zerolength", sftp.FXF_WRITE | sftp.FXF_CREAT |
781 def _write_excl_zerolength(wf):
782 d2 = self.root.get(u"zerolength")
783 d2.addCallback(lambda node: download_to_data(node))
784 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
786 # FIXME: no API to get the best version number exists (fix as part of #993)
788 d2.addCallback(lambda ign: self.root.get_best_version_number())
789 def _check_version(version):
791 d3.addCallback(lambda ign: self.root.get_best_version_number())
792 d3.addCallback(lambda new_version: self.failUnlessReallyEqual(new_version, version))
794 d2.addCallback(_check_version)
796 d2.addCallback(lambda ign: wf.close())
798 d.addCallback(_write_excl_zerolength)
799 d.addCallback(lambda ign: self.root.get(u"zerolength"))
800 d.addCallback(lambda node: download_to_data(node))
801 d.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
803 # test WRITE | CREAT | EXCL | APPEND
804 d.addCallback(lambda ign:
805 self.handler.openFile("exclappend", sftp.FXF_WRITE | sftp.FXF_CREAT |
806 sftp.FXF_EXCL | sftp.FXF_APPEND, {}))
807 def _write_excl_append(wf):
808 d2 = self.root.get(u"exclappend")
809 d2.addCallback(lambda node: download_to_data(node))
810 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
812 d2.addCallback(lambda ign: wf.writeChunk(10, "0123456789"))
813 d2.addCallback(lambda ign: wf.writeChunk(5, "01234"))
814 d2.addCallback(lambda ign: wf.close())
816 d.addCallback(_write_excl_append)
817 d.addCallback(lambda ign: self.root.get(u"exclappend"))
818 d.addCallback(lambda node: download_to_data(node))
819 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345678901234"))
821 # test WRITE | CREAT | APPEND when the file does not already exist
822 d.addCallback(lambda ign:
823 self.handler.openFile("creatappend", sftp.FXF_WRITE | sftp.FXF_CREAT |
824 sftp.FXF_APPEND, {}))
825 def _write_creat_append_new(wf):
826 d2 = wf.writeChunk(10, "0123456789")
827 d2.addCallback(lambda ign: wf.writeChunk(5, "01234"))
828 d2.addCallback(lambda ign: wf.close())
830 d.addCallback(_write_creat_append_new)
831 d.addCallback(lambda ign: self.root.get(u"creatappend"))
832 d.addCallback(lambda node: download_to_data(node))
833 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345678901234"))
835 # ... and when it does exist
836 d.addCallback(lambda ign:
837 self.handler.openFile("creatappend", sftp.FXF_WRITE | sftp.FXF_CREAT |
838 sftp.FXF_APPEND, {}))
839 def _write_creat_append_existing(wf):
840 d2 = wf.writeChunk(5, "01234")
841 d2.addCallback(lambda ign: wf.close())
843 d.addCallback(_write_creat_append_existing)
844 d.addCallback(lambda ign: self.root.get(u"creatappend"))
845 d.addCallback(lambda node: download_to_data(node))
846 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "01234567890123401234"))
848 # test WRITE | CREAT without TRUNC, when the file does not already exist
849 d.addCallback(lambda ign:
850 self.handler.openFile("newfile2", sftp.FXF_WRITE | sftp.FXF_CREAT, {}))
851 def _write_creat_new(wf):
852 d2 = wf.writeChunk(0, "0123456789")
853 d2.addCallback(lambda ign: wf.close())
855 d.addCallback(_write_creat_new)
856 d.addCallback(lambda ign: self.root.get(u"newfile2"))
857 d.addCallback(lambda node: download_to_data(node))
858 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
860 # ... and when it does exist
861 d.addCallback(lambda ign:
862 self.handler.openFile("newfile2", sftp.FXF_WRITE | sftp.FXF_CREAT, {}))
863 def _write_creat_existing(wf):
864 d2 = wf.writeChunk(0, "abcde")
865 d2.addCallback(lambda ign: wf.close())
867 d.addCallback(_write_creat_existing)
868 d.addCallback(lambda ign: self.root.get(u"newfile2"))
869 d.addCallback(lambda node: download_to_data(node))
870 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "abcde56789"))
872 d.addCallback(lambda ign: self.root.set_node(u"mutable2", self.mutable))
874 # test writing to a mutable file
875 d.addCallback(lambda ign:
876 self.handler.openFile("mutable", sftp.FXF_WRITE, {}))
877 def _write_mutable(wf):
878 d2 = wf.writeChunk(8, "new!")
879 d2.addCallback(lambda ign: wf.close())
881 d.addCallback(_write_mutable)
882 d.addCallback(lambda ign: self.root.get(u"mutable"))
883 def _check_same_file(node):
884 self.failUnless(node.is_mutable())
885 self.failIf(node.is_readonly())
886 self.failUnlessReallyEqual(node.get_uri(), self.mutable_uri)
887 return node.download_best_version()
888 d.addCallback(_check_same_file)
889 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "mutable new! contents"))
891 # ... and with permissions, which should be ignored
892 d.addCallback(lambda ign:
893 self.handler.openFile("mutable", sftp.FXF_WRITE, {'permissions': 0}))
894 d.addCallback(_write_mutable)
895 d.addCallback(lambda ign: self.root.get(u"mutable"))
896 d.addCallback(_check_same_file)
897 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "mutable new! contents"))
899 # ... and with a setAttrs call that diminishes the parent link to read-only, first by path
900 d.addCallback(lambda ign:
901 self.handler.openFile("mutable", sftp.FXF_WRITE, {}))
902 def _write_mutable_setattr(wf):
903 d2 = wf.writeChunk(8, "read-only link from parent")
905 d2.addCallback(lambda ign: self.handler.setAttrs("mutable", {'permissions': 0444}))
907 d2.addCallback(lambda ign: self.root.get(u"mutable"))
908 d2.addCallback(lambda node: self.failUnless(node.is_readonly()))
910 d2.addCallback(lambda ign: wf.getAttrs())
911 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['permissions'], S_IFREG | 0666))
912 d2.addCallback(lambda ign: self.handler.getAttrs("mutable", followLinks=0))
913 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['permissions'], S_IFREG | 0444))
915 d2.addCallback(lambda ign: wf.close())
917 d.addCallback(_write_mutable_setattr)
918 d.addCallback(lambda ign: self.root.get(u"mutable"))
919 def _check_readonly_file(node):
920 self.failUnless(node.is_mutable())
921 self.failUnless(node.is_readonly())
922 self.failUnlessReallyEqual(node.get_write_uri(), None)
923 self.failUnlessReallyEqual(node.get_storage_index(), self.mutable.get_storage_index())
924 return node.download_best_version()
925 d.addCallback(_check_readonly_file)
926 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "mutable read-only link from parent"))
928 # ... and then by handle
929 d.addCallback(lambda ign:
930 self.handler.openFile("mutable2", sftp.FXF_WRITE, {}))
931 def _write_mutable2_setattr(wf):
932 d2 = wf.writeChunk(7, "2")
934 d2.addCallback(lambda ign: wf.setAttrs({'permissions': 0444, 'size': 8}))
936 # The link isn't made read-only until the file is closed.
937 d2.addCallback(lambda ign: self.root.get(u"mutable2"))
938 d2.addCallback(lambda node: self.failIf(node.is_readonly()))
940 d2.addCallback(lambda ign: wf.getAttrs())
941 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['permissions'], S_IFREG | 0444))
942 d2.addCallback(lambda ign: self.handler.getAttrs("mutable2", followLinks=0))
943 d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['permissions'], S_IFREG | 0666))
945 d2.addCallback(lambda ign: wf.close())
947 d.addCallback(_write_mutable2_setattr)
948 d.addCallback(lambda ign: self.root.get(u"mutable2"))
949 d.addCallback(_check_readonly_file) # from above
950 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "mutable2"))
952 # test READ | WRITE without CREAT or TRUNC
953 d.addCallback(lambda ign:
954 self.handler.openFile("small", sftp.FXF_READ | sftp.FXF_WRITE, {}))
955 def _read_write(rwf):
956 d2 = rwf.writeChunk(8, "0123")
957 # test immediate read starting after the old end-of-file
958 d2.addCallback(lambda ign: rwf.readChunk(11, 1))
959 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "3"))
960 d2.addCallback(lambda ign: rwf.readChunk(0, 100))
961 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345670123"))
962 d2.addCallback(lambda ign: rwf.close())
964 d.addCallback(_read_write)
965 d.addCallback(lambda ign: self.root.get(u"small"))
966 d.addCallback(lambda node: download_to_data(node))
967 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345670123"))
969 # test WRITE and rename while still open
970 d.addCallback(lambda ign:
971 self.handler.openFile("small", sftp.FXF_WRITE, {}))
972 def _write_rename(wf):
973 d2 = wf.writeChunk(0, "abcd")
974 d2.addCallback(lambda ign: self.handler.renameFile("small", "renamed"))
975 d2.addCallback(lambda ign: wf.writeChunk(4, "efgh"))
976 d2.addCallback(lambda ign: wf.close())
978 d.addCallback(_write_rename)
979 d.addCallback(lambda ign: self.root.get(u"renamed"))
980 d.addCallback(lambda node: download_to_data(node))
981 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "abcdefgh0123"))
982 d.addCallback(lambda ign:
983 self.shouldFail(NoSuchChildError, "rename small while open", "small",
984 self.root.get, u"small"))
986 # test WRITE | CREAT | EXCL and rename while still open
987 d.addCallback(lambda ign:
988 self.handler.openFile("newexcl", sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
989 def _write_creat_excl_rename(wf):
990 d2 = wf.writeChunk(0, "abcd")
991 d2.addCallback(lambda ign: self.handler.renameFile("newexcl", "renamedexcl"))
992 d2.addCallback(lambda ign: wf.writeChunk(4, "efgh"))
993 d2.addCallback(lambda ign: wf.close())
995 d.addCallback(_write_creat_excl_rename)
996 d.addCallback(lambda ign: self.root.get(u"renamedexcl"))
997 d.addCallback(lambda node: download_to_data(node))
998 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "abcdefgh"))
999 d.addCallback(lambda ign:
1000 self.shouldFail(NoSuchChildError, "rename newexcl while open", "newexcl",
1001 self.root.get, u"newexcl"))
1003 # it should be possible to rename even before the open has completed
1004 def _open_and_rename_race(ign):
1005 slow_open = defer.Deferred()
1006 reactor.callLater(1, slow_open.callback, None)
1007 d2 = self.handler.openFile("new", sftp.FXF_WRITE | sftp.FXF_CREAT, {}, delay=slow_open)
1009 # deliberate race between openFile and renameFile
1010 d3 = self.handler.renameFile("new", "new2")
1011 d3.addErrback(lambda err: self.fail("renameFile failed: %r" % (err,)))
1013 d.addCallback(_open_and_rename_race)
1014 def _write_rename_race(wf):
1015 d2 = wf.writeChunk(0, "abcd")
1016 d2.addCallback(lambda ign: wf.close())
1018 d.addCallback(_write_rename_race)
1019 d.addCallback(lambda ign: self.root.get(u"new2"))
1020 d.addCallback(lambda node: download_to_data(node))
1021 d.addCallback(lambda data: self.failUnlessReallyEqual(data, "abcd"))
1022 d.addCallback(lambda ign:
1023 self.shouldFail(NoSuchChildError, "rename new while open", "new",
1024 self.root.get, u"new"))
1026 # check that failed downloads cause failed reads and failed close, when open for writing
1027 gross = u"gro\u00DF".encode("utf-8")
1028 d.addCallback(lambda ign: self.handler.openFile(gross, sftp.FXF_READ | sftp.FXF_WRITE, {}))
1029 def _read_write_broken(rwf):
1030 d2 = rwf.writeChunk(0, "abcdefghij")
1031 d2.addCallback(lambda ign: self.g.nuke_from_orbit())
1033 # reading should fail (reliably if we read past the written chunk)
1034 d2.addCallback(lambda ign:
1035 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "read/write broken",
1036 rwf.readChunk, 0, 100))
1037 # close should fail in this case
1038 d2.addCallback(lambda ign:
1039 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "read/write broken close",
1042 d.addCallback(_read_write_broken)
1044 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
1045 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
1048 def test_removeFile(self):
1049 d = self._set_up("removeFile")
1050 d.addCallback(lambda ign: self._set_up_tree())
1052 d.addCallback(lambda ign:
1053 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nofile",
1054 self.handler.removeFile, "nofile"))
1055 d.addCallback(lambda ign:
1056 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nofile",
1057 self.handler.removeFile, "nofile"))
1058 d.addCallback(lambda ign:
1059 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nodir/file",
1060 self.handler.removeFile, "nodir/file"))
1061 d.addCallback(lambda ign:
1062 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removefile ''",
1063 self.handler.removeFile, ""))
1065 # removing a directory should fail
1066 d.addCallback(lambda ign:
1067 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "removeFile tiny_lit_dir",
1068 self.handler.removeFile, "tiny_lit_dir"))
1070 # removing a file should succeed
1071 d.addCallback(lambda ign: self.root.get(u"gro\u00DF"))
1072 d.addCallback(lambda ign: self.handler.removeFile(u"gro\u00DF".encode('utf-8')))
1073 d.addCallback(lambda ign:
1074 self.shouldFail(NoSuchChildError, "removeFile gross", "gro\\xdf",
1075 self.root.get, u"gro\u00DF"))
1077 # removing an unknown should succeed
1078 d.addCallback(lambda ign: self.root.get(u"unknown"))
1079 d.addCallback(lambda ign: self.handler.removeFile("unknown"))
1080 d.addCallback(lambda ign:
1081 self.shouldFail(NoSuchChildError, "removeFile unknown", "unknown",
1082 self.root.get, u"unknown"))
1084 # removing a link to an open file should not prevent it from being read
1085 d.addCallback(lambda ign: self.handler.openFile("small", sftp.FXF_READ, {}))
1086 def _remove_and_read_small(rf):
1087 d2 = self.handler.removeFile("small")
1088 d2.addCallback(lambda ign:
1089 self.shouldFail(NoSuchChildError, "removeFile small", "small",
1090 self.root.get, u"small"))
1091 d2.addCallback(lambda ign: rf.readChunk(0, 10))
1092 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
1093 d2.addCallback(lambda ign: rf.close())
1095 d.addCallback(_remove_and_read_small)
1097 # removing a link to a created file should prevent it from being created
1098 d.addCallback(lambda ign: self.handler.openFile("tempfile", sftp.FXF_READ | sftp.FXF_WRITE |
1099 sftp.FXF_CREAT, {}))
1100 def _write_remove(rwf):
1101 d2 = rwf.writeChunk(0, "0123456789")
1102 d2.addCallback(lambda ign: self.handler.removeFile("tempfile"))
1103 d2.addCallback(lambda ign: rwf.readChunk(0, 10))
1104 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
1105 d2.addCallback(lambda ign: rwf.close())
1107 d.addCallback(_write_remove)
1108 d.addCallback(lambda ign:
1109 self.shouldFail(NoSuchChildError, "removeFile tempfile", "tempfile",
1110 self.root.get, u"tempfile"))
1112 # ... even if the link is renamed while open
1113 d.addCallback(lambda ign: self.handler.openFile("tempfile2", sftp.FXF_READ | sftp.FXF_WRITE |
1114 sftp.FXF_CREAT, {}))
1115 def _write_rename_remove(rwf):
1116 d2 = rwf.writeChunk(0, "0123456789")
1117 d2.addCallback(lambda ign: self.handler.renameFile("tempfile2", "tempfile3"))
1118 d2.addCallback(lambda ign: self.handler.removeFile("tempfile3"))
1119 d2.addCallback(lambda ign: rwf.readChunk(0, 10))
1120 d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
1121 d2.addCallback(lambda ign: rwf.close())
1123 d.addCallback(_write_rename_remove)
1124 d.addCallback(lambda ign:
1125 self.shouldFail(NoSuchChildError, "removeFile tempfile2", "tempfile2",
1126 self.root.get, u"tempfile2"))
1127 d.addCallback(lambda ign:
1128 self.shouldFail(NoSuchChildError, "removeFile tempfile3", "tempfile3",
1129 self.root.get, u"tempfile3"))
1131 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
1132 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
1135 def test_removeDirectory(self):
1136 d = self._set_up("removeDirectory")
1137 d.addCallback(lambda ign: self._set_up_tree())
1139 d.addCallback(lambda ign:
1140 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory nodir",
1141 self.handler.removeDirectory, "nodir"))
1142 d.addCallback(lambda ign:
1143 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory nodir/nodir",
1144 self.handler.removeDirectory, "nodir/nodir"))
1145 d.addCallback(lambda ign:
1146 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory ''",
1147 self.handler.removeDirectory, ""))
1149 # removing a file should fail
1150 d.addCallback(lambda ign:
1151 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "removeDirectory gross",
1152 self.handler.removeDirectory, u"gro\u00DF".encode('utf-8')))
1154 # removing a directory should succeed
1155 d.addCallback(lambda ign: self.root.get(u"tiny_lit_dir"))
1156 d.addCallback(lambda ign: self.handler.removeDirectory("tiny_lit_dir"))
1157 d.addCallback(lambda ign:
1158 self.shouldFail(NoSuchChildError, "removeDirectory tiny_lit_dir", "tiny_lit_dir",
1159 self.root.get, u"tiny_lit_dir"))
1161 # removing an unknown should succeed
1162 d.addCallback(lambda ign: self.root.get(u"unknown"))
1163 d.addCallback(lambda ign: self.handler.removeDirectory("unknown"))
1164 d.addCallback(lambda err:
1165 self.shouldFail(NoSuchChildError, "removeDirectory unknown", "unknown",
1166 self.root.get, u"unknown"))
1168 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
1169 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
1172 def test_renameFile(self):
1173 d = self._set_up("renameFile")
1174 d.addCallback(lambda ign: self._set_up_tree())
1176 # renaming a non-existent file should fail
1177 d.addCallback(lambda ign:
1178 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile nofile newfile",
1179 self.handler.renameFile, "nofile", "newfile"))
1180 d.addCallback(lambda ign:
1181 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile '' newfile",
1182 self.handler.renameFile, "", "newfile"))
1184 # renaming a file to a non-existent path should fail
1185 d.addCallback(lambda ign:
1186 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small nodir/small",
1187 self.handler.renameFile, "small", "nodir/small"))
1189 # renaming a file to an invalid UTF-8 name should fail
1190 d.addCallback(lambda ign:
1191 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small invalid",
1192 self.handler.renameFile, "small", "\xFF"))
1194 # renaming a file to or from an URI should fail
1195 d.addCallback(lambda ign:
1196 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small from uri",
1197 self.handler.renameFile, "uri/"+self.small_uri, "new"))
1198 d.addCallback(lambda ign:
1199 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small to uri",
1200 self.handler.renameFile, "small", "uri/fake_uri"))
1202 # renaming a file onto an existing file, directory or unknown should fail
1203 # The SFTP spec isn't clear about what error should be returned, but sshfs depends on
1204 # it being FX_PERMISSION_DENIED.
1205 d.addCallback(lambda ign:
1206 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small small2",
1207 self.handler.renameFile, "small", "small2"))
1208 d.addCallback(lambda ign:
1209 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small tiny_lit_dir",
1210 self.handler.renameFile, "small", "tiny_lit_dir"))
1211 d.addCallback(lambda ign:
1212 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small unknown",
1213 self.handler.renameFile, "small", "unknown"))
1215 # renaming a file onto a heisenfile should fail, even if the open hasn't completed
1216 def _rename_onto_heisenfile_race(wf):
1217 slow_open = defer.Deferred()
1218 reactor.callLater(1, slow_open.callback, None)
1220 d2 = self.handler.openFile("heisenfile", sftp.FXF_WRITE | sftp.FXF_CREAT, {}, delay=slow_open)
1222 # deliberate race between openFile and renameFile
1223 d3 = self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small heisenfile",
1224 self.handler.renameFile, "small", "heisenfile")
1225 d2.addCallback(lambda wf: wf.close())
1226 return deferredutil.gatherResults([d2, d3])
1227 d.addCallback(_rename_onto_heisenfile_race)
1229 # renaming a file to a correct path should succeed
1230 d.addCallback(lambda ign: self.handler.renameFile("small", "new_small"))
1231 d.addCallback(lambda ign: self.root.get(u"new_small"))
1232 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.small_uri))
1234 # renaming a file into a subdirectory should succeed (also tests Unicode names)
1235 d.addCallback(lambda ign: self.handler.renameFile(u"gro\u00DF".encode('utf-8'),
1236 u"loop/neue_gro\u00DF".encode('utf-8')))
1237 d.addCallback(lambda ign: self.root.get(u"neue_gro\u00DF"))
1238 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.gross_uri))
1240 # renaming a directory to a correct path should succeed
1241 d.addCallback(lambda ign: self.handler.renameFile("tiny_lit_dir", "new_tiny_lit_dir"))
1242 d.addCallback(lambda ign: self.root.get(u"new_tiny_lit_dir"))
1243 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.tiny_lit_dir_uri))
1245 # renaming an unknown to a correct path should succeed
1246 d.addCallback(lambda ign: self.handler.renameFile("unknown", "new_unknown"))
1247 d.addCallback(lambda ign: self.root.get(u"new_unknown"))
1248 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.unknown_uri))
1250 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
1251 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
1254 def test_renameFile_posix(self):
1255 def _renameFile(fromPathstring, toPathstring):
1256 extData = (struct.pack('>L', len(fromPathstring)) + fromPathstring +
1257 struct.pack('>L', len(toPathstring)) + toPathstring)
1259 d2 = self.handler.extendedRequest('posix-rename@openssh.com', extData)
1261 res.trap(sftp.SFTPError)
1262 if res.value.code == sftp.FX_OK:
1265 d2.addCallbacks(lambda res: self.fail("posix-rename request was supposed to "
1266 "raise an SFTPError, not get '%r'" % (res,)),
1270 d = self._set_up("renameFile_posix")
1271 d.addCallback(lambda ign: self._set_up_tree())
1273 d.addCallback(lambda ign: self.root.set_node(u"loop2", self.root))
1274 d.addCallback(lambda ign: self.root.set_node(u"unknown2", self.unknown))
1276 # POSIX-renaming a non-existent file should fail
1277 d.addCallback(lambda ign:
1278 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile_posix nofile newfile",
1279 _renameFile, "nofile", "newfile"))
1280 d.addCallback(lambda ign:
1281 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile_posix '' newfile",
1282 _renameFile, "", "newfile"))
1284 # POSIX-renaming a file to a non-existent path should fail
1285 d.addCallback(lambda ign:
1286 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile_posix small nodir/small",
1287 _renameFile, "small", "nodir/small"))
1289 # POSIX-renaming a file to an invalid UTF-8 name should fail
1290 d.addCallback(lambda ign:
1291 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile_posix small invalid",
1292 _renameFile, "small", "\xFF"))
1294 # POSIX-renaming a file to or from an URI should fail
1295 d.addCallback(lambda ign:
1296 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile_posix small from uri",
1297 _renameFile, "uri/"+self.small_uri, "new"))
1298 d.addCallback(lambda ign:
1299 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile_posix small to uri",
1300 _renameFile, "small", "uri/fake_uri"))
1302 # POSIX-renaming a file onto an existing file, directory or unknown should succeed
1303 d.addCallback(lambda ign: _renameFile("small", "small2"))
1304 d.addCallback(lambda ign: self.root.get(u"small2"))
1305 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.small_uri))
1307 d.addCallback(lambda ign: _renameFile("small2", "loop2"))
1308 d.addCallback(lambda ign: self.root.get(u"loop2"))
1309 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.small_uri))
1311 d.addCallback(lambda ign: _renameFile("loop2", "unknown2"))
1312 d.addCallback(lambda ign: self.root.get(u"unknown2"))
1313 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.small_uri))
1315 # POSIX-renaming a file to a correct new path should succeed
1316 d.addCallback(lambda ign: _renameFile("unknown2", "new_small"))
1317 d.addCallback(lambda ign: self.root.get(u"new_small"))
1318 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.small_uri))
1320 # POSIX-renaming a file into a subdirectory should succeed (also tests Unicode names)
1321 d.addCallback(lambda ign: _renameFile(u"gro\u00DF".encode('utf-8'),
1322 u"loop/neue_gro\u00DF".encode('utf-8')))
1323 d.addCallback(lambda ign: self.root.get(u"neue_gro\u00DF"))
1324 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.gross_uri))
1326 # POSIX-renaming a directory to a correct path should succeed
1327 d.addCallback(lambda ign: _renameFile("tiny_lit_dir", "new_tiny_lit_dir"))
1328 d.addCallback(lambda ign: self.root.get(u"new_tiny_lit_dir"))
1329 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.tiny_lit_dir_uri))
1331 # POSIX-renaming an unknown to a correct path should succeed
1332 d.addCallback(lambda ign: _renameFile("unknown", "new_unknown"))
1333 d.addCallback(lambda ign: self.root.get(u"new_unknown"))
1334 d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.unknown_uri))
1336 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
1337 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
1340 def test_makeDirectory(self):
1341 d = self._set_up("makeDirectory")
1342 d.addCallback(lambda ign: self._set_up_tree())
1344 # making a directory at a correct path should succeed
1345 d.addCallback(lambda ign: self.handler.makeDirectory("newdir", {'ext_foo': 'bar', 'ctime': 42}))
1347 d.addCallback(lambda ign: self.root.get_child_and_metadata(u"newdir"))
1348 def _got( (child, metadata) ):
1349 self.failUnless(IDirectoryNode.providedBy(child))
1350 self.failUnless(child.is_mutable())
1352 #self.failUnless('ctime' in metadata, metadata)
1353 #self.failUnlessReallyEqual(metadata['ctime'], 42)
1354 #self.failUnless('ext_foo' in metadata, metadata)
1355 #self.failUnlessReallyEqual(metadata['ext_foo'], 'bar')
1356 # TODO: child should be empty
1359 # making intermediate directories should also succeed
1360 d.addCallback(lambda ign: self.handler.makeDirectory("newparent/newchild", {}))
1362 d.addCallback(lambda ign: self.root.get(u"newparent"))
1363 def _got_newparent(newparent):
1364 self.failUnless(IDirectoryNode.providedBy(newparent))
1365 self.failUnless(newparent.is_mutable())
1366 return newparent.get(u"newchild")
1367 d.addCallback(_got_newparent)
1369 def _got_newchild(newchild):
1370 self.failUnless(IDirectoryNode.providedBy(newchild))
1371 self.failUnless(newchild.is_mutable())
1372 d.addCallback(_got_newchild)
1374 d.addCallback(lambda ign:
1375 self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "makeDirectory invalid UTF-8",
1376 self.handler.makeDirectory, "\xFF", {}))
1378 # should fail because there is an existing file "small"
1379 d.addCallback(lambda ign:
1380 self.shouldFailWithSFTPError(sftp.FX_FAILURE, "makeDirectory small",
1381 self.handler.makeDirectory, "small", {}))
1383 # directories cannot be created read-only via SFTP
1384 d.addCallback(lambda ign:
1385 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "makeDirectory newdir2 permissions:0444 denied",
1386 self.handler.makeDirectory, "newdir2",
1387 {'permissions': 0444}))
1389 d.addCallback(lambda ign: self.failUnlessEqual(sftpd.all_heisenfiles, {}))
1390 d.addCallback(lambda ign: self.failUnlessEqual(self.handler._heisenfiles, {}))
1393 def test_execCommand_and_openShell(self):
1400 def write(self, data):
1401 return self.outReceived(data)
1403 def outReceived(self, data):
1405 return defer.succeed(None)
1407 def errReceived(self, data):
1409 return defer.succeed(None)
1411 def processEnded(self, reason):
1412 self.reason = reason
1413 return defer.succeed(None)
1415 def _lines_end_in_crlf(s):
1416 return s.replace('\r\n', '').find('\n') == -1 and s.endswith('\r\n')
1418 d = self._set_up("execCommand_and_openShell")
1420 d.addCallback(lambda ign: conch_interfaces.ISession(self.handler))
1421 def _exec_df(session):
1422 protocol = MockProtocol()
1423 d2 = session.execCommand(protocol, "df -P -k /")
1424 d2.addCallback(lambda ign: self.failUnlessIn("1024-blocks", protocol.output))
1425 d2.addCallback(lambda ign: self.failUnless(_lines_end_in_crlf(protocol.output), protocol.output))
1426 d2.addCallback(lambda ign: self.failUnlessEqual(protocol.error, ""))
1427 d2.addCallback(lambda ign: self.failUnless(isinstance(protocol.reason.value, ProcessDone)))
1428 d2.addCallback(lambda ign: session.eofReceived())
1429 d2.addCallback(lambda ign: session.closed())
1431 d.addCallback(_exec_df)
1433 def _check_unsupported(protocol):
1434 d2 = defer.succeed(None)
1435 d2.addCallback(lambda ign: self.failUnlessEqual(protocol.output, ""))
1436 d2.addCallback(lambda ign: self.failUnlessIn("only the SFTP protocol", protocol.error))
1437 d2.addCallback(lambda ign: self.failUnless(_lines_end_in_crlf(protocol.error), protocol.error))
1438 d2.addCallback(lambda ign: self.failUnless(isinstance(protocol.reason.value, ProcessTerminated)))
1439 d2.addCallback(lambda ign: self.failUnlessEqual(protocol.reason.value.exitCode, 1))
1442 d.addCallback(lambda ign: conch_interfaces.ISession(self.handler))
1443 def _exec_error(session):
1444 protocol = MockProtocol()
1445 d2 = session.execCommand(protocol, "error")
1446 d2.addCallback(lambda ign: session.windowChanged(None))
1447 d2.addCallback(lambda ign: _check_unsupported(protocol))
1448 d2.addCallback(lambda ign: session.closed())
1450 d.addCallback(_exec_error)
1452 d.addCallback(lambda ign: conch_interfaces.ISession(self.handler))
1453 def _openShell(session):
1454 protocol = MockProtocol()
1455 d2 = session.openShell(protocol)
1456 d2.addCallback(lambda ign: _check_unsupported(protocol))
1457 d2.addCallback(lambda ign: session.closed())
1459 d.addCallback(_openShell)
1463 def test_extendedRequest(self):
1464 d = self._set_up("extendedRequest")
1466 d.addCallback(lambda ign: self.handler.extendedRequest("statvfs@openssh.com", "/"))
1468 self.failUnless(isinstance(res, str))
1469 self.failUnlessEqual(len(res), 8*11)
1470 d.addCallback(_check)
1472 d.addCallback(lambda ign:
1473 self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "extendedRequest foo bar",
1474 self.handler.extendedRequest, "foo", "bar"))
1476 d.addCallback(lambda ign:
1477 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "extendedRequest posix-rename@openssh.com invalid 1",
1478 self.handler.extendedRequest, 'posix-rename@openssh.com', ''))
1479 d.addCallback(lambda ign:
1480 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "extendedRequest posix-rename@openssh.com invalid 2",
1481 self.handler.extendedRequest, 'posix-rename@openssh.com', '\x00\x00\x00\x01'))
1482 d.addCallback(lambda ign:
1483 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "extendedRequest posix-rename@openssh.com invalid 3",
1484 self.handler.extendedRequest, 'posix-rename@openssh.com', '\x00\x00\x00\x01_\x00\x00\x00\x01'))