raoul/openlp
1
0
Fork 0
forked from openlp/openlp
Code Issues Pull Requests Projects Releases Wiki Activity

This update is a tidy up of the code that fixed bug #927473

Browse Source 
Changes are made due to the following issues:

- the code assumed that exception OperationalError would only be thrown by  mySQL temporarily disappearing. However, other dbms can throw this exception and usually for errors that mean a retry will also fail.

- the code repeated the actual code of the method within the exception handler. This means code duplication and also that any new exceptions  are not handled by the same exception handler so for example their transaction will not get rolled back.

- not all potential dbms exceptions were caught and so in some cases the database transaction was not rolled back

The solution is to retry transactions where an OperationalError is thrown. Currently these are retried up to 3 times before the error is logged and the method returns false. By retrying the transaction we ensure that the same transaction code with the same exception handlers is used each time.

An additional catchall exception has been added where there is a transaction to ensure that it is rolled back. As with the OperationError this throws the exception back up the stack.
This commit is contained in:
Dave Warnock 2012-06-10 22:45:02 +01:00
parent f1afae1813
commit 913b0433f6
1 changed files with 145 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
openlp/core/lib/db.py
View File

@ -238,6 +238,7 @@ class Manager(object):
``commit`` ``commit``
Commit the session with this object Commit the session with this object
""" """
for tryCount in range(3):
try: try:
self.session.add(object_instance) self.session.add(object_instance)
if commit: if commit:
@ -248,17 +249,19 @@ class Manager(object):
# This exception clause is for users running MySQL which likes # This exception clause is for users running MySQL which likes
# to terminate connections on its own without telling anyone. # to terminate connections on its own without telling anyone.
# See bug #927473 # See bug #927473
# However, other dbms can raise it, usually in a non-recoverable
# way. So we only retry 3 times.
log.exception(u'Probably a MySQL issue - "MySQL has gone away"') log.exception(u'Probably a MySQL issue - "MySQL has gone away"')
self.session.rollback() self.session.rollback()
self.session.add(object_instance) if tryCount >= 2:
if commit: raise
self.session.commit()
self.is_dirty = True
return True
except InvalidRequestError: except InvalidRequestError:
self.session.rollback() self.session.rollback()
log.exception(u'Object save failed') log.exception(u'Object list save failed')
return False return False
except:
self.session.rollback()
raise
def save_objects(self, object_list, commit=True): def save_objects(self, object_list, commit=True):
""" """
@ -270,6 +273,7 @@ class Manager(object):
``commit`` ``commit``
Commit the session with this object Commit the session with this object
""" """
for tryCount in range(3):
try: try:
self.session.add_all(object_list) self.session.add_all(object_list)
if commit: if commit:
@ -280,17 +284,19 @@ class Manager(object):
# This exception clause is for users running MySQL which likes # This exception clause is for users running MySQL which likes
# to terminate connections on its own without telling anyone. # to terminate connections on its own without telling anyone.
# See bug #927473 # See bug #927473
# However, other dbms can raise it, usually in a non-recoverable
# way. So we only retry 3 times.
log.exception(u'Probably a MySQL issue, "MySQL has gone away"') log.exception(u'Probably a MySQL issue, "MySQL has gone away"')
self.session.rollback() self.session.rollback()
self.session.add_all(object_list) if tryCount >= 2:
if commit: raise
self.session.commit()
self.is_dirty = True
return True
except InvalidRequestError: except InvalidRequestError:
self.session.rollback() self.session.rollback()
log.exception(u'Object list save failed') log.exception(u'Object list save failed')
return False return False
except:
self.session.rollback()
raise
def get_object(self, object_class, key=None): def get_object(self, object_class, key=None):
""" """
@ -305,15 +311,18 @@ class Manager(object):
if not key: if not key:
return object_class() return object_class()
else: else:
for tryCount in range(3):
try: try:
return self.session.query(object_class).get(key) return self.session.query(object_class).get(key)
except OperationalError: except OperationalError:
# This exception clause is for users running MySQL which likes # This exception clause is for users running MySQL which likes
# to terminate connections on its own without telling anyone. # to terminate connections on its own without telling anyone.
# See bug #927473 # See bug #927473
# However, other dbms can raise it, usually in a non-recoverable
# way. So we only retry 3 times.
log.exception(u'Probably a MySQL issue, "MySQL has gone away"') log.exception(u'Probably a MySQL issue, "MySQL has gone away"')
self.session.rollback() if tryCount >= 2:
return self.session.query(object_class).get(key) raise
def get_object_filtered(self, object_class, filter_clause): def get_object_filtered(self, object_class, filter_clause):
""" """
@ -325,15 +334,18 @@ class Manager(object):
``filter_clause`` ``filter_clause``
The criteria to select the object by The criteria to select the object by
""" """
for tryCount in range(3):
try: try:
return self.session.query(object_class).filter(filter_clause).first() return self.session.query(object_class).filter(filter_clause).first()
except OperationalError: except OperationalError:
# This exception clause is for users running MySQL which likes # This exception clause is for users running MySQL which likes
# to terminate connections on its own without telling anyone. # to terminate connections on its own without telling anyone.
# See bug #927473 # See bug #927473
# However, other dbms can raise it, usually in a non-recoverable
# way. So we only retry 3 times.
log.exception(u'Probably a MySQL issue, "MySQL has gone away"') log.exception(u'Probably a MySQL issue, "MySQL has gone away"')
self.session.rollback() if tryCount >= 2:
return self.session.query(object_class).filter(filter_clause).first() raise
def get_all_objects(self, object_class, filter_clause=None, def get_all_objects(self, object_class, filter_clause=None,
order_by_ref=None): order_by_ref=None):
@ -357,15 +369,18 @@ class Manager(object):
query = query.order_by(*order_by_ref) query = query.order_by(*order_by_ref)
elif order_by_ref is not None: elif order_by_ref is not None:
query = query.order_by(order_by_ref) query = query.order_by(order_by_ref)
for tryCount in range(3):
try: try:
return query.all() return query.all()
except OperationalError: except OperationalError:
# This exception clause is for users running MySQL which likes # This exception clause is for users running MySQL which likes
# to terminate connections on its own without telling anyone. # to terminate connections on its own without telling anyone.
# See bug #927473 # See bug #927473
# However, other dbms can raise it, usually in a non-recoverable
# way. So we only retry 3 times.
log.exception(u'Probably a MySQL issue, "MySQL has gone away"') log.exception(u'Probably a MySQL issue, "MySQL has gone away"')
self.session.rollback() if tryCount >= 2:
return query.all() raise
def get_object_count(self, object_class, filter_clause=None): def get_object_count(self, object_class, filter_clause=None):
""" """
@ -381,15 +396,18 @@ class Manager(object):
query = self.session.query(object_class) query = self.session.query(object_class)
if filter_clause is not None: if filter_clause is not None:
query = query.filter(filter_clause) query = query.filter(filter_clause)
for tryCount in range(3):
try: try:
return query.count() return query.count()
except OperationalError: except OperationalError:
# This exception clause is for users running MySQL which likes # This exception clause is for users running MySQL which likes
# to terminate connections on its own without telling anyone. # to terminate connections on its own without telling anyone.
# See bug #927473 # See bug #927473
# However, other dbms can raise it, usually in a non-recoverable
# way. So we only retry 3 times.
log.exception(u'Probably a MySQL issue, "MySQL has gone away"') log.exception(u'Probably a MySQL issue, "MySQL has gone away"')
self.session.rollback() if tryCount >= 2:
return query.count() raise
def delete_object(self, object_class, key): def delete_object(self, object_class, key):
""" """
@ -403,6 +421,7 @@ class Manager(object):
""" """
if key != 0: if key != 0:
object_instance = self.get_object(object_class, key) object_instance = self.get_object(object_class, key)
for tryCount in range(3):
try: try:
self.session.delete(object_instance) self.session.delete(object_instance)
self.session.commit() self.session.commit()
@ -412,16 +431,19 @@ class Manager(object):
# This exception clause is for users running MySQL which likes # This exception clause is for users running MySQL which likes
# to terminate connections on its own without telling anyone. # to terminate connections on its own without telling anyone.
# See bug #927473 # See bug #927473
# However, other dbms can raise it, usually in a non-recoverable
# way. So we only retry 3 times.
log.exception(u'Probably a MySQL issue, "MySQL has gone away"') log.exception(u'Probably a MySQL issue, "MySQL has gone away"')
self.session.rollback() self.session.rollback()
self.session.delete(object_instance) if tryCount >= 2:
self.session.commit() raise
self.is_dirty = True
return True
except InvalidRequestError: except InvalidRequestError:
self.session.rollback() self.session.rollback()
log.exception(u'Failed to delete object') log.exception(u'Failed to delete object')
return False return False
except:
self.session.rollback()
raise
else: else:
return True return True
@ -439,6 +461,7 @@ class Manager(object):
The filter governing selection of objects to return. Defaults to The filter governing selection of objects to return. Defaults to
None. None.
""" """
for tryCount in range(3):
try: try:
query = self.session.query(object_class) query = self.session.query(object_class)
if filter_clause is not None: if filter_clause is not None:
@ -451,19 +474,19 @@ class Manager(object):
# This exception clause is for users running MySQL which likes # This exception clause is for users running MySQL which likes
# to terminate connections on its own without telling anyone. # to terminate connections on its own without telling anyone.
# See bug #927473 # See bug #927473
# However, other dbms can raise it, usually in a non-recoverable
# way. So we only retry 3 times.
log.exception(u'Probably a MySQL issue, "MySQL has gone away"') log.exception(u'Probably a MySQL issue, "MySQL has gone away"')
self.session.rollback() self.session.rollback()
query = self.session.query(object_class) if tryCount >= 2:
if filter_clause is not None: raise
query = query.filter(filter_clause)
query.delete(synchronize_session=False)
self.session.commit()
self.is_dirty = True
return True
except InvalidRequestError: except InvalidRequestError:
self.session.rollback() self.session.rollback()
log.exception(u'Failed to delete %s records', object_class.__name__) log.exception(u'Failed to delete %s records', object_class.__name__)
return False return False
except:
self.session.rollback()
raise
def finalise(self): def finalise(self):
""" """