nios-apps 0.1.0__py3-none-any.whl

nios/__init__.py

@@ -0,0 +1,289 @@
+import asyncio
+import base64
+import http.client
+import json
+import struct
+import threading
+from concurrent.futures import ThreadPoolExecutor
+
+import websockets
+
+__all__ = ["app", "polling", "App", "NiosError"]
+__version__ = "0.1.0"
+
+DEFAULT_SERVER = "wss://ni-os.ru/apps/_/connect"
+
+T_OPEN, T_DATA, T_CLOSE, T_UDP, T_WSOPEN, T_WSTEXT, T_WSBIN, T_WSCLOSE = range(1, 9)
+HEADER = struct.Struct(">BI")
+LOOPBACK = {"127.0.0.1", "localhost", "::1"}
+CHUNK = 16384
+
+_default = None
+
+
+class NiosError(Exception):
+    pass
+
+
+def pack(kind, sid, payload=b""):
+    return HEADER.pack(kind, sid) + payload
+
+
+class App:
+    def __init__(self, key, port=8000, tcp=None, udp=None, host="127.0.0.1",
+                 server=DEFAULT_SERVER, workers=16, quiet=False):
+        if not isinstance(key, str) or not key.startswith("nios_app_"):
+            raise NiosError("API key must start with nios_app_")
+        if host not in LOOPBACK:
+            raise NiosError("only localhost targets are allowed")
+        self.key = key
+        self.port = int(port) if port else None
+        self.tcp = int(tcp) if tcp else None
+        self.udp = int(udp) if udp else None
+        self.host = host
+        self.server = server
+        self.quiet = quiet
+        self.url = None
+        self.tcp_address = None
+        self.udp_address = None
+        self._pool = ThreadPoolExecutor(max_workers=workers)
+        self._stop = threading.Event()
+        self._streams = {}
+        self._ws = None
+
+    def _log(self, *parts):
+        if not self.quiet:
+            print("[nios]", *parts, flush=True)
+
+    def _forward(self, msg):
+        path = msg.get("path") or "/"
+        if msg.get("query"):
+            path += "?" + msg["query"]
+        headers = dict(msg.get("headers") or {})
+        headers["Host"] = f"{self.host}:{self.port}"
+        headers["Accept-Encoding"] = "identity"
+        body = base64.b64decode(msg.get("body") or "")
+        conn = http.client.HTTPConnection(self.host, self.port, timeout=25)
+        try:
+            conn.request(msg["method"], path, body=body or None, headers=headers)
+            res = conn.getresponse()
+            limit = int(msg.get("max") or 0)
+            data = res.read(limit + 1) if limit else res.read()
+            if limit and len(data) > limit:
+                return {"t": "err", "id": msg["id"], "msg": "response exceeds the remaining traffic budget"}
+            out = {}
+            for name, value in res.getheaders():
+                out[name] = f"{out[name]}, {value}" if name in out else value
+            return {"t": "res", "id": msg["id"], "status": res.status, "headers": out,
+                    "body": base64.b64encode(data).decode("ascii")}
+        except OSError as exc:
+            return {"t": "err", "id": msg["id"], "msg": f"localhost:{self.port} unreachable ({exc.__class__.__name__})"}
+        finally:
+            conn.close()
+
+    async def _send(self, kind, sid, payload=b""):
+        if self._ws is not None:
+            await self._ws.send(pack(kind, sid, payload))
+
+    async def _tcp_open(self, sid, queue):
+        if not self.tcp:
+            self._streams.pop(sid, None)
+            await self._send(T_CLOSE, sid)
+            return
+        try:
+            reader, writer = await asyncio.open_connection(self.host, self.tcp)
+        except OSError:
+            self._streams.pop(sid, None)
+            await self._send(T_CLOSE, sid)
+            return
+
+        async def pump_in():
+            while True:
+                data = await reader.read(CHUNK)
+                if not data:
+                    return
+                await self._send(T_DATA, sid, data)
+
+        async def pump_out():
+            while True:
+                kind, payload = await queue.get()
+                if kind != T_DATA:
+                    return
+                writer.write(payload)
+                await writer.drain()
+
+        tasks = [asyncio.ensure_future(pump_in()), asyncio.ensure_future(pump_out())]
+        try:
+            await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+        finally:
+            for task in tasks:
+                task.cancel()
+            self._streams.pop(sid, None)
+            writer.close()
+            await self._send(T_CLOSE, sid)
+
+    async def _udp_peer(self, sid, first):
+        if not self.udp:
+            self._streams.pop(sid, None)
+            return
+        loop = asyncio.get_running_loop()
+        queue = self._streams[sid]
+        outer = self
+
+        class Relay(asyncio.DatagramProtocol):
+            def datagram_received(self, data, addr):
+                asyncio.ensure_future(outer._send(T_UDP, sid, data))
+
+        transport, _ = await loop.create_datagram_endpoint(Relay, remote_addr=(self.host, self.udp))
+        try:
+            transport.sendto(first)
+            while True:
+                kind, payload = await queue.get()
+                if kind != T_UDP:
+                    return
+                transport.sendto(payload)
+        finally:
+            transport.close()
+            self._streams.pop(sid, None)
+
+    async def _ws_open(self, sid, info):
+        if not self.port:
+            await self._send(T_WSOPEN, sid, b'{"ok":false}')
+            return
+        uri = f"ws://{self.host}:{self.port}{info.get('path') or '/'}"
+        if info.get("query"):
+            uri += "?" + info["query"]
+        try:
+            local = await websockets.connect(uri, subprotocols=info.get("subprotocols") or None,
+                                             max_size=1024 * 1024, open_timeout=8)
+        except Exception:
+            await self._send(T_WSOPEN, sid, b'{"ok":false}')
+            return
+        queue = asyncio.Queue()
+        self._streams[sid] = queue
+        await self._send(T_WSOPEN, sid, json.dumps({"ok": True, "subprotocol": local.subprotocol}).encode())
+
+        async def pump_in():
+            async for message in local:
+                if isinstance(message, str):
+                    await self._send(T_WSTEXT, sid, message.encode())
+                else:
+                    await self._send(T_WSBIN, sid, message)
+
+        async def pump_out():
+            while True:
+                kind, payload = await queue.get()
+                if kind == T_WSTEXT:
+                    await local.send(payload.decode("utf-8", "replace"))
+                elif kind == T_WSBIN:
+                    await local.send(payload)
+                else:
+                    return
+
+        tasks = [asyncio.ensure_future(pump_in()), asyncio.ensure_future(pump_out())]
+        try:
+            await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+        finally:
+            for task in tasks:
+                task.cancel()
+            self._streams.pop(sid, None)
+            await local.close()
+            await self._send(T_WSCLOSE, sid)
+
+    def _binary(self, raw):
+        kind, sid = HEADER.unpack_from(raw)
+        payload = raw[HEADER.size:]
+        if kind == T_OPEN:
+            queue = self._streams[sid] = asyncio.Queue()
+            asyncio.ensure_future(self._tcp_open(sid, queue))
+        elif kind == T_WSOPEN:
+            asyncio.ensure_future(self._ws_open(sid, json.loads(payload)))
+        elif kind == T_UDP and sid not in self._streams:
+            self._streams[sid] = asyncio.Queue()
+            asyncio.ensure_future(self._udp_peer(sid, payload))
+        else:
+            queue = self._streams.get(sid)
+            if queue is not None:
+                if kind in (T_CLOSE, T_WSCLOSE):
+                    queue.put_nowait((T_CLOSE, b""))
+                else:
+                    queue.put_nowait((kind, payload))
+
+    async def _session(self):
+        async with websockets.connect(self.server, max_size=16 * 1024 * 1024,
+                                      ping_interval=20, ping_timeout=30) as ws:
+            self._ws = ws
+            await ws.send(json.dumps({"t": "auth", "key": self.key}))
+            loop = asyncio.get_running_loop()
+            try:
+                async for raw in ws:
+                    if isinstance(raw, bytes):
+                        self._binary(raw)
+                        continue
+                    msg = json.loads(raw)
+                    kind = msg.get("t")
+                    if kind == "hello":
+                        self.url = msg["url"]
+                        self.tcp_address = msg.get("tcp")
+                        self.udp_address = msg.get("udp")
+                        self._log(f"online: {self.url}")
+                        if self.tcp_address:
+                            self._log(f"tcp: {self.tcp_address['host']}:{self.tcp_address['port']}")
+                        if self.udp_address:
+                            self._log(f"udp: {self.udp_address['host']}:{self.udp_address['port']}")
+                    elif kind == "error":
+                        raise NiosError(msg.get("msg", "connection refused"))
+                    elif kind == "req":
+                        loop.create_task(self._serve(ws, msg))
+            finally:
+                self._ws = None
+                for queue in list(self._streams.values()):
+                    queue.put_nowait((T_CLOSE, b""))
+
+    async def _serve(self, ws, msg):
+        loop = asyncio.get_running_loop()
+        reply = await loop.run_in_executor(self._pool, self._forward, msg)
+        await ws.send(json.dumps(reply))
+
+    async def _run(self):
+        delay = 1.0
+        while not self._stop.is_set():
+            try:
+                await self._session()
+                delay = 1.0
+            except NiosError as exc:
+                self._log("refused:", exc)
+                raise
+            except websockets.exceptions.ConnectionClosed as exc:
+                if exc.rcvd and exc.rcvd.code in (4401, 4404):
+                    raise NiosError(exc.rcvd.reason or "key is invalid or the app was deleted") from None
+                self._log("connection closed, reconnecting")
+            except (OSError, websockets.exceptions.WebSocketException) as exc:
+                self._log(f"no connection ({exc.__class__.__name__}), retry in {delay:.0f}s")
+            await asyncio.sleep(delay)
+            delay = min(delay * 2, 30.0)
+
+    def polling(self, background=False):
+        if background:
+            thread = threading.Thread(target=lambda: asyncio.run(self._run()), daemon=True, name="nios-polling")
+            thread.start()
+            return thread
+        try:
+            asyncio.run(self._run())
+        except KeyboardInterrupt:
+            self._log("stopped")
+
+    def stop(self):
+        self._stop.set()
+
+
+def app(key, port=8000, **options):
+    global _default
+    _default = App(key, port, **options)
+    return _default
+
+
+def polling(background=False):
+    if _default is None:
+        raise NiosError("call nios.app(key, port=...) first")
+    return _default.polling(background)

nios_apps-0.1.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: nios-apps
+Version: 0.1.0
+Summary: Expose localhost at ni-os.ru/apps/<name> (Nios Apps tunnel client)
+Project-URL: Homepage, https://ni-os.ru/apps
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=12
+
+# nios-apps
+
+Expose a local server at `https://ni-os.ru/apps/<name>`.
+
+```python
+import nios
+
+nios.app("nios_app_...", port=8000, tcp=25565, udp=19132)
+nios.polling()
+```
+
+HTTP and WebSocket requests arrive at `http://127.0.0.1:<port>`. Raw TCP and UDP traffic is forwarded to the `tcp` and `udp` local ports once a public port is opened in the cabinet at https://ni-os.ru/appsdev.
+
+Traffic limits are per Nios ID account. Rules: https://ni-os.ru/apps#policy

nios_apps-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+nios/__init__.py,sha256=0NLYLShg7_UOqHgRTay8rBUdDCS09ujFyO-c5k5E_tk,10808
+nios_apps-0.1.0.dist-info/METADATA,sha256=d_Qg-EIuCgHoBDzLwByv0Qv_wAKiXsL4N-VNeSSE0zE,869
+nios_apps-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+nios_apps-0.1.0.dist-info/top_level.txt,sha256=q9mlf8qzgqxzD0MpiuNoLCrtyUvcQxkr9VgJjd5qoJw,5
+nios_apps-0.1.0.dist-info/RECORD,,

nios_apps-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nios_apps-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nios