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

holado_db/tools/db/query/pypika/pypika_query_builder.py

@@ -13,10 +13,10 @@
 
 import logging
 from holado_core.common.exceptions.technical_exception import TechnicalException
-from holado_db.tools.db.query.base.query_builder import QueryBuilder
+from holado_db.tools.db.query.base.query_builder import QueryBuilder, DBCompareOperator
 from holado_core.common.tools.tools import Tools
-from holado_core.common.tools.comparators.comparator import CompareOperator
 from holado_python.standard_library.typing import Typing
+from pypika.terms import Function
 
 
 logger = logging.getLogger(__name__)
@@ -44,10 +44,11 @@ class PypikaQueryBuilder(QueryBuilder):
     def __init__(self, name, db_client=None):
         super().__init__(name, db_client)
     
-    def select(self, table_name, where_data: dict=None, sql_return="*"):
+    def select(self, table_name, where_data: dict=None, where_compare_data: list=None, sql_return="*"):
         """
         Simple query & values builder of a select by filtering on given where data.
-        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
+        @param where_data: dictionary of (field_name, value) for simple where clauses.
+        @param where_compare_data: list of tuples (field_name, operator, value) for where clauses comparing fields with values.
         """
         table = Table(table_name)
         res = Query.from_(table)
@@ -62,13 +63,15 @@ class PypikaQueryBuilder(QueryBuilder):
         
         if where_data:
             res, values = self.where(res, values, where_data)
-            
+        if where_compare_data:
+            res, values = self.where_compare(res, values, list_of_field_operator_value=where_compare_data)
+        
         return res, values
     
     def insert(self, table_name, data: dict):
         """
         Simple query & values builder of an insert of given data.
-        Parameter 'data' has to be a dictionary with keys equal to table column names.
+        @param data: data to insert as dictionary of (field_name, value).
         """
         col_names = tuple(sorted(data.keys()))
         values = tuple((data[c] for c in col_names))
@@ -79,29 +82,39 @@ class PypikaQueryBuilder(QueryBuilder):
         
         return res, values
     
-    def update(self, table_name, data: dict, where_data: dict):
+    def update(self, table_name, data: dict, where_data: dict=None, where_compare_data: list=None):
         """
         Simple query & values builder of an update of given data.
-        Parameters 'data' and 'where_data' have to be dictionaries with keys equal to table column names.
+        @param data: data to update as dictionary of (field_name, value).
+        @param where_data: dictionary of (field_name, value) for simple where clauses.
+        @param where_compare_data: list of tuples (field_name, operator, value) for where clauses comparing fields with values.
         """
         col_names = tuple(sorted(data.keys()))
-        values = tuple((data[c] for c in col_names))
         sql_placeholder = self.db_client._get_sql_placeholder()
         
         table = Table(table_name)
         res = Query.update(table)
+        values = []
         for c in col_names:
-            res = res.set(c, Parameter(sql_placeholder))
+            val = data[c]
+            if isinstance(val, Function):
+                res = res.set(c, val)
+            else:
+                res = res.set(c, Parameter(sql_placeholder))
+                values.append(val)
             
         if where_data:
             res, values = self.where(res, values, where_data)
+        if where_compare_data:
+            res, values = self.where_compare(res, values, list_of_field_operator_value=where_compare_data)
         
         return res, values
     
-    def delete(self, table_name, where_data: dict=None):
+    def delete(self, table_name, where_data: dict=None, where_compare_data: list=None):
         """
         Simple query & values builder of a delete by filtering on given where data.
-        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
+        @param where_data: dictionary of (field_name, value) for simple where clauses.
+        @param where_compare_data: list of tuples (field_name, operator, value) for where clauses comparing fields with values.
         """
         table = Table(table_name)
         res = Query.from_(table).delete()
@@ -109,18 +122,25 @@ class PypikaQueryBuilder(QueryBuilder):
         
         if where_data:
             res, values = self.where(res, values, where_data)
+        if where_compare_data:
+            res, values = self.where_compare(res, values, list_of_field_operator_value=where_compare_data)
             
         return res, values
     
     def where(self, query, values, where_data: dict):
         col_names = tuple(sorted(where_data.keys()))
-        where_values = tuple((where_data[c] for c in col_names))
         sql_placeholder = self.db_client._get_sql_placeholder()
         
         res = query
         table = self.__get_table(query)
+        where_values = []
         for c in col_names:
-            res = res.where(getattr(table, c) == Parameter(sql_placeholder))
+            val = where_data[c]
+            if val is None:
+                res, where_values = self.where_is_null(res, where_values, c)
+            else:
+                res = res.where(getattr(table, c) == Parameter(sql_placeholder))
+                where_values.append(where_data[c])
         
         if values is not None:
             values = (*values, *where_values)
@@ -128,21 +148,31 @@ class PypikaQueryBuilder(QueryBuilder):
             values = where_values
         return res, values
     
-    def where_compare(self, query, values, field_name, operator:CompareOperator, value):
+    def where_compare(self, query, values, *, field_name=None, operator:DBCompareOperator=None, value=None, list_of_field_operator_value=None):
+        if list_of_field_operator_value is not None:
+            return super().where_compare(query, values, list_of_field_operator_value=list_of_field_operator_value)
+        
+        # Manage operators calling other methods
+        if operator == DBCompareOperator.In:
+            return self.where_in(query, values, field_name, value, not_in=False)
+        elif operator == DBCompareOperator.NotIn:
+            return self.where_in(query, values, field_name, value, not_in=True)
+        
+        # Manage other operators
         table = self.__get_table(query)
         sql_placeholder = self.db_client._get_sql_placeholder()
         
-        if operator == CompareOperator.Different:
+        if operator == DBCompareOperator.Different:
             res = query.where(getattr(table, field_name) != Parameter(sql_placeholder))
-        elif operator == CompareOperator.Equal:
+        elif operator == DBCompareOperator.Equal:
             res = query.where(getattr(table, field_name) == Parameter(sql_placeholder))
-        elif operator == CompareOperator.Inferior:
+        elif operator == DBCompareOperator.Inferior:
             res = query.where(getattr(table, field_name) < Parameter(sql_placeholder))
-        elif operator == CompareOperator.InferiorOrEqual:
+        elif operator == DBCompareOperator.InferiorOrEqual:
             res = query.where(getattr(table, field_name) <= Parameter(sql_placeholder))
-        elif operator == CompareOperator.Superior:
+        elif operator == DBCompareOperator.Superior:
             res = query.where(getattr(table, field_name) > Parameter(sql_placeholder))
-        elif operator == CompareOperator.SuperiorOrEqual:
+        elif operator == DBCompareOperator.SuperiorOrEqual:
             res = query.where(getattr(table, field_name) >= Parameter(sql_placeholder))
         else:
             raise TechnicalException(f"Unmanaged compare operator {operator}")
@@ -161,6 +191,14 @@ class PypikaQueryBuilder(QueryBuilder):
             res = query.where(getattr(table, field_name).isin(field_values))
         return res, values
     
+    def where_is_null(self, query, values, field_name, is_not_null=False):
+        table = self.__get_table(query)
+        if is_not_null:
+            res = query.where(getattr(table, field_name).notnull())
+        else:
+            res = query.where(getattr(table, field_name).isnull())
+        return res, values
+        
     def where_json_value(self, query, values, field_name, key, value, as_text_value=False):
         table = self.__get_table(query)
         sql_placeholder = self.db_client._get_sql_placeholder()
@@ -181,6 +219,20 @@ class PypikaQueryBuilder(QueryBuilder):
             return query.get_sql()
         else:
             raise TechnicalException(f"Unmanaged query of type {Typing.get_object_class_fullname(query)}")
+    
+    # def is_query_type(self, query, query_type):
+    #     query_type = query_type.lower()
+    #
+    #     if query_type == 'insert':
+    #         return query._insert_table is not None
+    #     elif query_type == 'select':
+    #         return len(query._selects) > 0
+    #     elif query_type == 'update':
+    #         return query._update_table is not None
+    #     elif query_type == 'delete':
+    #         return query._delete_from
+    #     else:
+    #         raise TechnicalException(f"Unmanaged query type '{query_type}' (managed query types: 'insert', 'select', 'update', 'delete')")
         
     def __get_table(self, query):
         if query._from is not None and len(query._from) > 0:

holado_docker/tests/behave/steps/tools/docker_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 logging
 
 logger = logging.getLogger(__name__)

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_helper/script/action.py

@@ -89,13 +89,22 @@ class BehaveActionRunner():
     
     def __add_variable_values(self, res, params):
         if params:
-            for key, value in params.items():
-                if key == 'STATUS':
-                    continue
-                if value is not_applicable:
-                    res[key] = 'N/A'
-                else:
-                    res[key] = value
+            if isinstance(params, dict):
+                for key, value in params.items():
+                    self.__add_variable_value(res, key, value)
+            elif isinstance(params, list):
+                for key, value in params:
+                    self.__add_variable_value(res, key, value)
+            else:
+                raise TechnicalException(f"Unexpected params type '{type(params)}'")
+    
+    def __add_variable_value(self, res, var_name, value):
+        if var_name == 'STATUS':
+            return
+        if value is not_applicable:
+            res[var_name] = 'N/A'
+        else:
+            res[var_name] = value
     
     def run(self):
         logger.info(f"Processing action '{self.__action_info.action}' of index {self.__action_info.index}: {self.__action_info.params}")

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,9 +13,11 @@
 
 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
+from holado.common.handlers.undefined import undefined_argument
 
 logger = logging.getLogger(__name__)
 
@@ -31,8 +33,66 @@ class BlockingSocketClient(SocketClient):
     """
     __metaclass__ = abc.ABCMeta
     
-    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 start(self, *, read_bufsize=1024, read_kwargs=None, write_kwargs=None):
+        """Start client event loop.
+        """
+        if self.is_with_ssl:
+            # Set a small timeout, so that recv has a behaviour similar flag MSG_DONTWAIT
+            # See _process_recv_send implementation, recv flags are needed to be forced to 0
+            if self._idle_sleep_delay is not None:
+                self.internal_socket.settimeout(self._idle_sleep_delay)
+            else:
+                self.internal_socket.settimeout(0.01)
+        
+        kwargs = {'read_bufsize':read_bufsize, 'read_kwargs':read_kwargs, 'write_kwargs':write_kwargs}
+        thread = LoopFunctionThreaded(self._process_recv_send, kwargs=kwargs, register_thread=True, delay_before_run_sec=None)
+        self._start_thread(thread)
+    
+    def _process_recv_send(self, *, 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 {}
+        
+        recv_data = None
+        if self.is_run_with_recv:
+            if self.is_with_ssl:
+                # ssl doesn't suppôrt flags != 0
+                flags = 0
+            else:
+                # Add flag to not wait data
+                flags = read_kwargs.get('flags', 0)
+                flags |= socket.MSG_DONTWAIT
+            
+            try:
+                recv_data = self.internal_socket.recv(read_bufsize, flags)
+            except (BlockingIOError, TimeoutError):
+                # No data to read
+                pass
+            else:
+                if recv_data:
+                    has_activity = True
+                    with self._data_lock:
+                        self._data.in_bytes += recv_data
+                        if logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(f"[{self.name}] Received [{recv_data}] (type: {type(recv_data)} ; total: {len(self._data.in_bytes)})")
+        
+        sent = None
+        if self.is_run_with_send:
+            with self._data_lock:
+                if self._data.out_bytes:
+                    has_activity = True
+                    sent = self.internal_socket.send(self._data.out_bytes)
+                    if sent > 0:
+                        self._data.out_bytes = self._data.out_bytes[sent:]
+                        if logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(f"[{self.name}] Sent {sent} data (remaining to send: {len(self._data.out_bytes)})")
+        
+        # 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)
     
 
 class TCPBlockingSocketClient(BlockingSocketClient):
@@ -40,18 +100,27 @@ class TCPBlockingSocketClient(BlockingSocketClient):
     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)
+        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)
-            # sock = ssl_context.wrap_socket(sock, server_hostname=host)
-        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), 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)
 
 
 
@@ -67,24 +136,16 @@ class BlockingSocketServer(SocketServer):
     """
     __metaclass__ = abc.ABCMeta
     
-    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None):
-        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs)
-        
-        self.__start_thread = None
+    def __init__(self, *, name=None, create_ipv4_socket_kwargs=None, idle_sleep_delay=undefined_argument):
+        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
     
     def start(self, read_bufsize=1024, *, read_kwargs=None, write_kwargs=None):
         """Start server to wait a connection, and then listen data, process data, and send result.
         Note: current implementation is simple and supports only one connection at a time.
         """
         kwargs = {'read_bufsize':read_bufsize, 'read_kwargs':read_kwargs, 'write_kwargs':write_kwargs}
-        self.__start_thread = LoopFunctionThreaded(self.wait_and_process_connection, 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_connection, kwargs=kwargs, register_thread=True, delay_before_run_sec=None)
+        self._start_thread(thread)
     
     def wait_and_process_connection(self, read_bufsize=1024, *, read_kwargs=None, write_kwargs=None):
         """Wait a connection, and then listen data, process data, and send result.
@@ -93,26 +154,32 @@ 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_data(data)
+                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)
-    
-    @abc.abstractmethod
-    def _process_data(self, data):
-        raise NotImplementedError()
 
 
 
@@ -121,16 +188,19 @@ class TCPBlockingSocketServer(BlockingSocketServer):
     TCP socket server
     """
     
-    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):
+        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)
-        
-        sock = socket.create_server((host, port), **kwargs)
+        socket_kwargs = self._new_ssl_context_if_required(server_side=True, **kwargs)
         
-        if ssl_context:
-            # sock = ssl_context.wrap_socket(sock, do_handshake_on_connect=False, server_side=True)
-            sock = ssl_context.wrap_socket(sock, server_side=True)
-        self._set_internal_socket(sock)
+        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/echo_server.py

@@ -13,16 +13,17 @@
 
 import logging
 from holado_python.standard_library.socket.blocking_socket import TCPBlockingSocketServer
+from holado.common.handlers.undefined import undefined_argument
 
 logger = logging.getLogger(__name__)
 
 
 
 class EchoTCPBlockingSocketServer(TCPBlockingSocketServer):
-    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):
+        super().__init__(name=name, create_ipv4_socket_kwargs=create_ipv4_socket_kwargs, idle_sleep_delay=idle_sleep_delay)
     
-    def _process_data(self, data):
+    def _process_received_data(self, data):
         return data