GNServer 0.0.0.0.17__tar.gz → 0.0.0.0.18__tar.gz

gnserver-0.0.0.0.17/GNServer/GNServer/_client.py → gnserver-0.0.0.0.18/GNServer/GNServer/___client.py

@@ -9,7 +9,7 @@ import datetime
 logging2.basicConfig(level=logging2.INFO)
 
 from KeyisBLogging import logging
-from typing import Dict, List, Tuple, Optional, cast, AsyncGenerator, Callable
+from typing import Dict, List, Tuple, Optional, cast, AsyncGenerator, Callable, Literal
 from itertools import count
 from aioquic.asyncio.client import connect
 from aioquic.asyncio.protocol import QuicConnectionProtocol
@@ -101,13 +101,11 @@ class AsyncClient:
         self.__request_callbacks = {}
         self.__response_callbacks = {}
 
-        self._client: QuicClient = QuicClient()
-
-        self._active_connections: Dict[str, Any] = {}
+        self._active_connections: Dict[str, QuicClient] = {}
 
     async def _getCoreDNS(self, domain: str):
 
-        if domain.split('.')[-1].isdigit() and domain.split(':')[-1].isdigit():
+        if domain.split('.')[-1].split(':')[0].isdigit() and domain.split(':')[-1].isdigit():
             r2_data = {
                 "ip": domain.split(':')[0],
                 "port": int(domain.split(':')[-1])
@@ -143,53 +141,66 @@ class AsyncClient:
         self.__response_callbacks[name] = callback
 
   
-    async def connect(self, domain: str):
-        if domain in self._active_connections:
-            return
+    async def connect(self, domain: str, restart_connection: bool = False, reconnect_wait: float = 10) -> 'QuicClient':
+        print('Запрос подключения')
+        if not restart_connection and domain in self._active_connections:
+            print('Подключение уже было')
+            c = self._active_connections[domain]
+            if c.status == 'connecting':
+                if (c.connection_time + datetime.timedelta(seconds=11)) < datetime.datetime.now():
+                    print('ждем поделючения')
+                    try:
+                        await asyncio.wait_for(c.connect_future, reconnect_wait)
+                        print('дождались')
+                        return c
+                    except:
+                        print('Заново соеденяемся...')
+                        
+            else:
+                return c
+
+        c = QuicClient()
+        c.status = 'connecting'
+        self._active_connections[domain] = c
 
         data = await self._getCoreDNS(domain)
-        # подключаемся к серверу gn-proxy
-        await self._client.connect(data['ip'], data['port'])
-        self._active_connections[domain] = 'active'
 
-    async def disconnect(self):
-        await self._client.disconnect()
 
 
-    def _return_token(self, bigToken: str, s: bool = True) -> str:
-        return bigToken[:128] if s else bigToken[128:]
+        def f(domain):
+            self._active_connections.pop(domain)
 
+        c._disconnect_signal = f
+        c._domain = domain
 
-    async def request(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]]) -> GNResponse:
-        """
-        Build and send a async request.
-        
-        ```python
-        gnAsyncClient = KeyisBClient.AsyncClient()
-        async def func():
-            response = await gnAsyncClient.request(GNRequest('GET', Url('gn://example.com/example')))
-            command = response.command()
-            data = response.payload()
-        ```
-        """
+        await c.connect(data['ip'], data['port'])
+        await c.connect_future
 
+        return c
 
+    async def disconnect(self, domain):
+        if domain not in self._active_connections:
+            return
+        
+        await self._active_connections[domain].disconnect()
 
 
+    def _return_token(self, bigToken: str, s: bool = True) -> str:
+        return bigToken[:128] if s else bigToken[128:]
 
 
+    async def request(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]], restart_connection: bool = False, reconnect_wait: float = 10) -> GNResponse:
         if isinstance(request, GNRequest):
             
 
-            if request.url.hostname not in self._active_connections:
-                await self.connect(request.url.hostname)
+            c = await self.connect(request.url.hostname, restart_connection, reconnect_wait)
                 
 
 
             for f in self.__request_callbacks.values():
                 asyncio.create_task(f(request))
 
-            r = await self._client.asyncRequest(request)
+            r = await c.asyncRequest(request)
 
             for f in self.__response_callbacks.values():
                 asyncio.create_task(f(r))
@@ -249,16 +260,6 @@ class AsyncClient:
 
                 yield response
 
-
-
-
-
-
-
-
-
-# gn:quik
-
 from aioquic.asyncio.protocol import QuicConnectionProtocol
 from aioquic.quic.events import QuicEvent, StreamDataReceived, StreamReset
 from aioquic.quic.connection import END_STATES
@@ -266,18 +267,6 @@ import asyncio
 from collections import deque
 from typing import Dict, Deque, Tuple, Optional, List
 
-# ---------------------------------------------------------------------------
-#  Raw QUIC client with a dedicated SYS‑stream that consumes ~90 % CWND
-# ---------------------------------------------------------------------------
-#  Основная идея:
-#  • Один постоянный bidirectional stream (sys_stream_id) используется для 
-#    служебных сообщений.
-#  • Остальные запросы открываются в обычных потоках (user streams).
-#  • Отправка данных идёт через собственный scheduler: берём 9 «квантов» из
-#    SYS‑очереди и 1 квант из USER‑очереди, пока есть SYS‑данные.
-#  • Таким образом SYS‑канал получает ~90 % пропускной способности.
-# ---------------------------------------------------------------------------
-
 import asyncio
 import time
 from collections import deque
@@ -286,11 +275,10 @@ from itertools import count
 from typing import Deque, Dict, Optional, Tuple, Union
 
 from aioquic.quic.configuration import QuicConfiguration
-from aioquic.quic.events import QuicEvent, StreamDataReceived, StreamReset
+from aioquic.quic.events import QuicEvent, StreamDataReceived, StreamReset, ConnectionTerminated
 
 
 class RawQuicClient(QuicConnectionProtocol):
-    """Чистый‑QUIC клиент с приоритизированным SYS‑каналом + стриминг."""
 
     SYS_RATIO_NUM = 9  # SYS 9/10
     SYS_RATIO_DEN = 10
@@ -301,6 +289,8 @@ class RawQuicClient(QuicConnectionProtocol):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+        self.quicClient: QuicClient = None
+
         self._sys_stream_id: Optional[int] = None
         self._queue_sys: Deque[Tuple[int, bytes, bool]] = deque()
         self._queue_user: Deque[Tuple[int, bytes, bool]] = deque()
@@ -427,6 +417,17 @@ class RawQuicClient(QuicConnectionProtocol):
                 if not handler.done():
                     handler.set_exception(RuntimeError("stream reset"))
 
+
+        elif isinstance(event, ConnectionTerminated):
+            print("QUIC connection closed")
+            print("Error code:", event.error_code)
+            print("Reason:", event.reason_phrase)
+            if self.quicClient is None:
+                return
+            
+            asyncio.create_task(self.quicClient.disconnect())
+
+
     # ─────────────────────────────────────────── scheduler ─┤
     def _enqueue(self, sid: int, blob: bytes, end_stream: bool, is_sys: bool):
         (self._queue_sys if is_sys else self._queue_user).append((sid, blob, end_stream))
@@ -443,6 +444,7 @@ class RawQuicClient(QuicConnectionProtocol):
             if q is None:
                 break
             sid, blob, end_stream = q.popleft()
+            print(f'Отправка стрима {sid}')
             self._quic.send_stream_data(sid, blob, end_stream=end_stream)
         self.transmit()
         self._activity()
@@ -563,10 +565,20 @@ class QuicClient:
     def __init__(self):
         self._quik_core: Optional[RawQuicClient] = None
         self._client_cm = None
+        self._disconnect_signal = None
+        self._domain = None
+
+        self.status: Literal['active', 'connecting', 'disconnect']
+
+        self.connect_future = asyncio.get_event_loop().create_future()
+        self.connection_time: datetime.datetime = None
 
     async def connect(self, ip: str, port: int):
+        self.status = 'connecting'
+        self.connection_time = datetime.datetime.now()
         cfg = QuicConfiguration(is_client=True, alpn_protocols=["gn:backend"])
         cfg.load_verify_locations(KeyisBClient.ssl_gw_crt_path)
+        cfg.idle_timeout = 10
 
         self._client_cm = connect(
             ip,
@@ -576,8 +588,16 @@ class QuicClient:
             wait_connected=True,
         )
         self._quik_core = await self._client_cm.__aenter__()
+        self._quik_core.quicClient = self
+
+        self.status = 'active'
+        self.connect_future.set_result(True)
 
     async def disconnect(self):
+        self.status = 'disconnect'
+        if self._disconnect_signal is not None:
+            self._disconnect_signal(self._domain)
+        
         self._quik_core.close()
         await self._quik_core.wait_closed()
         self._quik_core = None

{gnserver-0.0.0.0.17 → gnserver-0.0.0.0.18}/GNServer/GNServer/_app.py

@@ -290,6 +290,7 @@ def _host_matches_pattern(host: str, pattern: str) -> bool:
 
 
 
+
 @dataclass
 class Route:
     method: str
@@ -367,6 +368,15 @@ def _convert_value(raw: str | list[str], ann: Any, fallback: Callable[[str], Any
             raw = [raw]
         return [_convert_value(r, subtype, fallback) for r in raw]
 
+    # --- fix Union ---
+    if origin is Union:
+        for subtype in args:
+            try:
+                return _convert_value(raw, subtype, fallback)
+            except Exception:
+                continue
+        return raw  # если ни один тип не подошёл
+
     conv = _CONVERTER_FUNC.get(ann, ann) if ann is not inspect._empty else fallback
     return conv(raw) if callable(conv) else raw
 
@@ -436,7 +446,7 @@ class App:
             if r.method != method:
                 continue
 
-            if r.cors is not None:
+            if r.cors is not None and r.cors._allow_origins is not None:
                 if request._origin is None:
                     return gn.GNResponse("gn:backend:801", {'error': 'Cors error. Route has cors but request has no origin url.'})
                 if not resolve_cors(request._origin, r.cors._allow_origins):
@@ -468,11 +478,16 @@ class App:
 
             result = await r.handler(**kw)
             if isinstance(result, gn.GNResponse):
-                if result._cors is None:
-                    result._cors = self._cors
-                if result._cors is not None and result._cors != r.cors:
+                if r.cors is None:
+                    if result._cors is None:
+                        result._cors = self._cors
+                else:
+                    result._cors = r.cors
+
+                if result._cors is not None and result._cors != r.cors and result._cors._allow_origins is not None:
                     if request._origin is None:
-                        return gn.GNResponse("gn:backend:801", {'error': 'Cors error. Route has cors but request has no origin url.'})
+                        print(result._cors._allow_origins)
+                        return gn.GNResponse("gn:backend:801", {'error': 'Cors error. Route has cors but request has no origin url. [2]'})
                     if not resolve_cors(request._origin, result._cors._allow_origins):
                         return gn.GNResponse("gn:backend:802", {'error': 'Cors error: origin'})
                     if request.method not in result._cors._allow_methods and '*' not in result._cors._allow_methods:
@@ -520,9 +535,10 @@ class App:
 
 
     def _init_sys_routes(self):
-        @self.get('/!gn-vm-host/ping')
+        @self.post('/!gn-vm-host/ping', cors=gn.CORSObject(None))
         async def r_ping(request: gn.GNRequest):
-            if request.client_ip != '127.0.0.1':
+            
+            if request._client_ip != '127.0.0.1':
                 return gn.GNResponse('gn:backend:403', {'error': 'Forbidden'})
             return gn.GNResponse('ok', {'time': datetime.datetime.now(datetime.UTC).isoformat()})
 
@@ -622,7 +638,7 @@ class App:
                     asyncio.create_task(self._handle_request(request, mode))
 
         async def _handle_request(self, request: gn.GNRequest, mode: int):
-            
+
             request._client_ip = self._quic._network_paths[0].addr[0]
 
             try:
@@ -673,7 +689,8 @@ class App:
         key_path: str,
         *,
         idle_timeout: float = 20.0,
-        wait: bool = True
+        wait: bool = True,
+        run: Optional[Callable] = None
     ):
 
         self._init_sys_routes()
@@ -691,6 +708,11 @@ class App:
                 create_protocol=lambda *a, **kw: App._ServerProto(*a, api=self, **kw),
                 retry=False,
             )
+            
+            if run is not None:
+                await run()
+
+
             if wait:
                 await asyncio.Event().wait()
 

gnserver-0.0.0.0.18/GNServer/GNServer/_client.py

@@ -0,0 +1,673 @@
+
+import os
+import httpx
+import asyncio
+import typing as _typing
+import logging as logging2
+from typing import Union, List, Dict, Tuple, Optional
+import datetime
+logging2.basicConfig(level=logging2.INFO)
+
+from KeyisBLogging import logging
+from typing import Dict, List, Tuple, Optional, cast, AsyncGenerator, Callable, Literal
+from itertools import count
+from aioquic.asyncio.client import connect
+from aioquic.asyncio.protocol import QuicConnectionProtocol
+from aioquic.h3.connection import H3_ALPN, H3Connection
+from aioquic.h3.events import DataReceived, DatagramReceived, H3Event, HeadersReceived
+from aioquic.quic.configuration import QuicConfiguration
+from aioquic.quic.events import QuicEvent
+
+
+import time
+import json, ssl, asyncio, struct, base64, hashlib
+from typing import Any, Dict, Optional
+import websockets
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+import os
+import msgpack
+import logging
+from httpx import Request, Headers, URL
+logging.basicConfig(level=logging.DEBUG)
+logging.getLogger("websockets").setLevel(logging.DEBUG)
+
+import KeyisBClient
+from KeyisBClient import Url
+httpxAsyncClient = httpx.AsyncClient(verify=KeyisBClient.ssl_gw_crt_path, timeout=200)
+
+class GNExceptions:
+    class ConnectionError:
+        class openconnector():
+            """Ошибка подключения к серверу openconnector.gn"""
+            
+            class connection(Exception):
+                def __init__(self, message="Ошибка подключения к серверу openconnector.gn. Сервер не найден."):
+                    super().__init__(message)
+
+            class timeout(Exception):
+                def __init__(self, message="Ошибка подключения к серверу openconnector.gn. Проблема с сетью или сервер перегружен."):
+                    super().__init__(message)
+
+            class data(Exception):
+                def __init__(self, message="Ошибка подключения к серверу openconnector.gn. Сервер не подтвердил подключение."):
+                    super().__init__(message)
+
+        class dns_core():
+            """Ошибка подключения к серверу dns.core"""
+            class connection(Exception):
+                def __init__(self, message="Ошибка подключения к серверу dns.core Сервер не найден."):
+                    super().__init__(message)
+
+            class timeout(Exception):
+                def __init__(self, message="Ошибка подключения к серверу dns.core Проблема с сетью или сервер перегружен"):
+                    super().__init__(message)
+    
+            class data(Exception):
+                def __init__(self, message="Ошибка подключения к серверу dns.core Сервер не подтвердил подключение."):
+                    super().__init__(message)
+
+        class connector():
+            """Ошибка подключения к серверу <?>~connector.gn"""
+            
+            class connection(Exception):
+                def __init__(self, message="Ошибка подключения к серверу <?>~connector.gn. Сервер не найден."):
+                    super().__init__(message)
+
+            class timeout(Exception):
+                def __init__(self, message="Ошибка подключения к серверу <?>~connector.gn. Проблема с сетью или сервер перегружен"):
+                    super().__init__(message)
+    
+            class data(Exception):
+                def __init__(self, message="Ошибка подключения к серверу <?>~connector.gn. Сервер не подтвердил подключение."):
+                    super().__init__(message)
+
+        class client():
+            """Ошибка клиента"""
+            
+            class connection(Exception):
+                def __init__(self, message="Ошибка подключения к серверу. Сервер не найден."):
+                    super().__init__(message)
+
+            class timeout(Exception):
+                def __init__(self, message="Ошибка подключения к серверу. Проблема с сетью или сервер перегружен"):
+                    super().__init__(message)
+    
+            class data(Exception):
+                def __init__(self, message="Ошибка подключения к серверу. Сервер не подтвердил подключение."):
+                    super().__init__(message)
+                    
+
+
+
+from KeyisBClient.gn import GNRequest, GNResponse, GNProtocol
+
+
+
+
+class AsyncClient:
+    def __init__(self):
+        self.__dns_core__ipv4 = '51.250.85.38:52943'
+        self.__dns_gn__ipv4 = None
+
+        self.__user = {}
+        self.__current_session = {}
+        self.__request_callbacks = {}
+        self.__response_callbacks = {}
+
+        self._active_connections: Dict[str, QuicClient] = {}
+
+    async def _getCoreDNS(self, domain: str):
+
+        if domain.split('.')[-1].split(':')[0].isdigit() and domain.split(':')[-1].isdigit():
+            r2_data = {
+                "ip": domain.split(':')[0],
+                "port": int(domain.split(':')[-1])
+            }
+            return r2_data
+
+        try:
+            if self.__dns_gn__ipv4 is None:
+                r1 = await httpxAsyncClient.request('GET', f'https://{self.__dns_core__ipv4}/gn/getIp?d=dns.gn')
+                if r1.status_code != 200:
+                    raise GNExceptions.ConnectionError.dns_core.data
+                r1_data = r1.json()
+                self.__dns_gn__ipv4 = r1_data['ip'] + ':' + str(r1_data['port'])
+
+
+            r2 = await httpxAsyncClient.request('GET', f'https://{self.__dns_gn__ipv4}/gn/getIp?d={domain}')
+        except httpx.TimeoutException:
+            raise GNExceptions.ConnectionError.dns_core.timeout
+        except:
+            raise GNExceptions.ConnectionError.dns_core.connection
+
+        if r2.status_code != 200:
+            raise GNExceptions.ConnectionError.dns_core.data
+
+        r2_data = r2.json()
+
+        return r2_data
+
+    def addRequestCallback(self, callback: Callable, name: str):
+        self.__request_callbacks[name] = callback
+
+    def addResponseCallback(self, callback: Callable, name: str):
+        self.__response_callbacks[name] = callback
+
+  
+    async def connect(self, domain: str, restart_connection: bool = False, reconnect_wait: float = 10) -> 'QuicClient':
+        print('Запрос подключения')
+        if not restart_connection and domain in self._active_connections:
+            c = self._active_connections[domain]
+            print(f'Подключение уже было [{c.status}]')
+            if c.status == 'connecting':
+                print('ждем поделючения')
+                try:
+                    await asyncio.wait_for(c.connect_future, reconnect_wait)
+                    print('дождались')
+                    if c.status == 'active':
+                        return c
+                    elif c.status == 'connecting': # если очень дого подключаемся, то кидаем ошибку
+                        await self.disconnect(domain)
+                        raise GNExceptions.ConnectionError.client.timeout
+                    elif c.status == 'disconnect':
+                        raise GNExceptions.ConnectionError.client.connection
+                except:
+                    print('Заново соеденяемся...')
+                    await self.disconnect(domain)
+                        
+            else:
+                return c
+
+        c = QuicClient()
+        c.status = 'connecting'
+        self._active_connections[domain] = c
+
+        data = await self._getCoreDNS(domain)
+
+
+
+        def f(domain):
+            self._active_connections.pop(domain)
+
+        c._disconnect_signal = f
+        c._domain = domain
+
+        await c.connect(data['ip'], data['port'])
+        await c.connect_future
+
+        return c
+
+    async def disconnect(self, domain):
+        if domain not in self._active_connections:
+            return
+        
+        await self._active_connections[domain].disconnect()
+
+
+    def _return_token(self, bigToken: str, s: bool = True) -> str:
+        return bigToken[:128] if s else bigToken[128:]
+
+
+    async def request(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]], restart_connection: bool = False, reconnect_wait: float = 10) -> GNResponse:
+        if isinstance(request, GNRequest):
+            
+
+            c = await self.connect(request.url.hostname, restart_connection, reconnect_wait)
+                
+
+
+            for f in self.__request_callbacks.values():
+                asyncio.create_task(f(request))
+
+            r = await c.asyncRequest(request)
+
+            for f in self.__response_callbacks.values():
+                asyncio.create_task(f(r))
+
+            return r
+        
+        # else:
+        #     async def wrapped(request) -> AsyncGenerator[GNRequest, None]:
+        #         async for req in request:
+        #             if req.gn_protocol is None:
+        #                 req.setGNProtocol(self.__current_session['protocols'][0])
+        #             req._stream = True
+                    
+        #             for f in self.__request_callbacks.values():
+        #                 asyncio.create_task(f(req))
+                        
+        #             yield req
+        #     r = await self.client.asyncRequest(wrapped(request))
+        
+        #     for f in self.__response_callbacks.values():
+        #         asyncio.create_task(f(r))
+                
+        #     return r
+
+    async def requestStream(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]]) -> AsyncGenerator[GNResponse, None]:
+        """
+        Build and send a async request.
+        """
+        if isinstance(request, GNRequest):
+            if request.gn_protocol is None:
+                request.setGNProtocol(self.__current_session['protocols'][0])
+                
+            for f in self.__request_callbacks.values():
+                asyncio.create_task(f(request))
+
+            async for response in self.client.asyncRequestStream(request):
+                    
+                for f in self.__response_callbacks.values():
+                    asyncio.create_task(f(response))
+
+                yield response
+        else:
+            async def wrapped(request) -> AsyncGenerator[GNRequest, None]:
+                async for req in request:
+                    if req.gn_protocol is None:
+                        req.setGNProtocol(self.__current_session['protocols'][0])
+                            
+                    for f in self.__request_callbacks.values():
+                        asyncio.create_task(f(req))
+                        
+                    req._stream = True
+                    yield req
+            async for response in self.client.asyncRequestStream(wrapped(request)):
+                
+                for f in self.__response_callbacks.values():
+                    asyncio.create_task(f(response))
+
+                yield response
+
+from aioquic.asyncio.protocol import QuicConnectionProtocol
+from aioquic.quic.events import QuicEvent, StreamDataReceived, StreamReset
+from aioquic.quic.connection import END_STATES
+import asyncio
+from collections import deque
+from typing import Dict, Deque, Tuple, Optional, List
+
+import asyncio
+import time
+from collections import deque
+from dataclasses import dataclass
+from itertools import count
+from typing import Deque, Dict, Optional, Tuple, Union
+
+from aioquic.quic.configuration import QuicConfiguration
+from aioquic.quic.events import QuicEvent, StreamDataReceived, StreamReset, ConnectionTerminated
+
+
+class RawQuicClient(QuicConnectionProtocol):
+
+    SYS_RATIO_NUM = 9  # SYS 9/10
+    SYS_RATIO_DEN = 10
+    KEEPALIVE_INTERVAL = 10  # сек
+    KEEPALIVE_IDLE_TRIGGER = 30  # сек
+
+    # ────────────────────────────────────────────────────────────────── init ─┐
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.quicClient: QuicClient = None
+
+        self._sys_stream_id: Optional[int] = None
+        self._queue_sys: Deque[Tuple[int, bytes, bool]] = deque()
+        self._queue_user: Deque[Tuple[int, bytes, bool]] = deque()
+
+        # <‑‑ Future | Queue[bytes | None]
+        self._inflight: Dict[int, Union[asyncio.Future, asyncio.Queue[Optional[GNResponse]]]] = {}
+        self._inflight_streams: Dict[int, bytearray] = {}
+        self._sys_inflight: Dict[int, asyncio.Future] = {}
+        self._buffer: Dict[Union[int, str], bytearray] = {}
+
+        self._sys_budget = self.SYS_RATIO_NUM
+        self._sys_id_gen = count(1)  # int64 message‑id generator
+
+        self._last_activity = time.time()
+        self._running = True
+        self._ping_id_gen = count(1)  # int64 ping‑id generator
+        asyncio.create_task(self._keepalive_loop())
+
+    # ───────────────────────────────────────── private helpers ─┤
+    def _activity(self):
+        self._last_activity = time.time()
+
+    async def _keepalive_loop(self):
+        while self._running:
+            await asyncio.sleep(self.KEEPALIVE_INTERVAL)
+            idle_time = time.time() - self._last_activity
+            if idle_time > self.KEEPALIVE_IDLE_TRIGGER:
+                self._quic.send_ping(next(self._ping_id_gen))
+                self.transmit()
+                self._last_activity = time.time()
+
+    def stop(self):
+        self._running = False
+
+    # ───────────────────────────────────────────── events ─┤
+    def quic_event_received(self, event: QuicEvent) -> None:  # noqa: C901
+        # ─── DATA ───────────────────────────────────────────
+        if isinstance(event, StreamDataReceived):
+            #print(event)
+            # SYS поток
+            if event.stream_id == self._sys_stream_id:
+                buf = self._buffer.setdefault("sys", bytearray())
+                buf.extend(event.data)
+                while True:
+                    if len(buf) < 12:
+                        break
+                    msg_id = int.from_bytes(buf[:8], "little")
+                    size = int.from_bytes(buf[8:12], "little")
+                    if len(buf) < 12 + size:
+                        break
+                    payload = bytes(buf[12 : 12 + size])
+                    del buf[: 12 + size]
+                    fut = self._sys_inflight.pop(msg_id, None) if msg_id else None
+                    if fut and not fut.done():
+                        fut.set_result(payload)
+            # USER поток
+            else:
+                handler = self._inflight.get(event.stream_id)
+                if handler is None:
+                    return
+                
+                # Чтение в зависимости от режима
+                if isinstance(handler, asyncio.Queue): # стрим от сервера
+                    # получаем байты
+
+                    buf = self._buffer.setdefault(event.stream_id, bytearray())
+                    buf.extend(event.data)
+
+                    if len(buf) < 8: # не дошел даже frame пакета
+                        return
+                    
+                    # получаем длинну пакета
+                    mode, stream, lenght = GNResponse.type(buf)
+
+                    if mode != 4: # не наш пакет
+                        self._buffer.pop(event.stream_id)
+                        return
+                    
+                    if not stream: # клиент просил стрим, а сервер прислал один пакет
+                        self._buffer.pop(event.stream_id)
+                        return
+                    
+                    # читаем пакет
+                    if len(buf) < lenght: # если пакет не весь пришел, пропускаем
+                        return
+                    
+                    # пакет пришел весь
+
+                    # берем пакет
+                    data = buf[:lenght]
+
+                    # удаляем его из буфера
+                    del buf[:lenght]
+                        
+                    
+                    r = GNResponse.deserialize(data, 2)
+                    handler.put_nowait(r)
+                    if event.end_stream:
+                        handler.put_nowait(None)
+                        self._buffer.pop(event.stream_id)
+                        self._inflight.pop(event.stream_id, None)
+
+
+
+                else:  # Future
+                    buf = self._buffer.setdefault(event.stream_id, bytearray())
+                    buf.extend(event.data)
+                    if event.end_stream:
+                        self._inflight.pop(event.stream_id, None)
+                        data = bytes(self._buffer.pop(event.stream_id, b""))
+                        if not handler.done():
+                            handler.set_result(data)
+
+        # ─── RESET ──────────────────────────────────────────
+        elif isinstance(event, StreamReset):
+            handler = self._inflight.pop(event.stream_id, None) or self._sys_inflight.pop(
+                event.stream_id, None
+            )
+            if handler is None:
+                return
+            if isinstance(handler, asyncio.Queue):
+                handler.put_nowait(None)
+            else:
+                if not handler.done():
+                    handler.set_exception(RuntimeError("stream reset"))
+
+
+        elif isinstance(event, ConnectionTerminated):
+            print("QUIC connection closed")
+            print("Error code:", event.error_code)
+            print("Reason:", event.reason_phrase)
+            if self.quicClient is None:
+                return
+            
+            asyncio.create_task(self.quicClient.disconnect())
+
+
+    # ─────────────────────────────────────────── scheduler ─┤
+    def _enqueue(self, sid: int, blob: bytes, end_stream: bool, is_sys: bool):
+        (self._queue_sys if is_sys else self._queue_user).append((sid, blob, end_stream))
+
+    def _schedule_flush(self):
+        while (self._queue_sys or self._queue_user) and self._quic._close_event is None:
+            q = None
+            if self._queue_sys and (self._sys_budget > 0 or not self._queue_user):
+                q = self._queue_sys
+                self._sys_budget -= 1
+            elif self._queue_user:
+                q = self._queue_user
+                self._sys_budget = self.SYS_RATIO_NUM
+            if q is None:
+                break
+            sid, blob, end_stream = q.popleft()
+            print(f'Отправка стрима {sid}')
+            self._quic.send_stream_data(sid, blob, end_stream=end_stream)
+        self.transmit()
+        self._activity()
+
+    # ─────────────────────────────────────────── public API ─┤
+    async def ensure_sys_stream(self):
+        if self._sys_stream_id is None:
+            self._sys_stream_id = self._quic.get_next_available_stream_id()
+            self._enqueue(self._sys_stream_id, b"", False, True)  # dummy
+            self._schedule_flush()
+
+    async def send_sys(self, request: GNRequest, response: bool = False) -> Optional[bytes]:
+        await self.ensure_sys_stream()
+        if response:
+            msg_id = next(self._sys_id_gen)
+            blob = request.serialize(2)
+            payload = (
+                msg_id.to_bytes(8, "little") + len(blob).to_bytes(4, "little") + blob
+            )
+            fut = asyncio.get_running_loop().create_future()
+            self._sys_inflight[msg_id] = fut
+            self._enqueue(self._sys_stream_id, payload, False, True)
+            self._schedule_flush()
+            return await fut
+        payload = (0).to_bytes(8, "little") + request.serialize(2)
+        self._enqueue(self._sys_stream_id, payload, False, True)
+        self._schedule_flush()
+        return None
+
+    async def request(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]]):
+        if isinstance(request, GNRequest):
+            blob = request.serialize(2)
+            sid = self._quic.get_next_available_stream_id()
+            self._enqueue(sid, blob, True, False)
+            self._schedule_flush()
+
+            
+            fut = asyncio.get_running_loop().create_future()
+            self._inflight[sid] = fut
+            return await fut
+        
+        else:
+            sid = self._quic.get_next_available_stream_id()
+            #if sid in self._quic._streams and not self._quic._streams[sid].is_finished:
+
+            async def _stream_sender(sid, request: AsyncGenerator[GNRequest, Any]):
+                _last = None
+                async for req in request:
+                    _last = req
+                    blob = req.serialize(2)
+                    self._enqueue(sid, blob, False, False)
+
+
+                    self._schedule_flush()
+
+                    print(f'Отправлен stream запрос {req}')
+                
+
+                _last.setPayload(None)
+                _last.setMethod('gn:end-stream')
+                blob = _last.serialize(2)
+                self._enqueue(sid, blob, True, False)
+                self._schedule_flush()
+            
+            asyncio.create_task(_stream_sender(sid, request))
+
+                
+            fut = asyncio.get_running_loop().create_future()
+            self._inflight[sid] = fut
+            return await fut
+    
+    async def requestStream(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]]) -> asyncio.Queue[GNResponse]:
+        if isinstance(request, GNRequest):
+            blob = request.serialize(2)
+            sid = self._quic.get_next_available_stream_id()
+            self._enqueue(sid, blob, False, False)
+            self._schedule_flush()
+
+            
+            q = asyncio.Queue()
+            self._inflight[sid] = q
+            return q
+            
+        else:
+            sid = self._quic.get_next_available_stream_id()
+
+            async def _stream_sender(sid, request: AsyncGenerator[GNRequest, Any]):
+                _last = None
+                async for req in request:
+                    _last = req
+                    blob = req.serialize(2)
+                    self._enqueue(sid, blob, False, False)
+
+
+                    self._schedule_flush()
+
+                    print(f'Отправлен stream запрос {req}')
+                
+
+                _last.setPayload(None)
+                _last.setMethod('gn:end-stream')
+                blob = _last.serialize(2)
+                self._enqueue(sid, blob, True, False)
+                self._schedule_flush()
+            
+            asyncio.create_task(_stream_sender(sid, request))
+
+                
+            q = asyncio.Queue()
+            self._inflight[sid] = q
+            return q
+
+        
+
+class QuicClient:
+    """Обёртка‑фасад над RawQuicClient."""
+
+    def __init__(self):
+        self._quik_core: Optional[RawQuicClient] = None
+        self._client_cm = None
+        self._disconnect_signal = None
+        self._domain = None
+
+        self.status: Literal['active', 'connecting', 'disconnect']
+
+        self.connect_future = asyncio.get_event_loop().create_future()
+        self.connection_time: datetime.datetime = None
+
+    async def connect(self, ip: str, port: int):
+        self.status = 'connecting'
+        self.connection_time = datetime.datetime.now()
+        cfg = QuicConfiguration(is_client=True, alpn_protocols=["gn:backend"])
+        cfg.load_verify_locations(KeyisBClient.ssl_gw_crt_path)
+        cfg.idle_timeout = 40
+
+        self._client_cm = connect(
+            ip,
+            port,
+            configuration=cfg,
+            create_protocol=RawQuicClient,
+            wait_connected=True,
+        )
+
+
+        try:
+            self._quik_core = await self._client_cm.__aenter__()
+            self._quik_core.quicClient = self
+
+            self.status = 'active'
+            if not self.connect_future.done():
+                self.connect_future.set_result(True)
+        except Exception as e:
+            print(f'Error connecting: {e}')
+            if not self.connect_future.done():
+                self.connect_future.set_exception(GNExceptions.ConnectionError.client.connection)
+            await self._client_cm.__aexit__()
+
+    async def disconnect(self):
+        self.status = 'disconnect'
+        
+        if self._quik_core is not None:
+            self._quik_core.stop()
+        
+
+        if self._disconnect_signal is not None:
+            self._disconnect_signal(self._domain)
+        
+
+        if self._quik_core is not None:
+
+
+            for fut in self._quik_core._inflight.values():
+                if isinstance(fut, asyncio.Queue):
+                    del fut
+                else:
+                    fut.set_exception(Exception)
+
+            for fut in self._quik_core._sys_inflight.values():
+                fut.set_exception(Exception)
+
+
+            self._quik_core.close()
+            await self._quik_core.wait_closed()
+            self._quik_core = None
+
+    async def asyncRequest(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]]) -> GNResponse:
+        if self._quik_core is None:
+            raise RuntimeError("Not connected")
+        
+        resp = await self._quik_core.request(request)
+        return GNResponse.deserialize(resp, 2)
+
+    async def asyncRequestStream(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]]) -> AsyncGenerator[GNResponse, None]:
+        
+        if self._quik_core is None:
+            raise RuntimeError("Not connected")
+
+        queue = await self._quik_core.requestStream(request)
+
+        while True:
+            chunk = await queue.get()
+            if chunk is None or chunk.command == 'gn:end-stream':
+                break
+            yield chunk
+
+

{gnserver-0.0.0.0.17 → gnserver-0.0.0.0.18}/GNServer/GNServer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GNServer
-Version: 0.0.0.0.17
+Version: 0.0.0.0.18
 Summary: GNServer
 Home-page: https://github.com/KeyisB/libs/tree/main/GNServer
 Author: KeyisB

{gnserver-0.0.0.0.17 → gnserver-0.0.0.0.18}/GNServer/GNServer.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ MANIFEST.in
 setup.py
 GNServer/LICENSE
 GNServer/mmbConfig.json
+GNServer/GNServer/___client.py
 GNServer/GNServer/__init__.py
 GNServer/GNServer/_app.py
 GNServer/GNServer/_client.py

{gnserver-0.0.0.0.17 → gnserver-0.0.0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GNServer
-Version: 0.0.0.0.17
+Version: 0.0.0.0.18
 Summary: GNServer
 Home-page: https://github.com/KeyisB/libs/tree/main/GNServer
 Author: KeyisB

{gnserver-0.0.0.0.17 → gnserver-0.0.0.0.18}/setup.py

@@ -5,7 +5,7 @@ filesName = 'GNServer'
 
 setup(
     name=name,
-    version='0.0.0.0.17',
+    version='0.0.0.0.18',
     author="KeyisB",
     author_email="keyisb.pip@gmail.com",
     description=name,