Moved to klog. Adjusted logging levels. Added auto versioning.

Related to #73
Fixes #50

Makefile

@@ -1,11 +1,10 @@
 # Go parameters
 GOCMD=go
-GOBUILD=$(GOCMD) build
 GOCLEAN=$(GOCMD) clean
 GOTEST=$(GOCMD) test
 BINARY_NAME=rbac-manager
-COMMIT := $(shell git rev-parse HEAD)
 VERSION := "dev"
+COMMIT := $(shell git rev-parse HEAD)
 
 all: test
 test:
@@ -16,11 +15,11 @@ test:
 	$(GOCMD) vet ./... 2> govet-report.out
 	$(GOCMD) tool cover -html=coverage.txt -o cover-report.html
 	printf "\nCoverage report available at cover-report.html\n\n"
-tidy:
-	$(GOCMD) mod tidy
 clean:
 	$(GOCLEAN)
 	$(GOCMD) fmt ./...
 	rm -f $(BINARY_NAME)
-	packr2 clean
-# Cross compilation
+build:
+	$(GOCMD) build -ldflags "-w -s -X main.version=$(VERSION) -X main.commit=$(COMMIT)" -a -o rbac-manager ./cmd/manager/main.go
+build-linux: 
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GOCMD) build -ldflags="-w -s" -a -o rbac-manager ./cmd/manager/main.go 

cmd/manager/main.go

@@ -23,72 +23,69 @@ import (
 	"github.com/fairwindsops/rbac-manager/pkg/apis"
 	"github.com/fairwindsops/rbac-manager/pkg/controller"
 	"github.com/fairwindsops/rbac-manager/pkg/watcher"
-	"github.com/fairwindsops/rbac-manager/version"
 
-	logrus "github.com/sirupsen/logrus"
 	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
+	klog "k8s.io/klog"
 	"sigs.k8s.io/controller-runtime/pkg/client/config"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/signals"
 )
 
-var logLevel = flag.String("log-level", logrus.InfoLevel.String(), "Logrus log level")
+var (
+	// version is set during build
+	version = "development"
+	// commit is set during build
+	commit = "n/a"
+)
 
 func main() {
+	klog.InitFlags(nil)
 	flag.Parse()
 
-	parsedLevel, err := logrus.ParseLevel(*logLevel)
-	if err != nil {
-		// This should theoretically never happen
-		logrus.Errorf("log-level flag has invalid value %s", *logLevel)
-	} else {
-		logrus.SetLevel(parsedLevel)
-	}
-
-	logrus.Info("----------------------------------")
-	logrus.Infof("rbac-manager %v running", version.Version)
-	logrus.Info("----------------------------------")
+	klog.Info("---------------------------------------------------------------")
+	klog.Infof("rbac-manager - %s (Git: %s) is starting...", version, commit)
+	klog.Info("---------------------------------------------------------------")
 
 	// Get a config to talk to the apiserver
-	logrus.Debug("Setting up client for manager")
+	klog.V(5).Info("Setting up client for manager")
 	cfg, err := config.GetConfig()
 	if err != nil {
-		logrus.Error(err, "unable to set up client config")
+		klog.Error(err, "unable to set up client config")
 		os.Exit(1)
 	}
 
 	// Create a new Cmd to provide shared dependencies and start components
-	logrus.Debug("Setting up manager")
+	klog.V(5).Info("Setting up manager")
 	mgr, err := manager.New(cfg, manager.Options{})
 	if err != nil {
-		logrus.Error(err, "unable to set up overall controller manager")
+		klog.Error(err, "unable to set up overall controller manager")
 		os.Exit(1)
 	}
 
-	logrus.Info("Registering components")
+	klog.Info("Registering components")
 
 	// Setup Scheme for all resources
-	logrus.Debug("Setting up scheme")
+	klog.V(5).Info("Setting up scheme")
 	if err := apis.AddToScheme(mgr.GetScheme()); err != nil {
-		logrus.Error(err, "unable add APIs to scheme")
+		klog.Error(err, "unable add APIs to scheme")
 		os.Exit(1)
 	}
 
 	// Setup all Controllers
-	logrus.Debug("Setting up controller")
+	klog.V(5).Info("Setting up controller")
 	if err := controller.Add(mgr); err != nil {
-		logrus.Error(err, "unable to register controller to the manager")
+		klog.Error(err, "unable to register controller to the manager")
 		os.Exit(1)
 	}
 
 	// Watch Related Resources
-	logrus.Info("Watching resources related to RBAC Definitions")
+	klog.Info("Watching resources related to RBAC Definitions")
 	watcher.WatchRelatedResources()
 
 	// Start the Cmd
-	logrus.Info("Watching RBAC Definitions")
+	klog.Info("Watching RBAC Definitions")
 	if err := mgr.Start(signals.SetupSignalHandler()); err != nil {
-		logrus.Error(err, "unable to run the manager")
+		klog.Error(err, "unable to run the manager")
 		os.Exit(1)
 	}
 }

pkg/controller/shared.go

@@ -18,9 +18,9 @@ package controller
 
 import (
 	rbacmanagerv1beta1 "github.com/fairwindsops/rbac-manager/pkg/apis/rbacmanager/v1beta1"
-	"github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/klog"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
@@ -37,15 +37,15 @@ func Add(mgr manager.Manager) error {
 	err = addController(mgr, newRbacDefReconciler(mgr), "rbacdefinition", rbacDef)
 
 	if err != nil {
-		logrus.Errorf("Error adding RBAC Definition reconciler")
+		klog.Error("Error adding RBAC Definition reconciler")
 		return err
 	}
 
 	namespace := &corev1.Namespace{}
 	err = addController(mgr, newNamespaceReconciler(mgr), "namespace", namespace)
 
 	if err != nil {
-		logrus.Errorf("Error adding Namespace reconciler")
+		klog.Error("Error adding Namespace reconciler")
 		return err
 	}
 

pkg/kube/kube.go

@@ -19,9 +19,9 @@ package kube
 import (
 	"os"
 
-	"github.com/sirupsen/logrus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
+	"k8s.io/klog"
 	"sigs.k8s.io/controller-runtime/pkg/client/config"
 )
 
@@ -42,14 +42,14 @@ func GetClientsetOrDie() *kubernetes.Clientset {
 	kubeConf, err := config.GetConfig()
 
 	if err != nil {
-		logrus.Error(err, "unable to get Kubernetes client config")
+		klog.Errorf("Unable to get Kubernetes client config: %v", err)
 		os.Exit(1)
 	}
 
 	clientset, err := kubernetes.NewForConfig(kubeConf)
 
 	if err != nil {
-		logrus.Error(err, "unable to get Kubernetes clientset")
+		klog.Errorf("Unable to get Kubernetes clientset: %v", err)
 		os.Exit(1)
 	}
 

pkg/reconciler/parser.go

@@ -20,11 +20,11 @@ import (
 
 	rbacmanagerv1beta1 "github.com/fairwindsops/rbac-manager/pkg/apis/rbacmanager/v1beta1"
 	"github.com/fairwindsops/rbac-manager/pkg/kube"
-	logrus "github.com/sirupsen/logrus"
 	v1 "k8s.io/api/core/v1"
 	rbacv1 "k8s.io/api/rbac/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
+	"k8s.io/klog"
 )
 
 // Parser parses RBAC Definitions and determines the Kubernetes resources that it specifies
@@ -39,7 +39,7 @@ type Parser struct {
 // Parse determines the desired Kubernetes resources an RBAC Definition refers to
 func (p *Parser) Parse(rbacDef rbacmanagerv1beta1.RBACDefinition) error {
 	if rbacDef.RBACBindings == nil {
-		logrus.Warn("No RBACBindings defined")
+		klog.Warning("No RBACBindings defined in rbacdefinition")
 		return nil
 	}
 
@@ -125,14 +125,14 @@ func (p *Parser) parseRoleBinding(
 	var roleRef rbacv1.RoleRef
 
 	if rb.ClusterRole != "" {
-		logrus.Debugf("Processing Requested ClusterRole %v <> %v <> %v", rb.ClusterRole, rb.Namespace, rb)
+		klog.V(3).Infof("Processing Requested ClusterRole %v <> %v <> %v", rb.ClusterRole, rb.Namespace, rb)
 		requestedRoleName = rb.ClusterRole
 		roleRef = rbacv1.RoleRef{
 			Kind: "ClusterRole",
 			Name: rb.ClusterRole,
 		}
 	} else if rb.Role != "" {
-		logrus.Debugf("Processing Requested Role %v <> %v <> %v", rb.Role, rb.Namespace, rb)
+		klog.V(3).Infof("Processing Requested Role %v <> %v <> %v", rb.Role, rb.Namespace, rb)
 		requestedRoleName = fmt.Sprintf("%v-%v", rb.Role, rb.Namespace)
 		roleRef = rbacv1.RoleRef{
 			Kind: "Role",
@@ -145,23 +145,23 @@ func (p *Parser) parseRoleBinding(
 	objectMeta.Name = fmt.Sprintf("%v-%v", prefix, requestedRoleName)
 
 	if rb.NamespaceSelector.MatchLabels != nil || len(rb.NamespaceSelector.MatchExpressions) > 0 {
-		logrus.Debugf("Processing Namespace Selector %v", rb.NamespaceSelector)
+		klog.V(3).Infof("Processing Namespace Selector %v", rb.NamespaceSelector)
 
 		selector, err := metav1.LabelSelectorAsSelector(&rb.NamespaceSelector)
 		if err != nil {
-			logrus.Debug("Error parsing label selector")
+			klog.V(3).Info("Error parsing label selector")
 			return err
 		}
 
 		listOptions := metav1.ListOptions{LabelSelector: selector.String()}
 		namespaces, err := p.Clientset.CoreV1().Namespaces().List(listOptions)
 		if err != nil {
-			logrus.Debug("Error listing namespaces")
+			klog.V(3).Info("Error listing namespaces")
 			return err
 		}
 
 		for _, namespace := range namespaces.Items {
-			logrus.Debugf("Adding Role Binding With Dynamic Namespace %v", namespace.Name)
+			klog.V(3).Infof("Adding Role Binding With Dynamic Namespace %v", namespace.Name)
 
 			om := objectMeta
 			om.Namespace = namespace.Name

pkg/reconciler/reconciler.go

@@ -21,12 +21,12 @@ import (
 	"github.com/fairwindsops/rbac-manager/pkg/kube"
 
 	rbacmanagerv1beta1 "github.com/fairwindsops/rbac-manager/pkg/apis/rbacmanager/v1beta1"
-	logrus "github.com/sirupsen/logrus"
 	v1 "k8s.io/api/core/v1"
 	rbacv1 "k8s.io/api/rbac/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/kubernetes"
+	"k8s.io/klog"
 )
 
 // Reconciler creates and deletes Kubernetes resources to achieve the desired state of an RBAC Definition
@@ -51,7 +51,7 @@ func (r *Reconciler) ReconcileNamespaceChange(rbacDef *rbacmanagerv1beta1.RBACDe
 	}
 
 	if p.hasNamespaceSelectors(rbacDef) {
-		logrus.Infof("Reconciling %v namespace for %v", namespace.Name, rbacDef.Name)
+		klog.Infof("Reconciling %v namespace for %v", namespace.Name, rbacDef.Name)
 		p.parseRoleBindings(rbacDef)
 		err := r.reconcileRoleBindings(&p.parsedRoleBindings)
 		if err != nil {
@@ -105,7 +105,7 @@ func (r *Reconciler) Reconcile(rbacDef *rbacmanagerv1beta1.RBACDefinition) error
 	mux.Lock()
 	defer mux.Unlock()
 
-	logrus.Infof("Reconciling RBACDefinition %v", rbacDef.Name)
+	klog.Infof("Reconciling RBACDefinition %v", rbacDef.Name)
 
 	r.ownerRefs = rbacDefOwnerRefs(rbacDef)
 
@@ -161,7 +161,7 @@ func (r *Reconciler) reconcileServiceAccounts(requested *[]v1.ServiceAccount) er
 		if !alreadyExists {
 			serviceAccountsToCreate = append(serviceAccountsToCreate, requestedSA)
 		} else {
-			logrus.Debugf("Service Account already exists %v", requestedSA.Name)
+			klog.V(3).Infof("Service Account already exists %v", requestedSA.Name)
 		}
 	}
 
@@ -176,22 +176,22 @@ func (r *Reconciler) reconcileServiceAccounts(requested *[]v1.ServiceAccount) er
 			}
 
 			if !matchingRequest {
-				logrus.Infof("Deleting Service Account %v", existingSA.Name)
+				klog.Infof("Deleting Service Account %v", existingSA.Name)
 				err := r.Clientset.CoreV1().ServiceAccounts(existingSA.Namespace).Delete(existingSA.Name, &metav1.DeleteOptions{})
 				if err != nil {
-					logrus.Infof("Error deleting Service Account: %v", err)
+					klog.Infof("Error deleting Service Account: %v", err)
 				}
 			} else {
-				logrus.Debugf("Matches requested Service Account %v", existingSA.Name)
+				klog.V(3).Infof("Matches requested Service Account %v", existingSA.Name)
 			}
 		}
 	}
 
 	for _, serviceAccountToCreate := range serviceAccountsToCreate {
-		logrus.Infof("Creating Service Account: %v", serviceAccountToCreate.Name)
+		klog.Infof("Creating Service Account: %v", serviceAccountToCreate.Name)
 		_, err := r.Clientset.CoreV1().ServiceAccounts(serviceAccountToCreate.ObjectMeta.Namespace).Create(&serviceAccountToCreate)
 		if err != nil {
-			logrus.Errorf("Error creating Service Account: %v", err)
+			klog.Errorf("Error creating Service Account: %v", err)
 		}
 	}
 
@@ -220,7 +220,7 @@ func (r *Reconciler) reconcileClusterRoleBindings(requested *[]rbacv1.ClusterRol
 		if !alreadyExists {
 			clusterRoleBindingsToCreate = append(clusterRoleBindingsToCreate, requestedCRB)
 		} else {
-			logrus.Debugf("Cluster Role Binding already exists %v", requestedCRB.Name)
+			klog.V(3).Infof("Cluster Role Binding already exists %v", requestedCRB.Name)
 		}
 	}
 
@@ -235,22 +235,22 @@ func (r *Reconciler) reconcileClusterRoleBindings(requested *[]rbacv1.ClusterRol
 			}
 
 			if !matchingRequest {
-				logrus.Infof("Deleting Cluster Role Binding: %v", existingCRB.Name)
+				klog.Infof("Deleting Cluster Role Binding: %v", existingCRB.Name)
 				err := r.Clientset.RbacV1().ClusterRoleBindings().Delete(existingCRB.Name, &metav1.DeleteOptions{})
 				if err != nil {
-					logrus.Errorf("Error deleting Cluster Role Binding: %v", err)
+					klog.Errorf("Error deleting Cluster Role Binding: %v", err)
 				}
 			} else {
-				logrus.Debugf("Matches requested Cluster Role Binding: %v", existingCRB.Name)
+				klog.V(3).Infof("Matches requested Cluster Role Binding: %v", existingCRB.Name)
 			}
 		}
 	}
 
 	for _, clusterRoleBindingToCreate := range clusterRoleBindingsToCreate {
-		logrus.Infof("Creating Cluster Role Binding: %v", clusterRoleBindingToCreate.Name)
+		klog.Infof("Creating Cluster Role Binding: %v", clusterRoleBindingToCreate.Name)
 		_, err := r.Clientset.RbacV1().ClusterRoleBindings().Create(&clusterRoleBindingToCreate)
 		if err != nil {
-			logrus.Errorf("Error creating Cluster Role Binding: %v", err)
+			klog.Errorf("Error creating Cluster Role Binding: %v", err)
 		}
 	}
 
@@ -279,7 +279,7 @@ func (r *Reconciler) reconcileRoleBindings(requested *[]rbacv1.RoleBinding) erro
 		if !alreadyExists {
 			roleBindingsToCreate = append(roleBindingsToCreate, requestedRB)
 		} else {
-			logrus.Debugf("Role Binding already exists %v", requestedRB.Name)
+			klog.V(3).Infof("Role Binding already exists %v", requestedRB.Name)
 		}
 	}
 
@@ -294,22 +294,22 @@ func (r *Reconciler) reconcileRoleBindings(requested *[]rbacv1.RoleBinding) erro
 			}
 
 			if !matchingRequest {
-				logrus.Infof("Deleting Role Binding %v", existingRB.Name)
+				klog.Infof("Deleting Role Binding %v", existingRB.Name)
 				err := r.Clientset.RbacV1().RoleBindings(existingRB.Namespace).Delete(existingRB.Name, &metav1.DeleteOptions{})
 				if err != nil {
-					logrus.Infof("Error deleting Role Binding: %v", err)
+					klog.Infof("Error deleting Role Binding: %v", err)
 				}
 			} else {
-				logrus.Debugf("Matches requested Role Binding %v", existingRB.Name)
+				klog.V(3).Infof("Matches requested Role Binding %v", existingRB.Name)
 			}
 		}
 	}
 
 	for _, roleBindingToCreate := range roleBindingsToCreate {
-		logrus.Infof("Creating Role Binding: %v", roleBindingToCreate.Name)
+		klog.Infof("Creating Role Binding: %v", roleBindingToCreate.Name)
 		_, err := r.Clientset.RbacV1().RoleBindings(roleBindingToCreate.ObjectMeta.Namespace).Create(&roleBindingToCreate)
 		if err != nil {
-			logrus.Errorf("Error creating Role Binding: %v", err)
+			klog.Errorf("Error creating Role Binding: %v", err)
 		}
 	}