Fixed bug with some databases when a connection is killed.

Author: anthony-tuininga

doc/src/release_notes.rst

@@ -17,6 +17,10 @@ oracledb 3.1.1 (TBD)
 Thin Mode Changes
 +++++++++++++++++
 
+#)  Fixed bug with some databases when a connection is killed. In some
+    scenarios :meth:`Connection.is_healthy()` would have incorrectly returned
+    the value *True* and in other cases a possible hang could occur.
+
 Thick Mode Changes
 ++++++++++++++++++
 

src/oracledb/errors.py

@@ -112,17 +112,21 @@ def _make_adjustments(self):
                     args = {} if match is None else match.groupdict()
                 else:
                     driver_error_num = driver_error_info
-                if driver_error_num == ERR_CONNECTION_CLOSED:
-                    self.is_session_dead = True
                 driver_error = _get_error_text(driver_error_num, **args)
                 self.message = f"{driver_error}\n{self.message}"
                 self.full_code = f"{ERR_PREFIX}-{driver_error_num:04}"
 
         # determine exception class to use when raising this error
+        # also determine whether error is recoverable and whether the session
+        # is deemed "dead"
         if self.full_code.startswith("DPY-"):
             driver_error_num = int(self.full_code[4:])
+            if driver_error_num == ERR_CONNECTION_CLOSED:
+                self.is_session_dead = self.isrecoverable = True
             self.exc_type = ERR_EXCEPTION_TYPES[driver_error_num // 1000]
         elif self.code != 0:
+            if self.code in ERR_RECOVERABLE_ERROR_CODES:
+                self.isrecoverable = True
             if self.code in ERR_INTEGRITY_ERROR_CODES:
                 self.exc_type = exceptions.IntegrityError
             elif self.code in ERR_INTERFACE_ERROR_CODES:
@@ -485,6 +489,21 @@ def _raise_not_supported(feature: str) -> None:
     28511,  # lost RPC connection to heterogeneous remote agent
 ]
 
+# Oracle error codes that are deemed recoverable
+# NOTE: this does not include the errors that are mapped to
+# ERR_CONNECTION_CLOSED since those are all deemed recoverable
+ERR_RECOVERABLE_ERROR_CODES = [
+    376,  # file %s cannot be read at this time
+    1033,  # ORACLE initialization or shutdown in progress
+    1034,  # the Oracle instance is not available for use
+    1090,  # shutdown in progress
+    1115,  # IO error reading block from file %s (block # %s)
+    12514,  # Service %s is not registered with the listener
+    12571,  # TNS:packet writer failure
+    12757,  # instance does not currently know of requested service
+    16456,  # missing or invalid value
+]
+
 # driver error message exception types (multiples of 1000)
 ERR_EXCEPTION_TYPES = {
     1: exceptions.InterfaceError,

src/oracledb/impl/thin/messages/base.pyx

@@ -67,39 +67,10 @@ cdef class Message:
         connection" error is detected, the connection is forced closed
         immediately.
         """
-        cdef bint is_recoverable = False
         if self.error_occurred:
-            if self.error_info.num in (
-                28,     # session has been terminated
-                31,     # session marked for kill
-                376,    # file %s cannot be read at this time
-                603,    # ORACLE server session terminated
-                1012,   # not logged on
-                1033,   # ORACLE initialization or shutdown in progress
-                1034,   # the Oracle instance is not available for use
-                1089,   # immediate shutdown or close in progress
-                1090,   # shutdown in progress
-                1092,   # ORACLE instance terminated
-                1115,   # IO error reading block from file %s (block # %s)
-                2396,   # exceeded maximum idle time
-                3113,   # end-of-file on communication channel
-                3114,   # not connected to ORACLE
-                3135,   # connection lost contact
-                12153,  # TNS:not connected
-                12514,  # Service %s is not registered with the listener
-                12537,  # TNS:connection closed
-                12547,  # TNS:lost contact
-                12570,  # TNS:packet reader failure
-                12571,  # TNS:packet writer failure
-                12583,  # TNS:no reader
-                12757,  # instance does not currently know of requested service
-                16456,  # missing or invalid value
-            ):
-                is_recoverable = True
             error = errors._Error(self.error_info.message,
                                   code=self.error_info.num,
-                                  offset=self.error_info.pos,
-                                  isrecoverable=is_recoverable)
+                                  offset=self.error_info.pos)
             if error.is_session_dead:
                 self.conn_impl._protocol._force_close()
             raise error.exc_type(error)

src/oracledb/impl/thin/packet.pyx

@@ -65,7 +65,7 @@ cdef class Packet:
             char *ptr
         ptr = cpython.PyBytes_AS_STRING(self.buf)
         flags = decode_uint16be(<const char_type*> &ptr[PACKET_HEADER_SIZE])
-        if flags & TNS_DATA_FLAGS_END_OF_RESPONSE:
+        if flags & TNS_DATA_FLAGS_END_OF_RESPONSE or flags & TNS_DATA_FLAGS_EOF:
             return True
         if self.packet_size == PACKET_HEADER_SIZE + 3 \
                 and ptr[PACKET_HEADER_SIZE + 2] == TNS_MSG_TYPE_END_OF_RESPONSE:
@@ -231,6 +231,8 @@ cdef class ReadBuffer(Buffer):
                 errors._raise_err(errors.ERR_UNSUPPORTED_INBAND_NOTIFICATION,
                                   err_num=self._pending_error_num)
         elif self._transport is None:
+            if self._pending_error_num == TNS_ERR_SESSION_SHUTDOWN:
+                errors._raise_err(errors.ERR_CONNECTION_CLOSED)
             errors._raise_err(errors.ERR_NOT_CONNECTED)
 
     cdef int _get_int_length_and_sign(self, uint8_t *length,

src/oracledb/impl/thin/protocol.pyx

@@ -902,6 +902,9 @@ cdef class BaseAsyncProtocol(BaseProtocol):
         """
         if not self._in_connect:
             self._transport = None
+            self._read_buf._transport = None
+            self._write_buf._transport = None
+            self._read_buf._pending_error_num = TNS_ERR_SESSION_SHUTDOWN
             if self._read_buf._waiter is not None \
                     and not self._read_buf._waiter.done():
                 error = errors._create_err(errors.ERR_CONNECTION_CLOSED)