Annotation of ExtFile/ExtFile.py, revision 1.1.1.1
1.1 dwinter 1: """ ExtFile product module """
2: # -*- coding: latin-1 -*-
3: ###############################################################################
4: #
5: # Copyright (c) 2001 Gregor Heine <mac.gregor@gmx.de>. All rights reserved.
6: # ExtFile Home: http://www.zope.org/Members/MacGregor/ExtFile/index_html
7: #
8: # Redistribution and use in source and binary forms, with or without
9: # modification, are permitted provided that the following conditions
10: # are met:
11: #
12: # 1. Redistributions of source code must retain the above copyright
13: # notice, this list of conditions and the following disclaimer.
14: # 2. Redistributions in binary form must reproduce the above copyright
15: # notice, this list of conditions and the following disclaimer in the
16: # documentation and/or other materials provided with the distribution.
17: # 3. The name of the author may not be used to endorse or promote products
18: # derived from this software without specific prior written permission
19: #
20: # Disclaimer
21: #
22: # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23: # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24: # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25: # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26: # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27: # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28: # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29: # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30: # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31: # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: #
33: # In accordance with the license provided for by the software upon
34: # which some of the source code has been derived or used, the following
35: # acknowledgement is hereby provided :
36: #
37: # "This product includes software developed by Digital Creations
38: # for use in the Z Object Publishing Environment
39: # (http://www.zope.org/)."
40: #
41: ###############################################################################
42:
43: __doc__ = """ExtFile product module.
44: The ExtFile-Product works like the Zope File-product, but stores
45: the uploaded file externally in a repository-direcory."""
46:
47: __version__='1.5.4'
48:
49: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
50: from OFS.SimpleItem import SimpleItem
51: from OFS.PropertyManager import PropertyManager
52: from OFS.Cache import Cacheable
53: from Globals import HTMLFile, MessageDialog, InitializeClass, package_home
54: from AccessControl import ClassSecurityInfo, getSecurityManager
55: from AccessControl import Permissions
56: from Acquisition import aq_acquire
57: from mimetypes import guess_extension
58: from webdav.Lockable import ResourceLockedError
59: from webdav.common import rfc1123_date
60: from DateTime import DateTime
61: import urllib, os, string, types, sha, base64
62: from os.path import join, isfile
63: from tempfile import TemporaryFile
64: from Products.ExtFile import TM
65:
66: from webdav.WriteLockInterface import WriteLockInterface
67: from IExtFile import IExtFile
68:
69: #from zLOG import *
70:
71:
72: _SUBSYS = 'ExtFile'
73: _debug = 0
74:
75: #ersetzt zLOG -- Aenderung DW 24.1.2007
76:
77: from logging import *
78:
79: def LOG(txt,method,txt2):
80: """logging"""
81: info(txt+ txt2)
82:
83:
84: try: import Zope2
85: except ImportError: ZOPE28 = 0
86: else: ZOPE28 = 1
87:
88: try: from zope.contenttype import guess_content_type
89: except ImportError:
90: try: from zope.app.content_types import guess_content_type
91: except ImportError: from OFS.content_types import guess_content_type
92:
93: try: from zExceptions import Redirect
94: except ImportError: Redirect = 'Redirect'
95:
96: try: from ZPublisher.Iterators import IStreamIterator
97: except ImportError: IStreamIterator = None
98:
99: ViewPermission = Permissions.view
100: AccessPermission = Permissions.view_management_screens
101: ChangePermission = 'Change ExtFile/ExtImage'
102: DownloadPermission = 'Download ExtFile/ExtImage'
103:
104: import re
105: copy_of_re = re.compile('(^(copy[0-9]*_of_)+)')
106:
107: from Config import *
108:
109: manage_addExtFileForm = HTMLFile('dtml/extFileAdd', globals())
110:
111:
112: def manage_addExtFile(self, id='', title='', descr='', file='',
113: content_type='', permission_check=0, redirect_default_view=0, REQUEST=None):
114: """ Add an ExtFile to a folder. """
115: if not id and getattr(file, 'filename', None) is not None:
116: # generate id from filename and make sure, it has no 'bad' chars
117: id = file.filename
118: id = id[max(string.rfind(id,'/'),
119: string.rfind(id,'\\'),
120: string.rfind(id,':'))+1:]
121: title = title or id
122: id = normalize_id(id)
123: tempExtFile = ExtFile(id, title, descr, permission_check, redirect_default_view)
124: self._setObject(id, tempExtFile)
125: if file != '':
126: self._getOb(id).manage_file_upload(file, content_type)
127: if REQUEST is not None:
128: return self.manage_main(self, REQUEST, update_menu=0)
129: return id
130:
131:
132:
133: class ExtFile(CatalogAware, SimpleItem, PropertyManager, Cacheable):
134: """ The ExtFile-Product works like the Zope File-product, but stores
135: the uploaded file externally in a repository-direcory. """
136:
137: __implements__ = (IExtFile, WriteLockInterface)
138:
139: # what properties have we?
140: _properties = (
141: {'id':'title', 'type':'string', 'mode': 'w'},
142: {'id':'descr', 'type':'text', 'mode': 'w'},
143: {'id':'content_type', 'type':'string', 'mode': 'w'},
144: {'id':'use_download_permission_check', 'type':'boolean', 'mode': 'w'},
145: {'id':'redirect_default_view', 'type':'boolean', 'mode': 'w'},
146: )
147: use_download_permission_check = 0
148: redirect_default_view = 0
149:
150: # what management options are there?
151: manage_options = ((
152: {'label':'Edit', 'action': 'manage_main' },
153: {'label':'View', 'action': '' },
154: {'label':'Upload', 'action': 'manage_uploadForm' },) +
155: PropertyManager.manage_options +
156: SimpleItem.manage_options[1:] +
157: Cacheable.manage_options
158: )
159:
160: security = ClassSecurityInfo()
161:
162: # what do people think they're adding?
163: meta_type = 'ExtFile'
164:
165: # location of the file-repository
166: _repository = REPOSITORY_PATH
167:
168: # make sure the download permission is available
169: security.setPermissionDefault(DownloadPermission, ('Manager',))
170:
171: # the above does not work in Zope < 2.8
172: if not ZOPE28:
173: security.declareProtected(DownloadPermission, '_dummy')
174:
175: # MIME-Type Dictionary. To add a MIME-Type, add a file in the directory
176: # icons/_category_/_subcategory-icon-file_
177: # example: Icon tifficon.gif for the MIME-Type image/tiff goes to
178: # icons/image/tifficon.gif and the dictionary must be updated like this:
179: # 'image':{'tiff':'tifficon.gif','default':'default.gif'}, ...
180: _types={'image':
181: {'default':'default.gif'},
182: 'text':
183: {'html':'html.gif', 'xml':'xml.gif', 'default':'default.gif',
184: 'python':'py.gif'},
185: 'application':
186: {'pdf':'pdf.gif', 'zip':'zip.gif', 'tar':'zip.gif',
187: 'msword':'doc.gif', 'excel':'xls.gif', 'powerpoint':'ppt.gif',
188: 'default':'default.gif'},
189: 'video':
190: {'default':'default.gif'},
191: 'audio':
192: {'default':'default.gif'},
193: 'default':'default.gif'
194: }
195:
196: ################################
197: # Init method #
198: ################################
199:
200: def __init__(self, id, title='', descr='', permission_check=0, redirect_default_view=0):
201: """ Initialize a new instance of ExtFile """
202: self.id = id
203: self.title = title
204: self.descr = descr
205: self.use_download_permission_check = permission_check
206: self.redirect_default_view = redirect_default_view
207: self.__version__ = __version__
208: self.filename = []
209: self.content_type = ''
210:
211: ################################
212: # Public methods #
213: ################################
214:
215: def __str__(self):
216: return self.index_html()
217:
218: def __len__(self):
219: return 1
220:
221: def _if_modified_since_request_handler(self, REQUEST):
222: """ HTTP If-Modified-Since header handling: return True if
223: we can handle this request by returning a 304 response.
224: """
225: header = REQUEST.get_header('If-Modified-Since', None)
226: if header is not None:
227: header = string.split(header, ';')[0]
228: try: mod_since = long(DateTime(header).timeTime())
229: except: mod_since = None
230: if mod_since is not None:
231: if self._p_mtime:
232: last_mod = long(self._p_mtime)
233: else:
234: last_mod = long(0)
235: if last_mod > 0 and last_mod < mod_since:
236: # Set headers for Apache caching
237: last_mod = rfc1123_date(self._p_mtime)
238: REQUEST.RESPONSE.setHeader('Last-Modified', last_mod)
239: REQUEST.RESPONSE.setHeader('Content-Type', self.content_type)
240: # RFC violation. See http://collector.zope.org/Zope/544
241: #REQUEST.RESPONSE.setHeader('Content-Length', self.get_size())
242: REQUEST.RESPONSE.setStatus(304)
243: return 1
244:
245: def _redirect_default_view_request_handler(self, icon, preview, REQUEST):
246: """ redirect_default_view property handling: return True if
247: we can handle this request by returning a 302 response.
248: Patch provided by Oliver Bleutgen.
249: """
250: if self.redirect_default_view:
251: if self.static_mode() and not icon:
252: static_url = self._static_url(preview=preview)
253: if static_url != self.absolute_url():
254: REQUEST.RESPONSE.redirect(static_url)
255: return 1
256:
257: security.declareProtected(ViewPermission, 'index_html')
258: def index_html (self, icon=0, preview=0, width=None, height=None,
259: REQUEST=None):
260: """ Return the file with it's corresponding MIME-type """
261:
262: if REQUEST is not None:
263: if self._if_modified_since_request_handler(REQUEST):
264: self.ZCacheable_set(None)
265: return ''
266:
267: if self._redirect_default_view_request_handler(icon, preview, REQUEST):
268: return ''
269:
270: filename, content_type, icon, preview = self._get_file_to_serve(icon, preview)
271: filename = self._get_fsname(filename)
272:
273: if _debug > 1: LOG(_SUBSYS, INFO, 'serving %s, %s, %s, %s' %(filename, content_type, icon, preview))
274:
275: cant_read_exc = "Can't read: "
276: if filename:
277: try: size = os.stat(filename)[6]
278: except: raise cant_read_exc, ("%s (%s)" %(self.id, filename))
279: else:
280: filename = join(package_home(globals()), 'icons', 'broken.gif')
281: try: size = os.stat(filename)[6]
282: except: raise cant_read_exc, ("%s (%s)" %(self.id, filename))
283: content_type = 'image/gif'
284: icon = 1
285:
286: if icon==0 and width is not None and height is not None:
287: data = TemporaryFile() # hold resized image
288: try:
289: from PIL import Image
290: im = Image.open(filename)
291: if im.mode!='RGB':
292: im = im.convert('RGB')
293: filter = Image.BICUBIC
294: if hasattr(Image, 'ANTIALIAS'): # PIL 1.1.3
295: filter = Image.ANTIALIAS
296: im = im.resize((int(width),int(height)), filter)
297: im.save(data, 'JPEG', quality=85)
298: except:
299: data = open(filename, 'rb')
300: else:
301: data.seek(0,2)
302: size = data.tell()
303: data.seek(0)
304: content_type = 'image/jpeg'
305: else:
306: data = open(filename, 'rb')
307:
308: close_data = 1
309: try:
310: if REQUEST is not None:
311: last_mod = rfc1123_date(self._p_mtime)
312: REQUEST.RESPONSE.setHeader('Last-Modified', last_mod)
313: REQUEST.RESPONSE.setHeader('Content-Type', content_type)
314: REQUEST.RESPONSE.setHeader('Content-Length', size)
315: self.ZCacheable_set(None)
316:
317: # Support Zope 2.7.1 IStreamIterator
318: if IStreamIterator is not None:
319: close_data = 0
320: return stream_iterator(data)
321:
322: blocksize = 2<<16
323: while 1:
324: buffer = data.read(blocksize)
325: REQUEST.RESPONSE.write(buffer)
326: if len(buffer) < blocksize:
327: break
328: return ''
329: else:
330: return data.read()
331: finally:
332: if close_data: data.close()
333:
334: security.declareProtected(ViewPermission, 'view_image_or_file')
335: def view_image_or_file(self):
336: """ The default view of the contents of the File or Image. """
337: raise Redirect, self.absolute_url()
338:
339: security.declareProtected(ViewPermission, 'link')
340: def link(self, text='', **args):
341: """ Return a HTML link tag to the file """
342: if text=='': text = self.title_or_id()
343: strg = '<a href="%s"' % (self._static_url())
344: for key in args.keys():
345: value = args.get(key)
346: strg = '%s %s="%s"' % (strg, key, value)
347: strg = '%s>%s</a>' % (strg, text)
348: return strg
349:
350: security.declareProtected(ViewPermission, 'icon_gif')
351: def icon_gif(self):
352: """ Return an icon for the file's MIME-Type """
353: raise Redirect, self._static_url(icon=1)
354:
355: security.declareProtected(ViewPermission, 'icon_tag')
356: def icon_tag(self):
357: """ Generate the HTML IMG tag for the icon """
358: return '<img src="%s" border="0" />' % self._static_url(icon=1)
359:
360: security.declareProtected(ViewPermission, 'icon_html')
361: def icon_html(self):
362: """ Same as icon_tag """
363: return self.icon_tag()
364:
365: security.declareProtected(ViewPermission, 'is_broken')
366: def is_broken(self):
367: """ Check if external file exists and return true (1) or false (0) """
368: return not self._get_fsname(self.filename)
369:
370: security.declareProtected(ViewPermission, 'get_size')
371: def get_size(self):
372: """ Returns the size of the file or image """
373: fn = self._get_fsname(self.filename)
374: if fn:
375: return os.stat(fn)[6]
376: return 0
377:
378: security.declareProtected(ViewPermission, 'rawsize')
379: def rawsize(self):
380: """ Same as get_size """
381: return self.get_size()
382:
383: security.declareProtected(ViewPermission, 'getSize')
384: def getSize(self):
385: """ Same as get_size """
386: return self.get_size()
387:
388: security.declareProtected(ViewPermission, 'size')
389: def size(self):
390: """ Returns a formatted stringified version of the file size """
391: return self._bytetostring(self.get_size())
392:
393: security.declareProtected(ViewPermission, 'getContentType')
394: def getContentType(self):
395: """ Returns the content type (MIME type) of a file or image. """
396: return self.content_type
397:
398: security.declareProtected(ViewPermission, 'getIconPath')
399: def getIconPath(self):
400: """ Depending on the MIME Type of the file/image an icon
401: can be displayed. This function determines which
402: image in the lib/python/Products/ExtFile/icons/...
403: directory shold be used as icon for this file/image
404: """
405: try:
406: cat, sub = string.split(self.content_type, '/')
407: except ValueError:
408: if getattr(self, 'has_preview', None) is not None:
409: cat, sub = 'image', ''
410: else:
411: cat, sub = '', ''
412: if self._types.has_key(cat):
413: file = self._types[cat]['default']
414: for item in self._types[cat].keys():
415: if string.find(sub, item) >= 0:
416: file = self._types[cat][item]
417: break
418: return join('icons', cat, file)
419: return join('icons', self._types['default'])
420:
421: security.declareProtected(ViewPermission, 'static_url')
422: def static_url(self, icon=0, preview=0):
423: """ Returns the static url of the file """
424: return self._static_url(icon, preview)
425:
426: security.declareProtected(ViewPermission, 'static_mode')
427: def static_mode(self):
428: """ Returns true if serving static urls """
429: return os.environ.get('EXTFILE_STATIC_PATH') is not None
430:
431: security.declareProtected(AccessPermission, 'get_filename')
432: def get_filename(self):
433: """ Returns the filename as file system path.
434: Used by the ZMI to display the filename.
435: """
436: return self._fsname(self.filename)
437:
438: security.declareProtected(ViewPermission, 'PrincipiaSearchSource')
439: def PrincipiaSearchSource(self):
440: """ Allow file objects to be searched.
441: """
442: if self.content_type.startswith('text/'):
443: return str(self)
444: return ''
445:
446: ################################
447: # Protected management methods #
448: ################################
449:
450: # Management Interface
451: security.declareProtected(AccessPermission, 'manage_main')
452: manage_main = HTMLFile('dtml/extFileEdit', globals())
453:
454: security.declareProtected(ChangePermission, 'manage_editExtFile')
455: def manage_editExtFile(self, title='', descr='', REQUEST=None):
456: """ Manage the edited values """
457: if self.title!=title: self.title = title
458: if self.descr!=descr: self.descr = descr
459: # update ZCatalog
460: self.reindex_object()
461:
462: self.ZCacheable_invalidate()
463:
464: if REQUEST is not None:
465: return self.manage_main(self, REQUEST, manage_tabs_message='Saved changes.')
466:
467: # File upload Interface
468: security.declareProtected(AccessPermission, 'manage_uploadForm')
469: manage_uploadForm = HTMLFile('dtml/extFileUpload', globals())
470:
471: security.declareProtected(ChangePermission, 'manage_upload')
472: def manage_upload(self, file='', content_type='', REQUEST=None):
473: """ Upload file from file handle or string buffer """
474: if self.wl_isLocked():
475: raise ResourceLockedError, "File is locked via WebDAV"
476:
477: if type(file) == types.StringType:
478: temp_file = TemporaryFile()
479: temp_file.write(file)
480: temp_file.seek(0)
481: else:
482: temp_file = file
483: return self.manage_file_upload(temp_file, content_type, REQUEST)
484:
485: security.declareProtected(ChangePermission, 'manage_file_upload')
486: def manage_file_upload(self, file='', content_type='', REQUEST=None):
487: """ Upload file from file handle or local directory """
488: if self.wl_isLocked():
489: raise ResourceLockedError, "File is locked via WebDAV"
490:
491: if type(file) == types.StringType:
492: cant_read_exc = "Can't open: "
493: try: file = open(file, 'rb')
494: except: raise cant_read_exc, file
495: if content_type:
496: file = HTTPUpload(file, content_type)
497: self.content_type = self._get_content_type(file, file.read(100),
498: self.id, self.content_type)
499: file.seek(0)
500: self._register() # Register with TM
501: try:
502: new_fn = self._get_ufn(self.filename)
503: self._update_data(file, self._temp_fsname(new_fn))
504: finally:
505: self._dir__unlock()
506: self.filename = new_fn
507: self._afterUpdate()
508: if REQUEST is not None:
509: return self.manage_main(self, REQUEST, manage_tabs_message='Upload complete.')
510:
511: security.declareProtected(ChangePermission, 'manage_http_upload')
512: def manage_http_upload(self, url, REQUEST=None):
513: """ Upload file from http-server """
514: if self.wl_isLocked():
515: raise ResourceLockedError, "File is locked via WebDAV"
516:
517: url = urllib.quote(url,'/:')
518: cant_read_exc = "Can't open: "
519: try: file = urllib.urlopen(url)
520: except: raise cant_read_exc, url
521: file = HTTPUpload(file)
522: self.content_type = self._get_content_type(file, file.read(100),
523: self.id, self.content_type)
524: file.seek(0)
525: self._register() # Register with TM
526: try:
527: new_fn = self._get_ufn(self.filename)
528: self._update_data(file, self._temp_fsname(new_fn))
529: finally:
530: self._dir__unlock()
531: self.filename = new_fn
532: self._afterUpdate()
533: if REQUEST is not None:
534: return self.manage_main(self, REQUEST, manage_tabs_message='Upload complete.')
535:
536: security.declareProtected(ChangePermission, 'PUT')
537: def PUT(self, REQUEST, RESPONSE):
538: """ Handle HTTP PUT requests """
539: self.dav__init(REQUEST, RESPONSE)
540: self.dav__simpleifhandler(REQUEST, RESPONSE, refresh=1)
541: file = REQUEST['BODYFILE']
542: content_type = REQUEST.get_header('content-type', None)
543: if content_type:
544: file = HTTPUpload(file, content_type)
545: self.content_type = self._get_content_type(file, file.read(100),
546: self.id, self.content_type)
547: file.seek(0)
548: self._register() # Register with TM
549: try:
550: # Need to pass in the path as webdav.NullResource calls PUT
551: # on an unwrapped object.
552: try:
553: self.aq_parent # This raises AttributeError if no context
554: except AttributeError:
555: path = self._get_zodb_path(REQUEST.PARENTS[0])
556: else:
557: path = None
558: new_fn = self._get_ufn(self.filename, path=path)
559: self._update_data(file, self._temp_fsname(new_fn))
560: finally:
561: self._dir__unlock()
562: self.filename = new_fn
563: self._afterUpdate()
564: RESPONSE.setStatus(204)
565: return RESPONSE
566:
567: security.declareProtected('FTP access', 'manage_FTPstat')
568: security.declareProtected('FTP access', 'manage_FTPlist')
569: security.declareProtected('FTP access', 'manage_FTPget')
570: def manage_FTPget(self):
571: """ Return body for FTP """
572: return self.index_html(REQUEST=self.REQUEST)
573:
574: ################################
575: # Private methods #
576: ################################
577:
578: def _access_permitted(self, REQUEST=None):
579: """ Check if the user is allowed to download the file """
580: if REQUEST is None and getattr(self, 'REQUEST', None) is not None:
581: REQUEST = self.REQUEST
582: if getattr(self, 'use_download_permission_check', 0) and \
583: (REQUEST is None or
584: not getSecurityManager().getUser().has_permission(
585: DownloadPermission, self)
586: ):
587: return 0
588: else:
589: return 1
590:
591: def _get_content_type(self, file, body, id, content_type=None):
592: """ Determine the mime-type """
593: headers = getattr(file, 'headers', None)
594: if headers and headers.has_key('content-type'):
595: content_type = headers['content-type']
596: else:
597: if type(body) is not type(''): body = body.data
598: content_type, enc = guess_content_type(getattr(file,'filename',id),
599: body, content_type)
600: cutoff = content_type.find(';')
601: if cutoff >= 0:
602: return content_type[:cutoff]
603: return content_type
604:
605: def _update_data(self, infile, outfile):
606: """ Store infile to outfile """
607: if type(infile) == types.ListType:
608: infile = self._fsname(infile)
609: if type(outfile) == types.ListType:
610: outfile = self._fsname(outfile)
611: try:
612: self._copy(infile, outfile)
613: except:
614: if isfile(outfile): # This is always a .tmp file
615: try: os.remove(outfile)
616: except OSError: pass
617: raise
618: else:
619: self.http__refreshEtag()
620:
621: def _copy(self, infile, outfile):
622: """ Read binary data from infile and write it to outfile
623: infile and outfile may be strings, in which case a file with that
624: name is opened, or filehandles, in which case they are accessed
625: directly.
626: """
627: if type(infile) is types.StringType:
628: try:
629: instream = open(infile, 'rb')
630: except IOError:
631: raise IOError, ("%s (%s)" %(self.id, infile))
632: close_in = 1
633: else:
634: instream = infile
635: close_in = 0
636: if type(outfile) is types.StringType:
637: umask = os.umask(REPOSITORY_UMASK)
638: try:
639: outstream = open(outfile, 'wb')
640: os.umask(umask)
641: self._dir__unlock() # unlock early
642: except IOError:
643: os.umask(umask)
644: raise IOError, ("%s (%s)" %(self.id, outfile))
645: close_out = 1
646: else:
647: outstream = outfile
648: close_out = 0
649: try:
650: blocksize = 2<<16
651: block = instream.read(blocksize)
652: outstream.write(block)
653: while len(block)==blocksize:
654: block = instream.read(blocksize)
655: outstream.write(block)
656: except IOError:
657: raise IOError, ("%s (%s)" %(self.id, filename))
658: try: instream.seek(0)
659: except: pass
660: if close_in: instream.close()
661: if close_out: outstream.close()
662:
663: def _undo(self):
664: """ Restore filename after delete or copy-paste """
665: fn = self._fsname(self.filename)
666: if not isfile(fn) and isfile(fn+'.undo'):
667: self._register() # Register with TM
668: os.rename(fn+'.undo', self._temp_fsname(self.filename))
669:
670: def _fsname(self, filename):
671: """ Generates the full filesystem name, incuding directories from
672: self._repository and filename
673: """
674: path = [INSTANCE_HOME]
675: path.extend(self._repository)
676: if type(filename) == types.ListType:
677: path.extend(filename)
678: elif filename != '':
679: path.append(filename)
680: return apply(join, path)
681:
682: def _temp_fsname(self, filename):
683: """ Generates the full filesystem name of the temporary file """
684: return '%s.tmp' % self._fsname(filename)
685:
686: def _get_fsname(self, filename):
687: """ Returns the full filesystem name, preferring tmp over main.
688: Also attempts to undo. Returns None if the file is broken.
689: """
690: tmp_fn = self._temp_fsname(filename)
691: if isfile(tmp_fn):
692: return tmp_fn
693: fn = self._fsname(filename)
694: if isfile(fn):
695: return fn
696: self._undo()
697: if isfile(tmp_fn):
698: return tmp_fn
699:
700: # b/w compatibility
701: def _get_filename(self, filename):
702: """ Deprecated, use _get_fsname """
703: return self._get_fsname(filename)
704:
705: def _get_ufn(self, filename, path=None, content_type=None, lock=1):
706: """ If no unique filename has been generated, generate one
707: otherwise, return the existing one.
708: """
709: if UNDO_POLICY==ALWAYS_BACKUP or filename==[]:
710: new_fn = self._get_new_ufn(path=path, content_type=content_type, lock=lock)
711: else:
712: new_fn = filename[:]
713: if filename:
714: old_fn = self._fsname(filename)
715: if UNDO_POLICY==ALWAYS_BACKUP:
716: try: os.rename(old_fn, old_fn+'.undo')
717: except OSError: pass
718: else:
719: try: os.rename(old_fn+'.undo', old_fn)
720: except OSError: pass
721: return new_fn
722:
723: def _get_new_ufn(self, path=None, content_type=None, lock=1):
724: """ Create a new unique filename """
725: id = self.id
726:
727: # hack so the files are not named copy_of_foo
728: if COPY_OF_PROTECTION:
729: match = copy_of_re.match(id)
730: if match is not None:
731: id = id[len(match.group(1)):]
732:
733: # get name and extension components from id
734: pos = string.rfind(id, '.')
735: if (pos+1):
736: id_name = id[:pos]
737: id_ext = id[pos:]
738: else:
739: id_name = id
740: id_ext = ''
741:
742: if not content_type:
743: content_type = self.content_type
744:
745: if REPOSITORY_EXTENSIONS in (MIMETYPE_APPEND, MIMETYPE_REPLACE):
746: mime_ext = guess_extension(content_type)
747: if mime_ext is not None:
748: if mime_ext in ('.jpeg', '.jpe'):
749: mime_ext = '.jpg' # for IE/Win :-(
750: if mime_ext in ('.obj',):
751: mime_ext = '.exe' # b/w compatibility
752: if mime_ext in ('.tiff',):
753: mime_ext = '.tif' # b/w compatibility
754: # don't change extensions of unknown binaries
755: if not (content_type == 'application/octet-stream' and id_ext):
756: if REPOSITORY_EXTENSIONS == MIMETYPE_APPEND:
757: id_name = id_name + id_ext
758: id_ext = mime_ext
759:
760: # generate directory structure
761: if path is not None:
762: rel_url_list = path
763: else:
764: rel_url_list = self._get_zodb_path()
765:
766: dirs = []
767: if REPOSITORY == SYNC_ZODB:
768: dirs = rel_url_list
769: elif REPOSITORY in (SLICED, SLICED_REVERSE, SLICED_HASH):
770: if REPOSITORY == SLICED_HASH:
771: # increase distribution by including the path in the hash
772: hashed = ''.join(list(rel_url_list)+[id_name])
773: temp = base64.encodestring(sha.new(hashed).digest())[:-1]
774: temp = temp.replace('/', '_')
775: temp = temp.replace('+', '_')
776: elif REPOSITORY == SLICED_REVERSE:
777: temp = list(id_name)
778: temp.reverse()
779: temp = ''.join(temp)
780: else:
781: temp = id_name
782: for i in range(SLICE_DEPTH):
783: if len(temp)<SLICE_WIDTH*(SLICE_DEPTH-i):
784: dirs.append(SLICE_WIDTH*'_')
785: else:
786: dirs.append(temp[:SLICE_WIDTH])
787: temp=temp[SLICE_WIDTH:]
788: elif REPOSITORY == CUSTOM:
789: method = aq_acquire(self, CUSTOM_METHOD)
790: dirs = method(rel_url_list, id)
791:
792: if NORMALIZE_CASE == NORMALIZE:
793: dirs = [d.lower() for d in dirs]
794:
795: # make directories
796: dirpath = self._fsname(dirs)
797: if not os.path.isdir(dirpath):
798: mkdir_exc = "Can't create directory: "
799: umask = os.umask(REPOSITORY_UMASK)
800: try:
801: os.makedirs(dirpath)
802: os.umask(umask)
803: except:
804: os.umask(umask)
805: raise mkdir_exc, dirpath
806:
807: # generate file name
808: fileformat = FILE_FORMAT
809: # time/counter (%t)
810: if string.find(fileformat, "%t")>=0:
811: fileformat = string.replace(fileformat, "%t", "%c")
812: counter = int(DateTime().strftime('%m%d%H%M%S'))
813: else:
814: counter = 0
815: invalid_format_exc = "Invalid file format: "
816: if string.find(fileformat, "%c")==-1:
817: raise invalid_format_exc, FILE_FORMAT
818: # user (%u)
819: if string.find(fileformat, "%u")>=0:
820: if (getattr(self, 'REQUEST', None) is not None and
821: self.REQUEST.has_key('AUTHENTICATED_USER')):
822: user = getSecurityManager().getUser().getUserName()
823: fileformat = string.replace(fileformat, "%u", user)
824: else:
825: fileformat = string.replace(fileformat, "%u", "")
826: # path (%p)
827: if string.find(fileformat, "%p")>=0:
828: temp = string.joinfields(rel_url_list, "_")
829: fileformat = string.replace(fileformat, "%p", temp)
830: # file and extension (%n and %e)
831: if string.find(fileformat,"%n")>=0 or string.find(fileformat,"%e")>=0:
832: fileformat = string.replace(fileformat, "%n", id_name)
833: fileformat = string.replace(fileformat, "%e", id_ext)
834:
835: # lock the directory
836: if lock: self._dir__lock(dirpath)
837:
838: # search for unique filename
839: if counter:
840: fn = join(dirpath, string.replace(fileformat, "%c", ".%s" % counter))
841: else:
842: fn = join(dirpath, string.replace(fileformat, "%c", ''))
843: while isfile(fn) or isfile(fn+'.undo') or isfile(fn+'.tmp'):
844: counter = counter + 1
845: fn = join(dirpath, string.replace(fileformat, "%c", ".%s" % counter))
846: if counter:
847: fileformat = string.replace(fileformat, "%c", ".%s" % counter)
848: else:
849: fileformat = string.replace(fileformat, "%c", '')
850:
851: dirs.append(fileformat)
852: return dirs
853:
854: def _static_url(self, icon=0, preview=0):
855: """ Return the static url of the file """
856: static_path = os.environ.get('EXTFILE_STATIC_PATH')
857: if static_path is not None:
858: filename, content_type, icon, preview = \
859: self._get_file_to_serve(icon, preview)
860: if icon:
861: # cannot serve statically
862: return '%s?icon=1' % self.absolute_url()
863: else:
864: # rewrite to static url
865: static_host = os.environ.get('EXTFILE_STATIC_HOST')
866: host = self.REQUEST.SERVER_URL
867: if static_host is not None:
868: if host[:8] == 'https://':
869: host = 'https://' + static_host
870: else:
871: host = 'http://' + static_host
872: host = host + urllib.quote(static_path) + '/'
873: return host + urllib.quote('/'.join(filename))
874: else:
875: if icon:
876: return '%s?icon=1' % self.absolute_url()
877: elif preview:
878: return '%s?preview=1' % self.absolute_url()
879: else:
880: return self.absolute_url()
881:
882: def _get_file_to_serve(self, icon=0, preview=0):
883: """ Find out about the file we are going to serve """
884: if not self._access_permitted():
885: preview = 1
886: if preview and not getattr(self, 'has_preview', 0):
887: icon = 1
888:
889: if icon:
890: filename = join(package_home(globals()), self.getIconPath())
891: content_type = 'image/gif'
892: elif preview:
893: filename = self.prev_filename
894: content_type = self.prev_content_type
895: else:
896: filename = self.filename
897: content_type = self.content_type
898:
899: return filename, content_type, icon, preview
900:
901: def _get_zodb_path(self, parent=None):
902: """ Returns the ZODB path of the parent object """
903: # XXX: The Photo product uploads into unwrapped ExtImages.
904: # As we can not reliably guess our parent object we fall back
905: # to the old behavior. This means that Photos will always
906: # use ZODB_PATH = VIRTUAL independent of config settings.
907: try:
908: from Products.Photo.ExtPhotoImage import PhotoImage
909: except ImportError:
910: pass
911: else:
912: if isinstance(self, PhotoImage):
913: path = self.absolute_url(1).split('/')[:-1]
914: return filter(None, path)
915: # XXX: End of hack
916:
917: # For normal operation objects must be wrapped
918: if parent is None:
919: parent = self.aq_parent
920:
921: if ZODB_PATH == VIRTUAL:
922: path = parent.absolute_url(1).split('/')
923: else:
924: path = list(parent.getPhysicalPath())
925: return filter(None, path)
926:
927: def _bytetostring(self, value):
928: """ Convert an int-value (file-size in bytes) to an String
929: with the file-size in Byte, KB or MB
930: """
931: bytes = float(value)
932: if bytes>=1000:
933: bytes = bytes/1024
934: if bytes>=1000:
935: bytes = bytes/1024
936: typ = ' MB'
937: else:
938: typ = ' KB'
939: else:
940: typ = ' Bytes'
941: strg = '%4.2f'%bytes
942: strg = strg[:4]
943: if strg[3]=='.': strg = strg[:3]
944: strg = strg+typ
945: return strg
946:
947: def _afterUpdate(self):
948: """ Called whenever the file data has been updated.
949: Invokes the manage_afterUpdate() hook.
950: """
951: self.ZCacheable_invalidate()
952:
953: return self.manage_afterUpdate(self._get_fsname(self.filename),
954: self.content_type, self.get_size())
955:
956: ################################
957: # Special management methods #
958: ################################
959:
960: security.declarePrivate('manage_afterClone')
961: def manage_afterClone(self, item, new_fn=None):
962: """ When a copy of the object is created (zope copy-paste-operation),
963: this function is called by CopySupport.py. A copy of the external
964: file is created and self.filename is changed.
965: """
966: call_afterUpdate = 0
967: try:
968: self.aq_parent # This raises AttributeError if no context
969: except AttributeError:
970: self._v_has_been_cloned=1 # This is to make webdav COPY work
971: else:
972: fn = self._get_fsname(self.filename)
973: if fn:
974: self._register() # Register with TM
975: try:
976: new_fn = new_fn or self._get_new_ufn()
977: self._update_data(fn, self._temp_fsname(new_fn))
978: self.filename = new_fn
979: call_afterUpdate = 1
980: finally:
981: self._dir__unlock()
982: if call_afterUpdate:
983: self._afterUpdate()
984: return ExtFile.inheritedAttribute("manage_afterClone")(self, item)
985:
986: security.declarePrivate('manage_afterAdd')
987: def manage_afterAdd(self, item, container):
988: """ This method is called, whenever _setObject in ObjectManager gets
989: called. This is the case after a normal add and if the object is a
990: result of cut-paste- or rename-operation. In the first case, the
991: external files doesn't exist yet, otherwise it was renamed to .undo
992: by manage_beforeDelete before and must be restored by _undo().
993: """
994: self._undo()
995: if hasattr(self, "_v_has_been_cloned"):
996: delattr(self, "_v_has_been_cloned")
997: self.manage_afterClone(item)
998: return ExtFile.inheritedAttribute("manage_afterAdd")(self, item, container)
999:
1000: security.declarePrivate('manage_beforeDelete')
1001: def manage_beforeDelete(self, item, container):
1002: """ This method is called, when the object is deleted. To support
1003: undo-functionality and because this happens too, when the object
1004: is moved (cut-paste) or renamed, the external file is not deleted.
1005: It is just renamed to filename.undo and remains in the
1006: repository, until it is deleted manually.
1007: """
1008: tmp_fn = self._temp_fsname(self.filename)
1009: fn = self._fsname(self.filename)
1010: if isfile(tmp_fn):
1011: try: os.rename(tmp_fn, fn+'.undo')
1012: except OSError: pass
1013: else:
1014: try: os.remove(fn)
1015: except OSError: pass
1016: elif isfile(fn):
1017: try: os.rename(fn, fn+'.undo')
1018: except OSError: pass
1019: return ExtFile.inheritedAttribute("manage_beforeDelete")(self, item, container)
1020:
1021: security.declarePrivate('manage_afterUpdate')
1022: def manage_afterUpdate(self, filename, content_type, size):
1023: """ This method is called whenever the file data has been updated.
1024: May be overridden by subclasses to perform additional operations.
1025: The 'filename' argument contains the path as returned by get_fsname().
1026: """
1027: pass
1028:
1029: security.declarePrivate('get_fsname')
1030: def get_fsname(self):
1031: """ Returns the current file system path of the file or image.
1032: This path can be used to access the file even while a
1033: transaction is in progress (aka Zagy's revenge :-).
1034: Returns None if the file does not exist in the repository.
1035: """
1036: return self._get_fsname(self.filename)
1037:
1038: ################################
1039: # Repository locking methods #
1040: ################################
1041:
1042: def _dir__lock(self, dir):
1043: """ Lock a directory """
1044: if hasattr(self, '_v_dir__lock'):
1045: raise DirLockError, 'Double lock in thread'
1046: self._v_dir__lock = DirLock(dir)
1047:
1048: def _dir__unlock(self):
1049: """ Unlock a previously locked directory """
1050: if hasattr(self, '_v_dir__lock'):
1051: self._v_dir__lock.release()
1052: delattr(self, '_v_dir__lock')
1053:
1054: ################################
1055: # Transaction manager methods #
1056: ################################
1057:
1058: def _register(self):
1059: if _debug: LOG(_SUBSYS, INFO, 'registering %s' % TM.contains(self))
1060: TM.register(self)
1061: if _debug: LOG(_SUBSYS, INFO, 'registered %s' % TM.contains(self))
1062:
1063: def _begin(self):
1064: self._v_begin_called = 1 # for tests
1065: if _debug: LOG(_SUBSYS, INFO, 'beginning %s' % self.id)
1066:
1067: def _finish(self):
1068: """ Commits the temporary file """
1069: self._v_finish_called = 1 # for tests
1070: TM.remove(self) # for tests
1071: if self.filename:
1072: tmp_fn = self._temp_fsname(self.filename)
1073: if _debug: LOG(_SUBSYS, INFO, 'finishing %s' % tmp_fn)
1074: if isfile(tmp_fn):
1075: if _debug: LOG(_SUBSYS, INFO, 'isfile %s' % tmp_fn)
1076: fn = self._fsname(self.filename)
1077: try: os.remove(fn)
1078: except OSError: pass
1079: os.rename(tmp_fn, fn)
1080:
1081: def _abort(self):
1082: """ Deletes the temporary file """
1083: self._v_abort_called = 1 # for tests
1084: TM.remove(self) # for tests
1085: if self.filename:
1086: tmp_fn = self._temp_fsname(self.filename)
1087: if _debug: LOG(_SUBSYS, INFO, 'aborting %s' % tmp_fn)
1088: if isfile(tmp_fn):
1089: if _debug: LOG(_SUBSYS, INFO, 'isfile %s' % tmp_fn)
1090: try: os.remove(tmp_fn)
1091: except OSError: pass
1092:
1093: InitializeClass(ExtFile)
1094:
1095:
1096: # Filename to id translation
1097: bad_chars = """ ,;:'"()[]{}ÄÅÁÀÂÃäåáàâãÇçÉÈÊËÆéèêëæÍÌÎÏíìîïÑñÖÓÒÔÕØöóòôõøŠšßÜÚÙÛüúùûÝŸýÿŽž"""
1098: good_chars = """____________AAAAAAaaaaaaCcEEEEEeeeeeIIIIiiiiNnOOOOOOooooooSssUUUUuuuuYYyyZz"""
1099: TRANSMAP = string.maketrans(bad_chars, good_chars)
1100:
1101: def normalize_id(id):
1102: # Support at least utf-8 and latin-1 filenames.
1103: # This is lame, but before it was latin-1 only.
1104: try:
1105: uid = unicode(id, 'utf-8')
1106: except UnicodeError, TypeError:
1107: try:
1108: uid = unicode(id, 'iso-8859-15')
1109: except UnicodeError, TypeError:
1110: return id
1111: id = uid.encode('iso-8859-15', 'ignore')
1112: id = string.translate(id, TRANSMAP)
1113: return id
1114:
1115:
1116: # FileUpload factory
1117: from cgi import FieldStorage
1118: from ZPublisher.HTTPRequest import FileUpload
1119:
1120: def HTTPUpload(fp, content_type=None):
1121: """ Create a FileUpload instance from a file handle (and content_type) """
1122: if isinstance(fp, FileUpload):
1123: if content_type:
1124: fp.headers['content-type'] = content_type
1125: return fp
1126: else:
1127: environ = {'REQUEST_METHOD': 'POST'}
1128: if content_type:
1129: environ['CONTENT_TYPE'] = content_type
1130: elif hasattr(fp, 'headers') and fp.headers.has_key('content-type'):
1131: environ['CONTENT_TYPE'] = fp.headers['content-type']
1132: fs = FieldStorage(fp=fp, environ=environ)
1133: return FileUpload(fs)
1134:
1135:
1136: # Repository lock
1137: import time
1138:
1139: class DirLockError(OSError):
1140: pass
1141:
1142: class DirLock:
1143: """ Manage the lockfile for a directory """
1144:
1145: lock_name = '@@@lock'
1146: sleep_secs = 1.5
1147: sleep_times = 10
1148:
1149: def _mklock(self):
1150: f = open(self._lock, 'wt')
1151: f.write('ExtFile dir lock. You may want to remove this file.')
1152: f.close()
1153:
1154: def _rmlock(self):
1155: os.remove(self._lock)
1156:
1157: def islocked(self):
1158: os.path.isfile(self._lock)
1159:
1160: def release(self):
1161: self._rmlock()
1162:
1163: def __init__(self, dir):
1164: self._lock = os.path.join(dir, self.lock_name)
1165: for i in range(self.sleep_times):
1166: if self.islocked():
1167: LOG(_SUBSYS, BLATHER, "Waiting for lock '%s'" % self._lock)
1168: time.sleep(self.sleep_secs)
1169: else:
1170: self._mklock()
1171: break
1172: else:
1173: LOG(_SUBSYS, BLATHER, "Failed to get lock '%s'" % self._lock)
1174: raise DirLockError, "Failed to get lock '%s'" % self._lock
1175:
1176:
1177: # Stream iterator
1178: if IStreamIterator is not None:
1179:
1180: class stream_iterator:
1181: __implements__ = (IStreamIterator,)
1182:
1183: def __init__(self, stream, blocksize=2<<16):
1184: self._stream = stream
1185: self._blocksize = blocksize
1186:
1187: def next(self):
1188: data = self._stream.read(self._blocksize)
1189: if not data:
1190: self._stream.close()
1191: self._stream = None
1192: raise StopIteration
1193: return data
1194:
1195: def __len__(self):
1196: cur_pos = self._stream.tell()
1197: self._stream.seek(0, 2)
1198: size = self._stream.tell()
1199: self._stream.seek(cur_pos, 0)
1200: return size
1201:
1202: def __nonzero__(self):
1203: return self.__len__() and 1 or 0
1204:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ExtFile.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ExtFile