dbi.dbi.DBI Class Reference

Inheritance diagram for dbi.dbi.DBI:

Collaboration diagram for dbi.dbi.DBI:

Public Member Functions
def	__init__ (self, config_dic)
def	checkTables (self)
def	getErrorCode (self)
def	getErrorMsg (self)
def	insert (self, tasks)
def	fetch (self, obj, clause)
def	sql (self, obj, clause)
def	fetchAll (self, tasks)
def	update (self, obj, clause)
def	insertOnUpdate (self, tasks, clause)
def	delete (self, obj, clause)
def	deleteAll (self, tasks)
def	sqlCustom (self, clause)

Static Public Member Functions
def	makeQueryFromObj (obj, engine, session)

Public Attributes
	engine
	session
	errorCode
	errorMessage

Static Public Attributes
list	MANDATORY_DBS

Detailed Description

Definition at line 37 of file dbi.py.

Constructor & Destructor Documentation

__init__()

def dbi.dbi.DBI.__init__	(		self,
			config_dic
	)

Definition at line 47 of file dbi.py.

  def __init__(self, config_dic):
    # db_name = config_dic["db_name"]
    engineString = "mysql+mysqldb://%s:%s@%s"
    engineString = engineString % (config_dic["db_user"], config_dic["db_pass"], config_dic["db_host"])
    if "db_port" in config_dic:
      engineString += ':' + str(config_dic["db_port"])
    engineString += '/' + config_dic["db_name"]

    # self.engine = create_engine("mysql+mysqldb://hce:hce12345@localhost:3306/dtm")
    self.engine = create_engine(engineString)
    self.checkTables()
    Session = sessionmaker(bind=self.engine)
    self.session = Session()

    self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
    self.errorMessage = CONSTANTS.DBI_SUCCESS_MSG

Member Function Documentation

checkTables()

def dbi.dbi.DBI.checkTables

(

self

)

Definition at line 68 of file dbi.py.

  def checkTables(self):
    try:
      insp = reflection.Inspector.from_engine(self.engine)
      avlTables = insp.get_table_names()
      for dbTable in self.MANDATORY_DBS:
        if dbTable not in avlTables:
          raise Exception(">>> %s table not present in database" % dbTable)
    except Exception as err:
      self.errorCode = CONSTANTS.DBI_COMMON_ERROR_CODE
      self.errorMessage = CONSTANTS.DBI_COMMON_ERROR_MSG + ": " + err.message
      raise DBIErr(self.getErrorCode(), self.getErrorMsg())

Here is the call graph for this function:

delete()

def dbi.dbi.DBI.delete	(		self,
			obj,
			clause
	)

Definition at line 367 of file dbi.py.

  def delete(self, obj, clause):
    with lock:
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
      deleted = []
      try:
        deleted_task = self.session.query(type(obj)).filter(text(clause)).first()
        if deleted_task:
          deleted.append(deleted_task)
          self.session.delete(deleted_task)
        self.session.commit()
      # Firstly, we check if exception was thrown by the DBI itself
      # If so we rollback DB
      except sqlalchemy.exc.SQLAlchemyError as err:
        self.session.rollback()
        self.errorCode = CONSTANTS.DBI_DELETE_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_DELETE_ERROR_MSG + ": " + str(err)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())
      except Exception as err:
        self.errorCode = CONSTANTS.DBI_DELETE_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_DELETE_ERROR_MSG + ": " + str(err)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      return deleted


#   # #deleteAll
#   # delete all objects from the database
#   # @param tasks - object type for deleting
#   # @return list of deleted objects
#   # @error can be checked by the getError() method
#   #
#   def deleteAll(self, tasks):
#     with lock:
#       deleted = []
#       self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
#       try:
#         conn = self.engine.connect()
#         if hasattr(tasks, "__len__"):
#           for task in tasks:
#             conn.execute(type(task).delete())
#         else:
#           # conn.execute(type(tasks).delete())
#           # self.session.query(delete(tasks))
#           # self.session.delete(tasks)
#           ress = self.session.query(tasks).filter(tasks.UThreads == "").first()
#           # ress = conn.execute(select([type(tasks)])).fetchall()
#           for res in ress:
#             self.session.delete(res)
#         self.session.commit()
#       # Firstly, we check if exception was thrown by the DBI itself
#       # If so we rollback DB
#       except sqlalchemy.exc.SQLAlchemyError as err:
#         self.session.rollback()
#         self.errorCode = CONSTANTS.DBI_DELETE_ERROR_CODE
#         self.errorMessage = CONSTANTS.DBI_DELETE_ERROR_MSG + ": " + err.message
#         raise DBIErr(self.getErrorCode(), self.getErrorMsg())
#       except Exception as err:
#         self.errorCode = CONSTANTS.DBI_DELETE_ERROR_CODE
#         self.errorMessage = CONSTANTS.DBI_DELETE_ERROR_MSG + ": " + err.message
#         raise DBIErr(self.getErrorCode(), self.getErrorMsg())
#       return deleted

Here is the call graph for this function:

Here is the caller graph for this function:

deleteAll()

def dbi.dbi.DBI.deleteAll	(		self,
			tasks
	)

Definition at line 435 of file dbi.py.

  def deleteAll(self, tasks):
    with lock:
      deleted = []
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
      connection = None
      try:
        connection = self.engine.connect()

        taskList = []
        if isinstance(tasks, collections.Iterable):
          taskList = tasks
        else:
          taskList.append(tasks)

        # boolean flag exist faults
        hasFaults = False
        for task in taskList:
          try:
            connection.execute(type(task).delete())
          except sqlalchemy.exc.SQLAlchemyError, err:
            self.session.rollback()
            self.errorMessage = CONSTANTS.DBI_DELETE_ERROR_MSG + ": " + str(err)
            hasFaults = True
          except Exception, err:
            self.errorMessage = CONSTANTS.DBI_DELETE_ERROR_MSG + ": " + str(err)
            hasFaults = True

        if hasFaults:
          self.errorCode = CONSTANTS.DBI_DELETE_ERROR_CODE
          raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      except DBIErr, e:
        raise e
      except Exception, e:
        raise DBIErr(CONSTANTS.DBI_DELETE_ERROR_CODE, str(e))
      finally:
        if connection is not None:
          connection.close()

      return deleted

Here is the call graph for this function:

fetch()

def dbi.dbi.DBI.fetch	(		self,
			obj,
			clause
	)

Definition at line 148 of file dbi.py.

  def fetch(self, obj, clause):
    with lock:
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
      fetched = []
      try:
        rows = self.session.query(type(obj)).filter(text(clause)).all()
        if len(rows):
          fetched = rows
      # Firstly, we check if exception was thrown by the DBI itself
      # If so we rollback DB
      except sqlalchemy.exc.SQLAlchemyError as err:
        self.session.rollback()
        self.errorCode = CONSTANTS.DBI_FETCH_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_FETCH_ERROR_MSG + ": " + str(err)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())
      except Exception as err:
        self.errorCode = CONSTANTS.DBI_FETCH_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_FETCH_ERROR_MSG + ": " + str(err)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      return fetched

Here is the call graph for this function:

fetchAll()

def dbi.dbi.DBI.fetchAll	(		self,
			tasks
	)

Definition at line 242 of file dbi.py.

  def fetchAll(self, tasks):
    with lock:
      # variable for result
      fetched = []
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE

      connection = None
      try:
        connection = self.engine.connect()

        taskList = []
        if isinstance(tasks, collections.Iterable):
          taskList = tasks
        else:
          taskList.append(tasks)

        # boolean flag exist faults
        hasFaults = False
        for task in taskList:
          try:
            fetched.append(connection.execute(select([type(task)])).fetchall())
          except sqlalchemy.exc.SQLAlchemyError, err:
            self.session.rollback()
            self.errorMessage = CONSTANTS.DBI_FETCH_ERROR_MSG + ": " + str(err)
            hasFaults = True
          except Exception, err:
            self.errorMessage = CONSTANTS.DBI_FETCH_ERROR_MSG + ": " + str(err)
            hasFaults = True

        if hasFaults:
          self.errorCode = CONSTANTS.DBI_FETCH_ERROR_CODE
          raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      except DBIErr, e:
        raise e
      except Exception, e:
        raise DBIErr(CONSTANTS.DBI_FETCH_ERROR_CODE, str(e))
      finally:
        if connection is not None:
          connection.close()

      return fetched

Here is the call graph for this function:

getErrorCode()

def dbi.dbi.DBI.getErrorCode

(

self

)

Definition at line 86 of file dbi.py.

  def getErrorCode(self):
    return self.errorCode

Here is the caller graph for this function:

getErrorMsg()

def dbi.dbi.DBI.getErrorMsg

(

self

)

Definition at line 95 of file dbi.py.

  def getErrorMsg(self):
    return self.errorMessage

Here is the caller graph for this function:

insert()

def dbi.dbi.DBI.insert	(		self,
			tasks
	)

Definition at line 106 of file dbi.py.

  def insert(self, tasks):
    with lock:
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE

      taskList = []
      if isinstance(tasks, collections.Iterable):
        taskList = tasks
      else:
        taskList.append(tasks)

      # boolean flag exist faults
      hasFaults = False

      for task in taskList:
        try:
          self.session.add(task)
          self.session.commit()
        except sqlalchemy.exc.SQLAlchemyError, err:
          logger.info("tasks: %s, type: %s", str(tasks), str(type(tasks)))
          self.errorMessage = CONSTANTS.DBI_INSERT_ERROR_MSG + ": " + str(err)
          self.session.rollback()
          hasFaults = True
        except Exception, err:
          logger.info("tasks: %s, type: %s", str(tasks), str(type(tasks)))
          self.errorMessage = CONSTANTS.DBI_INSERT_ERROR_MSG + ": " + str(err)
          hasFaults = True

      if hasFaults:
        self.errorCode = CONSTANTS.DBI_INSERT_ERROR_CODE
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      return tasks

Here is the call graph for this function:

Here is the caller graph for this function:

insertOnUpdate()

def dbi.dbi.DBI.insertOnUpdate	(		self,
			tasks,
			clause
	)

Definition at line 330 of file dbi.py.

  def insertOnUpdate(self, tasks, clause):  # pylint: disable=W0613
    with lock:
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
      try:

        taskList = []
        if isinstance(tasks, collections.Iterable):
          taskList = tasks
        else:
          taskList.append(tasks)

        for task in taskList:
          self.session.merge(task)

        self.session.commit()
      # Firstly, we check if exception was thrown by the DBI itself
      # If so we rollback DB
      except sqlalchemy.exc.SQLAlchemyError as err:
        self.session.rollback()
        self.errorCode = CONSTANTS.DBI_INSERT_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_INSERT_ERROR_MSG + ": " + str(err)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())
      except Exception as err:
        self.errorCode = CONSTANTS.DBI_INSERT_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_INSERT_ERROR_MSG + ": " + str(err)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      return tasks

Here is the call graph for this function:

makeQueryFromObj()

def dbi.dbi.DBI.makeQueryFromObj (   obj,   engine,   session  )

static

Definition at line 515 of file dbi.py.

  def makeQueryFromObj(obj, engine, session):
    ret = None
    criterions = {}
    insp = reflection.Inspector.from_engine(engine)
    localColumns = insp.get_columns(obj.__tablename__)
    for columName in [elem["name"] for elem in localColumns]:
      if columName in obj.__dict__:
        criterions[columName] = obj.__dict__[columName]
    if len(criterions) > 0:
      ret = session.query(type(obj)).filter_by(**criterions)
    return ret


# #Class is used to inform about error of DBI object
#
#

sql()

def dbi.dbi.DBI.sql	(		self,
			obj,
			clause
	)

Definition at line 179 of file dbi.py.

  def sql(self, obj, clause):
    with lock:
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
      fetched = []
      try:
        rows = self.session.query(type(obj)).from_statement(text(clause)).all()
        if len(rows):
          fetched = rows
      # Firstly, we check if exception was thrown by the DBI itself
      # If so we rollback DB
      except sqlalchemy.exc.SQLAlchemyError as err:
        self.session.rollback()
        self.errorCode = CONSTANTS.DBI_SQL_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_SQL_ERROR_MSG + ": " + str(err) + ", clause:\n" + str(clause)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())
      except Exception as err:
        self.errorCode = CONSTANTS.DBI_SQL_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_SQL_ERROR_MSG + ": " + str(err) + ", clause:\n" + str(clause)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      return fetched


#   # #fetchAll
#   # fetch all objects from the database
#   #
#   # @param tasks - object type for fetching
#   # @return list of fetched objects
#   # @error can be checked by the getError() method
#   #
#   def fetchAll(self, tasks):
#     with lock:
#       self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
#       fetched = []
#
#
#       try:
#         conn = self.engine.connect()
#         if hasattr(tasks, "__len__"):
#           for task in tasks:
#             fetched.append(conn.execute(select([type(task)])).fetchall())
#         else:
#           fetched.append(conn.execute(select([type(tasks)])).fetchall())
#       # Firstly, we check if exception was thrown by the DBI itself
#       # If so we rollback DB
#       except sqlalchemy.exc.SQLAlchemyError as err:
#         self.session.rollback()
#         self.errorCode = CONSTANTS.DBI_FETCH_ERROR_CODE
#         self.errorMessage = CONSTANTS.DBI_FETCH_ERROR_MSG + ": " + err.message
#         raise DBIErr(self.getErrorCode(), self.getErrorMsg())
#       except Exception as err:
#         self.errorCode = CONSTANTS.DBI_FETCH_ERROR_CODE
#         self.errorMessage = CONSTANTS.DBI_FETCH_ERROR_MSG + ": " + err.message
#         raise DBIErr(self.getErrorCode(), self.getErrorMsg())
#       return fetched

Here is the call graph for this function:

sqlCustom()

def dbi.dbi.DBI.sqlCustom	(		self,
			clause
	)

Definition at line 482 of file dbi.py.

  def sqlCustom(self, clause):
    with lock:
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
      customResponse = []
      try:
        sqlText = text(clause)
        result = self.session.execute(sqlText)
        if result is not None:
          customResponse = result.fetchall()
        self.session.commit()
      # Firstly, we check if exception was thrown by the DBI itself
      # If so we rollback DB
      except sqlalchemy.exc.SQLAlchemyError as err:
        self.session.rollback()
        self.errorCode = CONSTANTS.DBI_SQL_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_SQL_ERROR_MSG + ": " + err.message
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())
      except Exception as err:
        self.errorCode = CONSTANTS.DBI_SQL_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_SQL_ERROR_MSG + ": " + err.message
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      return customResponse

Here is the call graph for this function:

update()

def dbi.dbi.DBI.update	(		self,
			obj,
			clause
	)

Definition at line 294 of file dbi.py.

  def update(self, obj, clause):
    with lock:
      self.errorCode = CONSTANTS.DBI_SUCCESS_CODE
      updated = []
      try:
        updated_task = self.session.query(type(obj)).filter(text(clause)).first()
        if updated_task:
          attributes = [attr for attr in dir(obj) if not attr.startswith('__') \
                        and not attr.startswith('_') and getattr(obj, attr) is not None]
          # attributes = [attr for attr in dir(obj) if not attr.startswith('__') and not attr.startswith('_')]
          for attr in attributes:
            setattr(updated_task, attr, getattr(obj, attr))
          updated.append(updated_task)
        self.session.commit()
      # Firstly, we check if exception was thrown by the DBI itself
      # If so we rollback DB
      except sqlalchemy.exc.SQLAlchemyError as err:
        self.session.rollback()
        self.errorCode = CONSTANTS.DBI_UPDATE_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_UPDATE_ERROR_MSG + ": " + str(err)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())
      except Exception as err:
        self.errorCode = CONSTANTS.DBI_UPDATE_ERROR_CODE
        self.errorMessage = CONSTANTS.DBI_UPDATE_ERROR_MSG + ": " + str(err)
        raise DBIErr(self.getErrorCode(), self.getErrorMsg())

      return updated

Here is the call graph for this function:

Member Data Documentation

engine

dbi.dbi.DBI.engine

Definition at line 56 of file dbi.py.

errorCode

dbi.dbi.DBI.errorCode

Definition at line 61 of file dbi.py.

errorMessage

dbi.dbi.DBI.errorMessage

Definition at line 62 of file dbi.py.

MANDATORY_DBS

list dbi.dbi.DBI.MANDATORY_DBS

static

Initial value:

=  ["ee_responses_table", "resources_table", "scheduler_task_scheme", "task_back_log_scheme",
                   "task_log_scheme", "tasks_data_table"]

Definition at line 39 of file dbi.py.

session

dbi.dbi.DBI.session

Definition at line 59 of file dbi.py.

---

The documentation for this class was generated from the following file:

• sources/hce/dbi/dbi.py