GNServer 0.0.0.0.22__py3-none-any.whl → 0.0.0.0.24__py3-none-any.whl

GNServer/_app.py

@@ -2,6 +2,7 @@
 
 
 import re
+import sys
 import uuid
 import anyio
 import decimal
@@ -533,6 +534,7 @@ class App:
                 'async': inspect.iscoroutinefunction(fn),
                 'parameters': inspect.signature(fn).parameters
                 })
+            self._events[name] = events
             
             return fn
         return decorator
@@ -774,7 +776,7 @@ class App:
 
             try:
                 
-                response = await self._api.dispatch(request)
+                response = await self._api.dispatchRequest(request)
 
                 if inspect.isasyncgen(response):
                     async for chunk in response:  # type: ignore[misc]
@@ -796,7 +798,7 @@ class App:
                 logger.debug(f'Отправлен на сервер ответ -> {response.command} {response.payload if response.payload and len((response.payload)) < 200 else ''}')
                 self.transmit()
             except Exception as e:
-                if e.__qualname__.startswith("GNExceptions."):
+                if isinstance(e, _BaseEXception):
                     e: GNExceptions.UnprocessableEntity = e
                     r = e.assembly()
                     return r
@@ -824,11 +826,16 @@ class App:
         cert_path: str,
         key_path: str,
         *,
-        host: Optional[str] = '0.0.0.0',
+        host: str = '0.0.0.0',
         idle_timeout: float = 20.0,
         wait: bool = True,
         run: Optional[Callable] = None
     ):
+        """
+        # Запустить сервер
+
+        Запускает сервер в главном процессе asyncio.run()
+        """
 
         self.domain = domain
 
@@ -842,7 +849,7 @@ class App:
 
         async def _main():
             
-            await self.dispatchEvent('before-run')
+            await self.dispatchEvent('start')
 
             await serve(
                 host,
@@ -855,7 +862,6 @@ class App:
             if run is not None:
                 await run()
 
-            await self.dispatchEvent('run')
             
 
 
@@ -863,3 +869,27 @@ class App:
                 await asyncio.Event().wait()
 
         asyncio.run(_main())
+
+
+    def runByVMHost(self):
+        """
+        # Запусить через VM-host
+
+        Заупскает сервер через процесс vm-host
+        """
+        argv = sys.argv[1:]
+        command = argv[0]
+        if command == 'gn:vm-host:start':
+            domain = argv[1]
+            port = int(argv[2])
+            cert_path = argv[3]
+            key_path = argv[4]
+            host = argv[5]
+
+            self.run(
+                domain=domain,
+                port=port,
+                cert_path=cert_path,
+                key_path=key_path,
+                host=host
+            )

GNServer/_client.py

@@ -53,7 +53,7 @@ class GNExceptions:
                 def __init__(self, message="Ошибка подключения к серверу openconnector.gn. Сервер не подтвердил подключение."):
                     super().__init__(message)
 
-        class dns_core():
+        class dns():
             """Ошибка подключения к серверу dns.core"""
             class connection(Exception):
                 def __init__(self, message="Ошибка подключения к серверу dns.core Сервер не найден."):
@@ -100,7 +100,7 @@ class GNExceptions:
 
 
 
-from KeyisBClient.gn import GNRequest, GNResponse, GNProtocol
+from KeyisBClient.gn import GNRequest, GNResponse
 
 
 
@@ -108,7 +108,7 @@ 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.__dns_gn__ipv4: Optional[str] = None
 
         self.__current_session = {}
         self.__request_callbacks = {}
@@ -116,36 +116,69 @@ class AsyncClient:
 
         self._active_connections: Dict[str, QuicClient] = {}
 
-    async def _getCoreDNS(self, domain: str):
+        self.__dns_client: Optional[AsyncClient] = None
 
-        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
+    
+    async def getCoreDNS(self, domain: str) -> str:
+
+        if ':' in domain and domain.split('.')[-1].split(':')[0].isdigit() and domain.split(':')[-1].isdigit():
+            return domain
 
         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'])
+            if self.__dns_client is None:
+                self.__dns_client = AsyncClient()
+
+            r1 = await self.__dns_client.request(GNRequest('GET', Url(f'gn://{self.__dns_core__ipv4}/getIp?d={domain}')), keep_alive=False)
+
+            if r1.command != 'ok':
+                raise GNExceptions.ConnectionError.dns.data
 
+            r1_data = r1.payload
+
+            return 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
+            raise GNExceptions.ConnectionError.dns.timeout
         except:
-            raise GNExceptions.ConnectionError.dns_core.connection
+            raise GNExceptions.ConnectionError.dns.connection
+
+    
+
+    async def getGNDNS(self, domain: str, token: Optional[str] = None) -> str:
+        
+        if ':' in domain and domain.split('.')[-1].split(':')[0].isdigit() and domain.split(':')[-1].isdigit():
+            return domain
+
+
+        if self.__dns_gn__ipv4 is None:
+            self.__dns_gn__ipv4 = await self.getCoreDNS('dns.gn')
+
+
+        try:
+            if self.__dns_client is None:
+                self.__dns_client = AsyncClient()
+            
+            if token is not None:
+                payload = {'token': token}
+            else:
+                payload = None
+
+            r1 = await self.__dns_client.request(GNRequest('GET', Url(f'gn://{self.__dns_gn__ipv4}/getIp?d={domain}'), payload=payload))
+
+            if r1.command != 'ok':
+                raise GNExceptions.ConnectionError.dns.data
+
+            r1_data = r1.payload
+
+            return r1_data['ip'] + ':' + str(r1_data['port'])
+
+        except httpx.TimeoutException:
+            raise GNExceptions.ConnectionError.dns.timeout
+        except:
+            raise GNExceptions.ConnectionError.dns.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
@@ -154,7 +187,7 @@ class AsyncClient:
         self.__response_callbacks[name] = callback
 
   
-    async def connect(self, domain: str, restart_connection: bool = False, reconnect_wait: float = 10) -> 'QuicClient':
+    async def connect(self, domain: str, restart_connection: bool = False, reconnect_wait: float = 10, keep_alive: bool = True) -> 'QuicClient':
         print('Запрос подключения')
         if not restart_connection and domain in self._active_connections:
             c = self._active_connections[domain]
@@ -182,7 +215,9 @@ class AsyncClient:
         c.status = 'connecting'
         self._active_connections[domain] = c
 
-        data = await self._getCoreDNS(domain)
+        data = await self.getCoreDNS(domain)
+
+        data = data.split(':')
 
 
 
@@ -192,7 +227,7 @@ class AsyncClient:
         c._disconnect_signal = f
         c._domain = domain
 
-        await c.connect(data['ip'], data['port'])
+        await c.connect(data['ip'], data['port'], keep_alive=keep_alive)
         await c.connect_future
 
         return c
@@ -208,11 +243,11 @@ class AsyncClient:
         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:
+    async def request(self, request: Union[GNRequest, AsyncGenerator[GNRequest, Any]], keep_alive: bool = True, restart_connection: bool = False, reconnect_wait: float = 10) -> GNResponse:
         if isinstance(request, GNRequest):
             
 
-            c = await self.connect(request.url.hostname, restart_connection, reconnect_wait)
+            c = await self.connect(request.url.hostname, restart_connection, reconnect_wait, keep_alive=keep_alive)
                 
 
 
@@ -326,7 +361,6 @@ class RawQuicClient(QuicConnectionProtocol):
         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):
@@ -592,7 +626,7 @@ class QuicClient:
         self.connect_future = asyncio.get_event_loop().create_future()
         self.connection_time: datetime.datetime = None
 
-    async def connect(self, ip: str, port: int):
+    async def connect(self, ip: str, port: int, keep_alive: bool = True):
         self.status = 'connecting'
         self.connection_time = datetime.datetime.now()
         cfg = QuicConfiguration(is_client=True, alpn_protocols=["gn:backend"])
@@ -612,6 +646,9 @@ class QuicClient:
             self._quik_core = await self._client_cm.__aenter__()
             self._quik_core.quicClient = self
 
+            if keep_alive:
+                asyncio.create_task(self._quik_core._keepalive_loop())
+
             self.status = 'active'
             if not self.connect_future.done():
                 self.connect_future.set_result(True)
@@ -619,7 +656,7 @@ class QuicClient:
             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__()
+            await self._client_cm.__aexit__(None, None, None)
 
     async def disconnect(self):
         self.status = 'disconnect'

GNServer/tools/_models.py

@@ -1,5 +1,8 @@
 import time
-import threading
+import asyncio
+from typing import Optional
+
+
 
 class TTLDict:
     def __init__(self, default_ttl: int = 60, cleanup_interval: int = 300):
@@ -7,46 +10,38 @@ class TTLDict:
         :param default_ttl: TTL по умолчанию (сек), если при записи не указан
         :param cleanup_interval: периодическая очистка от просроченных ключей (сек), по умолчанию 5 мин
         """
+
         self._store = {}
-        self._lock = threading.Lock()
         self._default_ttl = default_ttl
         self._cleanup_interval = cleanup_interval
-        self._stop_event = threading.Event()
-
-        self._timer = threading.Thread(target=self._cleanup_worker, daemon=True)
-        self._timer.start()
+        self._task = None
 
-    def set(self, key, value, ttl: int = None):
-        """Установить значение с временем жизни (в секундах)."""
+    def set(self, key, value, ttl: Optional[int] = None):
         if ttl is None:
             ttl = self._default_ttl
         expire_at = time.monotonic() + ttl
-        with self._lock:
-            self._store[key] = (value, expire_at)
+        self._store[key] = (value, expire_at)
+
+        if self._task is None:
+            loop = asyncio.get_running_loop()
+            self._task = loop.create_task(self._cleanup_worker())
 
     def get(self, key):
-        """Получить значение или None, если ключ отсутствует/просрочен."""
         now = time.monotonic()
-        with self._lock:
-            item = self._store.get(key)
-            if not item:
-                return None
-
-            value, expire_at = item
-            if expire_at < now:
-                del self._store[key]
-                return None
+        item = self._store.get(key)
+        if not item:
+            return None
 
-            return value
+        value, expire_at = item
+        if expire_at < now:
+            del self._store[key]
+            return None
+        return value
 
     def __setitem__(self, key, value):
-        """
-        cache[key] = val         → TTL по умолчанию
-        """
         self.set(key, value, self._default_ttl)
 
     def __getitem__(self, key):
-        """cache[key] -> value | None"""
         return self.get(key)
 
     def __contains__(self, key):
@@ -58,20 +53,22 @@ class TTLDict:
     def __repr__(self):
         return f"<TTLDict size={len(self._store)}>"
 
-    def _cleanup_worker(self):
-        """Фоновый поток для периодической очистки."""
-        while not self._stop_event.wait(self._cleanup_interval):
+    async def _cleanup_worker(self):
+        while True:
+            await asyncio.sleep(self._cleanup_interval)
             self.cleanup()
 
     def cleanup(self):
-        """Удалить все просроченные ключи."""
+        """Удалить все просроченные ключи"""
         now = time.monotonic()
-        with self._lock:
-            expired = [k for k, (_, exp) in self._store.items() if exp < now]
-            for k in expired:
-                self._store.pop(k, None)
+        expired = [k for k, (_, exp) in self._store.items() if exp < now]
+        for k in expired:
+            self._store.pop(k, None)
 
-    def stop(self):
+    async def stop(self):
         """Остановить фон очистки"""
-        self._stop_event.set()
-        self._timer.join(timeout=1)
+        self._task.cancel()
+        try:
+            await self._task
+        except asyncio.CancelledError:
+            pass

{gnserver-0.0.0.0.22.dist-info → gnserver-0.0.0.0.24.dist-info}/METADATA

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

gnserver-0.0.0.0.24.dist-info/RECORD

@@ -0,0 +1,11 @@
+GNServer/___client.py,sha256=hmeUL2Vqp-BnwJeRcLZAaIfRNVxBrRRB_AFk9ofkei4,25459
+GNServer/__init__.py,sha256=V50sMYrrPdOGuI1iJm-SW7izhX-eggDH16AHvtIKjmM,1480
+GNServer/_app.py,sha256=WYK16u-G6TDEMBa3MVaJP3-HzTh4NIcmzsyOdxaSsm0,30664
+GNServer/_client.py,sha256=9zw3DbkVHjNr-DNhlLV92r2sNJ-VY9Ahc4QjP1sUCII,28443
+GNServer/tools/__init__.py,sha256=itqkS5iBB2GEHqz8H-htqgd55rUi6utnuKVAzBBByCM,28
+GNServer/tools/_models.py,sha256=1V94cbNHQGAl5l9DJbGvvkm1gmsgTEMgkjzlnZk8ymw,2264
+gnserver-0.0.0.0.24.dist-info/licenses/LICENSE,sha256=WH_t7dKZyWJ5Ld07eYIkUG4Tv6zZWXtAdsUqYAUesn0,1084
+gnserver-0.0.0.0.24.dist-info/METADATA,sha256=kVi7DeXW2P6Zgk8y3ZcUuDNFiS_gRvrsR8exkZPJ3vM,805
+gnserver-0.0.0.0.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gnserver-0.0.0.0.24.dist-info/top_level.txt,sha256=-UOUBuD4u7Qkb1o5PdcwyA3kx8xCH2lwy0tJHi26Wb4,9
+gnserver-0.0.0.0.24.dist-info/RECORD,,

gnserver-0.0.0.0.22.dist-info/RECORD

@@ -1,11 +0,0 @@
-GNServer/___client.py,sha256=hmeUL2Vqp-BnwJeRcLZAaIfRNVxBrRRB_AFk9ofkei4,25459
-GNServer/__init__.py,sha256=V50sMYrrPdOGuI1iJm-SW7izhX-eggDH16AHvtIKjmM,1480
-GNServer/_app.py,sha256=Mtpuoj7CPjedW9m5wL6YzfAwCV9F-5a69ag2Dh2VwIk,29908
-GNServer/_client.py,sha256=lwFGsNR2RullSNCuu7WXXdYfUbsV1_ZweMv-N-5Gpv0,27371
-GNServer/tools/__init__.py,sha256=itqkS5iBB2GEHqz8H-htqgd55rUi6utnuKVAzBBByCM,28
-GNServer/tools/_models.py,sha256=tXWR255ASJLlpdDrgMXcmRqD_nIcCb4qKeESvAhxWpU,2742
-gnserver-0.0.0.0.22.dist-info/licenses/LICENSE,sha256=WH_t7dKZyWJ5Ld07eYIkUG4Tv6zZWXtAdsUqYAUesn0,1084
-gnserver-0.0.0.0.22.dist-info/METADATA,sha256=b0GuFIDOkuPhFhVj_Cm66zZsjpm1nvQLvzLjGZhZhFA,805
-gnserver-0.0.0.0.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gnserver-0.0.0.0.22.dist-info/top_level.txt,sha256=-UOUBuD4u7Qkb1o5PdcwyA3kx8xCH2lwy0tJHi26Wb4,9
-gnserver-0.0.0.0.22.dist-info/RECORD,,