Create a route for Cincinnati service

cmd/manager/main.go

@@ -29,6 +29,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager/signals"
 
 	configv1 "github.com/openshift/api/config/v1"
+	routev1 "github.com/openshift/api/route/v1"
 	"github.com/openshift/cincinnati-operator/pkg/apis"
 	"github.com/openshift/cincinnati-operator/pkg/controller"
 	cincontroller "github.com/openshift/cincinnati-operator/pkg/controller/cincinnati"
@@ -129,6 +130,11 @@ func main() {
 		os.Exit(1)
 	}
 
+	if err := routev1.Install(mgr.GetScheme()); err != nil {
+		log.Error(err, "")
+		os.Exit(1)
+	}
+
 	opts := cincontroller.Options{
 		OperandImage: os.Getenv("OPERAND_IMAGE"),
 	}

deploy/role.yaml

@@ -105,6 +105,17 @@ rules:
   - get
   - list
   - watch
+- apiGroups:
+  - route.openshift.io
+  resources:
+  - routes
+  verbs:
+  - create
+  - get
+  - list
+  - patch
+  - update
+  - watch
 - apiGroups:
   - ""
   resources:

pkg/controller/cincinnati/cincinnati_controller.go

@@ -25,6 +25,7 @@ import (
 
 	apicfgv1 "github.com/openshift/api/config/v1"
 	cv1beta1 "github.com/openshift/cincinnati-operator/pkg/apis/cincinnati/v1beta1"
+	routev1 "github.com/openshift/api/route/v1"
 	"github.com/openshift/cluster-image-registry-operator/pkg/defaults"
 )
 
@@ -71,6 +72,7 @@ func add(mgr manager.Manager, r reconcile.Reconciler) error {
 		&corev1.ConfigMap{},
 		&corev1.Service{},
 		&policyv1beta1.PodDisruptionBudget{},
+		&routev1.Route{},
 	} {
 		err = c.Watch(&source.Kind{Type: obj}, &handler.EnqueueRequestForOwner{
 			IsController: true,
@@ -153,6 +155,7 @@ func (r *ReconcileCincinnati) Reconcile(request reconcile.Request) (reconcile.Re
 		r.ensureGraphBuilderService,
 		r.ensurePolicyEngineService,
 		r.ensurePodDisruptionBudget,
+		r.ensurePolicyEngineRoute,
 	} {
 		err = f(ctx, reqLogger, instanceCopy, resources)
 		if err != nil {
@@ -438,6 +441,41 @@ func (r *ReconcileCincinnati) ensurePolicyEngineService(ctx context.Context, req
 	return nil
 }
 
+func (r *ReconcileCincinnati) ensurePolicyEngineRoute(ctx context.Context, reqLogger logr.Logger, instance *cv1beta1.Cincinnati, resources *kubeResources) error {
+	route := resources.policyEngineRoute
+	// Set Cincinnati instance as the owner and controller
+	if err := controllerutil.SetControllerReference(instance, route, r.scheme); err != nil {
+		return err
+	}
+
+	// Check if it already exists
+	found := &routev1.Route{}
+	err := r.client.Get(ctx, types.NamespacedName{Name: route.Name, Namespace: route.Namespace}, found)
+	if err != nil && errors.IsNotFound(err) {
+		reqLogger.Info("Creating Route", "Namespace", route.Namespace, "Name", route.Name)
+		if err = r.client.Create(ctx, route); err != nil {
+			handleErr(reqLogger, &instance.Status, "CreateRouteFailed", err)
+		}
+		return err
+	} else if err != nil {
+		handleErr(reqLogger, &instance.Status, "GetRouteFailed", err)
+		return err
+	}
+
+	// found existing resource; let's compare and update if needed
+	if !reflect.DeepEqual(found.Spec, route.Spec) {
+		reqLogger.Info("Updating Route", "Namespace", route.Namespace, "Name", route.Name)
+		updated := found.DeepCopy()
+		updated.Spec = route.Spec
+		err = r.client.Update(ctx, updated)
+		if err != nil {
+			handleErr(reqLogger, &instance.Status, "UpdateRouteFailed", err)
+		}
+	}
+
+	return nil
+}
+
 func (r *ReconcileCincinnati) ensureService(ctx context.Context, reqLogger logr.Logger, service *corev1.Service) error {
 	// Check if this Service already exists
 	found := &corev1.Service{}

pkg/controller/cincinnati/cincinnati_controller_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	configv1 "github.com/openshift/api/config/v1"
+	routev1 "github.com/openshift/api/route/v1"
 	"github.com/openshift/cincinnati-operator/pkg/apis"
 	cv1beta1 "github.com/openshift/cincinnati-operator/pkg/apis/cincinnati/v1beta1"
 	"github.com/openshift/cluster-image-registry-operator/pkg/defaults"
@@ -19,6 +20,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/client-go/kubernetes/scheme"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
@@ -49,6 +51,11 @@ func TestMain(m *testing.M) {
 		os.Exit(1)
 	}
 
+	if err := routev1.AddToScheme(scheme.Scheme); err != nil {
+		log.Error(err, "Failed adding apis to scheme")
+		os.Exit(1)
+	}
+
 	exitVal := m.Run()
 	os.Exit(exitVal)
 }
@@ -352,6 +359,42 @@ func TestEnsurePodDisruptionBudget(t *testing.T) {
 	}
 }
 
+func TestEnsurePolicyEngineRoute(t *testing.T) {
+	tests := []struct {
+		name       string
+		cincinnati *cv1beta1.Cincinnati
+	}{
+		{
+			name:       "EnsurePolicyEngineRoute",
+			cincinnati: newDefaultCincinnati(),
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cincinnati := test.cincinnati
+			r := newTestReconciler(cincinnati)
+
+			resources, err := newKubeResources(test.cincinnati, testOperandImage)
+			err = r.ensurePolicyEngineRoute(context.TODO(), log, cincinnati, resources)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			found := &routev1.Route{}
+			err = r.client.Get(context.TODO(), types.NamespacedName{Name: namePolicyEngineRoute(cincinnati), Namespace: cincinnati.Namespace}, found)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			verifyOwnerReference(t, found.ObjectMeta.OwnerReferences[0], cincinnati)
+			assert.Equal(t, found.ObjectMeta.Labels["app"], nameDeployment(cincinnati))
+			assert.Equal(t, found.Spec.To.Kind, "Service")
+			assert.Equal(t, found.Spec.To.Name, namePolicyEngineService(cincinnati))
+			assert.Equal(t, found.Spec.Port.TargetPort, intstr.FromString("policy-engine"))
+		})
+	}
+}
+
 func newRequest(cincinnati *cv1beta1.Cincinnati) reconcile.Request {
 	namespacedName := types.NamespacedName{
 		Namespace: cincinnati.ObjectMeta.Namespace,

pkg/controller/cincinnati/names.go

@@ -44,6 +44,10 @@ func nameGraphBuilderService(instance *cv1beta1.Cincinnati) string {
 	return instance.Name + "-graph-builder"
 }
 
+func namePolicyEngineRoute(instance *cv1beta1.Cincinnati) string {
+	return namePolicyEngineService(instance) + "-route"
+}
+
 func nameAdditionalTrustedCA(instance *cv1beta1.Cincinnati) string {
 	return instance.Name + "-trusted-ca"
 }

pkg/controller/cincinnati/new.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 	"text/template"
 
+	routev1 "github.com/openshift/api/route/v1"
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	policyv1beta1 "k8s.io/api/policy/v1beta1"
@@ -75,6 +76,7 @@ type kubeResources struct {
 	policyEngineContainer  *corev1.Container
 	graphBuilderService    *corev1.Service
 	policyEngineService    *corev1.Service
+	policyEngineRoute      *routev1.Route
 }
 
 func newKubeResources(instance *cv1beta1.Cincinnati, image string) (*kubeResources, error) {
@@ -107,6 +109,7 @@ func newKubeResources(instance *cv1beta1.Cincinnati, image string) (*kubeResourc
 	k.deployment = k.newDeployment(instance, externalCACert)
 	k.graphBuilderService = k.newGraphBuilderService(instance)
 	k.policyEngineService = k.newPolicyEngineService(instance)
+	k.policyEngineRoute = k.newPolicyEngineRoute(instance)
 	return &k, nil
 }
 
@@ -196,6 +199,32 @@ func (k *kubeResources) newPolicyEngineService(instance *cv1beta1.Cincinnati) *c
 	}
 }
 
+func (k *kubeResources) newPolicyEngineRoute(instance *cv1beta1.Cincinnati) *routev1.Route {
+	name := namePolicyEngineRoute(instance)
+	return &routev1.Route{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: instance.Namespace,
+			Labels: map[string]string{
+				"app": nameDeployment(instance),
+			},
+		},
+		Spec: routev1.RouteSpec{
+			Port: &routev1.RoutePort{
+				TargetPort: intstr.FromString("policy-engine"),
+			},
+			To: routev1.RouteTargetReference{
+				Kind: "Service",
+				Name: namePolicyEngineService(instance),
+			},
+			TLS: &routev1.TLSConfig{
+				Termination:                   routev1.TLSTerminationEdge,
+				InsecureEdgeTerminationPolicy: routev1.InsecureEdgeTerminationPolicyAllow,
+			},
+		},
+	}
+}
+
 func (k *kubeResources) newEnvConfig(instance *cv1beta1.Cincinnati) *corev1.ConfigMap {
 	return &corev1.ConfigMap{
 		ObjectMeta: metav1.ObjectMeta{