cleanup

provider/kubernetes/kubernetes.go

@@ -66,13 +66,8 @@ func NewProvider(opts *Opts) (*Provider, error) {
 			}).Error("provider.kubernetes: failed to get cmd kubernetes config")
 			return nil, err
 		}
-
 	} else {
-		cfg.Host = opts.Master
-		cfg.KeyFile = opts.KeyFile
-		cfg.CAFile = opts.CAFile
-		cfg.CertFile = opts.CertFile
-		log.Info("provider.kubernetes: using out-of-cluster configuration")
+		return nil, fmt.Errorf("kubernetes config is missing")
 	}
 
 	client, err := kubernetes.NewForConfig(cfg)
@@ -119,12 +114,12 @@ func (p *Provider) startInternal() error {
 			log.WithFields(log.Fields{
 				"repository": event.Repository.Name,
 			}).Info("provider.kubernetes: processing event")
-			err := p.processEvent(event)
+			_, err := p.processEvent(event)
 			if err != nil {
 				log.WithFields(log.Fields{
-					"error":  err,
-					"event":  event.Repository,
-					"pusher": event.Pusher,
+					"error": err,
+					"image": event.Repository.Name,
+					"tag":   event.Repository.Tag,
 				}).Error("provider.kubernetes: failed to process event")
 			}
 		case <-p.stop:
@@ -134,21 +129,26 @@ func (p *Provider) startInternal() error {
 	}
 }
 
-func (p *Provider) processEvent(event *types.Event) error {
+func (p *Provider) processEvent(event *types.Event) (updated []*v1beta1.Deployment, err error) {
 	impacted, err := p.impactedDeployments(&event.Repository)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	err = p.updateDeployments(impacted)
-	if err != nil {
-		return err
+	if len(impacted) == 0 {
+		log.WithFields(log.Fields{
+			"image": event.Repository.Name,
+			"tag":   event.Repository.Tag,
+		}).Info("provider.kubernetes: no impacted deployments found for this event")
+		return
 	}
 
-	return nil
+	updated, err = p.updateDeployments(impacted)
+
+	return
 }
 
-func (p *Provider) updateDeployments(deployments []*v1beta1.Deployment) error {
+func (p *Provider) updateDeployments(deployments []*v1beta1.Deployment) (updated []*v1beta1.Deployment, err error) {
 	for _, deployment := range deployments {
 		_, err := p.client.Extensions().Deployments(deployment.Namespace).Update(deployment)
 		if err != nil {
@@ -157,10 +157,18 @@ func (p *Provider) updateDeployments(deployments []*v1beta1.Deployment) error {
 				"namespace":  deployment.Namespace,
 				"deployment": deployment.Name,
 			}).Error("provider.kubernetes: got error while update deployment")
+			continue
 		}
+		updated = append(updated, deployment)
 	}
 
-	return nil
+	return
+}
+
+// getDeployment - helper function to get specific deployment
+func (p *Provider) getDeployment(namespace, name string) (*v1beta1.Deployment, error) {
+	dep := p.client.Extensions().Deployments(namespace)
+	return dep.Get(name, meta_v1.GetOptions{})
 }
 
 // gets impacted deployments by changed repository

provider/kubernetes/kubernetes_test.go

@@ -2,6 +2,7 @@ package kubernetes
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/rusenask/keel/types"
 	"github.com/rusenask/keel/util/version"
@@ -9,6 +10,9 @@ import (
 	"testing"
 )
 
+var currentVersion = "0.0.2"
+var newVersion = "0.0.3"
+
 func TestGetNamespaces(t *testing.T) {
 	provider, err := NewProvider(&Opts{ConfigPath: ".kubeconfig"})
 	if err != nil {
@@ -23,6 +27,11 @@ func TestGetNamespaces(t *testing.T) {
 	fmt.Println(namespaces.Items)
 }
 
+func TestGetImageName(t *testing.T) {
+	name := versionreg.ReplaceAllString("gcr.io/v2-namespace/hello-world:1.1", "")
+	fmt.Println(name)
+}
+
 func TestGetDeployments(t *testing.T) {
 	provider, err := NewProvider(&Opts{ConfigPath: ".kubeconfig"})
 	if err != nil {
@@ -67,3 +76,38 @@ func TestGetImpacted(t *testing.T) {
 	fmt.Println(found)
 
 }
+func TestProcessEvent(t *testing.T) {
+	provider, err := NewProvider(&Opts{ConfigPath: ".kubeconfig"})
+	if err != nil {
+		t.Fatalf("failed to get provider: %s", err)
+	}
+
+	repo := types.Repository{
+		Name: "karolisr/webhook-demo",
+		Tag:  newVersion,
+	}
+
+	event := &types.Event{Repository: repo}
+	updated, err := provider.processEvent(event)
+	if err != nil {
+		t.Errorf("got error while processing event: %s", err)
+	}
+
+	//
+	time.Sleep(100 * time.Millisecond)
+	for _, upd := range updated {
+		current, err := provider.getDeployment(upd.Namespace, upd.Name)
+		if err != nil {
+			t.Fatalf("failed to get deployment %s, error: %s", upd.Name, err)
+		}
+		currentVer, err := version.GetVersionFromImageName(current.Spec.Template.Spec.Containers[0].Image)
+		if err != nil {
+			t.Fatalf("failed to get version from %s, error: %s", current.Spec.Template.Spec.Containers[0].Image, err)
+		}
+
+		if currentVer.String() != newVersion {
+			t.Errorf("deployment version wasn't updated, got: %s while expected: %s", currentVer.String(), newVersion)
+		}
+	}
+
+}