--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sat/memory/cache.py	Mon Apr 02 19:44:50 2018 +0200
@@ -0,0 +1,153 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+
+# SAT: a jabber client
+# Copyright (C) 2009-2018 Jérôme Poisson (goffi@goffi.org)
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program 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 Affero General Public License for more details.
+
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from sat.core.log import getLogger
+log = getLogger(__name__)
+from sat.tools.common import regex
+from sat.core import exceptions
+from sat.core.constants import Const as C
+import cPickle as pickle
+import mimetypes
+import os.path
+import time
+
+DEFAULT_EXT = '.raw'
+
+
+class Cache(object):
+    """generic file caching"""
+
+    def __init__(self, host, profile):
+        """
+        @param profile(unicode, None): ame of the profile to set the cache for
+            if None, the cache will be common for all profiles
+        """
+        self.profile = profile
+        path_elts = [host.memory.getConfig('', 'local_dir'), C.CACHE_DIR]
+        if profile:
+            path_elts.extend([u'profiles',regex.pathEscape(profile)])
+        else:
+            path_elts.append(u'common')
+        self.cache_dir = os.path.join(*path_elts)
+
+        if not os.path.exists(self.cache_dir):
+            os.makedirs(self.cache_dir)
+
+    def getPath(self, filename):
+        """return cached file URL
+
+        @param filename(unicode): cached file name (cache data or actual file)
+        """
+        if not filename or u'/' in filename:
+            log.error(u"invalid char found in file name, hack attempt? name:{}".format(filename))
+            raise exceptions.DataError(u"Invalid char found")
+        return os.path.join(self.cache_dir, filename)
+
+    def getMetadata(self, uid):
+        """retrieve metadata for cached data
+
+        @param uid(unicode): unique identifier of file
+        @return (dict, None): metadata with following keys:
+            see [cacheData] for data details, an additional "path" key is the full path to cached file.
+            None if file is not in cache (or cache is invalid)
+        """
+
+        uid = uid.strip()
+        if not uid:
+            raise exceptions.InternalError(u"uid must not be empty")
+        cache_url = self.getPath(uid)
+        if not os.path.exists(cache_url):
+            return None
+
+        try:
+            with open(cache_url, 'rb') as f:
+                cache_data = pickle.load(f)
+        except IOError:
+            log.warning(u"can't read cache at {}".format(cache_url))
+            return None
+        except pickle.UnpicklingError:
+            log.warning(u'invalid cache found at {}'.format(cache_url))
+            return None
+
+        try:
+            eol = cache_data['eol']
+        except KeyError:
+            log.warning(u'no End Of Life found for cached file {}'.format(uid))
+            eol = 0
+        if eol < time.time():
+            log.debug(u"removing expired cache (expired for {}s)".format(
+                time.time() - eol))
+            return None
+
+        cache_data['path'] = self.getPath(cache_data['filename'])
+        return cache_data
+
+    def getFilePath(self, uid):
+        """retrieve absolute path to file
+
+        @param uid(unicode): unique identifier of file
+        @return (unicode, None): absolute path to cached file
+            None if file is not in cache (or cache is invalid)
+        """
+        metadata = self.getMetadata(uid)
+        if metadata is not None:
+            return metadata['path']
+
+    def cacheData(self, source, uid, mime_type=None, max_age=None, filename=None):
+        """create cache metadata and file object to use for actual data
+
+        @param source(unicode): source of the cache (should be plugin's import_name)
+        @param uid(unicode): an identifier of the file which must be unique
+        @param mime_type(unicode): MIME type of the file to cache
+            it will be used notably to guess file extension
+        @param max_age(int, None): maximum age in seconds
+            the cache metadata will have an "eol" (end of life)
+            None to use default value
+            0 to ignore cache (file will be re-downloaded on each access)
+        @param filename: if not None, will be used as filename
+            else one will be generated from uid and guessed extension
+        @return(file): file object opened in write mode
+            you have to close it yourself (hint: use with statement)
+        """
+        cache_url = self.getPath(uid)
+        if filename is None:
+            if mime_type:
+                ext = mimetypes.guess_extension(mime_type, strict=False)
+                if ext is None:
+                    log.warning(u"can't find extension for MIME type {}".format(mime_type))
+                    ext = DEFAULT_EXT
+                elif ext == u'.jpe':
+                    ext = u'.jpg'
+            else:
+                ext = DEFAULT_EXT
+                mime_type = None
+            filename = uid + ext
+        if max_age is None:
+            max_age = C.DEFAULT_MAX_AGE
+        cache_data = {u'source': source,
+                      u'filename': filename,
+                      u'eol': int(time.time()) + max_age,
+                      u'mime_type': mime_type,
+                      }
+        file_path = self.getPath(filename)
+
+        with open(cache_url, 'wb') as f:
+            pickle.dump(cache_data, f, protocol=2)
+
+        return open(file_path, 'wb')