def _check_registry_type(folder=None):
"""Check if the user has placed a registry_type.txt file to choose the registry type
If a default registry type file is found, the DefaultBackingType and DefaultBackingFile
class parameters in ComponentRegistry are updated accordingly.
Args:
folder (string): The folder that we should check for a default registry type
"""
if folder is None:
folder = settings_directory()
#If we are relative to a virtual environment, place the registry into that virtual env
#Support both virtualenv and pythnon 3 venv
if hasattr(sys, 'real_prefix'):
folder = sys.prefix
elif hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
folder = sys.prefix
default_file = os.path.join(folder, 'registry_type.txt')
try:
with open(default_file, "r") as infile:
data = infile.read()
data = data.strip()
ComponentRegistry.SetBackingStore(data)
except IOError:
pass
def _registry_folder(folder=None):
if folder is None:
folder = settings_directory()
# If we are relative to a virtual environment, place the registry into that virtual env
# Support both virtualenv and pythnon 3 venv
if hasattr(sys, 'real_prefix'):
folder = sys.prefix
elif hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
folder = sys.prefix
return folder
class SQLiteKVStore(object):
"""
A simple string - string persistent map backed by sqlite for concurrent access
The KeyValueStore can be made to respect python virtual environments if desired
"""
DefaultFolder = settings_directory()
def __init__(self, name, folder=None, respect_venv=False):
if folder is None:
folder = SQLiteKVStore.DefaultFolder
#If we are relative to a virtual environment, place the registry into that virtual env
#Support both virtualenv and pythnon 3 venv
if respect_venv and hasattr(sys, 'real_prefix'):
folder = sys.prefix
elif respect_venv and hasattr(
sys, 'base_prefix') and sys.base_prefix != sys.prefix:
folder = sys.prefix
if not os.path.exists(folder):
os.makedirs(folder, 0o755)
dbfile = os.path.join(folder, name)
self.connection = sqlite3.connect(dbfile)
self.cursor = self.connection.cursor()
self.file = dbfile
self._setup_table()
def _setup_table(self):
query = 'create table if not exists KVStore (key TEXT PRIMARY KEY, value TEXT);'
self.cursor.execute(query)
self.connection.commit()
def size(self):
query = 'select count(*) from KVStore'
self.cursor.execute(query)
return self.cursor.fetchone()[0]
def get_all(self):
query = 'select key, value from KVStore'
self.cursor.execute(query)
vals = self.cursor.fetchall()
return vals
def get(self, id):
query = 'select value from KVStore where key is ?'
self.cursor.execute(query, (id, ))
val = self.cursor.fetchone()
if val is None:
raise KeyError("id not in key-value store: %s" % str(id))
return val[0]
def remove(self, key):
query = "delete from KVStore where key is ?"
self.cursor.execute(query, (key, ))
self.connection.commit()
def try_get(self, id):
try:
return self.get(id)
except KeyError:
return None
def set(self, key, value):
query = "insert or replace into KVStore values (?, ?)"
self.cursor.execute(query, (key, str(value)))
self.connection.commit()
def clear(self):
query = 'drop table KVStore'
self.cursor.execute(query)
self.connection.commit()
self._setup_table()
class JSONKVStore:
"""A Key Value store based on flat json files with atomic write semantics
This is intended as a drop in replacement for SQLiteKVStore. Note that the
implementation is not meant to be efficient in the sense of caching the file
in memory. Instead it has read-through and write-through semantics where the
file is reloaded every time a request is made.
Args:
name (string): The name of the file to use as a persistent store for this KVStore
folder (string): Optional folder to store the file. If None, the system default
settings directory is used
respect_venv (bool): Make folder relative to the current virtual environment if there
is one.
"""
DefaultFolder = settings_directory()
def __init__(self, name, folder=None, respect_venv=False):
if folder is None:
folder = JSONKVStore.DefaultFolder
# If we are relative to a virtual environment, place the registry into that virtual env
# Support both virtualenv and pythnon 3 venv
if respect_venv and hasattr(sys, 'real_prefix'):
folder = sys.prefix
elif respect_venv and hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix:
folder = sys.prefix
if not os.path.exists(folder):
os.makedirs(folder, 0o755)
jsonfile = os.path.join(folder, name)
self.file = jsonfile
def _load_file(self):
"""Load all entries from json backing file
"""
if not os.path.exists(self.file):
return {}
with open(self.file, "r") as infile:
data = json.load(infile)
return data
def _save_file(self, data):
"""Attempt to atomically save file by saving and then moving into position
The goal is to make it difficult for a crash to corrupt our data file since
the move operation can be made atomic if needed on mission critical filesystems.
"""
if platform.system() == 'Windows':
with open(self.file, "w") as outfile:
json.dump(data, outfile)
else:
newpath = self.file + '.new'
with open(newpath, "w") as outfile:
json.dump(data, outfile)
os.rename(
os.path.realpath(newpath),
os.path.realpath(self.file)
)
def get(self, key):
"""Get a value by its key
Args:
key (string): The key used to store this value
Returns:
value (string): The value associated to the key
Raises:
KeyError: if the key was not found
"""
data = self._load_file()
return data[key]
def get_all(self):
"""Return a list of all (key, value) tuples in the kv store
Returns:
list(string, string): A list of key, value pairs
"""
data = self._load_file()
return data.items()
def remove(self, key):
"""Remove a key from the data store
Args:
key (string): The key to remove
Raises:
KeyError: if the key was not found
"""
data = self._load_file()
del data[key]
self._save_file(data)
def try_get(self, key):
"""Try to get a value by its key, returning None if not found
Args:
key (string): The key used to store this value
Returns:
value (string): The value associated to the key or None
"""
data = self._load_file()
return data.get(key, None)
def set(self, key, value):
"""Set the value of a key
Args:
key (string): The key used to store this value
value (string): The value to store
"""
data = self._load_file()
data[key] = value
self._save_file(data)
def clear(self):
"""Clear all values from this kv store
"""
self._save_file({})
def setUp(self):
self.settings_dir = settings_directory()
self.confdir = os.path.join(os.path.expanduser('~'), '.config')