Skip to content
Snippets Groups Projects
Commit 8e3da5c3 authored by sveseli's avatar sveseli
Browse files

cleanup

parent a8734f79
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/python/dm/aps_user_db/impl/oracleDbManager.py.working deleted 100755 → 0
+ 0
− 222
View file @ a8734f79
#!/usr/bin/env python
import threading
import os.path
import sqlalchemy
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import mapper
from sqlalchemy.orm import relationship
from dm.common.exceptions.commandFailed import CommandFailed
from dm.common.exceptions.configurationError import ConfigurationError
from dm.common.utility.loggingManager import LoggingManager
from dm.common.utility.configurationManager import ConfigurationManager
from dm.common.oracle.entities import oracleDbEntityMap
class OracleDbManager:
""" Singleton class for db management. """
DB_CONNECTION_POOL_SIZE = 10
DB_CONNECTION_POOL_MAX_OVERFLOW = 2
DB_CONNECTION_POOL_RECYCYLE_TIME = 600
DB_CONNECTION_POOL_TIMEOUT = 60
DB_CONNECTION_LOGGING_FLAG = False
CONFIG_SECTION_NAME = 'OracleDbManager'
CONFIG_OPTION_NAME_LIST = [ 'dbSchema', 'dbUser', 'dbPasswordFile' ]
# Singleton.
__lock = threading.RLock()
__instance = None
@classmethod
def getInstance(cls):
from dm.common.oracle.impl.oracleDbManager import OracleDbManager
try:
mgr = OracleDbManager()
except OracleDbManager, ex:
mgr = ex
return mgr
def __init__(self):
OracleDbManager.__lock.acquire()
try:
if OracleDbManager.__instance is not None:
raise OracleDbManager.__instance
OracleDbManager.__instance = self
self.lock = threading.RLock()
self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
cm = ConfigurationManager.getInstance()
#cm.setOptionsFromConfigFile(OracleDbManager.CONFIG_SECTION_NAME, OracleDbManager.CONFIG_OPTION_NAME_LIST)
#dbUser = cm.getDbUser()
#self.logger.debug('Using DB user: %s' % dbUser)
#dbSchema = cm.getDbSchema()
#dbPasswordFile = cm.getDbPasswordFile()
#self.logger.debug('Using DB password file: %s' % dbPasswordFile)
#dbPassword = open(dbPasswordFile, 'r').readline().strip()
#dbPort = cm.getDbPort()
#dbHost = cm.getDbHost()
#db = cm.getDb()
db = "oracle"
dbPort = 1527
dbHost = "ra.aps.anl.gov"
dbSchema = "aps1"
dbUser = "glob_conn"
dbPassword = "ur2ytkownicy2u"
#self.logger.debug('DB schema: %s' % dbSchema)
#self.logger.debug('DB password file: %s' % dbPasswordFile)
engineUrl = '%s://%s:%s@%s:%s/%s' % (db, dbUser, dbPassword, dbHost, dbPort, dbSchema)
self.logger.debug('Using engine URL: %s' % engineUrl)
self.engine = sqlalchemy.create_engine(engineUrl,
pool_size=OracleDbManager.DB_CONNECTION_POOL_SIZE,
max_overflow=OracleDbManager.DB_CONNECTION_POOL_MAX_OVERFLOW,
pool_recycle=OracleDbManager.DB_CONNECTION_POOL_RECYCYLE_TIME,
echo=OracleDbManager.DB_CONNECTION_LOGGING_FLAG,
pool_timeout=OracleDbManager.DB_CONNECTION_POOL_TIMEOUT)
self.metadata = sqlalchemy.MetaData(engineUrl, schema='DCC')
print self.metadata
# 'DCC.FL$03_BL_APV_VIEW_V2'
self.metadata.reflect(self.engine, schema='DCC')
print self.metadata.tables
print self.metadata.__dict__
view = sqlalchemy.Table('FL$03_BL_APV_VIEW_V2', self.metadata, autoload=True) #, schema='DCC')
print 'VIEW:', view.__dict__
view.c.badge_no.primary_key=True
#view.c.last_name.primary_key=True
for column in view.columns:
self.logger.debug('Column: %s' % column.name)
self.logger.debug('%s' % column.__dict__)
self.logger.debug('Mapping DB tables')
from dm.common.oracle.entities.oracleUserInfo import OracleUserInfo
#mapper(OracleUserInfo, view, primary_key=[view.c.last_name])
mapper(OracleUserInfo, view, primary_key=[view.c.badge_no])
#for (dbTableName, (dbEntityClass, dbRelationDict)) in oracleDbEntityMap.ORACLE_DB_ENTITY_MAP.items():
# self.mapTable(dbEntityClass, dbTableName, dbRelationDict)
self.logger.debug('Initialized SQLalchemy engines')
finally:
OracleDbManager.__lock.release()
def getLogger(self):
return self.logger
def inspectTables(self):
from sqlalchemy import inspect
inspector = inspect(self.engine)
self.logger.debug('Inspecting tables')
for tableName in inspector.get_table_names():
self.logger.debug('Table: %s' % tableName)
for column in inspector.get_columns(tableName):
self.logger.debug('Column: %s' % column['name'])
def inspectTables2(self):
from sqlalchemy import MetaData
m = MetaData()
m.reflect(self.engine)
self.logger.debug('Inspecting tables via metadata')
for table in m.tables.values():
self.logger.debug('Table: %s' % table.name)
for column in table.c:
self.logger.debug('Column: %s' % column.name)
def initTable(self, tableClass, tableName):
""" Initialize DB table. """
self.lock.acquire()
try:
tbl = sqlalchemy.Table(tableName, self.metadata, autoload=True)
tableClass.columns = tbl.columns
return tbl
finally:
self.lock.release()
def mapTable(self, tableClass, tableName, relationDict):
""" Map DB table to a given class. """
self.lock.acquire()
try:
table = sqlalchemy.Table(tableName, self.metadata, autoload=True)
tableClass.columns = table.columns
# Build relations from specified foreign key columns and other properties.
tableRelations = {}
primaryKey = None
for (name, propertyDict) in relationDict.items():
if name == 'self':
primaryKey = propertyDict.get('primary_key')
continue
lazy = propertyDict.get('lazy')
parentEntity = propertyDict.get('parentEntity')
foreignKeyColumns = propertyDict.get('foreignKeyColumns', [])
if len(foreignKeyColumns):
fkList = []
for fk in foreignKeyColumns:
fkList.append(table.columns.get(fk))
tableRelations[name] = relationship(parentEntity, foreign_keys=fkList, lazy=lazy)
else:
tableRelations[name] = relationship(parentEntity, lazy=lazy)
if primaryKey:
print 'MAPPED PK:', table.columns.get(primaryKey)
mapper(tableClass, table, tableRelations, primary_key=table.columns.get(primaryKey))
else:
mapper(tableClass, table, tableRelations)
return table
finally:
self.lock.release()
def getMetadataTable(self, table):
return self.metadata.tables[table]
def openSession(self):
""" Open db session. """
self.lock.acquire()
try:
Session = sessionmaker(bind=self.engine)
return Session()
finally:
self.lock.release()
def closeSession(self, session):
""" Close db session. """
self.lock.acquire()
try:
session.close()
finally:
self.lock.release()
def acquireConnection(self):
""" Get db connection. """
self.lock.acquire()
try:
return self.engine.connect()
finally:
self.lock.release()
def releaseConnection(self, connection):
""" Release db connection. """
self.lock.acquire()
try:
if connection:
connection.close()
finally:
self.lock.release()
#######################################################################
# Testing.
if __name__ == '__main__':
ConfigurationManager.getInstance().setConsoleLogLevel('debug')
mgr = OracleDbManager.getInstance()
mgr.acquireConnection()
mgr.inspectTables()
mgr.inspectTables2()
print 'Got connection'
from oracleUserInfoHandler import OracleUserInfoHandler
handler = OracleUserInfoHandler()
session = mgr.openSession()
users = handler.getUsers(session)
for u in users:
print u.badge_no, u.last_name
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment