feat: support URLs and just hosts

pkg/condition/condition.go

@@ -0,0 +1,78 @@
+package condition
+
+import (
+	"github.com/go-logr/logr"
+	"github.com/opendatahub-io/odh-platform/controllers/authorization"
+	"github.com/opendatahub-io/odh-platform/pkg/spi"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+)
+
+/*
+
+	# Initial
+
+	* Load Config
+	* Register Conditional pr GAV pr Capability
+	* Start
+
+	# Update
+
+	* Load Config
+	* Register Conditional pr GAV pr Capability
+		* If existing but changed; kill to reload everything
+		* If removed?; kill to reload everything
+		* If exisitng but not changed; all ready running?
+		* If new, just add to start
+
+
+*/
+
+type When func() bool
+type Do func() error
+type Conditional func() (When, Do)
+
+type ConditionalEngine struct {
+	conditions []Conditional
+}
+
+func (c *ConditionalEngine) Add(condition Conditional) {
+	c.conditions = append(c.conditions, condition)
+}
+
+func (c *ConditionalEngine) Start() {
+
+	/*
+		for i, con := range c.conditions {
+			if con.When() {
+				con.Do()
+				// remove con
+			}
+		}
+		if len(c.conditions) > 0 {
+			Sleep(500)
+			c.Start()
+		}
+	*/
+
+}
+
+func Authorization(mgr manager.Manager, log logr.Logger, component spi.AuthorizationComponent) Conditional {
+	return func() (When, Do) {
+		return WhenGAVExists(mgr.GetClient(), component),
+			DoSetupAuthorization(mgr, log, component)
+	}
+}
+
+func WhenGAVExists(cli client.Client, component spi.AuthorizationComponent) When {
+	return func() bool {
+		return false // TODO: check CRD
+	}
+}
+
+func DoSetupAuthorization(mgr manager.Manager, log logr.Logger, component spi.AuthorizationComponent) Do {
+	return func() error {
+		return authorization.NewPlatformAuthorizationReconciler(mgr.GetClient(), log, component).
+			SetupWithManager(mgr)
+	}
+}

pkg/resource/authconfig.go

@@ -105,8 +105,10 @@ func NewConfigMapTemplateLoader(cli client.Client, fallback spi.AuthConfigTempla
 func (c *configMapTemplateLoader) Load(ctx context.Context, authType spi.AuthType, key types.NamespacedName) (authorinov1beta2.AuthConfig, error) {
 	// else
 	ac, err := c.fallback.Load(ctx, authType, key)
-
-	return ac, fmt.Errorf("could not load from fallback: %w", err)
+	if err != nil {
+		return authorinov1beta2.AuthConfig{}, fmt.Errorf("could not load from fallback: %w", err)
+	}
+	return ac, nil
 }
 
 type annotationAuthTypeDetector struct {
@@ -141,21 +143,32 @@ func NewExpressionHostExtractor(paths []string) spi.HostExtractor {
 func (k *expressionHostExtractor) Extract(target *unstructured.Unstructured) []string {
 	hosts := []string{}
 
+	isURL := func(url string) bool {
+		if strings.HasPrefix("http://", url) || strings.HasPrefix("https://", url) {
+			return true
+		}
+		return false
+	}
+
+	appendHost := func(h []string, urlStr string) []string {
+		if isURL(urlStr) {
+			parsedURL, err := url.Parse(urlStr)
+			if err == nil {
+				return append(h, parsedURL.Host)
+			}
+		}
+		return append(h, urlStr)
+	}
+
 	for _, path := range k.paths {
 		foundHost, found, err := unstructured.NestedString(target.Object, strings.Split(path, ".")...)
 		if err == nil && found {
-			parsedURL, err := url.Parse(foundHost)
-			if err == nil {
-				hosts = append(hosts, parsedURL.Host)
-			}
+			hosts = appendHost(hosts, foundHost)
 		}
 		foundHosts, found, err := unstructured.NestedStringSlice(target.Object, strings.Split(path, ".")...)
 		if err == nil && found {
 			for _, foundHost := range foundHosts {
-				parsedURL, err := url.Parse(foundHost)
-				if err == nil {
-					hosts = append(hosts, parsedURL.Host)
-				}
+				hosts = appendHost(hosts, foundHost)
 			}
 		}
 	}

pkg/resource/authconfig_test.go

@@ -34,12 +34,9 @@ var _ = Describe("AuthConfig functions", Label(labels.Unit), func() {
 			// given
 			extractor := resource.NewExpressionHostExtractor([]string{"status.url"})
 			target := unstructured.Unstructured{
-				Object: map[string]interface{}{
-					"status": map[string]interface{}{
-						"url": []interface{}{"http://test.com", "http://test2.com"},
-					},
-				},
+				Object: map[string]interface{}{},
 			}
+			unstructured.SetNestedStringSlice(target.Object, []string{"test.com", "test2.com"}, "status", "url")
 
 			// when
 			hosts := extractor.Extract(&target)