Upload folder using huggingface_hub

Dockerfile

@@ -1,8 +1,6 @@
-FROM nginxinc/nginx-unprivileged:1.25-alpine
+FROM alpine:3.19
 
-USER root
-
-RUN apk add --no-cache curl
+RUN apk add --no-cache curl python3
 
 ARG WSTUNNEL_VERSION=v10.5.5
 RUN curl -fsSL \
@@ -12,10 +10,11 @@ RUN curl -fsSL \
   && rm /tmp/wstunnel.tar.gz \
   && chmod +x /usr/local/bin/wstunnel
 
-COPY nginx.conf /etc/nginx/nginx.conf
+RUN adduser -D -u 1000 user
+USER user
 
-COPY --chmod=755 entrypoint.sh /entrypoint.sh
+COPY --chown=user server.py /app/server.py
 
 EXPOSE 7860
 
-CMD ["/entrypoint.sh"]
+CMD ["python3", "/app/server.py"]

server.py

@@ -0,0 +1,117 @@
+import asyncio
+import os
+import subprocess
+import signal
+import sys
+
+WSTUNNEL_PORT = 7861
+PROXY_PORT = 7860
+WSTUNNEL_BIN = "/usr/local/bin/wstunnel"
+
+
+async def health_check(reader, writer):
+    writer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nOK\n")
+    await writer.drain()
+    writer.close()
+
+
+async def tcp_proxy(reader, writer):
+    try:
+        backend_reader, backend_writer = await asyncio.wait_for(
+            asyncio.open_connection("127.0.0.1", WSTUNNEL_PORT), timeout=5
+        )
+    except (OSError, asyncio.TimeoutError):
+        writer.write(b"HTTP/1.1 502 Bad Gateway\r\nContent-Length: 15\r\n\r\nBackend unavailable\n")
+        await writer.drain()
+        writer.close()
+        return
+
+    async def forward(src, dst):
+        try:
+            while True:
+                data = await src.read(65536)
+                if not data:
+                    break
+                dst.write(data)
+                await dst.drain()
+        except (ConnectionResetError, BrokenPipeError, OSError):
+            pass
+        finally:
+            try:
+                dst.close()
+            except OSError:
+                pass
+
+    await asyncio.gather(
+        forward(reader, backend_writer),
+        forward(backend_reader, writer),
+    )
+
+
+async def handle_client(reader, writer):
+    try:
+        data = await asyncio.wait_for(reader.read(4096), timeout=10)
+        if not data:
+            writer.close()
+            return
+        is_health_check = (
+            data.startswith(b"GET / ")
+            and b"Upgrade: websocket" not in data
+        )
+        if is_health_check:
+            await health_check(reader, writer)
+        else:
+            writer.write(data)
+            await writer.drain()
+            await tcp_proxy(reader, writer)
+    except (ConnectionResetError, BrokenPipeError, OSError, asyncio.TimeoutError):
+        pass
+    finally:
+        try:
+            writer.close()
+        except OSError:
+            pass
+
+
+async def run_wstunnel():
+    token = os.environ.get("PROXY_TOKEN", "")
+    args = [WSTUNNEL_BIN, "server"]
+    if token:
+        args += ["--restrict-http-upgrade-path-prefix", token]
+    args += [f"ws://0.0.0.0:{WSTUNNEL_PORT}"]
+
+    proc = await asyncio.create_subprocess_exec(*args, stdout=sys.stderr, stderr=sys.stderr)
+    return proc
+
+
+async def main():
+    print(f"starting wstunnel on port {WSTUNNEL_PORT}...", flush=True)
+    wstunnel_proc = await run_wstunnel()
+    await asyncio.sleep(0.5)
+
+    if wstunnel_proc.returncode is not None:
+        print(f"ERROR: wstunnel exited with code {wstunnel_proc.returncode}", flush=True)
+        sys.exit(1)
+
+    print(f"starting TCP proxy on port {PROXY_PORT}...", flush=True)
+    server = await asyncio.start_server(handle_client, "0.0.0.0", PROXY_PORT)
+
+    async def shutdown():
+        server.close()
+        wstunnel_proc.terminate()
+        await wstunnel_proc.wait()
+
+    loop = asyncio.get_event_loop()
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        try:
+            loop.add_signal_handler(sig, lambda: asyncio.create_task(shutdown()))
+        except NotImplementedError:
+            pass
+
+    async with server:
+        print(f"proxy server ready on port {PROXY_PORT}", flush=True)
+        await server.serve_forever()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())