socket.d 2.4.10__tar.gz → 2.4.10.1__tar.gz

{socket.d-2.4.10 → socket.d-2.4.10.1}/PKG-INFO

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

socket.d-2.4.10.1/README.md

@@ -0,0 +1,42 @@
+
+
+基于事件和语义消息流的网络应用层协议。
+
+有用户说，“Socket.D 之于 Socket，尤如 Vue 之于 Js、Mvc 之于 Http”。支持 tcp, udp, ws, kcp 传输。
+
+```
+[len:int][flag:int][sid:str(<64)][\n][event:str(<512)][\n][metaString:str(<4k)][\n][data:byte(<16m)]
+```
+
+### 主要特性
+
+* 基于事件，每个消息都可事件路由
+* 所谓语义，通过元信息进行语义描述
+* 流关联性，来回相关的消息会串成一个流
+* 语言无关，使用二进制输传数据（支持 tcp, ws, udp）。支持多语言、多平台
+* 断线重连，自动连接恢复
+* 多路复用，一个连接便可允许多个请求和响应消息同时运行
+* 双向通讯，单链接双向互听互发
+* 自动分片，数据超出 16Mb（大小可配置），会自动分片、自动重组（udp 除外）
+* 接口简单，是响应式但用回调接口
+
+### 体验效果 (for python-client)
+
+```python
+#发送
+session.send("/demo/hello", StringEntity("hi"));
+#发送，且获取发送进度（如果有大数据发送，又需要显示进度）
+session.send("/demo/upload", FileEntity(file)).then_progress(lambda isSend, val, max: ...)
+
+#发送并请求，且同步等待
+reply = await session.send_and_request("/demo/hello", EntityDefault());
+#发送并请求，且取接收进度（如果有大数据获取，又需要显示进度）
+session.send_and_request("/demo/download", EntityDefault())
+       .then_progress(lambda isSend, val, max: ...)
+       .thenReply(lambda reply: ...)
+       .thenError(lambda err: ...)
+
+#发送并订阅
+entity = EntityDefault().range(5,5).meta_put("videoId","1");
+session.send_and_subscribe("/demo/stream", entity).then_reply(lambda reply: ...)
+```

{socket.d-2.4.10 → socket.d-2.4.10.1}/setup.py

@@ -4,11 +4,11 @@ from setuptools import setup,find_packages
 
 setup(
     name='socket.d',
-    version='2.4.10',
+    version='2.4.10.1',
     description='@noear/socket.d python project',
     author='noear,bai',
     url='https://socketd.noear.org/',
-    packages=["socketd","socketd_aio_tcp","socketd_websocket"],   # 包内不需要引用的文件夹
+    packages=find_packages(exclude=['*test*']),   # 包内不需要引用的文件夹
     install_requires=[                          # 依赖包
         'loguru',
         'websockets'

{socket.d-2.4.10 → socket.d-2.4.10.1}/socket.d.egg-info/PKG-INFO

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

socket.d-2.4.10.1/socket.d.egg-info/SOURCES.txt

@@ -0,0 +1,125 @@
+README.md
+setup.py
+socket.d.egg-info/PKG-INFO
+socket.d.egg-info/SOURCES.txt
+socket.d.egg-info/dependency_links.txt
+socket.d.egg-info/requires.txt
+socket.d.egg-info/top_level.txt
+socket.d.egg-info/zip-safe
+socketd/SocketD.py
+socketd/__init__.py
+socketd/broker/BrokerFragmentHandler.py
+socketd/broker/BrokerListener.py
+socketd/broker/BrokerListenerBase.py
+socketd/broker/__init__.py
+socketd/cluster/ClusterClient.py
+socketd/cluster/ClusterClientSession.py
+socketd/cluster/LoadBalancer.py
+socketd/cluster/__init__.py
+socketd/exception/SocketDExecption.py
+socketd/exception/__init__.py
+socketd/transport/__init__.py
+socketd/transport/client/Client.py
+socketd/transport/client/ClientBase.py
+socketd/transport/client/ClientChannel.py
+socketd/transport/client/ClientConfig.py
+socketd/transport/client/ClientConfigHandler.py
+socketd/transport/client/ClientConnectHandler.py
+socketd/transport/client/ClientConnector.py
+socketd/transport/client/ClientConnectorBase.py
+socketd/transport/client/ClientHandshakeResult.py
+socketd/transport/client/ClientHeartbeatHandler.py
+socketd/transport/client/ClientProvider.py
+socketd/transport/client/ClientSession.py
+socketd/transport/client/__init__.py
+socketd/transport/core/Asserts.py
+socketd/transport/core/Channel.py
+socketd/transport/core/ChannelAssistant.py
+socketd/transport/core/ChannelInternal.py
+socketd/transport/core/ChannelSupporter.py
+socketd/transport/core/Codec.py
+socketd/transport/core/Config.py
+socketd/transport/core/Costants.py
+socketd/transport/core/Entity.py
+socketd/transport/core/EntityMetas.py
+socketd/transport/core/Flags.py
+socketd/transport/core/FragmentAggregator.py
+socketd/transport/core/FragmentHandler.py
+socketd/transport/core/Frame.py
+socketd/transport/core/Frames.py
+socketd/transport/core/HandshakeDefault.py
+socketd/transport/core/IdGenerator.py
+socketd/transport/core/Listener.py
+socketd/transport/core/Message.py
+socketd/transport/core/Processor.py
+socketd/transport/core/Session.py
+socketd/transport/core/__init__.py
+socketd/transport/core/codec/Buffer.py
+socketd/transport/core/codec/ByteBufferCodecReader.py
+socketd/transport/core/codec/ByteBufferCodecWriter.py
+socketd/transport/core/codec/CodecDefault.py
+socketd/transport/core/codec/__init__.py
+socketd/transport/core/entity/EntityDefault.py
+socketd/transport/core/entity/FileEntity.py
+socketd/transport/core/entity/MessageBuilder.py
+socketd/transport/core/entity/MessageDefault.py
+socketd/transport/core/entity/StringEntity.py
+socketd/transport/core/entity/__init__.py
+socketd/transport/core/fragment/FragmentAggregatorDefault.py
+socketd/transport/core/fragment/FragmentHandlerBase.py
+socketd/transport/core/fragment/FragmentHandlerDefault.py
+socketd/transport/core/fragment/FragmentHolder.py
+socketd/transport/core/fragment/__init__.py
+socketd/transport/core/impl/ChannelBase.py
+socketd/transport/core/impl/ChannelDefault.py
+socketd/transport/core/impl/ConfigBase.py
+socketd/transport/core/impl/LogConfig.py
+socketd/transport/core/impl/ProcessorDefault.py
+socketd/transport/core/impl/SessionBase.py
+socketd/transport/core/impl/SessionDefault.py
+socketd/transport/core/impl/__init__.py
+socketd/transport/core/listener/EventListener.py
+socketd/transport/core/listener/PathListener.py
+socketd/transport/core/listener/PathMapper.py
+socketd/transport/core/listener/PipelineListener.py
+socketd/transport/core/listener/SimpleListener.py
+socketd/transport/core/listener/__init__.py
+socketd/transport/server/Server.py
+socketd/transport/server/ServerBase.py
+socketd/transport/server/ServerConfig.py
+socketd/transport/server/ServerProvider.py
+socketd/transport/server/__init__.py
+socketd/transport/stream/RequestStream.py
+socketd/transport/stream/SendStream.py
+socketd/transport/stream/Stream.py
+socketd/transport/stream/StreamBase.py
+socketd/transport/stream/StreamManger.py
+socketd/transport/stream/StreamMangerDefault.py
+socketd/transport/stream/SubscribeStream.py
+socketd/transport/stream/__init__.py
+socketd/transport/utils/AsyncUtil.py
+socketd/transport/utils/CompletableFuture.py
+socketd/transport/utils/StrUtil.py
+socketd/transport/utils/__init__.py
+socketd/transport/utils/async_api/AtomicRefer.py
+socketd/transport/utils/async_api/__init__.py
+socketd/transport/utils/sync_api/AtomicRefer.py
+socketd/transport/utils/sync_api/__init__.py
+socketd_aio_tcp/TCPAIOServer.py
+socketd_aio_tcp/TCPStreamIO.py
+socketd_aio_tcp/TcpAIOChannelAssistant.py
+socketd_aio_tcp/TcpAioClient.py
+socketd_aio_tcp/TcpAioClientConnector.py
+socketd_aio_tcp/TcpAioProvider.py
+socketd_aio_tcp/__init__.py
+socketd_websocket/WsAioChannelAssistant.py
+socketd_websocket/WsAioClient.py
+socketd_websocket/WsAioClientConnector.py
+socketd_websocket/WsAioProvider.py
+socketd_websocket/WsAioServer.py
+socketd_websocket/__init__.py
+socketd_websocket/impl/AIOConnect.py
+socketd_websocket/impl/AIOServe.py
+socketd_websocket/impl/AIOWebSocketClientImpl.py
+socketd_websocket/impl/AIOWebSocketServerImpl.py
+socketd_websocket/impl/__init__.py

socket.d-2.4.10.1/socketd/broker/BrokerFragmentHandler.py

@@ -0,0 +1,7 @@
+from socketd.transport.core.fragment.FragmentHandlerDefault import FragmentHandlerDefault
+
+
+# 经纪人分片处理（关掉聚合）
+class BrokerFragmentHandler(FragmentHandlerDefault):
+    def aggr_enable(self) -> bool:
+        return False

socket.d-2.4.10.1/socketd/broker/BrokerListener.py

@@ -0,0 +1,93 @@
+from socketd.broker.BrokerListenerBase import BrokerListenerBase
+from socketd.transport.core import Entity
+from socketd.transport.core.Message import Message
+from socketd.transport.core.Session import Session
+
+
+# 经纪人监听器（为不同的玩家转发消息）
+class BrokerListener(BrokerListenerBase):
+    def __init__(self):
+        super().__init__()
+
+    async def on_open(self, session: Session):
+        name = session.name()
+        self.add_player(name, session)
+
+    def on_close(self, session: Session):
+        name = session.name()
+        self.remove_player(name, session)
+
+    async def on_message(self, requester: Session, message: Message):
+        atName = message.at_name()
+
+        if atName is None:
+            await requester.send_alarm(message, "Broker message require '@' meta")
+            return
+
+        if atName.__eq__("*"):
+            # 广播模式（给所有玩家）
+            nameAll = self.get_name_all()
+            if nameAll is not None and len(nameAll) > 0:
+                for name in nameAll:
+                    self.forward_to_name(requester, message, name)
+        elif atName.endswith("*"):
+            # 群发模式（给同名的所有玩家）
+            atName = atName[:-1]
+            if not self.forward_to_name(requester, message, atName):
+                await requester.send_alarm(message, "Broker don't have '@" + atName + "' player")
+        else:
+            responder = self.get_player_any(atName, requester, message)
+            if responder is not None:
+                self.forward_to_session(requester, message, responder)
+            else:
+                await requester.send_alarm(message, "Broker don't have '@" + atName + "' session")
+
+    # 批量转发消息
+    def forward_to_name(self, requester: Session, message: Message, name: str) -> bool:
+        playerAll = self.get_player_all(name)
+
+        if playerAll is not None and len(playerAll) > 0:
+            for responder in playerAll:
+                if responder != requester:
+                    if responder.is_valid():
+                        self.forward_to_session(requester, message, responder)
+                    else:
+                        self.on_close(responder)
+            return True
+        else:
+            return False
+
+    # 转发消息
+    def forward_to_session(self, requester: Session, message: Message, responder: Session):
+        if message.is_request():
+            def then_reply(reply: Entity):
+                if requester.is_valid():
+                    requester.reply(message, reply)
+
+            def then_error(err: Exception):
+                if requester.is_valid():
+                    requester.send_alarm(message, err)
+
+            responder.send_and_request(message.event(), message, -1).then_reply(then_reply).then_error(then_error)
+            return
+
+        if message.is_subscribe():
+            def then_reply(reply: Entity):
+                if requester.is_valid():
+                    if message.is_end():
+                        requester.reply_end(message, reply)
+                    else:
+                        requester.reply(message, reply)
+
+            def then_error(err: Exception):
+                if requester.is_valid():
+                    requester.send_alarm(message, err)
+
+            responder.send_and_subscribe(message.event(), message, -1).then_reply(then_reply).then_error(then_error)
+            return
+
+        responder.send(message.event(), message)
+
+    def on_error(self, session: Session, error):
+        ...
+        # log.warn("Broker error", error)

socket.d-2.4.10.1/socketd/broker/BrokerListenerBase.py

@@ -0,0 +1,82 @@
+from abc import ABC
+from typing import Dict, List
+from socketd.cluster.LoadBalancer import LoadBalancer
+from socketd.transport.client.ClientSession import ClientSession
+from socketd.transport.core.EntityMetas import EntityMetas
+from socketd.transport.core.Listener import Listener
+from socketd.transport.core.Message import Message
+from socketd.transport.core.Session import Session
+from socketd.transport.utils.StrUtil import StrUtil
+
+
+# 经纪人监听器基类（实现玩家封闭管理）
+class BrokerListenerBase(Listener, ABC):
+    def __init__(self):
+        self.__sessionAll: Dict[str, Session] = {}
+        self.__playerSessions: Dict[str, List[Session]] = {}
+
+    # 获取所有会话（包括没有名字的）
+    def get_session_all(self) -> List[Session]:
+        return list(self.__sessionAll.values())
+
+    # 获取任意会话（包括没有名字的）
+    def get_session_any(self) -> ClientSession:
+        return LoadBalancer.get_any(self.get_session_all(), LoadBalancer.round_counter_get())
+
+    # 获取会话数量
+    def get_session_count(self) -> int:
+        return len(self.__sessionAll)
+
+    # 获取所有玩家的名字
+    def get_name_all(self) -> List[str]:
+        return list(self.__sessionAll.keys())
+
+    # 获取所有玩家数量
+    def get_player_count(self, name: str) -> int:
+        return len(self.get_player_all(name))
+
+    # 获取所有玩家会话
+    def get_player_all(self, name: str) -> List[Session]:
+        return self.__playerSessions[name]
+
+    # 获取任意一个玩家会话
+    def get_player_any(self, atName: str, requester: Session | None, message: Message | None) -> ClientSession | None:
+        if StrUtil.is_empty(atName):
+            return None
+
+        if atName.endswith("!"):
+            atName = atName[:-1]
+            x_hash = None
+
+            if message is not None:
+                x_hash = message.meta(EntityMetas.META_X_Hash)
+
+            if StrUtil.is_empty(x_hash):
+                if requester is None:
+                    return LoadBalancer.get_any_by_poll(self.get_player_all(atName))
+                else: # 使用请求者 ip 分流
+                    return LoadBalancer.get_any_by_hash(self.get_player_all(atName), requester.remote_address())
+            else:
+                return LoadBalancer.get_any_by_hash(self.get_player_all(atName), x_hash)
+        else:
+            return LoadBalancer.get_any_by_poll(self.get_player_all(atName))
+
+    # 添加玩家会话
+    def add_player(self, name: str, session: Session):
+        if StrUtil.is_not_empty(name):
+            tmp: List[Session] = self.__playerSessions.get(name)
+            if tmp is None:
+                tmp = [session]
+                self.__playerSessions[name] = tmp
+            tmp.append(session)
+
+        self.__sessionAll[session.session_id()] = session
+
+    # 移除玩家会话
+    def remove_player(self, name: str, session: Session):
+        if StrUtil.is_not_empty(name):
+            tmp: list[Session] = self.get_player_all(name)
+            if tmp is not None:
+                tmp.remove(session)
+
+        self.__sessionAll.pop(session.session_id())

socket.d-2.4.10.1/socketd/cluster/ClusterClient.py

@@ -0,0 +1,75 @@
+import asyncio
+from typing import Optional, List, Awaitable, Any
+
+from socketd import SocketD
+from socketd.cluster.ClusterClientSession import ClusterClientSession
+from socketd.transport.client.Client import Client, ClientInternal
+from socketd.transport.client.ClientConfigHandler import ClientConfigHandler
+from socketd.transport.client.ClientConnectHandler import ClientConnectHandler
+from socketd.transport.client.ClientSession import ClientSession
+from socketd.transport.core import Listener
+from socketd.transport.core.Session import Session
+from socketd.transport.client.ClientHeartbeatHandler import ClientHeartbeatHandler
+
+
+class ClusterClient(Client):
+
+    def __init__(self, *serverUrls):
+        self.__serverUrls: Optional[tuple[Any, ...]] = serverUrls
+
+        self.__connectHandler: ClientConnectHandler = None
+        self.__heartbeatHandler: ClientHeartbeatHandler = None
+        self.__configHandler: ClientConfigHandler = None
+
+        self.__listener = None
+
+    def connect_handler(self, connectHandler: ClientConnectHandler)  -> Client:
+        self.__connectHandler = connectHandler
+        return self
+
+    def heartbeat_handler(self, heartbeatHandler: ClientHeartbeatHandler) -> Client:
+        self.__heartbeatHandler = heartbeatHandler
+        return self
+
+    def config(self, configHandler: ClientConfigHandler) -> Client:
+        self.__configHandler = configHandler
+        return self
+
+    def listen(self, listener: Listener) -> Client:
+        self.__listener = listener
+        return self
+
+    def open(self) -> Awaitable[ClientSession]:
+        return self._open_do(False)
+
+    def open_or_throw(self) -> Awaitable[ClientSession]:
+        return self._open_do(True)
+
+    async def _open_do(self, is_throw):
+        sessions: List[Session] = []
+        exchangeExecutor = None
+        for urls in self.__serverUrls:
+            for url in urls.split(","):
+                client: ClientInternal = SocketD.create_client(url)
+
+                if self.__listener:
+                    client.listen(self.__listener)
+
+                if self.__configHandler:
+                    client.config(self.__configHandler)
+
+                if self.__connectHandler:
+                    client.connect_handler(self.__connectHandler)
+
+                if self.__heartbeatHandler:
+                    client.heartbeat_handler(self.__heartbeatHandler)
+
+                if exchangeExecutor is None:
+                    exchangeExecutor = client.get_config().get_exchange_executor()
+                else:
+                    client.get_config().exchange_executor(exchangeExecutor)
+
+                sessions.extend(await asyncio.gather(*[client.open_or_throw() if is_throw else client.open()]))
+        return ClusterClientSession(sessions)
+
+

socket.d-2.4.10.1/socketd/cluster/ClusterClientSession.py

@@ -0,0 +1,80 @@
+from socketd.cluster.LoadBalancer import LoadBalancer
+from socketd.exception.SocketDExecption import SocketDException
+from socketd.transport.client.ClientSession import ClientSession
+from socketd.transport.core import Entity
+from socketd.transport.stream.RequestStream import RequestStream
+from socketd.transport.stream.SendStream import SendStream
+from socketd.transport.stream.SubscribeStream import SubscribeStream
+from socketd.transport.utils.StrUtil import StrUtil
+
+
+class ClusterClientSession(ClientSession):
+
+    def __init__(self, _sessionSet):
+        self.__sessionSet: list[ClientSession] = _sessionSet
+        self.__sessionId = StrUtil.guid()
+
+    def get_session_all(self) -> list[ClientSession]:
+        return self.__sessionSet
+
+    def get_session_any(self, diversionOrNull: str | None) -> ClientSession:
+        session: ClientSession
+
+        if diversionOrNull:
+            session = LoadBalancer.get_any_by_poll(self.__sessionSet)
+        else:
+            session = LoadBalancer.get_any_by_hash(self.__sessionSet, diversionOrNull)
+
+        if session:
+            return session
+        else:
+            raise SocketDException("No session is available!")
+
+    def is_valid(self) -> bool:
+        for session in self.__sessionSet:
+            if session.is_valid():
+                return True
+        return False
+
+    def is_closing(self) -> bool:
+        for session in self.__sessionSet:
+            if session.is_closing():
+                return True
+        return False
+
+    def session_id(self) -> str:
+        return self.__sessionId
+
+    async def send(self, event: str, content: Entity) -> SendStream:
+        sender = self.get_session_any(None)
+
+        return await sender.send(event, content)
+
+    async def send_and_request(self, event: str, content: Entity, timeout: int) -> RequestStream:
+        sender = self.get_session_any(None)
+
+        return await sender.send_and_request(event, content, timeout)
+
+    async def send_and_subscribe(self, event: str, content: Entity, timeout: int = 0) -> SubscribeStream:
+        sender = self.get_session_any(None)
+
+        return await sender.send_and_subscribe(event, content, timeout)
+
+    async def preclose(self):
+        for session in self.__sessionSet:
+            try:
+                await session.preclose()
+            except RuntimeError as e:
+                pass
+
+    async def close(self):
+        for session in self.__sessionSet:
+            try:
+                await session.close()
+            except RuntimeError as e:
+                pass
+
+    async def reconnect(self):
+        for session in self.__sessionSet:
+            if not session.is_valid():
+                await session.reconnect()

socket.d-2.4.10.1/socketd/cluster/LoadBalancer.py

@@ -0,0 +1,65 @@
+from threading import RLock
+from typing import List
+
+from socketd.transport.client.ClientSession import ClientSession
+from socketd.transport.utils.StrUtil import StrUtil
+
+
+class LoadBalancer:
+    __roundCounter: int = 0  # 轮环计数器
+    __lock: RLock = RLock()  # 计数锁
+
+    @staticmethod
+    def round_counter_get() -> int:
+        LoadBalancer.__lock.acquire()
+
+        try:
+            LoadBalancer.__roundCounter += 1
+            if LoadBalancer.__roundCounter > 999_999:
+                LoadBalancer.__roundCounter = 0
+            return LoadBalancer.__roundCounter
+        finally:
+            LoadBalancer.__lock.release()
+
+    # 根据 poll 获取任意一个
+    @staticmethod
+    def get_any_by_poll(coll: List[ClientSession]) -> ClientSession:
+        return LoadBalancer.get_any(coll, LoadBalancer.round_counter_get())
+
+    # 根据 hash 获取任意一个
+    @staticmethod
+    def get_any_by_hash(coll: List[ClientSession], diversion: str) -> ClientSession:
+        return LoadBalancer.get_any(coll, StrUtil.hash_code(diversion))
+
+    # 获取任意一个
+    @staticmethod
+    def get_any(coll: list[ClientSession], random: int) -> ClientSession | None:
+        if coll is None or coll.__len__() == 0:
+            return None
+        else:
+            sessions: List[ClientSession] = []
+            for s in coll:
+                if s.is_valid() and not s.is_closing():
+                    sessions.append(s)
+
+            if sessions.__len__() == 0:
+                return None
+
+            if sessions.__len__() == 1:
+                return sessions[0]
+
+            random = abs(random)
+            idx = random % sessions.__len__()
+            return sessions[idx]
+
+    # 获取第一个
+    @staticmethod
+    def get_first(coll: List[ClientSession]):
+        if coll is None or coll.__len__() == 0:
+            return None
+        else:
+            for s in coll:
+                if s.is_valid() and not s.is_closing():
+                    return s
+
+            return None

socket.d-2.4.10.1/socketd/exception/SocketDExecption.py

@@ -0,0 +1,38 @@
+class SocketDException(RuntimeError):
+
+    def __init__(self, message):
+        super().__init__(self)
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
+
+class SocketDAlarmException(SocketDException):
+    """ 告警"""
+    pass
+
+
+class SocketDChannelException(SocketDException):
+    """ 通道"""
+    pass
+
+
+class SocketDCodecException(SocketDException):
+    """ 编码"""
+    pass
+
+
+class SocketDConnectionException(SocketDException):
+    """连接"""
+    pass
+
+
+class SocketDSizeLimitException(SocketDException):
+    """ 超长"""
+    pass
+
+
+class SocketDTimeoutException(SocketDException):
+    """ 超时"""
+    pass