erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix pep8 support in src/memory.

Browse source
This commit is contained in:
Emmanuel Gil Peyrot 2013-01-18 17:55:35 +01:00
commit 45488f486c
3 changed files with 176 additions and 177 deletions
Download patch file Download diff file Expand all files Collapse all files

149
src/memory/sqlite.py
View file

@ -19,50 +19,49 @@ 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 logging import debug, info, warning, error
from twisted.enterprise import adbapi
from twisted.internet import defer
from time import time
import os.path
import time
import cPickle as pickle
class SqliteStorage(object):
"""This class manage storage with Sqlite database"""
def __init__(self, db_filename):
"""Connect to the given database
@param db_filename: full path to the Sqlite database"""
self.initialized = defer.Deferred() #triggered when memory is fully initialised and ready
init_defers = [] #list of deferred we have to wait to before initialisation is complete
self.profiles={} #we keep cache for the profiles (key: profile name, value: profile id)
self.initialized = defer.Deferred() # triggered when memory is fully initialised and ready
init_defers = [] # list of deferred we have to wait to before initialisation is complete
self.profiles = {} # we keep cache for the profiles (key: profile name, value: profile id)
info(_("Connecting database"))
new_base = not os.path.exists(db_filename) #do we have to create the database ?
new_base = not os.path.exists(db_filename) # do we have to create the database ?
self.dbpool = adbapi.ConnectionPool("sqlite3", db_filename, check_same_thread=False)
init_defers.append(self.dbpool.runOperation("PRAGMA foreign_keys = ON").addErrback(lambda x: error(_("Can't activate foreign keys"))))
if new_base:
info(_("The database is new, creating the tables"))
database_creation = [
"CREATE TABLE profiles (id INTEGER PRIMARY KEY ASC, name TEXT, UNIQUE (name))",
"CREATE TABLE message_types (type TEXT PRIMARY KEY)",
"INSERT INTO message_types VALUES ('chat')",
"INSERT INTO message_types VALUES ('error')",
"INSERT INTO message_types VALUES ('groupchat')",
"INSERT INTO message_types VALUES ('headline')",
"INSERT INTO message_types VALUES ('normal')",
"CREATE TABLE history (id INTEGER PRIMARY KEY ASC, profile_id INTEGER, source TEXT, dest TEXT, source_res TEXT, dest_res TEXT, timestamp DATETIME, message TEXT, type TEXT, FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE, FOREIGN KEY(type) REFERENCES message_types(type))",
"CREATE TABLE param_gen (category TEXT, name TEXT, value TEXT, PRIMARY KEY (category,name))",
"CREATE TABLE param_ind (category TEXT, name TEXT, profile_id INTEGER, value TEXT, PRIMARY KEY (category,name,profile_id), FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE)",
"CREATE TABLE private_gen (namespace TEXT, key TEXT, value TEXT, PRIMARY KEY (namespace, key))",
"CREATE TABLE private_ind (namespace TEXT, key TEXT, profile_id INTEGER, value TEXT, PRIMARY KEY (namespace, key, profile_id), FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE)",
"CREATE TABLE private_gen_bin (namespace TEXT, key TEXT, value BLOB, PRIMARY KEY (namespace, key))",
"CREATE TABLE private_ind_bin (namespace TEXT, key TEXT, profile_id INTEGER, value BLOB, PRIMARY KEY (namespace, key, profile_id), FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE)",
"CREATE TABLE profiles (id INTEGER PRIMARY KEY ASC, name TEXT, UNIQUE (name))",
"CREATE TABLE message_types (type TEXT PRIMARY KEY)",
"INSERT INTO message_types VALUES ('chat')",
"INSERT INTO message_types VALUES ('error')",
"INSERT INTO message_types VALUES ('groupchat')",
"INSERT INTO message_types VALUES ('headline')",
"INSERT INTO message_types VALUES ('normal')",
"CREATE TABLE history (id INTEGER PRIMARY KEY ASC, profile_id INTEGER, source TEXT, dest TEXT, source_res TEXT, dest_res TEXT, timestamp DATETIME, message TEXT, type TEXT, FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE, FOREIGN KEY(type) REFERENCES message_types(type))",
"CREATE TABLE param_gen (category TEXT, name TEXT, value TEXT, PRIMARY KEY (category,name))",
"CREATE TABLE param_ind (category TEXT, name TEXT, profile_id INTEGER, value TEXT, PRIMARY KEY (category,name,profile_id), FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE)",
"CREATE TABLE private_gen (namespace TEXT, key TEXT, value TEXT, PRIMARY KEY (namespace, key))",
"CREATE TABLE private_ind (namespace TEXT, key TEXT, profile_id INTEGER, value TEXT, PRIMARY KEY (namespace, key, profile_id), FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE)",
"CREATE TABLE private_gen_bin (namespace TEXT, key TEXT, value BLOB, PRIMARY KEY (namespace, key))",
"CREATE TABLE private_ind_bin (namespace TEXT, key TEXT, profile_id INTEGER, value BLOB, PRIMARY KEY (namespace, key, profile_id), FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE)",
]
for op in database_creation:
d = self.dbpool.runOperation(op)
d.addErrback(lambda x: error(_("Error while creating tables in database [QUERY: %s]") % op ))
d.addErrback(lambda x: error(_("Error while creating tables in database [QUERY: %s]") % op))
init_defers.append(d)
def fillProfileCache(ignore):
@ -76,8 +75,8 @@ class SqliteStorage(object):
"""Fill the profiles cache
@param profiles_result: result of the sql profiles query"""
for profile in profiles_result:
name, id = profile
self.profiles[name] = id
name, id_ = profile
self.profiles[name] = id_
def getProfilesList(self):
""""Return list of all registered profiles"""
@ -86,20 +85,21 @@ class SqliteStorage(object):
def hasProfile(self, profile_name):
"""return True if profile_name exists
@param profile_name: name of the profile to check"""
return self.profiles.has_key(profile_name)
return profile_name in self.profiles
def createProfile(self, name):
"""Create a new profile
@param name: name of the profile
@return: deferred triggered once profile is actually created"""
def getProfileId(ignore):
return self.dbpool.runQuery("SELECT (id) FROM profiles WHERE name = ?", (name,))
return self.dbpool.runQuery("SELECT (id) FROM profiles WHERE name = ?", (name, ))
def profile_created(profile_id):
_id = profile_id[0][0]
self.profiles[name] = _id #we synchronise the cache
self.profiles[name] = _id # we synchronise the cache
d = self.dbpool.runQuery("INSERT INTO profiles(name) VALUES (?)", (name,))
d = self.dbpool.runQuery("INSERT INTO profiles(name) VALUES (?)", (name, ))
d.addCallback(getProfileId)
d.addCallback(profile_created)
return d
@ -111,20 +111,21 @@ class SqliteStorage(object):
def deletionError(failure):
error(_("Can't delete profile [%s]") % name)
return failure
del self.profiles[name]
d = self.dbpool.runQuery("DELETE FROM profiles WHERE name = ?", (name,))
d = self.dbpool.runQuery("DELETE FROM profiles WHERE name = ?", (name, ))
d.addCallback(lambda ignore: info(_("Profile [%s] deleted") % name))
return d
#Params
def loadGenParams(self, params_gen):
"""Load general parameters
@param params_gen: dictionary to fill
@return: deferred"""
def fillParams(result):
for param in result:
category,name,value = param
category, name, value = param
params_gen[(category, name)] = value
debug(_("loading general parameters from database"))
return self.dbpool.runQuery("SELECT category,name,value FROM param_gen").addCallback(fillParams)
@ -134,12 +135,13 @@ class SqliteStorage(object):
@param params_ind: dictionary to fill
@param profile: a profile which *must* exist
@return: deferred"""
def fillParams(result):
for param in result:
category,name,value = param
category, name, value = param
params_ind[(category, name)] = value
debug(_("loading individual parameters from database"))
d = self.dbpool.runQuery("SELECT category,name,value FROM param_ind WHERE profile_id=?", (self.profiles[profile],))
d = self.dbpool.runQuery("SELECT category,name,value FROM param_ind WHERE profile_id=?", (self.profiles[profile], ))
d.addCallback(fillParams)
return d
@ -149,7 +151,7 @@ class SqliteStorage(object):
@param name: name of the parameter
@param profile: %(doc_profile)s
@return: deferred"""
d = self.dbpool.runQuery("SELECT value FROM param_ind WHERE category=? AND name=? AND profile_id=?", (category,name,self.profiles[profile]))
d = self.dbpool.runQuery("SELECT value FROM param_ind WHERE category=? AND name=? AND profile_id=?", (category, name, self.profiles[profile]))
d.addCallback(self.__getFirstResult)
return d
@ -160,7 +162,7 @@ class SqliteStorage(object):
@param value: value to set
@return: deferred"""
d = self.dbpool.runQuery("REPLACE INTO param_gen(category,name,value) VALUES (?,?,?)", (category, name, value))
d.addErrback(lambda ignore: error(_("Can't set general parameter (%(category)s/%(name)s) in database" % {"category":category, "name":name})))
d.addErrback(lambda ignore: error(_("Can't set general parameter (%(category)s/%(name)s) in database" % {"category": category, "name": name})))
return d
def setIndParam(self, category, name, value, profile):
@ -171,7 +173,7 @@ class SqliteStorage(object):
@param profile: a profile which *must* exist
@return: deferred"""
d = self.dbpool.runQuery("REPLACE INTO param_ind(category,name,profile_id,value) VALUES (?,?,?,?)", (category, name, self.profiles[profile], value))
d.addErrback(lambda ignore: error(_("Can't set individual parameter (%(category)s/%(name)s) for [%(profile)s] in database" % {"category":category, "name":name, "profile":profile})))
d.addErrback(lambda ignore: error(_("Can't set individual parameter (%(category)s/%(name)s) for [%(profile)s] in database" % {"category": category, "name": name, "profile": profile})))
return d
#History
@ -185,10 +187,10 @@ class SqliteStorage(object):
"""
assert(profile)
d = self.dbpool.runQuery("INSERT INTO history(source, source_res, dest, dest_res, timestamp, message, type, profile_id) VALUES (?,?,?,?,?,?,?,?)",
(from_jid.userhost(), from_jid.resource, to_jid.userhost(), to_jid.resource, timestamp or time.time(),
message, _type, self.profiles[profile]))
(from_jid.userhost(), from_jid.resource, to_jid.userhost(), to_jid.resource, timestamp or time(),
message, _type, self.profiles[profile]))
d.addErrback(lambda ignore: error(_("Can't save following message in history: from [%(from_jid)s] to [%(to_jid)s] ==> [%(message)s]" %
{"from_jid":from_jid.full(), "to_jid":to_jid.full(), "message":message})))
{"from_jid": from_jid.full(), "to_jid": to_jid.full(), "message": message})))
return d
def getHistory(self, from_jid, to_jid, limit=0, between=True, profile=None):
@ -198,35 +200,35 @@ class SqliteStorage(object):
@param size: maximum number of messages to get, or 0 for unlimited
"""
assert(profile)
def sqliteToDict(query_result):
query_result.reverse()
result = []
for row in query_result:
timestamp, source, source_res, dest, dest_res, message, _type= row
timestamp, source, source_res, dest, dest_res, message, _type = row
result.append((timestamp, "%s/%s" % (source, source_res) if source_res else source,
"%s/%s" % (dest, dest_res) if dest_res else dest,
message, _type))
return result
query_parts = ["SELECT timestamp, source, source_res, dest, dest_res, message, type FROM history WHERE profile_id=? AND"]
values = [self.profiles[profile]]
def test_jid(_type,_jid):
def test_jid(_type, _jid):
values.append(_jid.userhost())
if _jid.resource:
values.append(_jid.resource)
return '(%s=? AND %s_res=?)' % (_type, _type)
return '%s=?' % (_type,)
return '%s=?' % (_type, )
if between:
query_parts.append("(%s OR %s) AND (%s or %s)" % (test_jid('source', from_jid),
test_jid('source', to_jid),
test_jid('dest', to_jid),
test_jid('dest', from_jid)))
test_jid('source', to_jid),
test_jid('dest', to_jid),
test_jid('dest', from_jid)))
else:
query_parts.append("%s AND %s") % (test_jid('source', from_jid),
test_jid('dest', to_jid))
query_parts.append("%s AND %s" % (test_jid('source', from_jid),
test_jid('dest', to_jid)))
query_parts.append("ORDER BY timestamp DESC")
@ -243,12 +245,13 @@ class SqliteStorage(object):
@param private_gen: dictionary to fill
@param namespace: namespace of the values
@return: deferred"""
def fillPrivates(result):
for private in result:
key,value = private
key, value = private
private_gen[key] = value
debug(_("loading general private values [namespace: %s] from database") % (namespace,))
d = self.dbpool.runQuery("SELECT key,value FROM private_gen WHERE namespace=?", (namespace,)).addCallback(fillPrivates)
debug(_("loading general private values [namespace: %s] from database") % (namespace, ))
d = self.dbpool.runQuery("SELECT key,value FROM private_gen WHERE namespace=?", (namespace, )).addCallback(fillPrivates)
return d.addErrback(lambda x: debug(_("No data present in database for namespace %s") % namespace))
def loadIndPrivates(self, private_ind, namespace, profile):
@ -257,11 +260,12 @@ class SqliteStorage(object):
@param namespace: namespace of the values
@param profile: a profile which *must* exist
@return: deferred"""
def fillPrivates(result):
for private in result:
key,value = private
key, value = private
private_ind[key] = value
debug(_("loading individual private values [namespace: %s] from database") % (namespace,))
debug(_("loading individual private values [namespace: %s] from database") % (namespace, ))
d = self.dbpool.runQuery("SELECT key,value FROM private_ind WHERE namespace=? AND profile_id=?", (namespace, self.profiles[profile]))
d.addCallback(fillPrivates)
return d.addErrback(lambda x: debug(_("No data present in database for namespace %s") % namespace))
@ -272,9 +276,9 @@ class SqliteStorage(object):
@param key: key of the private value
@param value: value to set
@return: deferred"""
d = self.dbpool.runQuery("REPLACE INTO private_gen(namespace,key,value) VALUES (?,?,?)", (namespace,key,value))
d = self.dbpool.runQuery("REPLACE INTO private_gen(namespace,key,value) VALUES (?,?,?)", (namespace, key, value))
d.addErrback(lambda ignore: error(_("Can't set general private value (%(key)s) [namespace:%(namespace)s] in database" %
{"namespace":namespace, "key":key})))
{"namespace": namespace, "key": key})))
return d
def setIndPrivate(self, namespace, key, value, profile):
@ -286,7 +290,7 @@ class SqliteStorage(object):
@return: deferred"""
d = self.dbpool.runQuery("REPLACE INTO private_ind(namespace,key,profile_id,value) VALUES (?,?,?,?)", (namespace, key, self.profiles[profile], value))
d.addErrback(lambda ignore: error(_("Can't set individual private value (%(key)s) [namespace: %(namespace)s] for [%(profile)s] in database" %
{"namespace":namespace, "key":key, "profile":profile})))
{"namespace": namespace, "key": key, "profile": profile})))
return d
def delGenPrivate(self, namespace, key):
@ -294,9 +298,9 @@ class SqliteStorage(object):
@param category: category of the privateeter
@param key: key of the private value
@return: deferred"""
d = self.dbpool.runQuery("DELETE FROM private_gen WHERE namespace=? AND key=?", (namespace,key))
d = self.dbpool.runQuery("DELETE FROM private_gen WHERE namespace=? AND key=?", (namespace, key))
d.addErrback(lambda ignore: error(_("Can't delete general private value (%(key)s) [namespace:%(namespace)s] in database" %
{"namespace":namespace, "key":key})))
{"namespace": namespace, "key": key})))
return d
def delIndPrivate(self, namespace, key, profile):
@ -307,21 +311,21 @@ class SqliteStorage(object):
@return: deferred"""
d = self.dbpool.runQuery("DELETE FROM private_ind WHERE namespace=? AND key=? AND profile=?)", (namespace, key, self.profiles[profile]))
d.addErrback(lambda ignore: error(_("Can't delete individual private value (%(key)s) [namespace: %(namespace)s] for [%(profile)s] in database" %
{"namespace":namespace, "key":key, "profile":profile})))
{"namespace": namespace, "key": key, "profile": profile})))
return d
def loadGenPrivatesBinary(self, private_gen, namespace):
"""Load general private binary values
@param private_gen: dictionary to fill
@param namespace: namespace of the values
@return: deferred"""
def fillPrivates(result):
for private in result:
key,value = private
key, value = private
private_gen[key] = pickle.loads(str(value))
debug(_("loading general private binary values [namespace: %s] from database") % (namespace,))
d = self.dbpool.runQuery("SELECT key,value FROM private_gen_bin WHERE namespace=?", (namespace,)).addCallback(fillPrivates)
debug(_("loading general private binary values [namespace: %s] from database") % (namespace, ))
d = self.dbpool.runQuery("SELECT key,value FROM private_gen_bin WHERE namespace=?", (namespace, )).addCallback(fillPrivates)
return d.addErrback(lambda x: debug(_("No binary data present in database for namespace %s") % namespace))
def loadIndPrivatesBinary(self, private_ind, namespace, profile):
@ -330,11 +334,12 @@ class SqliteStorage(object):
@param namespace: namespace of the values
@param profile: a profile which *must* exist
@return: deferred"""
def fillPrivates(result):
for private in result:
key,value = private
key, value = private
private_ind[key] = pickle.loads(str(value))
debug(_("loading individual private binary values [namespace: %s] from database") % (namespace,))
debug(_("loading individual private binary values [namespace: %s] from database") % (namespace, ))
d = self.dbpool.runQuery("SELECT key,value FROM private_ind_bin WHERE namespace=? AND profile_id=?", (namespace, self.profiles[profile]))
d.addCallback(fillPrivates)
return d.addErrback(lambda x: debug(_("No binary data present in database for namespace %s") % namespace))
@ -345,9 +350,9 @@ class SqliteStorage(object):
@param key: key of the private value
@param value: value to set
@return: deferred"""
d = self.dbpool.runQuery("REPLACE INTO private_gen_bin(namespace,key,value) VALUES (?,?,?)", (namespace,key,pickle.dumps(value,0)))
d = self.dbpool.runQuery("REPLACE INTO private_gen_bin(namespace,key,value) VALUES (?,?,?)", (namespace, key, pickle.dumps(value, 0)))
d.addErrback(lambda ignore: error(_("Can't set general private binary value (%(key)s) [namespace:%(namespace)s] in database" %
{"namespace":namespace, "key":key})))
{"namespace": namespace, "key": key})))
return d
def setIndPrivateBinary(self, namespace, key, value, profile):
@ -357,9 +362,9 @@ class SqliteStorage(object):
@param value: value to set
@param profile: a profile which *must* exist
@return: deferred"""
d = self.dbpool.runQuery("REPLACE INTO private_ind_bin(namespace,key,profile_id,value) VALUES (?,?,?,?)", (namespace, key, self.profiles[profile], pickle.dumps(value,0)))
d = self.dbpool.runQuery("REPLACE INTO private_ind_bin(namespace,key,profile_id,value) VALUES (?,?,?,?)", (namespace, key, self.profiles[profile], pickle.dumps(value, 0)))
d.addErrback(lambda ignore: error(_("Can't set individual binary private value (%(key)s) [namespace: %(namespace)s] for [%(profile)s] in database" %
{"namespace":namespace, "key":key, "profile":profile})))
{"namespace": namespace, "key": key, "profile": profile})))
return d
def delGenPrivateBinary(self, namespace, key):
@ -367,9 +372,9 @@ class SqliteStorage(object):
@param category: category of the privateeter
@param key: key of the private value
@return: deferred"""
d = self.dbpool.runQuery("DELETE FROM private_gen_bin WHERE namespace=? AND key=?", (namespace,key))
d = self.dbpool.runQuery("DELETE FROM private_gen_bin WHERE namespace=? AND key=?", (namespace, key))
d.addErrback(lambda ignore: error(_("Can't delete general private binary value (%(key)s) [namespace:%(namespace)s] in database" %
{"namespace":namespace, "key":key})))
{"namespace": namespace, "key": key})))
return d
def delIndPrivateBinary(self, namespace, key, profile):
@ -380,7 +385,7 @@ class SqliteStorage(object):
@return: deferred"""
d = self.dbpool.runQuery("DELETE FROM private_ind_bin WHERE namespace=? AND key=? AND profile=?)", (namespace, key, self.profiles[profile]))
d.addErrback(lambda ignore: error(_("Can't delete individual private binary value (%(key)s) [namespace: %(namespace)s] for [%(profile)s] in database" %
{"namespace":namespace, "key":key, "profile":profile})))
{"namespace": namespace, "key": key, "profile": profile})))
return d
##Helper methods##