Add namespace proto and registration

agent/consul/type_registry.go

@@ -9,6 +9,7 @@ import (
 	"github.com/hashicorp/consul/internal/mesh"
 	"github.com/hashicorp/consul/internal/resource"
 	"github.com/hashicorp/consul/internal/resource/demo"
+	"github.com/hashicorp/consul/internal/tenancy"
 )
 
 // NewTypeRegistry returns a registry populated with all supported resource
@@ -25,6 +26,7 @@ func NewTypeRegistry() resource.Registry {
 	mesh.RegisterTypes(registry)
 	catalog.RegisterTypes(registry)
 	auth.RegisterTypes(registry)
+	tenancy.RegisterTypes(registry)
 
 	return registry
 }

internal/tenancy/exports.go

@@ -0,0 +1,28 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package tenancy
+
+import (
+	"github.com/hashicorp/consul/internal/resource"
+	"github.com/hashicorp/consul/internal/tenancy/internal/types"
+)
+
+var (
+	// API Group Information
+
+	APIGroup        = types.GroupName
+	VersionV1Alpha1 = types.VersionV1Alpha1
+	CurrentVersion  = types.CurrentVersion
+
+	// Resource Kind Names.
+
+	NamespaceKind         = types.NamespaceKind
+	NamespaceV1Alpha1Type = types.NamespaceV1Alpha1Type
+)
+
+// RegisterTypes adds all resource types within the "catalog" API group
+// to the given type registry
+func RegisterTypes(r resource.Registry) {
+	types.Register(r)
+}

internal/tenancy/internal/types/errors.go

@@ -0,0 +1,11 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package types
+
+import "errors"
+
+var (
+	errInvalidName   = errors.New("invalid namespace name provided")
+	errOwnerNonEmpty = errors.New("namespace should not have an owner")
+)

internal/tenancy/internal/types/namespace.go

@@ -0,0 +1,61 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package types
+
+import (
+	"github.com/go-openapi/strfmt"
+	"github.com/hashicorp/consul/internal/resource"
+	"github.com/hashicorp/consul/proto-public/pbresource"
+	tenancyv1alpha1 "github.com/hashicorp/consul/proto-public/pbtenancy/v1alpha1"
+	"strings"
+)
+
+const (
+	NamespaceKind = "Namespace"
+)
+
+var (
+	NamespaceV1Alpha1Type = &pbresource.Type{
+		Group:        GroupName,
+		GroupVersion: VersionV1Alpha1,
+		Kind:         NamespaceKind,
+	}
+
+	TrafficPermissionsType = NamespaceV1Alpha1Type
+)
+
+func RegisterNamespace(r resource.Registry) {
+	r.Register(resource.Registration{
+		Type:     NamespaceV1Alpha1Type,
+		Proto:    &tenancyv1alpha1.Namespace{},
+		Scope:    resource.ScopePartition,
+		Validate: ValidateNamespace,
+		Mutate:   MutateNamespace,
+	})
+}
+
+func MutateNamespace(res *pbresource.Resource) error {
+	res.Id.Name = strings.ToLower(res.Id.Name)
+	return nil
+}
+
+func ValidateNamespace(res *pbresource.Resource) error {
+	var ns tenancyv1alpha1.Namespace
+
+	if err := res.Data.UnmarshalTo(&ns); err != nil {
+		return resource.NewErrDataParse(&ns, err)
+	}
+	if res.Owner != nil {
+		return errInvalidName
+	}
+
+	if res.Id.Name == resource.DefaultNamespacedTenancy().Namespace {
+		return errInvalidName
+	}
+
+	if ok := strfmt.IsHostname(res.Id.Name); !ok {
+		return errInvalidName
+	}
+	return nil
+}

internal/tenancy/internal/types/namespace_test.go

@@ -0,0 +1,98 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package types
+
+import (
+	"github.com/hashicorp/consul/internal/resource"
+	pbcatalog "github.com/hashicorp/consul/proto-public/pbcatalog/v1alpha1"
+	"github.com/hashicorp/consul/proto-public/pbresource"
+	tenancyv1alpha1 "github.com/hashicorp/consul/proto-public/pbtenancy/v1alpha1"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/types/known/anypb"
+	"testing"
+)
+
+func createNamespaceResource(t *testing.T, data protoreflect.ProtoMessage) *pbresource.Resource {
+	res := &pbresource.Resource{
+		Id: &pbresource.ID{
+			Type: NamespaceV1Alpha1Type,
+			Tenancy: &pbresource.Tenancy{
+				Partition: "default",
+				Namespace: "",
+				PeerName:  "local",
+			},
+			Name: "ns1234",
+		},
+	}
+
+	var err error
+	res.Data, err = anypb.New(data)
+	require.NoError(t, err)
+	return res
+}
+
+func validNamespace() *tenancyv1alpha1.Namespace {
+	return &tenancyv1alpha1.Namespace{
+		Description: "description from user",
+	}
+}
+
+func TestValidateNamespace_Ok(t *testing.T) {
+	res := createNamespaceResource(t, validNamespace())
+
+	err := ValidateNamespace(res)
+	require.NoError(t, err)
+}
+
+func TestValidateNamespace_defaultNamespace(t *testing.T) {
+	res := createNamespaceResource(t, validNamespace())
+	res.Id.Name = resource.DefaultNamespacedTenancy().Namespace
+
+	err := ValidateNamespace(res)
+	require.Error(t, err)
+	require.ErrorAs(t, err, &errInvalidName)
+}
+
+func TestValidateNamespace_InvalidName(t *testing.T) {
+	res := createNamespaceResource(t, validNamespace())
+	res.Id.Name = "-invalid"
+
+	err := ValidateNamespace(res)
+	require.Error(t, err)
+	require.ErrorAs(t, err, &errInvalidName)
+}
+
+func TestValidateNamespace_ParseError(t *testing.T) {
+	// Any type other than the Workload type would work
+	// to cause the error we are expecting
+	data := &pbcatalog.IP{Address: "198.18.0.1"}
+
+	res := createNamespaceResource(t, data)
+
+	err := ValidateNamespace(res)
+	require.Error(t, err)
+	require.ErrorAs(t, err, &resource.ErrDataParse{})
+}
+
+func TestMutateNamespace(t *testing.T) {
+	tests := []struct {
+		name          string
+		namespaceName string
+		expectedName  string
+	}{
+		{"lower", "lower", "lower"},
+		{"mixed", "MiXeD", "mixed"},
+		{"upper", "UPPER", "upper"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			res := &pbresource.Resource{Id: &pbresource.ID{Name: tt.namespaceName}}
+			if err := MutateNamespace(res); err != nil {
+				t.Errorf("MutateNamespace() error = %v", err)
+			}
+			require.Equal(t, res.Id.Name, tt.expectedName)
+		})
+	}
+}

internal/tenancy/internal/types/types.go

@@ -0,0 +1,18 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package types
+
+import (
+	"github.com/hashicorp/consul/internal/resource"
+)
+
+const (
+	GroupName       = "tenancy"
+	VersionV1Alpha1 = "v1alpha1"
+	CurrentVersion  = VersionV1Alpha1
+)
+
+func Register(r resource.Registry) {
+	RegisterNamespace(r)
+}