Update default wake timeout to 30 seconds, fixed port selection, improved idlewatcher

Refactoring
Refactor and fixed port and scheme assignment logic in FillMissingFields.
2026-02-10 04:27:42 +01:00 · 2024-09-25 05:27:12 +08:00 · 2024-09-25 03:43:47 +08:00 · 2024-09-25 03:40:57 +08:00 · 2024-09-25 00:56:33 +08:00 · 2024-09-24 18:30:25 +08:00
52 changed files with 1156 additions and 629 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -15,4 +15,6 @@ go.work.sum

 !src/**/

-todo.md
+todo.md
+
+.*.swp
--- a/11
+++ b/11
@@ -1,4 +1,5 @@
 FROM golang:1.23.1-alpine AS builder
+RUN apk add --no-cache tzdata
 COPY src /src
 ENV GOCACHE=/root/.cache/go-build
 WORKDIR /src
@@ -7,16 +8,20 @@ RUN --mount=type=cache,target="/go/pkg/mod" \
    go mod download && \
    CGO_ENABLED=0 GOOS=linux go build -pgo=auto -o go-proxy github.com/yusing/go-proxy

-FROM alpine:3.20
+FROM scratch

 LABEL maintainer="yusing@6uo.me"

-RUN apk add --no-cache tzdata
+# copy timezone data
+COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
+
 # copy binary
 COPY --from=builder /src/go-proxy /app/
 COPY schema/ /app/schema

-RUN chmod +x /app/go-proxy
+# copy cert required for setup
+COPY --from=builder /etc/ssl/certs /etc/ssl/certs
+
 ENV DOCKER_HOST=unix:///var/run/docker.sock
 ENV GOPROXY_DEBUG=0

--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 .PHONY: all build up quick-restart restart logs get udp-server

-all: build quick-restart logs
+all: debug

 setup:
 	mkdir -p config certs
--- a/README.md
+++ b/README.md
@@ -24,22 +24,24 @@ A lightweight, easy-to-use, and [performant](docs/benchmark_result.md) reverse p
    - [Use JSON Schema in VSCode](#use-json-schema-in-vscode)
    - [Config File](#config-file)
    - [Provider File](#provider-file)
-  - [Known issues](#known-issues)
+  - [Showcase](#showcase)
+    - [idlesleeper](#idlesleeper)
  - [Build it yourself](#build-it-yourself)

 ## Key Points

- 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)**
+-   Easy to use
+    -   Effortless configuration
+    -   Simple multi-node setup
+    -   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
+-   **idlesleeper**: stop containers on idle, wake it up on traffic _(optional, see [showcase](#idlesleeper))_
+-   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)**

 [🔼Back to top](#table-of-content)

@@ -47,18 +49,29 @@ A lightweight, easy-to-use, and [performant](docs/benchmark_result.md) reverse p

 ### Setup

-1. Setup DNS Records, e.g.
+1.  Pull docker image 
+    
+    ```shell
+    docker pull ghcr.io/yusing/go-proxy:latest
+    ```

-   - A Record: `*.y.z` -> `10.0.10.1`
-   - AAAA Record: `*.y.z` -> `::ffff:a00:a01`
+2.  Create new directory, `cd` into it, then run setup

-2. Setup `go-proxy` [See here](docs/docker.md)
+    ```shell
+    docker run --rm -v .:/setup ghcr.io/yusing/go-proxy /app/go-proxy setup
+    ```

-3. Setup `docker-socket-proxy` (see [example](docs/docker_socket_proxy.md) other machine that is running docker (if any)
+3.  Setup DNS Records point to machine which runs `go-proxy`, e.g.

-4. Configure `go-proxy`
-   - with text editor (e.g. Visual Studio Code)
-   - or with web config editor via `http://gp.y.z`
+    -   A Record: `*.y.z` -> `10.0.10.1`
+    -   AAAA Record: `*.y.z` -> `::ffff:a00:a01`
+
+4.  Setup `docker-socket-proxy` other docker nodes _(if any)_ (see [example](docs/docker_socket_proxy.md)) and then them inside `config.yml`
+
+5.  Done. You may now do some extra configuration
+    -   With text editor (e.g. Visual Studio Code)
+    -   With Web UI via `gp.y.z`
+    -   For more info, [See docker.md](docs/docker.md)

 [🔼Back to top](#table-of-content)

@@ -97,21 +110,21 @@ 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
-    - ...
+    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
+    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)
@@ -124,9 +137,11 @@ See [providers.example.yml](providers.example.yml) for examples

 [🔼Back to top](#table-of-content)

-## Known issues
+## Showcase

- `autocert` config is not hot-reloadable
+### idlesleeper
+
+![idlesleeper](showcase/idlesleeper.webp)

 [🔼Back to top](#table-of-content)

--- a/README_CHT.md
+++ b/README_CHT.md
@@ -22,22 +22,23 @@
    - [VSCode 中使用 JSON Schema](#vscode-中使用-json-schema)
    - [配置文件](#配置文件)
    - [透過文件配置](#透過文件配置)
-  - [已知問題](#已知問題)
+  - [展示](#展示)
+    - [idlesleeper](#idlesleeper)
  - [源碼編譯](#源碼編譯)

 ## 重點

- 易用
-  - 不需花費太多時間就能輕鬆配置
-  - 除錯簡單
- 自動處理 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)** 編寫
+-   易用
+    -   不需花費太多時間就能輕鬆配置
+    -   除錯簡單
+-   自動處理 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)** 編寫

 [🔼 返回頂部](#目錄)

@@ -47,14 +48,14 @@

 1. 設置 DNS 記錄，例如：

-   - A 記錄: `*.y.z` -> `10.0.10.1`
-   - AAAA 記錄: `*.y.z` -> `::ffff:a00:a01`
+    - 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` 使用網頁配置編輯器
+    - 使用文本編輯器 (推薦 Visual Studio Code [參見 VSCode 使用 schema](#vscode-中使用-json-schema))
+    - 或通過 `http://gp.y.z` 使用網頁配置編輯器

 [🔼 返回頂部](#目錄)

@@ -93,21 +94,21 @@
 ```yaml
 # autocert 配置
 autocert:
-  email: # ACME 電子郵件
-  domains: # 域名列表
-  provider: # DNS 供應商
-  options: # 供應商個別配置
-    - ...
+    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
+    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
 ```

 [🔼 返回頂部](#目錄)
@@ -120,9 +121,11 @@ providers:

 [🔼 返回頂部](#目錄)

-## 已知問題
+## 展示

- `autocert` 配置不能熱重載
+### idlesleeper
+
+![idlesleeper](showcase/idlesleeper.webp)

 [🔼 返回頂部](#目錄)

--- a/config.example.yml
+++ b/config.example.yml
@@ -15,14 +15,14 @@
 #   options:
 #     - auth_token: c1234565789-abcdefghijklmnopqrst # your zone API token

-# 3. other providers, check readme for more
+# 3. other providers, check docs/dns_providers.md for more

 providers:
-  include:
-    - providers.yml # config/providers.yml
-    # add some more below if you want
-    # - file1.yml # config/file_1.yml
-    # - file2.yml
+  # 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/
    # $DOCKER_HOST implies unix:///var/run/docker.sock by default
@@ -30,8 +30,7 @@ providers:
    # 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
+# redirect_to_https: false # redirect http requests to https (if enabled)
--- a/docs/dns_providers.md
+++ b/docs/dns_providers.md
@@ -11,42 +11,70 @@

 ## Cloudflare

+```yaml
+autocert:
+    provider: cloudflare
+    options:
+        auth_token:
+```
+
 `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`
+```yaml
+autocert:
+    provider: clouddns
+    options:
+        client_id:
+        email:
+        password:
+```

 ## DuckDNS

- `token`: DuckDNS Token
+```yaml
+autocert:
+    provider: duckdns
+    options:
+        token:
+```

 Tested by [earvingad](https://github.com/earvingad)

 ## OVHCloud

+```yaml
+autocert:
+    provider: ovh
+    options:
+        api_endpoint:
+        application_key:
+        application_secret:
+        consumer_key:
+        oauth2_config:
+            client_id:
+            client_secret:
+```
+
 _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`
+-   `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

--- a/docs/docker.md
+++ b/docs/docker.md
@@ -6,7 +6,7 @@

 - [Docker compose guide](#docker-compose-guide)
  - [Table of content](#table-of-content)
-  - [Setup](#setup)
+  - [Additional setup](#additional-setup)
  - [Labels](#labels)
    - [Syntax](#syntax)
    - [Fields](#fields)
@@ -16,34 +16,11 @@
  - [Docker compose examples](#docker-compose-examples)
    - [Services URLs for above examples](#services-urls-for-above-examples)

-## Setup
+## Additional setup

-1.  Install `wget` if not already
+1.  Enable HTTPs _(optional)_

-    - 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)
+    Mount a folder to store obtained certs or to load existing cert

    ```yaml
    services:
@@ -57,27 +34,28 @@

    ```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
+        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
+        provider: local
+        cert_path: /app/certs/cert.crt
+        key_path: /app/certs/priv.key
    ```

-5.  Modify `compose.yml` to fit your needs
+2.  Modify `compose.yml` to fit your needs

-6.  Run `docker compose up -d` to start the container
+3.  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
+4.  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)

@@ -85,31 +63,31 @@

 ### 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                                                                       |
+| Label                    | Description                                                                                                                                                         | Example                        | Default                     | Accepted values                                                           |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------ | --------------------------- | ------------------------------------------------------------------------- |
+| `proxy.aliases`          | comma separated aliases for subdomain and label matching                                                                                                            | `gitlab,gitlab-reg,gitlab-ssh` | `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)**<br> _**NOTE: idlewatcher will only be enabled containers that has non-empty `idle_timeout`**_ | `1h`                           | empty or `0` **(disabled)** | `number[unit]...`, e.g. `1m30s`                                           |
+| `proxy.wake_timeout`     | time to wait for target site to be ready                                                                                                                            |                                | `30s`                       | `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                                                                                                                                        | `proxy.gitlab-ssh.scheme`      | N/A                         | N/A                                                                       |
+| `proxy.$<index>.<field>` | set field for specific alias at index (starting from **1**)                                                                                                         | `proxy.$3.port`                | N/A                         | N/A                                                                       |
+| `proxy.*.<field>`        | set field for all aliases                                                                                                                                           | `proxy.*.set_headers`          | 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                                                                                                 |
+| 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 returned from docker                                                  | number in range of `1 - 65535`                                                                                                                                                                                          |
+| `port`          | proxy port **(tcp/udp)**                                                                       | `0:first_port`                                                                   | `x:y` <br><ul><li>**x**: port for `go-proxy` to listen on.<br>**x** can be 0, which means listen on a random port</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 | `/` **(proxy all requests)**                                                     | yaml style list[<sup>1</sup>](#list-example) of ([path patterns](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)

@@ -134,11 +112,11 @@ 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
+    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)
@@ -164,52 +142,52 @@ File Provider

 ```yaml
 service_a:
-  host: service_a.internal
-  path_patterns:
-    - GET /
-    - POST /auth
-  hide_headers:
-    - X-Custom-Header1
-    - X-Custom-Header2
+    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
+-   Container not showing up in proxies list

-  Please check that either `ports` or label `proxy.<alias>.port` is declared, e.g.
+    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
-  ```
+    ```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
+-   Firewall issues

-  If you are using `ufw` with vpn that drop all inbound traffic except vpn, run below:
+    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`
+    `sudo ufw allow from 172.16.0.0/16 to 100.64.0.0/10`

-  Explaination:
+    Explaination:

-  Docker network is usually `172.16.0.0/16`
+    Docker network is usually `172.16.0.0/16`

-  Tailscale is used as an example, `100.64.0.0/10` will be the CIDR
+    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:
+    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' -`
+    `docker network inspect $(docker network ls | awk '$3 == "bridge" { print $1}') | jq -r '.[] | .Name + " " + .IPAM.Config[0].Subnet' -`

 [🔼Back to top](#table-of-content)

@@ -219,97 +197,97 @@ More examples in [here](examples/)

 ```yaml
 volumes:
-  adg-work:
-  adg-conf:
-  mc-data:
-  palworld:
-  nginx:
+    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.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
+    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.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
+-   `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)
--- a/docs/docker_socket_proxy.md
+++ b/docs/docker_socket_proxy.md
@@ -23,7 +23,7 @@ docker-proxy:
  ports:
    - 2375:2375
    # or more secure
-    - <machine_ip>:2375:2375
+    - <machine_private_ip>:2375:2375
 ```

 ```yml
--- a/2
+++ b/2
--- a/providers.example.yml
+++ b/providers.example.yml
@@ -1,22 +1,21 @@
-example: # matching `app.y.z`
-  scheme: https
-  host: 10.0.0.1
-  port: 80
-  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
+example: # matching `example.y.z`
+    scheme: https
+    host: 10.0.0.1
+    port: 80
+    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/{$} # for exactly /home
+    no_tls_verify: false
+    set_headers:
+        HEADER_A: VALUE_A, VALUE_B
+        HEADER_B: VALUE_C
+    hide_headers:
+        - HEADER_C
+        - HEADER_D
+app1: # app1 -> localhost:8080
+    port: 8080
 app2:
-  scheme: tcp
-  host: 10.0.0.2
-  port: 20000:tcp
+    scheme: udp
+    host: 10.0.0.2
+    port: 2223:dns
--- a/schema/providers.schema.json
+++ b/schema/providers.schema.json
@@ -75,7 +75,10 @@
              "scheme": {
                "anyOf": [
                  {
-                    "enum": ["http", "https"]
+                    "enum": [
+                      "http",
+                      "https"
+                    ]
                  },
                  {
                    "type": "null"
@@ -87,7 +90,7 @@
          "then": {
            "properties": {
              "port": {
-                "markdownDescription": "Proxy port from **1** to **65535**",
+                "markdownDescription": "Proxy port from **0** to **65535**",
                "oneOf": [
                  {
                    "type": "string",
@@ -96,7 +99,7 @@
                  },
                  {
                    "type": "integer",
-                    "minimum": 1,
+                    "minimum": 0,
                    "maximum": 65535
                  }
                ]
@@ -160,7 +163,9 @@
                "not": true
              }
            },
-            "required": ["port"]
+            "required": [
+              "port"
+            ]
          }
        },
        {
@@ -192,4 +197,4 @@
    }
  },
  "additionalProperties": false
-}
+}
--- a/setup-docker.sh
+++ b/setup-docker.sh
@@ -1,14 +0,0 @@
-#!/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
--- a/showcase/idlesleeper.webp
+++ b/showcase/idlesleeper.webp
--- a/src/autocert/provider.go
+++ b/src/autocert/provider.go
@@ -71,11 +71,9 @@ func (p *Provider) ObtainCert() (res E.NestedError) {
 	}

 	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
-			}
+		if err := p.registerACME(); err.HasError() {
+			b.Add(E.FailWith("register ACME", err))
+			return
 		}
 	}

@@ -89,16 +87,18 @@ func (p *Provider) ObtainCert() (res E.NestedError) {
 		b.Add(err)
 		return
 	}
-	err = p.saveCert(cert)
-	if err.HasError() {
+
+	if err = p.saveCert(cert); 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))
@@ -187,29 +187,9 @@ func (p *Provider) registerACME() E.NestedError {
 	}
 	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 {
--- a/src/autocert/state.go
+++ b/src/autocert/state.go
@@ -3,7 +3,7 @@ package autocert
 type CertState int

 const (
-	CertStateValid    CertState = 0
-	CertStateExpired  CertState = iota
-	CertStateMismatch CertState = iota
+	CertStateValid CertState = iota
+	CertStateExpired
+	CertStateMismatch
 )
--- a/src/common/args.go
+++ b/src/common/args.go
@@ -13,6 +13,7 @@ type Args struct {

 const (
 	CommandStart              = ""
+	CommandSetup              = "setup"
 	CommandValidate           = "validate"
 	CommandListConfigs        = "ls-config"
 	CommandListRoutes         = "ls-routes"
@@ -23,6 +24,7 @@ const (

 var ValidCommands = []string{
 	CommandStart,
+	CommandSetup,
 	CommandValidate,
 	CommandListConfigs,
 	CommandListRoutes,
--- a/src/common/constants.go
+++ b/src/common/constants.go
@@ -10,83 +10,31 @@ const (
 	KeepAlive         = 5 * time.Second
 )

-const (
-	ProviderKind_Docker = "docker"
-	ProviderKind_File   = "file"
-)
-
 // file, folder structure

 const (
-	ConfigBasePath = "config/"
-	ConfigFileName = "config.yml"
-	ConfigPath     = ConfigBasePath + ConfigFileName
+	ConfigBasePath        = "config"
+	ConfigFileName        = "config.yml"
+	ConfigExampleFileName = "config.example.yml"
+	ConfigPath            = ConfigBasePath + "/" + ConfigFileName
 )

 const (
-	TemplatesBasePath        = "templates/"
-	PanelTemplatePath        = TemplatesBasePath + "panel/index.html"
-	ConfigEditorTemplatePath = TemplatesBasePath + "config_editor/index.html"
+	SchemaBasePath         = "schema"
+	ConfigSchemaPath       = SchemaBasePath + "/config.schema.json"
+	FileProviderSchemaPath = SchemaBasePath + "/providers.schema.json"
 )

 const (
-	SchemaBasePath         = "schema/"
-	ConfigSchemaPath       = SchemaBasePath + "config.schema.json"
-	FileProviderSchemaPath = SchemaBasePath + "providers.schema.json"
+	ComposeFileName        = "compose.yml"
+	ComposeExampleFileName = "compose.example.yml"
 )

 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"
+	WakeTimeoutDefault = "30s"
 	StopTimeoutDefault = "10s"
 	StopMethodDefault  = "stop"
 )
--- a/src/common/env.go
+++ b/src/common/env.go
@@ -7,18 +7,18 @@ import (
 )

 var (
-	NoSchemaValidation = getEnvBool("GOPROXY_NO_SCHEMA_VALIDATION")
-	IsDebug            = getEnvBool("GOPROXY_DEBUG")
-	ProxyHTTPAddr      = getEnv("GOPROXY_HTTP_ADDR", ":80")
-	ProxyHTTPSAddr     = getEnv("GOPROXY_HTTPS_ADDR", ":443")
-	APIHTTPAddr        = getEnv("GOPROXY_API_ADDR", "127.0.0.1:8888")
+	NoSchemaValidation = GetEnvBool("GOPROXY_NO_SCHEMA_VALIDATION")
+	IsDebug            = GetEnvBool("GOPROXY_DEBUG")
+	ProxyHTTPAddr      = GetEnv("GOPROXY_HTTP_ADDR", ":80")
+	ProxyHTTPSAddr     = GetEnv("GOPROXY_HTTPS_ADDR", ":443")
+	APIHTTPAddr        = GetEnv("GOPROXY_API_ADDR", "127.0.0.1:8888")
 )

-func getEnvBool(key string) bool {
+func GetEnvBool(key string) bool {
 	return U.ParseBool(os.Getenv(key))
 }

-func getEnv(key string, defaultValue string) string {
+func GetEnv(key string, defaultValue string) string {
 	value, ok := os.LookupEnv(key)
 	if !ok {
 		value = defaultValue
--- a/src/common/ports.go
+++ b/src/common/ports.go
@@ -0,0 +1,75 @@
+package common
+
+var (
+	WellKnownHTTPPorts = map[string]bool{
+		"80":   true,
+		"8000": true,
+		"8008": true,
+		"8080": true,
+		"3000": true,
+	}
+
+	ServiceNamePortMapTCP = map[string]int{
+		"mssql":            1433,
+		"mysql":            3306,
+		"mariadb":          3306,
+		"postgres":         5432,
+		"rabbitmq":         5672,
+		"redis":            6379,
+		"memcached":        11211,
+		"mongo":            27017,
+		"minecraft-server": 25565,
+
+		"ssh":  22,
+		"ftp":  21,
+		"smtp": 25,
+		"dns":  53,
+		"pop3": 110,
+		"imap": 143,
+	}
+
+	ImageNamePortMap = func() (m map[string]int) {
+		m = make(map[string]int, len(ServiceNamePortMapTCP)+len(imageNamePortMap))
+		for k, v := range ServiceNamePortMapTCP {
+			m[k] = v
+		}
+		for k, v := range imageNamePortMap {
+			m[k] = v
+		}
+		return
+	}()
+
+	imageNamePortMap = map[string]int{
+		"adguardhome":         3000,
+		"bazarr":              6767,
+		"calibre-web":         8083,
+		"changedetection.io":  3000,
+		"dockge":              5001,
+		"gitea":               3000,
+		"gogs":                3000,
+		"grafana":             3000,
+		"home-assistant":      8123,
+		"homebridge":          8581,
+		"httpd":               80,
+		"immich":              3001,
+		"jellyfin":            8096,
+		"lidarr":              8686,
+		"microbin":            8080,
+		"nginx":               80,
+		"nginx-proxy-manager": 81,
+		"open-webui":          8080,
+		"plex":                32400,
+		"portainer":           9000,
+		"portainer-ce":        9000,
+		"prometheus":          9090,
+		"prowlarr":            9696,
+		"radarr":              7878,
+		"radarr-sma":          7878,
+		"rsshub":              1200,
+		"rss-bridge":          80,
+		"sonarr":              8989,
+		"sonarr-sma":          8989,
+		"uptime-kuma":         3001,
+		"whisparr":            6969,
+	}
+)
--- a/src/docker/container.go
+++ b/src/docker/container.go
@@ -9,21 +9,6 @@ import (
 	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
@@ -32,18 +17,20 @@ type Container struct {
 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",
+		DockerHost:         dockerHost,
+		ContainerName:      res.getName(),
+		ImageName:          res.getImageName(),
+		PublicPortMapping:  res.getPublicPortMapping(),
+		PrivatePortMapping: res.getPrivatePortMapping(),
+		NetworkMode:        c.HostConfig.NetworkMode,
+		Aliases:            res.getAliases(),
+		IsExcluded:         U.ParseBool(res.getDeleteLabel(LabelExclude)),
+		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
 }
@@ -81,7 +68,7 @@ func (c Container) getDeleteLabel(label string) string {
 }

 func (c Container) getAliases() []string {
-	if l := c.getDeleteLabel(LableAliases); l != "" {
+	if l := c.getDeleteLabel(LabelAliases); l != "" {
 		return U.CommaSeperatedList(l)
 	} else {
 		return []string{c.getName()}
@@ -98,14 +85,21 @@ func (c Container) getImageName() string {
 	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)
+func (c Container) getPublicPortMapping() PortMapping {
+	res := make(PortMapping)
+	for _, v := range c.Ports {
+		if v.PublicPort == 0 {
+			continue
 		}
+		res[fmt.Sprint(v.PublicPort)] = v
 	}
-	return ""
+	return res
+}
+
+func (c Container) getPrivatePortMapping() PortMapping {
+	res := make(PortMapping)
+	for _, v := range c.Ports {
+		res[fmt.Sprint(v.PrivatePort)] = v
+	}
+	return res
 }
--- a/src/docker/idlewatcher/round_trip.go
+++ b/src/docker/idlewatcher/round_trip.go
@@ -3,7 +3,6 @@ package idlewatcher
 import (
 	"context"
 	"net/http"
-	"time"
 )

 type (
@@ -18,14 +17,14 @@ func (rt roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
 }

 func (w *watcher) roundTrip(origRoundTrip roundTripFunc, req *http.Request) (*http.Response, error) {
+	// wake the container
+	w.wakeCh <- struct{}{}
+
 	// target site is ready, passthrough
 	if w.ready.Load() {
 		return origRoundTrip(req)
 	}

-	// wake the container
-	w.wakeCh <- struct{}{}
-
 	// initial request
 	targetUrl := req.Header.Get(headerGoProxyTargetURL)
 	if targetUrl == "" {
@@ -57,7 +56,6 @@ func (w *watcher) roundTrip(origRoundTrip roundTripFunc, req *http.Request) (*ht
 					rtDone <- resp
 					return
 				}
-				time.Sleep(time.Millisecond * 200)
 			}
 		}
 	}()
@@ -66,6 +64,10 @@ func (w *watcher) roundTrip(origRoundTrip roundTripFunc, req *http.Request) (*ht
 		select {
 		case resp := <-rtDone:
 			return w.makeSuccResp(targetUrl, resp)
+		case err := <-w.wakeDone:
+			if err != nil {
+				return w.makeErrResp("error waking up %s\n%s", w.ContainerName, err.Error())
+			}
 		case <-ctx.Done():
 			if ctx.Err() == context.DeadlineExceeded {
 				return w.makeErrResp("Timed out waiting for %s to fully wake", w.ContainerName)
--- a/src/docker/idlewatcher/watcher.go
+++ b/src/docker/idlewatcher/watcher.go
@@ -78,8 +78,8 @@ func Register(entry *P.ReverseProxyEntry) (*watcher, E.NestedError) {
 		ReverseProxyEntry: entry,
 		client:            client,
 		refCount:          &sync.WaitGroup{},
-		wakeCh:            make(chan struct{}, 1),
-		wakeDone:          make(chan E.NestedError, 1),
+		wakeCh:            make(chan struct{}),
+		wakeDone:          make(chan E.NestedError),
 		l:                 logger.WithField("container", entry.ContainerName),
 	}
 	w.refCount.Add(1)
--- a/src/docker/labels.go
+++ b/src/docker/labels.go
@@ -3,8 +3,8 @@ package docker
 const (
 	WildcardAlias = "*"

-	LableAliases     = NSProxy + ".aliases"
-	LableExclude     = NSProxy + ".exclude"
+	LabelAliases     = NSProxy + ".aliases"
+	LabelExclude     = NSProxy + ".exclude"
 	LabelIdleTimeout = NSProxy + ".idle_timeout"
 	LabelWakeTimeout = NSProxy + ".wake_timeout"
 	LabelStopMethod  = NSProxy + ".stop_method"
--- a/src/docker/proxy_properties.go
+++ b/src/docker/proxy_properties.go
@@ -0,0 +1,22 @@
+package docker
+
+import "github.com/docker/docker/api/types"
+
+type PortMapping = map[string]types.Port
+type ProxyProperties struct {
+	DockerHost         string      `yaml:"-" json:"docker_host"`
+	ContainerName      string      `yaml:"-" json:"container_name"`
+	ImageName          string      `yaml:"-" json:"image_name"`
+	PublicPortMapping  PortMapping `yaml:"-" json:"public_port_mapping"`  // non-zero publicPort:types.Port
+	PrivatePortMapping PortMapping `yaml:"-" json:"private_port_mapping"` // privatePort:types.Port
+	NetworkMode        string      `yaml:"-" json:"network_mode"`
+
+	Aliases     []string `yaml:"-" json:"aliases"`
+	IsExcluded  bool     `yaml:"-" json:"is_excluded"`
+	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"`
+}
--- a/src/error/builder.go
+++ b/src/error/builder.go
@@ -55,15 +55,19 @@ func (b Builder) WithSeverity(s Severity) Builder {
 func (b Builder) Build() NestedError {
 	if len(b.errors) == 0 {
 		return nil
+	} else if len(b.errors) == 1 {
+		return b.errors[0]
 	}
 	return Join(b.message, b.errors...).Severity(b.severity)
 }

 func (b Builder) To(ptr *NestedError) {
-	if *ptr == nil {
+	if ptr == nil {
+		return
+	} else if *ptr == nil {
 		*ptr = b.Build()
 	} else {
-		**ptr = *b.Build()
+		(*ptr).With(b.Build())
 	}
 }

--- a/src/error/builder_test.go
+++ b/src/error/builder_test.go
@@ -43,10 +43,10 @@ func TestBuilderNested(t *testing.T) {
 	expected2 :=
 		(`error occurred:
  - Action 1 failed:
-    - invalid Inner: 2
-    - invalid Inner: 1
+    - invalid Inner: "1"
+    - invalid Inner: "2"
  - Action 2 failed:
-    - invalid Inner: 3`)
+    - invalid Inner: "3"`)
 	if got != expected1 && got != expected2 {
 		t.Errorf("expected \n%s, got \n%s", expected1, got)
 	}
--- a/src/error/error.go
+++ b/src/error/error.go
@@ -118,9 +118,9 @@ func (ne NestedError) With(s any) NestedError {
 	case string:
 		msg = ss
 	case fmt.Stringer:
-		msg = ss.String()
+		return ne.append(ss.String())
 	default:
-		msg = fmt.Sprint(s)
+		return ne.append(fmt.Sprint(s))
 	}
 	return ne.withError(From(errors.New(msg)))
 }
@@ -133,13 +133,19 @@ func (ne NestedError) Subject(s any) NestedError {
 	if ne == nil {
 		return ne
 	}
+	var subject string
 	switch ss := s.(type) {
 	case string:
-		ne.subject = ss
+		subject = ss
 	case fmt.Stringer:
-		ne.subject = ss.String()
+		subject = ss.String()
 	default:
-		ne.subject = fmt.Sprint(s)
+		subject = fmt.Sprint(s)
+	}
+	if ne.subject == "" {
+		ne.subject = subject
+	} else {
+		ne.subject = fmt.Sprintf("%s > %s", subject, ne.subject)
 	}
 	return ne
 }
@@ -201,6 +207,14 @@ func (ne NestedError) withError(err NestedError) NestedError {
 	return ne
 }

+func (ne NestedError) append(msg string) NestedError {
+	if ne == nil {
+		return nil
+	}
+	ne.err = fmt.Errorf("%w %s", ne.err, msg)
+	return ne
+}
+
 func (ne NestedError) writeToSB(sb *strings.Builder, level int, prefix string) {
 	for i := 0; i < level; i++ {
 		sb.WriteString("  ")
--- a/src/error/errors.go
+++ b/src/error/errors.go
@@ -10,10 +10,12 @@ var (
 	ErrUnsupported  = stderrors.New("unsupported")
 	ErrUnexpected   = stderrors.New("unexpected")
 	ErrNotExists    = stderrors.New("does not exist")
+	ErrMissing      = stderrors.New("missing")
 	ErrAlreadyExist = stderrors.New("already exist")
+	ErrOutOfRange   = stderrors.New("out of range")
 )

-const fmtSubjectWhat = "%w %v: %v"
+const fmtSubjectWhat = "%w %v: %q"

 func Failure(what string) NestedError {
 	return errorf("%s %w", what, ErrFailure)
@@ -47,6 +49,14 @@ func NotExist(subject, what any) NestedError {
 	return errorf("%v %w: %v", subject, ErrNotExists, what)
 }

+func Missing(subject any) NestedError {
+	return errorf("%w %v", ErrMissing, subject)
+}
+
 func AlreadyExist(subject, what any) NestedError {
 	return errorf("%v %w: %v", subject, ErrAlreadyExist, what)
 }
+
+func OutOfRange(subject string, value any) NestedError {
+	return errorf("%v %w: %v", subject, ErrOutOfRange, value)
+}
--- a/src/main.go
+++ b/src/main.go
@@ -30,6 +30,12 @@ import (

 func main() {
 	args := common.GetArgs()
+
+	if args.Command == common.CommandSetup {
+		Setup()
+		return
+	}
+
 	l := logrus.WithField("module", "main")
 	onShutdown := F.NewSlice[func()]()

@@ -44,6 +50,7 @@ func main() {
 			DisableSorting:         true,
 			DisableLevelTruncation: true,
 			FullTimestamp:          true,
+			ForceColors:            true,
 			TimestampFormat:        "01-02 15:04:05",
 		})
 	}
--- a/src/models/raw_entry.go
+++ b/src/models/raw_entry.go
@@ -1,6 +1,7 @@
 package model

 import (
+	"fmt"
 	"strconv"
 	"strings"

@@ -31,50 +32,75 @@ type (

 var NewProxyEntries = F.NewMapOf[string, *RawEntry]

-func (e *RawEntry) SetDefaults() {
-	if e.ProxyProperties == nil {
+func (e *RawEntry) FillMissingFields() bool {
+	isDocker := e.ProxyProperties != nil
+	if !isDocker {
 		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"
+	lp, pp, extra := e.splitPorts()
+
+	if port, ok := ServiceNamePortMapTCP[e.ImageName]; ok {
+		if pp == "" {
+			pp = strconv.Itoa(port)
+		}
+		e.Scheme = "tcp"
+	} else if port, ok := ImageNamePortMap[e.ImageName]; ok {
+		if pp == "" {
+			pp = strconv.Itoa(port)
+		}
+		e.Scheme = "http"
+	} else if pp == "" && e.Scheme == "https" {
+		pp = "443"
+	} else if pp == "" {
+		if p, ok := F.FirstValueOf(e.PrivatePortMapping); ok {
+			pp = fmt.Sprint(p.PrivatePort)
+		} else {
+			pp = "80"
+		}
+	}
+
+	// replace private port with public port (if any)
+	if isDocker && e.NetworkMode != "host" {
+		if p, ok := e.PrivatePortMapping[pp]; ok {
+			pp = fmt.Sprint(p.PublicPort)
+		}
+		if _, ok := e.PublicPortMapping[pp]; !ok { // port is not exposed, but specified
+			// try to fallback to first public port
+			if p, ok := F.FirstValueOf(e.PublicPortMapping); ok {
+				pp = fmt.Sprint(p.PublicPort)
+			}
+			// ignore only if it is NOT RUNNING
+			// because stopped containers
+			// will have empty port mapping got from docker
+			if e.Running {
+				return false
 			}
 		}
 	}

+	if e.Scheme == "" && isDocker {
+		if p, ok := e.PublicPortMapping[pp]; ok && p.Type == "udp" {
+			e.Scheme = "udp"
+		}
+	}
+
 	if e.Scheme == "" {
-		switch e.Port {
-		case "443", "8443":
+		if lp != "" {
+			e.Scheme = "tcp"
+		} else if strings.HasSuffix(pp, "443") {
 			e.Scheme = "https"
-		default:
+		} else if _, ok := WellKnownHTTPPorts[pp]; ok {
+			e.Scheme = "http"
+		} else {
+			// assume its http
 			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
 	}
@@ -87,4 +113,36 @@ func (e *RawEntry) SetDefaults() {
 	if e.StopMethod == "" {
 		e.StopMethod = StopMethodDefault
 	}
+
+	e.Port = joinPorts(lp, pp, extra)
+
+	return true
+}
+
+func (e *RawEntry) splitPorts() (lp string, pp string, extra string) {
+	portSplit := strings.Split(e.Port, ":")
+	if len(portSplit) == 1 {
+		pp = portSplit[0]
+	} else {
+		lp = portSplit[0]
+		pp = portSplit[1]
+	}
+	if len(portSplit) > 2 {
+		extra = strings.Join(portSplit[2:], ":")
+	}
+	return
+}
+
+func joinPorts(lp string, pp string, extra string) string {
+	s := make([]string, 0, 3)
+	if lp != "" {
+		s = append(s, lp)
+	}
+	if pp != "" {
+		s = append(s, pp)
+	}
+	if extra != "" {
+		s = append(s, extra)
+	}
+	return strings.Join(s, ":")
 }
--- a/src/proxy/constants.go
+++ b/src/proxy/constants.go
@@ -1,16 +0,0 @@
-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...)
-)
--- a/src/proxy/entry.go
+++ b/src/proxy/entry.go
@@ -44,14 +44,17 @@ func (rp *ReverseProxyEntry) UseIdleWatcher() bool {
 }

 func ValidateEntry(m *M.RawEntry) (any, E.NestedError) {
-	m.SetDefaults()
+	if !m.FillMissingFields() {
+		return nil, E.Missing("fields")
+	}
+
 	scheme, err := T.NewScheme(m.Scheme)
 	if err.HasError() {
 		return nil, err
 	}

 	var entry any
-	e := E.NewBuilder("error validating proxy entry")
+	e := E.NewBuilder("error validating entry")
 	if scheme.IsStream() {
 		entry = validateStreamEntry(m, e)
 	} else {
--- a/src/proxy/fields/host.go
+++ b/src/proxy/fields/host.go
@@ -7,6 +7,6 @@ import (
 type Host string
 type Subdomain = Alias

-func ValidateHost(s string) (Host, E.NestedError) {
+func ValidateHost[String ~string](s String) (Host, E.NestedError) {
 	return Host(s), nil
 }
--- a/src/proxy/fields/path_pattern.go
+++ b/src/proxy/fields/path_pattern.go
@@ -13,7 +13,7 @@ func NewPathPattern(s string) (PathPattern, E.NestedError) {
 	if len(s) == 0 {
 		return "", E.Invalid("path", "must not be empty")
 	}
-	if !pathPattern.MatchString(string(s)) {
+	if !pathPattern.MatchString(s) {
 		return "", E.Invalid("path pattern", s)
 	}
 	return PathPattern(s), nil
@@ -34,4 +34,4 @@ func ValidatePathPatterns(s []string) (PathPatterns, E.NestedError) {
 	return pp, nil
 }

-var pathPattern = regexp.MustCompile("^((GET|POST|DELETE|PUT|PATCH|HEAD|OPTIONS|CONNECT)\\s)?(/\\w*)+/?$")
+var pathPattern = regexp.MustCompile(`^(/[-\w./]*({\$\})?|((GET|POST|DELETE|PUT|HEAD|OPTION) /[-\w./]*({\$\})?))$`)
--- a/src/proxy/fields/path_pattern_test.go
+++ b/src/proxy/fields/path_pattern_test.go
@@ -0,0 +1,47 @@
+package fields
+
+import (
+	"testing"
+
+	E "github.com/yusing/go-proxy/error"
+	U "github.com/yusing/go-proxy/utils/testing"
+)
+
+var validPatterns = []string{
+	"/",
+	"/index.html",
+	"/somepage/",
+	"/drive/abc.mp4",
+	"/{$}",
+	"/some-page/{$}",
+	"GET /",
+	"GET /static/{$}",
+	"GET /drive/abc.mp4",
+	"GET /drive/abc.mp4/{$}",
+	"POST /auth",
+	"DELETE /user/",
+	"PUT /storage/id/",
+}
+
+var invalidPatterns = []string{
+	"/$",
+	"/{$}{$}",
+	"/{$}/{$}",
+	"/index.html$",
+	"get /",
+	"GET/",
+	"GET /$",
+	"GET /drive/{$}/abc.mp4/",
+	"OPTION /config/{$}/abc.conf/{$}",
+}
+
+func TestPathPatternRegex(t *testing.T) {
+	for _, pattern := range validPatterns {
+		_, err := NewPathPattern(pattern)
+		U.ExpectNoError(t, err.Error())
+	}
+	for _, pattern := range invalidPatterns {
+		_, err := NewPathPattern(pattern)
+		U.ExpectError2(t, pattern, E.ErrInvalid, err.Error())
+	}
+}
--- a/src/proxy/fields/port.go
+++ b/src/proxy/fields/port.go
@@ -8,27 +8,28 @@ import (

 type Port int

-func ValidatePort(v string) (Port, E.NestedError) {
-	p, err := strconv.Atoi(v)
+func ValidatePort[String ~string](v String) (Port, E.NestedError) {
+	p, err := strconv.Atoi(string(v))
 	if err != nil {
 		return ErrPort, E.Invalid("port number", v).With(err)
 	}
-	return NewPortInt(p)
+	return ValidatePortInt(p)
 }

-func NewPortInt[Int int | uint16](v Int) (Port, E.NestedError) {
-	pp := Port(v)
-	if err := pp.boundCheck(); err.HasError() {
-		return ErrPort, err
+func ValidatePortInt[Int int | uint16](v Int) (Port, E.NestedError) {
+	p := Port(v)
+	if !p.inBound() {
+		return ErrPort, E.OutOfRange("port", p)
 	}
-	return pp, nil
+	return p, nil
 }

-func (p Port) boundCheck() E.NestedError {
-	if p < MinPort || p > MaxPort {
-		return E.Invalid("port", p)
-	}
-	return nil
+func (p Port) inBound() bool {
+	return p >= MinPort && p <= MaxPort
+}
+
+func (p Port) String() string {
+	return strconv.Itoa(int(p))
 }

 const (
--- a/src/proxy/fields/scheme.go
+++ b/src/proxy/fields/scheme.go
@@ -6,7 +6,7 @@ import (

 type Scheme string

-func NewScheme(s string) (Scheme, E.NestedError) {
+func NewScheme[String ~string](s String) (Scheme, E.NestedError) {
 	switch s {
 	case "http", "https", "tcp", "udp":
 		return Scheme(s), nil
--- a/src/proxy/fields/stream_port.go
+++ b/src/proxy/fields/stream_port.go
@@ -1,7 +1,6 @@
 package fields

 import (
-	"fmt"
 	"strings"

 	"github.com/yusing/go-proxy/common"
@@ -15,36 +14,43 @@ type StreamPort struct {

 func ValidateStreamPort(p string) (StreamPort, E.NestedError) {
 	split := strings.Split(p, ":")
-	if len(split) != 2 {
-		return StreamPort{}, E.Invalid("stream port", fmt.Sprintf("%q", p)).With("should be in 'x:y' format")
+
+	switch len(split) {
+	case 1:
+		split = []string{"0", split[0]}
+	case 2:
+		break
+	default:
+		return ErrStreamPort, E.Invalid("stream port", p).With("too many colons")
 	}

 	listeningPort, err := ValidatePort(split[0])
-	if err.HasError() {
-		return StreamPort{}, err
-	}
-	if err = listeningPort.boundCheck(); err.HasError() {
-		return StreamPort{}, err
+	if err != nil {
+		return ErrStreamPort, err.Subject("listening port")
 	}

 	proxyPort, err := ValidatePort(split[1])
-	if err.HasError() {
+
+	if err.Is(E.ErrOutOfRange) {
+		return ErrStreamPort, err.Subject("proxy port")
+	} else if proxyPort == 0 {
+		return ErrStreamPort, E.Invalid("proxy port", p)
+	} else if err != nil {
 		proxyPort, err = parseNameToPort(split[1])
-		if err.HasError() {
-			return StreamPort{}, err
+		if err != nil {
+			return ErrStreamPort, E.Invalid("proxy port", proxyPort)
 		}
 	}
-	if err = proxyPort.boundCheck(); err.HasError() {
-		return StreamPort{}, err
-	}

-	return StreamPort{ListeningPort: listeningPort, ProxyPort: proxyPort}, nil
+	return StreamPort{listeningPort, proxyPort}, nil
 }

 func parseNameToPort(name string) (Port, E.NestedError) {
 	port, ok := common.ServiceNamePortMapTCP[name]
 	if !ok {
-		return -1, E.Unsupported("service", name)
+		return ErrPort, E.Invalid("service", name)
 	}
 	return Port(port), nil
 }
+
+var ErrStreamPort = StreamPort{ErrPort, ErrPort}
--- a/src/proxy/fields/stream_port_test.go
+++ b/src/proxy/fields/stream_port_test.go
@@ -0,0 +1,48 @@
+package fields
+
+import (
+	"testing"
+
+	E "github.com/yusing/go-proxy/error"
+	. "github.com/yusing/go-proxy/utils/testing"
+)
+
+var validPorts = []string{
+	"1234:5678",
+	"0:2345",
+	"2345",
+	"1234:postgres",
+}
+
+var invalidPorts = []string{
+	"",
+	"123:",
+	"0:",
+	":1234",
+	"1234:1234:1234",
+	"qwerty",
+	"asdfgh:asdfgh",
+	"1234:asdfgh",
+}
+
+var outOfRangePorts = []string{
+	"-1:1234",
+	"1234:-1",
+	"65536",
+	"0:65536",
+}
+
+func TestStreamPort(t *testing.T) {
+	for _, port := range validPorts {
+		_, err := ValidateStreamPort(port)
+		ExpectNoError(t, err.Error())
+	}
+	for _, port := range invalidPorts {
+		_, err := ValidateStreamPort(port)
+		ExpectError2(t, port, E.ErrInvalid, err.Error())
+	}
+	for _, port := range outOfRangePorts {
+		_, err := ValidateStreamPort(port)
+		ExpectError2(t, port, E.ErrOutOfRange, err.Error())
+	}
+}
--- a/src/proxy/provider/docker_provider.go
+++ b/src/proxy/provider/docker_provider.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"regexp"
 	"strconv"
-	"strings"

 	D "github.com/yusing/go-proxy/docker"
 	E "github.com/yusing/go-proxy/error"
@@ -123,6 +122,10 @@ func (p *DockerProvider) OnEvent(event W.Event, routes R.Routes) (res EventResul
 func (p *DockerProvider) entriesFromContainerLabels(container D.Container) (M.RawEntries, E.NestedError) {
 	entries := M.NewProxyEntries()

+	if container.IsExcluded {
+		return entries, nil
+	}
+
 	// init entries map for all aliases
 	for _, a := range container.Aliases {
 		entries.Store(a, &M.RawEntry{
@@ -137,26 +140,10 @@ func (p *DockerProvider) entriesFromContainerLabels(container D.Container) (M.Ra
 		errors.Add(p.applyLabel(container, entries, key, val))
 	}

-	// selecting correct host port
-	if container.HostConfig.NetworkMode != "host" {
-		for _, a := range container.Aliases {
-			entry, ok := entries.Load(a)
-			if !ok {
-				continue
-			}
-			for _, p := range container.Ports {
-				containerPort := strconv.Itoa(int(p.PrivatePort))
-				publicPort := strconv.Itoa(int(p.PublicPort))
-				entryPortSplit := strings.Split(entry.Port, ":")
-				if len(entryPortSplit) == 2 && entryPortSplit[1] == containerPort {
-					entryPortSplit[1] = publicPort
-				} else if len(entryPortSplit) == 1 && entryPortSplit[0] == containerPort {
-					entryPortSplit[0] = publicPort
-				}
-				entry.Port = strings.Join(entryPortSplit, ":")
-			}
-		}
-	}
+	// remove all entries that failed to fill in missing fields
+	entries.RemoveAll(func(re *M.RawEntry) bool {
+		return !re.FillMissingFields()
+	})

 	return entries, errors.Build().Subject(container.ContainerName)
 }
@@ -188,7 +175,7 @@ func (p *DockerProvider) applyLabel(container D.Container, entries M.RawEntries,
 				return ref
 			}
 			if index < 1 || index > len(container.Aliases) {
-				refErr.Add(E.Invalid("index", ref).Extraf("index out of range"))
+				refErr.Add(E.OutOfRange("index", ref))
 				return ref
 			}
 			return container.Aliases[index-1]
--- a/src/proxy/provider/docker_provider_test.go
+++ b/src/proxy/provider/docker_provider_test.go
@@ -8,15 +8,12 @@ import (
 	"github.com/yusing/go-proxy/common"
 	D "github.com/yusing/go-proxy/docker"
 	E "github.com/yusing/go-proxy/error"
-	F "github.com/yusing/go-proxy/utils/functional"
+	P "github.com/yusing/go-proxy/proxy"
+	T "github.com/yusing/go-proxy/proxy/fields"
+
 	. "github.com/yusing/go-proxy/utils/testing"
 )

-func get[KT comparable, VT any](m F.Map[KT, VT], key KT) VT {
-	v, _ := m.Load(key)
-	return v
-}
-
 var dummyNames = []string{"/a"}

 func TestApplyLabelFieldValidity(t *testing.T) {
@@ -48,10 +45,10 @@ X_Custom_Header2: value3
 		"X-Custom-Header2",
 	}
 	var p DockerProvider
-	var c = D.FromDocker(&types.Container{
+	entries, err := p.entriesFromContainerLabels(D.FromDocker(&types.Container{
 		Names: dummyNames,
 		Labels: map[string]string{
-			D.LableAliases:          "a,b",
+			D.LabelAliases:          "a,b",
 			D.LabelIdleTimeout:      common.IdleTimeoutDefault,
 			D.LabelStopMethod:       common.StopMethodDefault,
 			D.LabelStopSignal:       "SIGTERM",
@@ -65,11 +62,16 @@ X_Custom_Header2: value3
 			"proxy.a.path_patterns": pathPatterns,
 			"proxy.a.set_headers":   setHeaders,
 			"proxy.a.hide_headers":  hideHeaders,
-		}}, "")
-	entries, err := p.entriesFromContainerLabels(c)
+		},
+		Ports: []types.Port{
+			{Type: "tcp", PrivatePort: 4567, PublicPort: 8888},
+		}}, ""))
 	ExpectNoError(t, err.Error())
-	a := get(entries, "a")
-	b := get(entries, "b")
+
+	a, ok := entries.Load("a")
+	ExpectTrue(t, ok)
+	b, ok := entries.Load("b")
+	ExpectTrue(t, ok)

 	ExpectEqual(t, a.Scheme, "https")
 	ExpectEqual(t, b.Scheme, "https")
@@ -77,8 +79,8 @@ X_Custom_Header2: value3
 	ExpectEqual(t, a.Host, "app")
 	ExpectEqual(t, b.Host, "app")

-	ExpectEqual(t, a.Port, "4567")
-	ExpectEqual(t, b.Port, "4567")
+	ExpectEqual(t, a.Port, "8888")
+	ExpectEqual(t, b.Port, "8888")

 	ExpectTrue(t, a.NoTLSVerify)
 	ExpectTrue(t, b.NoTLSVerify)
@@ -110,36 +112,68 @@ X_Custom_Header2: value3

 func TestApplyLabel(t *testing.T) {
 	var p DockerProvider
-	var c = D.FromDocker(&types.Container{
+	entries, err := p.entriesFromContainerLabels(D.FromDocker(&types.Container{
 		Names: dummyNames,
 		Labels: map[string]string{
-			D.LableAliases:          "a,b,c",
+			D.LabelAliases:          "a,b,c",
 			"proxy.a.no_tls_verify": "true",
+			"proxy.a.port":          "3333",
 			"proxy.b.port":          "1234",
 			"proxy.c.scheme":        "https",
-		}}, "")
-	entries, err := p.entriesFromContainerLabels(c)
+		},
+		Ports: []types.Port{
+			{Type: "tcp", PrivatePort: 3333, PublicPort: 1111},
+			{Type: "tcp", PrivatePort: 4444, PublicPort: 1234},
+		}}, "",
+	))
+	a, ok := entries.Load("a")
+	ExpectTrue(t, ok)
+	b, ok := entries.Load("b")
+	ExpectTrue(t, ok)
+	c, ok := entries.Load("c")
+	ExpectTrue(t, ok)
+
 	ExpectNoError(t, err.Error())
-	ExpectEqual(t, get(entries, "a").NoTLSVerify, true)
-	ExpectEqual(t, get(entries, "b").Port, "1234")
-	ExpectEqual(t, get(entries, "c").Scheme, "https")
+	ExpectEqual(t, a.Scheme, "http")
+	ExpectEqual(t, a.Port, "1111")
+	ExpectEqual(t, a.NoTLSVerify, true)
+	ExpectEqual(t, b.Scheme, "http")
+	ExpectEqual(t, b.Port, "1234")
+	ExpectEqual(t, c.Scheme, "https")
+	ExpectEqual(t, c.Port, "1111")
 }

 func TestApplyLabelWithRef(t *testing.T) {
 	var p DockerProvider
-	var c = D.FromDocker(&types.Container{
+	entries, err := p.entriesFromContainerLabels(D.FromDocker(&types.Container{
 		Names: dummyNames,
 		Labels: map[string]string{
-			D.LableAliases:    "a,b,c",
+			D.LabelAliases:    "a,b,c",
 			"proxy.$1.host":   "localhost",
-			"proxy.$2.port":   "1234",
+			"proxy.*.port":    "1111",
+			"proxy.$1.port":   "4444",
+			"proxy.$2.port":   "9999",
 			"proxy.$3.scheme": "https",
-		}}, "")
-	entries, err := p.entriesFromContainerLabels(c)
+		},
+		Ports: []types.Port{
+			{Type: "tcp", PrivatePort: 3333, PublicPort: 9999},
+			{Type: "tcp", PrivatePort: 4444, PublicPort: 5555},
+			{Type: "tcp", PrivatePort: 1111, PublicPort: 2222},
+		}}, ""))
+	a, ok := entries.Load("a")
+	ExpectTrue(t, ok)
+	b, ok := entries.Load("b")
+	ExpectTrue(t, ok)
+	c, ok := entries.Load("c")
+	ExpectTrue(t, ok)
+
 	ExpectNoError(t, err.Error())
-	ExpectEqual(t, get(entries, "a").Host, "localhost")
-	ExpectEqual(t, get(entries, "b").Port, "1234")
-	ExpectEqual(t, get(entries, "c").Scheme, "https")
+	ExpectEqual(t, a.Scheme, "http")
+	ExpectEqual(t, a.Host, "localhost")
+	ExpectEqual(t, a.Port, "5555")
+	ExpectEqual(t, b.Port, "9999")
+	ExpectEqual(t, c.Scheme, "https")
+	ExpectEqual(t, c.Port, "2222")
 }

 func TestApplyLabelWithRefIndexError(t *testing.T) {
@@ -147,21 +181,134 @@ func TestApplyLabelWithRefIndexError(t *testing.T) {
 	var c = D.FromDocker(&types.Container{
 		Names: dummyNames,
 		Labels: map[string]string{
-			D.LableAliases:    "a,b",
+			D.LabelAliases:    "a,b",
 			"proxy.$1.host":   "localhost",
 			"proxy.$4.scheme": "https",
 		}}, "")
 	_, err := p.entriesFromContainerLabels(c)
-	ExpectError(t, E.ErrInvalid, err.Error())
+	ExpectError(t, E.ErrOutOfRange, err.Error())
 	ExpectTrue(t, strings.Contains(err.String(), "index out of range"))

-	c = D.FromDocker(&types.Container{
+	_, err = p.entriesFromContainerLabels(D.FromDocker(&types.Container{
 		Names: dummyNames,
 		Labels: map[string]string{
-			D.LableAliases:  "a,b",
+			D.LabelAliases:  "a,b",
 			"proxy.$0.host": "localhost",
-		}}, "")
-	_, err = p.entriesFromContainerLabels(c)
-	ExpectError(t, E.ErrInvalid, err.Error())
+		}}, ""))
+	ExpectError(t, E.ErrOutOfRange, err.Error())
 	ExpectTrue(t, strings.Contains(err.String(), "index out of range"))
 }
+
+func TestStreamDefaultValues(t *testing.T) {
+	var p DockerProvider
+	var c = D.FromDocker(&types.Container{
+		Names: dummyNames,
+		Labels: map[string]string{
+			D.LabelAliases:          "a",
+			"proxy.*.no_tls_verify": "true",
+		},
+		Ports: []types.Port{
+			{Type: "udp", PrivatePort: 1234, PublicPort: 5678},
+		}}, "",
+	)
+	entries, err := p.entriesFromContainerLabels(c)
+	ExpectNoError(t, err.Error())
+
+	raw, ok := entries.Load("a")
+	ExpectTrue(t, ok)
+
+	entry, err := P.ValidateEntry(raw)
+	ExpectNoError(t, err.Error())
+
+	a := ExpectType[*P.StreamEntry](t, entry)
+	ExpectEqual(t, a.Scheme.ListeningScheme, T.Scheme("udp"))
+	ExpectEqual(t, a.Scheme.ProxyScheme, T.Scheme("udp"))
+	ExpectEqual(t, a.Port.ListeningPort, 0)
+	ExpectEqual(t, a.Port.ProxyPort, 5678)
+}
+
+func TestExplicitExclude(t *testing.T) {
+	var p DockerProvider
+	entries, err := p.entriesFromContainerLabels(D.FromDocker(&types.Container{
+		Names: dummyNames,
+		Labels: map[string]string{
+			D.LabelAliases:          "a",
+			D.LabelExclude:          "true",
+			"proxy.a.no_tls_verify": "true",
+		}}, ""))
+	ExpectNoError(t, err.Error())
+
+	_, ok := entries.Load("a")
+	ExpectFalse(t, ok)
+}
+
+func TestImplicitExclude(t *testing.T) {
+	var p DockerProvider
+	entries, err := p.entriesFromContainerLabels(D.FromDocker(&types.Container{
+		Names: dummyNames,
+		Labels: map[string]string{
+			D.LabelAliases:          "a",
+			"proxy.a.no_tls_verify": "true",
+		},
+		State: "running",
+	}, ""))
+	ExpectNoError(t, err.Error())
+
+	_, ok := entries.Load("a")
+	ExpectFalse(t, ok)
+}
+
+func TestImplicitExcludeNoExposedPort(t *testing.T) {
+	var p DockerProvider
+	entries, err := p.entriesFromContainerLabels(D.FromDocker(&types.Container{
+		Image: "redis",
+		Names: []string{"redis"},
+		Ports: []types.Port{
+			{Type: "tcp", PrivatePort: 6379, PublicPort: 0}, // not exposed
+		},
+		State: "running",
+	}, ""))
+	ExpectNoError(t, err.Error())
+
+	_, ok := entries.Load("redis")
+	ExpectFalse(t, ok)
+}
+
+func TestNotExcludeSpecifiedPort(t *testing.T) {
+	var p DockerProvider
+	entries, err := p.entriesFromContainerLabels(D.FromDocker(&types.Container{
+		Image: "redis",
+		Names: []string{"redis"},
+		Ports: []types.Port{
+			{Type: "tcp", PrivatePort: 6379, PublicPort: 0}, // not exposed
+		},
+		Labels: map[string]string{
+			"proxy.redis.port": "6379:6379", // but specified in label
+		},
+	}, ""))
+	ExpectNoError(t, err.Error())
+
+	_, ok := entries.Load("redis")
+	ExpectTrue(t, ok)
+}
+
+func TestNotExcludeNonExposedPortHostNetwork(t *testing.T) {
+	var p DockerProvider
+	cont := &types.Container{
+		Image: "redis",
+		Names: []string{"redis"},
+		Ports: []types.Port{
+			{Type: "tcp", PrivatePort: 6379, PublicPort: 0}, // not exposed
+		},
+		Labels: map[string]string{
+			"proxy.redis.port": "6379:6379",
+		},
+	}
+	cont.HostConfig.NetworkMode = "host"
+
+	entries, err := p.entriesFromContainerLabels(D.FromDocker(cont, ""))
+	ExpectNoError(t, err.Error())
+
+	_, ok := entries.Load("redis")
+	ExpectTrue(t, ok)
+}
--- a/src/route/http_route.go
+++ b/src/route/http_route.go
@@ -148,7 +148,12 @@ func ProxyHandler(w http.ResponseWriter, r *http.Request) {
 }

 func findMux(host string) (*http.ServeMux, E.NestedError) {
-	sd := strings.Split(host, ".")[0]
+	hostSplit := strings.Split(host, ".")
+	n := len(hostSplit)
+	if n <= 2 {
+		return nil, E.Missing("subdomain")
+	}
+	sd := strings.Join(hostSplit[:n-2], ".")
 	if r, ok := httpRoutes.Load(PT.Alias(sd)); ok {
 		return r.mux, nil
 	}
--- a/src/route/route.go
+++ b/src/route/route.go
@@ -17,15 +17,15 @@ type (
 		Type() RouteType
 		URL() *url.URL
 	}
-	Routes    = F.Map[string, Route]
-	RouteType string
+	Routes = F.Map[string, Route]

 	RouteImpl interface {
 		Start() E.NestedError
 		Stop() E.NestedError
 		String() string
 	}
-	route struct {
+	RouteType string
+	route     struct {
 		RouteImpl
 		type_ RouteType
 		entry *M.RawEntry
@@ -42,7 +42,7 @@ var NewRoutes = F.NewMapOf[string, Route]

 func NewRoute(en *M.RawEntry) (Route, E.NestedError) {
 	rt, err := P.ValidateEntry(en)
-	if err.HasError() {
+	if err != nil {
 		return nil, err
 	}

@@ -58,7 +58,10 @@ func NewRoute(en *M.RawEntry) (Route, E.NestedError) {
 	default:
 		panic("bug: should not reach here")
 	}
-	return &route{RouteImpl: rt.(RouteImpl), entry: en, type_: t}, err
+	if err != nil {
+		return nil, err
+	}
+	return &route{RouteImpl: rt.(RouteImpl), entry: en, type_: t}, nil
 }

 func (rt *route) Entry() *M.RawEntry {
--- a/src/route/stream_route.go
+++ b/src/route/stream_route.go
@@ -14,7 +14,7 @@ import (
 )

 type StreamRoute struct {
-	P.StreamEntry
+	*P.StreamEntry
 	StreamImpl `json:"-"`

 	wg     sync.WaitGroup
@@ -31,6 +31,7 @@ type StreamImpl interface {
 	Accept() (any, error)
 	Handle(any) error
 	CloseListeners()
+	String() string
 }

 func NewStreamRoute(entry *P.StreamEntry) (*StreamRoute, E.NestedError) {
@@ -39,7 +40,7 @@ func NewStreamRoute(entry *P.StreamEntry) (*StreamRoute, E.NestedError) {
 		return nil, E.Unsupported("scheme", fmt.Sprintf("%v -> %v", entry.Scheme.ListeningScheme, entry.Scheme.ProxyScheme))
 	}
 	base := &StreamRoute{
-		StreamEntry: *entry,
+		StreamEntry: entry,
 		connCh:      make(chan any, 100),
 	}
 	if entry.Scheme.ListeningScheme.IsTCP() {
@@ -64,6 +65,7 @@ func (r *StreamRoute) Start() E.NestedError {
 	if err := r.Setup(); err != nil {
 		return E.FailWith("setup", err)
 	}
+	r.l.Infof("listening on port %d", r.Port.ListeningPort)
 	r.started.Store(true)
 	r.wg.Add(2)
 	go r.grAcceptConnections()
--- a/src/route/tcp_route.go
+++ b/src/route/tcp_route.go
@@ -7,6 +7,7 @@ import (
 	"sync"
 	"time"

+	T "github.com/yusing/go-proxy/proxy/fields"
 	U "github.com/yusing/go-proxy/utils"
 )

@@ -35,6 +36,8 @@ func (route *TCPRoute) Setup() error {
 	if err != nil {
 		return err
 	}
+	//! this read the allocated port from orginal ':0'
+	route.Port.ListeningPort = T.Port(in.Addr().(*net.TCPAddr).Port)
 	route.listener = in
 	return nil
 }
--- a/src/route/udp_route.go
+++ b/src/route/udp_route.go
@@ -5,6 +5,7 @@ import (
 	"io"
 	"net"

+	T "github.com/yusing/go-proxy/proxy/fields"
 	U "github.com/yusing/go-proxy/utils"
 	F "github.com/yusing/go-proxy/utils/functional"
 )
@@ -50,8 +51,12 @@ func (route *UDPRoute) Setup() error {
 		return err
 	}

+	//! this read the allocated listeningPort from orginal ':0'
+	route.Port.ListeningPort = T.Port(source.LocalAddr().(*net.UDPAddr).Port)
+
 	route.listeningConn = source
 	route.targetAddr = raddr
+
 	return nil
 }

--- a/src/setup.go
+++ b/src/setup.go
@@ -0,0 +1,115 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+
+	. "github.com/yusing/go-proxy/common"
+)
+
+var branch = GetEnv("GOPROXY_BRANCH", "v0.5")
+var baseUrl = fmt.Sprintf("https://github.com/yusing/go-proxy/raw/%s", branch)
+var requiredConfigs = []Config{
+	{ConfigBasePath, true, false, ""},
+	{ComposeFileName, false, true, ComposeExampleFileName},
+	{path.Join(ConfigBasePath, ConfigFileName), false, true, ConfigExampleFileName},
+}
+
+type Config struct {
+	Pathname         string
+	IsDir            bool
+	NeedDownload     bool
+	DownloadFileName string
+}
+
+func Setup() {
+	log.Println("setting up go-proxy")
+	log.Println("branch:", branch)
+
+	os.Chdir("/setup")
+
+	for _, config := range requiredConfigs {
+		config.setup()
+	}
+
+	log.Println("done")
+}
+
+func (c *Config) setup() {
+	if c.IsDir {
+		mkdir(c.Pathname)
+		return
+	}
+	if !c.NeedDownload {
+		touch(c.Pathname)
+		return
+	}
+
+	fetch(c.DownloadFileName, c.Pathname)
+}
+
+func hasFileOrDir(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+func mkdir(pathname string) {
+	_, err := os.Stat(pathname)
+	if err != nil && os.IsNotExist(err) {
+		log.Printf("creating directory %q\n", pathname)
+		err := os.MkdirAll(pathname, 0o755)
+		if err != nil {
+			log.Fatalf("failed: %s\n", err)
+		}
+		return
+	}
+	if err != nil {
+		log.Fatalf("failed: %s\n", err)
+	}
+}
+
+func touch(pathname string) {
+	if hasFileOrDir(pathname) {
+		return
+	}
+	log.Printf("creating file %q\n", pathname)
+	_, err := os.Create(pathname)
+	if err != nil {
+		log.Fatalf("failed: %s\n", err)
+	}
+}
+func fetch(remoteFilename string, outFileName string) {
+	if hasFileOrDir(outFileName) {
+		return
+	}
+	log.Printf("downloading %q\n", remoteFilename)
+
+	url, err := url.JoinPath(baseUrl, remoteFilename)
+	if err != nil {
+		log.Fatalf("unexpected error: %s\n", err)
+	}
+
+	resp, err := http.Get(url)
+	if err != nil {
+		log.Fatalf("http request failed: %s\n", err)
+	}
+
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatalf("error reading response body: %s\n", err)
+	}
+
+	err = os.WriteFile(outFileName, body, 0o644)
+	if err != nil {
+		log.Fatalf("failed to write to file: %s\n", err)
+	}
+
+	log.Printf("downloaded %q\n", outFileName)
+}
--- a/src/utils/functional/map_utils.go
+++ b/src/utils/functional/map_utils.go
@@ -0,0 +1,8 @@
+package functional
+
+func FirstValueOf[KT comparable, VT any](m map[KT]VT) (_ VT, ok bool) {
+	for _, v := range m {
+		return v, true
+	}
+	return
+}
--- a/src/utils/serialization.go
+++ b/src/utils/serialization.go
@@ -100,7 +100,6 @@ func Serialize(data any) (SerializedObject, E.NestedError) {
 			}
 		}
 	default:
-		// return nil, fmt.Errorf("unsupported type: %s", value.Kind())
 		return nil, E.Unsupported("type", value.Kind())
 	}

--- a/src/utils/string.go
+++ b/src/utils/string.go
@@ -1,6 +1,10 @@
 package utils

-import "strings"
+import (
+	"net/url"
+	"strconv"
+	"strings"
+)

 func CommaSeperatedList(s string) []string {
 	res := strings.Split(s, ",")
@@ -9,3 +13,11 @@ func CommaSeperatedList(s string) []string {
 	}
 	return res
 }
+
+func ExtractPort(fullURL string) (int, error) {
+	url, err := url.Parse(fullURL)
+	if err != nil {
+		return 0, err
+	}
+	return strconv.Atoi(url.Port())
+}
--- a/src/utils/testing/testing.go
+++ b/src/utils/testing/testing.go
@@ -10,13 +10,23 @@ func ExpectNoError(t *testing.T, err error) {
 	t.Helper()
 	if err != nil && !reflect.ValueOf(err).IsNil() {
 		t.Errorf("expected err=nil, got %s", err.Error())
+		t.FailNow()
 	}
 }

 func ExpectError(t *testing.T, expected error, err error) {
 	t.Helper()
 	if !errors.Is(err, expected) {
-		t.Errorf("expected err %s, got nil", expected.Error())
+		t.Errorf("expected err %s, got %s", expected.Error(), err.Error())
+		t.FailNow()
+	}
+}
+
+func ExpectError2(t *testing.T, input any, expected error, err error) {
+	t.Helper()
+	if !errors.Is(err, expected) {
+		t.Errorf("%v: expected err %s, got %s", input, expected.Error(), err.Error())
+		t.FailNow()
 	}
 }

@@ -24,6 +34,7 @@ func ExpectEqual[T comparable](t *testing.T, got T, want T) {
 	t.Helper()
 	if got != want {
 		t.Errorf("expected:\n%v, got\n%v", want, got)
+		t.FailNow()
 	}
 }

@@ -31,29 +42,34 @@ func ExpectDeepEqual[T any](t *testing.T, got T, want T) {
 	t.Helper()
 	if !reflect.DeepEqual(got, want) {
 		t.Errorf("expected:\n%v, got\n%v", want, got)
+		t.FailNow()
 	}
 }

 func ExpectTrue(t *testing.T, got bool) {
 	t.Helper()
 	if !got {
-		t.Errorf("expected true, got false")
+		t.Error("expected true")
+		t.FailNow()
 	}
 }

 func ExpectFalse(t *testing.T, got bool) {
 	t.Helper()
 	if got {
-		t.Errorf("expected false, got true")
+		t.Error("expected false")
+		t.FailNow()
 	}
 }

-func ExpectType[T any](t *testing.T, got any) T {
+func ExpectType[T any](t *testing.T, got any) (_ T) {
 	t.Helper()
 	tExpect := reflect.TypeFor[T]()
 	_, ok := got.(T)
 	if !ok {
-		t.Errorf("expected type %s, got %T", tExpect, got)
+		t.Fatalf("expected type %s, got %s", tExpect, reflect.TypeOf(got).Elem())
+		t.FailNow()
+		return
 	}
 	return got.(T)
 }
Author	SHA1	Message	Date
yusing	d10d0e49fa	Update default wake timeout to 30 seconds, fixed port selection, improved idlewatcher	2024-09-25 05:27:12 +08:00
yusing	dc3575c8fd	Refactoring	2024-09-25 03:43:47 +08:00
yusing	17115cfb0b	Refactor and fixed port and scheme assignment logic in FillMissingFields. Fixed issue that when a container is stopped or network=host, it will be excluded.	2024-09-25 03:40:57 +08:00
yusing	498082f7e5	no longer exclude a stopped container that have user specified port	2024-09-25 00:56:33 +08:00
yusing	99216ffe59	fixed subdomain matching for sub-sub-subdomain and so on, now return 404 when subdomain is missing	2024-09-24 18:30:25 +08:00
yusing	f426dbc9cf	removed save registration.json since it does not work properly	2024-09-24 18:18:37 +08:00
yusing	1c611cc9b9	example fix	2024-09-24 03:13:39 +08:00
yusing	dc43e26770	Format README for better clarity in setup instructions	2024-09-24 03:09:50 +08:00
yusing	79ae26f1b5	new simpler setup method, readme and doc update	2024-09-23 22:10:13 +08:00
yusing	109c2460fa	fixed container being excluded in host network_mode	2024-09-23 20:34:46 +08:00
yusing	71e8e4a462	smarter scheme and port detection	2024-09-23 20:16:38 +08:00
yusing	8e2cc56afb	Fixed nil dereferencing and added missing fields validation	2024-09-23 16:14:34 +08:00
yusing	6728bc39d2	fixed nil dereferencing	2024-09-23 07:19:47 +08:00
yusing	daca4b7735	shrink docker image size in half, adding back ForceColor for logrus	2024-09-23 05:34:50 +08:00
yusing	3b597eea29	support '0' listening port, readme update, showcase added	2024-09-23 04:09:56 +08:00