fixed host set to localhost even on remote docker, fixed one error in provider causing all routes not to load

Too sleepy...

.github/workflows/docker-image.yml

@@ -0,0 +1,21 @@
+name: Docker Image CI
+
+on:
+  push:
+    tags:
+      - "*"
+jobs:
+  build_and_push:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Docker Build and Push
+        id: docker_build_push
+        uses: GlueOps/github-actions-build-push-containers@v0.3.7
+        with:
+          tags: ${{ github.ref_name }}
+
+      - name: Tag as latest
+        if: startsWith(github.ref, 'refs/tags/') && !contains(github.ref_name, '-')
+        run: |
+          docker tag ghcr.io/${{ github.repository }}:${{ github.ref_name }} ghcr.io/${{ github.repository }}:latest
+          docker push ghcr.io/${{ github.repository }}:latest

.gitignore

@@ -1,7 +1,18 @@
 compose.yml
-go-proxy.yml
-config.yml
-providers.yml
-bin/go-proxy.bak
+
+config/
+certs/
+bin/
+
+templates/codemirror/
+
 logs/
-log/
+log/
+
+.vscode/settings.json
+
+go.work.sum
+
+!src/config/
+
+todo.md

.gitlab-ci.yml

@@ -0,0 +1,15 @@
+build-image:
+  image: docker
+  rules:
+    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH
+      variables:
+        CI_REGISTRY_IMAGE: $CI_REGISTRY_IMAGE:latest
+    - if: $CI_COMMIT_REF_NAME != $CI_DEFAULT_BRANCH
+      variables:
+        CI_REGISTRY_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_BRANCH
+  before_script:
+    - echo $CI_REGISTRY_PASSWORD | docker login -u $CI_REGISTRY_USER $CI_REGISTRY --password-stdin
+  script:
+    - echo building $CI_REGISTRY_IMAGE
+    - docker build --pull -t $CI_REGISTRY_IMAGE .
+    - docker push $CI_REGISTRY_IMAGE

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "frontend"]
+	path = frontend
+	url = https://github.com/yusing/go-proxy-frontend

.vscode/settings.example.json

@@ -0,0 +1,13 @@
+{
+  "yaml.schemas": {
+    "https://github.com/yusing/go-proxy/raw/main/schema/config.schema.json": [
+      "config.example.yml",
+      "config.yml"
+    ],
+    "https://github.com/yusing/go-proxy/raw/main/schema/providers.schema.json": [
+      "providers.example.yml",
+      "*.providers.yml",
+      "providers.yml"
+    ]
+  }
+}

.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "go.inferGopath": false
-}

Dockerfile

@@ -1,22 +1,28 @@
-FROM alpine:latest
+FROM golang:1.23.1-alpine AS builder
+COPY src /src
+ENV GOCACHE=/root/.cache/go-build
+WORKDIR /src
+RUN --mount=type=cache,target="/go/pkg/mod" \
+    --mount=type=cache,target="/root/.cache/go-build" \
+    go mod download && \
+    CGO_ENABLED=0 GOOS=linux go build -pgo=auto -o go-proxy github.com/yusing/go-proxy
+
+FROM alpine:3.20
 
 LABEL maintainer="yusing@6uo.me"
 
-RUN apk add --no-cache bash tzdata
-RUN mkdir /app
-COPY bin/go-proxy entrypoint.sh /app/
-COPY templates/ /app/templates
-COPY config.example.yml /app/config.yml
+RUN apk add --no-cache tzdata
+# copy binary
+COPY --from=builder /src/go-proxy /app/
+COPY schema/ /app/schema
 
-RUN chmod +x /app/go-proxy /app/entrypoint.sh
-ENV DOCKER_HOST unix:///var/run/docker.sock
-ENV GOPROXY_DEBUG 0
-ENV GOPROXY_REDIRECT_HTTP 1
+RUN chmod +x /app/go-proxy
+ENV DOCKER_HOST=unix:///var/run/docker.sock
+ENV GOPROXY_DEBUG=0
 
 EXPOSE 80
-EXPOSE 8080
+EXPOSE 8888
 EXPOSE 443
-EXPOSE 8443
 
 WORKDIR /app
-ENTRYPOINT /app/entrypoint.sh
+CMD ["/app/go-proxy"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 [fullname]
+
+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.

Makefile

@@ -2,34 +2,46 @@
 
 all: build quick-restart logs
 
+setup:
+	mkdir -p config certs
+	[ -f config/config.yml ] || cp config.example.yml config/config.yml
+	[ -f config/providers.yml ] || touch config/providers.yml
+
 build:
 	mkdir -p bin
-	CGO_ENABLED=0 GOOS=linux go build -pgo=auto -o bin/go-proxy src/go-proxy/*.go
+	CGO_ENABLED=0 GOOS=linux go build -pgo=auto -o bin/go-proxy github.com/yusing/go-proxy
+
+test:
+	go test ./src/...
 
 up:
-	docker compose up -d --build go-proxy
-
-quick-restart: # quick restart without restarting the container
-	docker cp bin/go-proxy go-proxy:/app/go-proxy
-	docker cp templates/* go-proxy:/app/templates
-	docker cp entrypoint.sh go-proxy:/app/entrypoint.sh
-	docker exec -d go-proxy bash /app/entrypoint.sh restart
+	docker compose up -d
 
 restart:
-	docker kill go-proxy
-	docker compose up -d go-proxy
+	docker compose restart -t 0
 
 logs:
-	tail -f log/go-proxy.log
+	docker compose logs -f
 
 get:
-	go get -d -u ./src/go-proxy
+	cd src && go get -u && go mod tidy && cd ..
 
-udp-server:
-	docker run -it --rm \
-		-p 9999:9999/udp \
-		--label proxy.test-udp.scheme=udp \
-		--label proxy.test-udp.port=20003:9999 \
-		--network data_default \
-		--name test-udp \
-		$$(docker build -q -f udp-test-server.Dockerfile .)
+debug:
+	make build && sudo GOPROXY_DEBUG=1 bin/go-proxy
+
+archive:
+	git archive HEAD -o ../go-proxy-$$(date +"%Y%m%d%H%M").zip
+
+repush:
+	git reset --soft HEAD^
+	git add -A
+	git commit -m "repush"
+	git push gitlab dev --force
+
+rapid-crash:
+	sudo docker run --restart=always --name test_crash debian:bookworm-slim /bin/cat &&\
+	sleep 3 &&\
+	sudo docker rm -f test_crash
+
+debug-list-containers:
+	bash -c 'echo -e "GET /containers/json HTTP/1.0\r\n" | sudo netcat -U /var/run/docker.sock | tail -n +9 | jq'

README.md

@@ -1,386 +1,145 @@
 # go-proxy
 
-A simple auto docker reverse proxy for home use. **Written in _Go_**
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=ncloc)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
 
-In the examples domain `x.y.z` is used, replace them with your domain
+[繁體中文文檔請看此](README_CHT.md)
+
+A lightweight, easy-to-use, and [performant](docs/benchmark_result.md) reverse proxy with a web UI.
 
 ## Table of content
 
-- [Key Points](#key-points)
-- [How to use](#how-to-use)
-  - [Binary](#binary)
-  - [Docker](#docker)
-- [Configuration](#configuration)
-  - [Labels](#labels)
-  - [Environment Variables](#environment-variables)
-  - [Config File](#config-file)
-  - [Provider File](#provider-file)
-  - [Supported Cert Providers](#supported-cert-providers)
-- [Examples](#examples)
-  - [Single Port Configuration](#single-port-configuration-example)
-  - [Multiple Ports Configuration](#multiple-ports-configuration-example)
-  - [TCP/UDP Configuration](#tcpudp-configuration-example)
-  - [Load balancing Configuration](#load-balancing-configuration-example)
-- [Troubleshooting](#troubleshooting)
-- [Benchmarks](#benchmarks)
-- [Memory usage](#memory-usage)
-- [Build it yourself](#build-it-yourself)
+<!-- TOC -->
+
+- [go-proxy](#go-proxy)
+  - [Table of content](#table-of-content)
+  - [Key Points](#key-points)
+  - [Getting Started](#getting-started)
+    - [Setup](#setup)
+    - [Commands line arguments](#commands-line-arguments)
+    - [Environment variables](#environment-variables)
+    - [Use JSON Schema in VSCode](#use-json-schema-in-vscode)
+    - [Config File](#config-file)
+    - [Provider File](#provider-file)
+  - [Known issues](#known-issues)
+  - [Build it yourself](#build-it-yourself)
 
 ## Key Points
 
-- fast, nearly no performance penalty for end users when comparing to direct IP connections (See [benchmarks](#benchmarks))
-- auto detect reverse proxies from docker
-- additional reverse proxies from provider yaml file
-- allow multiple docker / file providers by custom `config.yml` file
-- auto certificate obtaining and renewal (See [Config File](#config-file) and [Supported Cert Providers](#supported-cert-providers))
-- subdomain matching **(domain name doesn't matter)**
-- path matching
-- HTTP proxy
-- TCP/UDP Proxy
-- HTTP round robin load balance support (same subdomain and path across different hosts)
-- Auto hot-reload on container start / die / stop or config changes.
-- Simple panel to see all reverse proxies and health (visit port [panel port] of go-proxy `https://*.y.z:[panel port]`)
+- Easy to use
+  - Effortless configuration
+  - Error messages is clear and detailed, easy troubleshooting
+- Auto certificate obtaining and renewal (See [Supported DNS Challenge Providers](docs/dns_providers.md))
+- Auto configuration for docker containers
+- Auto hot-reload on container state / config file changes
+- Stop containers on idle, wake it up on traffic _(optional)_
+- HTTP(s) reserve proxy
+- TCP and UDP port forwarding
+- Web UI for configuration and monitoring (See [screenshots](https://github.com/yusing/go-proxy-frontend?tab=readme-ov-file#screenshots))
+- Written in **[Go](https://go.dev)**
 
-  - you can customize it by modifying [templates/panel.html](templates/panel.html)
+[🔼Back to top](#table-of-content)
 
-  ![panel screenshot](screenshots/panel.png)
+## Getting Started
 
-## How to use
+### Setup
 
-1. Download and extract the latest release (or clone the repository if you want to try out experimental features)
+1. Setup DNS Records, e.g.
 
-2. Copy `config.example.yml` to `config.yml` and modify the content to fit your needs
+   - A Record: `*.y.z` -> `10.0.10.1`
+   - AAAA Record: `*.y.z` -> `::ffff:a00:a01`
 
-3. Do the same for `providers.example.yml`
+2. Setup `go-proxy` [See here](docs/docker.md)
 
-4. See [Binary](#binary) or [docker](#docker)
+3. Configure `go-proxy`
+   - with text editor (e.g. Visual Studio Code)
+   - or with web config editor via `http://gp.y.z`
 
-### Binary
+[🔼Back to top](#table-of-content)
 
-1. (Optional) enabled HTTPS
+### Commands line arguments
 
-   - Use autocert feature by completing `autocert` in `config.yml`
+| Argument    | Description                      | Example                    |
+| ----------- | -------------------------------- | -------------------------- |
+| empty       | start proxy server               |                            |
+| `validate`  | validate config and exit         |                            |
+| `reload`    | trigger a force reload of config |                            |
+| `ls-config` | list config and exit             | `go-proxy ls-config \| jq` |
+| `ls-route`  | list proxy entries and exit      | `go-proxy ls-route \| jq`  |
 
-   - Use existing certificate
-
-     Prepare your wildcard (`*.y.z`) SSL cert in `certs/`
-
-     - cert / chain / fullchain: `./certs/cert.crt`
-     - private key: `./certs/priv.key`
-
-2. run the binary `bin/go-proxy`
-
-3. enjoy
-
-### Docker
-
-1. Copy content from [compose.example.yml](compose.example.yml) and create your own `compose.yml`
-
-2. Add networks to make sure it is in the same network with other containers, or make sure `proxy.<alias>.host` is reachable
-
-3. (Optional) enable HTTPS
-
-   - Use autocert feature
-
-     1. mount `./certs` to `/app/certs`
-     ```yaml
-     go-proxy:
-      ...
-      volumes:
-        - ./certs:/app/certs
-     ```
-     2. complete `autocert` in `config.yml`
-
-   - Use existing certificate
-
-     Mount your wildcard (`*.y.z`) SSL cert to enable https. See [Getting SSL Certs](#getting-ssl-certs)
-
-     - cert / chain / fullchain -> `/app/certs/cert.crt`
-     - private key -> `/app/certs/priv.key`
-
-4. Start `go-proxy` with `docker compose up -d` or `make up`.
-
-5. (Optional) If you are using ufw with vpn that drop all inbound traffic except vpn, run below to allow docker containers to connect to `go-proxy`
-
-   In case the network of your container is in subnet `172.16.0.0/16` (bridge),
-   and vpn network is under `100.64.0.0/10` (i.e. tailscale)
-
-   `sudo ufw allow from 172.16.0.0/16 to 100.64.0.0/10`
-
-   You can also list CIDRs of all docker bridge networks by:
-
-   `docker network inspect $(docker network ls | awk '$3 == "bridge" { print $1}') | jq -r '.[] | .Name + " " + .IPAM.Config[0].Subnet' -`
-
-6. start your docker app, and visit <container_name>.y.z
-
-7. check the logs with `docker compose logs` or `make logs` to see if there is any error, check panel at [panel port] for active proxies
-
-## Known issues
-
-None
-
-## Configuration
-
-With container name, most of the time no label needs to be added.
-
-### Labels
-
-- `proxy.aliases`: comma separated aliases for subdomain matching
-  - defaults to `container_name`
-- `proxy.*.<field>`: wildcard config for all aliases
-- `proxy.<alias>.scheme`: container port protocol (`http` or `https`)
-  - defaults to `http`
-- `proxy.<alias>.host`: proxy host
-  - defaults to `container_name`
-- `proxy.<alias>.port`: proxy port
-  - http/https: defaults to first expose port (declared in `Dockerfile` or `docker-compose.yml`)
-  - tcp/udp: is in format of `[<listeningPort>:]<targetPort>`
-    - when `listeningPort` is omitted (not suggested), a free port will be used automatically.
-    - `targetPort` must be a number, or the predefined names (see [constants.go:14](src/go-proxy/constants.go#L14))
-- `proxy.<alias>.no_tls_verify`: whether skip tls verify when scheme is https
-  - defaults to false
-- `proxy.<alias>.path`: path matching (for http proxy only)
-  - defaults to empty
-- `proxy.<alias>.path_mode`: mode for path handling
-
-  - defaults to empty
-  - allowed: \<empty>, forward, sub
-    - empty: remove path prefix from URL when proxying
-      1. apps.y.z/webdav -> webdav:80
-      2. apps.y.z./webdav/path/to/file -> webdav:80/path/to/file
-    - forward: path remain unchanged
-      1. apps.y.z/webdav -> webdav:80/webdav
-      2. apps.y.z./webdav/path/to/file -> webdav:80/webdav/path/to/file
-    - sub: (experimental) remove path prefix from URL and also append path to HTML link attributes (`src`, `href` and `action`) and Javascript `fetch(url)` by response body substitution
-      e.g. apps.y.z/app1 -> webdav:80, `href="/path/to/file"` -> `href="/app1/path/to/file"`
-
-- `proxy.<alias>.load_balance`: enable load balance
-  - allowed: `1`, `true`
+**run with `docker exec <container_name> /app/go-proxy <command>`**
 
 ### Environment variables
 
-- `GOPROXY_DEBUG`: set to `1` or `true` to enable debug behaviors (i.e. output, etc.)
-- `GOPROXY_REDIRECT_HTTP`: set to `0` or `false` to disable http to https redirect (only when certs are located)
+| Environment Variable           | Description                   | Default | Values  |
+| ------------------------------ | ----------------------------- | ------- | ------- |
+| `GOPROXY_NO_SCHEMA_VALIDATION` | disable schema validation     | `false` | boolean |
+| `GOPROXY_DEBUG`                | enable debug behaviors        | `false` | boolean |
+| `GOPROXY_HTTP_PORT`            | http server port              | `80`    | integer |
+| `GOPROXY_HTTPS_PORT`           | http server port (if enabled) | `443`   | integer |
+| `GOPROXY_API_PORT`             | api server port               | `8888`  | integer |
+
+### Use JSON Schema in VSCode
+
+Copy [`.vscode/settings.example.json`](.vscode/settings.example.json) to `.vscode/settings.json` and modify it to fit your needs
+
+[🔼Back to top](#table-of-content)
 
 ### Config File
 
-See [config.example.yml](config.example.yml)
+See [config.example.yml](config.example.yml) for more
+
+```yaml
+# autocert configuration
+autocert:
+  email: # ACME Email
+  domains: # a list of domains for cert registration
+  provider: # DNS Challenge provider
+  options: # provider specific options
+    - ...
+# reverse proxy providers configuration
+providers:
+  include:
+    - providers.yml
+    - other_file_1.yml
+    - ...
+  docker:
+    local: $DOCKER_HOST
+    remote-1: tcp://10.0.2.1:2375
+    remote-2: ssh://root:1234@10.0.2.2
+```
+
+[🔼Back to top](#table-of-content)
 
 ### Provider File
 
-See [providers.example.yml](providers.example.yml)
+See [Fields](docs/docker.md#fields)
 
-### Supported cert providers
+See [providers.example.yml](providers.example.yml) for examples
 
-- Cloudflare
+[🔼Back to top](#table-of-content)
 
-  ```yaml
-  autocert:
-    ...
-    options:
-      auth_token: "YOUR_ZONE_API_TOKEN"
-  ```
+## Known issues
 
-  Follow [this guide](https://cloudkul.com/blog/automcatic-renew-and-generate-ssl-on-your-website-using-lego-client/) to create a new token with `Zone.DNS` read and edit permissions
+- Cert "renewal" is actually obtaining a new cert instead of renewing the existing one
 
-## Examples
+- `autocert` config is not hot-reloadable
 
-### Single port configuration example
-
-```yaml
-# (default) https://<container_name>.y.z
-whoami:
-  image: traefik/whoami
-  container_name: whoami # => whoami.y.z
-
-# enable both subdomain and path matching:
-whoami:
-  image: traefik/whoami
-  container_name: whoami
-  labels:
-    - proxy.aliases=whoami,apps
-    - proxy.apps.path=/whoami
-# 1. visit https://whoami.y.z
-# 2. visit https://apps.y.z/whoami
-```
-
-### Multiple ports configuration example
-
-```yaml
-minio:
-  image: quay.io/minio/minio
-  container_name: minio
-  ...
-  labels:
-    - proxy.aliases=minio,minio-console
-    - proxy.minio.port=9000
-    - proxy.minio-console.port=9001
-
-# visit https://minio.y.z to access minio
-# visit https://minio-console.y.z/whoami to access minio console
-```
-
-### TCP/UDP configuration example
-
-```yaml
-# In the app
-app-db:
-  image: postgres:15
-  container_name: app-db
-  ...
-  labels:
-    # Optional (postgres is in the known image map)
-    - proxy.app-db.scheme=tcp
-
-    # Optional (first free port will be used for listening port)
-    - proxy.app-db.port=20000:postgres
-
-# In go-proxy
-go-proxy:
-  ...
-  ports:
-    - 80:80
-    ...
-    - 20000:20000/tcp
-    # or 20000-20010:20000-20010/tcp to declare large range at once
-
-# access app-db via <*>.y.z:20000
-```
-
-## Load balancing Configuration Example
-
-```yaml
-nginx:
-  ...
-  deploy:
-    mode: replicated
-    replicas: 3
-  labels:
-    - proxy.nginx.load_balance=1 # allowed: [1, true]
-```
-
-## Troubleshooting
-
-Q: How to fix when it shows "no matching route for subdomain \<subdomain>"?
-
-A: Make sure the container is running, and \<subdomain> matches any container name / alias
-
-## Benchmarks
-
-Benchmarked with `wrk` connecting `traefik/whoami`'s `/bench` endpoint
-
-Remote benchmark (client running wrk and `go-proxy` server are different devices)
-
-- Direct connection
-
-  ```shell
-  root@yusing-pc:~# wrk -t 10 -c 200 -d 10s -H "Host: bench.6uo.me" --latency http://10.0.100.3:8003/bench
-  Running 10s test @ http://10.0.100.3:8003/bench
-    10 threads and 200 connections
-    Thread Stats   Avg      Stdev     Max   +/- Stdev
-      Latency    94.75ms  199.92ms   1.68s    91.27%
-      Req/Sec     4.24k     1.79k   18.79k    72.13%
-    Latency Distribution
-      50%    1.14ms
-      75%  120.23ms
-      90%  245.63ms
-      99%    1.03s
-    423444 requests in 10.10s, 50.88MB read
-    Socket errors: connect 0, read 0, write 0, timeout 29
-  Requests/sec:  41926.32
-  Transfer/sec:      5.04MB
-  ```
-
-- With reverse proxy
-
-  ```shell
-  root@yusing-pc:~# wrk -t 10 -c 200 -d 10s -H "Host: bench.6uo.me" --latency http://10.0.1.7/bench
-  Running 10s test @ http://10.0.1.7/bench
-    10 threads and 200 connections
-    Thread Stats   Avg      Stdev     Max   +/- Stdev
-      Latency    79.35ms  169.79ms   1.69s    92.55%
-      Req/Sec     4.27k     1.90k   19.61k    75.81%
-    Latency Distribution
-      50%    1.12ms
-      75%  105.66ms
-      90%  200.22ms
-      99%  814.59ms
-    409836 requests in 10.10s, 49.25MB read
-    Socket errors: connect 0, read 0, write 0, timeout 18
-  Requests/sec:  40581.61
-  Transfer/sec:      4.88MB
-  ```
-
-Local benchmark (client running wrk and `go-proxy` server are under same proxmox host but different LXCs)
-
-- Direct connection
-
-  ```
-  root@http-benchmark-client:~# wrk -t 10 -c 200 -d 10s --latency http://10.0.100.1/bench
-  Running 10s test @ http://10.0.100.1/bench
-    10 threads and 200 connections
-    Thread Stats   Avg      Stdev     Max   +/- Stdev
-      Latency   434.08us  539.35us   8.76ms   85.28%
-      Req/Sec    67.71k     6.31k   87.21k    71.20%
-    Latency Distribution
-      50%  153.00us
-      75%  646.00us
-      90%    1.18ms
-      99%    2.38ms
-    6739591 requests in 10.01s, 809.85MB read
-  Requests/sec: 673608.15
-  Transfer/sec:     80.94MB
-  ```
-
-- With `go-proxy` reverse proxy
-
-  ```
-  root@http-benchmark-client:~# wrk -t 10 -c 200 -d 10s -H "Host: bench.6uo.me" --latency http://10.0.1.7/bench
-  Running 10s test @ http://10.0.1.7/bench
-    10 threads and 200 connections
-    Thread Stats   Avg      Stdev     Max   +/- Stdev
-      Latency     1.23ms    0.96ms  11.43ms   72.09%
-      Req/Sec    17.48k     1.76k   21.48k    70.20%
-    Latency Distribution
-      50%    0.98ms
-      75%    1.76ms
-      90%    2.54ms
-      99%    4.24ms
-    1739079 requests in 10.01s, 208.97MB read
-  Requests/sec: 173779.44
-  Transfer/sec:     20.88MB
-  ```
-
-- With `traefik-v3`
-  ```
-  root@traefik-benchmark:~# wrk -t10 -c200 -d10s -H "Host: benchmark.whoami" --latency http://127.0.0.1:8000/bench
-  Running 10s test @ http://127.0.0.1:8000/bench
-    10 threads and 200 connections
-    Thread Stats   Avg      Stdev     Max   +/- Stdev
-      Latency     2.81ms   10.36ms 180.26ms   98.57%
-      Req/Sec    11.35k     1.74k   13.76k    85.54%
-    Latency Distribution
-      50%    1.59ms
-      75%    2.27ms
-      90%    3.17ms
-      99%   37.91ms
-    1125723 requests in 10.01s, 109.50MB read
-  Requests/sec: 112499.59
-  Transfer/sec:     10.94MB
-  ```
-
-## Memory usage
-
-It takes ~30 MB for 50 proxy entries
+[🔼Back to top](#table-of-content)
 
 ## Build it yourself
 
-1. Install [go](https://go.dev/doc/install) and `make` if not already
+1. Clone the repository `git clone https://github.com/yusing/go-proxy --depth=1`
 
-2. get dependencies with `make get`
+2. Install / Upgrade [go (>=1.22)](https://go.dev/doc/install) and `make` if not already
 
-3. build binary with `make build`
+3. Clear cache if you have built this before (go < 1.22) with `go clean -cache`
 
-4. start your container with `make up` (docker) or `bin/go-proxy` (binary)
+4. get dependencies with `make get`
 
-[panel port]: 8443
+5. build binary with `make build`
+
+[🔼Back to top](#table-of-content)

README_CHT.md

@@ -0,0 +1,140 @@
+# go-proxy
+
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=ncloc)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=yusing_go-proxy&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=yusing_go-proxy)
+
+一個輕量化、易用且[高效](docs/benchmark_result.md)的反向代理工具
+
+## 目錄
+
+<!-- TOC -->
+
+- [go-proxy](#go-proxy)
+  - [目錄](#目錄)
+  - [重點](#重點)
+  - [入門指南](#入門指南)
+    - [安裝](#安裝)
+    - [命令行參數](#命令行參數)
+    - [環境變量](#環境變量)
+    - [VSCode 中使用 JSON Schema](#vscode-中使用-json-schema)
+    - [配置文件](#配置文件)
+    - [透過文件配置](#透過文件配置)
+  - [已知問題](#已知問題)
+  - [源碼編譯](#源碼編譯)
+
+## 重點
+
+- 易用
+  - 不需花費太多時間就能輕鬆配置
+  - 除錯簡單
+- 自動處理 HTTPS 證書（參見[可用的 DNS 供應商](docs/dns_providers.md)）
+- 透過 Docker 容器自動配置
+- 容器狀態變更時自動熱重載
+- 容器閒置時自動暫停/停止，入站時自動喚醒
+- HTTP(s)反向代理
+- TCP/UDP 端口轉發
+- 用於配置和監控的前端 Web 面板（[截圖](https://github.com/yusing/go-proxy-frontend?tab=readme-ov-file#screenshots)）
+- 使用 **[Go](https://go.dev)** 編寫
+
+[🔼 返回頂部](#目錄)
+
+## 入門指南
+
+### 安裝
+
+1. 設置 DNS 記錄，例如：
+
+   - A 記錄: `*.y.z` -> `10.0.10.1`
+   - AAAA 記錄: `*.y.z` -> `::ffff:a00:a01`
+
+2. 安裝 `go-proxy` [參見這裡](docs/docker.md)
+
+3. 配置 `go-proxy`
+   - 使用文本編輯器 (推薦 Visual Studio Code [參見 VSCode 使用 schema](#vscode-中使用-json-schema))
+   - 或通過 `http://gp.y.z` 使用網頁配置編輯器
+
+[🔼 返回頂部](#目錄)
+
+### 命令行參數
+
+| 參數        | 描述           | 示例                       |
+| ----------- | -------------- | -------------------------- |
+| 空          | 啟動代理服務器 |                            |
+| `validate`  | 驗證配置並退出 |                            |
+| `reload`    | 強制刷新配置   |                            |
+| `ls-config` | 列出配置並退出 | `go-proxy ls-config \| jq` |
+| `ls-route`  | 列出路由並退出 | `go-proxy ls-route \| jq`  |
+
+**使用 `docker exec <容器名稱> /app/go-proxy <參數>` 運行**
+
+### 環境變量
+
+| 環境變量                       | 描述             | 默認    | 值      |
+| ------------------------------ | ---------------- | ------- | ------- |
+| `GOPROXY_NO_SCHEMA_VALIDATION` | 禁用 schema 驗證 | `false` | boolean |
+| `GOPROXY_DEBUG`                | 啟用調試輸出     | `false` | boolean |
+
+### VSCode 中使用 JSON Schema
+
+複製 [`.vscode/settings.example.json`](.vscode/settings.example.json) 到 `.vscode/settings.json` 並根據需求修改
+
+[🔼 返回頂部](#目錄)
+
+### 配置文件
+
+參見 [config.example.yml](config.example.yml) 了解更多
+
+```yaml
+# autocert 配置
+autocert:
+  email: # ACME 電子郵件
+  domains: # 域名列表
+  provider: # DNS 供應商
+  options: # 供應商個別配置
+    - ...
+# 配置文件 / docker
+providers:
+  include:
+    - providers.yml
+    - other_file_1.yml
+    - ...
+  docker:
+    local: $DOCKER_HOST
+    remote-1: tcp://10.0.2.1:2375
+    remote-2: ssh://root:1234@10.0.2.2
+```
+
+[🔼 返回頂部](#目錄)
+
+### 透過文件配置
+
+參見 [Fields](docs/docker.md#fields)
+
+參見範例 [providers.example.yml](providers.example.yml)
+
+[🔼 返回頂部](#目錄)
+
+## 已知問題
+
+- 證書“更新”實際上是獲取新證書而不是更新現有證書
+
+- `autocert` 配置不能熱重載
+
+[🔼 返回頂部](#目錄)
+
+## 源碼編譯
+
+1. 獲取源碼 `git clone https://github.com/yusing/go-proxy --depth=1`
+
+2. 安裝/升級 [go 版本 (>=1.22)](https://go.dev/doc/install) 和 `make`（如果尚未安裝）
+
+3. 如果之前編譯過（go 版本 < 1.22），請使用 `go clean -cache` 清除緩存
+
+4. 使用 `make get` 獲取依賴項
+
+5. 使用 `make build` 編譯
+
+[🔼 返回頂部](#目錄)

compose.example.yml

@@ -1,51 +1,33 @@
-version: '3'
 services:
+  frontend:
+    image: ghcr.io/yusing/go-proxy-frontend:latest
+    container_name: go-proxy-frontend
+    restart: unless-stopped
+    network_mode: host
+    labels:
+      - proxy.aliases=gp
+      - proxy.gp.port=3000
+    depends_on:
+      - app
   app:
-    build: .
+    image: ghcr.io/yusing/go-proxy:latest
     container_name: go-proxy
     restart: always
-    networks: # ^also add here
-      - default
-    # environment:
-      # - GOPROXY_DEBUG=1 # (optional, enable only for debug)
-      # - GOPROXY_REDIRECT_HTTP=0 # (optional, uncomment to disable http redirect (http -> https))
-    ports:
-      - 80:80 # http
-      # - 443:443 # optional, https
-      - 8080:8080 # http panel
-      # - 8443:8443 # optional, https panel
-
-      # optional, if you declared any tcp/udp proxy, set a range you want to use
-      # - 20000:20100/tcp
-      # - 20000:20100/udp
+    network_mode: host
+    environment:
+      # (Optional) change this to your timezone to get correct log timestamp
+      TZ: ETC/UTC
     volumes:
-      # use existing certificate
-      # - /path/to/cert.pem:/app/certs/cert.crt:ro
-      # - /path/to/privkey.pem:/app/certs/priv.key:ro
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ./config:/app/config
+
+      # (Optional) choose one of below to enable https
+      # 1. use existing certificate
+      # if your cert is not named `cert.crt` change `cert_path` in `config/config.yml`
+      # if your cert key is not named `priv.key` change `key_path` in `config/config.yml`
+
+      # - /path/to/certs:/app/certs
+
+      # 2. use autocert, certs will be stored in ./certs (or other path you specify)
 
-      # use autocert feature
       # - ./certs:/app/certs
-
-      # if local docker provider is used (by default)
-      - /var/run/docker.sock:/var/run/docker.sock:ro
-
-      # to use custom config
-      # - path/to/config.yml:/app/config.yml
-
-      # mount file provider yaml files
-      # - path/to/provider1.yml:/app/provider1.yml
-      # - path/to/provider2.yml:/app/provider2.yml
-      # etc.
-    dns:
-      - 127.0.0.1 # workaround for "lookup: no such host"
-    extra_hosts:
-      # required if you use local docker provider and have containers in `host` network_mode
-      - host.docker.internal:host-gateway
-    logging:
-      driver: 'json-file'
-      options:
-        max-file: '1'
-        max-size: 128k
-networks: # ^you may add other external networks
-  default:
-    driver: bridge

config.example.yml

@@ -1,25 +1,37 @@
-# uncomment to use autocert
+# Autocert (choose one below and uncomment to enable)
+
+# 1. use existing cert
+# autocert:
+#   provider: local
+#   cert_path: certs/cert.crt # optional, uncomment only if you need to change it
+#   key_path: certs/priv.key # optional, uncomment only if you need to change it
+
+# 2. cloudflare
 # autocert:
-#   email: "user@y.z" # email for acme certificate
-#   domains:
-#     - "*.y.z" # domain for acme certificate, use wild card to allow all subdomains
 #   provider: cloudflare
+#   email: # ACME Email
+#   domains: # a list of domains for cert registration
+#     - x.y.z
 #   options:
-#     auth_token: "YOUR_ZONE_API_TOKEN"
+#     - auth_token: c1234565789-abcdefghijklmnopqrst # your zone API token
+
+# 3. other providers, check readme for more
+
 providers:
-  local:
-    kind: docker
+  include:
+    - providers.yml # config/providers.yml
+    # add some more below if you want
+    # - file1.yml # config/file_1.yml
+    # - file2.yml
+  docker:
     # for value format, see https://docs.docker.com/reference/cli/dockerd/
-    value: FROM_ENV
-  # remote1:
-  #   kind: docker
-  #   value: ssh://user@10.0.1.1
-  # remote2:
-  #   kind: docker
-  #   value: tcp://10.0.1.1:2375
-  # provider1:
-  #   kind: file
-  #   value: provider1.yml
-  # provider2:
-  #   kind: file
-  #   value: provider2.yml
+    # $DOCKER_HOST implies unix:///var/run/docker.sock by default
+    local: $DOCKER_HOST
+    # add more docker providers if needed
+    # remote-1: tcp://10.0.2.1:2375
+    # remote-2: ssh://root:1234@10.0.2.2
+
+# Fixed options (optional, non hot-reloadable)
+
+# timeout_shutdown: 5
+# redirect_to_https: false

docs/add_dns_provider.md

@@ -0,0 +1,41 @@
+# Adding provider support
+
+## **CloudDNS** as an example
+
+1. Fork this repo, modify [autocert.go](../src/go-proxy/autocert.go#L305)
+
+   ```go
+   var providersGenMap = map[string]ProviderGenerator{
+     "cloudflare": providerGenerator(cloudflare.NewDefaultConfig, cloudflare.NewDNSProviderConfig),
+     // add here, e.g.
+     "clouddns": providerGenerator(clouddns.NewDefaultConfig, clouddns.NewDNSProviderConfig),
+   }
+   ```
+
+2. Go to [https://go-acme.github.io/lego/dns/clouddns](https://go-acme.github.io/lego/dns/clouddns/) and check for required config
+
+3. Build `go-proxy` with `make build`
+
+4. Set required config in `config.yml` `autocert` -> `options` section
+
+   ```shell
+   # From https://go-acme.github.io/lego/dns/clouddns/
+   CLOUDDNS_CLIENT_ID=bLsdFAks23429841238feb177a572aX \
+   CLOUDDNS_EMAIL=you@example.com \
+   CLOUDDNS_PASSWORD=b9841238feb177a84330f \
+   lego --email you@example.com --dns clouddns --domains my.example.org run
+   ```
+
+   Should turn into:
+
+   ```yaml
+   autocert:
+     ...
+     options:
+       client_id: bLsdFAks23429841238feb177a572aX
+       email: you@example.com
+       password: b9841238feb177a84330f
+   ```
+
+5. Run with `GOPROXY_NO_SCHEMA_VALIDATION=1` and test if it works
+6. Commit and create pull request

docs/benchmark_result.md

@@ -0,0 +1,104 @@
+# Benchmarks
+
+Benchmarked with `wrk` and `traefik/whoami`'s `/bench` endpoint
+
+## Remote benchmark
+
+- Direct connection
+
+  ```shell
+  root@yusing-pc:~# wrk -t 10 -c 200 -d 10s -H "Host: bench.6uo.me" --latency http://10.0.100.3:8003/bench
+  Running 10s test @ http://10.0.100.3:8003/bench
+    10 threads and 200 connections
+    Thread Stats   Avg      Stdev     Max   +/- Stdev
+      Latency    94.75ms  199.92ms   1.68s    91.27%
+      Req/Sec     4.24k     1.79k   18.79k    72.13%
+    Latency Distribution
+      50%    1.14ms
+      75%  120.23ms
+      90%  245.63ms
+      99%    1.03s
+    423444 requests in 10.10s, 50.88MB read
+    Socket errors: connect 0, read 0, write 0, timeout 29
+  Requests/sec:  41926.32
+  Transfer/sec:      5.04MB
+  ```
+
+- With reverse proxy
+
+  ```shell
+  root@yusing-pc:~# wrk -t 10 -c 200 -d 10s -H "Host: bench.6uo.me" --latency http://10.0.1.7/bench
+  Running 10s test @ http://10.0.1.7/bench
+    10 threads and 200 connections
+    Thread Stats   Avg      Stdev     Max   +/- Stdev
+      Latency    79.35ms  169.79ms   1.69s    92.55%
+      Req/Sec     4.27k     1.90k   19.61k    75.81%
+    Latency Distribution
+      50%    1.12ms
+      75%  105.66ms
+      90%  200.22ms
+      99%  814.59ms
+    409836 requests in 10.10s, 49.25MB read
+    Socket errors: connect 0, read 0, write 0, timeout 18
+  Requests/sec:  40581.61
+  Transfer/sec:      4.88MB
+  ```
+
+## Local benchmark (client running wrk and `go-proxy` server are under same proxmox host but different LXCs)
+
+- Direct connection
+
+  ```shell
+  root@http-benchmark-client:~# wrk -t 10 -c 200 -d 10s --latency http://10.0.100.1/bench
+  Running 10s test @ http://10.0.100.1/bench
+    10 threads and 200 connections
+    Thread Stats   Avg      Stdev     Max   +/- Stdev
+      Latency   434.08us  539.35us   8.76ms   85.28%
+      Req/Sec    67.71k     6.31k   87.21k    71.20%
+    Latency Distribution
+      50%  153.00us
+      75%  646.00us
+      90%    1.18ms
+      99%    2.38ms
+    6739591 requests in 10.01s, 809.85MB read
+  Requests/sec: 673608.15
+  Transfer/sec:     80.94MB
+  ```
+
+- With `go-proxy` reverse proxy
+
+  ```shell
+  root@http-benchmark-client:~# wrk -t 10 -c 200 -d 10s -H "Host: bench.6uo.me" --latency http://10.0.1.7/bench
+  Running 10s test @ http://10.0.1.7/bench
+    10 threads and 200 connections
+    Thread Stats   Avg      Stdev     Max   +/- Stdev
+      Latency     1.23ms    0.96ms  11.43ms   72.09%
+      Req/Sec    17.48k     1.76k   21.48k    70.20%
+    Latency Distribution
+      50%    0.98ms
+      75%    1.76ms
+      90%    2.54ms
+      99%    4.24ms
+    1739079 requests in 10.01s, 208.97MB read
+  Requests/sec: 173779.44
+  Transfer/sec:     20.88MB
+  ```
+
+- With `traefik-v3`
+
+  ```shell
+  root@traefik-benchmark:~# wrk -t10 -c200 -d10s -H "Host: benchmark.whoami" --latency http://127.0.0.1:8000/bench
+  Running 10s test @ http://127.0.0.1:8000/bench
+    10 threads and 200 connections
+    Thread Stats   Avg      Stdev     Max   +/- Stdev
+      Latency     2.81ms   10.36ms 180.26ms   98.57%
+      Req/Sec    11.35k     1.74k   13.76k    85.54%
+    Latency Distribution
+      50%    1.59ms
+      75%    2.27ms
+      90%    3.17ms
+      99%   37.91ms
+    1125723 requests in 10.01s, 109.50MB read
+  Requests/sec: 112499.59
+  Transfer/sec:     10.94MB
+  ```

docs/dns_providers.md

@@ -0,0 +1,53 @@
+# Supported DNS Providers
+
+<!-- TOC -->
+
+- [Supported DNS Providers](#supported-dns-providers)
+  - [Cloudflare](#cloudflare)
+  - [CloudDNS](#clouddns)
+  - [DuckDNS](#duckdns)
+  - [OVHCloud](#ovhcloud)
+  - [Implement other DNS providers](#implement-other-dns-providers)
+
+## Cloudflare
+
+`auth_token` your zone API token
+
+Follow [this guide](https://cloudkul.com/blog/automcatic-renew-and-generate-ssl-on-your-website-using-lego-client/) to create a new token with `Zone.DNS` read and edit permissions
+
+## CloudDNS
+
+- `client_id`
+
+- `email`
+
+- `password`
+
+## DuckDNS
+
+- `token`: DuckDNS Token
+
+Tested by [earvingad](https://github.com/earvingad)
+
+## OVHCloud
+
+_Note, `application_key` and `oauth2_config` **CANNOT** be used together_
+
+- `api_endpoint`: Endpoint URL, or one of
+  - `ovh-eu`,
+  - `ovh-ca`,
+  - `ovh-us`,
+  - `kimsufi-eu`,
+  - `kimsufi-ca`,
+  - `soyoustart-eu`,
+  - `soyoustart-ca`
+- `application_secret`
+- `application_key`
+- `consumer_key`
+- `oauth2_config`: Client ID and Client Secret
+  - `client_id`
+  - `client_secret`
+
+## Implement other DNS providers
+
+See [add_dns_provider.md](docs/add_dns_provider.md)

docs/docker.md

@@ -0,0 +1,314 @@
+# Docker compose guide
+
+## Table of content
+
+<!-- TOC -->
+
+- [Docker compose guide](#docker-compose-guide)
+  - [Table of content](#table-of-content)
+  - [Setup](#setup)
+  - [Labels](#labels)
+    - [Syntax](#syntax)
+    - [Fields](#fields)
+      - [Key-value mapping example](#key-value-mapping-example)
+      - [List example](#list-example)
+  - [Troubleshooting](#troubleshooting)
+  - [Docker compose examples](#docker-compose-examples)
+    - [Services URLs for above examples](#services-urls-for-above-examples)
+
+## Setup
+
+1.  Install `wget` if not already
+
+    - Ubuntu based: `sudo apt install -y wget`
+    - Fedora based: `sudo yum install -y wget`
+    - Arch based: `sudo pacman -Sy wget`
+
+2.  Run setup script
+
+    `bash <(wget -qO- https://github.com/yusing/go-proxy/raw/main/setup-docker.sh)`
+
+    It will setup folder structure and required config files
+
+3.  Verify folder structure and then `cd go-proxy`
+
+    ```plain
+    go-proxy
+    ├── certs
+    ├── compose.yml
+    └── config
+        ├── config.yml
+        └── providers.yml
+    ```
+
+4.  Enable HTTPs _(optional)_
+
+    Mount a folder (to store obtained certs) or (containing existing cert)
+
+    ```yaml
+    services:
+      go-proxy:
+        ...
+        volumes:
+          - ./certs:/app/certs
+    ```
+
+    To use **autocert**, complete that section in `config.yml`, e.g.
+
+    ```yaml
+    autocert:
+      email: john.doe@x.y.z # ACME Email
+      domains: # a list of domains for cert registration
+        - x.y.z
+      provider: cloudflare
+      options:
+        - auth_token: c1234565789-abcdefghijklmnopqrst # your zone API token
+    ```
+
+    To use **existing certificate**, set path for cert and key in `config.yml`, e.g.
+
+    ```yaml
+    autocert:
+      cert_path: /app/certs/cert.crt
+      key_path: /app/certs/priv.key
+    ```
+
+5.  Modify `compose.yml` to fit your needs
+
+6.  Run `docker compose up -d` to start the container
+
+7.  Navigate to Web panel `http://gp.yourdomain.com` or use **Visual Studio Code (provides schema check)** to edit proxy config
+
+[🔼Back to top](#table-of-content)
+
+## Labels
+
+### Syntax
+
+| Label                    | Description                                                           | Default              | Accepted values                                                           |
+| ------------------------ | --------------------------------------------------------------------- | -------------------- | ------------------------------------------------------------------------- |
+| `proxy.aliases`          | comma separated aliases for subdomain and label matching              | `container_name`     | any                                                                       |
+| `proxy.exclude`          | to be excluded from `go-proxy`                                        | false                | boolean                                                                   |
+| `proxy.idle_timeout`     | time for idle (no traffic) before put it into sleep **(http/s only)** | empty **(disabled)** | `number[unit]...`, e.g. `1m30s`                                           |
+| `proxy.wake_timeout`     | time to wait for container to start before responding a loading page  | empty                | `number[unit]...`                                                         |
+| `proxy.stop_method`      | method to stop after `idle_timeout`                                   | `stop`               | `stop`, `pause`, `kill`                                                   |
+| `proxy.stop_timeout`     | time to wait for stop command                                         | `10s`                | `number[unit]...`                                                         |
+| `proxy.stop_signal`      | signal sent to container for `stop` and `kill` methods                | docker's default     | `SIGINT`, `SIGTERM`, `SIGHUP`, `SIGQUIT` and those without **SIG** prefix |
+| `proxy.<alias>.<field>`  | set field for specific alias                                          | N/A                  | N/A                                                                       |
+| `proxy.$<index>.<field>` | set field for specific alias at index (starting from **1**)            | N/A                  | N/A                                                                       |
+| `proxy.*.<field>`        | set field for all aliases                                             | N/A                  | N/A                                                                       |
+
+### Fields
+
+| Field                 | Description                                                                                    | Default                                                                          | Allowed Values / Syntax                                                                                                                                 |
+| --------------------- | ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `scheme`              | proxy protocol                                                                                 | <ul><li>`http` for numeric port</li><li>`tcp` for `x:y` port</li></ul>           | `http`, `https`, `tcp`, `udp`                                                                                                                           |
+| `host`                | proxy host                                                                                     | <ul><li>Docker: docker client IP / hostname </li><li>File: `localhost`</li></ul> | IP address, hostname                                                                                                                                    |
+| `port`                | proxy port **(http/s)**                                                                        | first port in `ports:`                                                           | number in range of `1 - 65535`                                                                                                                          |
+| `port` **(required)** | proxy port **(tcp/udp)**                                                                       | N/A                                                                              | `x:y` <br><ul><li>x: port for `go-proxy` to listen on</li><li>y: port or [_service name_](../src/common/constants.go#L55) of target container</li></ul> |
+| `no_tls_verify`       | whether skip tls verify **(https only)**                                                       | `false`                                                                          | boolean                                                                                                                                                 |
+| `path_patterns`       | proxy path patterns **(http/s only)**<br> only requests that matched a pattern will be proxied | empty **(proxy all requests)**                                                   | yaml style list[<sup>1</sup>](#list-example) of path patterns ([syntax](https://pkg.go.dev/net/http#hdr-Patterns-ServeMux))                             |
+| `set_headers`         | header to set **(http/s only)**                                                                | empty                                                                            | yaml style key-value mapping[<sup>2</sup>](#key-value-mapping-example) of header-value pairs                                                            |
+| `hide_headers`        | header to hide **(http/s only)**                                                               | empty                                                                            | yaml style list[<sup>1</sup>](#list-example) of headers                                                                                                 |
+
+[🔼Back to top](#table-of-content)
+
+#### Key-value mapping example
+
+Docker Compose
+
+```yaml
+services:
+  nginx:
+    ...
+    labels:
+      # values from duplicated header keys will be combined
+      proxy.nginx.set_headers: | # remember to add the '|'
+        X-Custom-Header1: value1, value2
+        X-Custom-Header2: value3
+        X-Custom-Header2: value4
+      # X-Custom-Header2 will be "value3, value4"
+```
+
+File Provider
+
+```yaml
+service_a:
+  host: service_a.internal
+  set_headers:
+    # do not duplicate header keys, as it is not allowed in YAML
+    X-Custom-Header1: value1, value2
+    X-Custom-Header2: value3
+```
+
+[🔼Back to top](#table-of-content)
+
+#### List example
+
+Docker Compose
+
+```yaml
+services:
+  nginx:
+    ...
+    labels:
+      proxy.nginx.path_patterns: | # remember to add the '|'
+        - GET /
+        - POST /auth
+      proxy.nginx.hide_headers: | # remember to add the '|'
+        - X-Custom-Header1
+        - X-Custom-Header2
+```
+
+File Provider
+
+```yaml
+service_a:
+  host: service_a.internal
+  path_patterns:
+    - GET /
+    - POST /auth
+  hide_headers:
+    - X-Custom-Header1
+    - X-Custom-Header2
+```
+
+[🔼Back to top](#table-of-content)
+
+## Troubleshooting
+
+- Container not showing up in proxies list
+
+  Please check that either `ports` or label `proxy.<alias>.port` is declared, e.g.
+
+  ```yaml
+  services:
+    nginx-1: # Option 1
+      ...
+      ports:
+        - 80
+    nginx-2: # Option 2
+      ...
+      container_name: nginx-2
+      network_mode: host
+      labels:
+        proxy.nginx-2.port: 80
+  ```
+
+- Firewall issues
+
+  If you are using `ufw` with vpn that drop all inbound traffic except vpn, run below:
+
+  `sudo ufw allow from 172.16.0.0/16 to 100.64.0.0/10`
+
+  Explaination:
+
+  Docker network is usually `172.16.0.0/16`
+
+  Tailscale is used as an example, `100.64.0.0/10` will be the CIDR
+
+  You can also list CIDRs of all docker bridge networks by:
+
+  `docker network inspect $(docker network ls | awk '$3 == "bridge" { print $1}') | jq -r '.[] | .Name + " " + .IPAM.Config[0].Subnet' -`
+
+[🔼Back to top](#table-of-content)
+
+## Docker compose examples
+
+```yaml
+volumes:
+  adg-work:
+  adg-conf:
+  mc-data:
+  palworld:
+  nginx:
+services:
+  adg:
+    image: adguard/adguardhome
+    restart: unless-stopped
+    labels:
+      - proxy.aliases=adg,adg-dns,adg-setup
+      - proxy.$1.port=80
+      - proxy.$2.scheme=udp
+      - proxy.$2.port=20000:dns
+      - proxy.$3.port=3000
+    volumes:
+      - adg-work:/opt/adguardhome/work
+      - adg-conf:/opt/adguardhome/conf
+    ports:
+      - 80
+      - 3000
+      - 53/udp
+  mc:
+    image: itzg/minecraft-server
+    tty: true
+    stdin_open: true
+    container_name: mc
+    restart: unless-stopped
+    ports:
+      - 25565
+    labels:
+      - proxy.mc.scheme=tcp
+      - proxy.mc.port=20001:25565
+    environment:
+      - EULA=TRUE
+    volumes:
+      - mc-data:/data
+  palworld:
+    image: thijsvanloef/palworld-server-docker:latest
+    restart: unless-stopped
+    container_name: pal
+    stop_grace_period: 30s
+    ports:
+      - 8211/udp
+      - 27015/udp
+    labels:
+      - proxy.aliases=pal1,pal2
+      - proxy.*.scheme=udp
+      - proxy.$1.port=20002:8211
+      - proxy.$2.port=20003:27015
+    environment: ...
+    volumes:
+      - palworld:/palworld
+  nginx:
+    image: nginx
+    container_name: nginx
+    volumes:
+      - nginx:/usr/share/nginx/html
+    ports:
+      - 80
+    labels:
+      proxy.idle_timeout: 1m
+  go-proxy:
+    image: ghcr.io/yusing/go-proxy:latest
+    container_name: go-proxy
+    restart: always
+    network_mode: host
+    volumes:
+      - ./config:/app/config
+      - /var/run/docker.sock:/var/run/docker.sock
+  go-proxy-frontend:
+    image: ghcr.io/yusing/go-proxy-frontend:latest
+    container_name: go-proxy-frontend
+    restart: unless-stopped
+    network_mode: host
+    labels:
+      - proxy.aliases=gp
+      - proxy.gp.port=3000
+    depends_on:
+      - go-proxy
+```
+
+[🔼Back to top](#table-of-content)
+
+### Services URLs for above examples
+
+- `gp.yourdomain.com`: go-proxy web panel
+- `adg-setup.yourdomain.com`: adguard setup (first time setup)
+- `adg.yourdomain.com`: adguard dashboard
+- `nginx.yourdomain.com`: nginx
+- `yourdomain.com:2000`: adguard dns (udp)
+- `yourdomain.com:20001`: minecraft server
+- `yourdomain.com:20002`: palworld server
+
+[🔼Back to top](#table-of-content)

entrypoint.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-if [ "$1" == "restart" ]; then
-    echo "restarting"
-    killall go-proxy
-fi
-if [ "$GOPROXY_DEBUG" == "1" ]; then
-    /app/go-proxy 2> log/go-proxy.log &
-    tail -f /dev/null
-else
-    /app/go-proxy
-fi

go.mod

@@ -1,52 +0,0 @@
-module github.com/yusing/go-proxy
-
-go 1.21.7
-
-require (
-	github.com/docker/cli v26.0.0+incompatible
-	github.com/docker/docker v26.0.0+incompatible
-	github.com/fsnotify/fsnotify v1.7.0
-	github.com/go-acme/lego/v4 v4.16.1
-	github.com/sirupsen/logrus v1.9.3
-	golang.org/x/net v0.22.0
-	gopkg.in/yaml.v3 v3.0.1
-)
-
-require (
-	github.com/Microsoft/go-winio v0.6.1 // indirect
-	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
-	github.com/cloudflare/cloudflare-go v0.91.0 // indirect
-	github.com/containerd/log v0.1.0 // indirect
-	github.com/distribution/reference v0.5.0 // indirect
-	github.com/docker/go-connections v0.5.0 // indirect
-	github.com/docker/go-units v0.5.0 // indirect
-	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/go-jose/go-jose/v4 v4.0.1 // indirect
-	github.com/go-logr/logr v1.4.1 // indirect
-	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/goccy/go-json v0.10.2 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/google/go-querystring v1.1.0 // indirect
-	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
-	github.com/hashicorp/go-retryablehttp v0.7.5 // indirect
-	github.com/miekg/dns v1.1.58 // indirect
-	github.com/moby/docker-image-spec v1.3.1 // indirect
-	github.com/moby/term v0.5.0 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.1.0 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 // indirect
-	go.opentelemetry.io/otel v1.24.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0 // indirect
-	go.opentelemetry.io/otel/metric v1.24.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.24.0 // indirect
-	go.opentelemetry.io/otel/trace v1.24.0 // indirect
-	golang.org/x/crypto v0.21.0 // indirect
-	golang.org/x/mod v0.16.0 // indirect
-	golang.org/x/sys v0.18.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-	golang.org/x/time v0.5.0 // indirect
-	golang.org/x/tools v0.19.0 // indirect
-	gotest.tools/v3 v3.5.1 // indirect
-)

go.work

@@ -0,0 +1,5 @@
+go 1.22.0
+
+toolchain go1.23.1
+
+use ./src

providers.example.yml

@@ -1,15 +1,22 @@
-app: # matching `app.y.z`
-  # optional
-  scheme: http
-  # required, proxy target
+example: # matching `app.y.z`
+  scheme: https
   host: 10.0.0.1
-  # optional
   port: 80
-  # optional, defaults to empty
-  path:
-  # optional
-  path_mode:
-  # optional
-  notlsverify: false
-# app2:
-#   ...
+  path_patterns: # Check https://pkg.go.dev/net/http#hdr-Patterns-ServeMux for syntax
+    - GET / # accept any GET request
+    - POST /auth # for /auth and /auth/* accept only POST
+    - GET /home/{$}
+    - /b/{bucket}/o/{any}
+  no_tls_verify: false
+  set_headers:
+    HEADER_A: VALUE_A, VALUE_B
+    HEADER_B: VALUE_C
+  hide_headers:
+    - HEADER_C
+    - HEADER_D
+app1:
+  host: some_host
+app2:
+  scheme: tcp
+  host: 10.0.0.2
+  port: 20000:tcp

schema/config.schema.json

@@ -0,0 +1,283 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "go-proxy config file",
+  "properties": {
+    "autocert": {
+      "title": "Autocert configuration",
+      "type": "object",
+      "properties": {
+        "email": {
+          "title": "ACME Email",
+          "type": "string",
+          "pattern": "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$",
+          "patternErrorMessage": "Invalid email"
+        },
+        "domains": {
+          "title": "Cert Domains",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "minItems": 1
+        },
+        "cert_path": {
+          "title": "path of cert file to load/store",
+          "default": "certs/cert.crt",
+          "markdownDescription": "default: `certs/cert.crt`",
+          "type": "string"
+        },
+        "key_path": {
+          "title": "path of key file to load/store",
+          "default": "certs/priv.key",
+          "markdownDescription": "default: `certs/priv.key`",
+          "type": "string"
+        },
+        "provider": {
+          "title": "DNS Challenge Provider",
+          "default": "local",
+          "type": "string",
+          "enum": ["local", "cloudflare", "clouddns", "duckdns", "ovh"]
+        },
+        "options": {
+          "title": "Provider specific options",
+          "type": "object"
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "not": {
+              "properties": {
+                "provider": {
+                  "const": "local"
+                }
+              }
+            }
+          },
+          "then": {
+            "required": ["email", "domains", "provider", "options"]
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "provider": {
+                "const": "cloudflare"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "options": {
+                "required": ["auth_token"],
+                "additionalProperties": false,
+                "properties": {
+                  "auth_token": {
+                    "description": "Cloudflare API Token with Zone Scope",
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "provider": {
+                "const": "clouddns"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "options": {
+                "required": ["client_id", "email", "password"],
+                "additionalProperties": false,
+                "properties": {
+                  "client_id": {
+                    "description": "CloudDNS Client ID",
+                    "type": "string"
+                  },
+                  "email": {
+                    "description": "CloudDNS Email",
+                    "type": "string"
+                  },
+                  "password": {
+                    "description": "CloudDNS Password",
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "provider": {
+                "const": "duckdns"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "options": {
+                "required": ["token"],
+                "additionalProperties": false,
+                "properties": {
+                  "token": {
+                    "description": "DuckDNS Token",
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "provider": {
+                "const": "ovh"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "options": {
+                "required": ["application_secret", "consumer_key"],
+                "additionalProperties": false,
+                "oneOf": [
+                  {
+                    "required": ["application_key"]
+                  },
+                  {
+                    "required": ["oauth2_config"]
+                  }
+                ],
+                "properties": {
+                  "api_endpoint": {
+                    "description": "OVH API endpoint",
+                    "default": "ovh-eu",
+                    "anyOf": [
+                      {
+                        "enum": [
+                          "ovh-eu",
+                          "ovh-ca",
+                          "ovh-us",
+                          "kimsufi-eu",
+                          "kimsufi-ca",
+                          "soyoustart-eu",
+                          "soyoustart-ca"
+                        ]
+                      },
+                      {
+                        "type": "string",
+                        "format": "uri"
+                      }
+                    ]
+                  },
+                  "application_secret": {
+                    "description": "OVH Application Secret",
+                    "type": "string"
+                  },
+                  "consumer_key": {
+                    "description": "OVH Consumer Key",
+                    "type": "string"
+                  },
+                  "application_key": {
+                    "description": "OVH Application Key",
+                    "type": "string"
+                  },
+                  "oauth2_config": {
+                    "description": "OVH OAuth2 config",
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "client_id": {
+                        "description": "OVH Client ID",
+                        "type": "string"
+                      },
+                      "client_secret": {
+                        "description": "OVH Client Secret",
+                        "type": "string"
+                      }
+                    },
+                    "required": ["client_id", "client_secret"]
+                  }
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    "providers": {
+      "title": "Proxy providers configuration",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "include": {
+          "title": "Proxy providers configuration files",
+          "description": "relative path to 'config'",
+          "type": "array",
+          "items": {
+            "type": "string",
+            "pattern": "^[a-zA-Z0-9_-]+\\.(yml|yaml)$",
+            "patternErrorMessage": "Invalid file name"
+          }
+        },
+        "docker": {
+          "title": "Docker provider configuration",
+          "description": "docker clients (name-address pairs)",
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9-_]+$": {
+              "type": "string",
+              "examples": [
+                "unix:///var/run/docker.sock",
+                "tcp://127.0.0.1:2375",
+                "ssh://user@host:port"
+              ],
+              "oneOf": [
+                {
+                  "const": "$DOCKER_HOST",
+                  "description": "Use DOCKER_HOST environment variable"
+                },
+                {
+                  "pattern": "^unix://.+$",
+                  "description": "A Unix socket for local Docker communication."
+                },
+                {
+                  "pattern": "^ssh://.+$",
+                  "description": "An SSH connection to a remote Docker host."
+                },
+                {
+                  "pattern": "^fd://.+$",
+                  "description": "A file descriptor for Docker communication."
+                },
+                {
+                  "pattern": "^tcp://.+$",
+                  "description": "A TCP connection to a remote Docker host."
+                }
+              ]
+            }
+          }
+        }
+      }
+    },
+    "timeout_shutdown": {
+      "title": "Shutdown timeout (in seconds)",
+      "type": "integer",
+      "minimum": 0
+    },
+    "redirect_to_https": {
+      "title": "Redirect to HTTPS on HTTP requests",
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false,
+  "required": ["providers"]
+}

schema/providers.schema.json

@@ -0,0 +1,195 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "go-proxy providers file",
+  "oneOf": [
+    {
+      "type": "object"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "patternProperties": {
+    "^[a-zA-Z0-9_-]+$": {
+      "title": "Proxy entry",
+      "type": "object",
+      "properties": {
+        "scheme": {
+          "title": "Proxy scheme (http, https, tcp, udp)",
+          "oneOf": [
+            {
+              "type": "string",
+              "enum": [
+                "http",
+                "https",
+                "tcp",
+                "udp",
+                "tcp:tcp",
+                "udp:udp",
+                "tcp:udp",
+                "udp:tcp"
+              ]
+            },
+            {
+              "type": "null",
+              "description": "Auto detect base on port format"
+            }
+          ]
+        },
+        "host": {
+          "default": "localhost",
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "localhost (default)"
+            },
+            {
+              "type": "string",
+              "format": "ipv4",
+              "description": "Proxy to ipv4 address"
+            },
+            {
+              "type": "string",
+              "format": "ipv6",
+              "description": "Proxy to ipv6 address"
+            },
+            {
+              "type": "string",
+              "format": "hostname",
+              "description": "Proxy to hostname"
+            }
+          ],
+          "title": "Proxy host (ipv4 / ipv6 / hostname)"
+        },
+        "port": {},
+        "no_tls_verify": {},
+        "path_patterns": {},
+        "set_headers": {},
+        "hide_headers": {}
+      },
+      "additionalProperties": false,
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "scheme": {
+                "anyOf": [
+                  {
+                    "enum": ["http", "https"]
+                  },
+                  {
+                    "type": "null"
+                  }
+                ]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "port": {
+                "markdownDescription": "Proxy port from **1** to **65535**",
+                "oneOf": [
+                  {
+                    "type": "string",
+                    "pattern": "^\\d{1,5}$",
+                    "patternErrorMessage": "`port` must be a number"
+                  },
+                  {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 65535
+                  }
+                ]
+              },
+              "path_patterns": {
+                "oneOf": [
+                  {
+                    "type": "array",
+                    "markdownDescription": "A list of [path patterns](https://pkg.go.dev/net/http#hdr-Patterns-ServeMux)",
+                    "items": {
+                      "type": "string",
+                      "pattern": "^((GET|POST|DELETE|PUT|PATCH|HEAD|OPTIONS|CONNECT)\\s)?(/(\\w*|{\\w*}|{\\$}))+/?$",
+                      "patternErrorMessage": "invalid path pattern"
+                    }
+                  },
+                  {
+                    "type": "null",
+                    "description": "No proxy path"
+                  }
+                ]
+              },
+              "set_headers": {
+                "type": "object",
+                "description": "Proxy headers to set",
+                "additionalProperties": {
+                  "items": {
+                    "type": "object",
+                    "additionalProperties": {
+                      "type": "string"
+                    }
+                  }
+                }
+              },
+              "hide_headers": {
+                "type": "array",
+                "description": "Proxy headers to hide",
+                "items": {
+                  "type": "string"
+                }
+              }
+            }
+          },
+          "else": {
+            "properties": {
+              "port": {
+                "markdownDescription": "`listening port:proxy port` or `listening port:service name`",
+                "type": "string",
+                "pattern": "^[0-9]+\\:[0-9a-z]+$",
+                "patternErrorMessage": "invalid syntax"
+              },
+              "no_tls_verify": {
+                "not": true
+              },
+              "path_patterns": {
+                "not": true
+              },
+              "set_headers": {
+                "not": true
+              },
+              "hide_headers": {
+                "not": true
+              }
+            },
+            "required": ["port"]
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "scheme": {
+                "const": "https"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "no_tls_verify": {
+                "description": "Disable TLS verification for https proxy",
+                "type": "boolean",
+                "default": false
+              }
+            }
+          },
+          "else": {
+            "properties": {
+              "no_tls_verify": {
+                "not": true
+              }
+            }
+          }
+        }
+      ]
+    }
+  },
+  "additionalProperties": false
+}

setup-docker.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+set -e
+if [ -z "$BRANCH" ]; then
+    BRANCH="v0.5"
+fi
+BASE_URL="https://github.com/yusing/go-proxy/raw/${BRANCH}"
+mkdir -p go-proxy
+cd go-proxy
+mkdir -p config
+mkdir -p certs
+[ -f compose.yml ] || wget -cO - ${BASE_URL}/compose.example.yml > compose.yml
+[ -f config/config.yml ] || wget -cO - ${BASE_URL}/config.example.yml > config/config.yml
+[ -f config/providers.yml ] || touch config/providers.yml

src/api/handler.go

@@ -0,0 +1,30 @@
+package api
+
+import (
+	"net/http"
+
+	v1 "github.com/yusing/go-proxy/api/v1"
+	"github.com/yusing/go-proxy/config"
+)
+
+func NewHandler(cfg *config.Config) http.Handler {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /v1", v1.Index)
+	mux.HandleFunc("GET /v1/checkhealth", wrap(cfg, v1.CheckHealth))
+	mux.HandleFunc("HEAD /v1/checkhealth", wrap(cfg, v1.CheckHealth))
+	mux.HandleFunc("POST /v1/reload", wrap(cfg, v1.Reload))
+	mux.HandleFunc("GET /v1/list", wrap(cfg, v1.List))
+	mux.HandleFunc("GET /v1/list/{what}", wrap(cfg, v1.List))
+	mux.HandleFunc("GET /v1/file", v1.GetFileContent)
+	mux.HandleFunc("GET /v1/file/{filename}", v1.GetFileContent)
+	mux.HandleFunc("POST /v1/file/{filename}", v1.SetFileContent)
+	mux.HandleFunc("PUT /v1/file/{filename}", v1.SetFileContent)
+	mux.HandleFunc("GET /v1/stats", wrap(cfg, v1.Stats))
+	return mux
+}
+
+func wrap(cfg *config.Config, f func(cfg *config.Config, w http.ResponseWriter, r *http.Request)) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		f(cfg, w, r)
+	}
+}

src/api/v1/checkhealth.go

@@ -0,0 +1,42 @@
+package v1
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	U "github.com/yusing/go-proxy/api/v1/utils"
+	"github.com/yusing/go-proxy/config"
+	R "github.com/yusing/go-proxy/route"
+)
+
+func CheckHealth(cfg *config.Config, w http.ResponseWriter, r *http.Request) {
+	target := r.FormValue("target")
+	if target == "" {
+		U.HandleErr(w, r, U.ErrMissingKey("target"), http.StatusBadRequest)
+		return
+	}
+
+	var ok bool
+	route := cfg.FindRoute(target)
+
+	switch {
+	case route == nil:
+		U.HandleErr(w, r, U.ErrNotFound("target", target), http.StatusNotFound)
+		return
+	case route.Type() == R.RouteTypeReverseProxy:
+		ok = U.IsSiteHealthy(route.URL().String())
+	case route.Type() == R.RouteTypeStream:
+		entry := route.Entry()
+		ok = U.IsStreamHealthy(
+			strings.Split(entry.Scheme, ":")[1], // target scheme
+			fmt.Sprintf("%s:%v", entry.Host, strings.Split(entry.Port, ":")[1]),
+		)
+	}
+
+	if ok {
+		w.WriteHeader(http.StatusOK)
+	} else {
+		w.WriteHeader(http.StatusRequestTimeout)
+	}
+}

src/api/v1/file.go

@@ -0,0 +1,57 @@
+package v1
+
+import (
+	"io"
+	"net/http"
+	"os"
+	"path"
+
+	U "github.com/yusing/go-proxy/api/v1/utils"
+	"github.com/yusing/go-proxy/common"
+	"github.com/yusing/go-proxy/config"
+	"github.com/yusing/go-proxy/proxy/provider"
+)
+
+func GetFileContent(w http.ResponseWriter, r *http.Request) {
+	filename := r.PathValue("filename")
+	if filename == "" {
+		filename = common.ConfigFileName
+	}
+	content, err := os.ReadFile(path.Join(common.ConfigBasePath, filename))
+	if err != nil {
+		U.HandleErr(w, r, err)
+		return
+	}
+	w.Write(content)
+}
+
+func SetFileContent(w http.ResponseWriter, r *http.Request) {
+	filename := r.PathValue("filename")
+	if filename == "" {
+		U.HandleErr(w, r, U.ErrMissingKey("filename"), http.StatusBadRequest)
+		return
+	}
+	content, err := io.ReadAll(r.Body)
+	if err != nil {
+		U.HandleErr(w, r, err)
+		return
+	}
+
+	if filename == common.ConfigFileName {
+		err = config.Validate(content).Error()
+	} else {
+		err = provider.Validate(content).Error()
+	}
+
+	if err != nil {
+		U.HandleErr(w, r, err, http.StatusBadRequest)
+		return
+	}
+
+	err = os.WriteFile(path.Join(common.ConfigBasePath, filename), content, 0644)
+	if err != nil {
+		U.HandleErr(w, r, err)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}

src/api/v1/index.go

@@ -0,0 +1,7 @@
+package v1
+
+import "net/http"
+
+func Index(w http.ResponseWriter, r *http.Request) {
+	w.Write([]byte("API ready"))
+}

src/api/v1/list.go

@@ -0,0 +1,62 @@
+package v1
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+
+	"github.com/yusing/go-proxy/common"
+	"github.com/yusing/go-proxy/config"
+
+	U "github.com/yusing/go-proxy/api/v1/utils"
+)
+
+func List(cfg *config.Config, w http.ResponseWriter, r *http.Request) {
+	what := r.PathValue("what")
+	if what == "" {
+		what = "routes"
+	}
+
+	switch what {
+	case "routes":
+		listRoutes(cfg, w, r)
+	case "config_files":
+		listConfigFiles(w, r)
+	default:
+		U.HandleErr(w, r, U.ErrInvalidKey("what"), http.StatusBadRequest)
+	}
+}
+
+func listRoutes(cfg *config.Config, w http.ResponseWriter, r *http.Request) {
+	routes := cfg.RoutesByAlias()
+	typeFilter := r.FormValue("type")
+	if typeFilter != "" {
+		for k, v := range routes {
+			if v["type"] != typeFilter {
+				delete(routes, k)
+			}
+		}
+	}
+
+	if err := U.RespondJson(routes, w); err != nil {
+		U.HandleErr(w, r, err)
+	}
+}
+
+func listConfigFiles(w http.ResponseWriter, r *http.Request) {
+	files, err := os.ReadDir(common.ConfigBasePath)
+	if err != nil {
+		U.HandleErr(w, r, err)
+		return
+	}
+	filenames := make([]string, len(files))
+	for i, f := range files {
+		filenames[i] = f.Name()
+	}
+	resp, err := json.Marshal(filenames)
+	if err != nil {
+		U.HandleErr(w, r, err)
+		return
+	}
+	w.Write(resp)
+}

src/api/v1/reload.go

@@ -0,0 +1,16 @@
+package v1
+
+import (
+	"net/http"
+
+	U "github.com/yusing/go-proxy/api/v1/utils"
+	"github.com/yusing/go-proxy/config"
+)
+
+func Reload(cfg *config.Config, w http.ResponseWriter, r *http.Request) {
+	if err := cfg.Reload().Error(); err != nil {
+		U.HandleErr(w, r, err)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}

src/api/v1/stats.go

@@ -0,0 +1,20 @@
+package v1
+
+import (
+	"net/http"
+
+	U "github.com/yusing/go-proxy/api/v1/utils"
+	"github.com/yusing/go-proxy/config"
+	"github.com/yusing/go-proxy/server"
+	"github.com/yusing/go-proxy/utils"
+)
+
+func Stats(cfg *config.Config, w http.ResponseWriter, r *http.Request) {
+	stats := map[string]any{
+		"proxies": cfg.Statistics(),
+		"uptime":  utils.FormatDuration(server.GetProxyServer().Uptime()),
+	}
+	if err := U.RespondJson(stats, w); err != nil {
+		U.HandleErr(w, r, err)
+	}
+}

src/api/v1/utils/error.go

@@ -0,0 +1,32 @@
+package utils
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/sirupsen/logrus"
+	E "github.com/yusing/go-proxy/error"
+)
+
+func HandleErr(w http.ResponseWriter, r *http.Request, origErr error, code ...int) {
+	err := E.From(origErr).Subjectf("%s %s", r.Method, r.URL)
+	logrus.WithField("module", "api").Error(err)
+	if len(code) > 0 {
+		http.Error(w, err.String(), code[0])
+		return
+	}
+	http.Error(w, err.String(), http.StatusInternalServerError)
+}
+
+func ErrMissingKey(k string) error {
+	return errors.New("missing key '" + k + "' in query or request body")
+}
+
+func ErrInvalidKey(k string) error {
+	return errors.New("invalid key '" + k + "' in query or request body")
+}
+
+func ErrNotFound(k, v string) error {
+	return fmt.Errorf("key %q with value %q not found", k, v)
+}

src/api/v1/utils/net.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+	"crypto/tls"
+	"fmt"
+	"net"
+	"net/http"
+
+	"github.com/yusing/go-proxy/common"
+	E "github.com/yusing/go-proxy/error"
+)
+
+func IsSiteHealthy(url string) bool {
+	// try HEAD first
+	// if HEAD is not allowed, try GET
+	resp, err := HttpClient.Head(url)
+	if resp != nil {
+		resp.Body.Close()
+	}
+	if err != nil && resp != nil && resp.StatusCode == http.StatusMethodNotAllowed {
+		_, err = HttpClient.Get(url)
+	}
+	if resp != nil {
+		resp.Body.Close()
+	}
+	return err == nil
+}
+
+func IsStreamHealthy(scheme, address string) bool {
+	conn, err := net.DialTimeout(scheme, address, common.DialTimeout)
+	if err != nil {
+		return false
+	}
+	conn.Close()
+	return true
+}
+
+func ReloadServer() E.NestedError {
+	resp, err := HttpClient.Post(fmt.Sprintf("http://localhost%v/reload", common.APIHTTPPort), "", nil)
+	if err != nil {
+		return E.From(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return E.Failure("server reload").Subjectf("status code: %v", resp.StatusCode)
+	}
+	return nil
+}
+
+var HttpClient = &http.Client{
+	Timeout: common.ConnectionTimeout,
+	Transport: &http.Transport{
+		Proxy:             http.ProxyFromEnvironment,
+		DisableKeepAlives: true,
+		ForceAttemptHTTP2: true,
+		DialContext: (&net.Dialer{
+			Timeout:   common.DialTimeout,
+			KeepAlive: common.KeepAlive, // this is different from DisableKeepAlives
+		}).DialContext,
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	},
+}

src/api/v1/utils/utils.go

@@ -0,0 +1,17 @@
+package utils
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func RespondJson(data any, w http.ResponseWriter) error {
+	w.Header().Set("Content-Type", "application/json")
+	j, err := json.Marshal(data)
+	if err != nil {
+		return err
+	} else {
+		w.Write(j)
+	}
+	return nil
+}

src/autocert/config.go

@@ -0,0 +1,75 @@
+package autocert
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+
+	"github.com/go-acme/lego/v4/certcrypto"
+	"github.com/go-acme/lego/v4/lego"
+	E "github.com/yusing/go-proxy/error"
+	M "github.com/yusing/go-proxy/models"
+)
+
+type Config M.AutoCertConfig
+
+func NewConfig(cfg *M.AutoCertConfig) *Config {
+	if cfg.CertPath == "" {
+		cfg.CertPath = CertFileDefault
+	}
+	if cfg.KeyPath == "" {
+		cfg.KeyPath = KeyFileDefault
+	}
+	if cfg.Provider == "" {
+		cfg.Provider = ProviderLocal
+	}
+	return (*Config)(cfg)
+}
+
+func (cfg *Config) GetProvider() (provider *Provider, res E.NestedError) {
+	b := E.NewBuilder("unable to initialize autocert")
+	defer b.To(&res)
+
+	if cfg.Provider != ProviderLocal {
+		if len(cfg.Domains) == 0 {
+			b.Addf("no domains specified")
+		}
+		if cfg.Provider == "" {
+			b.Addf("no provider specified")
+		}
+		if cfg.Email == "" {
+			b.Addf("no email specified")
+		}
+		// check if provider is implemented
+		_, ok := providersGenMap[cfg.Provider]
+		if !ok {
+			b.Addf("unknown provider: %q", cfg.Provider)
+		}
+	}
+
+	if b.HasError() {
+		return
+	}
+
+	privKey, err := E.Check(ecdsa.GenerateKey(elliptic.P256(), rand.Reader))
+	if err.HasError() {
+		b.Add(E.FailWith("generate private key", err))
+		return
+	}
+
+	user := &User{
+		Email: cfg.Email,
+		key:   privKey,
+	}
+
+	legoCfg := lego.NewConfig(user)
+	legoCfg.Certificate.KeyType = certcrypto.RSA2048
+
+	provider = &Provider{
+		cfg:     cfg,
+		user:    user,
+		legoCfg: legoCfg,
+	}
+
+	return
+}

src/autocert/constants.go

@@ -0,0 +1,40 @@
+package autocert
+
+import (
+	"errors"
+
+	"github.com/go-acme/lego/v4/providers/dns/clouddns"
+	"github.com/go-acme/lego/v4/providers/dns/cloudflare"
+	"github.com/go-acme/lego/v4/providers/dns/duckdns"
+	"github.com/go-acme/lego/v4/providers/dns/ovh"
+	"github.com/sirupsen/logrus"
+)
+
+const (
+	certBasePath     = "certs/"
+	CertFileDefault  = certBasePath + "cert.crt"
+	KeyFileDefault   = certBasePath + "priv.key"
+	RegistrationFile = certBasePath + "registration.json"
+)
+
+const (
+	ProviderLocal      = "local"
+	ProviderCloudflare = "cloudflare"
+	ProviderClouddns   = "clouddns"
+	ProviderDuckdns    = "duckdns"
+	ProviderOVH        = "ovh"
+)
+
+var providersGenMap = map[string]ProviderGenerator{
+	ProviderLocal:      providerGenerator(NewDummyDefaultConfig, NewDummyDNSProviderConfig),
+	ProviderCloudflare: providerGenerator(cloudflare.NewDefaultConfig, cloudflare.NewDNSProviderConfig),
+	ProviderClouddns:   providerGenerator(clouddns.NewDefaultConfig, clouddns.NewDNSProviderConfig),
+	ProviderDuckdns:    providerGenerator(duckdns.NewDefaultConfig, duckdns.NewDNSProviderConfig),
+	ProviderOVH:        providerGenerator(ovh.NewDefaultConfig, ovh.NewDNSProviderConfig),
+}
+
+var (
+	ErrGetCertFailure = errors.New("get certificate failed")
+)
+
+var logger = logrus.WithField("module", "autocert")

src/autocert/dummy.go

@@ -0,0 +1,20 @@
+package autocert
+
+type DummyConfig struct{}
+type DummyProvider struct{}
+
+func NewDummyDefaultConfig() *DummyConfig {
+	return &DummyConfig{}
+}
+
+func NewDummyDNSProviderConfig(*DummyConfig) (*DummyProvider, error) {
+	return &DummyProvider{}, nil
+}
+
+func (DummyProvider) Present(domain, token, keyAuth string) error {
+	return nil
+}
+
+func (DummyProvider) CleanUp(domain, token, keyAuth string) error {
+	return nil
+}

src/autocert/provider.go

@@ -0,0 +1,299 @@
+package autocert
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"os"
+	"reflect"
+	"sort"
+	"time"
+
+	"github.com/go-acme/lego/v4/certificate"
+	"github.com/go-acme/lego/v4/challenge"
+	"github.com/go-acme/lego/v4/lego"
+	"github.com/go-acme/lego/v4/registration"
+	E "github.com/yusing/go-proxy/error"
+	M "github.com/yusing/go-proxy/models"
+	U "github.com/yusing/go-proxy/utils"
+)
+
+type Provider struct {
+	cfg     *Config
+	user    *User
+	legoCfg *lego.Config
+	client  *lego.Client
+
+	tlsCert      *tls.Certificate
+	certExpiries CertExpiries
+}
+
+type ProviderGenerator func(M.AutocertProviderOpt) (challenge.Provider, E.NestedError)
+type CertExpiries map[string]time.Time
+
+func (p *Provider) GetCert(_ *tls.ClientHelloInfo) (*tls.Certificate, error) {
+	if p.tlsCert == nil {
+		return nil, ErrGetCertFailure
+	}
+	return p.tlsCert, nil
+}
+
+func (p *Provider) GetName() string {
+	return p.cfg.Provider
+}
+
+func (p *Provider) GetCertPath() string {
+	return p.cfg.CertPath
+}
+
+func (p *Provider) GetKeyPath() string {
+	return p.cfg.KeyPath
+}
+
+func (p *Provider) GetExpiries() CertExpiries {
+	return p.certExpiries
+}
+
+func (p *Provider) ObtainCert() (res E.NestedError) {
+	b := E.NewBuilder("failed to obtain certificate")
+	defer b.To(&res)
+
+	if p.cfg.Provider == ProviderLocal {
+		b.Addf("provider is set to %q", ProviderLocal)
+		return
+	}
+
+	if p.client == nil {
+		if err := p.initClient(); err.HasError() {
+			b.Add(E.FailWith("init autocert client", err))
+			return
+		}
+	}
+
+	if p.user.Registration == nil {
+		if err := p.loadRegistration(); err.HasError() {
+			if err := p.registerACME(); err.HasError() {
+				b.Add(E.FailWith("register ACME", err))
+				return
+			}
+		}
+	}
+
+	client := p.client
+	req := certificate.ObtainRequest{
+		Domains: p.cfg.Domains,
+		Bundle:  true,
+	}
+	cert, err := E.Check(client.Certificate.Obtain(req))
+	if err.HasError() {
+		b.Add(err)
+		return
+	}
+	err = p.saveCert(cert)
+	if err.HasError() {
+		b.Add(E.FailWith("save certificate", err))
+		return
+	}
+	tlsCert, err := E.Check(tls.X509KeyPair(cert.Certificate, cert.PrivateKey))
+	if err.HasError() {
+		b.Add(E.FailWith("parse obtained certificate", err))
+		return
+	}
+	expiries, err := getCertExpiries(&tlsCert)
+	if err.HasError() {
+		b.Add(E.FailWith("get certificate expiry", err))
+		return
+	}
+	p.tlsCert = &tlsCert
+	p.certExpiries = expiries
+
+	return nil
+}
+
+func (p *Provider) LoadCert() E.NestedError {
+	cert, err := E.Check(tls.LoadX509KeyPair(p.cfg.CertPath, p.cfg.KeyPath))
+	if err.HasError() {
+		return err
+	}
+	expiries, err := getCertExpiries(&cert)
+	if err.HasError() {
+		return err
+	}
+	p.tlsCert = &cert
+	p.certExpiries = expiries
+
+	logger.Infof("next renewal in %v", U.FormatDuration(time.Until(p.ShouldRenewOn())))
+	return p.renewIfNeeded()
+}
+
+func (p *Provider) ShouldRenewOn() time.Time {
+	for _, expiry := range p.certExpiries {
+		return expiry.AddDate(0, -1, 0) // 1 month before
+	}
+	// this line should never be reached
+	panic("no certificate available")
+}
+
+func (p *Provider) ScheduleRenewal(ctx context.Context) {
+	if p.GetName() == ProviderLocal {
+		return
+	}
+
+	logger.Debug("started renewal scheduler")
+	defer logger.Debug("renewal scheduler stopped")
+
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C: // check every 5 seconds
+			if err := p.renewIfNeeded(); err.HasError() {
+				logger.Warn(err)
+			}
+		}
+	}
+}
+
+func (p *Provider) initClient() E.NestedError {
+	legoClient, err := E.Check(lego.NewClient(p.legoCfg))
+	if err.HasError() {
+		return E.FailWith("create lego client", err)
+	}
+
+	legoProvider, err := providersGenMap[p.cfg.Provider](p.cfg.Options)
+	if err.HasError() {
+		return E.FailWith("create lego provider", err)
+	}
+
+	err = E.From(legoClient.Challenge.SetDNS01Provider(legoProvider))
+	if err.HasError() {
+		return E.FailWith("set challenge provider", err)
+	}
+
+	p.client = legoClient
+	return nil
+}
+
+func (p *Provider) registerACME() E.NestedError {
+	if p.user.Registration != nil {
+		return nil
+	}
+	reg, err := E.Check(p.client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true}))
+	if err.HasError() {
+		return err
+	}
+	p.user.Registration = reg
+
+	if err := p.saveRegistration(); err.HasError() {
+		logger.Warn(err)
+	}
+	return nil
+}
+
+func (p *Provider) loadRegistration() E.NestedError {
+	if p.user.Registration != nil {
+		return nil
+	}
+	reg := &registration.Resource{}
+	err := U.LoadJson(RegistrationFile, reg)
+	if err.HasError() {
+		return E.FailWith("parse registration file", err)
+	}
+	p.user.Registration = reg
+	return nil
+}
+
+func (p *Provider) saveRegistration() E.NestedError {
+	return U.SaveJson(RegistrationFile, p.user.Registration, 0o600)
+}
+
+func (p *Provider) saveCert(cert *certificate.Resource) E.NestedError {
+	err := os.WriteFile(p.cfg.KeyPath, cert.PrivateKey, 0o600) // -rw-------
+	if err != nil {
+		return E.FailWith("write key file", err)
+	}
+	err = os.WriteFile(p.cfg.CertPath, cert.Certificate, 0o644) // -rw-r--r--
+	if err != nil {
+		return E.FailWith("write cert file", err)
+	}
+	return nil
+}
+
+func (p *Provider) certState() CertState {
+	if time.Now().After(p.ShouldRenewOn()) {
+		return CertStateExpired
+	}
+
+	certDomains := make([]string, len(p.certExpiries))
+	wantedDomains := make([]string, len(p.cfg.Domains))
+	i := 0
+	for domain := range p.certExpiries {
+		certDomains[i] = domain
+		i++
+	}
+	copy(wantedDomains, p.cfg.Domains)
+	sort.Strings(wantedDomains)
+	sort.Strings(certDomains)
+
+	if !reflect.DeepEqual(certDomains, wantedDomains) {
+		logger.Debugf("cert domains mismatch: %v != %v", certDomains, p.cfg.Domains)
+		return CertStateMismatch
+	}
+
+	return CertStateValid
+}
+
+func (p *Provider) renewIfNeeded() E.NestedError {
+	switch p.certState() {
+	case CertStateExpired:
+		logger.Info("certs expired, renewing")
+	case CertStateMismatch:
+		logger.Info("cert domains mismatch with config, renewing")
+	default:
+		return nil
+	}
+
+	if err := p.ObtainCert(); err.HasError() {
+		return E.FailWith("renew certificate", err)
+	}
+	return nil
+}
+
+func getCertExpiries(cert *tls.Certificate) (CertExpiries, E.NestedError) {
+	r := make(CertExpiries, len(cert.Certificate))
+	for _, cert := range cert.Certificate {
+		x509Cert, err := E.Check(x509.ParseCertificate(cert))
+		if err.HasError() {
+			return nil, E.FailWith("parse certificate", err)
+		}
+		if x509Cert.IsCA {
+			continue
+		}
+		r[x509Cert.Subject.CommonName] = x509Cert.NotAfter
+		for i := range x509Cert.DNSNames {
+			r[x509Cert.DNSNames[i]] = x509Cert.NotAfter
+		}
+	}
+	return r, nil
+}
+
+func providerGenerator[CT any, PT challenge.Provider](
+	defaultCfg func() *CT,
+	newProvider func(*CT) (PT, error),
+) ProviderGenerator {
+	return func(opt M.AutocertProviderOpt) (challenge.Provider, E.NestedError) {
+		cfg := defaultCfg()
+		err := U.Deserialize(opt, cfg)
+		if err.HasError() {
+			return nil, err
+		}
+		p, err := E.Check(newProvider(cfg))
+		if err.HasError() {
+			return nil, err
+		}
+		return p, nil
+	}
+}

src/autocert/provider_test/ovh_test.go

@@ -0,0 +1,50 @@
+package provider_test
+
+import (
+	"testing"
+
+	"github.com/go-acme/lego/v4/providers/dns/ovh"
+	U "github.com/yusing/go-proxy/utils"
+	. "github.com/yusing/go-proxy/utils/testing"
+	"gopkg.in/yaml.v3"
+)
+
+// type Config struct {
+// 	APIEndpoint string
+
+// 	ApplicationKey    string
+// 	ApplicationSecret string
+// 	ConsumerKey       string
+
+// 	OAuth2Config *OAuth2Config
+
+// 	PropagationTimeout time.Duration
+// 	PollingInterval    time.Duration
+// 	TTL                int
+// 	HTTPClient         *http.Client
+// }
+
+func TestOVH(t *testing.T) {
+	cfg := &ovh.Config{}
+	testYaml := `
+api_endpoint: https://eu.api.ovh.com
+application_key: <application_key>
+application_secret: <application_secret>
+consumer_key: <consumer_key>
+oauth2_config:
+  client_id: <client_id>
+  client_secret: <client_secret>
+`
+	cfgExpected := &ovh.Config{
+		APIEndpoint:       "https://eu.api.ovh.com",
+		ApplicationKey:    "<application_key>",
+		ApplicationSecret: "<application_secret>",
+		ConsumerKey:       "<consumer_key>",
+		OAuth2Config:      &ovh.OAuth2Config{ClientID: "<client_id>", ClientSecret: "<client_secret>"},
+	}
+	testYaml = testYaml[1:] // remove first \n
+	opt := make(map[string]any)
+	ExpectNoError(t, yaml.Unmarshal([]byte(testYaml), opt))
+	ExpectTrue(t, U.Deserialize(opt, cfg).NoError())
+	ExpectDeepEqual(t, cfg, cfgExpected)
+}

src/autocert/state.go

@@ -0,0 +1,9 @@
+package autocert
+
+type CertState int
+
+const (
+	CertStateValid    CertState = 0
+	CertStateExpired  CertState = iota
+	CertStateMismatch CertState = iota
+)

src/autocert/user.go

@@ -0,0 +1,22 @@
+package autocert
+
+import (
+	"github.com/go-acme/lego/v4/registration"
+	"crypto"
+)
+
+type User struct {
+	Email        string
+	Registration *registration.Resource
+	key          crypto.PrivateKey
+}
+
+func (u *User) GetEmail() string {
+	return u.Email
+}
+func (u *User) GetRegistration() *registration.Resource {
+	return u.Registration
+}
+func (u *User) GetPrivateKey() crypto.PrivateKey {
+	return u.key
+}

src/common/args.go

@@ -0,0 +1,49 @@
+package common
+
+import (
+	"flag"
+
+	"github.com/sirupsen/logrus"
+	E "github.com/yusing/go-proxy/error"
+)
+
+type Args struct {
+	Command string
+}
+
+const (
+	CommandStart            = ""
+	CommandValidate         = "validate"
+	CommandListConfigs      = "ls-config"
+	CommandListRoutes       = "ls-routes"
+	CommandReload           = "reload"
+	CommandDebugListEntries = "debug-ls-entries"
+)
+
+var ValidCommands = []string{
+	CommandStart,
+	CommandValidate,
+	CommandListConfigs,
+	CommandListRoutes,
+	CommandReload,
+	CommandDebugListEntries,
+}
+
+func GetArgs() Args {
+	var args Args
+	flag.Parse()
+	args.Command = flag.Arg(0)
+	if err := validateArg(args.Command); err.HasError() {
+		logrus.Fatal(err)
+	}
+	return args
+}
+
+func validateArg(arg string) E.NestedError {
+	for _, v := range ValidCommands {
+		if arg == v {
+			return nil
+		}
+	}
+	return E.Invalid("argument", arg)
+}

src/common/constants.go

@@ -0,0 +1,92 @@
+package common
+
+import (
+	"time"
+)
+
+const (
+	ConnectionTimeout = 5 * time.Second
+	DialTimeout       = 3 * time.Second
+	KeepAlive         = 5 * time.Second
+)
+
+const (
+	ProviderKind_Docker = "docker"
+	ProviderKind_File   = "file"
+)
+
+// file, folder structure
+
+const (
+	ConfigBasePath = "config/"
+	ConfigFileName = "config.yml"
+	ConfigPath     = ConfigBasePath + ConfigFileName
+)
+
+const (
+	TemplatesBasePath        = "templates/"
+	PanelTemplatePath        = TemplatesBasePath + "panel/index.html"
+	ConfigEditorTemplatePath = TemplatesBasePath + "config_editor/index.html"
+)
+
+const (
+	SchemaBasePath      = "schema/"
+	ConfigSchemaPath    = SchemaBasePath + "config.schema.json"
+	ProvidersSchemaPath = SchemaBasePath + "providers.schema.json"
+)
+
+const DockerHostFromEnv = "$DOCKER_HOST"
+
+var WellKnownHTTPPorts = map[uint16]bool{
+	80:   true,
+	8000: true,
+	8008: true,
+	8080: true,
+	3000: true,
+}
+
+var (
+	ServiceNamePortMapTCP = map[string]int{
+		"postgres":         5432,
+		"mysql":            3306,
+		"mariadb":          3306,
+		"redis":            6379,
+		"mssql":            1433,
+		"memcached":        11211,
+		"rabbitmq":         5672,
+		"mongo":            27017,
+		"minecraft-server": 25565,
+
+		"dns":  53,
+		"ssh":  22,
+		"ftp":  21,
+		"smtp": 25,
+		"pop3": 110,
+		"imap": 143,
+	}
+)
+
+var ImageNamePortMapHTTP = map[string]int{
+	"nginx":               80,
+	"httpd":               80,
+	"adguardhome":         3000,
+	"gogs":                3000,
+	"gitea":               3000,
+	"portainer":           9000,
+	"portainer-ce":        9000,
+	"home-assistant":      8123,
+	"homebridge":          8581,
+	"uptime-kuma":         3001,
+	"changedetection.io":  3000,
+	"prometheus":          9090,
+	"grafana":             3000,
+	"dockge":              5001,
+	"nginx-proxy-manager": 81,
+}
+
+const (
+	IdleTimeoutDefault = "0"
+	WakeTimeoutDefault = "10s"
+	StopTimeoutDefault = "10s"
+	StopMethodDefault  = "stop"
+)

src/common/env.go

@@ -0,0 +1,27 @@
+package common
+
+import (
+	"os"
+
+	U "github.com/yusing/go-proxy/utils"
+)
+
+var (
+	NoSchemaValidation = getEnvBool("GOPROXY_NO_SCHEMA_VALIDATION")
+	IsDebug            = getEnvBool("GOPROXY_DEBUG")
+	ProxyHTTPPort      = ":" + getEnv("GOPROXY_HTTP_PORT", "80")
+	ProxyHTTPSPort     = ":" + getEnv("GOPROXY_HTTPS_PORT", "443")
+	APIHTTPPort        = ":" + getEnv("GOPROXY_API_PORT", "8888")
+)
+
+func getEnvBool(key string) bool {
+	return U.ParseBool(os.Getenv(key))
+}
+
+func getEnv(key string, defaultValue string) string {
+	value, ok := os.LookupEnv(key)
+	if !ok {
+		value = defaultValue
+	}
+	return value
+}

src/config/config.go

@@ -0,0 +1,277 @@
+package config
+
+import (
+	"context"
+	"os"
+
+	"github.com/sirupsen/logrus"
+	"github.com/yusing/go-proxy/autocert"
+	"github.com/yusing/go-proxy/common"
+	E "github.com/yusing/go-proxy/error"
+	M "github.com/yusing/go-proxy/models"
+	PR "github.com/yusing/go-proxy/proxy/provider"
+	R "github.com/yusing/go-proxy/route"
+	U "github.com/yusing/go-proxy/utils"
+	F "github.com/yusing/go-proxy/utils/functional"
+	W "github.com/yusing/go-proxy/watcher"
+	"gopkg.in/yaml.v3"
+)
+
+type Config struct {
+	value            *M.Config
+	proxyProviders   F.Map[string, *PR.Provider]
+	autocertProvider *autocert.Provider
+
+	l logrus.FieldLogger
+
+	watcher       W.Watcher
+	watcherCtx    context.Context
+	watcherCancel context.CancelFunc
+	reloadReq     chan struct{}
+}
+
+func Load() (*Config, E.NestedError) {
+	cfg := &Config{
+		proxyProviders: F.NewMapOf[string, *PR.Provider](),
+		l:              logrus.WithField("module", "config"),
+		watcher:        W.NewFileWatcher(common.ConfigFileName),
+		reloadReq:      make(chan struct{}, 1),
+	}
+	return cfg, cfg.load()
+}
+
+func Validate(data []byte) E.NestedError {
+	return U.ValidateYaml(U.GetSchema(common.ConfigSchemaPath), data)
+}
+
+func (cfg *Config) Value() M.Config {
+	return *cfg.value
+}
+
+func (cfg *Config) GetAutoCertProvider() *autocert.Provider {
+	return cfg.autocertProvider
+}
+
+func (cfg *Config) Dispose() {
+	if cfg.watcherCancel != nil {
+		cfg.watcherCancel()
+		cfg.l.Debug("stopped watcher")
+	}
+	cfg.stopProviders()
+}
+
+func (cfg *Config) Reload() E.NestedError {
+	cfg.stopProviders()
+	if err := cfg.load(); err.HasError() {
+		return err
+	}
+	cfg.StartProxyProviders()
+	return nil
+}
+
+func (cfg *Config) StartProxyProviders() {
+	cfg.controlProviders("start", (*PR.Provider).StartAllRoutes)
+}
+
+func (cfg *Config) WatchChanges() {
+	cfg.watcherCtx, cfg.watcherCancel = context.WithCancel(context.Background())
+	go func() {
+		for {
+			select {
+			case <-cfg.watcherCtx.Done():
+				return
+			case <-cfg.reloadReq:
+				if err := cfg.Reload(); err.HasError() {
+					cfg.l.Error(err)
+				}
+			}
+		}
+	}()
+	go func() {
+		eventCh, errCh := cfg.watcher.Events(cfg.watcherCtx)
+		for {
+			select {
+			case <-cfg.watcherCtx.Done():
+				return
+			case event := <-eventCh:
+				if event.Action.IsDelete() {
+					cfg.stopProviders()
+				} else {
+					cfg.reloadReq <- struct{}{}
+				}
+			case err := <-errCh:
+				cfg.l.Error(err)
+				continue
+			}
+		}
+	}()
+}
+
+func (cfg *Config) FindRoute(alias string) R.Route {
+	return F.MapFind(cfg.proxyProviders,
+		func(p *PR.Provider) (R.Route, bool) {
+			if route, ok := p.GetRoute(alias); ok {
+				return route, true
+			}
+			return nil, false
+		},
+	)
+}
+
+func (cfg *Config) RoutesByAlias() map[string]U.SerializedObject {
+	routes := make(map[string]U.SerializedObject)
+	cfg.forEachRoute(func(alias string, r R.Route, p *PR.Provider) {
+		obj, err := U.Serialize(r)
+		if err.HasError() {
+			cfg.l.Error(err)
+			return
+		}
+		obj["provider"] = p.GetName()
+		obj["type"] = string(r.Type())
+		routes[alias] = obj
+	})
+	return routes
+}
+
+func (cfg *Config) Statistics() map[string]any {
+	nTotalStreams := 0
+	nTotalRPs := 0
+	providerStats := make(map[string]any)
+
+	cfg.forEachRoute(func(alias string, r R.Route, p *PR.Provider) {
+		s, ok := providerStats[p.GetName()]
+		if !ok {
+			s = make(map[string]int)
+		}
+
+		stats := s.(map[string]int)
+		switch r.Type() {
+		case R.RouteTypeStream:
+			stats["num_streams"]++
+			nTotalStreams++
+		case R.RouteTypeReverseProxy:
+			stats["num_reverse_proxies"]++
+			nTotalRPs++
+		default:
+			panic("bug: should not reach here")
+		}
+	})
+
+	return map[string]any{
+		"num_total_streams":         nTotalStreams,
+		"num_total_reverse_proxies": nTotalRPs,
+		"providers":                 providerStats,
+	}
+}
+
+func (cfg *Config) DumpEntries() map[string]*M.ProxyEntry {
+	entries := make(map[string]*M.ProxyEntry)
+	cfg.forEachRoute(func(alias string, r R.Route, p *PR.Provider) {
+		entries[alias] = r.Entry()
+	})
+	return entries
+}
+
+func (cfg *Config) forEachRoute(do func(alias string, r R.Route, p *PR.Provider)) {
+	cfg.proxyProviders.RangeAll(func(_ string, p *PR.Provider) {
+		p.RangeRoutes(func(a string, r R.Route) {
+			do(a, r, p)
+		})
+	})
+}
+
+func (cfg *Config) load() (res E.NestedError) {
+	b := E.NewBuilder("errors loading config")
+	defer b.To(&res)
+
+	cfg.l.Debug("loading config")
+	defer cfg.l.Debug("loaded config")
+
+	data, err := E.Check(os.ReadFile(common.ConfigPath))
+	if err.HasError() {
+		b.Add(E.FailWith("read config", err))
+		return
+	}
+
+	if !common.NoSchemaValidation {
+		if err = Validate(data); err.HasError() {
+			b.Add(E.FailWith("schema validation", err))
+			return
+		}
+	}
+
+	model := M.DefaultConfig()
+	if err := E.From(yaml.Unmarshal(data, model)); err.HasError() {
+		b.Add(E.FailWith("parse config", err))
+		return
+	}
+
+	// errors are non fatal below
+	b.WithSeverity(E.SeverityWarning)
+	b.Add(cfg.initAutoCert(&model.AutoCert))
+	b.Add(cfg.loadProviders(&model.Providers))
+
+	cfg.value = model
+	return
+}
+
+func (cfg *Config) initAutoCert(autocertCfg *M.AutoCertConfig) (err E.NestedError) {
+	if cfg.autocertProvider != nil {
+		return
+	}
+
+	cfg.l.Debug("initializing autocert")
+	defer cfg.l.Debug("initialized autocert")
+
+	cfg.autocertProvider, err = autocert.NewConfig(autocertCfg).GetProvider()
+	if err.HasError() {
+		err = E.FailWith("autocert provider", err)
+	}
+	return
+}
+
+func (cfg *Config) loadProviders(providers *M.ProxyProviders) (res E.NestedError) {
+	cfg.l.Debug("loading providers")
+	defer cfg.l.Debug("loaded providers")
+
+	b := E.NewBuilder("errors loading providers")
+	defer b.To(&res)
+
+	for _, filename := range providers.Files {
+		p, err := PR.NewFileProvider(filename)
+		if err != nil {
+			b.Add(err.Subject(filename))
+			continue
+		}
+		cfg.proxyProviders.Store(p.GetName(), p)
+		b.Add(p.LoadRoutes().Subject(filename))
+	}
+	for name, dockerHost := range providers.Docker {
+		p, err := PR.NewDockerProvider(name, dockerHost)
+		if err != nil {
+			b.Add(err.Subject(dockerHost))
+			continue
+		}
+		cfg.proxyProviders.Store(p.GetName(), p)
+		b.Add(p.LoadRoutes().Subject(dockerHost))
+	}
+	return
+}
+
+func (cfg *Config) controlProviders(action string, do func(*PR.Provider) E.NestedError) {
+	errors := E.NewBuilder("cannot %s these providers", action)
+
+	cfg.proxyProviders.RangeAll(func(name string, p *PR.Provider) {
+		if err := do(p); err.HasError() {
+			errors.Add(err.Subject(p))
+		}
+	})
+
+	if err := errors.Build(); err.HasError() {
+		cfg.l.Error(err)
+	}
+}
+
+func (cfg *Config) stopProviders() {
+	cfg.controlProviders("stop routes", (*PR.Provider).StopAllRoutes)
+}

src/docker/client.go

@@ -0,0 +1,156 @@
+package docker
+
+import (
+	"net/http"
+	"sync"
+	"sync/atomic"
+
+	"github.com/docker/cli/cli/connhelper"
+	"github.com/docker/docker/client"
+	"github.com/sirupsen/logrus"
+	"github.com/yusing/go-proxy/common"
+	E "github.com/yusing/go-proxy/error"
+)
+
+type Client struct {
+	key      string
+	refCount *atomic.Int32
+	*client.Client
+
+	l logrus.FieldLogger
+}
+
+func ParseDockerHostname(host string) (string, E.NestedError) {
+	if host == common.DockerHostFromEnv {
+		return host, nil
+	} else if host == "" {
+		return "localhost", nil
+	}
+	url, err := E.Check(client.ParseHostURL(host))
+	if err != nil {
+		return "", E.Invalid("host", host).With(err)
+	}
+	return url.Hostname(), nil
+}
+
+func (c Client) DaemonHostname() string {
+	// DaemonHost should always return a valid host
+	hostname, _ := ParseDockerHostname(c.DaemonHost())
+	return hostname
+}
+
+func (c Client) Connected() bool {
+	return c.Client != nil
+}
+
+// if the client is still referenced, this is no-op
+func (c *Client) Close() error {
+	if c.refCount.Add(-1) > 0 {
+		return nil
+	}
+
+	clientMapMu.Lock()
+	defer clientMapMu.Unlock()
+	delete(clientMap, c.key)
+
+	client := c.Client
+	c.Client = nil
+
+	c.l.Debugf("client closed")
+
+	if client != nil {
+		return client.Close()
+	}
+	return nil
+}
+
+// ConnectClient creates a new Docker client connection to the specified host.
+//
+// Returns existing client if available.
+//
+// Parameters:
+//   - host: the host to connect to (either a URL or common.DockerHostFromEnv).
+//
+// Returns:
+//   - Client: the Docker client connection.
+//   - error: an error if the connection failed.
+func ConnectClient(host string) (Client, E.NestedError) {
+	clientMapMu.Lock()
+	defer clientMapMu.Unlock()
+
+	// check if client exists
+	if client, ok := clientMap[host]; ok {
+		client.refCount.Add(1)
+		return client, nil
+	}
+
+	// create client
+	var opt []client.Opt
+
+	switch host {
+	case common.DockerHostFromEnv:
+		opt = clientOptEnvHost
+	default:
+		helper, err := E.Check(connhelper.GetConnectionHelper(host))
+		if err.HasError() {
+			return Client{}, E.UnexpectedError(err.Error())
+		}
+		if helper != nil {
+			httpClient := &http.Client{
+				Transport: &http.Transport{
+					DialContext: helper.Dialer,
+				},
+			}
+			opt = []client.Opt{
+				client.WithHTTPClient(httpClient),
+				client.WithHost(helper.Host),
+				client.WithAPIVersionNegotiation(),
+				client.WithDialContext(helper.Dialer),
+			}
+		} else {
+			opt = []client.Opt{
+				client.WithHost(host),
+				client.WithAPIVersionNegotiation(),
+			}
+		}
+	}
+
+	client, err := E.Check(client.NewClientWithOpts(opt...))
+
+	if err.HasError() {
+		return Client{}, err
+	}
+
+	c := Client{
+		Client:   client,
+		key:      host,
+		refCount: &atomic.Int32{},
+		l:        logger.WithField("docker_client", client.DaemonHost()),
+	}
+	c.refCount.Add(1)
+	c.l.Debugf("client connected")
+
+	clientMap[host] = c
+	return clientMap[host], nil
+}
+
+func CloseAllClients() {
+	clientMapMu.Lock()
+	defer clientMapMu.Unlock()
+	for _, client := range clientMap {
+		client.Close()
+	}
+	clientMap = make(map[string]Client)
+	logger.Debug("closed all clients")
+}
+
+var (
+	clientMap        map[string]Client = make(map[string]Client)
+	clientMapMu      sync.Mutex
+	clientOptEnvHost = []client.Opt{
+		client.WithHostFromEnv(),
+		client.WithAPIVersionNegotiation(),
+	}
+
+	logger = logrus.WithField("module", "docker")
+)

src/docker/client_info.go

@@ -0,0 +1,54 @@
+package docker
+
+import (
+	"context"
+	"time"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/client"
+
+	E "github.com/yusing/go-proxy/error"
+)
+
+type ClientInfo struct {
+	Client     Client
+	Containers []types.Container
+}
+
+var listOptions = container.ListOptions{
+	// Filters: filters.NewArgs(
+	// 	filters.Arg("health", "healthy"),
+	// 	filters.Arg("health", "none"),
+	// 	filters.Arg("health", "starting"),
+	// ),
+	All: true,
+}
+
+func GetClientInfo(clientHost string, getContainer bool) (*ClientInfo, E.NestedError) {
+	dockerClient, err := ConnectClient(clientHost)
+	if err.HasError() {
+		return nil, E.FailWith("connect to docker", err)
+	}
+	defer dockerClient.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	var containers []types.Container
+	if getContainer {
+		containers, err = E.Check(dockerClient.ContainerList(ctx, listOptions))
+		if err.HasError() {
+			return nil, E.FailWith("list containers", err)
+		}
+	}
+
+	return &ClientInfo{
+		Client:     dockerClient,
+		Containers: containers,
+	}, nil
+}
+
+func IsErrConnectionFailed(err error) bool {
+	return client.IsErrConnectionFailed(err)
+}

src/docker/container.go

@@ -0,0 +1,111 @@
+package docker
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/docker/docker/api/types"
+	U "github.com/yusing/go-proxy/utils"
+)
+
+type ProxyProperties struct {
+	DockerHost    string   `yaml:"-" json:"docker_host"`
+	ContainerName string   `yaml:"-" json:"container_name"`
+	ImageName     string   `yaml:"-" json:"image_name"`
+	Aliases       []string `yaml:"-" json:"aliases"`
+	IsExcluded    bool     `yaml:"-" json:"is_excluded"`
+	FirstPort     string   `yaml:"-" json:"first_port"`
+	IdleTimeout   string   `yaml:"-" json:"idle_timeout"`
+	WakeTimeout   string   `yaml:"-" json:"wake_timeout"`
+	StopMethod    string   `yaml:"-" json:"stop_method"`
+	StopTimeout   string   `yaml:"-" json:"stop_timeout"` // stop_method = "stop" only
+	StopSignal    string   `yaml:"-" json:"stop_signal"`  // stop_method = "stop" | "kill" only
+	Running       bool     `yaml:"-" json:"running"`
+}
+
+type Container struct {
+	*types.Container
+	*ProxyProperties
+}
+
+func FromDocker(c *types.Container, dockerHost string) (res Container) {
+	res.Container = c
+	res.ProxyProperties = &ProxyProperties{
+		DockerHost:    dockerHost,
+		ContainerName: res.getName(),
+		ImageName:     res.getImageName(),
+		Aliases:       res.getAliases(),
+		IsExcluded:    U.ParseBool(res.getDeleteLabel(LableExclude)),
+		FirstPort:     res.firstPortOrEmpty(),
+		IdleTimeout:   res.getDeleteLabel(LabelIdleTimeout),
+		WakeTimeout:   res.getDeleteLabel(LabelWakeTimeout),
+		StopMethod:    res.getDeleteLabel(LabelStopMethod),
+		StopTimeout:   res.getDeleteLabel(LabelStopTimeout),
+		StopSignal:    res.getDeleteLabel(LabelStopSignal),
+		Running:       c.Status == "running" || c.State == "running",
+	}
+	return
+}
+
+func FromJson(json types.ContainerJSON, dockerHost string) Container {
+	ports := make([]types.Port, 0)
+	for k, bindings := range json.NetworkSettings.Ports {
+		for _, v := range bindings {
+			pubPort, _ := strconv.Atoi(v.HostPort)
+			privPort, _ := strconv.Atoi(k.Port())
+			ports = append(ports, types.Port{
+				IP:          v.HostIP,
+				PublicPort:  uint16(pubPort),
+				PrivatePort: uint16(privPort),
+			})
+		}
+	}
+	return FromDocker(&types.Container{
+		ID:     json.ID,
+		Names:  []string{json.Name},
+		Image:  json.Image,
+		Ports:  ports,
+		Labels: json.Config.Labels,
+		State:  json.State.Status,
+		Status: json.State.Status,
+	}, dockerHost)
+}
+
+func (c Container) getDeleteLabel(label string) string {
+	if l, ok := c.Labels[label]; ok {
+		delete(c.Labels, label)
+		return l
+	}
+	return ""
+}
+
+func (c Container) getAliases() []string {
+	if l := c.getDeleteLabel(LableAliases); l != "" {
+		return U.CommaSeperatedList(l)
+	} else {
+		return []string{c.getName()}
+	}
+}
+
+func (c Container) getName() string {
+	return strings.TrimPrefix(c.Names[0], "/")
+}
+
+func (c Container) getImageName() string {
+	colonSep := strings.Split(c.Image, ":")
+	slashSep := strings.Split(colonSep[0], "/")
+	return slashSep[len(slashSep)-1]
+}
+
+func (c Container) firstPortOrEmpty() string {
+	if len(c.Ports) == 0 {
+		return ""
+	}
+	for _, p := range c.Ports {
+		if p.PublicPort != 0 {
+			return fmt.Sprint(p.PublicPort)
+		}
+	}
+	return ""
+}

src/docker/homepage_label.go

@@ -0,0 +1,32 @@
+package docker
+
+type (
+	HomePageConfig   struct{ m map[string]HomePageCategory }
+	HomePageCategory []HomePageItem
+
+	HomePageItem struct {
+		Name         string
+		Icon         string
+		Category     string
+		Description  string
+		WidgetConfig map[string]any
+	}
+)
+
+func NewHomePageConfig() *HomePageConfig {
+	return &HomePageConfig{m: make(map[string]HomePageCategory)}
+}
+
+func NewHomePageItem() *HomePageItem {
+	return &HomePageItem{}
+}
+
+func (c *HomePageConfig) Clear() {
+	c.m = make(map[string]HomePageCategory)
+}
+
+func (c *HomePageConfig) Add(item HomePageItem) {
+	c.m[item.Category] = HomePageCategory{item}
+}
+
+const NSHomePage = "homepage"

src/docker/idlewatcher/round_trip.go

@@ -0,0 +1,14 @@
+package idlewatcher
+
+import "net/http"
+
+type (
+	roundTripper struct {
+		patched roundTripFunc
+	}
+	roundTripFunc func(*http.Request) (*http.Response, error)
+)
+
+func (rt roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	return rt.patched(req)
+}

src/docker/idlewatcher/watcher.go

@@ -0,0 +1,357 @@
+package idlewatcher
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"net/http"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/docker/docker/api/types/container"
+	"github.com/sirupsen/logrus"
+	D "github.com/yusing/go-proxy/docker"
+	E "github.com/yusing/go-proxy/error"
+	P "github.com/yusing/go-proxy/proxy"
+	PT "github.com/yusing/go-proxy/proxy/fields"
+	W "github.com/yusing/go-proxy/watcher"
+	event "github.com/yusing/go-proxy/watcher/events"
+)
+
+type watcher struct {
+	*P.ReverseProxyEntry
+
+	client D.Client
+
+	refCount atomic.Int32
+
+	stopByMethod StopCallback
+	wakeCh       chan struct{}
+	wakeDone     chan E.NestedError
+	running      atomic.Bool
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	l logrus.FieldLogger
+}
+
+type (
+	WakeDone     <-chan error
+	WakeFunc     func() WakeDone
+	StopCallback func() E.NestedError
+)
+
+func Register(entry *P.ReverseProxyEntry) (*watcher, E.NestedError) {
+	failure := E.Failure("idle_watcher register")
+
+	if entry.IdleTimeout == 0 {
+		return nil, failure.With(E.Invalid("idle_timeout", 0))
+	}
+
+	watcherMapMu.Lock()
+	defer watcherMapMu.Unlock()
+
+	if w, ok := watcherMap[entry.ContainerName]; ok {
+		w.refCount.Add(1)
+		w.ReverseProxyEntry = entry
+		return w, nil
+	}
+
+	client, err := D.ConnectClient(entry.DockerHost)
+	if err.HasError() {
+		return nil, failure.With(err)
+	}
+
+	w := &watcher{
+		ReverseProxyEntry: entry,
+		client:            client,
+		wakeCh:            make(chan struct{}, 1),
+		wakeDone:          make(chan E.NestedError, 1),
+		l:                 logger.WithField("container", entry.ContainerName),
+	}
+	w.refCount.Add(1)
+	w.running.Store(entry.ContainerRunning)
+	w.stopByMethod = w.getStopCallback()
+
+	watcherMap[w.ContainerName] = w
+
+	go func() {
+		newWatcherCh <- w
+	}()
+
+	return w, nil
+}
+
+// If the container is not registered, this is no-op
+func Unregister(containerName string) {
+	watcherMapMu.Lock()
+	defer watcherMapMu.Unlock()
+
+	if w, ok := watcherMap[containerName]; ok {
+		if w.refCount.Add(-1) > 0 {
+			return
+		}
+		if w.cancel != nil {
+			w.cancel()
+		}
+		w.client.Close()
+		delete(watcherMap, containerName)
+	}
+}
+
+func Start() {
+	logger.Debug("started")
+	defer logger.Debug("stopped")
+
+	mainLoopCtx, mainLoopCancel = context.WithCancel(context.Background())
+
+	defer mainLoopWg.Wait()
+
+	for {
+		select {
+		case <-mainLoopCtx.Done():
+			return
+		case w := <-newWatcherCh:
+			w.l.Debug("registered")
+			mainLoopWg.Add(1)
+			go func() {
+				w.watch()
+				Unregister(w.ContainerName)
+				w.l.Debug("unregistered")
+				mainLoopWg.Done()
+			}()
+		}
+	}
+}
+
+func Stop() {
+	mainLoopCancel()
+	mainLoopWg.Wait()
+}
+
+func (w *watcher) PatchRoundTripper(rtp http.RoundTripper) roundTripper {
+	return roundTripper{patched: func(r *http.Request) (*http.Response, error) {
+		return w.roundTrip(rtp.RoundTrip, r)
+	}}
+}
+
+func (w *watcher) roundTrip(origRoundTrip roundTripFunc, req *http.Request) (*http.Response, error) {
+	w.wakeCh <- struct{}{}
+
+	if w.running.Load() {
+		return origRoundTrip(req)
+	}
+	timeout := time.After(w.WakeTimeout)
+
+	for {
+		if w.running.Load() {
+			return origRoundTrip(req)
+		}
+		select {
+		case <-req.Context().Done():
+			return nil, req.Context().Err()
+		case err := <-w.wakeDone:
+			if err != nil {
+				return nil, err.Error()
+			}
+		case <-timeout:
+			return getLoadingResponse(), nil
+		}
+	}
+}
+
+func (w *watcher) containerStop() error {
+	return w.client.ContainerStop(w.ctx, w.ContainerName, container.StopOptions{
+		Signal:  string(w.StopSignal),
+		Timeout: &w.StopTimeout})
+}
+
+func (w *watcher) containerPause() error {
+	return w.client.ContainerPause(w.ctx, w.ContainerName)
+}
+
+func (w *watcher) containerKill() error {
+	return w.client.ContainerKill(w.ctx, w.ContainerName, string(w.StopSignal))
+}
+
+func (w *watcher) containerUnpause() error {
+	return w.client.ContainerUnpause(w.ctx, w.ContainerName)
+}
+
+func (w *watcher) containerStart() error {
+	return w.client.ContainerStart(w.ctx, w.ContainerName, container.StartOptions{})
+}
+
+func (w *watcher) containerStatus() (string, E.NestedError) {
+	json, err := w.client.ContainerInspect(w.ctx, w.ContainerName)
+	if err != nil {
+		return "", E.FailWith("inspect container", err)
+	}
+	return json.State.Status, nil
+}
+
+func (w *watcher) wakeIfStopped() E.NestedError {
+	status, err := w.containerStatus()
+
+	if err.HasError() {
+		return err
+	}
+	// "created", "running", "paused", "restarting", "removing", "exited", or "dead"
+	switch status {
+	case "exited", "dead":
+		return E.From(w.containerStart())
+	case "paused":
+		return E.From(w.containerUnpause())
+	case "running":
+		w.running.Store(true)
+		return nil
+	default:
+		return E.Unexpected("container state", status)
+	}
+}
+
+func (w *watcher) getStopCallback() StopCallback {
+	var cb func() error
+	switch w.StopMethod {
+	case PT.StopMethodPause:
+		cb = w.containerPause
+	case PT.StopMethodStop:
+		cb = w.containerStop
+	case PT.StopMethodKill:
+		cb = w.containerKill
+	default:
+		panic("should not reach here")
+	}
+	return func() E.NestedError {
+		status, err := w.containerStatus()
+		if err.HasError() {
+			return err
+		}
+		if status != "running" {
+			return nil
+		}
+		return E.From(cb())
+	}
+}
+
+func (w *watcher) watch() {
+	watcherCtx, watcherCancel := context.WithCancel(context.Background())
+	w.ctx = watcherCtx
+	w.cancel = watcherCancel
+
+	dockerWatcher := W.NewDockerWatcherWithClient(w.client)
+
+	defer close(w.wakeCh)
+
+	dockerEventCh, dockerEventErrCh := dockerWatcher.EventsWithOptions(w.ctx, W.DockerListOptions{
+		Filters: W.NewDockerFilter(
+			W.DockerFilterContainer,
+			W.DockerrFilterContainerName(w.ContainerName),
+			W.DockerFilterStart,
+			W.DockerFilterStop,
+			W.DockerFilterDie,
+			W.DockerFilterKill,
+			W.DockerFilterPause,
+			W.DockerFilterUnpause,
+		),
+	})
+
+	ticker := time.NewTicker(w.IdleTimeout)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-mainLoopCtx.Done():
+			w.cancel()
+		case <-watcherCtx.Done():
+			w.l.Debug("stopped")
+			return
+		case err := <-dockerEventErrCh:
+			if err != nil && err.IsNot(context.Canceled) {
+				w.l.Error(E.FailWith("docker watcher", err))
+			}
+		case e := <-dockerEventCh:
+			switch e.Action {
+			case event.ActionDockerStartUnpause:
+				w.running.Store(true)
+				w.l.Infof("%s %s", e.ActorName, e.Action)
+			case event.ActionDockerStopPause:
+				w.running.Store(false)
+				w.l.Infof("%s %s", e.ActorName, e.Action)
+			}
+		case <-ticker.C:
+			w.l.Debug("timeout")
+			ticker.Stop()
+			if err := w.stopByMethod(); err != nil && err.IsNot(context.Canceled) {
+				w.l.Error(E.FailWith("stop", err).Extraf("stop method: %s", w.StopMethod))
+			}
+		case <-w.wakeCh:
+			w.l.Debug("wake signal received")
+			ticker.Reset(w.IdleTimeout)
+			err := w.wakeIfStopped()
+			if err != nil && err.IsNot(context.Canceled) {
+				w.l.Error(E.FailWith("wake", err))
+			}
+			select {
+			case w.wakeDone <- err: // this is passed to roundtrip
+			default:
+			}
+		}
+	}
+}
+
+func getLoadingResponse() *http.Response {
+	return &http.Response{
+		StatusCode: http.StatusAccepted,
+		Header: http.Header{
+			"Content-Type": {"text/html"},
+			"Cache-Control": {
+				"no-cache",
+				"no-store",
+				"must-revalidate",
+			},
+		},
+		Body:          io.NopCloser(bytes.NewReader((loadingPage))),
+		ContentLength: int64(len(loadingPage)),
+	}
+}
+
+var (
+	mainLoopCtx    context.Context
+	mainLoopCancel context.CancelFunc
+	mainLoopWg     sync.WaitGroup
+
+	watcherMap   = make(map[string]*watcher)
+	watcherMapMu sync.Mutex
+
+	newWatcherCh = make(chan *watcher)
+
+	logger = logrus.WithField("module", "idle_watcher")
+
+	loadingPage = []byte(`
+<!DOCTYPE html>
+<html>
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Loading...</title>
+</head>
+<body>
+	<script>
+		window.onload = function() {
+			setTimeout(function() {
+				window.location.reload()
+			}, 1000)
+            // fetch(window.location.href)
+			// 	.then(resp => resp.text())
+			// 	.then(data => { document.body.innerHTML = data; })
+			// 	.catch(err => { document.body.innerHTML = 'Error: ' + err; });
+        };
+	</script>
+	<h1>Container is starting... Please wait</h1>
+</body>
+</html>
+`[1:])
+)

src/docker/inspect.go

@@ -0,0 +1,19 @@
+package docker
+
+import (
+	"context"
+	"time"
+
+	E "github.com/yusing/go-proxy/error"
+)
+
+func (c Client) Inspect(containerID string) (Container, E.NestedError) {
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	json, err := c.ContainerInspect(ctx, containerID)
+	if err != nil {
+		return Container{}, E.From(err)
+	}
+	return FromJson(json, c.key), nil
+}

src/docker/label.go

@@ -0,0 +1,78 @@
+package docker
+
+import (
+	"strings"
+
+	E "github.com/yusing/go-proxy/error"
+	U "github.com/yusing/go-proxy/utils"
+)
+
+type Label struct {
+	Namespace string
+	Target    string
+	Attribute string
+	Value     any
+}
+
+// Apply applies the value of a Label to the corresponding field in the given object.
+//
+// Parameters:
+//   - obj: a pointer to the object to which the Label value will be applied.
+//   - l: a pointer to the Label containing the attribute and value to be applied.
+//
+// Returns:
+//   - error: an error if the field does not exist.
+func ApplyLabel[T any](obj *T, l *Label) E.NestedError {
+	return U.Deserialize(map[string]any{l.Attribute: l.Value}, obj)
+}
+
+type ValueParser func(string) (any, E.NestedError)
+type ValueParserMap map[string]ValueParser
+
+func ParseLabel(label string, value string) (*Label, E.NestedError) {
+	parts := strings.Split(label, ".")
+
+	if len(parts) < 2 {
+		return &Label{
+			Namespace: label,
+			Value:     value,
+		}, nil
+	}
+
+	l := &Label{
+		Namespace: parts[0],
+		Target:    parts[1],
+		Value:     value,
+	}
+
+	if len(parts) == 3 {
+		l.Attribute = parts[2]
+	} else {
+		l.Attribute = l.Target
+	}
+
+	// find if namespace has value parser
+	pm, ok := labelValueParserMap[l.Namespace]
+	if !ok {
+		return l, nil
+	}
+	// find if attribute has value parser
+	p, ok := pm[l.Attribute]
+	if !ok {
+		return l, nil
+	}
+	// try to parse value
+	v, err := p(value)
+	if err.HasError() {
+		return nil, err
+	}
+	l.Value = v
+	return l, nil
+}
+
+func RegisterNamespace(namespace string, pm ValueParserMap) {
+	labelValueParserMap[namespace] = pm
+}
+
+// namespace:target.attribute -> func(string) (any, error)
+var labelValueParserMap = make(map[string]ValueParserMap)

src/docker/label_parser.go

@@ -0,0 +1,61 @@
+package docker
+
+import (
+	"strings"
+
+	E "github.com/yusing/go-proxy/error"
+	"gopkg.in/yaml.v3"
+)
+
+func yamlListParser(value string) (any, E.NestedError) {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return []string{}, nil
+	}
+	var data []string
+	err := E.From(yaml.Unmarshal([]byte(value), &data))
+	return data, err
+}
+
+func yamlStringMappingParser(value string) (any, E.NestedError) {
+	value = strings.TrimSpace(value)
+	lines := strings.Split(value, "\n")
+	h := make(map[string]string)
+	for _, line := range lines {
+		parts := strings.SplitN(line, ":", 2)
+		if len(parts) != 2 {
+			return nil, E.Invalid("set header statement", line)
+		}
+		key := strings.TrimSpace(parts[0])
+		val := strings.TrimSpace(parts[1])
+		if existing, ok := h[key]; ok {
+			h[key] = existing + ", " + val
+		} else {
+			h[key] = val
+		}
+	}
+	return h, nil
+}
+
+func boolParser(value string) (any, E.NestedError) {
+	switch strings.ToLower(value) {
+	case "true", "yes", "1":
+		return true, nil
+	case "false", "no", "0":
+		return false, nil
+	default:
+		return nil, E.Invalid("boolean value", value)
+	}
+}
+
+const NSProxy = "proxy"
+
+var _ = func() int {
+	RegisterNamespace(NSProxy, ValueParserMap{
+		"path_patterns": yamlListParser,
+		"set_headers":   yamlStringMappingParser,
+		"hide_headers":  yamlListParser,
+		"no_tls_verify": boolParser,
+	})
+	return 0
+}()

src/docker/label_parser_test.go

@@ -0,0 +1,140 @@
+package docker
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	E "github.com/yusing/go-proxy/error"
+	. "github.com/yusing/go-proxy/utils/testing"
+)
+
+func makeLabel(namespace string, alias string, field string) string {
+	return fmt.Sprintf("%s.%s.%s", namespace, alias, field)
+}
+
+func TestHomePageLabel(t *testing.T) {
+	alias := "foo"
+	field := "ip"
+	v := "bar"
+	pl, err := ParseLabel(makeLabel(NSHomePage, alias, field), v)
+	ExpectNoError(t, err.Error())
+	if pl.Target != alias {
+		t.Errorf("Expected alias=%s, got %s", alias, pl.Target)
+	}
+	if pl.Attribute != field {
+		t.Errorf("Expected field=%s, got %s", field, pl.Target)
+	}
+	if pl.Value != v {
+		t.Errorf("Expected value=%q, got %s", v, pl.Value)
+	}
+}
+
+func TestStringProxyLabel(t *testing.T) {
+	v := "bar"
+	pl, err := ParseLabel(makeLabel(NSProxy, "foo", "ip"), v)
+	ExpectNoError(t, err.Error())
+	ExpectEqual(t, pl.Value.(string), v)
+}
+
+func TestBoolProxyLabelValid(t *testing.T) {
+	tests := map[string]bool{
+		"true":  true,
+		"TRUE":  true,
+		"yes":   true,
+		"1":     true,
+		"false": false,
+		"FALSE": false,
+		"no":    false,
+		"0":     false,
+	}
+
+	for k, v := range tests {
+		pl, err := ParseLabel(makeLabel(NSProxy, "foo", "no_tls_verify"), k)
+		ExpectNoError(t, err.Error())
+		ExpectEqual(t, pl.Value.(bool), v)
+	}
+}
+
+func TestBoolProxyLabelInvalid(t *testing.T) {
+	alias := "foo"
+	field := "no_tls_verify"
+	_, err := ParseLabel(makeLabel(NSProxy, alias, field), "invalid")
+	if !err.Is(E.ErrInvalid) {
+		t.Errorf("Expected err InvalidProxyLabel, got %s", err.Error())
+	}
+}
+
+func TestSetHeaderProxyLabelValid(t *testing.T) {
+	v := `
+X-Custom-Header1: foo, bar
+X-Custom-Header1: baz
+X-Custom-Header2: boo`
+	v = strings.TrimPrefix(v, "\n")
+	h := map[string]string{
+		"X-Custom-Header1": "foo, bar, baz",
+		"X-Custom-Header2": "boo",
+	}
+
+	pl, err := ParseLabel(makeLabel(NSProxy, "foo", "set_headers"), v)
+	ExpectNoError(t, err.Error())
+	hGot := ExpectType[map[string]string](t, pl.Value)
+	if hGot != nil && !reflect.DeepEqual(h, hGot) {
+		t.Errorf("Expected %v, got %v", h, hGot)
+	}
+
+}
+
+func TestSetHeaderProxyLabelInvalid(t *testing.T) {
+	tests := []string{
+		"X-Custom-Header1 = bar",
+		"X-Custom-Header1",
+		"- X-Custom-Header1",
+	}
+
+	for _, v := range tests {
+		_, err := ParseLabel(makeLabel(NSProxy, "foo", "set_headers"), v)
+		if !err.Is(E.ErrInvalid) {
+			t.Errorf("Expected invalid err for %q, got %s", v, err.Error())
+		}
+	}
+}
+
+func TestHideHeadersProxyLabel(t *testing.T) {
+	v := `
+- X-Custom-Header1
+- X-Custom-Header2
+- X-Custom-Header3
+`
+	v = strings.TrimPrefix(v, "\n")
+	pl, err := ParseLabel(makeLabel(NSProxy, "foo", "hide_headers"), v)
+	ExpectNoError(t, err.Error())
+	sGot := ExpectType[[]string](t, pl.Value)
+	sWant := []string{"X-Custom-Header1", "X-Custom-Header2", "X-Custom-Header3"}
+	if sGot != nil {
+		ExpectDeepEqual(t, sGot, sWant)
+	}
+}
+
+// func TestCommaSepProxyLabelSingle(t *testing.T) {
+// 	v := "a"
+// 	pl, err := ParseLabel("proxy.aliases", v)
+// 	ExpectNoError(t, err)
+// 	sGot := ExpectType[[]string](t, pl.Value)
+// 	sWant := []string{"a"}
+// 	if sGot != nil {
+// 		ExpectEqual(t, sGot, sWant)
+// 	}
+// }
+
+// func TestCommaSepProxyLabelMulti(t *testing.T) {
+// 	v := "X-Custom-Header1, X-Custom-Header2,X-Custom-Header3"
+// 	pl, err := ParseLabel("proxy.aliases", v)
+// 	ExpectNoError(t, err)
+// 	sGot := ExpectType[[]string](t, pl.Value)
+// 	sWant := []string{"X-Custom-Header1", "X-Custom-Header2", "X-Custom-Header3"}
+// 	if sGot != nil {
+// 		ExpectEqual(t, sGot, sWant)
+// 	}
+// }

src/docker/labels.go

@@ -0,0 +1,13 @@
+package docker
+
+const (
+	WildcardAlias = "*"
+
+	LableAliases     = NSProxy + ".aliases"
+	LableExclude     = NSProxy + ".exclude"
+	LabelIdleTimeout = NSProxy + ".idle_timeout"
+	LabelWakeTimeout = NSProxy + ".wake_timeout"
+	LabelStopMethod  = NSProxy + ".stop_method"
+	LabelStopTimeout = NSProxy + ".stop_timeout"
+	LabelStopSignal  = NSProxy + ".stop_signal"
+)

src/error/builder.go

@@ -0,0 +1,71 @@
+package error
+
+import (
+	"fmt"
+	"sync"
+)
+
+type Builder struct {
+	*builder
+}
+
+type builder struct {
+	message  string
+	errors   []NestedError
+	severity Severity
+	sync.Mutex
+}
+
+func NewBuilder(format string, args ...any) Builder {
+	return Builder{&builder{message: fmt.Sprintf(format, args...)}}
+}
+
+// adding nil / nil is no-op,
+// you may safely pass expressions returning error to it
+func (b Builder) Add(err NestedError) Builder {
+	if err != nil {
+		b.Lock()
+		b.errors = append(b.errors, err)
+		b.Unlock()
+	}
+	return b
+}
+
+func (b Builder) AddE(err error) Builder {
+	return b.Add(From(err))
+}
+
+func (b Builder) Addf(format string, args ...any) Builder {
+	return b.Add(errorf(format, args...))
+}
+
+func (b Builder) WithSeverity(s Severity) Builder {
+	b.severity = s
+	return b
+}
+
+// Build builds a NestedError based on the errors collected in the Builder.
+//
+// If there are no errors in the Builder, it returns a Nil() NestedError.
+// Otherwise, it returns a NestedError with the message and the errors collected.
+//
+// Returns:
+//   - NestedError: the built NestedError.
+func (b Builder) Build() NestedError {
+	if len(b.errors) == 0 {
+		return nil
+	}
+	return Join(b.message, b.errors...).Severity(b.severity)
+}
+
+func (b Builder) To(ptr *NestedError) {
+	if *ptr == nil {
+		*ptr = b.Build()
+	} else {
+		**ptr = *b.Build()
+	}
+}
+
+func (b Builder) HasError() bool {
+	return len(b.errors) > 0
+}

src/error/builder_test.go

@@ -0,0 +1,53 @@
+package error
+
+import (
+	"testing"
+
+	. "github.com/yusing/go-proxy/utils/testing"
+)
+
+func TestBuilderEmpty(t *testing.T) {
+	eb := NewBuilder("qwer")
+	ExpectTrue(t, eb.Build() == nil)
+	ExpectTrue(t, eb.Build().NoError())
+	ExpectFalse(t, eb.HasError())
+}
+
+func TestBuilderAddNil(t *testing.T) {
+	eb := NewBuilder("asdf")
+	var err NestedError
+	for range 3 {
+		eb.Add(nil)
+	}
+	for range 3 {
+		eb.Add(err)
+	}
+	ExpectTrue(t, eb.Build() == nil)
+	ExpectTrue(t, eb.Build().NoError())
+	ExpectFalse(t, eb.HasError())
+}
+
+func TestBuilderNested(t *testing.T) {
+	eb := NewBuilder("error occurred")
+	eb.Add(Failure("Action 1").With(Invalid("Inner", "1")).With(Invalid("Inner", "2")))
+	eb.Add(Failure("Action 2").With(Invalid("Inner", "3")))
+
+	got := eb.Build().String()
+	expected1 :=
+		(`error occurred:
+  - Action 1 failed:
+    - invalid Inner: 1
+    - invalid Inner: 2
+  - Action 2 failed:
+    - invalid Inner: 3`)
+	expected2 :=
+		(`error occurred:
+  - Action 1 failed:
+    - invalid Inner: 2
+    - invalid Inner: 1
+  - Action 2 failed:
+    - invalid Inner: 3`)
+	if got != expected1 && got != expected2 {
+		t.Errorf("expected \n%s, got \n%s", expected1, got)
+	}
+}

src/error/error.go

@@ -0,0 +1,256 @@
+package error
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+type (
+	NestedError = *nestedError
+	nestedError struct {
+		subject  string
+		err      error
+		extras   []nestedError
+		severity Severity
+	}
+	Severity uint8
+)
+
+const (
+	SeverityFatal Severity = iota
+	SeverityWarning
+)
+
+func From(err error) NestedError {
+	if IsNil(err) {
+		return nil
+	}
+	return &nestedError{err: err}
+}
+
+// Check is a helper function that
+// convert (T, error) to (T, NestedError).
+func Check[T any](obj T, err error) (T, NestedError) {
+	return obj, From(err)
+}
+
+func Join(message string, err ...NestedError) NestedError {
+	extras := make([]nestedError, len(err))
+	nErr := 0
+	for i, e := range err {
+		if e == nil {
+			continue
+		}
+		extras[i] = *e
+		nErr += 1
+	}
+	if nErr == 0 {
+		return nil
+	}
+	return &nestedError{
+		err:    errors.New(message),
+		extras: extras,
+	}
+}
+
+func JoinE(message string, err ...error) NestedError {
+	b := NewBuilder(message)
+	for _, e := range err {
+		b.AddE(e)
+	}
+	return b.Build()
+}
+
+func IsNil(err error) bool {
+	return err == nil
+}
+
+func IsNotNil(err error) bool {
+	return err != nil
+}
+
+func (ne NestedError) String() string {
+	var buf strings.Builder
+	ne.writeToSB(&buf, 0, "")
+	return buf.String()
+}
+
+func (ne NestedError) Is(err error) bool {
+	if ne == nil {
+		return err == nil
+	}
+	// return errors.Is(ne.err, err)
+	if errors.Is(ne.err, err) {
+		return true
+	}
+	for _, e := range ne.extras {
+		if e.Is(err) {
+			return true
+		}
+	}
+	return false
+}
+
+func (ne NestedError) IsNot(err error) bool {
+	return !ne.Is(err)
+}
+
+func (ne NestedError) Error() error {
+	if ne == nil {
+		return nil
+	}
+	return ne.buildError(0, "")
+}
+
+func (ne NestedError) With(s any) NestedError {
+	if ne == nil {
+		return ne
+	}
+	var msg string
+	switch ss := s.(type) {
+	case nil:
+		return ne
+	case NestedError:
+		return ne.withError(ss)
+	case error:
+		return ne.withError(From(ss))
+	case string:
+		msg = ss
+	case fmt.Stringer:
+		msg = ss.String()
+	default:
+		msg = fmt.Sprint(s)
+	}
+	return ne.withError(From(errors.New(msg)))
+}
+
+func (ne NestedError) Extraf(format string, args ...any) NestedError {
+	return ne.With(errorf(format, args...))
+}
+
+func (ne NestedError) Subject(s any) NestedError {
+	if ne == nil {
+		return ne
+	}
+	switch ss := s.(type) {
+	case string:
+		ne.subject = ss
+	case fmt.Stringer:
+		ne.subject = ss.String()
+	default:
+		ne.subject = fmt.Sprint(s)
+	}
+	return ne
+}
+
+func (ne NestedError) Subjectf(format string, args ...any) NestedError {
+	if ne == nil {
+		return ne
+	}
+	if strings.Contains(format, "%q") {
+		panic("Subjectf format should not contain %q")
+	}
+	if strings.Contains(format, "%w") {
+		panic("Subjectf format should not contain %w")
+	}
+	ne.subject = fmt.Sprintf(format, args...)
+	return ne
+}
+
+func (ne NestedError) Severity(s Severity) NestedError {
+	if ne == nil {
+		return ne
+	}
+	ne.severity = s
+	return ne
+}
+
+func (ne NestedError) Warn() NestedError {
+	if ne == nil {
+		return ne
+	}
+	ne.severity = SeverityWarning
+	return ne
+}
+
+func (ne NestedError) NoError() bool {
+	return ne == nil
+}
+
+func (ne NestedError) HasError() bool {
+	return ne != nil
+}
+
+func (ne NestedError) IsFatal() bool {
+	return ne != nil && ne.severity == SeverityFatal
+}
+
+func (ne NestedError) IsWarning() bool {
+	return ne != nil && ne.severity == SeverityWarning
+}
+
+func errorf(format string, args ...any) NestedError {
+	return From(fmt.Errorf(format, args...))
+}
+
+func (ne NestedError) withError(err NestedError) NestedError {
+	if ne != nil && err != nil {
+		ne.extras = append(ne.extras, *err)
+	}
+	return ne
+}
+
+func (ne NestedError) writeToSB(sb *strings.Builder, level int, prefix string) {
+	for i := 0; i < level; i++ {
+		sb.WriteString("  ")
+	}
+	sb.WriteString(prefix)
+
+	if ne.NoError() {
+		sb.WriteString("nil")
+		return
+	}
+
+	sb.WriteString(ne.err.Error())
+	if ne.subject != "" {
+		sb.WriteString(fmt.Sprintf(" for %q", ne.subject))
+	}
+	if len(ne.extras) > 0 {
+		sb.WriteRune(':')
+		for _, extra := range ne.extras {
+			sb.WriteRune('\n')
+			extra.writeToSB(sb, level+1, "- ")
+		}
+	}
+}
+
+func (ne NestedError) buildError(level int, prefix string) error {
+	var res error
+	var sb strings.Builder
+
+	for i := 0; i < level; i++ {
+		sb.WriteString("  ")
+	}
+	sb.WriteString(prefix)
+
+	if ne.NoError() {
+		sb.WriteString("nil")
+		return errors.New(sb.String())
+	}
+
+	res = fmt.Errorf("%s%w", sb.String(), ne.err)
+	sb.Reset()
+
+	if ne.subject != "" {
+		sb.WriteString(fmt.Sprintf(" for %q", ne.subject))
+	}
+	if len(ne.extras) > 0 {
+		sb.WriteRune(':')
+		res = fmt.Errorf("%w%s", res, sb.String())
+		for _, extra := range ne.extras {
+			res = errors.Join(res, extra.buildError(level+1, "- "))
+		}
+	}
+	return res
+}

src/error/error_test.go

@@ -0,0 +1,109 @@
+package error_test
+
+import (
+	"errors"
+	"testing"
+
+	. "github.com/yusing/go-proxy/error"
+	. "github.com/yusing/go-proxy/utils/testing"
+)
+
+func TestErrorIs(t *testing.T) {
+	ExpectTrue(t, Failure("foo").Is(ErrFailure))
+	ExpectTrue(t, Failure("foo").With("bar").Is(ErrFailure))
+	ExpectFalse(t, Failure("foo").With("bar").Is(ErrInvalid))
+	ExpectFalse(t, Failure("foo").With("bar").With("baz").Is(ErrInvalid))
+
+	ExpectTrue(t, Invalid("foo", "bar").Is(ErrInvalid))
+	ExpectFalse(t, Invalid("foo", "bar").Is(ErrFailure))
+
+	ExpectFalse(t, Invalid("foo", "bar").Is(nil))
+
+	ExpectTrue(t, errors.Is(Failure("foo").Error(), ErrFailure))
+	ExpectTrue(t, errors.Is(Failure("foo").With(Invalid("bar", "baz")).Error(), ErrInvalid))
+	ExpectTrue(t, errors.Is(Failure("foo").With(Invalid("bar", "baz")).Error(), ErrFailure))
+	ExpectFalse(t, errors.Is(Failure("foo").With(Invalid("bar", "baz")).Error(), ErrNotExists))
+}
+
+func TestErrorNestedIs(t *testing.T) {
+	var err NestedError
+	ExpectTrue(t, err.Is(nil))
+
+	err = Failure("some reason")
+	ExpectTrue(t, err.Is(ErrFailure))
+	ExpectFalse(t, err.Is(ErrAlreadyExist))
+
+	err.With(AlreadyExist("something", ""))
+	ExpectTrue(t, err.Is(ErrFailure))
+	ExpectTrue(t, err.Is(ErrAlreadyExist))
+	ExpectFalse(t, err.Is(ErrInvalid))
+}
+
+func TestIsNil(t *testing.T) {
+	var err NestedError
+	ExpectTrue(t, err.Is(nil))
+	ExpectFalse(t, err.HasError())
+	ExpectTrue(t, err == nil)
+	ExpectTrue(t, err.NoError())
+
+	eb := NewBuilder("")
+	returnNil := func() error {
+		return eb.Build().Error()
+	}
+	ExpectTrue(t, IsNil(returnNil()))
+	ExpectTrue(t, returnNil() == nil)
+
+	ExpectTrue(t, (err.
+		Subject("any").
+		With("something").
+		Extraf("foo %s", "bar")) == nil)
+}
+
+func TestErrorSimple(t *testing.T) {
+	ne := Failure("foo bar")
+	ExpectEqual(t, ne.String(), "foo bar failed")
+	ne = ne.Subject("baz")
+	ExpectEqual(t, ne.String(), "foo bar failed for \"baz\"")
+}
+
+func TestErrorWith(t *testing.T) {
+	ne := Failure("foo").With("bar").With("baz")
+	ExpectEqual(t, ne.String(), "foo failed:\n  - bar\n  - baz")
+}
+
+func TestErrorNested(t *testing.T) {
+	inner := Failure("inner").
+		With("1").
+		With("1")
+	inner2 := Failure("inner2").
+		Subject("action 2").
+		With("2").
+		With("2")
+	inner3 := Failure("inner3").
+		Subject("action 3").
+		With("3").
+		With("3")
+	ne := Failure("foo").
+		With("bar").
+		With("baz").
+		With(inner).
+		With(inner.With(inner2.With(inner3)))
+	want :=
+		`foo failed:
+  - bar
+  - baz
+  - inner failed:
+    - 1
+    - 1
+  - inner failed:
+    - 1
+    - 1
+    - inner2 failed for "action 2":
+      - 2
+      - 2
+      - inner3 failed for "action 3":
+        - 3
+        - 3`
+	ExpectEqual(t, ne.String(), want)
+	ExpectEqual(t, ne.Error().Error(), want)
+}

src/error/errors.go

@@ -0,0 +1,52 @@
+package error
+
+import (
+	stderrors "errors"
+)
+
+var (
+	ErrFailure      = stderrors.New("failed")
+	ErrInvalid      = stderrors.New("invalid")
+	ErrUnsupported  = stderrors.New("unsupported")
+	ErrUnexpected   = stderrors.New("unexpected")
+	ErrNotExists    = stderrors.New("does not exist")
+	ErrAlreadyExist = stderrors.New("already exist")
+)
+
+const fmtSubjectWhat = "%w %v: %v"
+
+func Failure(what string) NestedError {
+	return errorf("%s %w", what, ErrFailure)
+}
+
+func FailedWhy(what string, why string) NestedError {
+	return errorf("%s %w because %s", what, ErrFailure, why)
+}
+
+func FailWith(what string, err any) NestedError {
+	return Failure(what).With(err)
+}
+
+func Invalid(subject, what any) NestedError {
+	return errorf(fmtSubjectWhat, ErrInvalid, subject, what)
+}
+
+func Unsupported(subject, what any) NestedError {
+	return errorf(fmtSubjectWhat, ErrUnsupported, subject, what)
+}
+
+func Unexpected(subject, what any) NestedError {
+	return errorf(fmtSubjectWhat, ErrUnexpected, subject, what)
+}
+
+func UnexpectedError(err error) NestedError {
+	return errorf("%w error: %w", ErrUnexpected, err)
+}
+
+func NotExist(subject, what any) NestedError {
+	return errorf("%v %w: %v", subject, ErrNotExists, what)
+}
+
+func AlreadyExist(subject, what any) NestedError {
+	return errorf("%v %w: %v", subject, ErrAlreadyExist, what)
+}

src/go-proxy/autocert.go

@@ -1,233 +0,0 @@
-package main
-
-import (
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/tls"
-	"crypto/x509"
-	"fmt"
-	"os"
-	"path"
-	"sync"
-	"time"
-
-	"github.com/go-acme/lego/v4/certcrypto"
-	"github.com/go-acme/lego/v4/certificate"
-	"github.com/go-acme/lego/v4/lego"
-	"github.com/go-acme/lego/v4/providers/dns/cloudflare"
-	"github.com/go-acme/lego/v4/registration"
-)
-
-type AutoCertConfig struct {
-	Email    string
-	Domains  []string `yaml:",flow"`
-	Provider string
-	Options  map[string]string `yaml:",flow"`
-}
-
-type AutoCertUser struct {
-	Email        string
-	Registration *registration.Resource
-	key          crypto.PrivateKey
-}
-
-func (u *AutoCertUser) GetEmail() string {
-	return u.Email
-}
-func (u *AutoCertUser) GetRegistration() *registration.Resource {
-	return u.Registration
-}
-func (u *AutoCertUser) GetPrivateKey() crypto.PrivateKey {
-	return u.key
-}
-
-type AutoCertProvider interface {
-	GetCert(*tls.ClientHelloInfo) (*tls.Certificate, error)
-	GetName() string
-	GetExpiry() time.Time
-	LoadCert() bool
-	ObtainCert() error
-
-	needRenew() bool
-}
-
-func (cfg AutoCertConfig) GetProvider() (AutoCertProvider, error) {
-	if len(cfg.Domains) == 0 {
-		return nil, fmt.Errorf("no domains specified")
-	}
-	if cfg.Provider == "" {
-		return nil, fmt.Errorf("no provider specified")
-	}
-	if cfg.Email == "" {
-		return nil, fmt.Errorf("no email specified")
-	}
-
-	privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		return nil, fmt.Errorf("unable to generate private key: %v", err)
-	}
-	user := &AutoCertUser{
-		Email: cfg.Email,
-		key:   privKey,
-	}
-	legoCfg := lego.NewConfig(user)
-	legoCfg.Certificate.KeyType = certcrypto.RSA2048
-	legoClient, err := lego.NewClient(legoCfg)
-	if err != nil {
-		return nil, fmt.Errorf("unable to create lego client: %v", err)
-	}
-	base := &AutoCertProviderBase{
-		name:    cfg.Provider,
-		cfg:     cfg,
-		user:    user,
-		legoCfg: legoCfg,
-		client:  legoClient,
-	}
-	switch cfg.Provider {
-	case "cloudflare":
-		return NewAutoCertCFProvider(base, cfg.Options)
-	}
-	return nil, fmt.Errorf("unknown provider: %s", cfg.Provider)
-}
-
-type AutoCertProviderBase struct {
-	name    string
-	cfg     AutoCertConfig
-	user    *AutoCertUser
-	legoCfg *lego.Config
-	client  *lego.Client
-
-	tlsCert *tls.Certificate
-	expiry  time.Time
-	mutex   sync.Mutex
-}
-
-func (p *AutoCertProviderBase) GetCert(_ *tls.ClientHelloInfo) (*tls.Certificate, error) {
-	if p.tlsCert == nil {
-		aclog.Fatal("no certificate available")
-	}
-	if p.needRenew() {
-		p.mutex.Lock()
-		defer p.mutex.Unlock()
-		if p.needRenew() {
-			err := p.ObtainCert()
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-	return p.tlsCert, nil
-}
-
-func (p *AutoCertProviderBase) GetName() string {
-	return p.name
-}
-
-func (p *AutoCertProviderBase) GetExpiry() time.Time {
-	return p.expiry
-}
-
-func (p *AutoCertProviderBase) ObtainCert() error {
-	client := p.client
-	if p.user.Registration == nil {
-		reg, err := client.Registration.Register(registration.RegisterOptions{TermsOfServiceAgreed: true})
-		if err != nil {
-			return err
-		}
-		p.user.Registration = reg
-	}
-	req := certificate.ObtainRequest{
-		Domains: p.cfg.Domains,
-		Bundle:  true,
-	}
-	cert, err := client.Certificate.Obtain(req)
-	if err != nil {
-		return err
-	}
-	err = p.saveCert(cert)
-	if err != nil {
-		return err
-	}
-	tlsCert, err := tls.X509KeyPair(cert.Certificate, cert.PrivateKey)
-	if err != nil {
-		return err
-	}
-	p.tlsCert = &tlsCert
-	x509Cert, err := x509.ParseCertificate(tlsCert.Certificate[len(tlsCert.Certificate)-1])
-	if err != nil {
-		return err
-	}
-	p.expiry = x509Cert.NotAfter
-	return nil
-}
-
-func (p *AutoCertProviderBase) LoadCert() bool {
-	cert, err := tls.LoadX509KeyPair(certFileDefault, keyFileDefault)
-	if err != nil {
-		return false
-	}
-	x509Cert, err := x509.ParseCertificate(cert.Certificate[len(cert.Certificate)-1])
-	if err != nil {
-		return false
-	}
-	p.tlsCert = &cert
-	p.expiry = x509Cert.NotAfter
-	return true
-}
-
-func (p *AutoCertProviderBase) saveCert(cert *certificate.Resource) error {
-	err := os.MkdirAll(path.Dir(certFileDefault), 0644)
-	if err != nil {
-		return fmt.Errorf("unable to create cert directory: %v", err)
-	}
-	err = os.WriteFile(keyFileDefault, cert.PrivateKey, 0600) // -rw-------
-	if err != nil {
-		return fmt.Errorf("unable to write key file: %v", err)
-	}
-	err = os.WriteFile(certFileDefault, cert.Certificate, 0644) // -rw-r--r--
-	if err != nil {
-		return fmt.Errorf("unable to write cert file: %v", err)
-	}
-	return nil
-}
-
-func (p *AutoCertProviderBase) needRenew() bool {
-	return p.expiry.Before(time.Now().Add(24 * time.Hour))
-}
-
-type AutoCertCFProvider struct {
-	*AutoCertProviderBase
-	*cloudflare.Config
-}
-
-func NewAutoCertCFProvider(base *AutoCertProviderBase, opt map[string]string) (*AutoCertCFProvider, error) {
-	p := &AutoCertCFProvider{
-		base,
-		cloudflare.NewDefaultConfig(),
-	}
-	err := setOptions(p.Config, opt)
-	if err != nil {
-		return nil, err
-	}
-	legoProvider, err := cloudflare.NewDNSProviderConfig(p.Config)
-	if err != nil {
-		return nil, fmt.Errorf("unable to create cloudflare provider: %v", err)
-	}
-	err = p.client.Challenge.SetDNS01Provider(legoProvider)
-	if err != nil {
-		return nil, fmt.Errorf("unable to set challenge provider: %v", err)
-	}
-	return p, nil
-}
-
-func setOptions[T interface{}](cfg *T, opt map[string]string) error {
-	for k, v := range opt {
-		err := SetFieldFromSnake(cfg, k, v)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}

src/go-proxy/config.go

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"sync"
-
-	"gopkg.in/yaml.v3"
-)
-
-// commented out if unused
-type Config interface {
-	// Load() error
-	MustLoad()
-	GetAutoCertProvider() (AutoCertProvider, error)
-	// MustReload()
-	// Reload() error
-	StartProviders()
-	StopProviders()
-	WatchChanges()
-	StopWatching()
-}
-
-func NewConfig() Config {
-	cfg := &config{}
-	cfg.watcher = NewFileWatcher(
-		configPath,
-		cfg.MustReload,        // OnChange
-		func() { os.Exit(1) }, // OnDelete
-	)
-	return cfg
-}
-
-func (cfg *config) Load() error {
-	cfg.mutex.Lock()
-	defer cfg.mutex.Unlock()
-
-	// unload if any
-	cfg.StopProviders()
-
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		return fmt.Errorf("unable to read config file: %v", err)
-	}
-
-	cfg.Providers = make(map[string]*Provider)
-	if err = yaml.Unmarshal(data, &cfg); err != nil {
-		return fmt.Errorf("unable to parse config file: %v", err)
-	}
-
-	for name, p := range cfg.Providers {
-		err := p.Init(name)
-		if err != nil {
-			cfgl.Errorf("failed to initialize provider %q %v", name, err)
-			cfg.Providers[name] = nil
-		}
-	}
-
-	return nil
-}
-
-func (cfg *config) MustLoad() {
-	if err := cfg.Load(); err != nil {
-		cfgl.Fatal(err)
-	}
-}
-
-func (cfg *config) GetAutoCertProvider() (AutoCertProvider, error) {
-	return cfg.AutoCert.GetProvider()
-}
-
-func (cfg *config) Reload() error {
-	return cfg.Load()
-}
-
-func (cfg *config) MustReload() {
-	cfg.MustLoad()
-}
-
-func (cfg *config) StartProviders() {
-	if cfg.Providers == nil {
-		cfgl.Fatal("providers not loaded")
-	}
-	// Providers have their own mutex, no lock needed
-	ParallelForEachValue(cfg.Providers, (*Provider).StartAllRoutes)
-}
-
-func (cfg *config) StopProviders() {
-	if cfg.Providers != nil {
-		// Providers have their own mutex, no lock needed
-		ParallelForEachValue(cfg.Providers, (*Provider).StopAllRoutes)
-	}
-}
-
-func (cfg *config) WatchChanges() {
-	cfg.watcher.Start()
-}
-
-func (cfg *config) StopWatching() {
-	cfg.watcher.Stop()
-}
-
-type config struct {
-	Providers map[string]*Provider `yaml:",flow"`
-	AutoCert  AutoCertConfig       `yaml:",flow"`
-	watcher   Watcher
-	mutex     sync.Mutex
-}

src/go-proxy/constants.go

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"net"
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/sirupsen/logrus"
-)
-
-var (
-	ImageNamePortMap = map[string]string{
-		"postgres":  "5432",
-		"mysql":     "3306",
-		"mariadb":   "3306",
-		"redis":     "6379",
-		"mssql":     "1433",
-		"memcached": "11211",
-		"rabbitmq":  "5672",
-		"mongo":     "27017",
-	}
-	ExtraNamePortMap = map[string]string{
-		"dns":  "53",
-		"ssh":  "22",
-		"ftp":  "21",
-		"smtp": "25",
-		"pop3": "110",
-		"imap": "143",
-	}
-	NamePortMap = func() map[string]string {
-		m := make(map[string]string)
-		for k, v := range ImageNamePortMap {
-			m[k] = v
-		}
-		for k, v := range ExtraNamePortMap {
-			m[k] = v
-		}
-		return m
-	}()
-)
-
-var (
-	StreamSchemes = []string{StreamType_TCP, StreamType_UDP} // TODO: support "tcp:udp", "udp:tcp"
-	HTTPSchemes   = []string{"http", "https"}
-	ValidSchemes  = append(StreamSchemes, HTTPSchemes...)
-)
-
-const (
-	StreamType_UDP = "udp"
-	StreamType_TCP = "tcp"
-)
-
-const (
-	ProxyPathMode_Forward     = "forward"
-	ProxyPathMode_Sub         = "sub"
-	ProxyPathMode_RemovedPath = ""
-)
-
-const (
-	ProviderKind_Docker = "docker"
-	ProviderKind_File   = "file"
-)
-
-// TODO: default + per proxy
-var (
-	transport = &http.Transport{
-		Proxy: http.ProxyFromEnvironment,
-		DialContext: (&net.Dialer{
-			Timeout:   60 * time.Second,
-			KeepAlive: 60 * time.Second,
-		}).DialContext,
-		MaxIdleConns:        1000,
-		MaxIdleConnsPerHost: 1000,
-	}
-
-	transportNoTLS = func() *http.Transport {
-		var clone = transport.Clone()
-		clone.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
-		return clone
-	}()
-)
-
-const wildcardLabelPrefix = "proxy.*."
-
-const clientUrlFromEnv = "FROM_ENV"
-
-const (
-	certFileDefault = "certs/cert.crt"
-	keyFileDefault  = "certs/priv.key"
-	configPath      = "config.yml"
-	templatePath    = "templates/panel.html"
-)
-
-const StreamStopListenTimeout = 1 * time.Second
-
-const udpBufferSize = 1500
-
-var logLevel = func() logrus.Level {
-	switch os.Getenv("GOPROXY_DEBUG") {
-	case "1", "true":
-		logrus.SetLevel(logrus.DebugLevel)
-	}
-	return logrus.GetLevel()
-}()
-
-var redirectHTTP = os.Getenv("GOPROXY_REDIRECT_HTTP") != "0" && os.Getenv("GOPROXY_REDIRECT_HTTP") != "false"

src/go-proxy/docker_provider.go

@@ -1,202 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/docker/cli/cli/connhelper"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/client"
-	"golang.org/x/net/context"
-)
-
-func (p *Provider) setConfigField(c *ProxyConfig, label string, value string, prefix string) error {
-	if strings.HasPrefix(label, prefix) {
-		field := strings.TrimPrefix(label, prefix)
-		SetFieldFromSnake(c, field, value)
-	}
-	return nil
-}
-
-func (p *Provider) getContainerProxyConfigs(container types.Container, clientIP string) []*ProxyConfig {
-	var aliases []string
-
-	cfgs := make([]*ProxyConfig, 0)
-
-	container_name := strings.TrimPrefix(container.Names[0], "/")
-	aliases_label, ok := container.Labels["proxy.aliases"]
-
-	if !ok {
-		aliases = []string{container_name}
-	} else {
-		aliases = strings.Split(aliases_label, ",")
-	}
-
-	isRemote := clientIP != ""
-
-	for _, alias := range aliases {
-		l := p.l.WithField("container", container_name).WithField("alias", alias)
-		config := NewProxyConfig(p)
-		prefix := fmt.Sprintf("proxy.%s.", alias)
-		for label, value := range container.Labels {
-			err := p.setConfigField(&config, label, value, prefix)
-			if err != nil {
-				l.Error(err)
-			}
-			err = p.setConfigField(&config, label, value, wildcardLabelPrefix)
-			if err != nil {
-				l.Error(err)
-			}
-		}
-		if config.Port == "" {
-			config.Port = fmt.Sprintf("%d", selectPort(container))
-		}
-		if config.Port == "0" {
-			// no ports exposed or specified
-			l.Debugf("no ports exposed, ignored")
-			continue
-		}
-		if config.Scheme == "" {
-			switch {
-			case strings.HasSuffix(config.Port, "443"):
-				config.Scheme = "https"
-			case strings.HasPrefix(container.Image, "sha256:"):
-				config.Scheme = "http"
-			default:
-				imageSplit := strings.Split(container.Image, "/")
-				imageSplit = strings.Split(imageSplit[len(imageSplit)-1], ":")
-				imageName := imageSplit[0]
-				_, isKnownImage := ImageNamePortMap[imageName]
-				if isKnownImage {
-					config.Scheme = "tcp"
-				} else {
-					config.Scheme = "http"
-				}
-			}
-		}
-		if !isValidScheme(config.Scheme) {
-			l.Warnf("unsupported scheme: %s, using http", config.Scheme)
-			config.Scheme = "http"
-		}
-		if config.Host == "" {
-			switch {
-			case isRemote:
-				config.Host = clientIP
-			case container.HostConfig.NetworkMode == "host":
-				config.Host = "host.docker.internal"
-			case config.LoadBalance == "true", config.LoadBalance == "1":
-				for _, network := range container.NetworkSettings.Networks {
-					config.Host = network.IPAddress
-					break
-				}
-			default:
-				for _, network := range container.NetworkSettings.Networks {
-					for _, alias := range network.Aliases {
-						config.Host = alias
-						break
-					}
-				}
-			}
-		}
-		if config.Host == "" {
-			config.Host = container_name
-		}
-		config.Alias = alias
-
-		cfgs = append(cfgs, &config)
-	}
-	return cfgs
-}
-
-func (p *Provider) getDockerClient() (*client.Client, error) {
-	var dockerOpts []client.Opt
-	if p.Value == clientUrlFromEnv {
-		dockerOpts = []client.Opt{
-			client.WithHostFromEnv(),
-			client.WithAPIVersionNegotiation(),
-		}
-	} else {
-		helper, err := connhelper.GetConnectionHelper(p.Value)
-		if err != nil {
-			p.l.Fatal("unexpected error: ", err)
-		}
-		if helper != nil {
-			httpClient := &http.Client{
-				Transport: &http.Transport{
-					DialContext: helper.Dialer,
-				},
-			}
-			dockerOpts = []client.Opt{
-				client.WithHTTPClient(httpClient),
-				client.WithHost(helper.Host),
-				client.WithAPIVersionNegotiation(),
-				client.WithDialContext(helper.Dialer),
-			}
-		} else {
-			dockerOpts = []client.Opt{
-				client.WithHost(p.Value),
-				client.WithAPIVersionNegotiation(),
-			}
-		}
-	}
-	return client.NewClientWithOpts(dockerOpts...)
-}
-
-func (p *Provider) getDockerProxyConfigs() ([]*ProxyConfig, error) {
-	var clientIP string
-
-	if p.Value == clientUrlFromEnv {
-		clientIP = ""
-	} else {
-		url, err := client.ParseHostURL(p.Value)
-		if err != nil {
-			return nil, fmt.Errorf("unable to parse docker host url: %v", err)
-		}
-		clientIP = strings.Split(url.Host, ":")[0]
-	}
-
-	dockerClient, err := p.getDockerClient()
-
-	if err != nil {
-		return nil, fmt.Errorf("unable to create docker client: %v", err)
-	}
-
-	ctx, _ := context.WithTimeout(context.Background(), 3*time.Second)
-	containerSlice, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
-
-	if err != nil {
-		return nil, fmt.Errorf("unable to list containers: %v", err)
-	}
-
-	cfgs := make([]*ProxyConfig, 0)
-
-	for _, container := range containerSlice {
-		cfgs = append(cfgs, p.getContainerProxyConfigs(container, clientIP)...)
-	}
-
-	return cfgs, nil
-}
-
-// var dockerUrlRegex = regexp.MustCompile(`^(?P<scheme>\w+)://(?P<host>[^:]+)(?P<port>:\d+)?(?P<path>/.*)?$`)
-
-func getPublicPort(p types.Port) uint16  { return p.PublicPort }
-func getPrivatePort(p types.Port) uint16 { return p.PrivatePort }
-
-func selectPort(c types.Container) uint16 {
-	if c.HostConfig.NetworkMode == "host" {
-		return selectPortInternal(c, getPrivatePort)
-	}
-	return selectPortInternal(c, getPublicPort)
-}
-
-func selectPortInternal(c types.Container, getPort func(types.Port) uint16) uint16 {
-	for _, p := range c.Ports {
-		if port := getPort(p); port != 0 {
-			return port
-		}
-	}
-	return 0
-}

src/go-proxy/file_provider.go

@@ -1,39 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"gopkg.in/yaml.v3"
-)
-
-func (p *Provider) getFileProxyConfigs() ([]*ProxyConfig, error) {
-	path := p.Value
-
-	if _, err := os.Stat(path); err == nil {
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return nil, fmt.Errorf("unable to read config file %q: %v", path, err)
-		}
-		configMap := make(map[string]ProxyConfig, 0)
-		configs := make([]*ProxyConfig, 0)
-		err = yaml.Unmarshal(data, &configMap)
-		if err != nil {
-			return nil, fmt.Errorf("unable to parse config file %q: %v", path, err)
-		}
-
-		for alias, cfg := range configMap {
-			cfg.Alias = alias
-			err = cfg.SetDefaults()
-			if err != nil {
-				return nil, err
-			}
-			configs = append(configs, &cfg)
-		}
-		return configs, nil
-	} else if !os.IsNotExist(err) {
-		return nil, fmt.Errorf("file not found: %s", path)
-	} else {
-		return nil, err
-	}
-}

src/go-proxy/functional.go

@@ -1,39 +0,0 @@
-package main
-
-import "sync"
-
-func ParallelForEach[T interface{}](obj []T, do func(T)) {
-	var wg sync.WaitGroup
-	wg.Add(len(obj))
-	for _, v := range obj {
-		go func(v T) {
-			do(v)
-			wg.Done()
-		}(v)
-	}
-	wg.Wait()
-}
-
-func ParallelForEachValue[K comparable, V interface{}](obj map[K]V, do func(V)) {
-	var wg sync.WaitGroup
-	wg.Add(len(obj))
-	for _, v := range obj {
-		go func(v V) {
-			do(v)
-			wg.Done()
-		}(v)
-	}
-	wg.Wait()
-}
-
-func ParallelForEachKeyValue[K comparable, V interface{}](obj map[K]V, do func(K, V)) {
-	var wg sync.WaitGroup
-	wg.Add(len(obj))
-	for k, v := range obj {
-		go func(k K, v V) {
-			do(k, v)
-			wg.Done()
-		}(k, v)
-	}
-	wg.Wait()
-}

src/go-proxy/http_lbpool.go

@@ -1,29 +0,0 @@
-package main
-
-import "sync/atomic"
-
-type httpLoadBalancePool struct {
-	pool        []*HTTPRoute
-	curentIndex atomic.Int32
-}
-
-func NewHTTPLoadBalancePool() *httpLoadBalancePool {
-	return &httpLoadBalancePool{
-		pool: make([]*HTTPRoute, 0),
-	}
-}
-
-func (p *httpLoadBalancePool) Add(route *HTTPRoute) {
-	p.pool = append(p.pool, route)
-}
-
-func (p *httpLoadBalancePool) Iterator() []*HTTPRoute {
-	return p.pool
-}
-
-func (p *httpLoadBalancePool) Pick() *HTTPRoute {
-	// round-robin
-	index := int(p.curentIndex.Load())
-	defer p.curentIndex.Add(1)
-	return p.pool[index%len(p.pool)]
-}

src/go-proxy/http_route.go

@@ -1,177 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/sirupsen/logrus"
-)
-
-type HTTPRoute struct {
-	Alias    string
-	Url      *url.URL
-	Path     string
-	PathMode string
-	Proxy    *ReverseProxy
-
-	l logrus.FieldLogger
-}
-
-func NewHTTPRoute(config *ProxyConfig) (*HTTPRoute, error) {
-	url, err := url.Parse(fmt.Sprintf("%s://%s:%s", config.Scheme, config.Host, config.Port))
-	if err != nil {
-		return nil, err
-	}
-
-	var tr *http.Transport
-	if config.NoTLSVerify {
-		tr = transportNoTLS
-	} else {
-		tr = transport
-	}
-
-	proxy := NewSingleHostReverseProxy(url, tr)
-
-	if !isValidProxyPathMode(config.PathMode) {
-		return nil, fmt.Errorf("invalid path mode: %s", config.PathMode)
-	}
-
-	route := &HTTPRoute{
-		Alias:    config.Alias,
-		Url:      url,
-		Path:     config.Path,
-		Proxy:    proxy,
-		PathMode: config.PathMode,
-		l: hrlog.WithFields(logrus.Fields{
-			"alias":     config.Alias,
-			"path":      config.Path,
-			"path_mode": config.PathMode,
-		}),
-	}
-
-	var rewriteBegin = proxy.Rewrite
-	var rewrite func(*ProxyRequest)
-	var modifyResponse func(*http.Response) error
-
-	switch {
-	case config.Path == "", config.PathMode == ProxyPathMode_Forward:
-		rewrite = rewriteBegin
-	case config.PathMode == ProxyPathMode_Sub:
-		rewrite = func(pr *ProxyRequest) {
-			rewriteBegin(pr)
-			// disable compression
-			pr.Out.Header.Set("Accept-Encoding", "identity")
-			// remove path prefix
-			pr.Out.URL.Path = strings.TrimPrefix(pr.Out.URL.Path, config.Path)
-		}
-		modifyResponse = func(r *http.Response) error {
-			contentType, ok := r.Header["Content-Type"]
-			if !ok || len(contentType) == 0 {
-				route.l.Debug("unknown content type for ", r.Request.URL.String())
-				return nil
-			}
-			// disable cache
-			r.Header.Set("Cache-Control", "no-store")
-
-			var err error = nil
-			switch {
-			case strings.HasPrefix(contentType[0], "text/html"):
-				err = utils.respHTMLSubPath(r, config.Path)
-			case strings.HasPrefix(contentType[0], "application/javascript"):
-				err = utils.respJSSubPath(r, config.Path)
-			default:
-				route.l.Debug("unknown content type(s): ", contentType)
-			}
-			if err != nil {
-				err = fmt.Errorf("failed to remove path prefix %s: %v", config.Path, err)
-				route.l.WithField("action", "path_sub").Error(err)
-				r.Status = err.Error()
-				r.StatusCode = http.StatusInternalServerError
-			}
-			return err
-		}
-	default:
-		rewrite = func(pr *ProxyRequest) {
-			rewriteBegin(pr)
-			pr.Out.URL.Path = strings.TrimPrefix(pr.Out.URL.Path, config.Path)
-		}
-	}
-
-	if logLevel == logrus.DebugLevel {
-		route.Proxy.Rewrite = func(pr *ProxyRequest) {
-			rewrite(pr)
-			route.l.Debug("request URL: ", pr.In.Host, pr.In.URL.Path)
-			route.l.Debug("request headers: ", pr.In.Header)
-		}
-		route.Proxy.ModifyResponse = func(r *http.Response) error {
-			route.l.Debug("response URL: ", r.Request.URL.String())
-			route.l.Debug("response headers: ", r.Header)
-			if modifyResponse != nil {
-				return modifyResponse(r)
-			}
-			return nil
-		}
-	} else {
-		route.Proxy.Rewrite = rewrite
-	}
-
-	return route, nil
-}
-
-func (r *HTTPRoute) Start() {}
-func (r *HTTPRoute) Stop() {
-	httpRoutes.Delete(r.Alias)
-}
-
-func isValidProxyPathMode(mode string) bool {
-	switch mode {
-	case ProxyPathMode_Forward, ProxyPathMode_Sub, ProxyPathMode_RemovedPath:
-		return true
-	default:
-		return false
-	}
-}
-
-func redirectToTLSHandler(w http.ResponseWriter, r *http.Request) {
-	// Redirect to the same host but with HTTPS
-	var redirectCode int
-	if r.Method == http.MethodGet {
-		redirectCode = http.StatusMovedPermanently
-	} else {
-		redirectCode = http.StatusPermanentRedirect
-	}
-	http.Redirect(w, r, fmt.Sprintf("https://%s%s?%s", r.Host, r.URL.Path, r.URL.RawQuery), redirectCode)
-}
-
-func findHTTPRoute(host string, path string) (*HTTPRoute, error) {
-	subdomain := strings.Split(host, ".")[0]
-	routeMap, ok := httpRoutes.UnsafeGet(subdomain)
-	if ok {
-		return routeMap.FindMatch(path)
-	}
-	return nil, fmt.Errorf("no matching route for subdomain %s", subdomain)
-}
-
-func proxyHandler(w http.ResponseWriter, r *http.Request) {
-	route, err := findHTTPRoute(r.Host, r.URL.Path)
-	if err != nil {
-		err = fmt.Errorf("request failed %s %s%s, error: %v",
-			r.Method,
-			r.Host,
-			r.URL.Path,
-			err,
-		)
-		logrus.Error(err)
-		http.Error(w, err.Error(), http.StatusNotFound)
-		return
-	}
-	route.Proxy.ServeHTTP(w, r)
-}
-
-// alias -> (path -> routes)
-type HTTPRoutes = SafeMap[string, *pathPoolMap]
-
-var httpRoutes HTTPRoutes = NewSafeMap[string](newPathPoolMap)

src/go-proxy/loggers.go

@@ -1,11 +0,0 @@
-package main
-
-import "github.com/sirupsen/logrus"
-
-var palog = logrus.WithField("component", "panel")
-var prlog = logrus.WithField("component", "provider")
-var cfgl = logrus.WithField("component", "config")
-var hrlog = logrus.WithField("component", "http_proxy")
-var srlog = logrus.WithField("component", "stream")
-var wlog = logrus.WithField("component", "watcher")
-var aclog = logrus.WithField("component", "autocert")

src/go-proxy/main.go

@@ -1,95 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"os"
-	"os/signal"
-	"runtime"
-	"syscall"
-
-	"github.com/sirupsen/logrus"
-)
-
-func main() {
-	// flag.Parse()
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	logrus.SetFormatter(&logrus.TextFormatter{
-		ForceColors:   true,
-		DisableColors: false,
-		FullTimestamp: true,
-	})
-
-	cfg := NewConfig()
-	cfg.MustLoad()
-
-	autoCertProvider, err := cfg.GetAutoCertProvider()
-
-	if err != nil {
-		aclog.Warn(err)
-		autoCertProvider = nil
-	}
-
-	var httpProxyHandler http.Handler
-	var httpPanelHandler http.Handler
-
-	var proxyServer *Server
-	var panelServer *Server
-
-	if redirectHTTP {
-		httpProxyHandler = http.HandlerFunc(redirectToTLSHandler)
-		httpPanelHandler = http.HandlerFunc(redirectToTLSHandler)
-	} else {
-		httpProxyHandler = http.HandlerFunc(proxyHandler)
-		httpPanelHandler = http.HandlerFunc(panelHandler)
-	}
-
-	if autoCertProvider != nil {
-		ok := autoCertProvider.LoadCert()
-		if !ok {
-			err := autoCertProvider.ObtainCert()
-			if err != nil {
-				aclog.Fatal("error obtaining certificate ", err)
-			}
-		}
-		aclog.Infof("certificate will be expired at %v and get renewed", autoCertProvider.GetExpiry())
-	}
-	proxyServer = NewServer(
-		"proxy",
-		autoCertProvider,
-		":80",
-		httpProxyHandler,
-		":443",
-		http.HandlerFunc(proxyHandler),
-	)
-	panelServer = NewServer(
-		"panel",
-		autoCertProvider,
-		":8080",
-		httpPanelHandler,
-		":8443",
-		http.HandlerFunc(panelHandler),
-	)
-
-	proxyServer.Start()
-	panelServer.Start()
-
-	InitFSWatcher()
-	InitDockerWatcher()
-
-	cfg.StartProviders()
-	cfg.WatchChanges()
-
-	sig := make(chan os.Signal, 1)
-	signal.Notify(sig, syscall.SIGINT)
-	signal.Notify(sig, syscall.SIGTERM)
-	signal.Notify(sig, syscall.SIGHUP)
-
-	<-sig
-	cfg.StopWatching()
-	StopFSWatcher()
-	StopDockerWatcher()
-	cfg.StopProviders()
-	panelServer.Stop()
-	proxyServer.Stop()
-}

src/go-proxy/map.go

@@ -1,99 +0,0 @@
-package main
-
-import "sync"
-
-type safeMap[KT comparable, VT interface{}] struct {
-	SafeMap[KT, VT]
-	m              map[KT]VT
-	mutex          sync.Mutex
-	defaultFactory func() VT
-}
-
-type SafeMap[KT comparable, VT interface{}] interface {
-	Set(key KT, value VT)
-	Ensure(key KT)
-	Get(key KT) VT
-	UnsafeGet(key KT) (VT, bool)
-	Delete(key KT)
-	Clear()
-	Size() int
-	Contains(key KT) bool
-	ForEach(fn func(key KT, value VT))
-	Iterator() map[KT]VT
-}
-
-func NewSafeMap[KT comparable, VT interface{}](df ...func() VT) SafeMap[KT, VT] {
-	if len(df) == 0 {
-		return &safeMap[KT, VT]{
-			m: make(map[KT]VT),
-		}
-	}
-	return &safeMap[KT, VT]{
-		m:              make(map[KT]VT),
-		defaultFactory: df[0],
-	}
-}
-
-func (m *safeMap[KT, VT]) Set(key KT, value VT) {
-	m.mutex.Lock()
-	m.m[key] = value
-	m.mutex.Unlock()
-}
-
-func (m *safeMap[KT, VT]) Ensure(key KT) {
-	m.mutex.Lock()
-	if _, ok := m.m[key]; !ok {
-		m.m[key] = m.defaultFactory()
-	}
-	m.mutex.Unlock()
-}
-
-func (m *safeMap[KT, VT]) Get(key KT) VT {
-	m.mutex.Lock()
-	value := m.m[key]
-	m.mutex.Unlock()
-	return value
-}
-
-func (m *safeMap[KT, VT]) UnsafeGet(key KT) (VT, bool) {
-	value, ok := m.m[key]
-	return value, ok
-}
-
-func (m *safeMap[KT, VT]) Delete(key KT) {
-	m.mutex.Lock()
-	delete(m.m, key)
-	m.mutex.Unlock()
-}
-
-func (m *safeMap[KT, VT]) Clear() {
-	m.mutex.Lock()
-	m.m = make(map[KT]VT)
-	m.mutex.Unlock()
-}
-
-func (m *safeMap[KT, VT]) Size() int {
-	m.mutex.Lock()
-	size := len(m.m)
-	m.mutex.Unlock()
-	return size
-}
-
-func (m *safeMap[KT, VT]) Contains(key KT) bool {
-	m.mutex.Lock()
-	_, ok := m.m[key]
-	m.mutex.Unlock()
-	return ok
-}
-
-func (m *safeMap[KT, VT]) ForEach(fn func(key KT, value VT)) {
-	m.mutex.Lock()
-	for k, v := range m.m {
-		fn(k, v)
-	}
-	m.mutex.Unlock()
-}
-
-func (m *safeMap[KT, VT]) Iterator() map[KT]VT {
-	return m.m
-}

src/go-proxy/panel.go

@@ -1,100 +0,0 @@
-package main
-
-import (
-	"html/template"
-	"net"
-	"net/http"
-	"net/url"
-	"time"
-)
-
-var healthCheckHttpClient = &http.Client{
-	Timeout: 5 * time.Second,
-	Transport: &http.Transport{
-		Proxy:             http.ProxyFromEnvironment,
-		DisableKeepAlives: true,
-		ForceAttemptHTTP2: true,
-		DialContext: (&net.Dialer{
-			Timeout:   5 * time.Second,
-			KeepAlive: 5 * time.Second,
-		}).DialContext,
-	},
-}
-
-func panelHandler(w http.ResponseWriter, r *http.Request) {
-	switch r.URL.Path {
-	case "/":
-		panelIndex(w, r)
-		return
-	case "/checkhealth":
-		panelCheckTargetHealth(w, r)
-		return
-	default:
-		palog.Errorf("%s not found", r.URL.Path)
-		http.NotFound(w, r)
-		return
-	}
-}
-
-func panelIndex(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodGet {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-
-	tmpl, err := template.ParseFiles(templatePath)
-
-	if err != nil {
-		palog.Error(err)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	type allRoutes struct {
-		HTTPRoutes   HTTPRoutes
-		StreamRoutes StreamRoutes
-	}
-
-	err = tmpl.Execute(w, allRoutes{
-		HTTPRoutes:   httpRoutes,
-		StreamRoutes: streamRoutes,
-	})
-	if err != nil {
-		palog.Error(err)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-func panelCheckTargetHealth(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodHead {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-
-	targetUrl := r.URL.Query().Get("target")
-
-	if targetUrl == "" {
-		http.Error(w, "target is required", http.StatusBadRequest)
-		return
-	}
-
-	url, err := url.Parse(targetUrl)
-	if err != nil {
-		palog.Infof("failed to parse url %q, error: %v", targetUrl, err)
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	scheme := url.Scheme
-
-	if isStreamScheme(scheme) {
-		err = utils.healthCheckStream(scheme, url.Host)
-	} else {
-		err = utils.healthCheckHttp(targetUrl)
-	}
-
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-	} else {
-		w.WriteHeader(http.StatusOK)
-	}
-}

src/go-proxy/path_pool_map.go

@@ -1,30 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-)
-
-type pathPoolMap struct {
-	SafeMap[string, *httpLoadBalancePool]
-}
-
-func newPathPoolMap() *pathPoolMap {
-	return &pathPoolMap{
-		NewSafeMap[string](NewHTTPLoadBalancePool),
-	}
-}
-
-func (m pathPoolMap) Add(path string, route *HTTPRoute) {
-	m.Ensure(path)
-	m.Get(path).Add(route)
-}
-
-func (m pathPoolMap) FindMatch(pathGot string) (*HTTPRoute, error) {
-	for pathWant, v := range m.Iterator() {
-		if strings.HasPrefix(pathGot, pathWant) {
-			return v.Pick(), nil
-		}
-	}
-	return nil, fmt.Errorf("no matching route for path %s", pathGot)
-}

src/go-proxy/provider.go

@@ -1,101 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/sirupsen/logrus"
-)
-
-type Provider struct {
-	Kind  string // docker, file
-	Value string
-
-	watcher Watcher
-	routes  map[string]Route // id -> Route
-	mutex   sync.Mutex
-	l       logrus.FieldLogger
-}
-
-// Init is called after LoadProxyConfig
-func (p *Provider) Init(name string) error {
-	p.l = prlog.WithFields(logrus.Fields{"kind": p.Kind, "name": name})
-
-	if err := p.loadProxyConfig(); err != nil {
-		return err
-	}
-
-	p.initWatcher()
-	return nil
-}
-
-func (p *Provider) StartAllRoutes() {
-	ParallelForEachValue(p.routes, Route.Start)
-	p.watcher.Start()
-}
-
-func (p *Provider) StopAllRoutes() {
-	p.watcher.Stop()
-	ParallelForEachValue(p.routes, Route.Stop)
-	p.routes = make(map[string]Route)
-}
-
-func (p *Provider) ReloadRoutes() {
-	p.mutex.Lock()
-	defer p.mutex.Unlock()
-
-	p.StopAllRoutes()
-	err := p.loadProxyConfig()
-	if err != nil {
-		p.l.Error("failed to reload routes: ", err)
-		return
-	}
-	p.StartAllRoutes()
-}
-
-func (p *Provider) loadProxyConfig() error {
-	var cfgs []*ProxyConfig
-	var err error
-
-	switch p.Kind {
-	case ProviderKind_Docker:
-		cfgs, err = p.getDockerProxyConfigs()
-	case ProviderKind_File:
-		cfgs, err = p.getFileProxyConfigs()
-	default:
-		// this line should never be reached
-		return fmt.Errorf("unknown provider kind")
-	}
-
-	if err != nil {
-		return err
-	}
-	p.l.Infof("loaded %d proxy configurations", len(cfgs))
-
-	p.routes = make(map[string]Route, len(cfgs))
-	for _, cfg := range cfgs {
-		r, err := NewRoute(cfg)
-		if err != nil {
-			p.l.Errorf("error creating route %s: %v", cfg.Alias, err)
-			continue
-		}
-		p.routes[cfg.GetID()] = r
-	}
-
-	return nil
-}
-
-func (p *Provider) initWatcher() error {
-	switch p.Kind {
-	case ProviderKind_Docker:
-		var err error
-		dockerClient, err := p.getDockerClient()
-		if err != nil {
-			return fmt.Errorf("unable to create docker client: %v", err)
-		}
-		p.watcher = NewDockerWatcher(dockerClient, p.ReloadRoutes)
-	case ProviderKind_File:
-		p.watcher = NewFileWatcher(p.Value, p.ReloadRoutes, p.StopAllRoutes)
-	}
-	return nil
-}

src/go-proxy/proxy_config.go

@@ -1,43 +0,0 @@
-package main
-
-import "fmt"
-
-type ProxyConfig struct {
-	Alias       string
-	Scheme      string
-	Host        string
-	Port        string
-	LoadBalance string // docker provider only
-	NoTLSVerify bool   // http proxy only
-	Path        string // http proxy only
-	PathMode    string `yaml:"path_mode"` // http proxy only
-
-	provider *Provider
-}
-
-func NewProxyConfig(provider *Provider) ProxyConfig {
-	return ProxyConfig{
-		provider: provider,
-	}
-}
-
-// used by `GetFileProxyConfigs`
-func (cfg *ProxyConfig) SetDefaults() error {
-	if cfg.Alias == "" {
-		return fmt.Errorf("alias is required")
-	}
-	if cfg.Scheme == "" {
-		cfg.Scheme = "http"
-	}
-	if cfg.Host == "" {
-		return fmt.Errorf("host is required for %q", cfg.Alias)
-	}
-	if cfg.Port == "" {
-		cfg.Port = "80"
-	}
-	return nil
-}
-
-func (cfg *ProxyConfig) GetID() string {
-	return fmt.Sprintf("%s-%s-%s-%s-%s", cfg.Alias, cfg.Scheme, cfg.Host, cfg.Port, cfg.Path)
-}

src/go-proxy/route.go

@@ -1,56 +0,0 @@
-package main
-
-import (
-	"fmt"
-)
-
-type Route interface {
-	Start()
-	Stop()
-}
-
-func NewRoute(cfg *ProxyConfig) (Route, error) {
-	if isStreamScheme(cfg.Scheme) {
-		id := cfg.GetID()
-		if streamRoutes.Contains(id) {
-			return nil, fmt.Errorf("duplicated %s stream %s, ignoring", cfg.Scheme, id)
-		}
-		route, err := NewStreamRoute(cfg)
-		if err != nil {
-			return nil, err
-		}
-		streamRoutes.Set(id, route)
-		return route, nil
-	} else {
-		httpRoutes.Ensure(cfg.Alias)
-		route, err := NewHTTPRoute(cfg)
-		if err != nil {
-			return nil, err
-		}
-		httpRoutes.Get(cfg.Alias).Add(cfg.Path, route)
-		return route, nil
-	}
-}
-
-func isValidScheme(s string) bool {
-	for _, v := range ValidSchemes {
-		if v == s {
-			return true
-		}
-	}
-	return false
-}
-
-func isStreamScheme(s string) bool {
-	for _, v := range StreamSchemes {
-		if v == s {
-			return true
-		}
-	}
-	return false
-}
-
-// id    -> target
-type StreamRoutes = SafeMap[string, StreamRoute]
-
-var streamRoutes = NewSafeMap[string, StreamRoute]()

src/go-proxy/server.go

@@ -1,97 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"net/http"
-	"time"
-
-	"github.com/sirupsen/logrus"
-	"golang.org/x/net/context"
-)
-
-type Server struct {
-	Name         string
-	KeyFile      string
-	CertFile     string
-	CertProvider AutoCertProvider
-	http         *http.Server
-	https        *http.Server
-	httpStarted  bool
-	httpsStarted bool
-}
-
-func NewServer(name string, provider AutoCertProvider, httpAddr string, httpHandler http.Handler, httpsAddr string, httpsHandler http.Handler) *Server {
-	if provider != nil {
-		return &Server{
-			Name:         name,
-			CertProvider: provider,
-			http: &http.Server{
-				Addr:    httpAddr,
-				Handler: httpHandler,
-			},
-			https: &http.Server{
-				Addr:    httpsAddr,
-				Handler: httpsHandler,
-				TLSConfig: &tls.Config{
-					GetCertificate: provider.GetCert,
-				},
-			},
-		}
-	}
-	return &Server{
-		Name:     name,
-		KeyFile:  keyFileDefault,
-		CertFile: certFileDefault,
-		http: &http.Server{
-			Addr:    httpAddr,
-			Handler: httpHandler,
-		},
-		https: &http.Server{
-			Addr:    httpsAddr,
-			Handler: httpsHandler,
-		},
-	}
-}
-
-func (s *Server) Start() {
-	if s.http != nil {
-		s.httpStarted = true
-		logrus.Printf("starting http %s server on %s", s.Name, s.http.Addr)
-		go func() {
-			err := s.http.ListenAndServe()
-			s.handleErr("http", err)
-		}()
-	}
-
-	if s.https != nil && (s.CertProvider != nil || utils.fileOK(s.CertFile) && utils.fileOK(s.KeyFile)) {
-		s.httpsStarted = true
-		logrus.Printf("starting https %s server on %s", s.Name, s.https.Addr)
-		go func() {
-			err := s.https.ListenAndServeTLS(s.CertFile, s.KeyFile)
-			s.handleErr("https", err)
-		}()
-	}
-}
-
-func (s *Server) Stop() {
-	ctx, _ := context.WithTimeout(context.Background(), 3*time.Second)
-
-	if s.httpStarted {
-		errHTTP := s.http.Shutdown(ctx)
-		s.handleErr("http", errHTTP)
-	}
-
-	if s.httpsStarted {
-		errHTTPS := s.https.Shutdown(ctx)
-		s.handleErr("https", errHTTPS)
-	}
-}
-
-func (s *Server) handleErr(scheme string, err error) {
-	switch err {
-	case nil, http.ErrServerClosed:
-		return
-	default:
-		logrus.Fatalf("failed to start %s %s server: %v", scheme, s.Name, err)
-	}
-}

src/go-proxy/stream_route.go

@@ -1,181 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/sirupsen/logrus"
-)
-
-type StreamRoute interface {
-	Route
-	ListeningUrl() string
-	TargetUrl() string
-	Logger() logrus.FieldLogger
-
-	closeListeners()
-	closeChannel()
-	unmarkPort()
-	wait()
-}
-
-type StreamRouteBase struct {
-	Alias           string // to show in panel
-	Type            string
-	ListeningScheme string
-	ListeningPort   int
-	TargetScheme    string
-	TargetHost      string
-	TargetPort      int
-
-	id        string
-	wg        sync.WaitGroup
-	stopChann chan struct{}
-	l         logrus.FieldLogger
-}
-
-func newStreamRouteBase(config *ProxyConfig) (*StreamRouteBase, error) {
-	var streamType string = StreamType_TCP
-	var srcPort string
-	var dstPort string
-	var srcScheme string
-	var dstScheme string
-
-	port_split := strings.Split(config.Port, ":")
-	if len(port_split) != 2 {
-		cfgl.Warnf("invalid port %s, assuming it is target port", config.Port)
-		srcPort = "0"
-		dstPort = config.Port
-	} else {
-		srcPort = port_split[0]
-		dstPort = port_split[1]
-	}
-
-	if port, hasName := NamePortMap[dstPort]; hasName {
-		dstPort = port
-	}
-
-	srcPortInt, err := strconv.Atoi(srcPort)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"invalid stream source port %s, ignoring", srcPort,
-		)
-	}
-
-	utils.markPortInUse(srcPortInt)
-
-	dstPortInt, err := strconv.Atoi(dstPort)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"invalid stream target port %s, ignoring", dstPort,
-		)
-	}
-
-	scheme_split := strings.Split(config.Scheme, ":")
-
-	if len(scheme_split) == 2 {
-		srcScheme = scheme_split[0]
-		dstScheme = scheme_split[1]
-	} else {
-		srcScheme = config.Scheme
-		dstScheme = config.Scheme
-	}
-
-	return &StreamRouteBase{
-		Alias:           config.Alias,
-		Type:            streamType,
-		ListeningScheme: srcScheme,
-		ListeningPort:   srcPortInt,
-		TargetScheme:    dstScheme,
-		TargetHost:      config.Host,
-		TargetPort:      dstPortInt,
-
-		id:        config.GetID(),
-		wg:        sync.WaitGroup{},
-		stopChann: make(chan struct{}, 1),
-		l: srlog.WithFields(logrus.Fields{
-			"alias": config.Alias,
-			"src":   fmt.Sprintf("%s://:%d", srcScheme, srcPortInt),
-			"dst":   fmt.Sprintf("%s://%s:%d", dstScheme, config.Host, dstPortInt),
-		}),
-	}, nil
-}
-
-func NewStreamRoute(config *ProxyConfig) (StreamRoute, error) {
-	switch config.Scheme {
-	case StreamType_TCP:
-		return NewTCPRoute(config)
-	case StreamType_UDP:
-		return NewUDPRoute(config)
-	default:
-		return nil, errors.New("unknown stream type")
-	}
-}
-
-func (route *StreamRouteBase) ListeningUrl() string {
-	return fmt.Sprintf("%s:%v", route.ListeningScheme, route.ListeningPort)
-}
-
-func (route *StreamRouteBase) TargetUrl() string {
-	return fmt.Sprintf("%s://%s:%v", route.TargetScheme, route.TargetHost, route.TargetPort)
-}
-
-func (route *StreamRouteBase) Logger() logrus.FieldLogger {
-	return route.l
-}
-
-func (route *StreamRouteBase) setupListen() {
-	if route.ListeningPort == 0 {
-		freePort, err := utils.findUseFreePort(20000)
-		if err != nil {
-			route.l.Error(err)
-			return
-		}
-		route.ListeningPort = freePort
-		route.l.Info("listening on free port ", route.ListeningPort)
-		return
-	}
-	route.l.Info("listening on ", route.ListeningUrl())
-}
-
-func (route *StreamRouteBase) wait() {
-	route.wg.Wait()
-}
-
-func (route *StreamRouteBase) closeChannel() {
-	close(route.stopChann)
-}
-
-func (route *StreamRouteBase) unmarkPort() {
-	utils.unmarkPortInUse(route.ListeningPort)
-}
-
-func stopListening(route StreamRoute) {
-	l := route.Logger()
-	l.Debug("stopping listening")
-
-	// close channel -> wait -> close listeners
-
-	route.closeChannel()
-
-	done := make(chan struct{})
-	
-	go func() {
-		route.wait()
-		close(done)
-		route.unmarkPort()
-	}()
-
-	select {
-	case <-done:
-		l.Info("stopped listening")
-	case <-time.After(StreamStopListenTimeout):
-		l.Error("timed out waiting for connections")
-	}
-
-	route.closeListeners()
-}

src/go-proxy/tcp_route.go

@@ -1,132 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net"
-	"sync"
-	"time"
-)
-
-const tcpDialTimeout = 5 * time.Second
-
-type TCPRoute struct {
-	*StreamRouteBase
-	listener net.Listener
-	connChan chan net.Conn
-}
-
-func NewTCPRoute(config *ProxyConfig) (StreamRoute, error) {
-	base, err := newStreamRouteBase(config)
-	if err != nil {
-		return nil, err
-	}
-	if base.TargetScheme != StreamType_TCP {
-		return nil, fmt.Errorf("tcp to %s not yet supported", base.TargetScheme)
-	}
-	return &TCPRoute{
-		StreamRouteBase: base,
-		listener:        nil,
-		connChan:        make(chan net.Conn),
-	}, nil
-}
-
-func (route *TCPRoute) Start() {
-	route.setupListen()
-	in, err := net.Listen("tcp", fmt.Sprintf(":%v", route.ListeningPort))
-	if err != nil {
-		route.l.Error(err)
-		return
-	}
-	route.listener = in
-	route.wg.Add(2)
-	go route.grAcceptConnections()
-	go route.grHandleConnections()
-}
-
-func (route *TCPRoute) Stop() {
-	stopListening(route)
-	streamRoutes.Delete(route.id)
-}
-
-func (route *TCPRoute) closeListeners() {
-	if route.listener == nil {
-		return
-	}
-	route.listener.Close()
-	route.listener = nil
-}
-
-func (route *TCPRoute) grAcceptConnections() {
-	defer route.wg.Done()
-
-	for {
-		select {
-		case <-route.stopChann:
-			return
-		default:
-			conn, err := route.listener.Accept()
-			if err != nil {
-				route.l.Error(err)
-				continue
-			}
-			route.connChan <- conn
-		}
-	}
-}
-
-func (route *TCPRoute) grHandleConnections() {
-	defer route.wg.Done()
-
-	for {
-		select {
-		case <-route.stopChann:
-			return
-		case conn := <-route.connChan:
-			route.wg.Add(1)
-			go route.grHandleConnection(conn)
-		}
-	}
-}
-
-func (route *TCPRoute) grHandleConnection(clientConn net.Conn) {
-	defer clientConn.Close()
-	defer route.wg.Done()
-
-	ctx, cancel := context.WithTimeout(context.Background(), tcpDialTimeout)
-	defer cancel()
-
-	serverAddr := fmt.Sprintf("%s:%v", route.TargetHost, route.TargetPort)
-	dialer := &net.Dialer{}
-	serverConn, err := dialer.DialContext(ctx, route.TargetScheme, serverAddr)
-	if err != nil {
-		route.l.WithField("stage", "dial").Infof("%v", err)
-		return
-	}
-	route.tcpPipe(clientConn, serverConn)
-}
-
-func (route *TCPRoute) tcpPipe(src net.Conn, dest net.Conn) {
-	close := func() {
-		src.Close()
-		dest.Close()
-	}
-
-	var wg sync.WaitGroup
-	wg.Add(2) // Number of goroutines
-
-	go func() {
-		_, err := io.Copy(src, dest)
-		route.l.Error(err)
-		close()
-		wg.Done()
-	}()
-	go func() {
-		_, err := io.Copy(dest, src)
-		route.l.Error(err)
-		close()
-		wg.Done()
-	}()
-	wg.Wait()
-}

src/go-proxy/udp_route.go

@@ -1,243 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"net"
-	"sync"
-
-	"github.com/sirupsen/logrus"
-)
-
-type UDPRoute struct {
-	*StreamRouteBase
-
-	connMap      map[net.Addr]net.Conn
-	connMapMutex sync.Mutex
-
-	listeningConn *net.UDPConn
-	targetConn    *net.UDPConn
-
-	connChan chan *UDPConn
-}
-
-type UDPConn struct {
-	remoteAddr    net.Addr
-	buffer        []byte
-	bytesReceived []byte
-	nReceived     int
-}
-
-func NewUDPRoute(config *ProxyConfig) (StreamRoute, error) {
-	base, err := newStreamRouteBase(config)
-	if err != nil {
-		return nil, err
-	}
-
-	if base.TargetScheme != StreamType_UDP {
-		return nil, fmt.Errorf("udp to %s not yet supported", base.TargetScheme)
-	}
-
-	return &UDPRoute{
-		StreamRouteBase: base,
-		connMap:         make(map[net.Addr]net.Conn),
-		connChan:        make(chan *UDPConn),
-	}, nil
-}
-
-func (route *UDPRoute) Start() {
-	route.setupListen()
-
-	source, err := net.ListenPacket(route.ListeningScheme, fmt.Sprintf(":%v", route.ListeningPort))
-	if err != nil {
-		route.l.Error(err)
-		return
-	}
-
-	target, err := net.Dial(route.TargetScheme, fmt.Sprintf("%s:%v", route.TargetHost, route.TargetPort))
-	if err != nil {
-		route.l.Error(err)
-		source.Close()
-		return
-	}
-
-	route.listeningConn = source.(*net.UDPConn)
-	route.targetConn = target.(*net.UDPConn)
-
-	route.wg.Add(2)
-	go route.grAcceptConnections()
-	go route.grHandleConnections()
-}
-
-func (route *UDPRoute) Stop() {
-	stopListening(route)
-	streamRoutes.Delete(route.id)
-}
-
-func (route *UDPRoute) closeListeners() {
-	if route.listeningConn != nil {
-		route.listeningConn.Close()
-		route.listeningConn = nil
-	}
-	if route.targetConn != nil {
-		route.targetConn.Close()
-		route.targetConn = nil
-	}
-	for _, conn := range route.connMap {
-		conn.(*net.UDPConn).Close() // TODO: change on non udp target
-	}
-	route.connMap = make(map[net.Addr]net.Conn)
-}
-
-func (route *UDPRoute) grAcceptConnections() {
-	defer route.wg.Done()
-
-	for {
-		select {
-		case <-route.stopChann:
-			return
-		default:
-			conn, err := route.accept()
-			if err != nil {
-				route.l.Error(err)
-				continue
-			}
-			route.connChan <- conn
-		}
-	}
-}
-
-func (route *UDPRoute) grHandleConnections() {
-	defer route.wg.Done()
-
-	for {
-		select {
-		case <-route.stopChann:
-			return
-		case conn := <-route.connChan:
-			go func() {
-				err := route.handleConnection(conn)
-				if err != nil {
-					route.l.Error(err)
-				}
-			}()
-		}
-	}
-}
-
-func (route *UDPRoute) handleConnection(conn *UDPConn) error {
-	var err error
-
-	srcConn, ok := route.connMap[conn.remoteAddr]
-	if !ok {
-		route.connMapMutex.Lock()
-		srcConn, err = net.DialUDP("udp", nil, conn.remoteAddr.(*net.UDPAddr))
-		if err != nil {
-			return err
-		}
-		route.connMap[conn.remoteAddr] = srcConn
-		route.connMapMutex.Unlock()
-	}
-
-	var forwarder func(*UDPConn, net.Conn) error
-
-	if logLevel == logrus.DebugLevel {
-		forwarder = route.forwardReceivedDebug
-	} else {
-		forwarder = route.forwardReceivedReal
-	}
-
-	// initiate connection to target
-	err = forwarder(conn, route.targetConn)
-	if err != nil {
-		return err
-	}
-
-	for {
-		select {
-		case <-route.stopChann:
-			return nil
-		default:
-			// receive from target
-			conn, err = route.readFrom(route.targetConn, conn.buffer)
-			if err != nil {
-				return err
-			}
-			// forward to source
-			err = forwarder(conn, srcConn)
-			if err != nil {
-				return err
-			}
-			// read from source
-			conn, err = route.readFrom(srcConn, conn.buffer)
-			if err != nil {
-				continue
-			}
-			// forward to target
-			err = forwarder(conn, route.targetConn)
-			if err != nil {
-				return err
-			}
-		}
-	}
-}
-
-func (route *UDPRoute) accept() (*UDPConn, error) {
-	in := route.listeningConn
-
-	buffer := make([]byte, udpBufferSize)
-	nRead, srcAddr, err := in.ReadFromUDP(buffer)
-
-	if err != nil {
-		return nil, err
-	}
-
-	if nRead == 0 {
-		return nil, io.ErrShortBuffer
-	}
-
-	return &UDPConn{
-			remoteAddr:    srcAddr,
-			buffer:        buffer,
-			bytesReceived: buffer[:nRead],
-			nReceived:     nRead},
-		nil
-}
-
-func (route *UDPRoute) readFrom(src net.Conn, buffer []byte) (*UDPConn, error) {
-	nRead, err := src.Read(buffer)
-
-	if err != nil {
-		return nil, err
-	}
-
-	if nRead == 0 {
-		return nil, io.ErrShortBuffer
-	}
-
-	return &UDPConn{
-		remoteAddr:    src.RemoteAddr(),
-		buffer:        buffer,
-		bytesReceived: buffer[:nRead],
-		nReceived:     nRead,
-	}, nil
-}
-
-func (route *UDPRoute) forwardReceivedReal(receivedConn *UDPConn, dest net.Conn) error {
-	nWritten, err := dest.Write(receivedConn.bytesReceived)
-
-	if nWritten != receivedConn.nReceived {
-		err = io.ErrShortWrite
-	}
-
-	return err
-}
-
-func (route *UDPRoute) forwardReceivedDebug(receivedConn *UDPConn, dest net.Conn) error {
-	route.l.WithField("size", receivedConn.nReceived).Debugf(
-		"forwarding from %s to %s",
-		receivedConn.remoteAddr.String(),
-		dest.RemoteAddr().String(),
-	)
-	return route.forwardReceivedReal(receivedConn, dest)
-}

src/go-proxy/utils.go

@@ -1,205 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"os"
-	"path"
-	"path/filepath"
-	"reflect"
-	"regexp"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/sirupsen/logrus"
-	xhtml "golang.org/x/net/html"
-)
-
-type Utils struct {
-	portsInUse      map[int]bool
-	portsInUseMutex sync.Mutex
-}
-
-var utils = &Utils{
-	portsInUse:      make(map[int]bool),
-	portsInUseMutex: sync.Mutex{},
-}
-
-func (u *Utils) findUseFreePort(startingPort int) (int, error) {
-	u.portsInUseMutex.Lock()
-	defer u.portsInUseMutex.Unlock()
-	for port := startingPort; port <= startingPort+100 && port <= 65535; port++ {
-		if u.portsInUse[port] {
-			continue
-		}
-		addr := fmt.Sprintf(":%d", port)
-		l, err := net.Listen("tcp", addr)
-		if err == nil {
-			u.portsInUse[port] = true
-			l.Close()
-			return port, nil
-		}
-	}
-	l, err := net.Listen("tcp", ":0")
-	if err == nil {
-		// NOTE: may not be after 20000
-		port := l.Addr().(*net.TCPAddr).Port
-		u.portsInUse[port] = true
-		l.Close()
-		return port, nil
-	}
-	return -1, fmt.Errorf("unable to find free port: %v", err)
-}
-
-func (u *Utils) markPortInUse(port int) {
-	u.portsInUseMutex.Lock()
-	u.portsInUse[port] = true
-	u.portsInUseMutex.Unlock()
-}
-
-func (u *Utils) unmarkPortInUse(port int) {
-	u.portsInUseMutex.Lock()
-	delete(u.portsInUse, port)
-	u.portsInUseMutex.Unlock()
-}
-
-func (*Utils) healthCheckHttp(targetUrl string) error {
-	// try HEAD first
-	// if HEAD is not allowed, try GET
-	resp, err := healthCheckHttpClient.Head(targetUrl)
-	if resp != nil {
-		resp.Body.Close()
-	}
-	if err != nil && resp != nil && resp.StatusCode == http.StatusMethodNotAllowed {
-		_, err = healthCheckHttpClient.Get(targetUrl)
-	}
-	if resp != nil {
-		resp.Body.Close()
-	}
-	return err
-}
-
-func (*Utils) healthCheckStream(scheme, host string) error {
-	conn, err := net.DialTimeout(scheme, host, 5*time.Second)
-	if err != nil {
-		return err
-	}
-	conn.Close()
-	return nil
-}
-
-func (*Utils) snakeToPascal(s string) string {
-	toHyphenCamel := http.CanonicalHeaderKey(strings.ReplaceAll(s, "_", "-"))
-	return strings.ReplaceAll(toHyphenCamel, "-", "")
-}
-
-func tryAppendPathPrefixImpl(pOrig, pAppend string) string {
-	switch {
-	case strings.Contains(pOrig, "://"):
-		return pOrig
-	case pOrig == "", pOrig == "#", pOrig == "/":
-		return pAppend
-	case filepath.IsLocal(pOrig) && !strings.HasPrefix(pOrig, pAppend):
-		return path.Join(pAppend, pOrig)
-	default:
-		return pOrig
-	}
-}
-
-var tryAppendPathPrefix func(string, string) string
-var _ = func() int {
-	if logLevel == logrus.DebugLevel {
-		tryAppendPathPrefix = func(s1, s2 string) string {
-			replaced := tryAppendPathPrefixImpl(s1, s2)
-			return replaced
-		}
-	} else {
-		tryAppendPathPrefix = tryAppendPathPrefixImpl
-	}
-	return 1
-}()
-
-func htmlNodesSubPath(n *xhtml.Node, p string) {
-	if n.Type == xhtml.ElementNode {
-		for i, attr := range n.Attr {
-			switch attr.Key {
-			case "src", "href", "action": // img, script, link, form etc.
-				n.Attr[i].Val = tryAppendPathPrefix(attr.Val, p)
-			}
-		}
-	}
-
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		htmlNodesSubPath(c, p)
-	}
-}
-
-func (*Utils) respHTMLSubPath(r *http.Response, p string) error {
-	// remove all path prefix from relative path in script, img, a, ...
-	doc, err := xhtml.Parse(r.Body)
-
-	if err != nil {
-		return err
-	}
-
-	if p[0] == '/' {
-		p = p[1:]
-	}
-	htmlNodesSubPath(doc, p)
-
-	var buf bytes.Buffer
-	err = xhtml.Render(&buf, doc)
-
-	if err != nil {
-		return err
-	}
-
-	r.Body = io.NopCloser(strings.NewReader(buf.String()))
-
-	return nil
-}
-
-func (*Utils) respJSSubPath(r *http.Response, p string) error {
-	var buf bytes.Buffer
-
-	_, err := buf.ReadFrom(r.Body)
-	if err != nil {
-		return err
-	}
-
-	if p[0] == '/' {
-		p = p[1:]
-	}
-
-	js := buf.String()
-
-	re := regexp.MustCompile(`fetch\(["'].+["']\)`)
-	replace := func(match string) string {
-		match = match[7 : len(match)-2]
-		replaced := tryAppendPathPrefix(match, p)
-		return fmt.Sprintf(`fetch(%q)`, replaced)
-	}
-	js = re.ReplaceAllStringFunc(js, replace)
-
-	r.Body = io.NopCloser(strings.NewReader(js))
-	return nil
-}
-
-func (*Utils) fileOK(path string) bool {
-	_, err := os.Stat(path)
-	return err == nil
-}
-
-func SetFieldFromSnake[T interface{}, VT interface{}](obj *T, field string, value VT) error {
-	field = utils.snakeToPascal(field)
-	prop := reflect.ValueOf(obj).Elem().FieldByName(field)
-	if prop.Kind() == 0 {
-		return fmt.Errorf("unknown field %s", field)
-	}
-	prop.Set(reflect.ValueOf(value))
-	return nil
-}

src/go-proxy/watcher.go

@@ -1,219 +0,0 @@
-package main
-
-import (
-	"path"
-	"sync"
-	"time"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/events"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/client"
-	"github.com/fsnotify/fsnotify"
-	"github.com/sirupsen/logrus"
-
-	"golang.org/x/net/context"
-)
-
-type Watcher interface {
-	Start()
-	Stop()
-	Dispose()
-}
-
-type watcherBase struct {
-	name     string // for log / error output
-	kind     string // for log / error output
-	onChange func()
-	l        logrus.FieldLogger
-}
-
-type fileWatcher struct {
-	*watcherBase
-	path     string
-	onDelete func()
-}
-
-type dockerWatcher struct {
-	*watcherBase
-	client *client.Client
-	stopCh chan struct{}
-	wg     sync.WaitGroup
-}
-
-func newWatcher(kind string, name string, onChange func()) *watcherBase {
-	return &watcherBase{
-		kind:     kind,
-		name:     name,
-		onChange: onChange,
-		l:        wlog.WithFields(logrus.Fields{"kind": kind, "name": name}),
-	}
-}
-func NewFileWatcher(p string, onChange func(), onDelete func()) Watcher {
-	return &fileWatcher{
-		watcherBase: newWatcher("File", path.Base(p), onChange),
-		path:        p,
-		onDelete:    onDelete,
-	}
-}
-
-func NewDockerWatcher(c *client.Client, onChange func()) Watcher {
-	return &dockerWatcher{
-		watcherBase: newWatcher("Docker", c.DaemonHost(), onChange),
-		client:      c,
-		stopCh:      make(chan struct{}, 1),
-	}
-}
-
-func (w *fileWatcher) Start() {
-	if fsWatcher == nil {
-		return
-	}
-	err := fsWatcher.Add(w.path)
-	if err != nil {
-		w.l.Error("failed to start: ", err)
-		return
-	}
-	fileWatchMap.Set(w.path, w)
-}
-
-func (w *fileWatcher) Stop() {
-	if fsWatcher == nil {
-		return
-	}
-	fileWatchMap.Delete(w.path)
-	err := fsWatcher.Remove(w.path)
-	if err != nil {
-		w.l.WithField("action", "stop").Error(err)
-	}
-}
-
-func (w *fileWatcher) Dispose() {
-	w.Stop()
-}
-
-func (w *dockerWatcher) Start() {
-	dockerWatchMap.Set(w.name, w)
-	w.wg.Add(1)
-	go w.watch()
-}
-
-func (w *dockerWatcher) Stop() {
-	if w.stopCh == nil {
-		return
-	}
-	close(w.stopCh)
-	w.wg.Wait()
-	w.stopCh = nil
-	dockerWatchMap.Delete(w.name)
-}
-
-func (w *dockerWatcher) Dispose() {
-	w.Stop()
-	w.client.Close()
-}
-
-func InitFSWatcher() {
-	w, err := fsnotify.NewWatcher()
-	if err != nil {
-		wlog.Errorf("unable to create file watcher: %v", err)
-		return
-	}
-	fsWatcher = w
-	fsWatcherWg.Add(1)
-	go watchFiles()
-}
-
-func InitDockerWatcher() {
-	// stop all docker client on watcher stop
-	go func() {
-		defer dockerWatcherWg.Done()
-		<-dockerWatcherStop
-		ParallelForEachValue(
-			dockerWatchMap.Iterator(),
-			(*dockerWatcher).Dispose,
-		)
-	}()
-}
-
-func StopFSWatcher() {
-	close(fsWatcherStop)
-	fsWatcherWg.Wait()
-}
-
-func StopDockerWatcher() {
-	close(dockerWatcherStop)
-	dockerWatcherWg.Wait()
-}
-
-func watchFiles() {
-	defer fsWatcher.Close()
-	defer fsWatcherWg.Done()
-	for {
-		select {
-		case <-fsWatcherStop:
-			return
-		case event, ok := <-fsWatcher.Events:
-			if !ok {
-				wlog.Error("file watcher channel closed")
-				return
-			}
-			w, ok := fileWatchMap.UnsafeGet(event.Name)
-			if !ok {
-				wlog.Errorf("watcher for %s not found", event.Name)
-			}
-			switch {
-			case event.Has(fsnotify.Write):
-				w.l.Info("file changed")
-				go w.onChange()
-			case event.Has(fsnotify.Remove), event.Has(fsnotify.Rename):
-				w.l.Info("file renamed / deleted")
-				go w.onDelete()
-			}
-		case err := <-fsWatcher.Errors:
-			wlog.Error(err)
-		}
-	}
-}
-
-func (w *dockerWatcher) watch() {
-	defer w.wg.Done()
-
-	filter := filters.NewArgs(
-		filters.Arg("type", "container"),
-		filters.Arg("event", "start"),
-		filters.Arg("event", "die"), // 'stop' already triggering 'die'
-	)
-	listen := func() (<-chan events.Message, <-chan error) {
-		return w.client.Events(context.Background(), types.EventsOptions{Filters: filter})
-	}
-	msgChan, errChan := listen()
-
-	for {
-		select {
-		case <-w.stopCh:
-			return
-		case msg := <-msgChan:
-			w.l.Infof("container %s %s", msg.Actor.Attributes["name"], msg.Action)
-			go w.onChange()
-		case err := <-errChan:
-			w.l.Errorf("%s, retrying in 1s", err)
-			time.Sleep(1 * time.Second)
-			msgChan, errChan = listen()
-		}
-	}
-}
-
-var fsWatcher *fsnotify.Watcher
-var (
-	fileWatchMap   = NewSafeMap[string, *fileWatcher]()
-	dockerWatchMap = NewSafeMap[string, *dockerWatcher]()
-)
-var (
-	fsWatcherStop     = make(chan struct{}, 1)
-	dockerWatcherStop = make(chan struct{}, 1)
-)
-var (
-	fsWatcherWg     sync.WaitGroup
-	dockerWatcherWg sync.WaitGroup
-)

src/go.mod

@@ -0,0 +1,56 @@
+module github.com/yusing/go-proxy
+
+go 1.22.0
+
+require (
+	github.com/docker/cli v27.3.1+incompatible
+	github.com/docker/docker v27.3.1+incompatible
+	github.com/fsnotify/fsnotify v1.7.0
+	github.com/go-acme/lego/v4 v4.18.0
+	github.com/puzpuzpuz/xsync/v3 v3.4.0
+	github.com/santhosh-tekuri/jsonschema v1.2.4
+	github.com/sirupsen/logrus v1.9.3
+	golang.org/x/net v0.29.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
+	github.com/cloudflare/cloudflare-go v0.104.0 // indirect
+	github.com/containerd/log v0.1.0 // indirect
+	github.com/distribution/reference v0.6.0 // indirect
+	github.com/docker/go-connections v0.5.0 // indirect
+	github.com/docker/go-units v0.5.0 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/go-jose/go-jose/v4 v4.0.4 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/goccy/go-json v0.10.3 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/miekg/dns v1.1.62 // indirect
+	github.com/moby/docker-image-spec v1.3.1 // indirect
+	github.com/moby/term v0.5.0 // indirect
+	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.1.0 // indirect
+	github.com/ovh/go-ovh v1.6.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.55.0 // indirect
+	go.opentelemetry.io/otel v1.30.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0 // indirect
+	go.opentelemetry.io/otel/metric v1.30.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.24.0 // indirect
+	go.opentelemetry.io/otel/trace v1.30.0 // indirect
+	golang.org/x/crypto v0.27.0 // indirect
+	golang.org/x/mod v0.21.0 // indirect
+	golang.org/x/oauth2 v0.23.0 // indirect
+	golang.org/x/sync v0.8.0 // indirect
+	golang.org/x/sys v0.25.0 // indirect
+	golang.org/x/text v0.18.0 // indirect
+	golang.org/x/time v0.6.0 // indirect
+	golang.org/x/tools v0.25.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gotest.tools/v3 v3.5.1 // indirect
+)

src/go.sum

@@ -1,51 +1,43 @@
 github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8=
 github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
-github.com/Microsoft/go-winio v0.4.14 h1:+hMXMk01us9KgxGb7ftKQt2Xpf5hH/yky+TDA+qxleU=
-github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA=
-github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
-github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
-github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
-github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
-github.com/cloudflare/cloudflare-go v0.86.0 h1:jEKN5VHNYNYtfDL2lUFLTRo+nOVNPFxpXTstVx0rqHI=
-github.com/cloudflare/cloudflare-go v0.86.0/go.mod h1:wYW/5UP02TUfBToa/yKbQHV+r6h1NnJ1Je7XjuGM4Jw=
-github.com/cloudflare/cloudflare-go v0.91.0 h1:L7IR+86qrZuEMSjGFg4cwRwtHqC8uCPmMUkP7BD4CPw=
-github.com/cloudflare/cloudflare-go v0.91.0/go.mod h1:nUqvBUUDRxNzsDSQjbqUNWHEIYAoUlgRmcAzMKlFdKs=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
+github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
+github.com/cloudflare/cloudflare-go v0.104.0 h1:R/lB0dZupaZbOgibAH/BRrkFbZ6Acn/WsKg2iX2xXuY=
+github.com/cloudflare/cloudflare-go v0.104.0/go.mod h1:pfUQ4PIG4ISI0/Mmc21Bp86UnFU0ktmPf3iTgbSL+cM=
 github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
 github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/distribution/reference v0.5.0 h1:/FUIFXtfc/x2gpa5/VGfiGLuOIdYa1t65IKK2OFGvA0=
-github.com/distribution/reference v0.5.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
-github.com/docker/cli v26.0.0+incompatible h1:90BKrx1a1HKYpSnnBFR6AgDq/FqkHxwlUyzJVPxD30I=
-github.com/docker/cli v26.0.0+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
-github.com/docker/docker v26.0.0+incompatible h1:Ng2qi+gdKADUa/VM+6b6YaY2nlZhk/lVJiKR/2bMudU=
-github.com/docker/docker v26.0.0+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
+github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
+github.com/docker/cli v27.3.1+incompatible h1:qEGdFBF3Xu6SCvCYhc7CzaQTlBmqDuzxPDpigSyeKQQ=
+github.com/docker/cli v27.3.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/docker v27.3.1+incompatible h1:KttF0XoteNTicmUtBO0L2tP+J7FGRFTjaEF4k6WdhfI=
+github.com/docker/docker v27.3.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
 github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
 github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
-github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
 github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
-github.com/go-acme/lego/v4 v4.16.1 h1:JxZ93s4KG0jL27rZ30UsIgxap6VGzKuREsSkkyzeoCQ=
-github.com/go-acme/lego/v4 v4.16.1/go.mod h1:AVvwdPned/IWpD/ihHhMsKnveF7HHYAz/CmtXi7OZoE=
-github.com/go-jose/go-jose/v4 v4.0.1 h1:QVEPDE3OluqXBQZDcnNvQrInro2h0e4eqNbnZSWqS6U=
-github.com/go-jose/go-jose/v4 v4.0.1/go.mod h1:WVf9LFMHh/QVrmqrOfqun0C45tMe3RoiKJMPvgWwLfY=
+github.com/go-acme/lego/v4 v4.18.0 h1:2hH8KcdRBSb+p5o9VZIm61GAOXYALgILUCSs1Q+OYsk=
+github.com/go-acme/lego/v4 v4.18.0/go.mod h1:Blkg3izvXpl3zxk7WKngIuwR2I/hvYVP3vRnvgBp7m8=
+github.com/go-jose/go-jose/v4 v4.0.4 h1:VsjPI33J0SB9vQM6PLmNjoHqMQNGPiZ0rHL7Ni7Q6/E=
+github.com/go-jose/go-jose/v4 v4.0.4/go.mod h1:NKb5HO1EZccyMpiZNbdUw/14tiXNyUJh188dfnMCAfc=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
-github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
-github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
+github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
@@ -53,26 +45,18 @@ github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD
 github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 h1:Wqo399gCIufwto+VfwCSvsnfGpF/w5E9CNxSwbpD6No=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0/go.mod h1:qmOFXW2epJhM0qSnUUYpldc7gVz2KMQwJ/QYCDIa7XU=
-github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
-github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
-github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
-github.com/hashicorp/go-hclog v1.2.0 h1:La19f8d7WIlm4ogzNHB0JGqs5AUDAZ2UfCY4sJXcJdM=
-github.com/hashicorp/go-hclog v1.2.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
-github.com/hashicorp/go-retryablehttp v0.7.5 h1:bJj+Pj19UZMIweq/iie+1u5YCdGrnxCT9yvm0e+Nd5M=
-github.com/hashicorp/go-retryablehttp v0.7.5/go.mod h1:Jy/gPYAdjqffZ/yFGCFV2doI5wjtH1ewM9u8iYVjtX8=
+github.com/jarcoal/httpmock v1.3.0 h1:2RJ8GP0IIaWwcC9Fp2BmVi8Kog3v2Hn7VXM3fTd+nuc=
+github.com/jarcoal/httpmock v1.3.0/go.mod h1:3yb8rc4BI7TCBhFY8ng0gjuLKJNquuDNiPaZjnENuYg=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
 github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
-github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/miekg/dns v1.1.58 h1:ca2Hdkz+cDg/7eNF6V56jjzuZ4aCAE+DbVkILdQWG/4=
-github.com/miekg/dns v1.1.58/go.mod h1:Ypv+3b/KadlvW9vJfXOTf300O4UqaHFzFCuHz+rPkBY=
+github.com/maxatome/go-testdeep v1.12.0 h1:Ql7Go8Tg0C1D/uMMX59LAoYK7LffeJQ6X2T04nTH68g=
+github.com/maxatome/go-testdeep v1.12.0/go.mod h1:lPZc/HAcJMP92l7yI6TRz1aZN5URwUBUAfUNvrclaNM=
+github.com/miekg/dns v1.1.62 h1:cN8OuEF1/x5Rq6Np+h1epln8OiyPWV+lROx9LxcGgIQ=
+github.com/miekg/dns v1.1.62/go.mod h1:mvDlcItzm+br7MToIKqkglaGhlFMHJ9DTNNWONWXbNQ=
 github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
 github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
 github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
@@ -83,101 +67,100 @@ github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
 github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/ovh/go-ovh v1.6.0 h1:ixLOwxQdzYDx296sXcgS35TOPEahJkpjMGtzPadCjQI=
+github.com/ovh/go-ovh v1.6.0/go.mod h1:cTVDnl94z4tl8pP1uZ/8jlVxntjSIf09bNcQ5TJSC7c=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/puzpuzpuz/xsync/v3 v3.4.0 h1:DuVBAdXuGFHv8adVXjWWZ63pJq+NRXOWVXlKDBZ+mJ4=
+github.com/puzpuzpuz/xsync/v3 v3.4.0/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
 github.com/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg=
 github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
-github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
+github.com/santhosh-tekuri/jsonschema v1.2.4 h1:hNhW8e7t+H1vgY+1QeEQpveR6D4+OwKPXCfD2aieJis=
+github.com/santhosh-tekuri/jsonschema v1.2.4/go.mod h1:TEAUOeZSmIxTTuHatJzrvARHiuO9LYd+cIxzgEHCQI4=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw=
-go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
-go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.55.0 h1:ZIg3ZT/aQ7AfKqdwp7ECpOK6vHqquXXuyTjIO8ZdmPs=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.55.0/go.mod h1:DQAwmETtZV00skUwgD6+0U89g80NKsJE3DCKeLLPQMI=
+go.opentelemetry.io/otel v1.30.0 h1:F2t8sK4qf1fAmY9ua4ohFS/K+FUuOPemHUIXHtktrts=
+go.opentelemetry.io/otel v1.30.0/go.mod h1:tFw4Br9b7fOS+uEao81PJjVMjW/5fvNCbpsDIXqP0pc=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.24.0 h1:t6wl9SPayj+c7lEIFgm4ooDBZVb01IhLB4InpomhRw8=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.24.0/go.mod h1:iSDOcsnSA5INXzZtwaBPrKp/lWu/V14Dd+llD0oI2EA=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0 h1:Xw8U6u2f8DK2XAkGRFV7BBLENgnTGX9i4rQRxJf+/vs=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0/go.mod h1:6KW1Fm6R/s6Z3PGXwSJN2K4eT6wQB3vXX6CVnYX9NmM=
-go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
-go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco=
+go.opentelemetry.io/otel/metric v1.30.0 h1:4xNulvn9gjzo4hjg+wzIKG7iNFEaBMX00Qd4QIZs7+w=
+go.opentelemetry.io/otel/metric v1.30.0/go.mod h1:aXTfST94tswhWEb+5QjlSqG+cZlmyXy/u8jFpor3WqQ=
 go.opentelemetry.io/otel/sdk v1.24.0 h1:YMPPDNymmQN3ZgczicBY3B6sf9n62Dlj9pWD3ucgoDw=
 go.opentelemetry.io/otel/sdk v1.24.0/go.mod h1:KVrIYw6tEubO9E96HQpcmpTKDVn9gdv35HoYiQWGDFg=
-go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
-go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
+go.opentelemetry.io/otel/trace v1.30.0 h1:7UBkkYzeg3C7kQX8VAidWh2biiQbtAKjyIML8dQ9wmc=
+go.opentelemetry.io/otel/trace v1.30.0/go.mod h1:5EyKqTzzmyqB9bwtCCq6pDLktPK6fmGf/Dph+8VI02o=
 go.opentelemetry.io/proto/otlp v1.1.0 h1:2Di21piLrCqJ3U3eXGCTPHE9R8Nh+0uglSnOyxikMeI=
 go.opentelemetry.io/proto/otlp v1.1.0/go.mod h1:GpBHCBWiqvVLDqmHZsoMM3C5ySeKTC7ej/RNTae6MdY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
-golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A=
+golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0=
-golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.16.0 h1:QX4fJ0Rr5cPQCF7O9lh9Se4pmwfwskqZfq5moyldzic=
-golang.org/x/mod v0.16.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.21.0 h1:vvrHzRwRfVKSiLrG+d4FMl/Qi4ukBCE6kZlTUkDYRT0=
+golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.22.0 h1:9sGLhx7iRIHEiX0oAJ3MRZMUCElJgy7Br1nO+AMN3Tc=
-golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo=
+golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0=
+golang.org/x/oauth2 v0.23.0 h1:PbgcYx2W7i4LvjJWEbf0ngHV6qJYr86PkAV3bXdLEbs=
+golang.org/x/oauth2 v0.23.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
-golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
+golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
-golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
+golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U=
+golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc=
-golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps=
-golang.org/x/tools v0.19.0 h1:tfGCXNR1OsFG+sVdLAitlpjAvD/I6dHDKnYrpEZUHkw=
-golang.org/x/tools v0.19.0/go.mod h1:qoJWxmGSIBmAeriMx19ogtrEPrGtDbPK634QFIcLAhc=
+golang.org/x/tools v0.25.0 h1:oFU9pkj/iJgs+0DT+VMHrx+oBKs/LJMV+Uvg78sl+fE=
+golang.org/x/tools v0.25.0/go.mod h1:/vtpO8WL1N9cQC3FN5zPqb//fRXskFHbLKk4OW1Q7rg=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc h1:8DyZCyvI8mE1IdLy/60bS+52xfymkE72wv1asokgtao=
-google.golang.org/genproto/googleapis/api v0.0.0-20240102182953-50ed04b92917 h1:rcS6EyEaoCO52hQDupoSfrxI3R6C2Tq741is7X8OvnM=
-google.golang.org/genproto/googleapis/api v0.0.0-20240102182953-50ed04b92917/go.mod h1:CmlNWB9lSezaYELKS5Ym1r44VrrbPUa7JTvw+6MbpJ0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240102182953-50ed04b92917 h1:6G8oQ016D88m1xAKljMlBOOGWDZkes4kMhgGFlf8WcQ=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240102182953-50ed04b92917/go.mod h1:xtjpI3tXFPP051KaWnhvxkiubL/6dJ18vLVf7q2pTOU=
-google.golang.org/grpc v1.61.1 h1:kLAiWrZs7YeDM6MumDe7m3y4aM6wacLzM1Y/wiLP9XY=
-google.golang.org/grpc v1.61.1/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs=
-google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
-google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de h1:F6qOa9AZTYJXOUEr4jDysRDLrm4PHePlge4v4TGAlxY=
+google.golang.org/genproto/googleapis/api v0.0.0-20240311132316-a219d84964c2 h1:rIo7ocm2roD9DcFIX67Ym8icoGCKSARAiPljFhh5suQ=
+google.golang.org/genproto/googleapis/api v0.0.0-20240311132316-a219d84964c2/go.mod h1:O1cOfN1Cy6QEYr7VxtjOyP5AdAuR0aJ/MYZaaof623Y=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 h1:NnYq6UN9ReLM9/Y01KWNOWyI5xQ9kbIms5GGJVwS/Yc=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY=
+google.golang.org/grpc v1.63.1 h1:pNClQmvdlyNUiwFETOux/PYqfhmA7BrswEdGRnib1fA=
+google.golang.org/grpc v1.63.1/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDomNkRA=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

src/main.go

@@ -0,0 +1,190 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"runtime"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	"github.com/yusing/go-proxy/api"
+	apiUtils "github.com/yusing/go-proxy/api/v1/utils"
+	"github.com/yusing/go-proxy/common"
+	"github.com/yusing/go-proxy/config"
+	"github.com/yusing/go-proxy/docker"
+	"github.com/yusing/go-proxy/docker/idlewatcher"
+	E "github.com/yusing/go-proxy/error"
+	R "github.com/yusing/go-proxy/route"
+	"github.com/yusing/go-proxy/server"
+	F "github.com/yusing/go-proxy/utils/functional"
+)
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	args := common.GetArgs()
+	l := logrus.WithField("module", "main")
+
+	if common.IsDebug {
+		logrus.SetLevel(logrus.DebugLevel)
+	}
+
+	logrus.SetFormatter(&logrus.TextFormatter{
+		DisableSorting:         true,
+		DisableLevelTruncation: true,
+		FullTimestamp:          true,
+		ForceColors:            true,
+		TimestampFormat:        "01-02 15:04:05",
+	})
+
+	if args.Command == common.CommandReload {
+		if err := apiUtils.ReloadServer(); err.HasError() {
+			l.Fatal(err)
+		}
+		return
+	}
+
+	onShutdown := F.NewSlice[func()]()
+
+	// exit if only validate config
+	if args.Command == common.CommandValidate {
+		data, err := os.ReadFile(common.ConfigPath)
+		if err == nil {
+			err = config.Validate(data).Error()
+		}
+		if err != nil {
+			l.Fatal("config error: ", err)
+		}
+		l.Printf("config OK")
+		return
+	}
+
+	cfg, err := config.Load()
+	if err.IsFatal() {
+		l.Fatal(err)
+	}
+
+	if args.Command == common.CommandListConfigs {
+		printJSON(cfg.Value())
+		return
+	}
+
+	cfg.StartProxyProviders()
+
+	if args.Command == common.CommandListRoutes {
+		printJSON(cfg.RoutesByAlias())
+		return
+	}
+
+	if args.Command == common.CommandDebugListEntries {
+		printJSON(cfg.DumpEntries())
+		return
+	}
+
+	if err.HasError() {
+		l.Warn(err)
+	}
+
+	cfg.WatchChanges()
+
+	onShutdown.Add(docker.CloseAllClients)
+	onShutdown.Add(cfg.Dispose)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, syscall.SIGINT)
+	signal.Notify(sig, syscall.SIGTERM)
+	signal.Notify(sig, syscall.SIGHUP)
+
+	autocert := cfg.GetAutoCertProvider()
+
+	if autocert != nil {
+		if err = autocert.LoadCert(); err.HasError() {
+			if !err.Is(os.ErrNotExist) { // ignore if cert doesn't exist
+				l.Error(err)
+			}
+			l.Debug("obtaining cert due to error loading cert")
+			if err = autocert.ObtainCert(); err.HasError() {
+				l.Warn(err)
+			}
+		}
+
+		if err.NoError() {
+			ctx, certRenewalCancel := context.WithCancel(context.Background())
+			go autocert.ScheduleRenewal(ctx)
+			onShutdown.Add(certRenewalCancel)
+		}
+
+		for _, expiry := range autocert.GetExpiries() {
+			l.Infof("certificate expire on %s", expiry)
+			break
+		}
+	} else {
+		l.Info("autocert not configured")
+	}
+
+	proxyServer := server.InitProxyServer(server.Options{
+		Name:            "proxy",
+		CertProvider:    autocert,
+		HTTPPort:        common.ProxyHTTPPort,
+		HTTPSPort:       common.ProxyHTTPSPort,
+		Handler:         http.HandlerFunc(R.ProxyHandler),
+		RedirectToHTTPS: cfg.Value().RedirectToHTTPS,
+	})
+	apiServer := server.InitAPIServer(server.Options{
+		Name:            "api",
+		CertProvider:    autocert,
+		HTTPPort:        common.APIHTTPPort,
+		Handler:         api.NewHandler(cfg),
+		RedirectToHTTPS: cfg.Value().RedirectToHTTPS,
+	})
+
+	proxyServer.Start()
+	apiServer.Start()
+	onShutdown.Add(proxyServer.Stop)
+	onShutdown.Add(apiServer.Stop)
+
+	go idlewatcher.Start()
+	onShutdown.Add(idlewatcher.Stop)
+
+	// wait for signal
+	<-sig
+
+	// grafully shutdown
+	logrus.Info("shutting down")
+	done := make(chan struct{}, 1)
+
+	var wg sync.WaitGroup
+	wg.Add(onShutdown.Size())
+	onShutdown.ForEach(func(f func()) {
+		go func() {
+			f()
+			wg.Done()
+		}()
+	})
+	go func() {
+		wg.Wait()
+		close(done)
+	}()
+
+	select {
+	case <-done:
+		logrus.Info("shutdown complete")
+	case <-time.After(time.Duration(cfg.Value().TimeoutShutdown) * time.Second):
+		logrus.Info("timeout waiting for shutdown")
+	}
+}
+
+func printJSON(obj any) {
+	j, err := E.Check(json.Marshal(obj))
+	if err.HasError() {
+		logrus.Fatal(err)
+	}
+	rawLogger := log.New(os.Stdout, "", 0)
+	rawLogger.Printf("%s", j) // raw output for convenience using "jq"
+}

src/models/autocert_config.go

@@ -0,0 +1,13 @@
+package model
+
+type (
+	AutoCertConfig struct {
+		Email    string              `json:"email"`
+		Domains  []string            `yaml:",flow" json:"domains"`
+		CertPath string              `yaml:"cert_path" json:"cert_path"`
+		KeyPath  string              `yaml:"key_path" json:"key_path"`
+		Provider string              `json:"provider"`
+		Options  AutocertProviderOpt `yaml:",flow" json:"options"`
+	}
+	AutocertProviderOpt map[string]any
+)

src/models/config.go

@@ -0,0 +1,16 @@
+package model
+
+type Config struct {
+	Providers       ProxyProviders `yaml:",flow" json:"providers"`
+	AutoCert        AutoCertConfig `yaml:",flow" json:"autocert"`
+	TimeoutShutdown int            `yaml:"timeout_shutdown" json:"timeout_shutdown"`
+	RedirectToHTTPS bool           `yaml:"redirect_to_https" json:"redirect_to_https"`
+}
+
+func DefaultConfig() *Config {
+	return &Config{
+		Providers:       ProxyProviders{},
+		TimeoutShutdown: 3,
+		RedirectToHTTPS: true,
+	}
+}

src/models/proxy_entry.go

@@ -0,0 +1,88 @@
+package model
+
+import (
+	"strconv"
+	"strings"
+
+	. "github.com/yusing/go-proxy/common"
+	D "github.com/yusing/go-proxy/docker"
+	F "github.com/yusing/go-proxy/utils/functional"
+)
+
+type (
+	ProxyEntry struct { // raw entry object before validation
+		Alias        string            `yaml:"-" json:"-"`
+		Scheme       string            `yaml:"scheme" json:"scheme"`
+		Host         string            `yaml:"host" json:"host"`
+		Port         string            `yaml:"port" json:"port"`
+		NoTLSVerify  bool              `yaml:"no_tls_verify" json:"no_tls_verify"` // https proxy only
+		PathPatterns []string          `yaml:"path_patterns" json:"path_patterns"` // http(s) proxy only
+		SetHeaders   map[string]string `yaml:"set_headers" json:"set_headers"`     // http(s) proxy only
+		HideHeaders  []string          `yaml:"hide_headers" json:"hide_headers"`   // http(s) proxy only
+
+		/* Docker only */
+		*D.ProxyProperties `yaml:"-" json:"proxy_properties"`
+	}
+
+	ProxyEntries = F.Map[string, *ProxyEntry]
+)
+
+var NewProxyEntries = F.NewMapOf[string, *ProxyEntry]
+
+func (e *ProxyEntry) SetDefaults() {
+	if e.ProxyProperties == nil {
+		e.ProxyProperties = &D.ProxyProperties{}
+	}
+
+	if e.Scheme == "" {
+		switch {
+		case strings.ContainsRune(e.Port, ':'):
+			e.Scheme = "tcp"
+		case e.ProxyProperties != nil:
+			if _, ok := ServiceNamePortMapTCP[e.ImageName]; ok {
+				e.Scheme = "tcp"
+			}
+		}
+	}
+
+	if e.Scheme == "" {
+		switch e.Port {
+		case "443", "8443":
+			e.Scheme = "https"
+		default:
+			e.Scheme = "http"
+		}
+	}
+	if e.Host == "" {
+		e.Host = "localhost"
+	}
+	if e.Port == "" {
+		e.Port = e.FirstPort
+	}
+	if e.Port == "" {
+		if port, ok := ServiceNamePortMapTCP[e.Port]; ok {
+			e.Port = strconv.Itoa(port)
+		} else if port, ok := ImageNamePortMapHTTP[e.Port]; ok {
+			e.Port = strconv.Itoa(port)
+		} else {
+			switch e.Scheme {
+			case "http":
+				e.Port = "80"
+			case "https":
+				e.Port = "443"
+			}
+		}
+	}
+	if e.IdleTimeout == "" {
+		e.IdleTimeout = IdleTimeoutDefault
+	}
+	if e.WakeTimeout == "" {
+		e.WakeTimeout = WakeTimeoutDefault
+	}
+	if e.StopTimeout == "" {
+		e.StopTimeout = StopTimeoutDefault
+	}
+	if e.StopMethod == "" {
+		e.StopMethod = StopMethodDefault
+	}
+}

src/models/proxy_providers.go

@@ -0,0 +1,6 @@
+package model
+
+type ProxyProviders struct {
+	Files  []string          `yaml:"include" json:"include"` // docker, file
+	Docker map[string]string `yaml:"docker" json:"docker"`
+}

src/proxy/constants.go

@@ -0,0 +1,16 @@
+package proxy
+
+const (
+	StreamType_UDP string = "udp"
+	StreamType_TCP string = "tcp"
+	// StreamType_UDP_TCP Scheme = "udp-tcp"
+	// StreamType_TCP_UDP Scheme = "tcp-udp"
+	// StreamType_TLS Scheme = "tls"
+)
+
+var (
+	// TODO: support "tcp-udp", "udp-tcp", etc.
+	StreamSchemes = []string{StreamType_TCP, StreamType_UDP}
+	HTTPSchemes   = []string{"http", "https"}
+	ValidSchemes  = append(StreamSchemes, HTTPSchemes...)
+)

src/proxy/entry.go

@@ -0,0 +1,144 @@
+package proxy
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+
+	E "github.com/yusing/go-proxy/error"
+	M "github.com/yusing/go-proxy/models"
+	T "github.com/yusing/go-proxy/proxy/fields"
+)
+
+type (
+	ReverseProxyEntry struct { // real model after validation
+		Alias        T.Alias
+		Scheme       T.Scheme
+		URL          *url.URL
+		NoTLSVerify  bool
+		PathPatterns T.PathPatterns
+		SetHeaders   http.Header
+		HideHeaders  []string
+
+		/* Docker only */
+		IdleTimeout      time.Duration
+		WakeTimeout      time.Duration
+		StopMethod       T.StopMethod
+		StopTimeout      int
+		StopSignal       T.Signal
+		DockerHost       string
+		ContainerName    string
+		ContainerRunning bool
+	}
+	StreamEntry struct {
+		Alias  T.Alias        `json:"alias"`
+		Scheme T.StreamScheme `json:"scheme"`
+		Host   T.Host         `json:"host"`
+		Port   T.StreamPort   `json:"port"`
+	}
+)
+
+func (rp *ReverseProxyEntry) UseIdleWatcher() bool {
+	return rp.IdleTimeout > 0 && rp.DockerHost != ""
+}
+
+func ValidateEntry(m *M.ProxyEntry) (any, E.NestedError) {
+	m.SetDefaults()
+	scheme, err := T.NewScheme(m.Scheme)
+	if err.HasError() {
+		return nil, err
+	}
+
+	var entry any
+	e := E.NewBuilder("error validating proxy entry")
+	if scheme.IsStream() {
+		entry = validateStreamEntry(m, e)
+	} else {
+		entry = validateRPEntry(m, scheme, e)
+	}
+	if err := e.Build(); err.HasError() {
+		return nil, err
+	}
+	return entry, nil
+}
+
+func validateRPEntry(m *M.ProxyEntry, s T.Scheme, b E.Builder) *ReverseProxyEntry {
+	var stopTimeOut time.Duration
+
+	host, err := T.ValidateHost(m.Host)
+	b.Add(err)
+
+	port, err := T.ValidatePort(m.Port)
+	b.Add(err)
+
+	pathPatterns, err := T.ValidatePathPatterns(m.PathPatterns)
+	b.Add(err)
+
+	setHeaders, err := T.ValidateHTTPHeaders(m.SetHeaders)
+	b.Add(err)
+
+	url, err := E.Check(url.Parse(fmt.Sprintf("%s://%s:%d", s, host, port)))
+	b.Add(err)
+
+	idleTimeout, err := T.ValidateDurationPostitive(m.IdleTimeout)
+	b.Add(err)
+
+	wakeTimeout, err := T.ValidateDurationPostitive(m.WakeTimeout)
+	b.Add(err)
+
+	stopMethod, err := T.ValidateStopMethod(m.StopMethod)
+	b.Add(err)
+
+	if stopMethod == T.StopMethodStop {
+		stopTimeOut, err = T.ValidateDurationPostitive(m.StopTimeout)
+		b.Add(err)
+	}
+
+	stopSignal, err := T.ValidateSignal(m.StopSignal)
+	b.Add(err)
+
+	if err.HasError() {
+		return nil
+	}
+
+	return &ReverseProxyEntry{
+		Alias:            T.NewAlias(m.Alias),
+		Scheme:           s,
+		URL:              url,
+		NoTLSVerify:      m.NoTLSVerify,
+		PathPatterns:     pathPatterns,
+		SetHeaders:       setHeaders,
+		HideHeaders:      m.HideHeaders,
+		IdleTimeout:      idleTimeout,
+		WakeTimeout:      wakeTimeout,
+		StopMethod:       stopMethod,
+		StopTimeout:      int(stopTimeOut.Seconds()), // docker api takes integer seconds for timeout argument
+		StopSignal:       stopSignal,
+		DockerHost:       m.DockerHost,
+		ContainerName:    m.ContainerName,
+		ContainerRunning: m.Running,
+	}
+}
+
+func validateStreamEntry(m *M.ProxyEntry, b E.Builder) *StreamEntry {
+	host, err := T.ValidateHost(m.Host)
+	b.Add(err)
+
+	port, err := T.ValidateStreamPort(m.Port)
+	b.Add(err)
+
+	scheme, err := T.ValidateStreamScheme(m.Scheme)
+	b.Add(err)
+
+	if b.HasError() {
+		return nil
+	}
+
+	return &StreamEntry{
+		Alias:  T.NewAlias(m.Alias),
+		Scheme: *scheme,
+		Host:   host,
+		Port:   port,
+	}
+}

src/proxy/fields/alias.go

@@ -0,0 +1,6 @@
+package fields
+
+type (
+	Alias    string
+	NewAlias = Alias
+)

src/proxy/fields/headers.go

@@ -0,0 +1,19 @@
+package fields
+
+import (
+	"net/http"
+	"strings"
+
+	E "github.com/yusing/go-proxy/error"
+)
+
+func ValidateHTTPHeaders(headers map[string]string) (http.Header, E.NestedError) {
+	h := make(http.Header)
+	for k, v := range headers {
+		vSplit := strings.Split(v, ",")
+		for _, header := range vSplit {
+			h.Add(k, strings.TrimSpace(header))
+		}
+	}
+	return h, nil
+}

src/proxy/fields/host.go

@@ -0,0 +1,12 @@
+package fields
+
+import (
+	E "github.com/yusing/go-proxy/error"
+)
+
+type Host string
+type Subdomain = Alias
+
+func ValidateHost(s string) (Host, E.NestedError) {
+	return Host(s), nil
+}

src/proxy/fields/path_mode.go

@@ -0,0 +1,24 @@
+package fields
+
+import (
+	E "github.com/yusing/go-proxy/error"
+)
+
+type PathMode string
+
+func NewPathMode(pm string) (PathMode, E.NestedError) {
+	switch pm {
+	case "", "forward":
+		return PathMode(pm), nil
+	default:
+		return "", E.Invalid("path mode", pm)
+	}
+}
+
+func (p PathMode) IsRemove() bool {
+	return p == ""
+}
+
+func (p PathMode) IsForward() bool {
+	return p == "forward"
+}

src/proxy/fields/path_pattern.go

@@ -0,0 +1,37 @@
+package fields
+
+import (
+	"regexp"
+
+	E "github.com/yusing/go-proxy/error"
+)
+
+type PathPattern string
+type PathPatterns = []PathPattern
+
+func NewPathPattern(s string) (PathPattern, E.NestedError) {
+	if len(s) == 0 {
+		return "", E.Invalid("path", "must not be empty")
+	}
+	if !pathPattern.MatchString(string(s)) {
+		return "", E.Invalid("path pattern", s)
+	}
+	return PathPattern(s), nil
+}
+
+func ValidatePathPatterns(s []string) (PathPatterns, E.NestedError) {
+	if len(s) == 0 {
+		return []PathPattern{"/"}, nil
+	}
+	pp := make(PathPatterns, len(s))
+	for i, v := range s {
+		if pattern, err := NewPathPattern(v); err.HasError() {
+			return nil, err
+		} else {
+			pp[i] = pattern
+		}
+	}
+	return pp, nil
+}
+
+var pathPattern = regexp.MustCompile("^((GET|POST|DELETE|PUT|PATCH|HEAD|OPTIONS|CONNECT)\\s)?(/\\w*)+/?$")