etunnel 1.0.0__tar.gz

etunnel-1.0.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: etunnel
+Version: 1.0.0
+Summary: Expose a local service through an etunnel reverse-tunnel server with one line of code
+Author: etunnel authors
+License: MIT
+Project-URL: Homepage, https://github.com/ggcode/etunnel
+Project-URL: Repository, https://github.com/ggcode/etunnel
+Keywords: tunnel,reverse-proxy,webhook,localhost,ngrok
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: websocket-client>=1.6
+
+# etunnel for Python
+
+websocket-client based.
+
+Zero registration: every SDK client speaks the same tiny wire protocol
+([PROTOCOL.md](../../PROTOCOL.md)) against any etunnel server
+(default `wss://t.ggcode.uk/tunnel`).
+
+## Install
+
+```
+pip install etunnel
+```
+
+Python >= 3.8 (websocket-client installed automatically).
+
+## CLI
+
+```
+etunnel 3000
+```
+
+Prints `TUNNEL_URL: https://<subdomain>.t.ggcode.uk` — that URL now routes to
+your local service. Ctrl-C closes the tunnel.
+
+## Embed
+
+```python
+from etunnel import connect
+t = connect("wss://t.ggcode.uk/tunnel", 3000, {})
+print(t["url"])
+```
+
+## Environment variables
+
+| Variable | Meaning | Default |
+|---|---|---|
+| `ETUNNEL_SERVER` | tunnel server WebSocket URL | `wss://t.ggcode.uk/tunnel` |
+| `ETUNNEL_LOCAL` | local port or `host:port` (or 1st CLI arg) | `3000` |
+| `ETUNNEL_TOKEN` | paid-plan API key (optional) | - |
+| `ETUNNEL_SUBDOMAIN` | custom subdomain (paid plans) | random |
+
+## License
+
+MIT — see [LICENSE](../../LICENSE). Buffer-based protocol client: request and
+response bodies are buffered per stream (fine for webhooks/dashboards/demos;
+use the [Go SDK](../../sdk) for streaming and WebSocket pass-through).

etunnel-1.0.0/README.md

@@ -0,0 +1,47 @@
+# etunnel for Python
+
+websocket-client based.
+
+Zero registration: every SDK client speaks the same tiny wire protocol
+([PROTOCOL.md](../../PROTOCOL.md)) against any etunnel server
+(default `wss://t.ggcode.uk/tunnel`).
+
+## Install
+
+```
+pip install etunnel
+```
+
+Python >= 3.8 (websocket-client installed automatically).
+
+## CLI
+
+```
+etunnel 3000
+```
+
+Prints `TUNNEL_URL: https://<subdomain>.t.ggcode.uk` — that URL now routes to
+your local service. Ctrl-C closes the tunnel.
+
+## Embed
+
+```python
+from etunnel import connect
+t = connect("wss://t.ggcode.uk/tunnel", 3000, {})
+print(t["url"])
+```
+
+## Environment variables
+
+| Variable | Meaning | Default |
+|---|---|---|
+| `ETUNNEL_SERVER` | tunnel server WebSocket URL | `wss://t.ggcode.uk/tunnel` |
+| `ETUNNEL_LOCAL` | local port or `host:port` (or 1st CLI arg) | `3000` |
+| `ETUNNEL_TOKEN` | paid-plan API key (optional) | - |
+| `ETUNNEL_SUBDOMAIN` | custom subdomain (paid plans) | random |
+
+## License
+
+MIT — see [LICENSE](../../LICENSE). Buffer-based protocol client: request and
+response bodies are buffered per stream (fine for webhooks/dashboards/demos;
+use the [Go SDK](../../sdk) for streaming and WebSocket pass-through).

etunnel-1.0.0/etunnel.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: etunnel
+Version: 1.0.0
+Summary: Expose a local service through an etunnel reverse-tunnel server with one line of code
+Author: etunnel authors
+License: MIT
+Project-URL: Homepage, https://github.com/ggcode/etunnel
+Project-URL: Repository, https://github.com/ggcode/etunnel
+Keywords: tunnel,reverse-proxy,webhook,localhost,ngrok
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: websocket-client>=1.6
+
+# etunnel for Python
+
+websocket-client based.
+
+Zero registration: every SDK client speaks the same tiny wire protocol
+([PROTOCOL.md](../../PROTOCOL.md)) against any etunnel server
+(default `wss://t.ggcode.uk/tunnel`).
+
+## Install
+
+```
+pip install etunnel
+```
+
+Python >= 3.8 (websocket-client installed automatically).
+
+## CLI
+
+```
+etunnel 3000
+```
+
+Prints `TUNNEL_URL: https://<subdomain>.t.ggcode.uk` — that URL now routes to
+your local service. Ctrl-C closes the tunnel.
+
+## Embed
+
+```python
+from etunnel import connect
+t = connect("wss://t.ggcode.uk/tunnel", 3000, {})
+print(t["url"])
+```
+
+## Environment variables
+
+| Variable | Meaning | Default |
+|---|---|---|
+| `ETUNNEL_SERVER` | tunnel server WebSocket URL | `wss://t.ggcode.uk/tunnel` |
+| `ETUNNEL_LOCAL` | local port or `host:port` (or 1st CLI arg) | `3000` |
+| `ETUNNEL_TOKEN` | paid-plan API key (optional) | - |
+| `ETUNNEL_SUBDOMAIN` | custom subdomain (paid plans) | random |
+
+## License
+
+MIT — see [LICENSE](../../LICENSE). Buffer-based protocol client: request and
+response bodies are buffered per stream (fine for webhooks/dashboards/demos;
+use the [Go SDK](../../sdk) for streaming and WebSocket pass-through).

etunnel-1.0.0/etunnel.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+etunnel.py
+pyproject.toml
+etunnel.egg-info/PKG-INFO
+etunnel.egg-info/SOURCES.txt
+etunnel.egg-info/dependency_links.txt
+etunnel.egg-info/entry_points.txt
+etunnel.egg-info/requires.txt
+etunnel.egg-info/top_level.txt

etunnel-1.0.0/etunnel.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

etunnel-1.0.0/etunnel.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+etunnel = etunnel:_main

etunnel-1.0.0/etunnel.egg-info/requires.txt

@@ -0,0 +1 @@
+websocket-client>=1.6

etunnel-1.0.0/etunnel.egg-info/top_level.txt

@@ -0,0 +1 @@
+etunnel

etunnel-1.0.0/etunnel.py

@@ -0,0 +1,184 @@
+"""etunnel SDK for Python (uses the `websocket-client` package).
+
+Buffer-based protocol client: request/response bodies are buffered per stream
+(WebSocket upgrades are not forwarded — use the Go SDK for those).
+
+    from etunnel import connect
+    t = connect("wss://t.ggcode.uk/tunnel", 3000)
+    print(t["url"])
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import signal
+import sys
+import threading
+import urllib.request
+import urllib.error
+from typing import Any, Optional
+
+import websocket  # pip install websocket-client
+
+MAXP = 32768
+
+HOP = {
+    "connection", "proxy-connection", "keep-alive", "proxy-authenticate",
+    "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade",
+}
+
+KIND_DATA, KIND_FIN, KIND_RST = 0x01, 0x02, 0x03
+
+
+def _frame(kind: int, sid: int, payload: bytes = b"") -> bytes:
+    return bytes([kind]) + sid.to_bytes(4, "big") + len(payload).to_bytes(4, "big") + payload
+
+
+def _parse_frame(buf: bytes):
+    kind = buf[0]
+    sid = int.from_bytes(buf[1:5], "big")
+    n = int.from_bytes(buf[5:9], "big")
+    return kind, sid, buf[9:9 + n]
+
+
+def connect(server: str, local, opts: Optional[dict] = None) -> dict:
+    """Connect to an etunnel server exposing the local service.
+
+    local: port number or "host:port".
+    opts: {token, subdomain, client, on_close}.
+    Returns a dict {url, hostname, subdomain, plan, close()}.
+    """
+    opts = opts or {}
+    if isinstance(local, int):
+        local = f"127.0.0.1:{local}"
+    elif ":" not in str(local):
+        local = f"127.0.0.1:{local}"
+
+    ws = websocket.create_connection(server, subprotocols=["etunnel-v1"], timeout=15)
+    ws.send(json.dumps({
+        "type": "hello", "proto": 1,
+        "subdomain": opts.get("subdomain"),
+        "token": opts.get("token"),
+        "client": opts.get("client", "etunnel-python/1.0"),
+    }))
+
+    while True:
+        m = json.loads(ws.recv())
+        if m.get("type") == "welcome":
+            info = m
+            break
+        if m.get("type") == "error":
+            ws.close()
+            raise RuntimeError(f"etunnel: {m.get('code')}: {m.get('message', '')}")
+
+    state = {"closed": False}
+    streams: dict[int, dict] = {}
+    lock = threading.Lock()
+
+    def handle(req: dict, body: bytes, sid: int) -> None:
+        headers = {k: ", ".join(vs) for k, vs in (req.get("headers") or {}).items()
+                   if k.lower() not in HOP}
+        method = req.get("method", "GET")
+        data = body if method not in ("GET", "HEAD") else None
+        r = urllib.request.Request(f"http://{local}{req.get('path', '/')}", data=data,
+                                   headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(r, timeout=60) as resp:
+                status = resp.status
+                rh = {k: [v] for k, v in resp.getheaders() if k.lower() not in HOP}
+                payload = resp.read()
+        except urllib.error.HTTPError as e:
+            status = e.code
+            rh = {k: [v] for k, v in e.headers.items() if k.lower() not in HOP}
+            payload = e.read()
+        except Exception as e:  # noqa: BLE001
+            with lock:
+                ws.send(json.dumps({"type": "res", "streamId": sid, "status": 502,
+                                    "headers": {"Content-Type": ["text/plain"]}}))
+                ws.send_binary(_frame(KIND_DATA, sid, f"etunnel: local service error: {e}\n".encode()))
+                ws.send_binary(_frame(KIND_FIN, sid))
+            return
+        with lock:
+            ws.send(json.dumps({"type": "res", "streamId": sid, "status": status, "headers": rh}))
+            for i in range(0, len(payload), MAXP):
+                ws.send_binary(_frame(KIND_DATA, sid, payload[i:i + MAXP]))
+            ws.send_binary(_frame(KIND_FIN, sid))
+
+    def reader() -> None:
+        try:
+            while True:
+                m = ws.recv()
+                if isinstance(m, str):
+                    msg = json.loads(m)
+                    t = msg.get("type")
+                    if t == "req":
+                        streams[msg["streamId"]] = {"req": msg, "body": []}
+                    elif t == "ping":
+                        with lock:
+                            ws.send(json.dumps({"type": "pong", "ts": msg.get("ts", 0)}))
+                    elif t == "bye":
+                        state["closed"] = True
+                        if opts.get("on_close"):
+                            opts["on_close"](msg.get("reason", ""))
+                        ws.close()
+                        return
+                else:
+                    kind, sid, payload = _parse_frame(m)
+                    st = streams.get(sid)
+                    if not st:
+                        continue
+                    if kind == KIND_DATA:
+                        st["body"].append(payload)
+                    elif kind == KIND_FIN:
+                        streams.pop(sid, None)
+                        body = b"".join(st["body"])
+                        threading.Thread(target=handle, args=(st["req"], body, sid), daemon=True).start()
+                    elif kind == KIND_RST:
+                        streams.pop(sid, None)
+        except Exception:
+            state["closed"] = True
+            if opts.get("on_close"):
+                opts["on_close"]("read closed")
+
+    threading.Thread(target=reader, daemon=True).start()
+
+    def close(reason: str = "client closed") -> None:
+        if state["closed"]:
+            return
+        state["closed"] = True
+        try:
+            ws.send(json.dumps({"type": "bye", "reason": reason}))
+        except Exception:
+            pass
+        ws.close()
+        if opts.get("on_close"):
+            opts["on_close"](reason)
+
+    return {
+        "url": info["url"],
+        "hostname": info["hostname"],
+        "subdomain": info["subdomain"],
+        "plan": info.get("plan", ""),
+        "close": close,
+    }
+
+
+def _main() -> None:
+    server = os.environ.get("ETUNNEL_SERVER", "wss://t.ggcode.uk/tunnel")
+    local = os.environ.get("ETUNNEL_LOCAL") or (sys.argv[1] if len(sys.argv) > 1 else "3000")
+    try:
+        t = connect(server, local, {
+            "token": os.environ.get("ETUNNEL_TOKEN"),
+            "subdomain": os.environ.get("ETUNNEL_SUBDOMAIN"),
+        })
+    except Exception as e:  # noqa: BLE001
+        print(f"etunnel: {e}", file=sys.stderr)
+        sys.exit(1)
+    print("TUNNEL_URL:", t["url"], flush=True)
+    signal.signal(signal.SIGINT, lambda *_: (t["close"](), sys.exit(0)))
+    signal.pause()
+
+
+if __name__ == "__main__":
+    _main()

etunnel-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "etunnel"
+version = "1.0.0"
+description = "Expose a local service through an etunnel reverse-tunnel server with one line of code"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "etunnel authors" }]
+keywords = ["tunnel", "reverse-proxy", "webhook", "localhost", "ngrok"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Internet :: Proxy Servers",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = ["websocket-client>=1.6"]
+
+[project.urls]
+Homepage = "https://github.com/ggcode/etunnel"
+Repository = "https://github.com/ggcode/etunnel"
+
+[project.scripts]
+etunnel = "etunnel:_main"
+
+[tool.setuptools]
+py-modules = ["etunnel"]

etunnel-1.0.0/setup.cfg

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