source file: /home/buildslave/tahoe/edgy/build/src/allmydata/web/filenode.py
file stats: 289 lines, 282 executed: 97.6% covered
1.
2. import simplejson
3.
4. from zope.interface import implements
5. from twisted.internet.interfaces import IConsumer
6. from twisted.web import http, static, resource, server
7. from twisted.internet import defer
8. from nevow import url, rend
9. from nevow.inevow import IRequest
10.
11. from allmydata.interfaces import IDownloadTarget, ExistingChildError
12. from allmydata.immutable.upload import FileHandle
13. from allmydata.util import log
14.
15. from allmydata.web.common import text_plain, WebError, IClient, RenderMixin, \
16. boolean_of_arg, get_arg, should_create_intermediate_directories
17. from allmydata.web.checker_results import CheckerResults
18.
19. class ReplaceMeMixin:
20.
21. def replace_me_with_a_child(self, ctx, replace):
22. # a new file is being uploaded in our place.
23. req = IRequest(ctx)
24. client = IClient(ctx)
25. mutable = boolean_of_arg(get_arg(req, "mutable", "false"))
26. if mutable:
27. req.content.seek(0)
28. data = req.content.read()
29. d = client.create_mutable_file(data)
30. def _uploaded(newnode):
31. d2 = self.parentnode.set_node(self.name, newnode,
32. overwrite=replace)
33. d2.addCallback(lambda res: newnode)
34. return d2
35. d.addCallback(_uploaded)
36. else:
37. uploadable = FileHandle(req.content, convergence=client.convergence)
38. d = self.parentnode.add_file(self.name, uploadable,
39. overwrite=replace)
40. def _done(filenode):
41. log.msg("webish upload complete",
42. facility="tahoe.webish", level=log.NOISY)
43. if self.node:
44. # we've replaced an existing file (or modified a mutable
45. # file), so the response code is 200
46. req.setResponseCode(http.OK)
47. else:
48. # we've created a new file, so the code is 201
49. req.setResponseCode(http.CREATED)
50. return filenode.get_uri()
51. d.addCallback(_done)
52. return d
53.
54. def replace_me_with_a_childcap(self, ctx, replace):
55. req = IRequest(ctx)
56. req.content.seek(0)
57. childcap = req.content.read()
58. client = IClient(ctx)
59. childnode = client.create_node_from_uri(childcap)
60. d = self.parentnode.set_node(self.name, childnode, overwrite=replace)
61. d.addCallback(lambda res: childnode.get_uri())
62. return d
63.
64. def _read_data_from_formpost(self, req):
65. # SDMF: files are small, and we can only upload data, so we read
66. # the whole file into memory before uploading.
67. contents = req.fields["file"]
68. contents.file.seek(0)
69. data = contents.file.read()
70. return data
71.
72. def replace_me_with_a_formpost(self, ctx, replace):
73. # create a new file, maybe mutable, maybe immutable
74. req = IRequest(ctx)
75. client = IClient(ctx)
76. mutable = boolean_of_arg(get_arg(req, "mutable", "false"))
77.
78. if mutable:
79. data = self._read_data_from_formpost(req)
80. d = client.create_mutable_file(data)
81. def _uploaded(newnode):
82. d2 = self.parentnode.set_node(self.name, newnode,
83. overwrite=replace)
84. d2.addCallback(lambda res: newnode.get_uri())
85. return d2
86. d.addCallback(_uploaded)
87. return d
88. # create an immutable file
89. contents = req.fields["file"]
90. uploadable = FileHandle(contents.file, convergence=client.convergence)
91. d = self.parentnode.add_file(self.name, uploadable, overwrite=replace)
92. d.addCallback(lambda newnode: newnode.get_uri())
93. return d
94.
95. class PlaceHolderNodeHandler(RenderMixin, rend.Page, ReplaceMeMixin):
96. def __init__(self, parentnode, name):
97. rend.Page.__init__(self)
98. assert parentnode
99. self.parentnode = parentnode
100. self.name = name
101. self.node = None
102.
103. def render_PUT(self, ctx):
104. req = IRequest(ctx)
105. t = get_arg(req, "t", "").strip()
106. replace = boolean_of_arg(get_arg(req, "replace", "true"))
107. assert self.parentnode and self.name
108. if not t:
109. return self.replace_me_with_a_child(ctx, replace)
110. if t == "uri":
111. return self.replace_me_with_a_childcap(ctx, replace)
112.
113. raise WebError("PUT to a file: bad t=%s" % t)
114.
115. def render_POST(self, ctx):
116. req = IRequest(ctx)
117. t = get_arg(req, "t", "").strip()
118. replace = boolean_of_arg(get_arg(req, "replace", "true"))
119. if t == "upload":
120. # like PUT, but get the file data from an HTML form's input field.
121. # We could get here from POST /uri/mutablefilecap?t=upload,
122. # or POST /uri/path/file?t=upload, or
123. # POST /uri/path/dir?t=upload&name=foo . All have the same
124. # behavior, we just ignore any name= argument
125. d = self.replace_me_with_a_formpost(ctx, replace)
126. else:
127. # t=mkdir is handled in DirectoryNodeHandler._POST_mkdir, so
128. # there are no other t= values left to be handled by the
129. # placeholder.
130. raise WebError("POST to a file: bad t=%s" % t)
131.
132. when_done = get_arg(req, "when_done", None)
133. if when_done:
134. d.addCallback(lambda res: url.URL.fromString(when_done))
135. return d
136.
137.
138. class FileNodeHandler(RenderMixin, rend.Page, ReplaceMeMixin):
139. def __init__(self, node, parentnode=None, name=None):
140. rend.Page.__init__(self)
141. assert node
142. self.node = node
143. self.parentnode = parentnode
144. self.name = name
145.
146. def childFactory(self, ctx, name):
147. req = IRequest(ctx)
148. if should_create_intermediate_directories(req):
149. raise WebError("Cannot create directory '%s', because its "
150. "parent is a file, not a directory" % name)
151. raise WebError("Files have no children, certainly not named '%s'"
152. % name)
153.
154. def render_GET(self, ctx):
155. req = IRequest(ctx)
156. t = get_arg(req, "t", "").strip()
157. if not t:
158. # just get the contents
159. save_to_file = boolean_of_arg(get_arg(req, "save", "False"))
160. # the filename arrives as part of the URL or in a form input
161. # element, and will be sent back in a Content-Disposition header.
162. # Different browsers use various character sets for this name,
163. # sometimes depending upon how language environment is
164. # configured. Firefox sends the equivalent of
165. # urllib.quote(name.encode("utf-8")), while IE7 sometimes does
166. # latin-1. Browsers cannot agree on how to interpret the name
167. # they see in the Content-Disposition header either, despite some
168. # 11-year old standards (RFC2231) that explain how to do it
169. # properly. So we assume that at least the browser will agree
170. # with itself, and echo back the same bytes that we were given.
171. filename = get_arg(req, "filename", self.name) or "unknown"
172. return FileDownloader(self.node, filename, save_to_file)
173. if t == "json":
174. return FileJSONMetadata(ctx, self.node)
175. if t == "uri":
176. return FileURI(ctx, self.node)
177. if t == "readonly-uri":
178. return FileReadOnlyURI(ctx, self.node)
179. raise WebError("GET file: bad t=%s" % t)
180.
181. def render_HEAD(self, ctx):
182. req = IRequest(ctx)
183. t = get_arg(req, "t", "").strip()
184. if t:
185. raise WebError("GET file: bad t=%s" % t)
186. # if we have a filename, use it to get the content-type
187. filename = get_arg(req, "filename", self.name) or "unknown"
188. gte = static.getTypeAndEncoding
189. ctype, encoding = gte(filename,
190. static.File.contentTypes,
191. static.File.contentEncodings,
192. defaultType="text/plain")
193. req.setHeader("content-type", ctype)
194. if encoding:
195. req.setHeader("content-encoding", encoding)
196. if self.node.is_mutable():
197. d = self.node.get_size_of_best_version()
198. # otherwise, we can get the size from the URI
199. else:
200. d = defer.succeed(self.node.get_size())
201. def _got_length(length):
202. req.setHeader("content-length", length)
203. return ""
204. d.addCallback(_got_length)
205. return d
206.
207. def render_PUT(self, ctx):
208. req = IRequest(ctx)
209. t = get_arg(req, "t", "").strip()
210. replace = boolean_of_arg(get_arg(req, "replace", "true"))
211. if not t:
212. if self.node.is_mutable():
213. return self.replace_my_contents(ctx)
214. if not replace:
215. # this is the early trap: if someone else modifies the
216. # directory while we're uploading, the add_file(overwrite=)
217. # call in replace_me_with_a_child will do the late trap.
218. raise ExistingChildError()
219. assert self.parentnode and self.name
220. return self.replace_me_with_a_child(ctx, replace)
221. if t == "uri":
222. if not replace:
223. raise ExistingChildError()
224. assert self.parentnode and self.name
225. return self.replace_me_with_a_childcap(ctx, replace)
226.
227. raise WebError("PUT to a file: bad t=%s" % t)
228.
229. def render_POST(self, ctx):
230. req = IRequest(ctx)
231. t = get_arg(req, "t", "").strip()
232. replace = boolean_of_arg(get_arg(req, "replace", "true"))
233. if t == "check":
234. d = self._POST_check(req)
235. elif t == "upload":
236. # like PUT, but get the file data from an HTML form's input field
237. # We could get here from POST /uri/mutablefilecap?t=upload,
238. # or POST /uri/path/file?t=upload, or
239. # POST /uri/path/dir?t=upload&name=foo . All have the same
240. # behavior, we just ignore any name= argument
241. if self.node.is_mutable():
242. d = self.replace_my_contents_with_a_formpost(ctx)
243. else:
244. if not replace:
245. raise ExistingChildError()
246. assert self.parentnode and self.name
247. d = self.replace_me_with_a_formpost(ctx, replace)
248. else:
249. raise WebError("POST to file: bad t=%s" % t)
250.
251. when_done = get_arg(req, "when_done", None)
252. if when_done:
253. d.addCallback(lambda res: url.URL.fromString(when_done))
254. return d
255.
256. def _POST_check(self, req):
257. verify = boolean_of_arg(get_arg(req, "verify", "false"))
258. repair = boolean_of_arg(get_arg(req, "repair", "false"))
259. d = self.node.check(verify, repair)
260. d.addCallback(lambda res: CheckerResults(res))
261. return d
262.
263. def render_DELETE(self, ctx):
264. assert self.parentnode and self.name
265. d = self.parentnode.delete(self.name)
266. d.addCallback(lambda res: self.node.get_uri())
267. return d
268.
269. def replace_my_contents(self, ctx):
270. req = IRequest(ctx)
271. req.content.seek(0)
272. new_contents = req.content.read()
273. d = self.node.overwrite(new_contents)
274. d.addCallback(lambda res: self.node.get_uri())
275. return d
276.
277. def replace_my_contents_with_a_formpost(self, ctx):
278. # we have a mutable file. Get the data from the formpost, and replace
279. # the mutable file's contents with it.
280. req = IRequest(ctx)
281. new_contents = self._read_data_from_formpost(req)
282. d = self.node.overwrite(new_contents)
283. d.addCallback(lambda res: self.node.get_uri())
284. return d
285.
286.
287. class WebDownloadTarget:
288. implements(IDownloadTarget, IConsumer)
289. def __init__(self, req, content_type, content_encoding, save_to_filename):
290. self._req = req
291. self._content_type = content_type
292. self._content_encoding = content_encoding
293. self._opened = False
294. self._producer = None
295. self._save_to_filename = save_to_filename
296.
297. def registerProducer(self, producer, streaming):
298. self._req.registerProducer(producer, streaming)
299. def unregisterProducer(self):
300. self._req.unregisterProducer()
301.
302. def open(self, size):
303. self._opened = True
304. self._req.setHeader("content-type", self._content_type)
305. if self._content_encoding:
306. self._req.setHeader("content-encoding", self._content_encoding)
307. self._req.setHeader("content-length", str(size))
308. if self._save_to_filename is not None:
309. # tell the browser to save the file rather display it we don't
310. # try to encode the filename, instead we echo back the exact same
311. # bytes we were given in the URL. See the comment in
312. # FileNodeHandler.render_GET for the sad details.
313. filename = self._save_to_filename
314. self._req.setHeader("content-disposition",
315. 'attachment; filename="%s"' % filename)
316.
317. def write(self, data):
318. self._req.write(data)
319. def close(self):
320. self._req.finish()
321.
322. def fail(self, why):
323. if self._opened:
324. # The content-type is already set, and the response code
325. # has already been sent, so we can't provide a clean error
326. # indication. We can emit text (which a browser might interpret
327. # as something else), and if we sent a Size header, they might
328. # notice that we've truncated the data. Keep the error message
329. # small to improve the chances of having our error response be
330. # shorter than the intended results.
331. #
332. # We don't have a lot of options, unfortunately.
333. self._req.write("problem during download\n")
334. else:
335. # We haven't written anything yet, so we can provide a sensible
336. # error message.
337. msg = str(why.type)
338. msg.replace("\n", "|")
339. self._req.setResponseCode(http.GONE, msg)
340. self._req.setHeader("content-type", "text/plain")
341. # TODO: HTML-formatted exception?
342. self._req.write(str(why))
343. self._req.finish()
344.
345. def register_canceller(self, cb):
346. pass
347. def finish(self):
348. pass
349.
350. class FileDownloader(resource.Resource):
351. # since we override the rendering process (to let the tahoe Downloader
352. # drive things), we must inherit from regular old twisted.web.resource
353. # instead of nevow.rend.Page . Nevow will use adapters to wrap a
354. # nevow.appserver.OldResourceAdapter around any
355. # twisted.web.resource.IResource that it is given. TODO: it looks like
356. # that wrapper would allow us to return a Deferred from render(), which
357. # might could simplify the implementation of WebDownloadTarget.
358.
359. def __init__(self, filenode, filename, save_to_file):
360. resource.Resource.__init__(self)
361. self.filenode = filenode
362. self.filename = filename
363. self.save_to_file = save_to_file
364. def render(self, req):
365. gte = static.getTypeAndEncoding
366. ctype, encoding = gte(self.filename,
367. static.File.contentTypes,
368. static.File.contentEncodings,
369. defaultType="text/plain")
370. save_to_filename = None
371. if self.save_to_file:
372. save_to_filename = self.filename
373. wdt = WebDownloadTarget(req, ctype, encoding, save_to_filename)
374. d = self.filenode.download(wdt)
375. # exceptions during download are handled by the WebDownloadTarget
376. d.addErrback(lambda why: None)
377. return server.NOT_DONE_YET
378.
379. def FileJSONMetadata(ctx, filenode):
380. if filenode.is_readonly():
381. rw_uri = None
382. ro_uri = filenode.get_uri()
383. else:
384. rw_uri = filenode.get_uri()
385. ro_uri = filenode.get_readonly_uri()
386. data = ("filenode", {})
387. data[1]['size'] = filenode.get_size()
388. if ro_uri:
389. data[1]['ro_uri'] = ro_uri
390. if rw_uri:
391. data[1]['rw_uri'] = rw_uri
392. data[1]['mutable'] = filenode.is_mutable()
393. return text_plain(simplejson.dumps(data, indent=1), ctx)
394.
395. def FileURI(ctx, filenode):
396. return text_plain(filenode.get_uri(), ctx)
397.
398. def FileReadOnlyURI(ctx, filenode):
399. if filenode.is_readonly():
400. return text_plain(filenode.get_uri(), ctx)
401. return text_plain(filenode.get_readonly_uri(), ctx)
402.
403. class FileNodeDownloadHandler(FileNodeHandler):
404. def childFactory(self, ctx, name):
405. return FileNodeDownloadHandler(self.node, name=name)