# syntax=docker/dockerfile:1

ARG TARGETOS
ARG TARGETARCH

# Build the Go dashboard from source for the target OS/arch
FROM --platform=$TARGETOS/$TARGETARCH golang:1.26 AS builder
ENV CGO_ENABLED=1
WORKDIR /src

# Cache Go modules
COPY go.mod .
COPY go.sum .
RUN go mod download

# Copy source and build
COPY . .
RUN GOOS=$TARGETOS GOARCH=$TARGETARCH CGO_ENABLED=1 \
    go build -trimpath -o dashboard ./cmd/dashboard

# Runtime image
FROM --platform=$TARGETOS/$TARGETARCH busybox:stable-musl
ARG TARGETOS
ARG TARGETARCH
ENV TZ=Asia/Shanghai

WORKDIR /dashboard

# Copy the built binary and runtime resources from the builder
COPY --from=builder /src/dashboard /dashboard/app/dashboard
COPY --from=builder /etc/ssl/certs /etc/ssl/certs
COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
COPY ./script/entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

EXPOSE 8008
VOLUME ["/dashboard/data"]

ENV TZ=$TZ
ENTRYPOINT ["/entrypoint.sh"]

FROM alpine AS depend
RUN apk add --update --no-cache ca-certificates tzdata

FROM busybox:stable-musl

ARG TARGETOS
ARG TARGETARCH

COPY --from=depend /etc/ssl/certs /etc/ssl/certs
COPY --from=depend /usr/share/zoneinfo /usr/share/zoneinfo
COPY ./script/entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

WORKDIR /dashboard
COPY dist/dashboard-${TARGETOS}-${TARGETARCH} ./app

VOLUME ["/dashboard/data"]
EXPOSE 8008
ARG TZ=Asia/Shanghai
ENV TZ=$TZ
ENTRYPOINT ["/entrypoint.sh"]

# Ignore Go build artifacts and vendor
**/vendor/
**/*.dll
**/*.so
**/*.dylib
**/node_modules/
**/dist/
**/build/
**/.git
**/.github
**/dist

#!/bin/sh
printf "nameserver 127.0.0.11\nnameserver 8.8.4.4\nnameserver 223.5.5.5\n" > /etc/resolv.conf
exec /dashboard/app

- CLI flags
  - -v: print singleton.Version and exit
  - -c data/config.yaml: config file path
  - -db data/sqlite.db: SQLite DB file path

- Startup flow
  - InitFrontendTemplates, load config from path, init timezone/cache
  - If configured, set Go memory limit and log it
  - Init DB from path, InitTSDB, then run initSystem(bus)
  - Admin user creation: if no users, create user "admin" with bcrypt hash of "admin"
  - Load all singleton services, schedule Cron tasks:
    - "0 30 3 * * *" → singleton.CleanMonitorHistory
    - "0 0 * * * *" → singleton.RecordTransferHourlyUsage

- Networking
  - TCP listener at singleton.Conf.ListenHost:singleton.Conf.ListenPort
  - HTTP server with ReadHeaderTimeout 5s, HTTP/1, unencrypted HTTP2 enabled
  - Optional HTTPS server if singleton.Conf.HTTPS.ListenPort != 0
    - TLS cert/key from TLSCertPath/TLSKeyPath
    - TLS InsecureSkipVerify controlled by singleton.Conf.HTTPS.InsecureTLS

- Graceful shutdown
  - Uses graceful.Graceful
  - On start: log start, start HTTPS/HTTP servers, call RecordTransferHourlyUsage during shutdown
  - On shutdown: CloseTSDB; Shutdown HTTPS (if present) and HTTP; combine errors

- Components started
  - rpc.DispatchKeepalive, go routines for task dispatch and AlertSentinelStart
  - rpc.ServeRPC, controller.ServeWeb(frontendDist), controller.InitUpgrader
  - HTTP+GRPC mux created via newHTTPandGRPCMux(httpHandler, grpcHandler)

- Request multiplexing (newHTTPandGRPCMux)
  - NAT routing: if singleton.NATShared.GetNATConfigByDomain(r.Host) != nil
    - if natConfig.Enabled is false → show block page via waf.ShowBlockPage
    - else rpc.ServeNAT(w, r, natConfig)
  - gRPC requests: HTTP/2 with Content-Type application/grpc and path starts with /<ServiceName>
  - otherwise: HTTP handler

- OpenAPI/docs and assets
  - OpenAPI host: localhost:8008, BasePath /api/v1
  - Frontend assets embedded: //go:embed *-dist (frontendDist)

- Files/paths to know
  - data/config.yaml
  - data/sqlite.db
  - TLS cert/key paths from singleton.Conf.HTTPS.TLSCertPath and TLSKeyPath

- Logs and error handling
  - Uses logs with prefix NEZHA>>
  - On fatal errors, log and exit
  - If Graceful returns an error of type *utils.WrapError, logs inner error for HTTPS side

- Version docs
  - singleton.Version printed when -v is used

# syntax=docker/dockerfile:1

# Multi-stage build: build from source for the target OS/ARCH and run on a lightweight runtime
FROM --platform=${TARGETOS:-linux}/$TARGETARCH golang:1.26 AS builder
ARG TARGETOS
ARG TARGETARCH
WORKDIR /src

# Cache Go modules
COPY go.mod go.sum ./
RUN go mod download

# Copy source and build the dashboard binary
COPY . .
RUN CGO_ENABLED=1 GOOS=$TARGETOS GOARCH=$TARGETARCH \
    go build -trimpath -o /dashboard/app ./cmd/dashboard

# Runtime image
FROM --platform=${TARGETOS:-linux}/$TARGETARCH busybox:stable-musl
ARG TARGETOS
ARG TARGETARCH
ENV TZ=Asia/Shanghai
WORKDIR /dashboard

# Copy the built binary and necessary resources from the builder
COPY --from=builder /dashboard/app /dashboard/app
COPY --from=builder /etc/ssl/certs /etc/ssl/certs
COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
COPY ./script/entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

EXPOSE 8008
VOLUME ["/dashboard/data"]
ARG TZ=Asia/Shanghai
ENV TZ=$TZ
ENTRYPOINT ["/entrypoint.sh"]

# syntax=docker/dockerfile:1

# Build the dashboard from source for multiple OS/ARCH targets
FROM golang:1.26 AS builder
ARG TARGETOS
ARG TARGETARCH
ENV CGO_ENABLED=0
WORKDIR /src

# Cache Go modules
COPY go.mod go.sum ./
RUN go mod download

# Copy source and build the dashboard binary
COPY . .
RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -trimpath -o /dashboard/app ./cmd/dashboard

# Runtime image
FROM busybox:stable-musl
ARG TARGETOS
ARG TARGETARCH
ENV TZ=Asia/Shanghai
WORKDIR /dashboard

# Copy the built binary and necessary resources from the builder
COPY --from=builder /dashboard/app /dashboard/app
COPY --from=builder /etc/ssl/certs /etc/ssl/certs
COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
COPY ./script/entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

EXPOSE 8008
VOLUME ["/dashboard/data"]
ENV TZ=$TZ
ENTRYPOINT ["/entrypoint.sh"]

Summary (under 1500 chars):

Failing step and exit
- Step: [builder 6/6] RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -trimpath -o /dashboard/app ./cmd/dashboard
- Exit code: 1
- Error result: ERROR: process "/bin/sh -c GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -trimpath -o /dashboard/app ./cmd/dashboard" did not complete successfully: exit code: 1

Exact error messages (verbatim)
- cmd/dashboard/controller/controller.go:23:2: no required module provides package github.com/nezhahq/nezha/cmd/dashboard/docs; to add it:
- 	go get github.com/nezhahq/nezha/cmd/dashboard/docs
- cmd/dashboard/main.go:40:13: pattern *-dist: cannot embed directory admin-dist: contains no embeddable files

Missing packages/files mentioned
- Missing module/package: github.com/nezhahq/nezha/cmd/dashboard/docs
- Embedding issue: admin-dist contains no embeddable files (related to embedding pattern in cmd/dashboard/main.go)

Version mismatch info
- Builder uses golang:1.26 (Go build is performed in a Go 1.26 environment). No explicit version mismatch error is reported.

Notes
- The build failure is caused by a missing module package and an embedding constraint, as indicated by the errors above. Suggested next steps are to add the missing module (go get github.com/nezhahq/nezha/cmd/dashboard/docs) and adjust or provide embeddable files for admin-dist.

# syntax=docker/dockerfile:1

FROM golang:1.26 AS builder
ARG TARGETOS
ARG TARGETARCH
WORKDIR /src

# Cache Go modules
COPY go.mod go.sum ./
RUN go mod download

# Ensure dist directories exist to satisfy embed and add a placeholder file
RUN mkdir -p cmd/dashboard/admin-dist cmd/dashboard/user-dist \
  && sh -lc 'echo placeholder > cmd/dashboard/admin-dist/.placeholder' \
  && sh -lc 'echo placeholder > cmd/dashboard/user-dist/.placeholder'

# Copy source and build swagger docs
COPY . .

# Install swag tool and generate docs for embedding
RUN go install github.com/swaggo/swag/cmd/swag@latest
RUN swag init --pd -d cmd/dashboard -g main.go -o cmd/dashboard/docs

# Build the dashboard binary for the target OS/ARCH
RUN CGO_ENABLED=1 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \
    go build -trimpath -o /dashboard/app ./cmd/dashboard

FROM busybox:stable-musl
ARG TARGETOS
ARG TARGETARCH
ENV TZ=Asia/Shanghai
WORKDIR /dashboard

COPY --from=builder /dashboard/app /dashboard/app
COPY --from=builder /etc/ssl/certs /etc/ssl/certs
COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
COPY ./script/entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

EXPOSE 8008
VOLUME ["/dashboard/data"]
ENV TZ=$TZ
ENTRYPOINT ["/entrypoint.sh"]

- Exact error message and exit code:
  - cmd/dashboard/main.go:40:13: pattern *-dist: cannot embed directory admin-dist: contains no embeddable files
  - Exit code: 1

- Failing command/step:
  - [builder 9/9] RUN CGO_ENABLED=1 GOOS=linux GOARCH=amd64     go build -trimpath -o /dashboard/app ./cmd/dashboard

- Missing packages or files mentioned:
  - The build fails due to embedding admin-dist via a pattern "*-dist" in Go's embed directive: admin-dist contains no embeddable files.
  - admin-dist was created in an earlier step (cmd/dashboard/admin-dist) and a hidden file (.placeholder) was added, but Go embed patterns ignore dotfiles, resulting in no embeddable files found.
  - Suggested fix: rename .placeholder to a non-dot name (e.g., placeholder) or adjust the embed pattern to include non-hidden files.

- Version mismatch information:
  - Base images used: golang:1.26 and busybox:stable-musl
  - No explicit version mismatch error is reported in the log.

- Package: controller
- Key components: ServeWeb(frontendDist fs.FS) http.Handler, routers(r *gin.Engine, frontendDist fs.FS), frontend fallback logic (fallbackToFrontend)
- Runtime flags and UI
  - Gin mode: Release by default; if singleton.Conf.Debug then DebugMode and pprof.Register
  - Swagger UI shown only when singleton.Conf.Debug
  - Swagger UI URL: http://localhost:<singleton.Conf.ListenPort>/swagger/index.html
  - Swagger version: docs.SwaggerInfo.Version
- JWT auth
  - Init: authMiddleware, error on Init: log.Fatal("JWT Error:" + err.Error())
  - MiddlewareInit error also fatal
  - Routes under /api/v1
  - /login, /oauth2/:provider, /oauth2/:provider/unbind, /refresh-token
  - Optional auth vs admin: optionalAuthMw uses utils.IfOr(singleton.Conf.ForceAuth, authMw, fallbackAuthMw)
  - Admin checks: unauthorized → Localizer error "unauthorized"; non-admin → "permission denied"
- Route groups (highlights)
  - fallbackAuth: /setting, /oauth2/callback
  - optionalAuth: /ws/server, /server-group, /service, /service/server, /service/:id/history, /server/:id/service, /server/:id/metrics
  - auth: /terminal, /ws/terminal/:id, /file, /ws/file/:id, /profile, /oauth2/:provider/unbind, /refresh-token
  - Admin-like: /user, /batch-delete/user
  - Core entities: /service (list, create, update, batch-delete), /server (config get/set, batch ops, force-update), /server-group, /notification-group, /notification, /alert-rule, /cron, /ddns, /nat, /waf (list, batch-delete), /online-user (list, batch-block), /setting (patch), /maintenance (post)
  - Notifications: /notification, /batch-delete/notification
  - Alerts: /alert-rule, /batch-delete/alert-rule
  - Cron: /cron, /cron/:id, /cron/:id/manual, /batch-delete/cron
  - DDNS/NAT/WAF/ONLINE: various CRUD and batch endpoints listed in code
  - Fallback: r.NoRoute(fallbackToFrontend(frontendDist))
- Error handling and helpers
  - newErrorResponse(err) returns model.CommonResponse with error string
  - Custom errors: gormError (newGormError), wsError (newWsError)
  - errNoop sentinel: errors.New("wrote")
  - handle() maps errors:
    - *gormError → log and "database error" message
    - *wsError → log websocket error if present
    - default → if not errNoop, return error as response
  - listHandler / pCommonHandler wrappers for data and pagination
  - filter enforces HasPermission per item
  - getUid reads authorized user ID from context
- Frontend fallback logic (fallbackToFrontend)
  - checkLocalFileOrFs serves static from local path or frontend fs
  - frontendPageUrlRegistry lists allowed frontend URLs (official: ^/$, ^/server/\d*$; dashboard: /dashboard/, /dashboard/login, /dashboard/service, /dashboard/cron, /dashboard/notification, /dashboard/alert-rule, /dashboard/ddns, /dashboard/nat, /dashboard/server-group, /dashboard/notification-group, /dashboard/profile, /dashboard/settings, /dashboard/settings/user, /dashboard/settings/online-user, /dashboard/settings/waf)
  - getFallbackStatusCode returns 200 if path matches registry, else 404
  - Dashboard paths: if /dashboard, redirect to /dashboard/
  - If path starts with /dashboard: local path = AdminTemplate + stripped; try serve; else serve AdminTemplate/index.html with fallback code
  - Else: local path = UserTemplate + path; try serve; else UserTemplate/index.html with fallback code
  - AdminTemplate and UserTemplate paths come from singleton.Conf.AdminTemplate and singleton.Conf.UserTemplate
- File/paths noted for actions
  - Admin UI templates: singleton.Conf.AdminTemplate, singleton.Conf.UserTemplate
  - Frontend assets served via frontendDist fs.FS
- Misc
  - recordPath sets MatchedPath with dynamic route tokens
  - Program heavily relies on package names: controller, jwt, gin, pprof, swagger, waf, docs, model, utils, singleton

This preserves actionable items: error messages, exact file/template paths, version reference, key commands (HTTP endpoints), and package names.

Failing step
- [builder 9/9] RUN CGO_ENABLED=1 GOOS=linux GOARCH=amd64     go build -trimpath -o /dashboard/app ./cmd/dashboard

Exact error message and exit code
- cmd/dashboard/main.go:40:13: pattern *-dist: cannot embed directory admin-dist: contains no embeddable files
- The build process did not complete successfully: exit code 1
- Full failure line: ERROR: failed to build: failed to solve: process "/bin/sh -c CGO_ENABLED=1 GOOS=${TARGETOS} GOARCH=${TARGETARCH}     go build -trimpath -o /dashboard/app ./cmd/dashboard" did not complete successfully: exit code: 1

Missing packages or files mentioned
- The embed failure references: pattern *-dist: cannot embed directory admin-dist: contains no embeddable files
- Admin-dist is present (created earlier in the Dockerfile), but the embed pattern is failing to find embeddable content inside admin-dist
- Implicit issue: admin-dist directory is not providing embeddable files for the go:embed directive (despite prior placeholder creation), so the embedding configuration needs adjustment (e.g., ensure embeddable files exist in admin-dist or change the embed pattern)

Version or mismatch information
- No explicit version mismatch reported
- Base images shown: golang:1.26 and busybox:stable-musl, but no mismatch noted in the log

# syntax=docker/dockerfile:1

# Multi-stage build: build from source for the target OS/ARCH and run on a lightweight runtime
FROM golang:1.26 AS builder
ARG TARGETOS
ARG TARGETARCH
ENV CGO_ENABLED=0
ENV PATH=$PATH:/go/bin
WORKDIR /src

# Prepare dist directories with embeddable files to satisfy go:embed
RUN mkdir -p cmd/dashboard/admin-dist cmd/dashboard/user-dist \
  && printf '<html><body>admin-dist placeholder</body></html>' > cmd/dashboard/admin-dist/index.html \
  && printf '<html><body>user-dist placeholder</body></html>' > cmd/dashboard/user-dist/index.html

# Cache Go modules
COPY go.mod go.sum ./
RUN go mod download

# Copy source
COPY . .

# Install swag tool and generate docs for embedding
RUN go install github.com/swaggo/swag/cmd/swag@latest
RUN swag init --pd -d cmd/dashboard -g main.go -o cmd/dashboard/docs

# Build the dashboard binary for the target OS/ARCH
RUN CGO_ENABLED=0 GOOS=${TARGETOS:-linux} GOARCH=${TARGETARCH:-amd64} \
    go build -trimpath -o /dashboard/app ./cmd/dashboard

FROM busybox:stable-musl
ARG TARGETOS
ARG TARGETARCH
ENV TZ=Asia/Shanghai
WORKDIR /dashboard

# Copy the built binary and necessary resources from the builder
COPY --from=builder /dashboard/app /dashboard/app
COPY --from=builder /etc/ssl/certs /etc/ssl/certs
COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
COPY ./script/entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

EXPOSE 8008
VOLUME ["/dashboard/data"]
ENV TZ=$TZ
ENTRYPOINT ["/entrypoint.sh"]