socket.d 2.5.8__tar.gz → 2.5.10__tar.gz

{socket.d-2.5.8 → socket.d-2.5.10}/PKG-INFO

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

{socket.d-2.5.8 → socket.d-2.5.10}/setup.py

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

{socket.d-2.5.8 → socket.d-2.5.10}/socket.d.egg-info/PKG-INFO

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

{socket.d-2.5.8 → socket.d-2.5.10}/socketd/SocketD.py

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

{socket.d-2.5.8 → socket.d-2.5.10}/socketd/transport/core/Config.py

@@ -132,7 +132,8 @@ class Config(ABC):
         ...
 
     @abstractmethod
-    def get_is_thread(self) -> bool: ...
+    def get_is_thread(self) -> bool:
+        ...
 
     @abstractmethod
     def get_max_udp_size(self) -> int:
@@ -140,3 +141,9 @@ class Config(ABC):
         返回允许的最大_uDP包大小。
         """
         ...
+
+    def is_use_subprotocols(self) -> bool:
+        """
+        是否使用子协议
+        """
+        ...

{socket.d-2.5.8 → socket.d-2.5.10}/socketd/transport/core/impl/ConfigBase.py

@@ -52,6 +52,7 @@ class ConfigBase(Config, ABC):
 
         self.__isThread = False
         self.__loggerLevel = "INFO"
+        self.__useSubprotocols = True;
 
     def __del__(self):
         if self._exchangeExecutor:
@@ -216,3 +217,10 @@ class ConfigBase(Config, ABC):
     def max_udp_size(self, maxUdpSize):
         self._maxUdpSize = maxUdpSize
         return self
+
+    def use_subprotocols(self, useSubprotocols):
+        self.__useSubprotocols = useSubprotocols
+        return self
+
+    def is_use_subprotocols(self) -> bool:
+        return self.__useSubprotocols

{socket.d-2.5.8 → socket.d-2.5.10}/socketd_websocket/WsAioClientConnector.py

@@ -40,17 +40,27 @@ class WsAioClientConnector(ClientConnectorBase):
         self._top = AsyncUtils.run_forever(self._loop, daemon=True)
 
         try:
-            self.__con: AIOConnect = AIOConnect(uri=ws_url,
-                                                client=self.client,
-                                                ssl=self.client.get_config().get_ssl_context(),
-                                                create_protocol=AIOWebSocketClientImpl,
-                                                subprotocols=[Subprotocol(SocketD.protocol_name())],
-                                                ping_timeout=self.client.get_config().get_idle_timeout() / 1000,
-                                                ping_interval=self.client.get_config().get_idle_timeout() / 1000,
-                                                logger=logger,
-                                                max_size=Constants.MAX_SIZE_FRAME,
-                                                message_loop=self._loop
-                                                )
+            if self.client.get_config().is_use_subprotocols():
+                self.__con: AIOConnect = AIOConnect(uri=ws_url,
+                                                    client=self.client,
+                                                    ssl=self.client.get_config().get_ssl_context(),
+                                                    create_protocol=AIOWebSocketClientImpl,
+                                                    subprotocols=[Subprotocol(SocketD.protocol_name())],
+                                                    ping_timeout=self.client.get_config().get_idle_timeout() / 1000,
+                                                    ping_interval=self.client.get_config().get_idle_timeout() / 1000,
+                                                    logger=logger,
+                                                    max_size=Constants.MAX_SIZE_FRAME,
+                                                    message_loop=self._loop)
+            else:
+                self.__con: AIOConnect = AIOConnect(uri=ws_url,
+                                                    client=self.client,
+                                                    ssl=self.client.get_config().get_ssl_context(),
+                                                    create_protocol=AIOWebSocketClientImpl,
+                                                    ping_timeout=self.client.get_config().get_idle_timeout() / 1000,
+                                                    ping_interval=self.client.get_config().get_idle_timeout() / 1000,
+                                                    logger=logger,
+                                                    max_size=Constants.MAX_SIZE_FRAME,
+                                                    message_loop=self._loop)
 
             self.__real: AIOWebSocketClientImpl | WebSocketClientProtocol = await self.__con
             handshakeResult: ClientHandshakeResult = await self.__real.handshake_future.get(self.client.get_config().get_connect_timeout() / 1000)

{socket.d-2.5.8 → socket.d-2.5.10}/socketd_websocket/WsAioServer.py

@@ -38,16 +38,14 @@ class WsAioServer(ServerBase):
         else:
             __host = self.get_config().get_host()
 
-        self._server = AIOServe(ws_handler=None,
-                           host=__host,
-                           port=self.get_config().get_port(),
-                           create_protocol=AIOWebSocketServerImpl,
-                           subprotocols=[Subprotocol(SocketD.protocol_name())],
-                           ws_aio_server=self,
-                           ssl=self.get_config().get_ssl_context(),
-                           logger=logger,
-                           max_size=Constants.MAX_SIZE_FRAME
-                           )
+        self._server = AIOServe(
+            host=__host,
+            port=self.get_config().get_port(),
+            create_protocol=AIOWebSocketServerImpl,
+            ws_aio_server=self,
+            ssl=self.get_config().get_ssl_context(),
+            logger=logger,
+            max_size=Constants.MAX_SIZE_FRAME)
 
         log.info("Socket.D server started: {server=" + self.get_config().get_local_url() + "}")
         await self._server

{socket.d-2.5.8 → socket.d-2.5.10}/socketd_websocket/impl/AIOServe.py

@@ -8,7 +8,6 @@ from wsgiref.headers import Headers
 from websockets import WebSocketServerProtocol, LoggerLike, Origin, Subprotocol
 from websockets.extensions import ServerExtensionFactory
 from websockets.extensions.permessage_deflate import enable_server_permessage_deflate
-from websockets.headers import validate_subprotocols
 from websockets.http import USER_AGENT
 from websockets import WebSocketServer
 from websockets.legacy.server import HeadersLikeOrCallable, HTTPResponse, remove_path_argument,serve
@@ -20,15 +19,11 @@ class AIOServe:
     辑
     """
 
-    def __init__(self, ws_handler: Union[
-        Callable[[WebSocketServerProtocol], Awaitable[Any]],
-        Callable[[WebSocketServerProtocol, str], Awaitable[Any]],
-    ], host: Optional[Union[str, Sequence[str]]] = None, port: Optional[int] = None, ws_aio_server=None, *,
+    def __init__(self, host: Optional[Union[str, Sequence[str]]] = None, port: Optional[int] = None, ws_aio_server=None, *,
                  create_protocol: Optional[Callable[..., WebSocketServerProtocol]] = None,
                  logger: Optional[LoggerLike] = None, compression: Optional[str] = "deflate",
                  origins: Optional[Sequence[Optional[Origin]]] = None,
                  extensions: Optional[Sequence[ServerExtensionFactory]] = None,
-                 subprotocols: Optional[Sequence[Subprotocol]] = None,
                  extra_headers: Optional[HeadersLikeOrCallable] = None, server_header: Optional[str] = USER_AGENT,
                  process_request: Optional[
                      Callable[[str, Headers], Awaitable[Optional[HTTPResponse]]]
@@ -72,16 +67,12 @@ class AIOServe:
         elif compression is not None:
             raise ValueError(f"unsupported compression: {compression}")
 
-        if subprotocols is not None:
-            validate_subprotocols(subprotocols)
-
         # 自定义protocol
         factory = functools.partial(
             create_protocol,
             # For backwards compatibility with 10.0 or earlier. Done here in
             # addition to WebSocketServerProtocol to trigger the deprecation
             # warning once per serve() call rather than once per connection.
-            remove_path_argument(ws_handler),
             ws_server,
             host=host,
             port=port,
@@ -99,7 +90,6 @@ class AIOServe:
             legacy_recv=legacy_recv,
             origins=origins,
             extensions=extensions,
-            subprotocols=subprotocols,
             extra_headers=extra_headers,
             server_header=server_header,
             process_request=process_request,

{socket.d-2.5.8 → socket.d-2.5.10}/socketd_websocket/impl/AIOWebSocketServerImpl.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 import asyncio
-from typing import Optional, Union
+from typing import Optional, Union, Sequence
 
-from websockets import ConnectionClosedOK, ConnectionClosedError, ConnectionClosed
-from websockets.frames import Opcode
+from websockets import ConnectionClosedOK, ConnectionClosedError, Subprotocol, Headers, InvalidOrigin
 from websockets.server import WebSocketServer, WebSocketServerProtocol
 
+from socketd import SocketD
 from socketd.transport.core.Channel import Channel
 from socketd.transport.core.ChannelInternal import ChannelInternal
 from socketd.utils.LogConfig import log
@@ -16,7 +16,7 @@ from socketd.transport.core.Frame import Frame
 
 class AIOWebSocketServerImpl(WebSocketServerProtocol):
 
-    def __init__(self, ws_handler, ws_server: WebSocketServer, ws_aio_server: 'WsAioServer',
+    def __init__(self, ws_server: WebSocketServer, ws_aio_server: 'WsAioServer',
                  *args, **kwargs):
         self.ws_aio_server = ws_aio_server
         self.__ws_server: WebSocketServer = ws_server
@@ -27,6 +27,23 @@ class AIOWebSocketServerImpl(WebSocketServerProtocol):
                                          *args,
                                          **kwargs)
 
+    def process_subprotocol(self, headers: Headers, available_subprotocols: Optional[Sequence[Subprotocol]]) \
+            -> Optional[Subprotocol]:
+        header_values = headers.get_all("Sec-WebSocket-Protocol")
+
+        if self.ws_aio_server.get_config().is_use_subprotocols():
+            # 开启子协议验证的时候，如果不匹配则拒绝握手
+            if bool(header_values) and header_values.__contains__(SocketD.protocol_name()):
+                return Subprotocol(SocketD.protocol_name())
+            else:
+                raise InvalidOrigin("No subprotocols supported")
+        else:
+            if bool(header_values) and header_values.__contains__(SocketD.protocol_name()):
+                return Subprotocol(SocketD.protocol_name())
+
+        return super().process_subprotocol(headers, available_subprotocols)
+
+
     def set_attachment(self, obj: ChannelInternal):
         self.__attachment = obj
 
@@ -38,12 +55,10 @@ class AIOWebSocketServerImpl(WebSocketServerProtocol):
         super().connection_open()
         self.on_open(self)
 
-    async def read_frame(self, max_size: Optional[int]) -> Frame:
-        frame = await super().read_frame(max_size)
-        if frame is not None:
-            if frame.opcode == Opcode.PONG:
-                await self.assert_handshake()
-        return frame
+    async def keepalive_ping(self) -> None:
+        await asyncio.sleep(self.ping_interval)
+        if await self.assert_handshake():
+            return await super().keepalive_ping()
 
     def on_open(self, conn) -> None:
         """create_protocol"""