def __init__(self):
""" Initialize the connection if Teiid configured """
# Fetch connection data from the config, bail out if missing
config = Config()
try:
database = config.teiid.database
user = config.teiid.user
password = config.teiid.password
host = config.teiid.host
port = config.teiid.port
except AttributeError:
log.debug("Teiid not configured, skipping db connection")
self.connection = None
return
# Initialize the connection
log.debug("Connecting as {0} to database {1} at {2}:{3}".format(
user, database, host, port))
try:
self.connection = psycopg2.connect(database=database,
user=user,
password=password,
host=host,
port=port)
except psycopg2.DatabaseError as error:
log.error("Teiid connect error: {0}".format(error))
raise TeiidError("Failed to connect to the Teiid instance")
self.connection.set_isolation_level(0)
def save(self):
""" Save caches to specified file """
# Nothing to do when persistent caching is off
if not self._filename or get_cache_level() < config.CACHE_PERSISTENT:
return
# Clear expired items and gather all caches into a single object
self.expire()
log.cache("Cache dump stats:\n" + self.stats().strip())
data = {}
for current_class in self._classes:
# Put container classes into id-sleep
if issubclass(current_class, containers.Container):
for container in current_class._cache.values():
container._sleep()
data[current_class.__name__] = current_class._cache
# Dump the cache object into file
try:
# Use temporary file to minimize the time during which
# the real cache is inconsistent
output_file = tempfile.NamedTemporaryFile(
mode="wb", delete=False, prefix="nitrate-cache.",
dir=os.path.dirname(self._filename))
log.cache("Temporary cache file: {0}".format(output_file.name))
output_file = gzip.open(output_file.name, "wb")
log.debug("Saving persistent cache into {0}".format(
self._filename))
pickle.dump(data, output_file)
output_file.close()
os.rename(output_file.name, self._filename)
log.debug("Persistent cache successfully saved")
except IOError as error:
log.error("Failed to save persistent cache ({0})".format(error))
def load(self):
""" Load caches from specified file """
# Nothing to do when persistent caching is off
if not self._filename or get_cache_level() < config.CACHE_PERSISTENT:
return
# Load the saved cache from file
try:
log.debug("Loading persistent cache from {0}".format(
self._filename))
input_file = gzip.open(self._filename, 'rb')
data = pickle.load(input_file)
input_file.close()
except EOFError:
log.cache("Cache file empty, will fill it upon exit")
return
except (IOError, zlib.error), error:
if getattr(error, "errno", None) == 2:
log.warn("Cache file not found, will create one on exit")
return
else:
log.error("Failed to load the cache ({0})".format(error))
log.warn("Going on but switching to the CACHE_OBJECTS level")
set_cache_level(config.CACHE_OBJECTS)
self.unlock()
return
def save(self):
""" Save caches to specified file """
# Nothing to do when persistent caching is off
if not self._filename or get_cache_level() < config.CACHE_PERSISTENT:
return
# Clear expired items and gather all caches into a single object
self.expire()
log.cache("Cache dump stats:\n" + self.stats().strip())
data = {}
for current_class in self._classes:
# Put container classes into id-sleep
if issubclass(current_class, containers.Container):
for container in current_class._cache.itervalues():
container._sleep()
data[current_class.__name__] = current_class._cache
# Dump the cache object into file
try:
# Use temporary file to minimize the time during which
# the real cache is inconsistent
output_file = tempfile.NamedTemporaryFile(
mode="wb", delete=False, prefix="nitrate-cache.",
dir=os.path.dirname(self._filename))
log.cache("Temporary cache file: {0}".format(output_file.name))
output_file = gzip.open(output_file.name, "wb")
log.debug("Saving persistent cache into {0}".format(
self._filename))
pickle.dump(data, output_file)
output_file.close()
os.rename(output_file.name, self._filename)
log.debug("Persistent cache successfully saved")
except IOError as error:
log.error("Failed to save persistent cache ({0})".format(error))
def unlock(self):
""" Remove the cache lock """
# Nothing to do when in read-only mode
if self._mode == "read-only":
return
try:
log.cache("Removing cache lock {0}".format(self._lock))
os.remove(self._lock)
except OSError as error:
log.error("Failed to remove the cache lock {0} ({1})".format(
self._lock, error))
def load(self):
""" Load caches from specified file """
# Nothing to do when persistent caching is off
if not self._filename or get_cache_level() < config.CACHE_PERSISTENT:
return
# Load the saved cache from file
try:
log.debug("Loading persistent cache from {0}".format(
self._filename))
input_file = gzip.open(self._filename, 'rb')
data = pickle.load(input_file)
input_file.close()
except EOFError:
log.cache("Cache file empty, will fill it upon exit")
return
except (IOError, zlib.error) as error:
if getattr(error, "errno", None) == 2:
log.warn("Cache file not found, will create one on exit")
return
else:
log.error("Failed to load the cache ({0})".format(error))
log.warn("Going on but switching to the CACHE_OBJECTS level")
set_cache_level(config.CACHE_OBJECTS)
self.unlock()
return
# Restore cache for immutable & mutable classes first
for current_class in self._immutable + self._mutable:
try:
log.cache("Loading cache for {0}".format(
current_class.__name__))
current_class._cache = data[current_class.__name__]
except KeyError:
log.cache("Failed to load cache for {0}, starting "
"with empty".format(current_class.__name__))
current_class._cache = {}
# Containers to be loaded last (to prevent object duplicates)
for current_class in self._containers:
try:
log.cache("Loading cache for {0}".format(
current_class.__name__))
current_class._cache = data[current_class.__name__]
except KeyError:
log.cache("Failed to load cache for {0}, starting "
"with empty".format(current_class.__name__))
current_class._cache = {}
# Wake up container objects from the id-sleep
for container in current_class._cache.values():
container._wake()
# Clear expired items and give a short summary for debugging
self.expire()
log.cache("Cache restore stats:\n" + self.stats().strip())
def unlock(self):
""" Remove the cache lock """
# Nothing to do when in read-only mode
if self._mode == "read-only":
return
try:
log.cache("Removing cache lock {0}".format(self._lock))
os.remove(self._lock)
except OSError as error:
log.error("Failed to remove the cache lock {0} ({1})".format(
self._lock, error))
def load(self):
""" Load caches from specified file """
# Nothing to do when persistent caching is off
if not self._filename or get_cache_level() < config.CACHE_PERSISTENT:
return
# Load the saved cache from file
try:
log.debug("Loading persistent cache from {0}".format(
self._filename))
input_file = gzip.open(self._filename, 'rb')
data = pickle.load(input_file)
input_file.close()
except EOFError:
log.cache("Cache file empty, will fill it upon exit")
return
except (IOError, zlib.error) as error:
if getattr(error, "errno", None) == 2:
log.warn("Cache file not found, will create one on exit")
return
else:
log.error("Failed to load the cache ({0})".format(error))
log.warn("Going on but switching to the CACHE_OBJECTS level")
set_cache_level(config.CACHE_OBJECTS)
self.unlock()
return
# Restore cache for immutable & mutable classes first
for current_class in self._immutable + self._mutable:
try:
log.cache("Loading cache for {0}".format(
current_class.__name__))
current_class._cache = data[current_class.__name__]
except KeyError:
log.cache("Failed to load cache for {0}, starting "
"with empty".format(current_class.__name__))
current_class._cache = {}
# Containers to be loaded last (to prevent object duplicates)
for current_class in self._containers:
try:
log.cache("Loading cache for {0}".format(
current_class.__name__))
current_class._cache = data[current_class.__name__]
except KeyError:
log.cache("Failed to load cache for {0}, starting "
"with empty".format(current_class.__name__))
current_class._cache = {}
# Wake up container objects from the id-sleep
for container in current_class._cache.itervalues():
container._wake()
# Clear expired items and give a short summary for debugging
self.expire()
log.cache("Cache restore stats:\n" + self.stats().strip())
def __init__(self):
""" Initialize the connection if Teiid configured """
# Fetch connection data from the config, bail out if missing
config = Config()
try:
database = config.teiid.database
user = config.teiid.user
password = config.teiid.password
host = config.teiid.host
port = config.teiid.port
except AttributeError:
log.debug("Teiid not configured, skipping db connection")
self.connection = None
return
# Initialize the connection
log.debug("Connecting as {0} to database {1} at {2}:{3}".format(
user, database, host, port))
try:
self.connection = psycopg2.connect(database=database,
user=user, password=password, host=host, port=port)
except psycopg2.DatabaseError, error:
log.error("Teiid connect error: {0}".format(error))
raise TeiidError("Failed to connect to the Teiid instance")