def get_dbdir_summary(self, dirpath, name):
"""
Returns (people_count, bsddb_version, schema_version) of
current DB.
Returns ("Unknown", "Unknown", "Unknown") if invalid DB or other error.
"""
if config.get('preferences.use-bsddb3'):
from bsddb3 import dbshelve, db
else:
from bsddb import dbshelve, db
from gen.db import META, PERSON_TBL
from gen.db.dbconst import BDBVERSFN
bdbversion_file = os.path.join(dirpath, BDBVERSFN)
if os.path.isfile(bdbversion_file):
vers_file = open(bdbversion_file)
bsddb_version = vers_file.readline().strip()
else:
return "Unknown", "Unknown", "Unknown"
current_bsddb_version = str(db.version())
if bsddb_version != current_bsddb_version:
return "Unknown", bsddb_version, "Unknown"
env = db.DBEnv()
flags = db.DB_CREATE | db.DB_PRIVATE |\
db.DB_INIT_MPOOL |\
db.DB_INIT_LOG | db.DB_INIT_TXN
try:
env.open(dirpath, flags)
except Exception as msg:
LOG.warning("Error opening db environment for '%s': %s" %
(name, str(msg)))
try:
env.close()
except Exception as msg:
LOG.warning("Error closing db environment for '%s': %s" %
(name, str(msg)))
return "Unknown", bsddb_version, "Unknown"
dbmap1 = dbshelve.DBShelf(env)
fname = os.path.join(dirpath, META + ".db")
try:
dbmap1.open(fname, META, db.DB_HASH, db.DB_RDONLY)
except:
env.close()
return "Unknown", bsddb_version, "Unknown"
schema_version = dbmap1.get('version', default=None)
dbmap1.close()
dbmap2 = dbshelve.DBShelf(env)
fname = os.path.join(dirpath, PERSON_TBL + ".db")
try:
dbmap2.open(fname, PERSON_TBL, db.DB_HASH, db.DB_RDONLY)
except:
env.close()
return "Unknown", bsddb_version, schema_version
count = len(dbmap2)
dbmap2.close()
env.close()
return (count, bsddb_version, schema_version)
def _open_tables(self):
dbmap = dbshelve.DBShelf(self.env)
dbmap.db.set_pagesize(16384)
dbmap.open(self.full_name, 'person', db.DB_HASH,
db.DB_CREATE | db.DB_AUTO_COMMIT, 0o666)
person_map = dbmap
table_flags = db.DB_CREATE | db.DB_AUTO_COMMIT
surnames = db.DB(self.env)
surnames.set_flags(db.DB_DUP | db.DB_DUPSORT)
surnames.open(self.full_name,
"surnames",
db.DB_BTREE,
flags=table_flags)
def find_surname(key, data):
val = data.surname
if isinstance(val, str):
val = val.encode('utf-8')
return val
person_map.associate(surnames, find_surname, table_flags)
return (person_map, surnames)
def _open_treetables(self):
dbmap = dbshelve.DBShelf(self.env)
dbmap.db.set_pagesize(16384)
dbmap.open(self.full_name, 'places', db.DB_HASH,
db.DB_CREATE | db.DB_AUTO_COMMIT, 0o666)
place_map = dbmap
table_flags = db.DB_CREATE | db.DB_AUTO_COMMIT
placerefs = db.DB(self.env)
placerefs.set_flags(db.DB_DUP | db.DB_DUPSORT)
placerefs.open(self.full_name,
"placerefs",
db.DB_BTREE,
flags=table_flags)
def find_placeref(key, data):
val = data[2]
if isinstance(val, str):
val = val.encode('utf-8')
return val
place_map.associate(placerefs, find_placeref, table_flags)
return (place_map, placerefs)
def do_open(self):
self.homeDir = homeDir = os.path.join(
os.path.dirname(sys.argv[0]), 'db_home')
try: os.mkdir(homeDir)
except os.error: pass
self.env = db.DBEnv()
self.env.open(homeDir, self.envflags | db.DB_INIT_MPOOL | db.DB_CREATE)
self.filename = os.path.split(self.filename)[1]
self.d = dbshelve.DBShelf(self.env)
self.d.open(self.filename, self.dbtype, self.dbflags)
def __init__(self, generator, directory=None, prefix=None, suffix=None):
"""Create a new generator list cache.
generator - the generator to cache
directory - optional directory to create the cache
(defaults to dbfile_directory)
prefix - filename prefix for the cache (defaults to dbfile_prefix)
suffix - filename suffix for the cache (defaults to dbfile_suffix)
Following attributes are bound to the instance:
generator - the generator itself
uid - the unique ID of this cache ("%s-%s" % (os.getpid(), id(self))
path - the path to the cachefile
cache - the cache object
Note that using negative indices automatically leads to consuming
the whole generator.
"""
assert hasattr(generator, "next") and \
hasattr(generator, "__iter__")
super(dbcache, self).__init__()
if directory is None:
directory = dbcache.dbfile_directory
if prefix is None:
prefix = dbcache.dbfile_prefix
if suffix is None:
suffix = dbcache.dbfile_suffix
self.generator = generator
self.uid = "%i-%i" % (os.getpid(), id(self))
self.path = "%s/%s%s%s" % \
(directory, suffix, self.uid, prefix)
try:
os.unlink(self.path)
except OSError:
pass
self.__idx = None
self.__len = None
self.cache = dbshelve.DBShelf()
self.cache.open(self.path, None, db.DB_HASH, db.DB_CREATE)
def do_open(self):
self.d = dbshelve.DBShelf()
self.d.open(self.filename, self.dbtype, self.dbflags)
"""
return self.db.put(key, data, txn or self.txn, **kwargs)
def delete(self, key, txn=None, **kwargs):
"""
Removes a key/data pair from the database
"""
self.db.delete(key, txn or self.txn, **kwargs)
# test code
if __name__ == "__main__":
print("1")
from bsddb3 import db, dbshelve
print("2")
x = db.DBEnv()
print("3")
x.open('/tmp', db.DB_CREATE | db.DB_PRIVATE |\
db.DB_INIT_MPOOL |\
db.DB_INIT_LOG | db.DB_INIT_TXN)
print("4")
d = dbshelve.DBShelf(x)
print("5")
#from tran import BSDDBTxn as T
print("6")
T = BSDDBTxn
with T(x) as tx:
print("stat", tx.stat())
print("id", tx.id())
tx.checkpoint()
