# This program is free software; you can redistribute it and/or modify it under
# the terms of the (LGPL) GNU Lesser 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 Library Lesser General Public License
# for more details at ( http://www.gnu.org/licenses/lgpl.html ).
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# written by: Jeff Ortel ( jortel@redhat.com )
"""
Basic caching classes.
"""
import suds
import suds.sax.element
import suds.sax.parser
import datetime
import os
try:
import pickle as pickle
except Exception:
import pickle
import shutil
import tempfile
from logging import getLogger
log = getLogger(__name__)
class Cache(object):
"""An object cache."""
def get(self, id):
"""
Get an object from the cache by id.
@param id: The object id.
@type id: str
@return: The object, else None.
@rtype: any
"""
raise Exception("not-implemented")
def put(self, id, object):
"""
Put an object into the cache.
@param id: The object id.
@type id: str
@param object: The object to add.
@type object: any
"""
raise Exception("not-implemented")
def purge(self, id):
"""
Purge an object from the cache by id.
@param id: A object id.
@type id: str
"""
raise Exception("not-implemented")
def clear(self):
"""Clear all objects from the cache."""
raise Exception("not-implemented")
class NoCache(Cache):
"""The pass-through object cache."""
def get(self, id):
return
def put(self, id, object):
pass
class FileCache(Cache):
"""
A file-based URL cache.
@cvar fnprefix: The file name prefix.
@type fnprefix: str
@cvar remove_default_location_on_exit: Whether to remove the default cache
location on process exit (default=True).
@type remove_default_location_on_exit: bool
@ivar duration: The duration after which cached entries expire (0=never).
@type duration: datetime.timedelta
@ivar location: The cached file folder.
@type location: str
"""
fnprefix = "suds"
__default_location = None
remove_default_location_on_exit = True
def __init__(self, location=None, **duration):
"""
Initialized a new FileCache instance.
If no cache location is specified, a temporary default location will be
used. Such default cache location will be shared by all FileCache
instances with no explicitly specified location within the same
process. The default cache location will be removed automatically on
process exit unless user sets the remove_default_location_on_exit
FileCache class attribute to False.
@param location: The cached file folder.
@type location: str
@param duration: The duration after which cached entries expire
(default: 0=never).
@type duration: keyword arguments for datetime.timedelta constructor
"""
if location is None:
location = self.__get_default_location()
self.location = location
self.duration = datetime.timedelta(**duration)
self.__check_version()
def clear(self):
for filename in os.listdir(self.location):
path = os.path.join(self.location, filename)
if os.path.isdir(path):
continue
if filename.startswith(self.fnprefix):
os.remove(path)
log.debug("deleted: %s", path)
def fnsuffix(self):
"""
Get the file name suffix.
@return: The suffix.
@rtype: str
"""
return "gcf"
def get(self, id):
try:
f = self._getf(id)
try:
return f.read()
finally:
f.close()
except Exception:
pass
def purge(self, id):
filename = self.__filename(id)
try:
os.remove(filename)
except Exception:
pass
def put(self, id, data):
try:
filename = self.__filename(id)
f = self.__open(filename, "wb")
try:
f.write(data)
finally:
f.close()
return data
except Exception:
log.debug(id, exc_info=1)
return data
def _getf(self, id):
"""Open a cached file with the given id for reading."""
try:
filename = self.__filename(id)
self.__remove_if_expired(filename)
return self.__open(filename, "rb")
except Exception:
pass
def __check_version(self):
path = os.path.join(self.location, "version")
try:
f = self.__open(path)
try:
version = f.read()
finally:
f.close()
if version != suds.__version__:
raise Exception()
except Exception:
self.clear()
f = self.__open(path, "w")
try:
f.write(suds.__version__)
finally:
f.close()
def __filename(self, id):
"""Return the cache file name for an entry with a given id."""
suffix = self.fnsuffix()
filename = "%s-%s.%s" % (self.fnprefix, id, suffix)
return os.path.join(self.location, filename)
@staticmethod
def __get_default_location():
"""
Returns the current process's default cache location folder.
The folder is determined lazily on first call.
"""
if not FileCache.__default_location:
tmp = tempfile.mkdtemp("suds-default-cache")
FileCache.__default_location = tmp
import atexit
atexit.register(FileCache.__remove_default_location)
return FileCache.__default_location
def __mktmp(self):
"""Create the I{location} folder if it does not already exist."""
try:
if not os.path.isdir(self.location):
os.makedirs(self.location)
except Exception:
log.debug(self.location, exc_info=1)
return self
def __open(self, filename, *args):
"""Open cache file making sure the I{location} folder is created."""
self.__mktmp()
return open(filename, *args)
@staticmethod
def __remove_default_location():
"""
Removes the default cache location folder.
This removal may be disabled by setting the
remove_default_location_on_exit FileCache class attribute to False.
"""
if FileCache.remove_default_location_on_exit:
# We must not load shutil here on-demand as under some
# circumstances this may cause the shutil.rmtree() operation to
# fail due to not having some internal module loaded. E.g. this
# happens if you run the project's test suite using the setup.py
# test command on Python 2.4.x.
shutil.rmtree(FileCache.__default_location, ignore_errors=True)
def __remove_if_expired(self, filename):
"""
Remove a cached file entry if it expired.
@param filename: The file name.
@type filename: str
"""
if not self.duration:
return
created = datetime.datetime.fromtimestamp(os.path.getctime(filename))
expired = created + self.duration
if expired < datetime.datetime.now():
os.remove(filename)
log.debug("%s expired, deleted", filename)
class DocumentCache(FileCache):
"""XML document file cache."""
def fnsuffix(self):
return "xml"
def get(self, id):
fp = None
try:
fp = self._getf(id)
if fp is not None:
p = suds.sax.parser.Parser()
cached = p.parse(fp)
fp.close()
return cached
except Exception:
if fp is not None:
fp.close()
self.purge(id)
def put(self, id, object):
if isinstance(object,
(suds.sax.document.Document, suds.sax.element.Element)):
super(DocumentCache, self).put(id, suds.byte_str(str(object)))
return object
class ObjectCache(FileCache):
"""
Pickled object file cache.
@cvar protocol: The pickling protocol.
@type protocol: int
"""
protocol = 2
def fnsuffix(self):
return "px"
def get(self, id):
fp = None
try:
fp = self._getf(id)
if fp is not None:
cached = pickle.load(fp)
fp.close()
return cached
except Exception:
if fp is not None:
fp.close()
self.purge(id)
def put(self, id, object):
data = pickle.dumps(object, self.protocol)
super(ObjectCache, self).put(id, data)
return object