Add namespace validation to catch invalid names before build/deploy

Signed-off-by: RayyanSeliya <rayyanseliya786@gmail.com>

Author: RayyanSeliya

cmd/deploy.go

@@ -20,6 +20,7 @@ import (
 	"knative.dev/func/pkg/config"
 	fn "knative.dev/func/pkg/functions"
 	"knative.dev/func/pkg/k8s"
+	"knative.dev/func/pkg/utils"
 )
 
 func NewDeployCmd(newClient ClientFactory) *cobra.Command {
@@ -280,6 +281,20 @@ func runDeploy(cmd *cobra.Command, newClient ClientFactory) (err error) {
 	}
 	if err = cfg.Validate(cmd); err != nil {
 		// Layer 2: Catch technical errors and provide CLI-specific user-friendly messages
+		if errors.Is(err, fn.ErrInvalidNamespace) {
+			return fmt.Errorf(`%w
+
+Invalid namespace name. Kubernetes namespaces must:
+  - Contain only lowercase letters, numbers, and hyphens (-)
+  - Start and end with a letter or number
+  - Be 63 characters or less
+
+Valid examples:
+  func deploy --namespace myapp
+  func deploy --namespace my-app-123
+
+For more options, run 'func deploy --help'`, err)
+		}
 		if errors.Is(err, fn.ErrConflictingImageAndRegistry) {
 			return fmt.Errorf(`%w
 
@@ -738,6 +753,14 @@ func (c deployConfig) Validate(cmd *cobra.Command) (err error) {
 		return
 	}
 
+	// Validate namespace format if provided
+	if c.Namespace != "" {
+		if err = utils.ValidateNamespace(c.Namespace); err != nil {
+			// Wrap the validation error as fn.ErrInvalidNamespace for layer consistency
+			return fn.ErrInvalidNamespace
+		}
+	}
+
 	// Check Image Digest was included
 	var digest bool
 	if c.Image != "" {

pkg/functions/errors.go

@@ -34,6 +34,9 @@ var (
 
 	// ErrConflictingImageAndRegistry is returned when both --image and --registry flags are explicitly provided
 	ErrConflictingImageAndRegistry = errors.New("both --image and --registry flags provided")
+
+	// ErrInvalidNamespace is returned when a namespace name doesn't meet Kubernetes naming requirements
+	ErrInvalidNamespace = errors.New("invalid namespace")
 )
 
 // ErrNotInitialized indicates that a function is uninitialized

pkg/utils/names.go

@@ -23,6 +23,9 @@ type ErrInvalidSecretKey error
 // ErrInvalidLabel indicates the name did not pass label key validation, or the value did not pass label value validation.
 type ErrInvalidLabel error
 
+// ErrInvalidNamespace indicates the namespace name did not pass Kubernetes namespace validation.
+type ErrInvalidNamespace error
+
 // ValidateFunctionName validates that the input name is a valid function name, ie. valid DNS-1035 label.
 // It must consist of lower case alphanumeric characters or '-' and start with an alphabetic character and end with an alphanumeric character.
 // (e.g. 'my-name',  or 'abc-1', regex used for validation is '[a-z]([-a-z0-9]*[a-z0-9])?')
@@ -102,3 +105,17 @@ func ValidateLabelValue(value string) error {
 	}
 	return nil
 }
+
+// ValidateNamespace validates that the input name is a valid Kubernetes namespace name, ie. valid DNS-1123 label.
+// It must consist of lower case alphanumeric characters or '-',
+// and must start and end with an alphanumeric character
+// (e.g. 'my-namespace', 'abc-123', regex used for validation is '[a-z0-9]([-a-z0-9]*[a-z0-9])?')
+func ValidateNamespace(namespace string) error {
+	if errs := validation.IsDNS1123Label(namespace); len(errs) > 0 {
+		// Reuse the error message from Kubernetes validation
+		// Replace "a DNS-1123 label" with more user-friendly context
+		errMsg := strings.Replace(strings.Join(errs, ""), "a DNS-1123 label", fmt.Sprintf("Namespace '%v'", namespace), 1)
+		return ErrInvalidNamespace(errors.New(errMsg))
+	}
+	return nil
+}

pkg/utils/names_test.go

@@ -209,3 +209,68 @@ func TestValidateLabelValue(t *testing.T) {
 		}
 	}
 }
+
+// TestValidateNamespace tests that only correct Kubernetes namespace names are accepted
+func TestValidateNamespace(t *testing.T) {
+	cases := []struct {
+		In    string
+		Valid bool
+	}{
+		// Valid namespaces
+		{"default", true},
+		{"kube-system", true},
+		{"my-namespace", true},
+		{"myapp", true},
+		{"my-app-123", true},
+		{"prod", true},
+		{"test-123", true},
+		{"a", true},
+		{"a-b", true},
+		{"abc-123-xyz", true},
+
+		// Invalid namespaces
+		{"", false},                  // empty
+		{"My-App", false},            // uppercase not allowed
+		{"MY-APP", false},            // uppercase not allowed
+		{"123app", false},            // cannot start with number
+		{"123invalid", false},        // cannot start with number
+		{"my_app", false},            // underscore not allowed
+		{"my app", false},            // spaces not allowed
+		{"invalid namespace", false}, // spaces not allowed
+		{"my@app", false},            // @ not allowed
+		{"invalid@namespace", false}, // @ not allowed
+		{"-myapp", false},            // cannot start with hyphen
+		{"myapp-", false},            // cannot end with hyphen
+		{"my..app", false},           // dots not allowed
+		{"my/app", false},            // slash not allowed
+		{"my:app", false},            // colon not allowed
+		{"my;app", false},            // semicolon not allowed
+		{"my,app", false},            // comma not allowed
+		{"my*app", false},            // asterisk not allowed
+		{"my!app", false},            // exclamation not allowed
+	}
+
+	for _, c := range cases {
+		err := ValidateNamespace(c.In)
+		if err != nil && c.Valid {
+			t.Fatalf("Unexpected error for valid namespace: %v, namespace: '%v'", err, c.In)
+		}
+		if err == nil && !c.Valid {
+			t.Fatalf("Expected error for invalid namespace: '%v'", c.In)
+		}
+	}
+}
+
+func TestValidateNamespaceErrMsg(t *testing.T) {
+	invalidNamespace := "123invalid"
+	errMsgPrefix := fmt.Sprintf("Namespace '%v'", invalidNamespace)
+
+	err := ValidateNamespace(invalidNamespace)
+	if err != nil {
+		if !strings.HasPrefix(err.Error(), errMsgPrefix) {
+			t.Fatalf("Unexpected error message: %v, the message should start with '%v' string", err.Error(), errMsgPrefix)
+		}
+	} else {
+		t.Fatalf("Expected error for invalid namespace: %v", invalidNamespace)
+	}
+}