Update Jaeger CR

pkg/account/main.go

@@ -24,6 +24,14 @@ func getMain(jaeger *v1alpha1.Jaeger) *v1.ServiceAccount {
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      JaegerServiceAccountFor(jaeger),
 			Namespace: jaeger.Namespace,
+			Labels: map[string]string{
+				"app":                          "jaeger",
+				"app.kubernetes.io/name":       JaegerServiceAccountFor(jaeger),
+				"app.kubernetes.io/instance":   jaeger.Name,
+				"app.kubernetes.io/component":  "service-account",
+				"app.kubernetes.io/part-of":    "jaeger",
+				"app.kubernetes.io/managed-by": "jaeger-operator",
+			},
 			OwnerReferences: []metav1.OwnerReference{
 				{
 					APIVersion: jaeger.APIVersion,

pkg/account/oauth-proxy.go

@@ -20,6 +20,14 @@ func OAuthProxy(jaeger *v1alpha1.Jaeger) *v1.ServiceAccount {
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      OAuthProxyAccountNameFor(jaeger),
 			Namespace: jaeger.Namespace,
+			Labels: map[string]string{
+				"app":                          "jaeger",
+				"app.kubernetes.io/name":       OAuthProxyAccountNameFor(jaeger),
+				"app.kubernetes.io/instance":   jaeger.Name,
+				"app.kubernetes.io/component":  "service-account-oauth-proxy",
+				"app.kubernetes.io/part-of":    "jaeger",
+				"app.kubernetes.io/managed-by": "jaeger-operator",
+			},
 			Annotations: map[string]string{
 				"serviceaccounts.openshift.io/oauth-redirectreference.primary": getOAuthRedirectReference(jaeger),
 			},

pkg/cmd/start/main.go

@@ -79,12 +79,11 @@ func start(cmd *cobra.Command, args []string) {
 	}
 
 	log.WithFields(log.Fields{
-		"os":      runtime.GOOS,
-		"arch":    runtime.GOARCH,
-		"version": runtime.Version(),
-	}).Info("Go")
-
-	log.WithField("version", version.Get().OperatorSdk).Print("operator-sdk")
+		"os":           runtime.GOOS,
+		"arch":         runtime.GOARCH,
+		"version":      runtime.Version(),
+		"operator-sdk": version.Get().OperatorSdk,
+	}).Info("Versions")
 
 	namespace, err := k8sutil.GetWatchNamespace()
 	if err != nil {

pkg/config/sampling/sampling.go

@@ -55,6 +55,14 @@ func (u *Config) Get() *v1.ConfigMap {
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      fmt.Sprintf("%s-sampling-configuration", u.jaeger.Name),
 			Namespace: u.jaeger.Namespace,
+			Labels: map[string]string{
+				"app":                          "jaeger",
+				"app.kubernetes.io/name":       fmt.Sprintf("%s-sampling-configuration", u.jaeger.Name),
+				"app.kubernetes.io/instance":   u.jaeger.Name,
+				"app.kubernetes.io/component":  "sampling-configuration",
+				"app.kubernetes.io/part-of":    "jaeger",
+				"app.kubernetes.io/managed-by": "jaeger-operator",
+			},
 			OwnerReferences: []metav1.OwnerReference{
 				metav1.OwnerReference{
 					APIVersion: u.jaeger.APIVersion,

pkg/config/ui/ui.go

@@ -46,6 +46,14 @@ func (u *UIConfig) Get() *v1.ConfigMap {
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      fmt.Sprintf("%s-ui-configuration", u.jaeger.Name),
 			Namespace: u.jaeger.Namespace,
+			Labels: map[string]string{
+				"app":                          "jaeger",
+				"app.kubernetes.io/name":       fmt.Sprintf("%s-ui-configuration", u.jaeger.Name),
+				"app.kubernetes.io/instance":   u.jaeger.Name,
+				"app.kubernetes.io/component":  "ui-configuration",
+				"app.kubernetes.io/part-of":    "jaeger",
+				"app.kubernetes.io/managed-by": "jaeger-operator",
+			},
 			OwnerReferences: []metav1.OwnerReference{
 				metav1.OwnerReference{
 					APIVersion: u.jaeger.APIVersion,

pkg/controller/jaeger/account.go

@@ -0,0 +1,52 @@
+package jaeger
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"k8s.io/api/core/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1"
+	"github.com/jaegertracing/jaeger-operator/pkg/inventory"
+)
+
+func (r *ReconcileJaeger) applyAccounts(jaeger v1alpha1.Jaeger, desired []v1.ServiceAccount) error {
+	opts := client.MatchingLabels(map[string]string{
+		"app.kubernetes.io/instance":   jaeger.Name,
+		"app.kubernetes.io/managed-by": "jaeger-operator",
+	})
+	list := &v1.ServiceAccountList{}
+	if err := r.client.List(context.Background(), opts, list); err != nil {
+		return err
+	}
+
+	logFields := log.WithFields(log.Fields{
+		"namespace": jaeger.Namespace,
+		"instance":  jaeger.Name,
+	})
+
+	inv := inventory.ForAccounts(list.Items, desired)
+	for _, d := range inv.Create {
+		logFields.WithField("account", d.Name).Debug("creating service account")
+		if err := r.client.Create(context.Background(), &d); err != nil {
+			return err
+		}
+	}
+
+	for _, d := range inv.Update {
+		logFields.WithField("account", d.Name).Debug("updating service account")
+		if err := r.client.Update(context.Background(), &d); err != nil {
+			return err
+		}
+	}
+
+	for _, d := range inv.Delete {
+		logFields.WithField("account", d.Name).Debug("deleting service account")
+		if err := r.client.Delete(context.Background(), &d); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

pkg/controller/jaeger/account_test.go

@@ -0,0 +1,131 @@
+package jaeger
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	"github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1"
+	"github.com/jaegertracing/jaeger-operator/pkg/strategy"
+)
+
+func TestServiceAccountCreate(t *testing.T) {
+	// prepare
+	nsn := types.NamespacedName{
+		Name: "TestServiceAccountCreate",
+	}
+
+	objs := []runtime.Object{
+		v1alpha1.NewJaeger(nsn.Name),
+	}
+
+	r, cl := getReconciler(objs)
+	req := reconcile.Request{
+		NamespacedName: nsn,
+	}
+
+	r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S {
+		s := strategy.New().WithAccounts([]v1.ServiceAccount{{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: nsn.Name,
+			},
+		}})
+		return s
+	}
+
+	// test
+	res, err := r.Reconcile(req)
+
+	// verify
+	assert.NoError(t, err)
+	assert.False(t, res.Requeue, "We don't requeue for now")
+
+	persisted := &v1.ServiceAccount{}
+	persistedName := types.NamespacedName{
+		Name:      nsn.Name,
+		Namespace: nsn.Namespace,
+	}
+	err = cl.Get(context.Background(), persistedName, persisted)
+	assert.Equal(t, persistedName.Name, persisted.Name)
+	assert.NoError(t, err)
+}
+
+func TestServiceAccountUpdate(t *testing.T) {
+	// prepare
+	nsn := types.NamespacedName{
+		Name: "TestServiceAccountUpdate",
+	}
+
+	orig := v1.ServiceAccount{}
+	orig.Name = nsn.Name
+	orig.Annotations = map[string]string{"key": "value"}
+
+	objs := []runtime.Object{
+		v1alpha1.NewJaeger(nsn.Name),
+		&orig,
+	}
+
+	r, cl := getReconciler(objs)
+	r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S {
+		updated := v1.ServiceAccount{}
+		updated.Name = orig.Name
+		updated.Annotations = map[string]string{"key": "new-value"}
+
+		s := strategy.New().WithAccounts([]v1.ServiceAccount{updated})
+		return s
+	}
+
+	// test
+	_, err := r.Reconcile(reconcile.Request{NamespacedName: nsn})
+	assert.NoError(t, err)
+
+	// verify
+	persisted := &v1.ServiceAccount{}
+	persistedName := types.NamespacedName{
+		Name:      orig.Name,
+		Namespace: orig.Namespace,
+	}
+	err = cl.Get(context.Background(), persistedName, persisted)
+	assert.Equal(t, "new-value", persisted.Annotations["key"])
+	assert.NoError(t, err)
+}
+
+func TestServiceAccountDelete(t *testing.T) {
+	// prepare
+	nsn := types.NamespacedName{
+		Name: "TestServiceAccountDelete",
+	}
+
+	orig := v1.ServiceAccount{}
+	orig.Name = nsn.Name
+
+	objs := []runtime.Object{
+		v1alpha1.NewJaeger(nsn.Name),
+		&orig,
+	}
+
+	r, cl := getReconciler(objs)
+	r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S {
+		return strategy.S{}
+	}
+
+	// test
+	_, err := r.Reconcile(reconcile.Request{NamespacedName: nsn})
+	assert.NoError(t, err)
+
+	// verify
+	persisted := &v1.ServiceAccount{}
+	persistedName := types.NamespacedName{
+		Name:      orig.Name,
+		Namespace: orig.Namespace,
+	}
+	err = cl.Get(context.Background(), persistedName, persisted)
+	assert.Empty(t, persisted.Name)
+	assert.Error(t, err) // not found
+}

pkg/controller/jaeger/configmap.go

@@ -0,0 +1,52 @@
+package jaeger
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"k8s.io/api/core/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1"
+	"github.com/jaegertracing/jaeger-operator/pkg/inventory"
+)
+
+func (r *ReconcileJaeger) applyConfigMaps(jaeger v1alpha1.Jaeger, desired []v1.ConfigMap) error {
+	opts := client.MatchingLabels(map[string]string{
+		"app.kubernetes.io/instance":   jaeger.Name,
+		"app.kubernetes.io/managed-by": "jaeger-operator",
+	})
+	list := &v1.ConfigMapList{}
+	if err := r.client.List(context.Background(), opts, list); err != nil {
+		return err
+	}
+
+	logFields := log.WithFields(log.Fields{
+		"namespace": jaeger.Namespace,
+		"instance":  jaeger.Name,
+	})
+
+	inv := inventory.ForConfigMaps(list.Items, desired)
+	for _, d := range inv.Create {
+		logFields.WithField("configMap", d.Name).Debug("creating config maps")
+		if err := r.client.Create(context.Background(), &d); err != nil {
+			return err
+		}
+	}
+
+	for _, d := range inv.Update {
+		logFields.WithField("configMap", d.Name).Debug("updating config maps")
+		if err := r.client.Update(context.Background(), &d); err != nil {
+			return err
+		}
+	}
+
+	for _, d := range inv.Delete {
+		logFields.WithField("configMap", d.Name).Debug("deleting config maps")
+		if err := r.client.Delete(context.Background(), &d); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}