diff --git a/src/python/dm/aps_user_db/impl/oracleDbManager.py.working b/src/python/dm/aps_user_db/impl/oracleDbManager.py.working
deleted file mode 100755
index 2dc35ae753287b3a0d1bcdc577ec150df38228e6..0000000000000000000000000000000000000000
--- a/src/python/dm/aps_user_db/impl/oracleDbManager.py.working
+++ /dev/null
@@ -1,222 +0,0 @@
-#!/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
-
-