Esempio n. 1
0
 def __init__(self):
     """Constructor."""
     self.m_path = []
     self.m_cache = LruCache(1000)
Esempio n. 2
0
 def __init__(self, models, changes=None):
     """Constructor."""
     self.m_models = models
     if changes:
         self._set_change_manager(changes)
     self.m_cache = LruCache(1000)
Esempio n. 3
0
class ImageInfo(object):
    """Get image info.

    The object's responsibility is to provide information on images in
    certain parts of the file system. The information returns in a
    3-tuple of (format, with, height).

    A LRU cache is used for efficiency. The cache is validated on every
    access by means of file modification time.

    This class is thread safe.
    """

    def __init__(self):
        """Constructor."""
        self.m_path = []
        self.m_cache = LruCache(1000)

    @classmethod
    def _create(cls, api):
        """Factory method."""
        images = cls()
        docroot = api.request.docroot()
        images.add_path(docroot)
        config = api.config.ns('draco2.draco.image')
        if config.has_key('cachesize'):
            images._set_cache_size(config['cachesize'])
        if hasattr(api, 'changes'):
            images._set_change_manager(api.changes)
        return images

    def _set_change_manager(self, changes):
        """Set the change manager to `changes'."""
        ctx = changes.get_context('draco2.core.config')
        ctx.add_callback(self._change_callback)

    def _change_callback(self, api):
        """Reload config."""
        config = api.config.ns('draco2.draco.image')
        if config.has_key('cachesize'):
            self._set_cache_size(config['cachesize'])
        logger = logging.getLogger('draco2.draco.image')
        logger.debug('Reloaded due to config change.')

    def _set_cache_size(self, size):
        """Set the cache size."""
        self.m_cache.set_size(size)

    def add_path(self, path):
        """Add `path' to the image search path. """
        self.m_path.append(path)

    def get_info(self, fname):
        """Get image size for `fname'.

        The file `fname' is looked up in the path.
        """
        for path in self.m_path:
            # do not use os.path.join() as fname() may start with '/'
            fname = path + os.sep + fname
            try:
                st = os.stat(fname)
            except OSError:
                st = None
            if st and stat.S_ISREG(st.st_mode):
                break
        else:
            return
        mtime = st.st_mtime
        entry = self.m_cache.get(fname)
        if entry and entry[0] == mtime:
            return entry[1]
        info = get_image_info(fname)
        if not info:
            return
        entry = [mtime, info]
        self.m_cache.add(fname, entry)
        return info
Esempio n. 4
0
class Translator(TranslatorInterface):
    """The default translator.

    This translator uses the the DracoModel to translate messages. It also
    employs a LRU cache to cut down on the number of database lookups.
    """

    def __init__(self, models, changes=None):
        """Constructor."""
        self.m_models = models
        if changes:
            self._set_change_manager(changes)
        self.m_cache = LruCache(1000)

    @classmethod
    def _create(cls, api):
        """Factory method."""
        if hasattr(api, 'changes'):
            changes = api.changes
        else:
            changes = None
        translator = cls(api.models, changes)
        config = api.config.namespace('draco2.draco.config')
        if config.has_key('cachesize'):
            translator.set_cache_size(config['cachesize'])
        return translator

    def _set_change_manager(self, changes):
        """Use change manager `changes'."""
        ctx = changes.get_context('draco2.draco.translator')
        ctx.add_object('translation', self._mtime)
        ctx.add_callback(self._change_callback)
        ctx = changes.get_context('draco2.draco.config')  # for cache size
        ctx.add_callback(self._change_callback)

    def _change_callback(self, api):
        """Change callback."""
        self.clear_cache()
        config = api.config.namespace('draco2.draco.config')
        if config.has_key('cachesize'):
            self.set_cache_size(config['cachesize'])

    def _mtime(self):
        """Return the time stamp at which the last update to the
        translation table was made."""
        transaction = self.m_models.model('draco').transaction('shared')
        try:
            change = transaction.entity(Change, (Translation.name,))
        except ModelInterfaceError:
            return
        return change['change_date']

    def set_cache_size(self, size):
        """Set the cache size to `size'."""
        self.m_cache.set_size(size)

    def clear_cache(self):
        """Clear the translations cache."""
        self.m_cache.clear()

    def translate(self, message, languages, context=None, name=None):
        """Translate `message'."""
        hash = Message.hash(message)
        cacheid = (hash, context, name) + tuple(languages)
        translation = self.m_cache.get(cacheid)
        if translation:
            return translation
        # All translations are looked up where the corresponding message
        # matches `message' or `name', and that match any of the languages
        # specified in `languages'. If no results are found, `message' itself
        # is returned. If results are found, they are ordered by applying the
        # criteria mentioned below and the first entry is returned:
        # 1. Translations where the message name matched.
        # 2. Translations where the message id matched.
        # 3. Translations that have a language earlier in the `languages' list.
        # 4. Translations where the context matched.
        transaction = self.m_models.model('draco').transaction('shared')
        where = '(message.hash = %s'
        args = [hash]
        if name:
            where += ' OR message.name = %s'
            args.append(name)
        where += ')'
        array = ','.join(['%s'] * len(languages))
        where += ' AND language IN (%s)' % array
        args += languages
        # Ordering on columns that can contain NULL values: testing whether a
        # NULL value is equal to something always returns NULL, and therefore
        # we need to weed those out in the ordering test.
        order = []
        if name is not None:
            order.append('message.name = %s AND NOT name IS NULL DESC')
            args.append(name)
        else:
            order.append('message.name IS NULL DESC')
        order.append('message.hash = %s DESC')
        args.append(hash)
        order += ['language=%s DESC'] * len(languages)
        args += languages
        if context:
            order.append('message.context = %s AND NOT context IS NULL DESC')
            args.append(context)
        order = ','.join(order)
        join = (Translation, 'translation',
                MessageTranslationRelationship, 'INNER')
        result = transaction.select(Translation, where, args,
                                    order=order, join=join)
        if result:
            translation = result[0]['translation']
        else:
            translation = message
        self.m_cache.add(cacheid, translation)
        return translation