# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
#
# This file is part of CubicWeb.
#
# CubicWeb is free software: you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 2.1 of the License, or (at your option)
# any later version.
#
# CubicWeb is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with CubicWeb. If not, see <http://www.gnu.org/licenses/>.
"""Set of static resources controllers for :
- /data/...
- /static/...
- /fckeditor/...
"""
from __future__ import with_statement
import os
import os.path as osp
import hashlib
import mimetypes
from time import mktime
from datetime import datetime, timedelta
from logging import getLogger
from cubicweb import Unauthorized
from cubicweb.web import NotFound
from cubicweb.web.http_headers import generateDateTime
from cubicweb.web.controller import Controller
from cubicweb.web.views.urlrewrite import URLRewriter
class StaticFileController(Controller):
"""an abtract class to serve static file
Make sure to add your subclass to the STATIC_CONTROLLERS list"""
__abstract__ = True
directory_listing_allowed = False
def max_age(self, path):
"""max cache TTL"""
return 60*60*24*7
def static_file(self, path):
"""Return full content of a static file.
XXX iterable content would be better
"""
debugmode = self._cw.vreg.config.debugmode
if osp.isdir(path):
if self.directory_listing_allowed:
return u''
raise Unauthorized(path)
if not osp.isfile(path):
raise NotFound()
if not debugmode:
# XXX: Don't provide additional resource information to error responses
#
# the HTTP RFC recommands not going further than 1 year ahead
expires = datetime.now() + timedelta(days=6*30)
self._cw.set_header('Expires', generateDateTime(mktime(expires.timetuple())))
# XXX system call to os.stats could be cached once and for all in
# production mode (where static files are not expected to change)
#
# Note that: we do a osp.isdir + osp.isfile before and a potential
# os.read after. Improving this specific call will not help
#
# Real production environment should use dedicated static file serving.
self._cw.set_header('last-modified', generateDateTime(os.stat(path).st_mtime))
self._cw.validate_cache()
# XXX elif uri.startswith('/https/'): uri = uri[6:]
mimetype, encoding = mimetypes.guess_type(path)
self._cw.set_content_type(mimetype, osp.basename(path), encoding)
return file(path).read()
@property
def relpath(self):
"""path of a requested file relative to the controller"""
path = self._cw.form.get('static_relative_path')
if path is None:
path = self._cw.relative_path(includeparams=True)
return path
class ConcatFilesHandler(object):
"""Emulating the behavior of modconcat
this serve multiple file as a single one.
"""
def __init__(self, config):
self._resources = {}
self.config = config
self.logger = getLogger('cubicweb.web')
def _resource(self, path):
"""get the resouce"""
try:
return self._resources[path]
except KeyError:
self._resources[path] = self.config.locate_resource(path)
return self._resources[path]
def _up_to_date(self, filepath, paths):
"""
The concat-file is considered up-to-date if it exists.
In debug mode, an additional check is performed to make sure that
concat-file is more recent than all concatenated files
"""
if not osp.isfile(filepath):
return False
if self.config.debugmode:
concat_lastmod = os.stat(filepath).st_mtime
for path in paths:
dirpath, rid = self._resource(path)
if rid is None:
raise NotFound(path)
path = osp.join(dirpath, rid)
if os.stat(path).st_mtime > concat_lastmod:
return False
return True
def build_filepath(self, paths):
"""return the filepath that will be used to cache concatenation of `paths`
"""
_, ext = osp.splitext(paths[0])
fname = 'cache_concat_' + hashlib.md5(';'.join(paths)).hexdigest() + ext
return osp.join(self.config.appdatahome, 'uicache', fname)
def concat_cached_filepath(self, paths):
filepath = self.build_filepath(paths)
if not self._up_to_date(filepath, paths):
with open(filepath, 'wb') as f:
for path in paths:
dirpath, rid = self._resource(path)
if rid is None:
# In production mode log an error, do not return a 404
# XXX the erroneous content is cached anyway
self.logger.error('concatenated data url error: %r file '
'does not exist', path)
if self.config.debugmode:
raise NotFound(path)
else:
for line in open(osp.join(dirpath, rid)):
f.write(line)
f.write('\n')
return filepath
class DataController(StaticFileController):
"""Controller in charge of serving static file in /data/
Handle modeconcat like url.
"""
__regid__ = 'data'
def __init__(self, *args, **kwargs):
super(DataController, self).__init__(*args, **kwargs)
config = self._cw.vreg.config
md5_version = config.instance_md5_version()
self.base_datapath = config.data_relpath()
self.data_modconcat_basepath = '%s??' % self.base_datapath
self.concat_files_registry = ConcatFilesHandler(config)
def publish(self, rset=None):
config = self._cw.vreg.config
# includeparams=True for modconcat-like urls
relpath = self.relpath
if relpath.startswith(self.data_modconcat_basepath):
paths = relpath[len(self.data_modconcat_basepath):].split(',')
filepath = self.concat_files_registry.concat_cached_filepath(paths)
return self.static_file(filepath)
else:
relpath = relpath[len(self.base_datapath):] # skip leading '/data/'
dirpath, rid = config.locate_resource(relpath)
if dirpath is None:
raise NotFound()
return self.static_file(osp.join(dirpath, rid))
class FCKEditorController(StaticFileController):
"""Controller in charge of serving FCKEditor related file
The motivational for a dedicated controller have been lost.
"""
__regid__ = 'fckeditor'
def publish(self, rset=None):
config = self._cw.vreg.config
if self._cw.https:
uiprops = config.https_uiprops
else:
uiprops = config.uiprops
relpath = self.relpath
return self.static_file(osp.join(uiprops['FCKEDITOR_PATH'], relpath))
class StaticDirectoryController(StaticFileController):
"""Controller in charge of serving static file in /static/
"""
__regid__ = 'static'
def publish(self, rset=None):
staticdir = self._cw.vreg.config.static_directory
relpath = self.relpath
return self.static_file(osp.join(staticdir, relpath))
STATIC_CONTROLLERS = [DataController, FCKEditorController,
StaticDirectoryController]
class StaticControlerRewriter(URLRewriter):
"""a quick and dirty rewritter in charge of server static file.
This is a work around the flatness of url handling in cubicweb."""
__regid__ = 'static'
priority = 10
def rewrite(self, req, uri):
for ctrl in STATIC_CONTROLLERS:
if uri.startswith('/%s/' % ctrl.__regid__):
break
else:
self.debug("not a static file uri: %s", uri)
raise KeyError(uri)
relpath = self._cw.relative_path(includeparams=False)
self._cw.form['static_relative_path'] = self._cw.relative_path(includeparams=True)
return ctrl.__regid__, None