keel-hq
/
keel
mirror of https://github.com/keel-hq/keel/tree/master/chart/keel
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

moving deployment update logic into other file, splitting it in parts

pull/26/head
Karolis Rusenas 2017-07-03 08:45:58 +01:00
parent 53bc2285b2
commit 319b009004
2 changed files with 267 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
provider/kubernetes/deployment.go Normal file
View File

@ -0,0 +1,141 @@
package kubernetes
import (
"fmt"
"k8s.io/client-go/pkg/api/v1"
"k8s.io/client-go/pkg/apis/extensions/v1beta1"
"github.com/rusenask/keel/types"
"github.com/rusenask/keel/util/image"
"github.com/rusenask/keel/util/policies"
"github.com/rusenask/keel/util/version"
log "github.com/Sirupsen/logrus"
)
func (p *Provider) checkDeployment(newVersion *types.Version, repo *types.Repository, deployment *v1beta1.Deployment) (updated v1beta1.Deployment, shouldUpdateDeployment bool, err error) {
shouldUpdateDeployment = false
updated = *deployment
labels := deployment.GetLabels()
policy := policies.GetPolicy(labels)
if policy == types.PolicyTypeNone {
return
}
log.WithFields(log.Fields{
"labels": labels,
"name": deployment.Name,
"namespace": deployment.Namespace,
"policy": policy,
}).Info("provider.kubernetes: keel policy found, checking deployment...")
for idx, c := range deployment.Spec.Template.Spec.Containers {
ref, err := image.Parse(c.Image)
if err != nil {
log.WithFields(log.Fields{
"error": err,
"image_name": c.Image,
}).Error("provider.kubernetes: failed to parse image name")
continue
}
log.WithFields(log.Fields{
"name": deployment.Name,
"namespace": deployment.Namespace,
"parsed_image_name": ref.Remote(),
"target_image_name": repo.Name,
"target_tag": repo.Tag,
"policy": policy,
"image": c.Image,
}).Info("provider.kubernetes: checking image")
if ref.Remote() != repo.Name {
log.WithFields(log.Fields{
"parsed_image_name": ref.Remote(),
"target_image_name": repo.Name,
}).Info("provider.kubernetes: images do not match, ignoring")
continue
}
currentVersion, err := version.GetVersion(ref.Tag())
if err != nil {
log.WithFields(log.Fields{
"error": err,
"image_name": c.Image,
"keel_policy": policy,
}).Error("provider.kubernetes: failed to get image version, is it tagged as semver?")
continue
}
log.WithFields(log.Fields{
"labels": labels,
"name": deployment.Name,
"namespace": deployment.Namespace,
"image": c.Image,
"current_version": currentVersion.String(),
"policy": policy,
}).Info("provider.kubernetes: current image version")
shouldUpdateContainer, err := version.ShouldUpdate(currentVersion, newVersion, policy)
if err != nil {
log.WithFields(log.Fields{
"error": err,
"new_version": newVersion.String(),
"current_version": currentVersion.String(),
"keel_policy": policy,
}).Error("provider.kubernetes: got error while checking whether deployment should be updated")
continue
}
log.WithFields(log.Fields{
"labels": labels,
"name": deployment.Name,
"namespace": deployment.Namespace,
"image": c.Image,
"current_version": currentVersion.String(),
"new_version": newVersion.String(),
"policy": policy,
"should_update": shouldUpdateContainer,
}).Info("provider.kubernetes: checked version, deciding whether to update")
if shouldUpdateContainer {
// updating image
if ref.Registry() == image.DefaultRegistryHostname {
c.Image = fmt.Sprintf("%s:%s", ref.ShortName(), newVersion.String())
} else {
c.Image = fmt.Sprintf("%s:%s", ref.Remote(), newVersion.String())
}
deployment.Spec.Template.Spec.Containers[idx] = c
// marking this deployment for update
shouldUpdateDeployment = true
// updating digest if available
if repo.Digest != "" {
// labels[types.KeelDigestLabel] = hash.GetShort(repo.Digest)
}
log.WithFields(log.Fields{
"parsed_image": ref.Remote(),
"raw_image_name": c.Image,
"target_image": repo.Name,
"target_image_tag": repo.Tag,
"policy": policy,
}).Info("provider.kubernetes: impacted deployment container found")
}
}
return updated, shouldUpdateDeployment, nil
}
func (p *Provider) semverPath(currentVersion, newVersion *types.Version, repo *types.Repository, container v1.Container) (updated v1.Container, shouldUpdateContainer bool, err error) {
return
}
func (p *Provider) forceUpdatePath(repo *types.Repository, container v1.Container) (updated v1.Container, shouldUpdateContainer bool, err error) {
return
}

196
provider/kubernetes/kubernetes.go
View File

@ -8,7 +8,9 @@ import (
"k8s.io/client-go/pkg/apis/extensions/v1beta1" "k8s.io/client-go/pkg/apis/extensions/v1beta1"
"github.com/rusenask/keel/types" "github.com/rusenask/keel/types"
"github.com/rusenask/keel/util/policies" // "github.com/rusenask/keel/util/hash"
// "github.com/rusenask/keel/util/image"
// "github.com/rusenask/keel/util/policies"
"github.com/rusenask/keel/util/version" "github.com/rusenask/keel/util/version"
log "github.com/Sirupsen/logrus" log "github.com/Sirupsen/logrus"
@ -143,100 +145,134 @@ func (p *Provider) impactedDeployments(repo *types.Repository) ([]v1beta1.Deploy
for _, deploymentList := range deploymentLists { for _, deploymentList := range deploymentLists {
for _, deployment := range deploymentList.Items { for _, deployment := range deploymentList.Items {
labels := deployment.GetLabels() // labels := deployment.GetLabels()
policy := policies.GetPolicy(labels) // policy := policies.GetPolicy(labels)
if policy == types.PolicyTypeNone { // if policy == types.PolicyTypeNone {
continue // continue
} // }
log.WithFields(log.Fields{ // log.WithFields(log.Fields{
"labels": labels, // "labels": labels,
"name": deployment.Name, // "name": deployment.Name,
"namespace": deployment.Namespace, // "namespace": deployment.Namespace,
"policy": policy, // "policy": policy,
}).Info("provider.kubernetes: keel policy found, checking deployment...") // }).Info("provider.kubernetes: keel policy found, checking deployment...")
shouldUpdateDeployment := false // shouldUpdateDeployment := false
for idx, c := range deployment.Spec.Template.Spec.Containers { // for idx, c := range deployment.Spec.Template.Spec.Containers {
// Remove version if any // // Remove version if any
containerImageName := versionreg.ReplaceAllString(c.Image, "") // // containerImageName := versionreg.ReplaceAllString(c.Image, "")
log.WithFields(log.Fields{ // ref, err := image.Parse(c.Image)
"name": deployment.Name, // if err != nil {
"namespace": deployment.Namespace, // log.WithFields(log.Fields{
"parsed_image_name": containerImageName, // "error": err,
"target_image_name": repo.Name, // "image_name": c.Image,
"target_tag": repo.Tag, // }).Error("provider.kubernetes: failed to parse image name")
"policy": policy, // continue
"image": c.Image, // }
}).Info("provider.kubernetes: checking image")
if containerImageName != repo.Name { // log.WithFields(log.Fields{
continue // "name": deployment.Name,
} // "namespace": deployment.Namespace,
// "parsed_image_name": ref.Remote(),
// "target_image_name": repo.Name,
// "target_tag": repo.Tag,
// "policy": policy,
// "image": c.Image,
// }).Info("provider.kubernetes: checking image")
currentVersion, err := version.GetVersionFromImageName(c.Image) // if ref.Remote() != repo.Name {
// log.WithFields(log.Fields{
// "parsed_image_name": ref.Remote(),
// "target_image_name": repo.Name,
// }).Info("provider.kubernetes: images do not match, ignoring")
// continue
// }
// currentVersion, err := version.GetVersionFromImageName(c.Image)
// if err != nil {
// log.WithFields(log.Fields{
// "error": err,
// "image_name": c.Image,
// "keel_policy": policy,
// }).Error("provider.kubernetes: failed to get image version, is it tagged as semver?")
// continue
// }
// log.WithFields(log.Fields{
// "labels": labels,
// "name": deployment.Name,
// "namespace": deployment.Namespace,
// "image": c.Image,
// "current_version": currentVersion.String(),
// "policy": policy,
// }).Info("provider.kubernetes: current image version")
// shouldUpdateContainer, err := version.ShouldUpdate(currentVersion, newVersion, policy)
// if err != nil {
// log.WithFields(log.Fields{
// "error": err,
// "new_version": newVersion.String(),
// "current_version": currentVersion.String(),
// "keel_policy": policy,
// }).Error("provider.kubernetes: got error while checking whether deployment should be updated")
// continue
// }
// log.WithFields(log.Fields{
// "labels": labels,
// "name": deployment.Name,
// "namespace": deployment.Namespace,
// "image": c.Image,
// "current_version": currentVersion.String(),
// "new_version": newVersion.String(),
// "policy": policy,
// "should_update": shouldUpdateContainer,
// }).Info("provider.kubernetes: checked version, deciding whether to update")
// if shouldUpdateContainer {
// // updating image
// if ref.Registry() == image.DefaultRegistryHostname {
// c.Image = fmt.Sprintf("%s:%s", ref.ShortName(), newVersion.String())
// } else {
// c.Image = fmt.Sprintf("%s:%s", ref.Remote(), newVersion.String())
// }
// deployment.Spec.Template.Spec.Containers[idx] = c
// // marking this deployment for update
// shouldUpdateDeployment = true
// // updating digest if available
// if repo.Digest != "" {
// labels[types.KeelDigestLabel] = hash.GetShort(repo.Digest)
// }
// log.WithFields(log.Fields{
// "parsed_image": ref.Remote(),
// "raw_image_name": c.Image,
// "target_image": repo.Name,
// "target_image_tag": repo.Tag,
// "policy": policy,
// }).Info("provider.kubernetes: impacted deployment container found")
// }
// }
updated, shouldUpdateDeployment, err := p.checkDeployment(newVersion, repo, &deployment)
if err != nil { if err != nil {
log.WithFields(log.Fields{ log.WithFields(log.Fields{
"error": err, "error": err,
"image_name": c.Image, "deployment": deployment.Name,
"keel_policy": policy,
}).Error("provider.kubernetes: failed to get image version, is it tagged as semver?")
continue
}
log.WithFields(log.Fields{
"labels": labels,
"name": deployment.Name,
"namespace": deployment.Namespace, "namespace": deployment.Namespace,
"image": c.Image, }).Error("provider.kubernetes: got error while checking deployment")
"current_version": currentVersion.String(),
"policy": policy,
}).Info("provider.kubernetes: current image version")
shouldUpdateContainer, err := version.ShouldUpdate(currentVersion, newVersion, policy)
if err != nil {
log.WithFields(log.Fields{
"error": err,
"new_version": newVersion.String(),
"current_version": currentVersion.String(),
"keel_policy": policy,
}).Error("provider.kubernetes: got error while checking whether deployment should be updated")
continue continue
} }
log.WithFields(log.Fields{
"labels": labels,
"name": deployment.Name,
"namespace": deployment.Namespace,
"image": c.Image,
"current_version": currentVersion.String(),
"new_version": newVersion.String(),
"policy": policy,
"should_update": shouldUpdateContainer,
}).Info("provider.kubernetes: checked version, deciding whether to update")
if shouldUpdateContainer {
// updating image
c.Image = fmt.Sprintf("%s:%s", containerImageName, newVersion.String())
deployment.Spec.Template.Spec.Containers[idx] = c
// marking this deployment for update
shouldUpdateDeployment = true
log.WithFields(log.Fields{
"parsed_image": containerImageName,
"raw_image_name": c.Image,
"target_image": repo.Name,
"target_image_tag": repo.Tag,
"policy": policy,
}).Info("provider.kubernetes: impacted deployment container found")
}
}
if shouldUpdateDeployment { if shouldUpdateDeployment {
impacted = append(impacted, deployment) impacted = append(impacted, updated)
} }
} }
} }