socket.d 2.5.2__tar.gz → 2.5.4__tar.gz

{socket.d-2.5.2 → socket.d-2.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: socket.d
-Version: 2.5.2
+Version: 2.5.4
 Summary: @noear/socket.d python project
 Home-page: https://socketd.noear.org/
 Author: noear,bai

{socket.d-2.5.2 → socket.d-2.5.4}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup,find_packages
 
 setup(
     name='socket.d',
-    version='2.5.2',
+    version='2.5.4',
     description='@noear/socket.d python project',
     author='noear,bai',
     url='https://socketd.noear.org/',

{socket.d-2.5.2 → socket.d-2.5.4}/socket.d.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: socket.d
-Version: 2.5.2
+Version: 2.5.4
 Summary: @noear/socket.d python project
 Home-page: https://socketd.noear.org/
 Author: noear,bai

{socket.d-2.5.2 → socket.d-2.5.4}/socket.d.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ socketd/transport/core/Flags.py
 socketd/transport/core/FragmentAggregator.py
 socketd/transport/core/FragmentHandler.py
 socketd/transport/core/Frame.py
+socketd/transport/core/FrameIoHandler.py
 socketd/transport/core/Frames.py
 socketd/transport/core/HandshakeDefault.py
 socketd/transport/core/IdGenerator.py

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/SocketD.py

@@ -14,7 +14,7 @@ from socketd_aio_tcp.TcpAioProvider import TcpAioProvider
 
 
 def version() -> str:
-    return "2.5.2"
+    return "2.5.4"
 
 def protocol_name() -> str:
     return "Socket.D"

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/exception/SocketDExecption.py

@@ -16,9 +16,13 @@ class SocketDAlarmException(SocketDException):
     def __init__(self, alarm:Message):
         super().__init__(alarm.data_as_string())
         self.__alarm = alarm
-    def get_alarm(self):
+        self.__alarmCode = alarm.meta_as_int("code");
+    def get_alarm(self) -> Message:
         return self.__alarm
 
+    def get_alarm_code(self) -> int:
+        return  self.__alarmCode;
+
 
 class SocketDChannelException(SocketDException):
     """ 通道"""

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/client/ClientChannel.py

@@ -63,7 +63,7 @@ class ClientChannel(ChannelBase):
 
             if Asserts.is_closed_and_end(self.__real):
                 log.debug("Client channel is closed (pause heartbeat), sessionId=" + self.get_session().session_id())
-                await self.close(self.__real.is_closed())
+                await self.close(self.__real.close_code())
                 return
 
             if self.__real.is_closing():
@@ -86,11 +86,11 @@ class ClientChannel(ChannelBase):
         else:
             return self.__real.is_valid()
 
-    def is_closed(self):
+    def close_code(self):
         if self.__real is None:
             return False
         else:
-            return self.__real.is_closed()
+            return self.__real.close_code()
 
     def get_remote_address(self):
         if self.__real is None:

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/Asserts.py

@@ -12,12 +12,12 @@ class Asserts:
 
     @staticmethod
     def assert_closed(channel: Channel):
-        if channel and channel.is_closed() > 0:
+        if channel and channel.close_code() > 0:
             raise SocketDChannelException("This channel is closed, sessionId=" + channel.get_session().session_id())
 
     @staticmethod
     def is_closed_and_end(channel: Channel):
-        return channel.is_closed() == Constants.CLOSE2009_USER or channel.is_closed() == Constants.CLOSE2008_OPEN_FAIL
+        return channel.close_code() == Constants.CLOSE2009_USER or channel.close_code() == Constants.CLOSE2008_OPEN_FAIL
 
     @staticmethod
     def assert_closed_and_end(channel: Channel):

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/Channel.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import Any, Optional
 from asyncio import Future
 
+from socketd.transport.core import Entity
 from socketd.transport.core.HandshakeDefault import HandshakeDefault
 from socketd.transport.core.Session import Session
 from socketd.transport.core.Config import Config
@@ -30,7 +31,7 @@ class Channel(ABC):
         ...
 
     @abstractmethod
-    def is_closed(self) -> int:
+    def close_code(self) -> int:
         ...
 
     @abstractmethod
@@ -79,17 +80,19 @@ class Channel(ABC):
         ...
 
     @abstractmethod
-    async def send_alarm(self, _from: Message, alarm:str) -> None:
+    async def send_alarm(self, _from: Message, alarm:Entity) -> None:
         ...
 
     @abstractmethod
-    async def send(self, frame: 'Frame', stream: Optional[StreamInternal]) -> None:
+    async def send_pressure(self, _from: Message, pressure: Entity) -> None:
         ...
 
+
     @abstractmethod
-    async def retrieve(self, frame: Frame, stream: StreamInternal) -> None:
+    async def send(self, frame: 'Frame', stream: Optional[StreamInternal]) -> None:
         ...
 
+
     @abstractmethod
     def get_session(self) -> Session:
         ...

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/ChannelInternal.py

@@ -13,6 +13,9 @@ class ChannelInternal(Channel, ABC):
     @abstractmethod
     def set_live_time_as_now(self):...
 
+    @abstractmethod
+    def set_alarm_code(self, alarm_code:int):...
+
     @abstractmethod
     def get_stream(self, sid: str): ...
 

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/Costants.py

@@ -50,3 +50,6 @@ class Constants:
     CLOSE2008_OPEN_FAIL = 2008
     # 因用户主动关闭（不可再重连）
     CLOSE2009_USER = 2009
+
+    # 因压力告警
+    ALARM3001_PRESSURE = 3001

socket.d-2.5.4/socketd/transport/core/FrameIoHandler.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar, Callable
+
+from socketd.transport.core.ChannelAssistant import ChannelAssistant
+from socketd.transport.core.ChannelInternal import ChannelInternal
+from socketd.transport.core.Frame import Frame
+
+S = TypeVar("S")
+
+# 帧输入输出处理器 # 为 TrafficLimiter 提供支持
+class FrameIoHandler(ABC):
+    # 发送帧处理
+    @abstractmethod
+    async def send_frame_handle(self, channel: ChannelInternal, frame: Frame, channelAssistant: ChannelAssistant[S],
+                          target: S, completionHandler:Callable[[bool, Exception], None]):
+        ...
+
+    # 接收帧处理
+    @abstractmethod
+    async def reve_frame_handle(self, channel: ChannelInternal, frame: Frame):
+        ...

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/Frames.py

@@ -1,4 +1,5 @@
 from socketd import SocketD
+from socketd.transport.core.Entity import Entity
 from socketd.transport.core.Flags import Flags
 from socketd.transport.core.EntityMetas import EntityMetas
 from socketd.transport.core.HandshakeDefault import HandshakeInternal
@@ -23,7 +24,7 @@ class Frames:
         return Frame(Flags.Connect, message)
 
     @staticmethod
-    def connack_frame(handshake: HandshakeInternal):
+    def connack_frame(handshake: HandshakeInternal) -> Frame:
         entity = EntityDefault()
         # 添加框架版本号
         entity.meta_map_put(handshake.get_out_meta_map())
@@ -37,27 +38,52 @@ class Frames:
         return Frame(Flags.Connack, message)
 
     @staticmethod
-    def ping_frame():
+    def ping_frame() -> Frame:
         return Frame(Flags.Ping, None)
 
     @staticmethod
-    def pong_frame():
+    def pong_frame() -> Frame:
         return Frame(Flags.Pong, None)
 
     @staticmethod
-    def close_frame(_code: int):
+    def close_frame(_code: int) -> Frame:
         messageBuilder = MessageBuilder()
         messageBuilder.entity(EntityDefault().meta_put("code", str(_code)))
 
         return Frame(Flags.Close, messageBuilder.build())
 
     @staticmethod
-    def alarm_frame(_from: Message, alarm: str):
+    def alarm_frame(_from: Message, alarm: Entity) -> Frame:
         messageBuilder = MessageBuilder()
 
         if _from:
-            messageBuilder.sid(_from.sid()).event(_from.event())
-            messageBuilder.entity(StringEntity(alarm).meta_string_set(_from.data_as_string()))
+            entity = EntityDefault()
+            entity.meta_string_set(_from.meta_string())
+            entity.data_set(alarm.data());
+            entity.meta_map_put(alarm.meta_map())
+
+            messageBuilder.sid(_from.sid());
+            messageBuilder.event(_from.event());
+            messageBuilder.entity(entity)
         else:
-            messageBuilder.entity(StringEntity(alarm))
+            messageBuilder.entity(alarm)
+
         return Frame(Flags.Alarm, messageBuilder.build())
+
+    @staticmethod
+    def pressure_frame(_from: Message, pressure: Entity) -> Frame:
+        messageBuilder = MessageBuilder()
+
+        if _from:
+            entity = EntityDefault()
+            entity.meta_string_set(_from.meta_string())
+            entity.data_set(pressure.data());
+            entity.meta_map_put(pressure.meta_map())
+
+            messageBuilder.sid(_from.sid());
+            messageBuilder.event(_from.event());
+            messageBuilder.entity(entity)
+        else:
+            messageBuilder.entity(pressure)
+
+        return Frame(Flags.Pressure, messageBuilder.build())

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/Listener.py

@@ -5,18 +5,30 @@ from socketd.transport.core.Session import Session
 
 
 class Listener(abc.ABC):
+    # 打开时
     @abc.abstractmethod
     async def on_open(self, session: Session):
         pass
 
+    # 收到消息时
     @abc.abstractmethod
     async def on_message(self, session: Session, message: Message):
         pass
 
+    # 收到答复时
+    async def on_reply(self, session: Session, message: Message):
+        pass
+
+    # 发送消息时
+    async def on_send(self, session: Session, message: Message):
+        pass
+
+    # 关闭时
     @abc.abstractmethod
     async def on_close(self, session: Session):
         pass
 
+    # 出错时
     @abc.abstractmethod
     async def on_error(self, session: Session, error):
         pass

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/Processor.py

@@ -1,11 +1,14 @@
 from abc import ABC, abstractmethod
+from typing import TypeVar, Callable
 
 from socketd.transport.core import Listener
 from socketd.transport.core.Channel import Channel
+from socketd.transport.core.ChannelAssistant import ChannelAssistant
 from socketd.transport.core.ChannelInternal import ChannelInternal
 from socketd.transport.core.Frame import Frame
-from socketd.transport.core.Message import Message
+from socketd.transport.stream.Stream import StreamInternal
 
+S = TypeVar("S")
 
 class Processor(ABC):
 
@@ -14,7 +17,11 @@ class Processor(ABC):
         pass
 
     @abstractmethod
-    def on_receive(self, channel: Channel, frame:Frame):
+    def send_frame(self, channel: ChannelInternal, frame: Frame, channelAssistant: ChannelAssistant[S], target: S):
+        pass
+
+    @abstractmethod
+    def reve_frame(self, channel: Channel, frame: Frame):
         pass
 
     @abstractmethod
@@ -22,9 +29,13 @@ class Processor(ABC):
         pass
 
     @abstractmethod
-    def on_message(self, channel: ChannelInternal, message:Message):
+    def on_message(self, channel: ChannelInternal, frame: Frame):
         pass
 
+    @abstractmethod
+    def on_reply(self, channel: ChannelInternal, frame: Frame, stream: StreamInternal) -> None:
+        ...
+
     @abstractmethod
     def on_close(self, channel: ChannelInternal):
         pass

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/Session.py

@@ -69,7 +69,11 @@ class Session(ClientSession):
         ...
 
     @abc.abstractmethod
-    async def send_alarm(self, _from: Message, alarm: str) -> None:
+    async def send_alarm(self, _from: Message, alarm: Entity) -> None:
+        ...
+
+    @abc.abstractmethod
+    async def send_pressure(self, _from: Message, pressure: Entity) -> None:
         ...
 
     @abc.abstractmethod

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/impl/ChannelBase.py

@@ -4,6 +4,7 @@ import threading
 from abc import ABC
 from typing import Optional
 
+from socketd.transport.core import Entity
 from socketd.transport.core.Channel import Channel
 from socketd.transport.core.Costants import Constants
 from socketd.transport.core.Frames import Frames
@@ -72,9 +73,12 @@ class ChannelBase(Channel, ABC):
     async def send_close(self, code: int):
         await self.send(Frames.close_frame(code), None)
 
-    async def send_alarm(self, _from: Message, alarm: str):
+    async def send_alarm(self, _from: Message, alarm: Entity):
         await self.send(Frames.alarm_frame(_from, alarm), None)
 
+    async def send_pressure(self, _from: Message, pressure: Entity):
+        await self.send(Frames.pressure_frame(_from, pressure), None)
+
     async def close(self, code: int):
         if code > Constants.CLOSE1000_PROTOCOL_CLOSE_STARTING:
             self.__attachments.clear()

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/impl/ChannelDefault.py

@@ -40,15 +40,16 @@ class ChannelDefault(ChannelBase, ChannelInternal):
         self._session: Optional[Session] = None
         self._liveTime: Optional[float] = None
         self._closeCode: int = 0
-        self._isCloseNotified = False;
+        self._isCloseNotified = False
+        self._alarmCode: int = 0
 
     def is_valid(self) -> bool:
-        return self.is_closed() == 0 and self._assistant.is_valid(self._source)
+        return self.close_code() == 0 and self._assistant.is_valid(self._source)
 
     def is_closing(self) -> bool:
         return self._closeCode == Constants.CLOSE1000_PROTOCOL_CLOSE_STARTING
 
-    def is_closed(self):
+    def close_code(self):
         if self._closeCode > Constants.CLOSE1000_PROTOCOL_CLOSE_STARTING:
             return self._closeCode
         else:
@@ -60,6 +61,9 @@ class ChannelDefault(ChannelBase, ChannelInternal):
     def set_live_time_as_now(self):
         self._liveTime = time.time()
 
+    def set_alarm_code(self, alarm_code:int):
+        self._alarmCode = alarm_code
+
     def get_remote_address(self) -> str:
         return self._assistant.get_remote_address(self._source)
 
@@ -74,13 +78,20 @@ class ChannelDefault(ChannelBase, ChannelInternal):
         else:
             log.debug(f"S-SEN:{frame}")
 
-        if self.get_config().is_nolock_send():
+        with self:
             await self.send_do(frame, stream)
-        else:
-            with self:
-                await self.send_do(frame, stream)
 
     async def send_do(self, frame: Frame, stream: StreamInternal):
+        if self._alarmCode == Constants.ALARM3001_PRESSURE:
+            if frame.flag() >= Flags.Message and frame.flag() <= Flags.Subscribe:
+                if frame.message().meta(EntityMetas.META_X_UNLIMITED) is None:
+                    try:
+                        log.debug("Too much pressure, sleep=100ms")
+                        self.set_alarm_code(0)
+                        time.sleep(0.1)
+                    except Exception as e:
+                        ... #略过
+
         if frame.message() is not None:
             message: Message = frame.message()
             # 注册流接收器
@@ -100,33 +111,15 @@ class ChannelDefault(ChannelBase, ChannelInternal):
                         messageNew = MessageBuilder().flag(frame.flag()).sid(message.sid()).event(
                             message.event()).entity(fragmentEntity).build()
                         fragmentFrame = Frame(frame.flag(), messageNew)
-                    await self._assistant.write(self._source, fragmentFrame)
+                    await self._processor.send_frame(self, fragmentFrame, self._assistant, self._source)
 
                 await self.get_config().get_fragment_handler().split_fragment(self, stream, message, __consumer)
             return
 
-        await self._assistant.write(self._source, frame)
+        await self._processor.send_frame(self, frame, self._assistant, self._source)
         if stream is not None:
             stream.on_progress(True, 1, 1)
 
-    async def retrieve(self, frame: Frame, stream: StreamInternal) -> None:
-        """接收（接收答复帧）"""
-        if stream is not None:
-            if stream.demands() < Constants.DEMANDS_MULTIPLE or frame.flag() == Flags.ReplyEnd:
-                # 如果是单收或者答复结束，则移除流接收器
-                self._streamManger.remove_stream(frame.message().sid())
-
-            if stream.demands() < Constants.DEMANDS_MULTIPLE:
-                # 单收时，内部已经是异步机制
-                await RunUtils.waitTry(stream.on_reply(frame.message()))
-            else:
-                # 改为异步处理，避免卡死Io线程
-                asyncio.get_running_loop().run_in_executor(self.get_config().get_exchange_executor(),
-                                                           lambda _m: asyncio.run(stream.on_reply(_m)), frame.message())
-        else:
-            log.debug(
-                f"{self.get_config().get_role_name()} stream not found, sid={frame.message().sid()}, sessionId={self.get_session().session_id()}")
-
     def reconnect(self):
         ...
 

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/impl/ProcessorDefault.py

@@ -1,9 +1,12 @@
+import asyncio
 import traceback
 from abc import ABC
-from typing import Optional
+from typing import Optional, Callable, TypeVar
 
 from socketd.exception.SocketDExecption import SocketDAlarmException, SocketDConnectionException
+from socketd.transport.core.ChannelAssistant import ChannelAssistant
 from socketd.transport.core.ChannelInternal import ChannelInternal
+from socketd.transport.core.FrameIoHandler import FrameIoHandler
 from socketd.transport.core.HandshakeDefault import HandshakeDefault
 from socketd.transport.core.Message import Message
 from socketd.transport.core.Processor import Processor
@@ -16,8 +19,10 @@ from socketd.transport.core.listener.SimpleListener import SimpleListener
 from socketd.transport.stream.Stream import StreamInternal
 from socketd.utils.RunUtils import RunUtils
 
+S = TypeVar("S")
 
-class ProcessorDefault(Processor, ABC):
+# 协议处理器默认实现（原则上，写不要在读的线程上执行）
+class ProcessorDefault(Processor, FrameIoHandler, ABC):
 
     def __init__(self):
         self.listener = SimpleListener()
@@ -26,7 +31,23 @@ class ProcessorDefault(Processor, ABC):
         if listener is not None:
             self.listener = listener
 
-    async def on_receive(self, channel: ChannelInternal, frame):
+    async def send_frame(self, channel: ChannelInternal, frame: Frame, channelAssistant: ChannelAssistant[S], target: S):
+        def completionHandler(result:bool, throwable:Exception):
+            ...
+
+        await self.send_frame_handle(channel, frame, channelAssistant, target, completionHandler)
+
+    async def send_frame_handle(self, channel: ChannelInternal, frame: Frame, channelAssistant: ChannelAssistant[S],
+                          target: S, completionHandler:Callable[[bool, Exception], None]):
+        await channelAssistant.write(target, frame)
+
+        if frame.flag() >= Flags.Message:
+            await RunUtils.waitTry(self.listener.on_send(channel.get_session(), frame.message()))
+
+    async def reve_frame(self, channel: ChannelInternal, frame):
+        await self.reve_frame_handle(channel, frame)
+
+    async def reve_frame_handle(self, channel: ChannelInternal, frame: Frame):
         if channel.get_config().client_mode():
             log.debug(f"C-REV:{frame}")
         else:
@@ -72,7 +93,7 @@ class ProcessorDefault(Processor, ABC):
 
             try:
                 if frame.flag() == Flags.Ping:
-                    await channel.send_pong()
+                    RunUtils.taskTry(channel.send_pong())
                 elif frame.flag() == Flags.Pong:
                     pass
                 elif frame.flag() == Flags.Close:
@@ -87,14 +108,18 @@ class ProcessorDefault(Processor, ABC):
                     await self.on_close_internal(channel, code)
                 elif frame.flag() == Flags.Alarm:
                     e = SocketDAlarmException(frame.message())
+                    channel.set_alarm_code(e.get_alarm_code())
+
                     stream: StreamInternal = channel.get_config().get_stream_manger().get_stream(frame.message().sid())
 
                     if stream is None:
                         self.on_error(channel, e)
                     else:
                         channel.get_config().get_stream_manger().remove_stream(frame.message().sid())
-                        stream.on_error(e)
+                        RunUtils.taskTry(stream.on_error(e))
                 elif frame.flag() == Flags.Pressure:
+                    code = frame.message().meta_as_int("code")
+                    channel.set_alarm_code(code)
                     pass
                 elif frame.flag() in [Flags.Message, Flags.Request, Flags.Subscribe]:
                     await self.on_receive_do(channel, frame, False)
@@ -138,9 +163,9 @@ class ProcessorDefault(Processor, ABC):
         if isReply:
             if stream:
                 stream.on_progress(False, streamIndex, streamTotal)
-            await channel.retrieve(frame, stream)
+            await self.on_reply(channel, frame, stream)
         else:
-            self.on_message(channel, frame.message())
+            self.on_message(channel, frame)
 
     def on_open(self, channel: ChannelInternal):
         RunUtils.taskTry(self.on_open_do(channel))
@@ -154,19 +179,39 @@ class ProcessorDefault(Processor, ABC):
             log.warning(f"{channel.get_config().get_role_name()} channel listener onOpen error \n{e_msg}")
             channel.do_open_future(False, e)
 
-    def on_message(self, channel: ChannelInternal, message: Message):
-        RunUtils.taskTry(self.on_message_do(channel, message))
+    def on_message(self, channel: ChannelInternal, frame: Frame):
+        RunUtils.taskTry(self.on_message_do(channel, frame.message()))
 
     async def on_message_do(self, channel: ChannelInternal, message: Message):
         try:
-            await self.listener.on_message(channel.get_session(), message)
+            await RunUtils.waitTry(self.listener.on_message(channel.get_session(), message))
         except Exception as e:
             e_msg = traceback.format_exc()
             log.warning(f"{channel.get_config().get_role_name()} channel listener onMessage error \n{e_msg}")
             self.on_error(channel, e)
 
+    async def on_reply(self, channel: ChannelInternal, frame: Frame, stream: StreamInternal) -> None:
+        """接收（接收答复帧）"""
+        if stream is not None:
+            if stream.demands() < Constants.DEMANDS_MULTIPLE or frame.flag() == Flags.ReplyEnd:
+                # 如果是单收或者答复结束，则移除流接收器
+                channel.get_config().get_stream_manger().remove_stream(frame.message().sid())
+
+            if stream.demands() < Constants.DEMANDS_MULTIPLE:
+                # 单收时，内部已经是异步机制
+                await RunUtils.waitTry(stream.on_reply(frame.message()))
+                await RunUtils.waitTry(self.listener.on_reply(channel.get_session(), frame.message()))
+            else:
+                # 改为异步处理，避免卡死Io线程
+                asyncio.get_running_loop().run_in_executor(self.get_config().get_exchange_executor(),
+                                                           lambda _m: asyncio.run(stream.on_reply(_m)), frame.message())
+        else:
+            await RunUtils.waitTry(self.listener.on_reply(channel.get_session(), frame.message()))
+            log.debug(
+                f"{channel.get_config().get_role_name()} stream not found, sid={frame.message().sid()}, sessionId={channel.get_session().session_id()}")
+
     def on_close(self, channel: ChannelInternal):
-        if channel.is_closed() <= Constants.CLOSE1000_PROTOCOL_CLOSE_STARTING:
+        if channel.close_code() <= Constants.CLOSE1000_PROTOCOL_CLOSE_STARTING:
             RunUtils.taskTry(self.on_close_internal(channel, Constants.CLOSE2003_DISCONNECTION))
 
     async def on_close_internal(self, channel: ChannelInternal, code: int):

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/impl/SessionDefault.py

@@ -2,6 +2,7 @@ import traceback
 from typing import Optional
 
 from socketd.transport.core.entity.MessageBuilder import MessageBuilder
+from socketd.transport.core.entity.StringEntity import StringEntity
 from socketd.transport.core.impl.SessionBase import SessionBase
 from socketd.transport.core.Channel import Channel
 from socketd.transport.core.HandshakeDefault import HandshakeDefault
@@ -122,7 +123,13 @@ class SessionDefault(SessionBase):
     def param_or_default(self, name: str, defVal: str) -> str:
         return self.handshake().param_or_default(name, defVal)
 
-    async def send_alarm(self, _from: Message, alarm: str) -> None:
-        await self._channel.send_alarm(_from, alarm)
+    async def send_alarm(self, _from: Message, alarm: str|Entity) -> None:
+        if isinstance(alarm, str):
+            await self._channel.send_alarm(_from, StringEntity(alarm))
+        else:
+            await self._channel.send_alarm(_from, alarm)
+
+    async def send_pressure(self, _from: Message, pressure: Entity) -> None:
+        await self._channel.send_pressure(_from, pressure)
 
 

{socket.d-2.5.2 → socket.d-2.5.4}/socketd/transport/core/listener/EventListener.py

@@ -15,6 +15,9 @@ class EventListener(Listener):
     def __init__(self):
         self._doOnOpenHandler: Union[Callable[[Session], Coroutine], None] = None
         self._doOnMessageHandler: Union[Callable[[Session, Message], Coroutine], None] = None
+        self._doOnReplyHandler: Union[Callable[[Session, Message], Coroutine], None] = None
+        self._doOnSendHandler: Union[Callable[[Session, Message], Coroutine], None] = None
+
         self._doOnCloseHandler: Union[Callable[[Session], Coroutine], None] = None
         self._doOnErrorHandler: Union[Callable[[Session, Exception], Coroutine], None] = None
         self._eventRouteSelector: Dict[str, Callable[[Session, Message], Coroutine]] = {}
@@ -27,6 +30,14 @@ class EventListener(Listener):
         self._doOnMessageHandler = handler
         return self
 
+    def do_on_reply(self, handler: Callable[[Session, Message], None]) -> 'EventListener':
+        self._doOnReplyHandler = handler
+        return self
+
+    def do_on_send(self, handler: Callable[[Session, Message], None]) -> 'EventListener':
+        self._doOnSendHandler = handler
+        return self
+
     def do_on_close(self, handler: Callable[[Session], None]) -> 'EventListener':
         self._doOnCloseHandler = handler
         return self
@@ -50,6 +61,14 @@ class EventListener(Listener):
         if message_handler := self._eventRouteSelector.get(message.event()):
             await RunUtils.waitTry(message_handler(session, message))
 
+    async def on_reply(self, session: Session, message: Message):
+        if self._doOnReplyHandler:
+            await RunUtils.waitTry(self._doOnReplyHandler(session, message))
+
+    async def on_send(self, session: Session, message: Message):
+        if self._doOnSendHandler:
+            await RunUtils.waitTry(self._doOnSendHandler(session, message))
+
     async def on_close(self, session: Session):
         if self._doOnCloseHandler:
             await RunUtils.waitTry(self._doOnCloseHandler(session))