4.2.1-ticket5784-patch.txt0000644000076700000000000000773211624754034015447 0ustar moorewheel00000000000000From 1d8a5945f30a87aff20b3b55c77a63d708b8de33 Mon Sep 17 00:00:00 2001 From: Carlos Neves Date: Wed, 8 Jun 2011 03:14:01 +0100 Subject: [PATCH] Fixing the reconnect on session lost abort path (fixes #5784). What was happening in the failed test was that we had two connections on the same session uuid, and one requested the session to be killed. The theory is this should make the other connection die with a ConnectionLostException on any request, but in practice at the last stage of the reconnection attempt instead of trying to rejoin the session uuid on a new connection, a completely new session was being created for the user if the credentials where available. The code now prevents this scenario by making sure that the reconnection code can only attach to the previous session uuid or give up. --- .../tools/OmeroPy/src/omero/gateway/__init__.py | 29 ++++++++++++++++--- 1 files changed, 24 insertions(+), 5 deletions(-) diff --git a/components/tools/OmeroPy/src/omero/gateway/__init__.py b/components/tools/OmeroPy/src/omero/gateway/__init__.py index 409aa66..3963051 100644 --- a/components/tools/OmeroPy/src/omero/gateway/__init__.py +++ b/components/tools/OmeroPy/src/omero/gateway/__init__.py @@ -2354,11 +2354,16 @@ def safeCallWrap (self, attr, f): #pragma: no cover logger.debug(traceback.format_exc()) try: # Recreate connection - self._connect() + self._connect(forcejoin=True) logger.debug('last try for %s' % attr) # Last try, don't catch exception func = getattr(self._obj, attr) return func(*args, **kwargs) +# raise Ice.ConnectionLostException() + except Ice.ObjectNotExistException: + raise Ice.ConnectionLostException() + except Ice.CommunicatorDestroyedException: + raise Ice.ConnectionLostException() except: raise @@ -2377,10 +2382,16 @@ def safeCallWrap (self, attr, f): #pragma: no cover except Ice.UnknownException: logger.debug("UnknownException, bailing out") raise + except Ice.ConnectionLostException: + logger.debug("ConnectionLostException, bailing out") + raise + except Ice.CommunicatorDestroyedException: + logger.debug("CommunicatorDestroyedException, bailing out") + raise except Ice.Exception, x: logger.debug('wrapped ' + f.func_name) logger.debug(x.__dict__) - if x.serverExceptionClass == 'ome.conditions.InternalException': + if hasattr(x, 'serverExceptionClass') and x.serverExceptionClass == 'ome.conditions.InternalException': if x.message.find('java.lang.NullPointerException') > 0: logger.debug("NullPointerException, bailing out") raise @@ -2434,15 +2445,23 @@ class ProxyObjectWrapper (object): def clone (self): return ProxyObjectWrapper(self._conn, self._func_str) - def _connect (self): #pragma: no cover + def _connect (self, forcejoin=False): #pragma: no cover """ - Returns True if connected. + Returns True if connected. If connection OK, wrapped service is also created. + + @param forcejoin: if True forces the connection to only succeed if we can + rejoin the current sessionid + @type forcejoin: Boolean @return: Boolean """ logger.debug("proxy_connect: a"); - if not self._conn.connect(): + if forcejoin: + sUuid = self._conn._sessionUuid + else: + sUuid = None + if not self._conn.connect(sUuid=sUuid): logger.debug('connect failed') logger.debug('/n'.join(traceback.format_stack())) return False -- 1.7.5.4