refactor: domains is now API utils

api/utils/allowed.go

@@ -0,0 +1,9 @@
+// Copyright 2020-2021 Clastix Labs
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+type AllowedList interface {
+	ExactMatch(value string) bool
+	RegexMatch(value string) bool
+}

api/utils/imagepullpolicy.go

@@ -0,0 +1,51 @@
+// Copyright 2020-2021 Clastix Labs
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+import (
+	"strings"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	podAllowedImagePullPolicyAnnotation = "capsule.clastix.io/allowed-image-pull-policy"
+)
+
+type ImagePullPolicy interface {
+	IsPolicySupported(policy string) bool
+	AllowedPullPolicies() []string
+}
+
+type imagePullPolicyValidator struct {
+	allowedPolicies []string
+}
+
+func (i imagePullPolicyValidator) IsPolicySupported(policy string) bool {
+	for _, allowed := range i.allowedPolicies {
+		if strings.EqualFold(allowed, policy) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (i imagePullPolicyValidator) AllowedPullPolicies() []string {
+	return i.allowedPolicies
+}
+
+func NewImagePullPolicy(object metav1.Object) ImagePullPolicy {
+	annotations := object.GetAnnotations()
+
+	v, ok := annotations[podAllowedImagePullPolicyAnnotation]
+	// the Tenant doesn't enforce the allowed image pull policy, returning nil
+	if !ok {
+		return nil
+	}
+
+	return &imagePullPolicyValidator{
+		allowedPolicies: strings.Split(v, ","),
+	}
+}

api/utils/podpriority.go

@@ -0,0 +1,38 @@
+// Copyright 2020-2021 Clastix Labs
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+import (
+	"regexp"
+	"strings"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/clastix/capsule/api/v1alpha1"
+)
+
+const (
+	podPriorityAllowedAnnotation      = "priorityclass.capsule.clastix.io/allowed"
+	podPriorityAllowedRegexAnnotation = "priorityclass.capsule.clastix.io/allowed-regex"
+)
+
+func NewPodPriority(object metav1.Object) (allowed *v1alpha1.AllowedListSpec) {
+	annotations := object.GetAnnotations()
+
+	if v, ok := annotations[podPriorityAllowedAnnotation]; ok {
+		allowed = &v1alpha1.AllowedListSpec{}
+		allowed.Exact = strings.Split(v, ",")
+	}
+
+	if v, ok := annotations[podPriorityAllowedRegexAnnotation]; ok {
+		if _, err := regexp.Compile(v); err == nil {
+			if allowed == nil {
+				allowed = &v1alpha1.AllowedListSpec{}
+			}
+			allowed.Regex = v
+		}
+	}
+
+	return
+}

api/utils/registry.go

@@ -0,0 +1,72 @@
+// Copyright 2020-2021 Clastix Labs
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+import (
+	"regexp"
+)
+
+const defaultRegistryName = "docker.io"
+
+type registry map[string]string
+
+func (r registry) Registry() string {
+	res, ok := r["registry"]
+	if !ok {
+		return ""
+	}
+	if len(res) == 0 {
+		return defaultRegistryName
+	}
+	return res
+}
+
+func (r registry) Repository() string {
+	res, ok := r["repository"]
+	if !ok {
+		return ""
+	}
+	if res == defaultRegistryName {
+		return ""
+	}
+	return res
+}
+
+func (r registry) Image() string {
+	res, ok := r["image"]
+	if !ok {
+		return ""
+	}
+	return res
+}
+
+func (r registry) Tag() string {
+	res, ok := r["tag"]
+	if !ok {
+		return ""
+	}
+	if len(res) == 0 {
+		res = "latest"
+	}
+	return res
+}
+
+func NewRegistry(value string) Registry {
+	reg := make(registry)
+	r := regexp.MustCompile(`(((?P<registry>[a-zA-Z0-9-.]+)\/)?((?P<repository>[a-zA-Z0-9-.]+)\/))?(?P<image>[a-zA-Z0-9-.]+)(:(?P<tag>[a-zA-Z0-9-.]+))?`)
+	match := r.FindStringSubmatch(value)
+	for i, name := range r.SubexpNames() {
+		if i > 0 && i <= len(match) {
+			reg[name] = match[i]
+		}
+	}
+	return reg
+}
+
+type Registry interface {
+	Registry() string
+	Repository() string
+	Image() string
+	Tag() string
+}

api/utils/registry_test.go

@@ -0,0 +1,65 @@
+// Copyright 2020-2021 Clastix Labs
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewRegistry(t *testing.T) {
+	type tc struct {
+		registry string
+		repo     string
+		image    string
+		tag      string
+	}
+	for name, tc := range map[string]tc{
+		"docker.io/my-org/my-repo:v0.0.1": {
+			registry: "docker.io",
+			repo:     "my-org",
+			image:    "my-repo",
+			tag:      "v0.0.1",
+		},
+		"unnamed/repository:1.2.3": {
+			registry: "docker.io",
+			repo:     "unnamed",
+			image:    "repository",
+			tag:      "1.2.3",
+		},
+		"quay.io/clastix/capsule:v1.0.0": {
+			registry: "quay.io",
+			repo:     "clastix",
+			image:    "capsule",
+			tag:      "v1.0.0",
+		},
+		"docker.io/redis:alpine": {
+			registry: "docker.io",
+			repo:     "",
+			image:    "redis",
+			tag:      "alpine",
+		},
+		"nginx:alpine": {
+			registry: "docker.io",
+			repo:     "",
+			image:    "nginx",
+			tag:      "alpine",
+		},
+		"nginx": {
+			registry: "docker.io",
+			repo:     "",
+			image:    "nginx",
+			tag:      "latest",
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			r := NewRegistry(name)
+			assert.Equal(t, tc.registry, r.Registry())
+			assert.Equal(t, tc.repo, r.Repository())
+			assert.Equal(t, tc.image, r.Image())
+			assert.Equal(t, tc.tag, r.Tag())
+		})
+	}
+}