holado 0.2.8__py3-none-any.whl → 0.4.0__py3-none-any.whl

holado_grpc/tests/behave/steps/api/grpc_client_steps.py

@@ -15,7 +15,7 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_grpc.api.rpc.grpc_client import GRpcClient
 import logging
 from holado_test.behave.scenario.behave_step_tools import BehaveStepTools

holado_grpc/tests/behave/steps/private/api/grpc_steps.py

@@ -14,7 +14,7 @@
 
 
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import os.path
 from holado_core.tools.abstracts.blocking_command_service import BlockingCommandService
 import logging

holado_json/tests/behave/steps/ipc/json_steps.py

@@ -15,7 +15,7 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_json.ipc.json import create_name_value_table_from_json,\
     create_table_with_header_from_json
 import logging

holado_keycloak/tests/behave/steps/tools/keycloak_client_steps.py

@@ -14,7 +14,7 @@
 
 
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_keycloak.tools.keycloak.keycloak_client import KeycloakClient
 import logging
 from holado_core.common.exceptions.functional_exception import FunctionalException

holado_multitask/tests/behave/steps/multiprocessing_steps.py

@@ -15,7 +15,7 @@
 
 from holado.common.context.session_context import SessionContext
 from holado_core.common.exceptions.functional_exception import FunctionalException
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_core.common.block.function import Function
 from holado_test.scenario.step_tools import StepTools
 import logging

holado_multitask/tests/behave/steps/multithreading_steps.py

@@ -21,7 +21,7 @@ from holado_test.scenario.step_tools import StepTools
 import logging
 from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado_scripting.common.tools.evaluate_parameters import EvaluateParameters
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_multitask.multithreading.periodicfunctionthreaded import PeriodicFunctionThreaded
 from holado.common.handlers.undefined import undefined_argument
 

holado_protobuf/ipc/protobuf/types/google/protobuf.py

@@ -41,7 +41,7 @@ class Duration(Type):
         elif isinstance(value, timedelta):
             obj.FromTimedelta(value)
         elif isinstance(value, int) or isinstance(value, float):
-            nanos = value * 1e9
+            nanos = round(value * 1e9)
             obj.FromNanoseconds(nanos)
         elif isinstance(value, str):
             if re.match(r"-?\d+(?:.\d+)?s", value): 

holado_protobuf/tests/behave/steps/ipc/protobuf_steps.py

@@ -15,7 +15,7 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_protobuf.ipc.protobuf.protobuf_messages import ProtobufMessages
 import logging

holado_python/common/tools/datetime.py

@@ -26,6 +26,7 @@ from datetime import timedelta
 from dateutil.relativedelta import relativedelta
 import math
 from decimal import Decimal
+from holado_python.standard_library.typing import Typing
 
 logger = logging.getLogger(__name__)
 
@@ -35,6 +36,7 @@ EPOCH_JULIAN_CNES = datetime.datetime(year=1950, month=1, day=1, tzinfo=datetime
 EPOCH_JULIAN_NASA = datetime.datetime(year=1968, month=5, day=24, tzinfo=datetime.timezone.utc)
 
 FORMAT_DATETIME_ISO = '%Y-%m-%dT%H:%M:%S.%fZ'
+FORMAT_DATETIME_ISO_SECONDS = '%Y-%m-%dT%H:%M:%SZ'
 FORMAT_DATETIME_HUMAN_SECOND = '%Y-%m-%d %H:%M:%S'
 
 
@@ -159,12 +161,24 @@ class DateTime(object):
     
     ### Conversions to/from timestamp
     
+    @classmethod
+    def _get_epoch_datetime(cls, epoch):
+        res = None
+        if epoch is not None:
+            if isinstance(epoch, str):
+                if epoch in ['EPOCH_1970', 'EPOCH_JULIAN_CNES', 'EPOCH_JULIAN_NASA']:
+                    res = eval(epoch)
+                else:
+                    res = DateTime.str_2_datetime(epoch)
+            elif isinstance(epoch, datetime.datetime):
+                res = epoch
+            else:
+                raise TechnicalException(f"Epoch can be a datetime, a str containing a datetime, a str containing an EPOCH name, or None")
+        return res
+        
     @classmethod
     def datetime_to_timestamp(cls, dt, epoch=None):
-        if epoch is not None and isinstance(epoch, str):
-            epoch = DateTime.str_2_datetime(epoch)
-        elif epoch is not None and not isinstance(epoch, datetime.datetime):
-            raise TechnicalException(f"Parameter 'epoch' should be a datetime or None")
+        epoch = cls._get_epoch_datetime(epoch)
         
         if epoch is None:
             return dt.timestamp()
@@ -176,12 +190,17 @@ class DateTime(object):
         """
         Convert timestamp to UTC datetime
         """
-        if epoch is not None and isinstance(epoch, str):
-            epoch = DateTime.str_2_datetime(epoch)
-        elif epoch is not None and not isinstance(epoch, datetime.datetime):
-            raise TechnicalException(f"Parameter 'epoch' should be a datetime or None")
+        epoch = cls._get_epoch_datetime(epoch)
+        
+        if isinstance(ts, str):
+            if Converter.is_float(ts) or Converter.is_integer(ts):
+                ts = Converter.to_float(ts)
+            else:
+                raise FunctionalException(f"Timestamp is a string that doesn't contain a float|int (obtained timestamp: '{ts}')")
+        if not isinstance(ts, float) and not isinstance(ts, int):
+            raise TechnicalException(f"Timestamp must be a float|int or a string containing a float|int (obtained type: {Typing.get_object_class_fullname(ts)})")
         
-        res = datetime.datetime.utcfromtimestamp(ts)
+        res = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc)
         if epoch is not None:
             res = epoch + (res - EPOCH_1970)
         return res
@@ -212,9 +231,9 @@ class DateTime(object):
         """
         Convert (seconds, nanos) to timestamp.
         By default, it returns a timestamp as float with nanos rounded to microsecond precision.
-        To keep nanosecond precision, set cast_type=None and round_func=None, it will returns a timestamp as decimal.Decimal.
-        @param cast_func: Type of the returned value (default: float). The type can also be decimal.Decimal, usefull to keep nanosecond precision.
-        @param round_func: defines the rounding method applied to microseconds (default: round ; possible methods: round, math.ceil, math.trunc)
+        To keep nanosecond precision, set cast_func=None and round_func=None, it will returns a timestamp as decimal.Decimal.
+        @param cast_func: Type of the returned value (default: float). If None, no cast is applied, and result is of type decimal.Decimal, usefull to keep nanosecond precision.
+        @param round_func: defines the rounding method applied to microseconds (default: round ; possible methods: round, math.ceil, math.trunc). If None, value is not rounded.
         """
         res_dec = Decimal(seconds) + Decimal(nanos) / Decimal(1e9)
         if round_func is not None:

holado_python/standard_library/socket/blocking_socket.py

@@ -13,7 +13,7 @@
 
 import logging
 import socket
-from holado_python.standard_library.socket.socket import SocketClient, SocketServer
+from holado_python.standard_library.socket.socket import SocketClient, SocketServer, Socket
 import abc
 from holado_multitask.multithreading.loopfunctionthreaded import LoopFunctionThreaded
 import time
@@ -94,10 +94,6 @@ class BlockingSocketClient(SocketClient):
         if not has_activity and self._idle_sleep_delay is not None:
             time.sleep(self._idle_sleep_delay)
     
-    def do_ssl_handshake(self):
-        if self.is_with_ssl:
-            self.internal_socket.do_handshake()
-
 
 class TCPBlockingSocketClient(BlockingSocketClient):
     """
@@ -108,16 +104,22 @@ class TCPBlockingSocketClient(BlockingSocketClient):
         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)
+        socket_kwargs = self._new_ssl_context_if_required(**kwargs)
         
-        if ssl_context:
-            # do_handshake_on_connect = True
-            do_handshake_on_connect = False
-            sock = ssl_context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=do_handshake_on_connect)
-            self._set_internal_socket(sock, is_with_ssl=True, is_ssl_handshake_done_on_connect=do_handshake_on_connect)
+        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), do_connect=True, **socket_kwargs)
+            
+            wrap_socket_kwargs = self._ssl_wrap_socket_kwargs
+            # do_handshake_on_connect = wrap_socket_kwargs.pop('do_handshake_on_connect', True)
+            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)
             self._set_internal_socket(sock)
 
 
@@ -152,21 +154,31 @@ class BlockingSocketServer(SocketServer):
         read_kwargs = read_kwargs if read_kwargs is not None else {}
         write_kwargs = write_kwargs if write_kwargs is not None else {}
         
-        conn, _ = self.accept()
+        conn, from_addr = self.accept()
         if logger.isEnabledFor(logging.DEBUG):
-            logger.debug(f"[{self.name}] New connection: {conn}")
+            logger.debug(f"[{self.name}] New connection: {conn} from {from_addr}")
+        
+        if self.is_with_ssl:
+            wrap_socket_kwargs = self._ssl_wrap_socket_kwargs
+            do_handshake_on_connect = wrap_socket_kwargs.pop('do_handshake_on_connect', False)
+            # do_handshake_on_connect = wrap_socket_kwargs.pop('do_handshake_on_connect', True)
+            ssocket = self._ssl_context.wrap_socket(conn.internal_socket, server_side=True, do_handshake_on_connect=do_handshake_on_connect)
+            conn = Socket.create(name=conn.name, internal_socket=ssocket)
+        
         with conn:
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"[{self.name} - {from_addr}] Start read & write loop")
             while True:
                 data = conn.read(read_bufsize, **read_kwargs)
                 if logger.isEnabledFor(logging.DEBUG):
-                    logger.debug(f"[{self.name}] Received: {data}")
+                    logger.debug(f"[{self.name} - {from_addr}] Received: {data}")
                     
                 if not data:
                     break
                 result = self._process_received_data(data)
                 
                 if logger.isEnabledFor(logging.DEBUG):
-                    logger.debug(f"[{self.name}] Sending: {result}")
+                    logger.debug(f"[{self.name} - {from_addr}] Sending: {result}")
                 conn.write(result, **write_kwargs)
 
 
@@ -180,14 +192,15 @@ class TCPBlockingSocketServer(BlockingSocketServer):
         super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
     
     def create_ipv4_socket(self, host, port, **kwargs):
-        ssl_context, kwargs = self._new_ssl_context_if_required(server_side=True, **kwargs)
+        socket_kwargs = self._new_ssl_context_if_required(server_side=True, **kwargs)
         
-        sock = socket.create_server((host, port), **kwargs)
-        
-        if ssl_context:
-            do_handshake_on_connect = True
-            sock = ssl_context.wrap_socket(sock, server_side=True, do_handshake_on_connect=do_handshake_on_connect)
-            self._set_internal_socket(sock, is_with_ssl=True, is_ssl_handshake_done_on_connect=do_handshake_on_connect)
+        if self.is_with_ssl:
+            # sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            # sock.bind((host, port))
+            # sock.listen()
+            sock = socket.create_server((host, port), **socket_kwargs)
+            self._set_internal_socket(sock)
         else:
+            sock = socket.create_server((host, port), **socket_kwargs)
             self._set_internal_socket(sock)
 

holado_python/standard_library/socket/message_socket.py

@@ -44,11 +44,13 @@ class MessageSocketClient(object):
 
     @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 _extract_messages_from_data(self, data):
         while True:
@@ -68,6 +70,10 @@ class MessageSocketClient(object):
         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:
@@ -115,12 +121,14 @@ class MessageTCPNonBlockingSocketClient(TCPNonBlockingSocketClient, MessageSocke
 
     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)
+        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,10 +17,9 @@ from holado_python.standard_library.socket.socket import SocketClient
 import abc
 from holado_multitask.multithreading.loopfunctionthreaded import LoopFunctionThreaded
 import selectors
-import ssl
-import select
 from holado.common.handlers.undefined import undefined_argument
 import time
+import ssl
 
 logger = logging.getLogger(__name__)
 
@@ -84,8 +83,10 @@ class NonBlockingSocketClient(SocketClient):
                 flags = 0
             else:
                 flags = read_kwargs.get('flags', 0)
-            
-            recv_data = sock.recv(read_bufsize, flags)
+            try:
+                recv_data = sock.recv(read_bufsize, flags)
+            except ssl.SSLWantReadError:
+                recv_data = None
             if recv_data:
                 has_activity = True
                 with self._data_lock:      # data is self._data
@@ -97,7 +98,10 @@ class NonBlockingSocketClient(SocketClient):
             with self._data_lock:      # data is self._data
                 if data.out_bytes:
                     has_activity = True
-                    sent = sock.send(data.out_bytes)
+                    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):
@@ -105,17 +109,6 @@ class NonBlockingSocketClient(SocketClient):
         
         return has_activity
     
-    def do_ssl_handshake(self):
-        if self.is_with_ssl:
-            while True:
-                try:
-                    self.internal_socket.do_handshake()
-                    break
-                except ssl.SSLWantReadError:
-                    select.select([self.internal_socket], [], [])
-                except ssl.SSLWantWriteError:
-                    select.select([], [self.internal_socket], [])
-
 
 class TCPNonBlockingSocketClient(NonBlockingSocketClient):
     """
@@ -126,16 +119,23 @@ class TCPNonBlockingSocketClient(NonBlockingSocketClient):
         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)
+        socket_kwargs = self._new_ssl_context_if_required(**kwargs)
         
-        sock = socket.create_connection((host, port), **kwargs)
-        sock.setblocking(False)
-        
-        if ssl_context:
-            do_handshake_on_connect = False
-            sock = ssl_context.wrap_socket(sock, server_hostname=host, do_handshake_on_connect=do_handshake_on_connect)
-            self._set_internal_socket(sock, is_with_ssl=True, is_ssl_handshake_done_on_connect=do_handshake_on_connect)
+        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

holado_python/standard_library/socket/socket.py

@@ -13,7 +13,7 @@
 
 import logging
 import socket
-from _socket import SHUT_RDWR
+from _socket import SHUT_RDWR, SOCK_STREAM, error
 from holado.common.handlers.object import DeleteableObject
 import abc
 from holado_core.common.exceptions.functional_exception import FunctionalException
@@ -23,6 +23,10 @@ import threading
 import types
 from abc import abstractmethod
 from holado.common.handlers.undefined import undefined_argument
+import copy
+from holado_python.standard_library.typing import Typing
+import ssl
+import select
 
 logger = logging.getLogger(__name__)
 
@@ -35,6 +39,62 @@ class Socket(DeleteableObject):
     """
     __metaclass__ = abc.ABCMeta
     
+    @classmethod
+    def create(cls, name, internal_socket):
+        res = cls.__new__(cls, name=name)
+        res.__init__(name=name)
+        res._set_internal_socket(internal_socket)
+        return res
+    
+    @classmethod
+    def create_connection(cls, address, timeout=undefined_argument,
+                          source_address=None, do_connect=True):
+        """Connect to *address* and return the socket object.
+    
+        Convenience function.  Connect to *address* (a 2-tuple ``(host,
+        port)``) and return the socket object.  Passing the optional
+        *timeout* parameter will set the timeout on the socket instance
+        before attempting to connect.  If no *timeout* is supplied, the
+        global default timeout setting returned by :func:`getdefaulttimeout`
+        is used.  If *source_address* is set it must be a tuple of (host, port)
+        for the socket to bind as a source address before making the connection.
+        A host of '' or port 0 tells the OS to use the default.
+        
+        Note: Implementation is a copy of socket.create_connection, but allowing to not connect.
+              If do_connect==True, implementation is identical to socket.create_connection.
+        """
+    
+        host, port = address
+        err = None
+        for res in socket.getaddrinfo(host, port, 0, SOCK_STREAM):
+            af, socktype, proto, canonname, sa = res  # @UnusedVariable
+            sock = None
+            try:
+                sock = socket.socket(af, socktype, proto)
+                if timeout is not undefined_argument:
+                    sock.settimeout(timeout)
+                if source_address:
+                    sock.bind(source_address)
+                if do_connect:
+                    sock.connect(sa)
+                # Break explicitly a reference cycle
+                err = None
+                return sock
+    
+            except error as _:
+                err = _
+                if sock is not None:
+                    sock.close()
+    
+        if err is not None:
+            try:
+                raise err
+            finally:
+                # Break explicitly a reference cycle
+                err = None
+        else:
+            raise error("getaddrinfo returns an empty list")
+    
     def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument):
         """Socket constructor
         @param name: Socket name
@@ -44,7 +104,7 @@ class Socket(DeleteableObject):
         if name is None and create_ipv4_socket_kwargs is not None:
             if not set(create_ipv4_socket_kwargs.keys()).issuperset({'host', 'port'}):
                 raise FunctionalException(f"Parameters 'host' and 'port' must be defined")
-            name = f"{create_ipv4_socket_kwargs['host']}:{create_ipv4_socket_kwargs['port']}"
+            name = f"{Typing.get_object_class_name(self)}({create_ipv4_socket_kwargs['host']}:{create_ipv4_socket_kwargs['port']})"
         
         super().__init__(name)
         self.__socket = None
@@ -53,7 +113,8 @@ class Socket(DeleteableObject):
         self.__idle_sleep_delay = idle_sleep_delay if idle_sleep_delay is not undefined_argument else 0.01
         
         # SSL management
-        self.__is_with_ssl = False
+        self.__ssl_kwargs_tuple = None
+        self.__ssl_context = None
         self.__is_ssl_handshake_done = False
         
         if create_ipv4_socket_kwargs is not None:
@@ -78,15 +139,30 @@ class Socket(DeleteableObject):
     
     @property
     def is_with_ssl(self):
-        return self.__is_with_ssl
+        return self.__ssl_context is not None
+    
+    @property
+    def _ssl_kwargs(self):
+        return copy.copy(self.__ssl_kwargs_tuple[0]) if self.__ssl_kwargs_tuple and self.__ssl_kwargs_tuple[0] is not None else None
+    
+    @property
+    def _ssl_context_kwargs(self):
+        return copy.copy(self.__ssl_kwargs_tuple[1]) if self.__ssl_kwargs_tuple and self.__ssl_kwargs_tuple[1] is not None else None
+    
+    @property
+    def _ssl_wrap_socket_kwargs(self):
+        return copy.copy(self.__ssl_kwargs_tuple[2]) if self.__ssl_kwargs_tuple and self.__ssl_kwargs_tuple[2] is not None else None
+    
+    @property
+    def _ssl_context(self):
+        return self.__ssl_context
     
     @property
     def _idle_sleep_delay(self):
         return self.__idle_sleep_delay
     
-    def _set_internal_socket(self, socket, is_with_ssl=False, is_ssl_handshake_done_on_connect=True):
+    def _set_internal_socket(self, socket, is_ssl_handshake_done_on_connect=True):
         self.__socket = socket
-        self.__is_with_ssl = is_with_ssl
         self.__is_ssl_handshake_done = is_ssl_handshake_done_on_connect
     
     @abc.abstractmethod
@@ -98,7 +174,9 @@ class Socket(DeleteableObject):
             try:
                 self.__socket.shutdown(SHUT_RDWR)
             except OSError as exc:
-                if 'Errno 107' in str(exc):
+                if 'Errno 9' in str(exc):
+                    logger.info(f"Got following error on socket shutdown (known to appear when connection is not open correctly or already closed): {exc}")
+                elif 'Errno 107' in str(exc):
                     logger.info(f"Got following error on socket shutdown (known to appear sometimes during shutdown): {exc}")
                 else:
                     raise exc
@@ -149,19 +227,45 @@ class Socket(DeleteableObject):
                 logger.debug(f"[{self.name}] Sent {res}/{len(data_bytes)} bytes of [{data_bytes}] (type: {type(data_bytes)})")
             return res
     
-    def _new_ssl_context_if_required(self, server_side=False, **socket_kwargs):
-        """Return a SSLContext if required, and the remaining socket kwargs.
+    def _extract_ssl_kwargs(self, socket_kwargs):
+        """Pop from socket kwargs: global ssl kwargs, SSLContext kwargs, and wrap_socket kwargs.
         """
-        res = None
+        ssl_kwargs, context_kwargs, wrap_socket_kwargs = None, {}, {}
         if Tools.has_sub_kwargs(socket_kwargs, 'ssl.'):
             ssl_kwargs = Tools.pop_sub_kwargs(socket_kwargs, 'ssl.')
-            res = SslManager.new_ssl_context(server_side=server_side, flat_kwargs=ssl_kwargs)
-        return res, socket_kwargs
+            if Tools.has_sub_kwargs(ssl_kwargs, 'context.'):
+                context_kwargs = Tools.pop_sub_kwargs(ssl_kwargs, 'context.')
+            if Tools.has_sub_kwargs(ssl_kwargs, 'wrap_socket.'):
+                wrap_socket_kwargs = Tools.pop_sub_kwargs(ssl_kwargs, 'wrap_socket.')
+        self.__ssl_kwargs_tuple = (ssl_kwargs, context_kwargs, wrap_socket_kwargs)
+        return socket_kwargs
+    
+    def _new_ssl_context_if_required(self, server_side=False, **kwargs):
+        """Return the remaining socket kwargs after ssl kwargs extraction.
+        """
+        res = self._extract_ssl_kwargs(kwargs)
+        
+        if self._ssl_kwargs is not None:
+            self.__ssl_context = SslManager.new_ssl_context(server_side=server_side, ssl_kwargs=self._ssl_kwargs, context_kwargs=self._ssl_context_kwargs)
+            
+        return res
     
     def do_ssl_handshake(self):
-        # Handshake management is performed differently with blocking or non-blocking connection
-        # See BlockingSocketClient and NonBlockingSocketClient for implementation
-        raise NotImplementedError()
+        if self.is_with_ssl:
+            if self.internal_socket.getblocking():
+                self.internal_socket.do_handshake()
+                # self.internal_socket.do_handshake(block=True)
+            else:
+                while True:
+                    try:
+                        self.internal_socket.do_handshake()
+                        break
+                    except ssl.SSLWantReadError:
+                        select.select([self.internal_socket], [], [])
+                    except ssl.SSLWantWriteError:
+                        select.select([], [self.internal_socket], [])
+
+
     
     def ensure_ssl_handshake_is_done(self):
         if self.is_with_ssl and not self.__is_ssl_handshake_done:
@@ -186,8 +290,8 @@ class SocketClient(Socket):
         # Data used in start processing
         self.__data_lock = threading.Lock()
         self.__data = types.SimpleNamespace(
-            in_bytes=b"",
-            out_bytes=b"",
+            in_bytes = b'',
+            out_bytes = b'',
         )
         self.__with_recv = do_run_with_recv
         self.__with_send = do_run_with_send
@@ -222,12 +326,22 @@ class SocketClient(Socket):
         # Start thread
         super()._start_thread(thread)
     
+    @property
+    def received_data(self):
+        with self.__data_lock:
+            res = copy.copy(self.__data.in_bytes)
+        return res
+    
     @property
     def received_data_size(self):
         with self.__data_lock:
             res = len(self.__data.in_bytes)
         return res
     
+    def reset_received_data(self):
+        with self.__data_lock:
+            self.__data.in_bytes = b''
+    
     def read(self, bufsize=1024, **kwargs):
         if self.is_started and self.is_run_with_recv:
             with self.__data_lock:
@@ -263,8 +377,7 @@ class SocketServer(Socket):
     
     def accept(self):
         conn, addr = self.internal_socket.accept()
-        res = Socket(name=f"[{self.name}] Connection with {addr}")
-        res._set_internal_socket(conn)
+        res = Socket.create(name=f"[{self.name}] Connection with {addr}", internal_socket=conn)
         return res, addr
     
     @abc.abstractmethod

holado_python/standard_library/ssl/resources/certificates/NOTES.txt

@@ -1,4 +1,4 @@
-localhost.ct and localhost.key were generated with command:
+localhost.crt and localhost.key were generated with command:
     openssl req -x509 -out localhost.crt -keyout localhost.key \
       -newkey rsa:2048 -nodes -sha256 \
       -subj '/CN=localhost' -extensions EXT -config <( \