fix(cli) reduce fallback and push cyclomatic complexity and fix lint errors

commit: 28e7d52a964508a816b4f4bd05ccd2089ff521bb
author: bnema · 8mo ago · 2026-02-06 20:42 UTC
parent: 7b5ce70
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

2 files · +51 -31

M internal/adapters/in/cli/fallback.go +30 -23


@@ -2,35 +2,42 @@ package cli
2	2
3	3		import "strings"
4	4
5		-	func shouldFallbackToLocal(err error) bool {
6		-	if err == nil {
7		-	return false
	5	+	var (
	6	+	fallbackNetworkErrors = []string{
	7	+	"connection refused",
	8	+	"no such host",
	9	+	"i/o timeout",
	10	+	"timeout",
8	11		}
9		-	msg := strings.ToLower(err.Error())
10	12
11		-	// Retry local signal mode when remote API is unavailable or misrouted.
12		-	if strings.Contains(msg, "connection refused") \|\|
13		-	strings.Contains(msg, "no such host") \|\|
14		-	strings.Contains(msg, "i/o timeout") \|\|
15		-	strings.Contains(msg, "timeout") {
16		-	return true
	13	+	fallbackStatusCodes = []string{
	14	+	"500", "501", "502", "503", "504", "505",
17	15		}
18	16
19		-	if strings.Contains(msg, "500") \|\|
20		-	strings.Contains(msg, "501") \|\|
21		-	strings.Contains(msg, "502") \|\|
22		-	strings.Contains(msg, "503") \|\|
23		-	strings.Contains(msg, "504") \|\|
24		-	strings.Contains(msg, "505") {
25		-	return true
	17	+	fallbackGatewayErrors = []string{
	18	+	"internal server error",
	19	+	"service unavailable",
	20	+	"bad gateway",
	21	+	"gateway timeout",
26	22		}
	23	+	)
27	24
28		-	if strings.Contains(msg, "internal server error") \|\|
29		-	strings.Contains(msg, "service unavailable") \|\|
30		-	strings.Contains(msg, "bad gateway") \|\|
31		-	strings.Contains(msg, "gateway timeout") {
32		-	return true
	25	+	func containsAny(s string, patterns []string) bool {
	26	+	for _, p := range patterns {
	27	+	if strings.Contains(s, p) {
	28	+	return true
	29	+	}
33	30		}
34		-
35	31		return false
36	32		}
	33	+
	34	+	func shouldFallbackToLocal(err error) bool {
	35	+	if err == nil {
	36	+	return false
	37	+	}
	38	+	msg := strings.ToLower(err.Error())
	39	+
	40	+	return containsAny(msg, fallbackNetworkErrors) \|\|
	41	+	containsAny(msg, fallbackStatusCodes) \|\|
	42	+	containsAny(msg, fallbackGatewayErrors)
	43	+	}

 import "strings"
-func shouldFallbackToLocal(err error) bool {
+var (
-	if err == nil {
+	fallbackNetworkErrors = []string{
-		return false
+		"connection refused",
+		"no such host",
+		"i/o timeout",
+		"timeout",
 	}
-	msg := strings.ToLower(err.Error())
-	// Retry local signal mode when remote API is unavailable or misrouted.
+	fallbackStatusCodes = []string{
-	if strings.Contains(msg, "connection refused") ||
+		"500", "501", "502", "503", "504", "505",
-		strings.Contains(msg, "no such host") ||
-		strings.Contains(msg, "i/o timeout") ||
-		strings.Contains(msg, "timeout") {
-		return true
 	}
-	if strings.Contains(msg, "500") ||
+	fallbackGatewayErrors = []string{
-		strings.Contains(msg, "501") ||
+		"internal server error",
-		strings.Contains(msg, "502") ||
+		"service unavailable",
-		strings.Contains(msg, "503") ||
+		"bad gateway",
-		strings.Contains(msg, "504") ||
+		"gateway timeout",
-		strings.Contains(msg, "505") {
-		return true
 	}
+)
-	if strings.Contains(msg, "internal server error") ||
+func containsAny(s string, patterns []string) bool {
-		strings.Contains(msg, "service unavailable") ||
+	for _, p := range patterns {
-		strings.Contains(msg, "bad gateway") ||
+		if strings.Contains(s, p) {
-		strings.Contains(msg, "gateway timeout") {
+			return true
-		return true
+		}
 	}
 	return false
 }
+func shouldFallbackToLocal(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := strings.ToLower(err.Error())
+	return containsAny(msg, fallbackNetworkErrors) ||
+		containsAny(msg, fallbackStatusCodes) ||
+		containsAny(msg, fallbackGatewayErrors)
+}

M internal/adapters/in/cli/push.go +21 -8


@@ -57,17 +57,31 @@ Examples:
57	57		return cmd
58	58		}
59	59
	60	+	func resolveDockerfile(dockerfile string, build bool) (string, error) {
	61	+	if dockerfile != "" && !build {
	62	+	return "", fmt.Errorf("--file can only be used with --build")
	63	+	}
	64	+	if dockerfile == "" {
	65	+	return "Dockerfile", nil
	66	+	}
	67	+	return dockerfile, nil
	68	+	}
	69	+
	70	+	func resolveImageRefs(registry, imageName, version string) (versionRef, latestRef string) {
	71	+	versionRef = fmt.Sprintf("%s/%s:%s", registry, imageName, version)
	72	+	latestRef = fmt.Sprintf("%s/%s:latest", registry, imageName)
	73	+	return versionRef, latestRef
	74	+	}
	75	+
60	76		func runPush(ctx context.Context, pushDomain, tag string, build bool, platform string, dockerfile string, buildArgs []string, noDeploy bool, noConfirm bool) error {
61	77		client, isRemote := GetRemoteClient()
62	78		if !isRemote {
63	79		return fmt.Errorf("push requires remote mode")
64	80		}
65	81
66		-	if dockerfile != "" && !build {
67		-	return fmt.Errorf("--file can only be used with --build")
68		-	}
69		-	if dockerfile == "" {
70		-	dockerfile = "Dockerfile"
	82	+	dockerfile, err := resolveDockerfile(dockerfile, build)
	83	+	if err != nil {
	84	+	return err
71	85		}
72	86
73	87		route, err := client.GetRoute(ctx, pushDomain)

@@ -93,8 +107,7 @@ func runPush(ctx context.Context, pushDomain, tag string, build bool, platform s
93	107		}
94	108		}
95	109
96		-	versionRef := fmt.Sprintf("%s/%s:%s", registry, imageName, version)
97		-	latestRef := fmt.Sprintf("%s/%s:latest", registry, imageName)
	110	+	versionRef, latestRef := resolveImageRefs(registry, imageName, version)
98	111
99	112		fmt.Printf("Image: %s\n", styles.Theme.Bold.Render(versionRef))
100	113		if version != "latest" {

@@ -133,7 +146,7 @@ func determineVersion(ctx context.Context, tag string) string {
133	146
134	147		func buildAndPush(ctx context.Context, version, platform, dockerfile string, buildArgs []string, versionRef, latestRef string) error {
135	148		if _, err := os.Stat(dockerfile); os.IsNotExist(err) {
136		-	return fmt.Errorf("Dockerfile not found: %s", dockerfile)
	149	+	return fmt.Errorf("dockerfile not found: %s", dockerfile)
137	150		}
138	151
139	152		// Build and load into local daemon (NOT --push).

 	return cmd
 }
+func resolveDockerfile(dockerfile string, build bool) (string, error) {
+	if dockerfile != "" && !build {
+		return "", fmt.Errorf("--file can only be used with --build")
+	}
+	if dockerfile == "" {
+		return "Dockerfile", nil
+	}
+	return dockerfile, nil
+}
+func resolveImageRefs(registry, imageName, version string) (versionRef, latestRef string) {
+	versionRef = fmt.Sprintf("%s/%s:%s", registry, imageName, version)
+	latestRef = fmt.Sprintf("%s/%s:latest", registry, imageName)
+	return versionRef, latestRef
+}
 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 {
+	dockerfile, err := resolveDockerfile(dockerfile, build)
-		return fmt.Errorf("--file can only be used with --build")
+	if err != nil {
-	}
+		return err
-	if dockerfile == "" {
-		dockerfile = "Dockerfile"
 	}
 	route, err := client.GetRoute(ctx, pushDomain)
 		}
 	}
-	versionRef := fmt.Sprintf("%s/%s:%s", registry, imageName, version)
+	versionRef, latestRef := resolveImageRefs(registry, imageName, version)
-	latestRef := fmt.Sprintf("%s/%s:latest", registry, imageName)
 	fmt.Printf("Image: %s\n", styles.Theme.Bold.Render(versionRef))
 	if version != "latest" {
 func buildAndPush(ctx context.Context, version, platform, dockerfile string, buildArgs []string, versionRef, latestRef string) error {
 	if _, err := os.Stat(dockerfile); os.IsNotExist(err) {
-		return fmt.Errorf("Dockerfile not found: %s", dockerfile)
+		return fmt.Errorf("dockerfile not found: %s", dockerfile)
 	}
 	// Build and load into local daemon (NOT --push).