a338153 feat(cli): add custom Dockerfile flag to gordon push --build · gordon

M docs/cli/push.md +7 -2


@@ -21,6 +21,7 @@ gordon push <domain> [options]
21	21		\| Option \| Description \|
22	22		\|--------\|-------------\|
23	23		\| `--build` \| Build the image first using `docker buildx` \|
	24	+	\| `-f, --file` \| Path to Dockerfile (default: `./Dockerfile`, used with `--build`) \|
24	25		\| `--platform` \| Target platform for buildx (default: `linux/amd64`) \|
25	26		\| `--build-arg` \| Additional build args (repeatable, `KEY=VALUE`) \|
26	27		\| `--tag` \| Override version tag (default: `git describe --tags --abbrev=0`) \|

@@ -37,8 +38,9 @@ Gordon registry, pushes it, and optionally deploys it.
37	38		- The registry and repository are derived from the route image on the server.
38	39		- The version tag defaults to the latest git tag. If no tag is found, `latest`
39	40		is used.
40		-	- When `--build` is set, the command uses `docker buildx build --push` and
41		-	injects `VERSION=<tag>` plus any `--build-arg` values.
	41	+	- When `--build` is set, the command builds with `docker buildx build --load`
	42	+	and injects `VERSION=<tag>` plus any `--build-arg` values.
	43	+	- Use `-f/--file` to build from a Dockerfile outside the current directory root.
42	44		- The version tag and `latest` are both pushed (unless the version is `latest`).
43	45
44	46		### Examples

@@ -55,6 +57,9 @@ gordon push myapp.example.com --no-confirm
55	57
56	58		# Build for ARM and pass build args
57	59		gordon push myapp.example.com --build --platform linux/arm64 --build-arg CGO_ENABLED=0
	60	+
	61	+	# Build from a custom Dockerfile path
	62	+	gordon push myapp.example.com --build -f docker/app/Dockerfile
58	63		```
59	64
60	65		### Notes

 | Option | Description |
 |--------|-------------|
 | `--build` | Build the image first using `docker buildx` |
+| `-f, --file` | Path to Dockerfile (default: `./Dockerfile`, used with `--build`) |
 | `--platform` | Target platform for buildx (default: `linux/amd64`) |
 | `--build-arg` | Additional build args (repeatable, `KEY=VALUE`) |
 | `--tag` | Override version tag (default: `git describe --tags --abbrev=0`) |
 - The registry and repository are derived from the route image on the server.
 - The version tag defaults to the latest git tag. If no tag is found, `latest`
   is used.
-- When `--build` is set, the command uses `docker buildx build --push` and
+- When `--build` is set, the command builds with `docker buildx build --load`
-  injects `VERSION=<tag>` plus any `--build-arg` values.
+  and injects `VERSION=<tag>` plus any `--build-arg` values.
+- Use `-f/--file` to build from a Dockerfile outside the current directory root.
 - The version tag and `latest` are both pushed (unless the version is `latest`).
 ### Examples
 # Build for ARM and pass build args
 gordon push myapp.example.com --build --platform linux/arm64 --build-arg CGO_ENABLED=0
+# Build from a custom Dockerfile path
+gordon push myapp.example.com --build -f docker/app/Dockerfile
 ```
 ### Notes

M internal/adapters/in/cli/push.go +24 -14


@@ -18,12 +18,13 @@ import (
18	18
19	19		func newPushCmd() *cobra.Command {
20	20		var (
21		-	noDeploy bool
22		-	noConfirm bool
23		-	build bool
24		-	platform string
25		-	tag string
26		-	buildArgs []string
	21	+	noDeploy bool
	22	+	noConfirm bool
	23	+	build bool
	24	+	platform string
	25	+	tag string
	26	+	dockerfile string
	27	+	buildArgs []string
27	28		)
28	29
29	30		cmd := &cobra.Command{

@@ -41,7 +42,7 @@ Examples:
41	42		gordon push myapp.example.com --build --build-arg CGO_ENABLED=0 --remote ...`,
42	43		Args: cobra.ExactArgs(1),
43	44		RunE: func(cmd *cobra.Command, args []string) error {
44		-	return runPush(cmd.Context(), args[0], tag, build, platform, buildArgs, noDeploy, noConfirm)
	45	+	return runPush(cmd.Context(), args[0], tag, build, platform, dockerfile, buildArgs, noDeploy, noConfirm)
45	46		},
46	47		}
47	48

@@ -49,18 +50,26 @@ Examples:
49	50		cmd.Flags().BoolVar(&noConfirm, "no-confirm", false, "Skip deploy confirmation prompt")
50	51		cmd.Flags().BoolVar(&build, "build", false, "Build the image first using docker buildx")
51	52		cmd.Flags().StringVar(&platform, "platform", "linux/amd64", "Target platform (used with --build)")
	53	+	cmd.Flags().StringVarP(&dockerfile, "file", "f", "", "Path to Dockerfile (default: ./Dockerfile, used with --build)")
52	54		cmd.Flags().StringVar(&tag, "tag", "", "Override version tag (default: git describe)")
53	55		cmd.Flags().StringArrayVar(&buildArgs, "build-arg", nil, "Additional build args (used with --build)")
54	56
55	57		return cmd
56	58		}
57	59
58		-	func runPush(ctx context.Context, pushDomain, tag string, build bool, platform string, buildArgs []string, noDeploy bool, noConfirm bool) error {
	60	+	func runPush(ctx context.Context, pushDomain, tag string, build bool, platform string, dockerfile string, buildArgs []string, noDeploy bool, noConfirm bool) error {
59	61		client, isRemote := GetRemoteClient()
60	62		if !isRemote {
61	63		return fmt.Errorf("push requires remote mode")
62	64		}
63	65
	66	+	if dockerfile != "" && !build {
	67	+	return fmt.Errorf("--file can only be used with --build")
	68	+	}
	69	+	if dockerfile == "" {
	70	+	dockerfile = "Dockerfile"
	71	+	}
	72	+
64	73		route, err := client.GetRoute(ctx, pushDomain)
65	74		if err != nil {
66	75		return fmt.Errorf("failed to get route: %w", err)

@@ -93,7 +102,7 @@ func runPush(ctx context.Context, pushDomain, tag string, build bool, platform s
93	102		}
94	103
95	104		if build {
96		-	if err := buildAndPush(ctx, version, platform, buildArgs, versionRef, latestRef); err != nil {
	105	+	if err := buildAndPush(ctx, version, platform, dockerfile, buildArgs, versionRef, latestRef); err != nil {
97	106		return err
98	107		}
99	108		} else {

@@ -122,9 +131,9 @@ func determineVersion(ctx context.Context, tag string) string {
122	131		return version
123	132		}
124	133
125		-	func buildAndPush(ctx context.Context, version, platform string, buildArgs []string, versionRef, latestRef string) error {
126		-	if _, err := os.Stat("Dockerfile"); os.IsNotExist(err) {
127		-	return fmt.Errorf("no Dockerfile found in current directory")
	134	+	func buildAndPush(ctx context.Context, version, platform, dockerfile string, buildArgs []string, versionRef, latestRef string) error {
	135	+	if _, err := os.Stat(dockerfile); os.IsNotExist(err) {
	136	+	return fmt.Errorf("Dockerfile not found: %s", dockerfile)
128	137		}
129	138
130	139		// Build and load into local daemon (NOT --push).

@@ -132,7 +141,7 @@ func buildAndPush(ctx context.Context, version, platform string, buildArgs []str
132	141		// Cloudflare's 100MB per-request limit. Loading locally then
133	142		// using docker push gives us chunked uploads (~5MB per request).
134	143		fmt.Println("\nBuilding image...")
135		-	buildCmd := exec.CommandContext(ctx, "docker", buildImageArgs(version, platform, buildArgs, versionRef, latestRef)...) // #nosec G204
	144	+	buildCmd := exec.CommandContext(ctx, "docker", buildImageArgs(version, platform, dockerfile, buildArgs, versionRef, latestRef)...) // #nosec G204
136	145		buildCmd.Stdout = os.Stdout
137	146		buildCmd.Stderr = os.Stderr
138	147		if err := buildCmd.Run(); err != nil {

@@ -155,10 +164,11 @@ func buildAndPush(ctx context.Context, version, platform string, buildArgs []str
155	164		// buildImageArgs constructs the docker buildx build arguments.
156	165		// Uses --load instead of --push so the image is loaded into the local
157	166		// daemon, allowing docker push to handle the upload with chunked requests.
158		-	func buildImageArgs(version, platform string, buildArgs []string, versionRef, latestRef string) []string {
	167	+	func buildImageArgs(version, platform, dockerfile string, buildArgs []string, versionRef, latestRef string) []string {
159	168		args := []string{
160	169		"buildx", "build",
161	170		"--platform", platform,
	171	+	"-f", dockerfile,
162	172		"-t", latestRef,
163	173		"--build-arg", "VERSION=" + version,
164	174		}

 func newPushCmd() *cobra.Command {
 	var (
-		noDeploy  bool
+		noDeploy   bool
-		noConfirm bool
+		noConfirm  bool
-		build     bool
+		build      bool
-		platform  string
+		platform   string
-		tag       string
+		tag        string
-		buildArgs []string
+		dockerfile string
+		buildArgs  []string
 	)
 	cmd := &cobra.Command{
   gordon push myapp.example.com --build --build-arg CGO_ENABLED=0 --remote ...`,
 		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runPush(cmd.Context(), args[0], tag, build, platform, buildArgs, noDeploy, noConfirm)
+			return runPush(cmd.Context(), args[0], tag, build, platform, dockerfile, buildArgs, noDeploy, noConfirm)
 		},
 	}
 	cmd.Flags().BoolVar(&noConfirm, "no-confirm", false, "Skip deploy confirmation prompt")
 	cmd.Flags().BoolVar(&build, "build", false, "Build the image first using docker buildx")
 	cmd.Flags().StringVar(&platform, "platform", "linux/amd64", "Target platform (used with --build)")
+	cmd.Flags().StringVarP(&dockerfile, "file", "f", "", "Path to Dockerfile (default: ./Dockerfile, used with --build)")
 	cmd.Flags().StringVar(&tag, "tag", "", "Override version tag (default: git describe)")
 	cmd.Flags().StringArrayVar(&buildArgs, "build-arg", nil, "Additional build args (used with --build)")
 	return cmd
 }
-func runPush(ctx context.Context, pushDomain, tag string, build bool, platform string, buildArgs []string, noDeploy bool, noConfirm bool) error {
+func runPush(ctx context.Context, pushDomain, tag string, build bool, platform string, dockerfile string, buildArgs []string, noDeploy bool, noConfirm bool) error {
 	client, isRemote := GetRemoteClient()
 	if !isRemote {
 		return fmt.Errorf("push requires remote mode")
 	}
+	if dockerfile != "" && !build {
+		return fmt.Errorf("--file can only be used with --build")
+	}
+	if dockerfile == "" {
+		dockerfile = "Dockerfile"
+	}
 	route, err := client.GetRoute(ctx, pushDomain)
 	if err != nil {
 		return fmt.Errorf("failed to get route: %w", err)
 	}
 	if build {
-		if err := buildAndPush(ctx, version, platform, buildArgs, versionRef, latestRef); err != nil {
+		if err := buildAndPush(ctx, version, platform, dockerfile, buildArgs, versionRef, latestRef); err != nil {
 			return err
 		}
 	} else {
 	return version
 }
-func buildAndPush(ctx context.Context, version, platform string, buildArgs []string, versionRef, latestRef string) error {
+func buildAndPush(ctx context.Context, version, platform, dockerfile string, buildArgs []string, versionRef, latestRef string) error {
-	if _, err := os.Stat("Dockerfile"); os.IsNotExist(err) {
+	if _, err := os.Stat(dockerfile); os.IsNotExist(err) {
-		return fmt.Errorf("no Dockerfile found in current directory")
+		return fmt.Errorf("Dockerfile not found: %s", dockerfile)
 	}
 	// Build and load into local daemon (NOT --push).
 	// Cloudflare's 100MB per-request limit. Loading locally then
 	// using docker push gives us chunked uploads (~5MB per request).
 	fmt.Println("\nBuilding image...")
-	buildCmd := exec.CommandContext(ctx, "docker", buildImageArgs(version, platform, buildArgs, versionRef, latestRef)...) // #nosec G204
+	buildCmd := exec.CommandContext(ctx, "docker", buildImageArgs(version, platform, dockerfile, buildArgs, versionRef, latestRef)...) // #nosec G204
 	buildCmd.Stdout = os.Stdout
 	buildCmd.Stderr = os.Stderr
 	if err := buildCmd.Run(); err != nil {
 // buildImageArgs constructs the docker buildx build arguments.
 // Uses --load instead of --push so the image is loaded into the local
 // daemon, allowing docker push to handle the upload with chunked requests.
-func buildImageArgs(version, platform string, buildArgs []string, versionRef, latestRef string) []string {
+func buildImageArgs(version, platform, dockerfile string, buildArgs []string, versionRef, latestRef string) []string {
 	args := []string{
 		"buildx", "build",
 		"--platform", platform,
+		"-f", dockerfile,
 		"-t", latestRef,
 		"--build-arg", "VERSION=" + version,
 	}

M internal/adapters/in/cli/push_test.go +10 -1


@@ -63,9 +63,18 @@ func TestParseImageRef(t *testing.T) {
63	63
64	64		func TestBuildAndPush_BuildArgs(t *testing.T) {
65	65		// Verify buildImageArgs produces --load instead of --push
66		-	args := buildImageArgs("v1.0.0", "linux/amd64", []string{"CGO_ENABLED=0"}, "reg.example.com/app:v1.0.0", "reg.example.com/app:latest")
	66	+	args := buildImageArgs("v1.0.0", "linux/amd64", "Dockerfile", []string{"CGO_ENABLED=0"}, "reg.example.com/app:v1.0.0", "reg.example.com/app:latest")
67	67
68	68		assert.Contains(t, args, "--load")
69	69		assert.NotContains(t, args, "--push")
70	70		assert.Contains(t, args, "--platform")
	71	+	assert.Contains(t, args, "-f")
	72	+	assert.Contains(t, args, "Dockerfile")
	73	+	}
	74	+
	75	+	func TestBuildImageArgs_CustomDockerfile(t *testing.T) {
	76	+	args := buildImageArgs("v1.0.0", "linux/amd64", "docker/app/Dockerfile", nil, "reg.example.com/app:v1.0.0", "reg.example.com/app:latest")
	77	+
	78	+	assert.Contains(t, args, "-f")
	79	+	assert.Contains(t, args, "docker/app/Dockerfile")
71	80		}

 func TestBuildAndPush_BuildArgs(t *testing.T) {
 	// Verify buildImageArgs produces --load instead of --push
-	args := buildImageArgs("v1.0.0", "linux/amd64", []string{"CGO_ENABLED=0"}, "reg.example.com/app:v1.0.0", "reg.example.com/app:latest")
+	args := buildImageArgs("v1.0.0", "linux/amd64", "Dockerfile", []string{"CGO_ENABLED=0"}, "reg.example.com/app:v1.0.0", "reg.example.com/app:latest")
 	assert.Contains(t, args, "--load")
 	assert.NotContains(t, args, "--push")
 	assert.Contains(t, args, "--platform")
+	assert.Contains(t, args, "-f")
+	assert.Contains(t, args, "Dockerfile")
+}
+func TestBuildImageArgs_CustomDockerfile(t *testing.T) {
+	args := buildImageArgs("v1.0.0", "linux/amd64", "docker/app/Dockerfile", nil, "reg.example.com/app:v1.0.0", "reg.example.com/app:latest")
+	assert.Contains(t, args, "-f")
+	assert.Contains(t, args, "docker/app/Dockerfile")
 }