holado 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

holado_python/standard_library/socket/message_socket.py

@@ -17,6 +17,9 @@ import selectors
 from holado_python.standard_library.socket.non_blocking_socket import TCPNonBlockingSocketClient
 import copy
 import threading
+from holado_python.standard_library.socket.blocking_socket import TCPBlockingSocketClient
+from holado_core.common.tools.tools import Tools
+from holado.common.handlers.undefined import undefined_argument
 
 logger = logging.getLogger(__name__)
 
@@ -26,14 +29,14 @@ logger = logging.getLogger(__name__)
 ##########################################################################
 
 
-class MessageTCPSocketClient(TCPNonBlockingSocketClient):
+class MessageSocketClient(object):
     """
-    Base class for blocking socket client.
+    Base class for message socket client.
     """
     __metaclass__ = abc.ABCMeta
     
-    def __init__(self, separator=b'\n', *, name=None, create_ipv4_socket_kwargs=None):
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
+    def __init__(self, separator=b'\n'):
+        super().__init__()
         
         self.__separator = separator
         self.__messages_lock = threading.Lock()
@@ -41,32 +44,36 @@ class MessageTCPSocketClient(TCPNonBlockingSocketClient):
 
     @property
     def messages(self):
-        return self.__messages
+        with self.__messages_lock:
+            return copy.copy(self.__messages)
     
     @property
     def nb_messages(self):
-        return len(self.__messages)
+        with self.__messages_lock:
+            return len(self.__messages)
     
-    def _service_connection(self, key, mask, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
-        # Read from socket & write in socket
-        super()._service_connection(key, mask, read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+    def _extract_messages_from_data(self, data):
+        while True:
+            ind = data.in_bytes.find(self.__separator)
+            if ind >=0:
+                msg = data.in_bytes[:ind]
+                self._add_message(msg)
+                data.in_bytes = data.in_bytes[ind+len(self.__separator):]
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"[{self.name}] New message (total: {self.nb_messages}): {msg}")
+                elif Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"[{self.name}] New message (total: {self.nb_messages})")
+            else:
+                break
         
-        # Extract messages from received data
-        if mask & selectors.EVENT_READ:
-            with self._data_lock:
-                while True:
-                    ind = self._data.in_bytes.find(self.__separator)
-                    if ind >=0:
-                        msg = self._data.in_bytes[:ind]
-                        self.__add_message(msg)
-                        self._data.in_bytes = self._data.in_bytes[ind+len(self.__separator):]
-                    else:
-                        break
-    
-    def __add_message(self, msg):
+    def _add_message(self, msg):
         with self.__messages_lock:
             self.__messages.append(msg)
     
+    def reset_received_messages(self):
+        with self.__messages_lock:
+            self.__messages.clear()
+        
     def read_message(self):
         res = None
         with self.__messages_lock:
@@ -85,6 +92,46 @@ class MessageTCPSocketClient(TCPNonBlockingSocketClient):
 
 
 
+class MessageTCPBlockingSocketClient(TCPBlockingSocketClient, MessageSocketClient):
+    """
+    Message socket client with TCP blocking socket.
+    """
+    def __init__(self, separator=b'\n', *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument):
+        MessageSocketClient.__init__(self, separator)
+        TCPBlockingSocketClient.__init__(self, name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
+
+    def _process_recv_send(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        # Read from socket & write in socket
+        super()._process_recv_send(read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+        
+        # Extract messages from received data
+        if self.is_run_with_recv:
+            with self._data_lock:
+                self._extract_messages_from_data(self._data)
+
+
+
+class MessageTCPNonBlockingSocketClient(TCPNonBlockingSocketClient, MessageSocketClient):
+    """
+    Message socket client with TCP non-blocking socket.
+    """
+    def __init__(self, separator=b'\n', *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument):
+        MessageSocketClient.__init__(self, separator)
+        TCPNonBlockingSocketClient.__init__(self, name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
+
+    def _service_connection(self, key, mask, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        # Read from socket & write in socket
+        res = super()._service_connection(key, mask, read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+        
+        # Extract messages from received data
+        if mask & selectors.EVENT_READ:
+            with self._data_lock:
+                self._extract_messages_from_data(self._data)
+        
+        return res
+
+
+
 
 
 

holado_python/standard_library/socket/non_blocking_socket.py

@@ -17,8 +17,9 @@ from holado_python.standard_library.socket.socket import SocketClient
 import abc
 from holado_multitask.multithreading.loopfunctionthreaded import LoopFunctionThreaded
 import selectors
-import types
-import threading
+from holado.common.handlers.undefined import undefined_argument
+import time
+import ssl
 
 logger = logging.getLogger(__name__)
 
@@ -34,111 +35,108 @@ class NonBlockingSocketClient(SocketClient):
     """
     __metaclass__ = abc.ABCMeta
     
-    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None):
+    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument, do_run_with_recv=True, do_run_with_send=True):
         self.__selector = selectors.DefaultSelector()
         
-        self.__data_lock = threading.Lock()
-        self.__data = types.SimpleNamespace(
-            in_bytes=b"",
-            out_bytes=b"",
-        )
-        
-        # Note: __selector and __data must be defined before, since Socket.__init__ can execute create_ipv4_socket
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
-        
-        self.__start_thread = None
+        # Note: __selector must be defined before, since Socket.__init__ can execute create_ipv4_socket
+        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay, do_run_with_recv=do_run_with_recv, do_run_with_send=do_run_with_send)
 
     def _delete_object(self):
-        self.stop()
         if self.internal_socket:
+            # Note: stop must be done before unregistering selector
+            self.stop()
             self.__selector.unregister(self.internal_socket)
         
         super()._delete_object()
     
     def _register_socket(self, sock):
         events = selectors.EVENT_READ | selectors.EVENT_WRITE
-        self.__selector.register(sock, events, data=self.__data)
-    
-    @property
-    def _data_lock(self):
-        return self.__data_lock
-    
-    @property
-    def _data(self):
-        return self.__data
+        self.__selector.register(sock, events, data=self._data)
     
     def start(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
         """Start client event loop.
         """
         kwargs = {'read_bufsize':read_bufsize, 'read_kwargs':read_kwargs, 'write_kwargs':write_kwargs}
-        self.__start_thread = LoopFunctionThreaded(self._wait_and_process_events, kwargs=kwargs, register_thread=True, delay_before_run_sec=None)
-        self.__start_thread.start()
-    
-    def stop(self):
-        if self.__start_thread is not None:
-            self.__start_thread.interrupt()
-            self.__start_thread.join()
-            self.__start_thread = None
+        thread = LoopFunctionThreaded(self._wait_and_process_events, kwargs=kwargs, register_thread=True, delay_before_run_sec=None)
+        self._start_thread(thread)
     
     def _wait_and_process_events(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        has_activity = False
         events = self.__selector.select(timeout=None)
         for key, mask in events:
-            self._service_connection(key, mask, read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+            has_activity |= self._service_connection(key, mask, read_bufsize=read_bufsize, read_kwargs=read_kwargs, write_kwargs=write_kwargs)
+        
+        # Wait before next loop if no data was exchanged
+        if not has_activity and self._idle_sleep_delay is not None:
+            time.sleep(self._idle_sleep_delay)
 
     def _service_connection(self, key, mask, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        has_activity = False
         read_kwargs = read_kwargs if read_kwargs is not None else {}
         write_kwargs = write_kwargs if write_kwargs is not None else {}
         
         sock = key.fileobj
         data = key.data
-        if mask & selectors.EVENT_READ:
-            recv_data = sock.recv(read_bufsize, **read_kwargs)
+        if self.is_run_with_recv and mask & selectors.EVENT_READ:
+            if self.is_with_ssl:
+                # ssl doesn't suppôrt flags != 0
+                flags = 0
+            else:
+                flags = read_kwargs.get('flags', 0)
+            try:
+                recv_data = sock.recv(read_bufsize, flags)
+            except ssl.SSLWantReadError:
+                recv_data = None
             if recv_data:
-                with self.__data_lock:      # data is self.__data
+                has_activity = True
+                with self._data_lock:      # data is self._data
                     data.in_bytes += recv_data
-        if mask & selectors.EVENT_WRITE:
-            with self.__data_lock:      # data is self.__data
+                    if logger.isEnabledFor(logging.DEBUG):
+                        logger.debug(f"[{self.name}] Received [{recv_data}] (type: {type(recv_data)} ; total: {len(data.in_bytes)})")
+        
+        if self.is_run_with_send and mask & selectors.EVENT_WRITE:
+            with self._data_lock:      # data is self._data
                 if data.out_bytes:
-                    sent = sock.send(data.out_bytes)
-                    data.out_bytes = data.out_bytes[sent:]
-    
-    @property
-    def received_data_size(self):
-        with self.__data_lock:
-            res = len(self.__data.in_bytes)
-        return res
-    
-    def read(self, bufsize=1024):
-        with self.__data_lock:
-            if self.__data.in_bytes:
-                res = self.__data.in_bytes[:bufsize]
-                self.__data.in_bytes = self.__data.in_bytes[bufsize:]
-            else:
-                res = b''
-        return res
+                    has_activity = True
+                    try:
+                        sent = sock.send(data.out_bytes)
+                    except ssl.SSLWantWriteError:
+                        sent = 0
+                    if sent > 0:
+                        data.out_bytes = data.out_bytes[sent:]
+                        if logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(f"[{self.name}] Sent {sent} data (remaining to send: {len(data.out_bytes)})")
+        
+        return has_activity
     
-    def write(self, data_bytes):
-        with self.__data_lock:
-            self.__data.out_bytes += data_bytes
-
 
 class TCPNonBlockingSocketClient(NonBlockingSocketClient):
     """
     TCP socket client.
     """
     
-    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None):
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
+    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument, do_run_with_recv=True, do_run_with_send=True):
+        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay, do_run_with_recv=do_run_with_recv, do_run_with_send=do_run_with_send)
     
     def create_ipv4_socket(self, host, port, **kwargs):
-        ssl_context, kwargs = self._new_ssl_context_if_required(**kwargs)
-        
-        sock = socket.create_connection((host, port), **kwargs)
-        sock.setblocking(False)
+        socket_kwargs = self._new_ssl_context_if_required(**kwargs)
         
-        if ssl_context:
-            sock = ssl_context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=False)
-        self._set_internal_socket(sock)
+        if self.is_with_ssl:
+            # sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            # sock = Socket.create_connection((host, port), do_connect=False, **socket_kwargs)
+            sock = socket.create_connection((host, port), **socket_kwargs)
+            sock.setblocking(False)
+            
+            wrap_socket_kwargs = self._ssl_wrap_socket_kwargs
+            do_handshake_on_connect = wrap_socket_kwargs.pop('do_handshake_on_connect', False)
+            sock = self._ssl_context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=do_handshake_on_connect, **wrap_socket_kwargs)
+            self._set_internal_socket(sock, is_ssl_handshake_done_on_connect=do_handshake_on_connect)
+            
+            # sock.connect((host, port))
+        else:
+            sock = socket.create_connection((host, port), **socket_kwargs)
+            sock.setblocking(False)
+            self._set_internal_socket(sock)
         
         # Register socket
         self._register_socket(sock)