Rename end of request to end of response for accuracy; code

simplification.

Author: anthony-tuininga

src/oracledb/impl/thin/capabilities.pyx

@@ -41,7 +41,7 @@ cdef class Capabilities:
         uint32_t max_string_size
         bint supports_fast_auth
         bint supports_oob
-        bint supports_end_of_request
+        bint supports_end_of_response
         uint32_t sdu
 
     def __init__(self):
@@ -60,19 +60,19 @@ cdef class Capabilities:
         if flags & TNS_ACCEPT_FLAG_FAST_AUTH:
             self.supports_fast_auth = True
         if protocol_version >= TNS_VERSION_MIN_END_OF_RESPONSE \
-                and flags & TNS_ACCEPT_FLAG_HAS_END_OF_REQUEST:
-            self.compile_caps[TNS_CCAP_TTC4] |= TNS_CCAP_END_OF_REQUEST
-            self.supports_end_of_request = True
+                and flags & TNS_ACCEPT_FLAG_HAS_END_OF_RESPONSE:
+            self.compile_caps[TNS_CCAP_TTC4] |= TNS_CCAP_END_OF_RESPONSE
+            self.supports_end_of_response = True
 
     @cython.boundscheck(False)
     cdef void _adjust_for_server_compile_caps(self, bytearray server_caps):
         if server_caps[TNS_CCAP_FIELD_VERSION] < self.ttc_field_version:
             self.ttc_field_version = server_caps[TNS_CCAP_FIELD_VERSION]
             self.compile_caps[TNS_CCAP_FIELD_VERSION] = self.ttc_field_version
         if self.ttc_field_version < TNS_CCAP_FIELD_VERSION_23_4 \
-                and self.supports_end_of_request:
-            self.compile_caps[TNS_CCAP_TTC4] ^= TNS_CCAP_END_OF_REQUEST
-            self.supports_end_of_request = False
+                and self.supports_end_of_response:
+            self.compile_caps[TNS_CCAP_TTC4] ^= TNS_CCAP_END_OF_RESPONSE
+            self.supports_end_of_response = False
 
     @cython.boundscheck(False)
     cdef void _adjust_for_server_runtime_caps(self, bytearray server_caps):

src/oracledb/impl/thin/constants.pxi

@@ -47,7 +47,7 @@ cdef enum:
 
 # data flags
 cdef enum:
-    TNS_DATA_FLAGS_END_OF_REQUEST = 0x2000
+    TNS_DATA_FLAGS_END_OF_RESPONSE = 0x2000
     TNS_DATA_FLAGS_EOF = 0x0040
 
 # marker types
@@ -412,7 +412,7 @@ cdef enum:
     TNS_MSG_TYPE_ONEWAY_FN = 26
     TNS_MSG_TYPE_IMPLICIT_RESULTSET = 27
     TNS_MSG_TYPE_RENEGOTIATE = 28
-    TNS_MSG_TYPE_END_OF_REQUEST = 29
+    TNS_MSG_TYPE_END_OF_RESPONSE = 29
     TNS_MSG_TYPE_FAST_AUTH = 34
 
 # parameter keyword numbers
@@ -714,7 +714,7 @@ cdef enum:
     TNS_CCAP_DRCP = 0x10
     TNS_CCAP_ZLNP = 0x04
     TNS_CCAP_INBAND_NOTIFICATION = 0x04
-    TNS_CCAP_END_OF_REQUEST = 0x20
+    TNS_CCAP_END_OF_RESPONSE = 0x20
     TNS_CCAP_CLIENT_FN_MAX = 12
     TNS_CCAP_VECTOR_SUPPORT = 0x08
 
@@ -749,7 +749,7 @@ cdef enum:
 # accept flags
 cdef enum:
     TNS_ACCEPT_FLAG_FAST_AUTH = 0x10000000
-    TNS_ACCEPT_FLAG_HAS_END_OF_REQUEST = 0x02000000
+    TNS_ACCEPT_FLAG_HAS_END_OF_RESPONSE = 0x02000000
 
 # transaction switching op codes
 cdef enum:

src/oracledb/impl/thin/messages.pyx

@@ -56,6 +56,21 @@ cdef class Message:
         bint retry
         object warning
 
+    cdef int _check_and_raise_exception(self) except -1:
+        """
+        Checks to see if an error has occurred. If one has, an error object is
+        created and then the appropriate exception raised. Note that if a "dead
+        connection" error is detected, the connection is forced closed
+        immediately.
+        """
+        if self.error_occurred:
+            error = errors._Error(self.error_info.message,
+                                  code=self.error_info.num,
+                                  offset=self.error_info.pos)
+            if error.is_session_dead:
+                self.conn_impl._protocol._force_close()
+            raise error.exc_type(error)
+
     cdef int _initialize(self, BaseThinConnImpl conn_impl) except -1:
         """
         Initializes the message to contain the connection and a place to store
@@ -172,7 +187,7 @@ cdef class Message:
 
         # an error message marks the end of a response if no explicit end of
         # response is available
-        if not buf._caps.supports_end_of_request:
+        if not buf._caps.supports_end_of_response:
             self.end_of_response = True
 
     cdef int _process_message(self, ReadBuffer buf,
@@ -184,13 +199,13 @@ cdef class Message:
         elif message_type == TNS_MSG_TYPE_STATUS:
             buf.read_ub4(&self.call_status)
             buf.read_ub2(&self.end_to_end_seq_num)
-            if not buf._caps.supports_end_of_request:
+            if not buf._caps.supports_end_of_response:
                 self.end_of_response = True
         elif message_type == TNS_MSG_TYPE_PARAMETER:
             self._process_return_parameters(buf)
         elif message_type == TNS_MSG_TYPE_SERVER_SIDE_PIGGYBACK:
             self._process_server_side_piggyback(buf)
-        elif message_type == TNS_MSG_TYPE_END_OF_REQUEST:
+        elif message_type == TNS_MSG_TYPE_END_OF_RESPONSE:
             self.end_of_response = True
         else:
             errors._raise_err(errors.ERR_MESSAGE_TYPE_UNKNOWN,
@@ -1936,7 +1951,7 @@ cdef class DataTypesMessage(Message):
             buf.read_uint16(&conv_data_type)
             if conv_data_type != 0:
                 buf.skip_raw_bytes(4)
-        if not buf._caps.supports_end_of_request:
+        if not buf._caps.supports_end_of_response:
             self.end_of_response = True
 
     cdef int _write_message(self, WriteBuffer buf) except -1:
@@ -2378,7 +2393,7 @@ cdef class ProtocolMessage(Message):
                               uint8_t message_type) except -1:
         if message_type == TNS_MSG_TYPE_PROTOCOL:
             self._process_protocol_info(buf)
-            if not buf._caps.supports_end_of_request:
+            if not buf._caps.supports_end_of_response:
                 self.end_of_response = True
         else:
             Message._process_message(self, buf, message_type)

src/oracledb/impl/thin/packet.pyx

@@ -55,7 +55,7 @@ cdef class Packet:
         uint8_t packet_flags
         bytes buf
 
-    cdef inline bint has_end_of_request(self):
+    cdef inline bint has_end_of_response(self):
         """
         Returns a boolean indicating if the end of request byte is found at the
         end of the packet.
@@ -66,10 +66,10 @@ cdef class Packet:
         ptr = cpython.PyBytes_AS_STRING(self.buf)
         flags = unpack_uint16(<const char_type*> &ptr[PACKET_HEADER_SIZE],
                               BYTE_ORDER_MSB)
-        if flags & TNS_DATA_FLAGS_END_OF_REQUEST:
+        if flags & TNS_DATA_FLAGS_END_OF_RESPONSE:
             return True
         if self.packet_size == PACKET_HEADER_SIZE + 3 \
-                and ptr[PACKET_HEADER_SIZE + 2] == TNS_MSG_TYPE_END_OF_REQUEST:
+                and ptr[PACKET_HEADER_SIZE + 2] == TNS_MSG_TYPE_END_OF_RESPONSE:
             return True
         return False
 
@@ -346,7 +346,7 @@ cdef class ReadBuffer(Buffer):
             notify_waiter[0] = \
                     packet.packet_type != TNS_PACKET_TYPE_DATA \
                     or not self._check_request_boundary \
-                    or packet.has_end_of_request()
+                    or packet.has_end_of_response()
 
     cdef int _read_raw_bytes_and_length(self, const char_type **ptr,
                                         ssize_t *num_bytes) except -1:
@@ -710,6 +710,7 @@ cdef class WriteBuffer(Buffer):
     cdef:
         uint8_t _packet_type
         uint8_t _packet_flags
+        uint16_t _data_flags
         Capabilities _caps
         Transport _transport
         uint8_t _seq_num
@@ -735,12 +736,14 @@ cdef class WriteBuffer(Buffer):
         self.write_uint8(self._packet_type)
         self.write_uint8(self._packet_flags)
         self.write_uint16(0)
+        if self._packet_type == TNS_PACKET_TYPE_DATA:
+            self.write_uint16(self._data_flags)
         self._pos = size
         self._transport.write_packet(self)
         self._packet_sent = True
         self._pos = PACKET_HEADER_SIZE
-        if not final_packet:
-            self.write_uint16(0)            # add data flags for next packet
+        if not final_packet and self._packet_type == TNS_PACKET_TYPE_DATA:
+            self._pos += sizeof(uint16_t)   # allow space for data flags
 
     cdef int _size_for_sdu(self) except -1:
         """
@@ -786,7 +789,8 @@ cdef class WriteBuffer(Buffer):
         self._packet_flags = packet_flags
         self._pos = PACKET_HEADER_SIZE
         if packet_type == TNS_PACKET_TYPE_DATA:
-            self.write_uint16(data_flags)
+            self._data_flags = data_flags
+            self._pos += sizeof(uint16_t)
 
     cdef object write_dbobject(self, ThinDbObjectImpl obj_impl):
         """

src/oracledb/impl/thin/protocol.pyx

@@ -425,15 +425,7 @@ cdef class Protocol(BaseProtocol):
             if message.retry:
                 message.error_occurred = False
                 return self._process_message(message)
-            error = errors._Error(message.error_info.message,
-                                  code=message.error_info.num,
-                                  offset=message.error_info.pos)
-
-            # if a connection has received dead connection error then it is no
-            # longer usable
-            if error.is_session_dead:
-                self._force_close()
-            raise error.exc_type(error)
+            message._check_and_raise_exception()
 
     cdef int _process_single_message(self, Message message) except -1:
         """
@@ -452,7 +444,7 @@ cdef class Protocol(BaseProtocol):
             uint16_t refuse_message_len
             const char_type* ptr
         buf._check_request_boundary = \
-                check_request_boundary and self._caps.supports_end_of_request
+                check_request_boundary and self._caps.supports_end_of_response
         buf.wait_for_packets_sync()
         buf._check_request_boundary = False
         if buf._current_packet.packet_type == TNS_PACKET_TYPE_MARKER:
@@ -779,15 +771,7 @@ cdef class BaseAsyncProtocol(BaseProtocol):
             if message.retry:
                 message.error_occurred = False
                 return await self._process_message(message)
-            error = errors._Error(message.error_info.message,
-                                  code=message.error_info.num,
-                                  offset=message.error_info.pos)
-
-            # if a connection has received dead connection error then it is no
-            # longer usable
-            if error.is_session_dead:
-                self._force_close()
-            raise error.exc_type(error)
+            message._check_and_raise_exception()
 
     async def _process_message_helper(self, Message message):
         """
@@ -830,7 +814,7 @@ cdef class BaseAsyncProtocol(BaseProtocol):
             uint16_t refuse_message_len
             const char_type* ptr
         buf._check_request_boundary = \
-                check_request_boundary and self._caps.supports_end_of_request
+                check_request_boundary and self._caps.supports_end_of_response
         await buf.wait_for_packets_async()
         buf._check_request_boundary = False
         if buf._current_packet.packet_type == TNS_PACKET_TYPE_MARKER: