dev sep 25

etpproto/client_info.py

@@ -11,7 +11,7 @@
     RequestSession,
 )
 
-from etpproto.endpoint_capability_kind import kind_from_name
+from etpproto.endpoint_capability_kind import *
 
 
 @dataclass
@@ -20,8 +20,8 @@ class ClientInfo:
 
     endpoint_capabilities: Dict[str, Any] = field(
         default_factory=lambda: {
-            "MaxWebSocketFramePayloadSize": 10000,
-            "MaxWebSocketMessagePayloadSize": 10000,
+            MaxWebSocketFramePayloadSize.name(): 10000,
+            MaxWebSocketMessagePayloadSize.name(): 10000,
         }
     )
     login: str = field(default="anonymousUser")

etpproto/connection.py

@@ -26,6 +26,8 @@
 from etptypes.energistics.etp.v12.datatypes.supported_protocol import (
     SupportedProtocol,
 )
+from etptypes.energistics.etp.v12.datatypes.version import Version
+
 from etptypes.energistics.etp.v12.protocol.core.acknowledge import Acknowledge
 from etptypes.energistics.etp.v12.protocol.core.close_session import (
     CloseSession,
@@ -56,12 +58,12 @@
 
 
 class Protocol:
-    def handle_message(
+    async def handle_message(
         self,
         etp_object: object,
         msg_header: MessageHeader,
         client_info: Union[None, ClientInfo] = None,
-    ) -> Generator[Optional[Message], None]:
+    ) -> AsyncGenerator[Optional[Message], None]:
         yield NotSupportedError().to_etp_message(
             correlation_id=msg_header.message_id
         )
@@ -119,6 +121,13 @@ class CommunicationProtocol(Enum):
     #: In ETP v1.1, this protocol was published as Protocol 8. It is now a custom protocol published by an Energistics member company. .
     WITSML_SOAP = 2000
 
+    @classmethod
+    def from_value(cls, value: int) -> CommunicationProtocol:
+        for protocol in CommunicationProtocol:
+            if protocol.value == value:
+                return protocol
+        raise UnsupportedProtocolError(value)
+
 
 @dataclass
 class ETPConnection:
@@ -137,7 +146,7 @@ class ETPConnection:
         get_all_etp_protocol_classes()
     )
 
-    transition_table: ClassVar[Dict[CommunicationProtocol, Protocol]] = {}
+    transition_table: ClassVar[Dict[int, Protocol]] = {}
 
     server_capabilities: Optional[ServerCapabilities] = field(default=None)
 
@@ -320,19 +329,17 @@ async def _handle_message_generator(
                             try:
                                 # Test si le protocol est supporte par le serveur
                                 if (
-                                    CommunicationProtocol(
-                                        etp_input_msg.header.protocol
-                                    )
+                                    # CommunicationProtocol.from_value(
+                                    etp_input_msg.header.protocol
+                                    # )
                                     in self.transition_table
                                 ):
                                     # demande la reponse au protocols du serveur
                                     try:
                                         async for (
                                             handled
                                         ) in self.transition_table[
-                                            CommunicationProtocol(
-                                                etp_input_msg.header.protocol
-                                            )
+                                            etp_input_msg.header.protocol
                                         ].handle_message(
                                             etp_object=etp_input_msg.body,
                                             msg_header=etp_input_msg.header,
@@ -369,7 +376,7 @@ async def _handle_message_generator(
                                 )
                             except Exception as e:
                                 logging.error(
-                                    f"{self.client_info.ip}: _SERVER_ not handled exception",
+                                    f"{self.client_info.ip}: _SERVER_ not handled exception ({e}) {type(e)}",
                                 )
                                 raise e
                 else:  # not connected
@@ -455,12 +462,24 @@ def consume_msg_id(self):
 
     @classmethod
     def on(
-        cls: Type[ETPConnection], protocol: CommunicationProtocol
+        cls: Type[ETPConnection],
+        protocol: Optional[int] = None,
     ) -> Callable[[Type[Protocol]], Type[Protocol]]:
         """Should only be used to decorate classes."""
 
         def decorate(cls_protocol: Type[Protocol]) -> Type[Protocol]:
-            cls.transition_table[protocol] = cls_protocol()
+            proto = protocol
+            if proto is None:
+                if hasattr(cls_protocol, "protocol_id"):
+                    proto = getattr(cls_protocol, "protocol_id")
+            elif isinstance(proto, CommunicationProtocol):
+                proto = proto.value
+            else:
+                raise ValueError(
+                    "The protocol parameter must be an int or a CommunicationProtocol"
+                )
+            print(f"Register protocol {proto} to {cls_protocol}")
+            cls.transition_table[proto] = cls_protocol()
             return cls_protocol
 
         return decorate
@@ -483,18 +502,18 @@ def get_supported_protocol_list(
     ) -> List[SupportedProtocol]:
         supported_protocols: List[SupportedProtocol] = []
         for protocol in cls.transition_table:
-            if protocol.value != CommunicationProtocol.CORE:
+            if protocol != CommunicationProtocol.CORE.value:
                 supported_protocols.append(
                     SupportedProtocol(
-                        protocol=protocol.value,
-                        protocol_version={
-                            "major": 1,
-                            "minor": 2,
-                            "patch": 0,
-                            "revision": 0,
-                        },
+                        protocol=protocol,
+                        protocolVersion=Version(
+                            major=1,
+                            minor=2,
+                            patch=0,
+                            revision=0,
+                        ),
                         role="server",
-                        protocol_capabilities={},
+                        protocolCapabilities={},
                     )
                 )
         return supported_protocols

etpproto/endpoint_capability_kind.py

@@ -4,6 +4,9 @@
 import sys
 from dataclasses import dataclass, field
 from typing import ClassVar, List, Optional, Union
+from etptypes.energistics.etp.v12.datatypes.endpoint_capability_kind import (
+    EndpointCapabilityKind as ECKind,
+)
 
 
 @dataclass
@@ -14,6 +17,21 @@ class EndpointCapabilityKind:
     _max: ClassVar = None
     _unit: ClassVar[Optional[str]] = None
 
+    @classmethod
+    def name(cls) -> str:
+        try:
+            return cls.as_eck().value
+        except ValueError:
+            # Return the class name if no matching enum value is found
+            return cls.__name__
+
+    @classmethod
+    def as_eck(cls) -> Optional[ECKind]:
+        try:
+            return ECKind(cls.__name__)
+        except ValueError:
+            return None
+
 
 @dataclass
 class ActiveTimeoutPeriod(EndpointCapabilityKind):
@@ -253,3 +271,8 @@ class SupportsMessageHeaderExtensions(EndpointCapabilityKind):
 
 def kind_from_name(classname):
     return getattr(sys.modules[__name__], classname)
+
+
+if __name__ == "__main__":
+    print(ActiveTimeoutPeriod.name())
+    print(ActiveTimeoutPeriod.as_eck())