KeyisBVMHost 0.0.0.0.2__tar.gz

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/KeyisBVMHost/__init__.py

@@ -0,0 +1,40 @@
+"""
+Copyright (C) 2024 KeyisB. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to use the Software exclusively for
+projects related to the GN or GW systems, including personal,
+educational, and commercial purposes, subject to the following
+conditions:
+
+1. Copying, modification, merging, publishing, distribution,
+sublicensing, and/or selling copies of the Software are
+strictly prohibited.
+2. The licensee may use the Software only in its original,
+unmodified form.
+3. All copies or substantial portions of the Software must
+remain unaltered and include this copyright notice and these terms of use.
+4. Use of the Software for projects not related to GN or
+GW systems is strictly prohibited.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR
+A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+"""
+
+from ._app import App
+from KeyisBClient.gn import GNRequest, GNResponse, CORSObject, FileObject, TemplateObject
+
+
+
+
+
+
+from ._client import AsyncClient

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/KeyisBVMHost/_app.py

@@ -0,0 +1,390 @@
+from GNServer import App as _App, GNRequest, GNResponse, AsyncClient
+from typing import Optional
+import datetime
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from typing import Iterable, Set, Tuple
+import os
+from cryptography.hazmat.primitives.ciphers import Cipher,algorithms
+import subprocess
+import sys
+from KeyisBClient import Url
+import asyncio
+
+
+def _kill_process_by_port(port: int):
+
+    def _run(cmd: list[str]) -> Tuple[int, str, str]:
+        try:
+            p = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            return p.returncode, p.stdout.strip(), p.stderr.strip()
+        except FileNotFoundError:
+            return 127, "", f"{cmd[0]} not found"
+
+    def pids_from_fuser(port: int, proto: str) -> Set[int]:
+        # fuser понимает 59367/udp и 59367/tcp (оба стека)
+        rc, out, _ = _run(["fuser", f"{port}/{proto}"])
+        if rc != 0:
+            return set()
+        return {int(x) for x in re.findall(r"\b(\d+)\b", out)}
+
+    def pids_from_lsof(port: int, proto: str) -> Set[int]:
+        # lsof -ti UDP:59367  /  lsof -ti TCP:59367
+        rc, out, _ = _run(["lsof", "-ti", f"{proto.upper()}:{port}"])
+        if rc != 0 or not out:
+            return set()
+        return {int(x) for x in out.splitlines() if x.isdigit()}
+
+    def pids_from_ss(port: int, proto: str) -> Set[int]:
+        # ss -H -uapn 'sport = :59367'  (UDP)  /  ss -H -tapn ... (TCP)
+        flag = "-uapn" if proto == "udp" else "-tapn"
+        rc, out, _ = _run(["ss", "-H", flag, f"sport = :{port}"])
+        if rc != 0 or not out:
+            return set()
+        pids = set()
+        for line in out.splitlines():
+            # ... users:(("python3",pid=1234,fd=55))
+            for m in re.finditer(r"pid=(\d+)", line):
+                pids.add(int(m.group(1)))
+        return pids
+
+    def find_pids(port: int, proto: str | None) -> Set[int]:
+        protos: Iterable[str] = [proto] if proto in ("udp","tcp") else ("udp","tcp")
+        found: Set[int] = set()
+        for pr in protos:
+            # Порядок: fuser -> ss -> lsof (достаточно любого)
+            found |= pids_from_fuser(port, pr)
+            found |= pids_from_ss(port, pr)
+            found |= pids_from_lsof(port, pr)
+        # не убивать себя
+        found.discard(os.getpid())
+        return found
+
+    def kill_pids(pids: Set[int]) -> None:
+        if not pids:
+            return
+        me = os.getpid()
+        for sig in (signal.SIGTERM, signal.SIGKILL):
+            still = set()
+            for pid in pids:
+                if pid == me:
+                    continue
+                try:
+                    os.kill(pid, sig)
+                except ProcessLookupError:
+                    continue
+                except PermissionError:
+                    print(f"[WARN] No permission to signal {pid}")
+                    still.add(pid)
+                    continue
+                still.add(pid)
+            if not still:
+                return
+            # подождём чуть-чуть
+            for _ in range(10):
+                live = set()
+                for pid in still:
+                    try:
+                        os.kill(pid, 0)
+                        live.add(pid)
+                    except ProcessLookupError:
+                        pass
+                still = live
+                if not still:
+                    return
+                time.sleep(0.1)
+
+    def wait_port_free(port: int, proto: str | None, timeout: float = 3.0) -> bool:
+        t0 = time.time()
+        while time.time() - t0 < timeout:
+            if not find_pids(port, proto):
+                return True
+            time.sleep(0.1)
+        return not find_pids(port, proto)
+
+    for proto in ("udp", "tcp"):
+        pids = find_pids(port, proto)
+    
+
+        print(f"Гашу процессы на порту {port}: {sorted(pids)}")
+        kill_pids(pids)
+
+        if wait_port_free(port, proto):
+            print(f"Порт {port} освобождён.")
+        else:
+            print(f"[ERROR] Не удалось освободить порт {port}. Возможно, другой netns/служба перезапускает процесс.")
+
+
+
+
+def _sign(k:bytes)->bytes:nonce=os.urandom(16);m=b"keyisb-vm-host-"+os.urandom(32);return nonce+Cipher(algorithms.ChaCha20(k[:32],nonce),None).encryptor().update(m)
+def _verify(k:bytes,s:bytes)->bool:nonce,ct=s[:16],s[16:];return Cipher(algorithms.ChaCha20(k[:32],nonce),None).decryptor().update(ct).startswith(b"keyisb-vm-host-")
+
+class App():
+    def __init__(self):
+        self._app = _App()
+
+        self._servers_start_files = {}
+
+        self._access_key: Optional[str] = None
+
+        self._default_venv_path = None
+
+        self._client = AsyncClient()
+
+        self.__add_routes()
+
+
+
+    def setAccessKey(self, key: str):
+        self._access_key = key
+
+    def setVenvPath(self, venv_path: str):
+        self._default_venv_path = venv_path
+
+    def addServerStartFile(self, name: str, file_path: str, port: Optional[int] = None, start_when_run: bool = False, venv_path: Optional[str] = None):
+        self._servers_start_files[name] = {"name": name, "path": file_path, "port": port, "start_when_run": start_when_run, "venv_path": venv_path if venv_path is not None else self._default_venv_path}
+
+    async def startLikeRun(self):
+        for server in self._servers_start_files:
+            if self._servers_start_files[server]["start_when_run"]:
+                asyncio.create_task(self.startServer(server))
+
+    async def startServer(self, name: str, timeout: float = 10.0) -> bool:
+        if name in self._servers_start_files:
+            server = self._servers_start_files[name]
+            path = server["path"]
+            venv_path = server["venv_path"]
+            if not os.path.isfile(path):
+                raise ValueError(f"Server start file not found: {path}")
+            
+            if path.endswith('.py'):
+                if venv_path is not None:
+                    if not os.path.isdir(venv_path):
+                        raise ValueError(f"Virtual environment path not found: {venv_path}")
+                    python_executable = os.path.join(venv_path, 'bin', 'python')
+                    if not os.path.isfile(python_executable):
+                        raise ValueError(f"Python executable not found in virtual environment: {python_executable}")
+                else:
+                    python_executable = sys.executable
+                
+                subprocess.Popen([python_executable, path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+            else:
+                subprocess.Popen([path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            
+            return await self.checkServerHealth(name, timeout=timeout)
+        else:
+            raise ValueError(f"No server start file found with name: {name}")
+    
+
+
+    async def _send_message_to_server(self, name: str, path: str, payload: Optional[dict] = None, timeout: float = 1.0) -> Optional[GNResponse]:
+        port = self._servers_start_files[name].get("port")
+        if port is None:
+            raise ValueError(f"No port specified for server: {name}")
+
+        if path.startswith('/'):
+            path = path[1:]
+
+        c = self._client.request(GNRequest('POST', Url(f'gn://127.0.0.1:{port}/!gn-vm-host/{path}'), payload=payload))
+
+        try:
+            result = await asyncio.wait_for(c, timeout=timeout)
+        except asyncio.TimeoutError:
+            result = None
+        
+        return result
+
+    async def checkServerHealth(self, name: str, timeout: float = 3.0, interval=0.5):
+        end = asyncio.get_event_loop().time() + timeout
+        while asyncio.get_event_loop().time() < end:
+            result = await self._send_message_to_server(name, '/ping', timeout=timeout)
+            if result is not None:
+                return True
+            else:
+                await asyncio.sleep(interval)
+        return False
+        
+
+
+    def stopServer(self, name: str):
+        if name in self._servers_start_files:
+            server = self._servers_start_files[name]
+            port = server["port"]
+            if port is not None:
+                _kill_process_by_port(port)
+            else:
+                raise ValueError(f"No port specified for server: {name}")
+        else:
+            raise ValueError(f"No server start file found with name: {name}")
+
+    async def reloadServer(self, name: str, timeout: float = 1):
+        if name in self._servers_start_files:
+            self.stopServer(name)
+            await asyncio.sleep(timeout)
+            return await self.startServer(name)
+        else:
+            raise ValueError(f"No server start file found with name: {name}")
+
+    def run(self,
+            host,
+            port,
+            cert_path: str,
+            key_path: str,
+            *,
+            idle_timeout: float = 20.0,
+            wait: bool = True
+            ):
+        
+
+        asyncio.create_task(self.startLikeRun())
+
+        self._app.run(
+            host=host,
+            port=port,
+            cert_path=cert_path,
+            key_path=key_path,
+            idle_timeout=idle_timeout,
+            wait=wait
+        )
+
+
+    def __resolve_access_key(self, request: GNRequest) -> bool:
+        if self._access_key is None:
+            raise ValueError("Access key is not set.")
+        
+        sign = request.cookies.get('vm-host-sign')
+
+        if sign is None:
+            return False
+
+        return _verify(self._access_key.encode(), sign)
+
+    def __add_routes(self):
+        @self._app.route('POST', '/ping')
+        async def ping_handler(request: GNRequest, name: Optional[str] = None, timeout: float = 3.0):
+            if not self.__resolve_access_key(request):
+                return None
+            
+            if not name:
+                return GNResponse('ok', {'time': datetime.datetime.now(datetime.timezone.utc).isoformat()})
+            else:
+                try:
+                    result = await self.checkServerHealth(name, timeout=timeout)
+                    if result:
+                        return GNResponse('ok', {'message': f'Server {name} is alive.'})
+                    else:
+                        return GNResponse('error', {'error': f'Server {name} is not responding.'})
+                except ValueError as e:
+                    return GNResponse('error', {'error': str(e)})
+                
+        @self._app.route('GET', '/servers')
+        async def list_servers_handler(request: GNRequest):
+            if not self.__resolve_access_key(request):
+                return None
+            
+            servers_info = []
+            for server in self._servers_start_files.values():
+                servers_info.append({
+                    'name': server['name'],
+                    'port': server['port'],
+                    'start_when_run': server['start_when_run']
+                })
+            return GNResponse('ok', {'servers': servers_info})
+
+
+
+            
+
+        @self._app.route('POST', '/start-server')
+        async def start_server_handler(request: GNRequest, name: str = ''):
+            if not self.__resolve_access_key(request):
+                return None
+            
+            if not name:
+                return GNResponse('error', {'error': 'Server name is required.'})
+            try:
+                result = await self.startServer(name)
+                if result:
+                    return GNResponse('ok', {'message': f'Server {name} started.'})
+                else:
+                    return GNResponse('error', {'error': f'Server {name} failed to start within the timeout period.'})
+            except ValueError as e:
+                return GNResponse('error', {'error': str(e)})
+            
+            
+
+        @self._app.route('POST', '/reload-server')
+        async def reload_server_handler(request: GNRequest, name: str = '', timeout: float = 0.5):
+            if not self.__resolve_access_key(request):
+                return None
+
+            if not name:
+                return GNResponse('error', {'error': 'Server name is required.'})
+
+            try:
+                result = await self.reloadServer(name, timeout)
+                if result:
+                    return GNResponse('ok', {'message': f'Server {name} reloaded.'})
+                else:
+                    return GNResponse('error', {'error': f'Server {name} failed to reload within the timeout period.'})
+            except ValueError as e:
+                return GNResponse('error', {'error': str(e)})
+        
+        @self._app.route('POST', '/stop-server')
+        async def stop_server_handler(request: GNRequest, name: str = ''):
+            if not self.__resolve_access_key(request):
+                return None
+
+            if not name:
+                return GNResponse('error', {'error': 'Server name is required.'})
+
+            try:
+                self.stopServer(name)
+                return GNResponse('ok', {'message': f'Server {name} stopped.'})
+            except ValueError as e:
+                return GNResponse('error', {'error': str(e)})
+        
+        @self._app.route('POST', '/start-all-servers')
+        async def start_all_servers_handler(request: GNRequest):
+            if not self.__resolve_access_key(request):
+                return None
+
+            for server in self._servers_start_files:
+                try:
+                    result = await self.startServer(server)
+                    if not result:
+                        return GNResponse('error', {'error': f'Server {server} failed to start within the timeout period.'})
+                except ValueError as e:
+                    return GNResponse('error', {'error': str(e)})
+        
+        @self._app.route('POST', '/stop-all-servers')
+        async def stop_all_servers_handler(request: GNRequest):
+            if not self.__resolve_access_key(request):
+                return None
+
+            for server in self._servers_start_files:
+                try:
+                    self.stopServer(server)
+                except ValueError as e:
+                    return GNResponse('error', {'error': str(e)})
+
+            return GNResponse('ok', {'message': 'All servers stopped.'})
+        
+        @self._app.route('POST', '/reload-all-servers')
+        async def reload_all_servers_handler(request: GNRequest, timeout: float = 0.5):
+            if not self.__resolve_access_key(request):
+                return None
+
+            for server in self._servers_start_files:
+                try:
+                    result = await self.reloadServer(server, timeout)
+                    if not result:
+                        return GNResponse('error', {'error': f'Server {server} failed to reload within the timeout period.'})
+                except ValueError as e:
+                    return GNResponse('error', {'error': str(e)})

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/KeyisBVMHost/_client.py

@@ -0,0 +1,600 @@
+
+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
+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)
+
+
+
+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._client: QuicClient = QuicClient()
+
+        self._active_connections: Dict[str, Any] = {}
+
+    async def _getCoreDNS(self, domain: str):
+        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):
+        if domain in self._active_connections:
+            return
+
+        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:]
+
+
+    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()
+        ```
+        """
+
+
+
+
+
+
+        if isinstance(request, GNRequest):
+            
+
+            if request.url.hostname not in self._active_connections:
+                await self.connect(request.url.hostname)
+                
+
+
+            for f in self.__request_callbacks.values():
+                asyncio.create_task(f(request))
+
+            r = await self._client.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
+
+
+
+
+
+
+
+
+
+# gn:quik
+
+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
+
+# ---------------------------------------------------------------------------
+#  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
+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
+
+
+class RawQuicClient(QuicConnectionProtocol):
+    """Чистый‑QUIC клиент с приоритизированным SYS‑каналом + стриминг."""
+
+    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._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"))
+
+    # ─────────────────────────────────────────── 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()
+            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
+
+    async def connect(self, ip: str, port: int):
+        cfg = QuicConfiguration(is_client=True, alpn_protocols=["gn:backend"])
+        cfg.load_verify_locations(KeyisBClient.ssl_gw_crt_path)
+
+        self._client_cm = connect(
+            ip,
+            port,
+            configuration=cfg,
+            create_protocol=RawQuicClient,
+            wait_connected=True,
+        )
+        self._quik_core = await self._client_cm.__aenter__()
+
+    async def disconnect(self):
+        self._quik_core.close()
+        await self._quik_core.wait_closed()
+        self._quik_core = None
+
+    def syncRequest(self, request: GNRequest):
+        return asyncio.get_event_loop().run_until_complete(self.asyncRequest(request))
+
+    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
+
+

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/KeyisBVMHost.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: KeyisBVMHost
+Version: 0.0.0.0.2
+Summary: KeyisBVMHost
+Home-page: https://github.com/KeyisB/libs/tree/main/KeyisBVMHost
+Author: KeyisB
+Author-email: keyisb.pip@gmail.com
+License: MMB License v1.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: aioquic
+Requires-Dist: anyio
+Requires-Dist: KeyisBClient
+Requires-Dist: aiofiles
+Requires-Dist: uvloop
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+GW and MMB Project libraries

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/KeyisBVMHost.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+setup.py
+KeyisBVMHost/LICENSE
+KeyisBVMHost/mmbConfig.json
+KeyisBVMHost/KeyisBVMHost/__init__.py
+KeyisBVMHost/KeyisBVMHost/_app.py
+KeyisBVMHost/KeyisBVMHost/_client.py
+KeyisBVMHost/KeyisBVMHost.egg-info/PKG-INFO
+KeyisBVMHost/KeyisBVMHost.egg-info/SOURCES.txt
+KeyisBVMHost/KeyisBVMHost.egg-info/dependency_links.txt
+KeyisBVMHost/KeyisBVMHost.egg-info/requires.txt
+KeyisBVMHost/KeyisBVMHost.egg-info/top_level.txt

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/KeyisBVMHost.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/KeyisBVMHost.egg-info/requires.txt

@@ -0,0 +1,5 @@
+aioquic
+anyio
+KeyisBClient
+aiofiles
+uvloop

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/KeyisBVMHost.egg-info/top_level.txt

@@ -0,0 +1 @@
+KeyisBVMHost

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/LICENSE

@@ -0,0 +1,28 @@
+Copyright (C) 2024 KeyisB. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated 
+1. Copying, modification, merging, publishing, distribution,
+sublicensing, and/or selling copies of the Software are
+strictly prohibited.documentation
+files (the "Software"), to use the Software exclusively for
+projects related to the GN or GW systems, including personal,
+educational, and commercial purposes, subject to the following
+conditions:
+
+2. The licensee may use the Software only in its original,
+unmodified form.
+3. All copies or substantial portions of the Software must
+remain unaltered and include this copyright notice and these terms of use.
+4. Use of the Software for projects not related to GN or
+GW systems is strictly prohibited.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR
+A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

keyisbvmhost-0.0.0.0.2/KeyisBVMHost/mmbConfig.json

@@ -0,0 +1,9 @@
+{
+    "requirements": [
+        "aioquic",
+        "anyio",
+        "KeyisBClient",
+        "aiofiles",
+        "uvloop"
+    ]
+}

keyisbvmhost-0.0.0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 KeyisB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

keyisbvmhost-0.0.0.0.2/MANIFEST.in

@@ -0,0 +1,4 @@
+graft KeyisBVMHost
+global-exclude __pycache__ *.py[cod] .DS_Store
+include LICENSE
+include README.md

keyisbvmhost-0.0.0.0.2/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: KeyisBVMHost
+Version: 0.0.0.0.2
+Summary: KeyisBVMHost
+Home-page: https://github.com/KeyisB/libs/tree/main/KeyisBVMHost
+Author: KeyisB
+Author-email: keyisb.pip@gmail.com
+License: MMB License v1.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: aioquic
+Requires-Dist: anyio
+Requires-Dist: KeyisBClient
+Requires-Dist: aiofiles
+Requires-Dist: uvloop
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+GW and MMB Project libraries

keyisbvmhost-0.0.0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

keyisbvmhost-0.0.0.0.2/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup
+
+name = 'KeyisBVMHost'
+filesName = 'KeyisBVMHost'
+
+setup(
+    name=name,
+    version='0.0.0.0.2',
+    author="KeyisB",
+    author_email="keyisb.pip@gmail.com",
+    description=name,
+    long_description = 'GW and MMB Project libraries',
+    long_description_content_type= 'text/plain',
+    url=f"https://github.com/KeyisB/libs/tree/main/{name}",
+    include_package_data=True,
+    package_data = {}, # type: ignore
+    package_dir={'': f'{filesName}'.replace('-','_')},
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.12',
+    license="MMB License v1.0",
+    install_requires = ['aioquic', 'anyio', 'KeyisBClient', 'aiofiles', 'uvloop'],
+)