Release v0.1.0

Switch to Quay and Go 1.11

.travis.yml

@@ -2,7 +2,7 @@ sudo: required
 language: go
 
 go:
-- 1.10.x
+- 1.11.x
 
 services:
 - docker
@@ -14,25 +14,28 @@ addons:
 
 script:
 - set -e
-- make test
+- make test-fmt
+- make test-codegen
+- go test -race -coverprofile=coverage.txt -covermode=atomic ./pkg/controller/
 - make build
 
 after_success:
 - if [ -z "$DOCKER_USER" ]; then
-    echo "PR build, skipping Docker Hub push";
+    echo "PR build, skipping image push";
   else
-    docker tag stefanprodan/flagger:latest stefanprodan/flagger:${TRAVIS_COMMIT};
-    echo $DOCKER_PASS | docker login -u=$DOCKER_USER --password-stdin;
-    docker push stefanprodan/flagger:${TRAVIS_COMMIT};
+    docker tag stefanprodan/flagger:latest quay.io/stefanprodan/flagger:${TRAVIS_COMMIT};
+    echo $DOCKER_PASS | docker login -u=$DOCKER_USER --password-stdin quay.io;
+    docker push quay.io/stefanprodan/flagger:${TRAVIS_COMMIT};
   fi
 - if [ -z "$TRAVIS_TAG" ]; then
-    echo "Not a release, skipping Docker Hub push";
+    echo "Not a release, skipping image push";
   else
-    docker tag stefanprodan/flagger:latest stefanprodan/flagger:$TRAVIS_TAG;
-    echo $DOCKER_PASS | docker login -u=$DOCKER_USER --password-stdin;
-    docker push stefanprodan/flagger:latest;
-    docker push stefanprodan/flagger:$TRAVIS_TAG;
+    docker tag stefanprodan/flagger:latest quay.io/stefanprodan/flagger:${TRAVIS_TAG};
+    echo $DOCKER_PASS | docker login -u=$DOCKER_USER --password-stdin quay.io;
+    docker push quay.io/stefanprodan/flagger:$TRAVIS_TAG;
   fi
+- bash <(curl -s https://codecov.io/bash)
+- rm coverage.txt
 
 deploy:
 - provider: script

CONTRIBUTING.md

@@ -0,0 +1,72 @@
+# How to Contribute
+
+Flagger is [Apache 2.0 licensed](LICENSE) and accepts contributions via GitHub
+pull requests. This document outlines some of the conventions on development
+workflow, commit message formatting, contact points and other resources to make
+it easier to get your contribution accepted.
+
+We gratefully welcome improvements to documentation as well as to code.
+
+## Certificate of Origin
+
+By contributing to this project you agree to the Developer Certificate of
+Origin (DCO). This document was created by the Linux Kernel community and is a
+simple statement that you, as a contributor, have the legal right to make the
+contribution.
+
+## Chat
+
+The project uses Slack: To join the conversation, simply join the
+[Weave community](https://slack.weave.works/) Slack workspace.
+
+## Getting Started
+
+- Fork the repository on GitHub
+- If you want to contribute as a developer, continue reading this document for further instructions
+- If you have questions, concerns, get stuck or need a hand, let us know
+  on the Slack channel. We are happy to help and look forward to having
+  you part of the team. No matter in which capacity.
+- Play with the project, submit bugs, submit pull requests!
+
+## Contribution workflow
+
+This is a rough outline of how to prepare a contribution:
+
+- Create a topic branch from where you want to base your work (usually branched from master).
+- Make commits of logical units.
+- Make sure your commit messages are in the proper format (see below).
+- Push your changes to a topic branch in your fork of the repository.
+- If you changed code:
+  - add automated tests to cover your changes
+- Submit a pull request to the original repository.
+
+## Acceptance policy
+
+These things will make a PR more likely to be accepted:
+
+- a well-described requirement
+- new code and tests follow the conventions in old code and tests
+- a good commit message (see below)
+- All code must abide [Go Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments)
+- Names should abide [What's in a name](https://talks.golang.org/2014/names.slide#1)
+- Code must build on both Linux and Darwin, via plain `go build`
+- Code should have appropriate test coverage and tests should be written
+  to work with `go test`
+
+In general, we will merge a PR once one maintainer has endorsed it.
+For substantial changes, more people may become involved, and you might
+get asked to resubmit the PR or divide the changes into more than one PR.
+
+### Format of the Commit Message
+
+For Flux we prefer the following rules for good commit messages:
+
+- Limit the subject to 50 characters and write as the continuation
+  of the sentence "If applied, this commit will ..."
+- Explain what and why in the body, if more than a trivial change;
+  wrap it at 72 characters.
+
+The [following article](https://chris.beams.io/posts/git-commit/#seven-rules)
+has some more helpful advice on documenting your work.
+
+This doc is adapted from the [Weaveworks Flux](https://github.com/weaveworks/flux/blob/master/CONTRIBUTING.md)

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.10
+FROM golang:1.11
 
 RUN mkdir -p /go/src/github.com/stefanprodan/flagger/
 
@@ -13,17 +13,17 @@ RUN GIT_COMMIT=$(git rev-list -1 HEAD) && \
 
 FROM alpine:3.8
 
-RUN addgroup -S app \
-    && adduser -S -g app app \
+RUN addgroup -S flagger \
+    && adduser -S -g flagger flagger \
     && apk --no-cache add ca-certificates
 
-WORKDIR /home/app
+WORKDIR /home/flagger
 
 COPY --from=0 /go/src/github.com/stefanprodan/flagger/flagger .
 
-RUN chown -R app:app ./
+RUN chown -R flagger:flagger ./
 
-USER app
+USER flagger
 
 ENTRYPOINT ["./flagger"]
 

Gopkg.lock

@@ -25,14 +25,6 @@
   revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
   version = "v1.1.1"
 
-[[projects]]
-  digest = "1:ade392a843b2035effb4b4a2efa2c3bab3eb29b992e98bacf9c898b0ecb54e45"
-  name = "github.com/fatih/color"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "5b77d2a35fb0ede96d138fc9a99f5c9b6aef11b4"
-  version = "v1.7.0"
-
 [[projects]]
   digest = "1:81466b4218bf6adddac2572a30ac733a9255919bc2f470b4827a317bd4ee1756"
   name = "github.com/ghodss/yaml"
@@ -92,10 +84,11 @@
   revision = "4030bb1f1f0c35b30ca7009e9ebd06849dd45306"
 
 [[projects]]
-  digest = "1:2e3c336fc7fde5c984d2841455a658a6d626450b1754a854b3b32e7a8f49a07a"
+  digest = "1:d2754cafcab0d22c13541618a8029a70a8959eb3525ff201fe971637e2274cd0"
   name = "github.com/google/go-cmp"
   packages = [
     "cmp",
+    "cmp/cmpopts",
     "cmp/internal/diff",
     "cmp/internal/function",
     "cmp/internal/value",
@@ -170,7 +163,7 @@
   revision = "f2b4162afba35581b6d4a50d3b8f34e33c144682"
 
 [[projects]]
-  digest = "1:555e31114bd0e89c6340c47ab73162e8c8d873e4d88914310923566f487bfcd5"
+  digest = "1:03a74b0d86021c8269b52b7c908eb9bb3852ff590b363dad0a807cf58cec2f89"
   name = "github.com/knative/pkg"
   packages = [
     "apis",
@@ -182,31 +175,19 @@
     "apis/istio/common/v1alpha1",
     "apis/istio/v1alpha3",
     "client/clientset/versioned",
+    "client/clientset/versioned/fake",
     "client/clientset/versioned/scheme",
     "client/clientset/versioned/typed/authentication/v1alpha1",
+    "client/clientset/versioned/typed/authentication/v1alpha1/fake",
     "client/clientset/versioned/typed/duck/v1alpha1",
+    "client/clientset/versioned/typed/duck/v1alpha1/fake",
     "client/clientset/versioned/typed/istio/v1alpha3",
+    "client/clientset/versioned/typed/istio/v1alpha3/fake",
     "signals",
   ]
   pruneopts = "NUT"
   revision = "c15d7c8f2220a7578b33504df6edefa948c845ae"
 
-[[projects]]
-  digest = "1:08c231ec84231a7e23d67e4b58f975e1423695a32467a362ee55a803f9de8061"
-  name = "github.com/mattn/go-colorable"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
-  version = "v0.0.9"
-
-[[projects]]
-  digest = "1:bffa444ca07c69c599ae5876bc18b25bfd5fa85b297ca10a25594d284a7e9c5d"
-  name = "github.com/mattn/go-isatty"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "6ca4dbf54d38eea1a992b3c722a76a5d1c4cb25c"
-  version = "v0.0.4"
-
 [[projects]]
   digest = "1:5985ef4caf91ece5d54817c11ea25f182697534f8ae6521eadcd628c142ac4b6"
   name = "github.com/matttproud/golang_protobuf_extensions"
@@ -547,42 +528,72 @@
   version = "kubernetes-1.11.0"
 
 [[projects]]
-  digest = "1:29e55bcff61dd3d1f768724450a3933ea76e6277684796eb7c315154f41db902"
+  digest = "1:c7d6cf5e28c377ab4000b94b6b9ff562c4b13e7e8b948ad943f133c5104be011"
   name = "k8s.io/client-go"
   packages = [
     "discovery",
     "discovery/fake",
     "kubernetes",
+    "kubernetes/fake",
     "kubernetes/scheme",
     "kubernetes/typed/admissionregistration/v1alpha1",
+    "kubernetes/typed/admissionregistration/v1alpha1/fake",
     "kubernetes/typed/admissionregistration/v1beta1",
+    "kubernetes/typed/admissionregistration/v1beta1/fake",
     "kubernetes/typed/apps/v1",
+    "kubernetes/typed/apps/v1/fake",
     "kubernetes/typed/apps/v1beta1",
+    "kubernetes/typed/apps/v1beta1/fake",
     "kubernetes/typed/apps/v1beta2",
+    "kubernetes/typed/apps/v1beta2/fake",
     "kubernetes/typed/authentication/v1",
+    "kubernetes/typed/authentication/v1/fake",
     "kubernetes/typed/authentication/v1beta1",
+    "kubernetes/typed/authentication/v1beta1/fake",
     "kubernetes/typed/authorization/v1",
+    "kubernetes/typed/authorization/v1/fake",
     "kubernetes/typed/authorization/v1beta1",
+    "kubernetes/typed/authorization/v1beta1/fake",
     "kubernetes/typed/autoscaling/v1",
+    "kubernetes/typed/autoscaling/v1/fake",
     "kubernetes/typed/autoscaling/v2beta1",
+    "kubernetes/typed/autoscaling/v2beta1/fake",
     "kubernetes/typed/batch/v1",
+    "kubernetes/typed/batch/v1/fake",
     "kubernetes/typed/batch/v1beta1",
+    "kubernetes/typed/batch/v1beta1/fake",
     "kubernetes/typed/batch/v2alpha1",
+    "kubernetes/typed/batch/v2alpha1/fake",
     "kubernetes/typed/certificates/v1beta1",
+    "kubernetes/typed/certificates/v1beta1/fake",
     "kubernetes/typed/core/v1",
+    "kubernetes/typed/core/v1/fake",
     "kubernetes/typed/events/v1beta1",
+    "kubernetes/typed/events/v1beta1/fake",
     "kubernetes/typed/extensions/v1beta1",
+    "kubernetes/typed/extensions/v1beta1/fake",
     "kubernetes/typed/networking/v1",
+    "kubernetes/typed/networking/v1/fake",
     "kubernetes/typed/policy/v1beta1",
+    "kubernetes/typed/policy/v1beta1/fake",
     "kubernetes/typed/rbac/v1",
+    "kubernetes/typed/rbac/v1/fake",
     "kubernetes/typed/rbac/v1alpha1",
+    "kubernetes/typed/rbac/v1alpha1/fake",
     "kubernetes/typed/rbac/v1beta1",
+    "kubernetes/typed/rbac/v1beta1/fake",
     "kubernetes/typed/scheduling/v1alpha1",
+    "kubernetes/typed/scheduling/v1alpha1/fake",
     "kubernetes/typed/scheduling/v1beta1",
+    "kubernetes/typed/scheduling/v1beta1/fake",
     "kubernetes/typed/settings/v1alpha1",
+    "kubernetes/typed/settings/v1alpha1/fake",
     "kubernetes/typed/storage/v1",
+    "kubernetes/typed/storage/v1/fake",
     "kubernetes/typed/storage/v1alpha1",
+    "kubernetes/typed/storage/v1alpha1/fake",
     "kubernetes/typed/storage/v1beta1",
+    "kubernetes/typed/storage/v1beta1/fake",
     "pkg/apis/clientauthentication",
     "pkg/apis/clientauthentication/v1alpha1",
     "pkg/apis/clientauthentication/v1beta1",
@@ -675,24 +686,29 @@
   analyzer-name = "dep"
   analyzer-version = 1
   input-imports = [
-    "github.com/fatih/color",
     "github.com/google/go-cmp/cmp",
+    "github.com/google/go-cmp/cmp/cmpopts",
     "github.com/istio/glog",
     "github.com/knative/pkg/apis/istio/v1alpha3",
     "github.com/knative/pkg/client/clientset/versioned",
+    "github.com/knative/pkg/client/clientset/versioned/fake",
     "github.com/knative/pkg/signals",
     "github.com/prometheus/client_golang/prometheus/promhttp",
     "go.uber.org/zap",
     "go.uber.org/zap/zapcore",
     "k8s.io/api/apps/v1",
+    "k8s.io/api/autoscaling/v1",
+    "k8s.io/api/autoscaling/v2beta1",
     "k8s.io/api/core/v1",
     "k8s.io/apimachinery/pkg/api/errors",
+    "k8s.io/apimachinery/pkg/api/resource",
     "k8s.io/apimachinery/pkg/apis/meta/v1",
     "k8s.io/apimachinery/pkg/labels",
     "k8s.io/apimachinery/pkg/runtime",
     "k8s.io/apimachinery/pkg/runtime/schema",
     "k8s.io/apimachinery/pkg/runtime/serializer",
     "k8s.io/apimachinery/pkg/types",
+    "k8s.io/apimachinery/pkg/util/intstr",
     "k8s.io/apimachinery/pkg/util/runtime",
     "k8s.io/apimachinery/pkg/util/sets/types",
     "k8s.io/apimachinery/pkg/util/wait",
@@ -700,6 +716,7 @@
     "k8s.io/client-go/discovery",
     "k8s.io/client-go/discovery/fake",
     "k8s.io/client-go/kubernetes",
+    "k8s.io/client-go/kubernetes/fake",
     "k8s.io/client-go/kubernetes/scheme",
     "k8s.io/client-go/kubernetes/typed/core/v1",
     "k8s.io/client-go/plugin/pkg/client/auth/gcp",

Makefile

@@ -4,7 +4,10 @@ VERSION_MINOR:=$(shell grep 'VERSION' pkg/version/version.go | awk '{ print $$4
 PATCH:=$(shell grep 'VERSION' pkg/version/version.go | awk '{ print $$4 }' | tr -d '"' | awk -F. '{print $$NF}')
 SOURCE_DIRS = cmd pkg/apis pkg/controller pkg/server pkg/logging pkg/version
 run:
-	go run cmd/flagger/* -kubeconfig=$$HOME/.kube/config -log-level=info -metrics-server=https://prometheus.istio.weavedx.com
+	go run cmd/flagger/* -kubeconfig=$$HOME/.kube/config -log-level=info \
+	-metrics-server=https://prometheus.iowa.weavedx.com \
+	-slack-url=https://hooks.slack.com/services/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 \
+	-slack-channel="devops-alerts"
 
 build:
 	docker build -t stefanprodan/flagger:$(TAG) . -f Dockerfile
@@ -25,12 +28,13 @@ test: test-fmt test-codegen
 	go test ./...
 
 helm-package:
-	cd charts/ && helm package flagger/ && helm package podinfo-flagger/ && helm package grafana/
+	cd charts/ && helm package flagger/ && helm package grafana/
 	mv charts/*.tgz docs/
 	helm repo index docs --url https://stefanprodan.github.io/flagger --merge ./docs/index.yaml
 
 helm-up:
 	helm upgrade --install flagger ./charts/flagger --namespace=istio-system --set crd.create=false
+	helm upgrade --install flagger-grafana ./charts/grafana --namespace=istio-system
 
 version-set:
 	@next="$(TAG)" && \
@@ -52,10 +56,10 @@ version-up:
 
 dev-up: version-up
 	@echo "Starting build/push/deploy pipeline for $(VERSION)"
-	docker build -t stefanprodan/flagger:$(VERSION) . -f Dockerfile
-	docker push stefanprodan/flagger:$(VERSION)
+	docker build -t quay.io/stefanprodan/flagger:$(VERSION) . -f Dockerfile
+	docker push quay.io/stefanprodan/flagger:$(VERSION)
 	kubectl apply -f ./artifacts/flagger/crd.yaml
-	helm upgrade --install flagger ./charts/flagger --namespace=istio-system --set crd.create=false
+	helm upgrade -i flagger ./charts/flagger --namespace=istio-system --set crd.create=false
 
 release:
 	git tag $(VERSION)
@@ -68,3 +72,7 @@ release-set: fmt version-set helm-package
 	git tag $(VERSION)
 	git push origin $(VERSION)
 
+reset-test:
+	kubectl delete -f ./artifacts/namespaces
+	kubectl apply -f ./artifacts/namespaces
+	kubectl apply -f ./artifacts/canaries

README.md

@@ -2,13 +2,12 @@
 
 [![build](https://travis-ci.org/stefanprodan/flagger.svg?branch=master)](https://travis-ci.org/stefanprodan/flagger)
 [![report](https://goreportcard.com/badge/github.com/stefanprodan/flagger)](https://goreportcard.com/report/github.com/stefanprodan/flagger)
+[![codecov](https://codecov.io/gh/stefanprodan/flagger/branch/master/graph/badge.svg)](https://codecov.io/gh/stefanprodan/flagger)
 [![license](https://img.shields.io/github/license/stefanprodan/flagger.svg)](https://github.com/stefanprodan/flagger/blob/master/LICENSE)
 [![release](https://img.shields.io/github/release/stefanprodan/flagger/all.svg)](https://github.com/stefanprodan/flagger/releases)
 
 Flagger is a Kubernetes operator that automates the promotion of canary deployments
 using Istio routing for traffic shifting and Prometheus metrics for canary analysis.
-The project is currently in experimental phase and it is expected that breaking changes 
-to the API will be made in the upcoming releases.
 
 ### Install 
 
@@ -19,7 +18,7 @@ Deploy Flagger in the `istio-system` namespace using Helm:
 
 ```bash
 # add the Helm repository
-helm repo add flagger https://stefanprodan.github.io/flagger
+helm repo add flagger https://flagger.app
 
 # install or upgrade
 helm upgrade -i flagger flagger/flagger \
@@ -32,10 +31,11 @@ Flagger is compatible with Kubernetes >1.10.0 and Istio >1.0.0.
 
 ### Usage
 
-Flagger requires two Kubernetes [deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/): 
-one for the version you want to upgrade called _primary_ and one for the _canary_.
-Each deployment must have a corresponding ClusterIP [service](https://kubernetes.io/docs/concepts/services-networking/service/) 
-that exposes a port named http or https. These services are used as destinations in a Istio [virtual service](https://istio.io/docs/reference/config/istio.networking.v1alpha3/#VirtualService).
+Flagger takes a Kubernetes deployment and creates a series of objects 
+(Kubernetes [deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/), 
+ClusterIP [services](https://kubernetes.io/docs/concepts/services-networking/service/) and 
+Istio [virtual services](https://istio.io/docs/reference/config/istio.networking.v1alpha3/#VirtualService)) 
+to drive the canary analysis and promotion.
 
 ![flagger-overview](https://raw.githubusercontent.com/stefanprodan/flagger/master/docs/diagrams/flagger-overview.png)
 
@@ -44,25 +44,25 @@ Gated canary promotion stages:
 * scan for canary deployments
 * check Istio virtual service routes are mapped to primary and canary ClusterIP services
 * check primary and canary deployments status
-    * halt rollout if a rolling update is underway
-    * halt rollout if pods are unhealthy
+    * halt advancement if a rolling update is underway
+    * halt advancement if pods are unhealthy
 * increase canary traffic weight percentage from 0% to 5% (step weight)
 * check canary HTTP request success rate and latency
-    * halt rollout if any metric is under the specified threshold
+    * halt advancement if any metric is under the specified threshold
     * increment the failed checks counter
 * check if the number of failed checks reached the threshold
     * route all traffic to primary
     * scale to zero the canary deployment and mark it as failed
     * wait for the canary deployment to be updated (revision bump) and start over
 * increase canary traffic weight by 5% (step weight) till it reaches 50% (max weight) 
-    * halt rollout while canary request success rate is under the threshold
-    * halt rollout while canary request duration P99 is over the threshold
-    * halt rollout if the primary or canary deployment becomes unhealthy 
-    * halt rollout while canary deployment is being scaled up/down by HPA
+    * halt advancement while canary request success rate is under the threshold
+    * halt advancement while canary request duration P99 is over the threshold
+    * halt advancement if the primary or canary deployment becomes unhealthy 
+    * halt advancement while canary deployment is being scaled up/down by HPA
 * promote canary to primary
     * copy canary deployment spec template over primary
 * wait for primary rolling update to finish
-    * halt rollout if pods are unhealthy
+    * halt advancement if pods are unhealthy
 * route all traffic to primary
 * scale to zero the canary deployment
 * mark rollout as finished
@@ -70,76 +70,43 @@ Gated canary promotion stages:
 
 You can change the canary analysis _max weight_ and the _step weight_ percentage in the Flagger's custom resource.
 
-Assuming the primary deployment is named _podinfo_ and the canary one _podinfo-canary_, Flagger will require 
-a virtual service configured with weight-based routing:
+For a deployment named _podinfo_, a canary promotion can be defined using Flagger's custom resource:
 
 ```yaml
-apiVersion: networking.istio.io/v1alpha3
-kind: VirtualService
-metadata:
-  name: podinfo
-spec:
-  hosts:
-  - podinfo
-  http:
-  - route:
-    - destination:
-        host: podinfo
-        port:
-          number: 9898
-      weight: 100
-    - destination:
-        host: podinfo-canary
-        port:
-          number: 9898
-      weight: 0
-```
-
-Primary and canary services should expose a port named http:
-
-```yaml
-apiVersion: v1
-kind: Service
-metadata:
-  name: podinfo-canary
-spec:
-  type: ClusterIP
-  selector:
-    app: podinfo-canary
-  ports:
-  - name: http
-    port: 9898
-    targetPort: 9898
-```
-
-Based on the two deployments, services and virtual service, a canary promotion can be defined using Flagger's custom resource:
-
-```yaml
-apiVersion: flagger.app/v1beta1
+apiVersion: flagger.app/v1alpha1
 kind: Canary
 metadata:
   name: podinfo
   namespace: test
 spec:
-  targetKind: Deployment
-  virtualService:
+  # deployment reference
+  targetRef:
+    apiVersion: apps/v1
+    kind: Deployment
     name: podinfo
-  primary:
+  # hpa reference (optional)
+  autoscalerRef:
+    apiVersion: autoscaling/v2beta1
+    kind: HorizontalPodAutoscaler
     name: podinfo
-    host: podinfo
-  canary:
-    name: podinfo-canary
-    host: podinfo-canary
+  service:
+    # container port
+    port: 9898
+    # Istio gateways (optional)
+    gateways:
+    - public-gateway.istio-system.svc.cluster.local
+    # Istio virtual service host names (optional)
+    hosts:
+    - app.istio.weavedx.com
   canaryAnalysis:
-    # max number of failed checks
-    # before rolling back the canary
-    threshold: 10
+    # max number of failed metric checks before rollback
+    threshold: 5
     # max traffic percentage routed to canary
     # percentage (0-100)
     maxWeight: 50
     # canary increment step
     # percentage (0-100)
-    stepWeight: 5
+    stepWeight: 10
     metrics:
     - name: istio_requests_total
       # minimum req success rate (non 5xx responses)
@@ -150,7 +117,7 @@ spec:
       # maximum req duration P99
       # milliseconds
       threshold: 500
-      interval: 1m
+      interval: 30s
 ```
 
 The canary analysis is using the following promql queries:
@@ -198,8 +165,6 @@ histogram_quantile(0.99,
 
 ### Automated canary analysis, promotions and rollbacks
 
-![flagger-canary](https://raw.githubusercontent.com/stefanprodan/flagger/master/docs/diagrams/flagger-canary-hpa.png)
-
 Create a test namespace with Istio sidecar injection enabled:
 
 ```bash
@@ -208,66 +173,72 @@ export REPO=https://raw.githubusercontent.com/stefanprodan/flagger/master
 kubectl apply -f ${REPO}/artifacts/namespaces/test.yaml
 ```
 
-Create the primary deployment, service and hpa:
+Create a deployment and a horizontal pod autoscaler:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/workloads/primary-deployment.yaml
-kubectl apply -f ${REPO}/artifacts/workloads/primary-service.yaml
-kubectl apply -f ${REPO}/artifacts/workloads/primary-hpa.yaml
+kubectl apply -f ${REPO}/artifacts/canaries/deployment.yaml
+kubectl apply -f ${REPO}/artifacts/canaries/hpa.yaml
 ```
 
-Create the canary deployment, service and hpa:
+Create a canary promotion custom resource (replace the Istio gateway and the internet domain with your own):
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/workloads/canary-deployment.yaml
-kubectl apply -f ${REPO}/artifacts/workloads/canary-service.yaml
-kubectl apply -f ${REPO}/artifacts/workloads/canary-hpa.yaml
+kubectl apply -f ${REPO}/artifacts/canaries/canary.yaml
 ```
 
-Create a virtual service (replace the Istio gateway and the internet domain with your own):
+After a couple of seconds Flagger will create the canary objects:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/workloads/virtual-service.yaml
+# applied 
+deployment.apps/podinfo
+horizontalpodautoscaler.autoscaling/podinfo
+canary.flagger.app/podinfo
+# generated 
+deployment.apps/podinfo-primary
+horizontalpodautoscaler.autoscaling/podinfo-primary
+service/podinfo
+service/podinfo-canary
+service/podinfo-primary
+virtualservice.networking.istio.io/podinfo
 ```
 
-Create a canary promotion custom resource:
+![flagger-canary-steps](https://raw.githubusercontent.com/stefanprodan/flagger/master/docs/diagrams/flagger-canary-steps.png)
+
+Trigger a canary deployment by updating the container image:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/rollouts/podinfo.yaml
+kubectl -n test set image deployment/podinfo \
+podinfod=quay.io/stefanprodan/podinfo:1.2.1
 ```
 
-Canary promotion output:
+Flagger detects that the deployment revision changed and starts a new rollout:
 
 ```
 kubectl -n test describe canary/podinfo
 
 Status:
-  Canary Revision:  16271121
-  Failed Checks:    6
+  Canary Revision:  19871136
+  Failed Checks:    0
   State:            finished
 Events:
   Type     Reason  Age   From     Message
   ----     ------  ----  ----     -------
-  Normal   Synced  3m    flagger  Starting canary deployment for podinfo.test
+  Normal   Synced  3m    flagger  New revision detected podinfo.test
+  Normal   Synced  3m    flagger  Scaling up podinfo.test
+  Warning  Synced  3m    flagger  Waiting for podinfo.test rollout to finish: 0 of 1 updated replicas are available
   Normal   Synced  3m    flagger  Advance podinfo.test canary weight 5
   Normal   Synced  3m    flagger  Advance podinfo.test canary weight 10
   Normal   Synced  3m    flagger  Advance podinfo.test canary weight 15
-  Warning  Synced  3m    flagger  Halt podinfo.test advancement request duration 2.525s > 500ms
-  Warning  Synced  3m    flagger  Halt podinfo.test advancement request duration 1.567s > 500ms
-  Warning  Synced  3m    flagger  Halt podinfo.test advancement request duration 823ms > 500ms
   Normal   Synced  2m    flagger  Advance podinfo.test canary weight 20
   Normal   Synced  2m    flagger  Advance podinfo.test canary weight 25
   Normal   Synced  1m    flagger  Advance podinfo.test canary weight 30
-  Warning  Synced  1m    flagger  Halt podinfo.test advancement success rate 82.33% < 99%
-  Warning  Synced  1m    flagger  Halt podinfo.test advancement success rate 87.22% < 99%
-  Warning  Synced  1m    flagger  Halt podinfo.test advancement success rate 94.74% < 99%
   Normal   Synced  1m    flagger  Advance podinfo.test canary weight 35
   Normal   Synced  55s   flagger  Advance podinfo.test canary weight 40
   Normal   Synced  45s   flagger  Advance podinfo.test canary weight 45
   Normal   Synced  35s   flagger  Advance podinfo.test canary weight 50
-  Normal   Synced  25s   flagger  Copying podinfo-canary.test template spec to podinfo.test
-  Warning  Synced  15s   flagger  Waiting for podinfo.test rollout to finish: 1 of 2 updated replicas are available
-  Normal   Synced  5s    flagger  Promotion completed! Scaling down podinfo-canary.test
+  Normal   Synced  25s   flagger  Copying podinfo.test template spec to podinfo-primary.test
+  Warning  Synced  15s   flagger  Waiting for podinfo-primary.test rollout to finish: 1 of 2 updated replicas are available
+  Normal   Synced  5s    flagger  Promotion completed! Scaling down podinfo.test
 ```
 
 During the canary analysis you can generate HTTP 500 errors and high latency to test if Flagger pauses the rollout.
@@ -313,45 +284,8 @@ Events:
   Normal   Synced  2m    flagger  Halt podinfo.test advancement success rate 55.06% < 99%
   Normal   Synced  2m    flagger  Halt podinfo.test advancement success rate 47.00% < 99%
   Normal   Synced  2m    flagger  (combined from similar events): Halt podinfo.test advancement success rate 38.08% < 99%
-  Warning  Synced  1m    flagger  Rolling back podinfo-canary.test failed checks threshold reached 10
-  Warning  Synced  1m    flagger  Canary failed! Scaling down podinfo-canary.test
-```
-
-Trigger a new canary deployment by updating the canary image:
-
-```bash
-kubectl -n test set image deployment/podinfo-canary \
-podinfod=quay.io/stefanprodan/podinfo:1.2.1
-```
-
-Steer detects that the canary revision changed and starts a new rollout:
-
-```
-kubectl -n test describe canary/podinfo
-
-Status:
-  Canary Revision:  19871136
-  Failed Checks:    0
-  State:            finished
-Events:
-  Type     Reason  Age   From     Message
-  ----     ------  ----  ----     -------
-  Normal   Synced  3m    flagger  New revision detected podinfo-canary.test old 17211012 new 17246876
-  Normal   Synced  3m    flagger  Scaling up podinfo.test
-  Warning  Synced  3m    flagger  Waiting for podinfo.test rollout to finish: 0 of 1 updated replicas are available
-  Normal   Synced  3m    flagger  Advance podinfo.test canary weight 5
-  Normal   Synced  3m    flagger  Advance podinfo.test canary weight 10
-  Normal   Synced  3m    flagger  Advance podinfo.test canary weight 15
-  Normal   Synced  2m    flagger  Advance podinfo.test canary weight 20
-  Normal   Synced  2m    flagger  Advance podinfo.test canary weight 25
-  Normal   Synced  1m    flagger  Advance podinfo.test canary weight 30
-  Normal   Synced  1m    flagger  Advance podinfo.test canary weight 35
-  Normal   Synced  55s   flagger  Advance podinfo.test canary weight 40
-  Normal   Synced  45s   flagger  Advance podinfo.test canary weight 45
-  Normal   Synced  35s   flagger  Advance podinfo.test canary weight 50
-  Normal   Synced  25s   flagger  Copying podinfo-canary.test template spec to podinfo.test
-  Warning  Synced  15s   flagger  Waiting for podinfo.test rollout to finish: 1 of 2 updated replicas are available
-  Normal   Synced  5s    flagger  Promotion completed! Scaling down podinfo-canary.test
+  Warning  Synced  1m    flagger  Rolling back podinfo.test failed checks threshold reached 10
+  Warning  Synced  1m    flagger  Canary failed! Scaling down podinfo.test
 ```
 
 ### Monitoring
@@ -388,18 +322,55 @@ Advance podinfo.test canary weight 40
 Halt podinfo.test advancement request duration 1.515s > 500ms
 Advance podinfo.test canary weight 45
 Advance podinfo.test canary weight 50
-Copying podinfo-canary.test template spec to podinfo-primary.test
-Scaling down podinfo-canary.test
-Promotion completed! podinfo-canary.test revision 81289
+Copying podinfo.test template spec to podinfo-primary.test
+Halt podinfo-primary.test advancement waiting for rollout to finish: 1 old replicas are pending termination
+Scaling down podinfo.test
+Promotion completed! podinfo.test
 ```
 
+Flagger exposes Prometheus metrics that can be used to determine the canary analysis status and the destination weight values:
+
+```bash
+# Canaries total gauge
+flagger_canary_total{namespace="test"} 1
+
+# Canary promotion last known status gauge
+# 0 - running, 1 - successful, 2 - failed
+flagger_canary_status{name="podinfo" namespace="test"} 1
+
+# Canary traffic weight gauge
+flagger_canary_weight{workload="podinfo-primary" namespace="test"} 95
+flagger_canary_weight{workload="podinfo" namespace="test"} 5
+
+# Seconds spent performing canary analysis histogram
+flagger_canary_duration_seconds_bucket{name="podinfo",namespace="test",le="10"} 6
+flagger_canary_duration_seconds_bucket{name="podinfo",namespace="test",le="+Inf"} 6
+flagger_canary_duration_seconds_sum{name="podinfo",namespace="test"} 17.3561329
+flagger_canary_duration_seconds_count{name="podinfo",namespace="test"} 6
+```
+
+### Alerting
+
+Flagger can be configured to send Slack notifications:
+
+```bash
+helm upgrade -i flagger flagger/flagger \
+--namespace=istio-system \
+--set slack.url=https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK \
+--set slack.channel=general \
+--set slack.user=flagger
+```
+
+Once configured with a Slack incoming webhook, Flagger will post messages when a canary deployment has been initialized,
+when a new revision has been detected and if the canary analysis failed or succeeded.
+
+![flagger-slack](https://raw.githubusercontent.com/stefanprodan/flagger/master/docs/screens/slack-notifications.png)
+
 ### Roadmap
 
-* Extend the canary analysis and promotion to other types than Kubernetes deployments such as Flux Helm releases or OpenFaaS functions
 * Extend the validation mechanism to support other metrics than HTTP success rate and latency
 * Add support for comparing the canary metrics to the primary ones and do the validation based on the derivation between the two
-* Alerting: Trigger Alertmanager on successful or failed promotions (Prometheus instrumentation of the canary analysis)  
-* Reporting: publish canary analysis results to Slack/Jira/etc
+* Extend the canary analysis and promotion to other types than Kubernetes deployments such as Flux Helm releases or OpenFaaS functions
 
 ### Contributing
 

artifacts/canaries/canary.yaml

@@ -0,0 +1,45 @@
+apiVersion: flagger.app/v1alpha1
+kind: Canary
+metadata:
+  name: podinfo
+  namespace: test
+spec:
+  # deployment reference
+  targetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: podinfo
+  # HPA reference (optional)
+  autoscalerRef:
+    apiVersion: autoscaling/v2beta1
+    kind: HorizontalPodAutoscaler
+    name: podinfo
+  service:
+    # container port
+    port: 9898
+    # Istio gateways (optional)
+    gateways:
+    - public-gateway.istio-system.svc.cluster.local
+    # Istio virtual service host names (optional)
+    hosts:
+    - app.iowa.weavedx.com
+  canaryAnalysis:
+    # max number of failed metric checks before rollback
+    threshold: 10
+    # max traffic percentage routed to canary
+    # percentage (0-100)
+    maxWeight: 50
+    # canary increment step
+    # percentage (0-100)
+    stepWeight: 5
+    metrics:
+    - name: istio_requests_total
+      # minimum req success rate (non 5xx responses)
+      # percentage (0-100)
+      threshold: 99
+      interval: 1m
+    - name: istio_request_duration_seconds_bucket
+      # maximum req duration P99
+      # milliseconds
+      threshold: 500
+      interval: 30s

artifacts/canaries/deployment.yaml

@@ -0,0 +1,66 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: podinfo
+  namespace: test
+  labels:
+    app: podinfo
+spec:
+  minReadySeconds: 5
+  revisionHistoryLimit: 5
+  strategy:
+    rollingUpdate:
+      maxUnavailable: 0
+    type: RollingUpdate
+  selector:
+    matchLabels:
+      app: podinfo
+  template:
+    metadata:
+      annotations:
+        prometheus.io/scrape: "true"
+      labels:
+        app: podinfo
+    spec:
+      containers:
+      - name: podinfod
+        image: quay.io/stefanprodan/podinfo:1.3.0
+        imagePullPolicy: IfNotPresent
+        ports:
+        - containerPort: 9898
+          name: http
+          protocol: TCP
+        command:
+        - ./podinfo
+        - --port=9898
+        - --level=info
+        - --random-delay=false
+        - --random-error=false
+        env:
+        - name: PODINFO_UI_COLOR
+          value: blue
+        livenessProbe:
+          exec:
+            command:
+            - podcli
+            - check
+            - http
+            - localhost:9898/healthz
+          initialDelaySeconds: 5
+          timeoutSeconds: 5
+        readinessProbe:
+          exec:
+            command:
+            - podcli
+            - check
+            - http
+            - localhost:9898/readyz
+          initialDelaySeconds: 5
+          timeoutSeconds: 5
+        resources:
+          limits:
+            cpu: 2000m
+            memory: 512Mi
+          requests:
+            cpu: 100m
+            memory: 64Mi

artifacts/canaries/hpa.yaml

@@ -0,0 +1,19 @@
+apiVersion: autoscaling/v2beta1
+kind: HorizontalPodAutoscaler
+metadata:
+  name: podinfo
+  namespace: test
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: podinfo
+  minReplicas: 2
+  maxReplicas: 4
+  metrics:
+  - type: Resource
+    resource:
+      name: cpu
+      # scale up if usage is above
+      # 99% of the requested CPU (100m)
+      targetAverageUtilization: 99

artifacts/flagger/crd.yaml

@@ -4,9 +4,9 @@ metadata:
   name: canaries.flagger.app
 spec:
   group: flagger.app
-  version: v1beta1
+  version: v1alpha1
   versions:
-    - name: v1beta1
+    - name: v1alpha1
       served: true
       storage: true
   names:
@@ -19,30 +19,30 @@ spec:
       properties:
         spec:
           required:
-            - targetKind
-            - virtualService
-            - primary
-            - canary
-            - canaryAnalysis
+          - targetRef
+          - service
+          - canaryAnalysis
           properties:
-            targetKind:
-              type: string
-            virtualService:
+            targetRef:
               properties:
+                apiVersion:
+                  type: string
+                kind:
+                  type: string
                 name:
                   type: string
-            primary:
+            autoscalerRef:
               properties:
+                apiVersion:
+                  type: string
+                kind:
+                  type: string
                 name:
                   type: string
-                host:
-                  type: string
-            canary:
+            service:
               properties:
-                name:
-                  type: string
-                host:
-                  type: string
+                port:
+                  type: number
             canaryAnalysis:
               properties:
                 threshold:
@@ -64,4 +64,3 @@ spec:
                           pattern: "^[0-9]+(m)"
                         threshold:
                           type: number
-

artifacts/flagger/deployment.yaml

@@ -22,7 +22,7 @@ spec:
       serviceAccountName: flagger
       containers:
       - name: flagger
-        image: stefanprodan/flagger:0.0.1
+        image: quay.io/stefanprodan/flagger:0.1.0
         imagePullPolicy: Always
         ports:
         - name: http
@@ -41,6 +41,7 @@ spec:
             - --timeout=2
             - --spider
             - http://localhost:8080/healthz
+          timeoutSeconds: 5
         readinessProbe:
           exec:
             command:
@@ -50,6 +51,7 @@ spec:
             - --timeout=2
             - --spider
             - http://localhost:8080/healthz
+          timeoutSeconds: 5
         resources:
           limits:
             memory: "512Mi"

artifacts/rollouts/podinfo.yaml

@@ -1,42 +0,0 @@
-# monitor events:  watch "kubectl -n test describe rollout/podinfo | sed -n 35,1000p"
-# run tester: kubectl run -n test tester --image=quay.io/stefanprodan/podinfo:1.2.1 -- ./podinfo --port=9898
-# generate latency: watch curl http://podinfo-canary:9898/delay/1
-# generate errors: watch curl http://podinfo-canary:9898/status/500
-# run load test: kubectl run -n test -it --rm --restart=Never hey --image=stefanprodan/loadtest -- sh
-# generate load: hey -z 2m -h2 -m POST -d '{test: 1}' -c 10 -q 5 http://podinfo:9898/api/echo
-apiVersion: flagger.app/v1beta1
-kind: Canary
-metadata:
-  name: podinfo
-  namespace: test
-spec:
-  targetKind: Deployment
-  virtualService:
-    name: podinfo
-  primary:
-    name: podinfo
-    host: podinfo
-  canary:
-    name: podinfo-canary
-    host: podinfo-canary
-  canaryAnalysis:
-    # max number of failed metric checks
-    # before rolling back the canary
-    threshold: 5
-    # max traffic percentage routed to canary
-    # percentage (0-100)
-    maxWeight: 50
-    # canary increment step
-    # percentage (0-100)
-    stepWeight: 10
-    metrics:
-    - name: istio_requests_total
-      # minimum req success rate (non 5xx responses)
-      # percentage (0-100)
-      threshold: 99
-      interval: 1m
-    - name: istio_request_duration_seconds_bucket
-      # maximum req duration P99
-      # milliseconds
-      threshold: 500
-      interval: 30s

artifacts/rollouts/podinfoc.yaml

@@ -1,36 +0,0 @@
-apiVersion: flagger.app/v1beta1
-kind: Canary
-metadata:
-  name: podinfoc
-  namespace: test
-spec:
-  targetKind: Deployment
-  virtualService:
-    name: podinfoc
-  primary:
-    name: podinfoc-primary
-    host: podinfoc-primary
-  canary:
-    name: podinfoc-canary
-    host: podinfoc-canary
-  canaryAnalysis:
-    # max number of failed metric checks
-    # before rolling back the canary
-    threshold: 10
-    # max traffic percentage routed to canary
-    # percentage (0-100)
-    maxWeight: 50
-    # canary increment step
-    # percentage (0-100)
-    stepWeight: 10
-    metrics:
-    - name: istio_requests_total
-      # minimum req success rate (non 5xx responses)
-      # percentage (0-100)
-      threshold: 99
-      interval: 1m
-    - name: istio_request_duration_seconds_bucket
-      # maximum req duration P99
-      # milliseconds
-      threshold: 500
-      interval: 30s

artifacts/routing/match.yaml

@@ -0,0 +1,34 @@
+apiVersion: networking.istio.io/v1alpha3
+kind: VirtualService
+metadata:
+  name: podinfo
+  namespace: test
+spec:
+  gateways:
+  - public-gateway.istio-system.svc.cluster.local
+  - mesh
+  hosts:
+  - podinfo.iowa.weavedx.com
+  - podinfo
+  http:
+  - match:
+    - headers:
+        user-agent:
+          regex: ^(?!.*Chrome)(?=.*\bSafari\b).*$
+    route:
+    - destination:
+        host: podinfo-primary
+        port:
+          number: 9898
+      weight: 0
+    - destination:
+        host: podinfo
+        port:
+          number: 9898
+      weight: 100
+  - route:
+    - destination:
+        host: podinfo-primary
+        port:
+          number: 9898
+      weight: 100

artifacts/routing/mirror.yaml

@@ -0,0 +1,25 @@
+apiVersion: networking.istio.io/v1alpha3
+kind: VirtualService
+metadata:
+  name: podinfo
+  namespace: test
+  labels:
+    app: podinfo
+spec:
+  gateways:
+  - public-gateway.istio-system.svc.cluster.local
+  - mesh
+  hosts:
+  - podinfo.iowa.weavedx.com
+  - podinfo
+  http:
+  - route:
+    - destination:
+        host: podinfo-primary
+        port:
+          number: 9898
+      weight: 100
+    mirror:
+      host: podinfo
+      port:
+        number: 9898

artifacts/routing/weight.yaml

@@ -0,0 +1,26 @@
+apiVersion: networking.istio.io/v1alpha3
+kind: VirtualService
+metadata:
+  name: podinfo
+  namespace: test
+  labels:
+    app: podinfo
+spec:
+  gateways:
+  - public-gateway.istio-system.svc.cluster.local
+  - mesh
+  hosts:
+  - podinfo.iowa.weavedx.com
+  - podinfo
+  http:
+  - route:
+    - destination:
+        host: podinfo-primary
+        port:
+          number: 9898
+      weight: 100
+    - destination:
+        host: podinfo
+        port:
+          number: 9898
+      weight: 0

artifacts/workloads/canary-deployment.yaml

@@ -1,10 +1,10 @@
 apiVersion: apps/v1
 kind: Deployment
 metadata:
-  name: podinfo-canary
+  name: podinfo
   namespace: test
   labels:
-    app: podinfo-canary
+    app: podinfo
 spec:
   replicas: 1
   strategy:
@@ -13,13 +13,13 @@ spec:
     type: RollingUpdate
   selector:
     matchLabels:
-      app: podinfo-canary
+      app: podinfo
   template:
     metadata:
       annotations:
         prometheus.io/scrape: "true"
       labels:
-        app: podinfo-canary
+        app: podinfo
     spec:
       containers:
       - name: podinfod

artifacts/workloads/canary-hpa.yaml

@@ -1,13 +1,13 @@
 apiVersion: autoscaling/v2beta1
 kind: HorizontalPodAutoscaler
 metadata:
-  name: podinfo-canary
+  name: podinfo
   namespace: test
 spec:
   scaleTargetRef:
     apiVersion: apps/v1
     kind: Deployment
-    name: podinfo-canary
+    name: podinfo
   minReplicas: 2
   maxReplicas: 3
   metrics:

artifacts/workloads/canary-service.yaml

@@ -1,14 +1,14 @@
 apiVersion: v1
 kind: Service
 metadata:
-  name: podinfo-canary
+  name: podinfo
   namespace: test
   labels:
-    app: podinfo-canary
+    app: podinfo
 spec:
   type: ClusterIP
   selector:
-    app: podinfo-canary
+    app: podinfo
   ports:
   - name: http
     port: 9898

artifacts/workloads/primary-deployment.yaml

@@ -1,10 +1,10 @@
 apiVersion: apps/v1
 kind: Deployment
 metadata:
-  name: podinfo
+  name: podinfo-primary
   namespace: test
   labels:
-    app: podinfo
+    app: podinfo-primary
 spec:
   replicas: 1
   strategy:
@@ -13,13 +13,13 @@ spec:
     type: RollingUpdate
   selector:
     matchLabels:
-      app: podinfo
+      app: podinfo-primary
   template:
     metadata:
       annotations:
         prometheus.io/scrape: "true"
       labels:
-        app: podinfo
+        app: podinfo-primary
     spec:
       containers:
       - name: podinfod

artifacts/workloads/primary-hpa.yaml

@@ -1,13 +1,13 @@
 apiVersion: autoscaling/v2beta1
 kind: HorizontalPodAutoscaler
 metadata:
-  name: podinfo
+  name: podinfo-primary
   namespace: test
 spec:
   scaleTargetRef:
     apiVersion: apps/v1
     kind: Deployment
-    name: podinfo
+    name: podinfo-primary
   minReplicas: 2
   maxReplicas: 4
   metrics:

artifacts/workloads/primary-service.yaml

@@ -1,14 +1,14 @@
 apiVersion: v1
 kind: Service
 metadata:
-  name: podinfo
+  name: podinfo-primary
   namespace: test
   labels:
-    app: podinfo
+    app: podinfo-primary
 spec:
   type: ClusterIP
   selector:
-    app: podinfo
+    app: podinfo-primary
   ports:
   - name: http
     port: 9898

artifacts/workloads/virtual-service.yaml

@@ -8,18 +8,19 @@ metadata:
 spec:
   gateways:
   - public-gateway.istio-system.svc.cluster.local
+  - mesh
   hosts:
-  - app.istio.weavedx.com
+  - podinfo.istio.weavedx.com
   - podinfo
   http:
   - route:
     - destination:
-        host: podinfo
+        host: podinfo-primary
         port:
           number: 9898
       weight: 100
     - destination:
-        host: podinfo-canary
+        host: podinfo
         port:
           number: 9898
       weight: 0

charts/flagger/Chart.yaml

@@ -1,6 +1,6 @@
 apiVersion: v1
 name: flagger
-version: 0.0.1
-appVersion: 0.0.1
+version: 0.1.0
+appVersion: 0.1.0
 description: Flagger is a Kubernetes operator that automates the promotion of canary deployments using Istio routing for traffic shifting and Prometheus metrics for canary analysis.
 home: https://github.com/stefanprodan/flagger

charts/flagger/README.md

@@ -1,14 +1,20 @@
 # Flagger
 
-Flagger is a Kubernetes operator that automates the promotion of canary deployments
+[Flagger](https://flagger.app) is a Kubernetes operator that automates the promotion of canary deployments
 using Istio routing for traffic shifting and Prometheus metrics for canary analysis.
 
 ## Installing the Chart
 
+Add Flagger Hel repository:
+
+```console
+helm repo add flagger https://flagger.app
+```
+
 To install the chart with the release name `flagger`:
 
 ```console
-$ helm upgrade --install flagger ./charts/flagger --namespace=istio-system
+$ helm install --name flagger --namespace istio-system flagger/flagger
 ```
 
 The command deploys Flagger on the Kubernetes cluster in the istio-system namespace.
@@ -30,9 +36,16 @@ The following tables lists the configurable parameters of the Flagger chart and
 
 Parameter | Description | Default
 --- | --- | ---
-`image.repository` | image repository | `stefanprodan/flagger`
+`image.repository` | image repository | `quay.io/stefanprodan/flagger`
 `image.tag` | image tag | `<VERSION>`
 `image.pullPolicy` | image pull policy | `IfNotPresent`
+`controlLoopInterval` | wait interval between checks | `10s`
+`metricsServer` | Prometheus URL | `http://prometheus.istio-system:9090`
+`slack.url` | Slack incoming webhook | None
+`slack.channel` | Slack channel | None
+`slack.user` | Slack username | `flagger`
+`rbac.create` | if `true`, create and use RBAC resources | `true`
+`crd.create` | if `true`, create Flagger's CRDs | `true`
 `resources.requests/cpu` | pod CPU request | `10m`
 `resources.requests/memory` | pod memory request | `32Mi`
 `resources.limits/cpu` | pod CPU limit | `1000m`
@@ -44,16 +57,16 @@ Parameter | Description | Default
 Specify each parameter using the `--set key=value[,key=value]` argument to `helm upgrade`. For example,
 
 ```console
-$ helm upgrade --install flagger ./charts/flagger \
-  --namespace=istio-system \
-  --set=image.tag=0.0.2
+$ helm upgrade -i flagger flagger/flagger \
+  --namespace istio-system \
+  --set controlLoopInterval=1m
 ```
 
 Alternatively, a YAML file that specifies the values for the above parameters can be provided while installing the chart. For example,
 
 ```console
-$ helm upgrade --install flagger ./charts/flagger \
-  --namespace=istio-system \
+$ helm upgrade -i flagger flagger/flagger \
+  --namespace istio-system \
   -f values.yaml
 ```
 

charts/flagger/templates/crd.yaml

@@ -3,11 +3,13 @@ apiVersion: apiextensions.k8s.io/v1beta1
 kind: CustomResourceDefinition
 metadata:
   name: canaries.flagger.app
+  annotations:
+    "helm.sh/resource-policy": keep
 spec:
   group: flagger.app
-  version: v1beta1
+  version: v1alpha1
   versions:
-    - name: v1beta1
+    - name: v1alpha1
       served: true
       storage: true
   names:
@@ -20,30 +22,30 @@ spec:
       properties:
         spec:
           required:
-            - targetKind
-            - virtualService
-            - primary
-            - canary
-            - canaryAnalysis
+          - targetRef
+          - service
+          - canaryAnalysis
           properties:
-            targetKind:
-              type: string
-            virtualService:
+            targetRef:
               properties:
+                apiVersion:
+                  type: string
+                kind:
+                  type: string
                 name:
                   type: string
-            primary:
+            autoscalerRef:
               properties:
+                apiVersion:
+                  type: string
+                kind:
+                  type: string
                 name:
                   type: string
-                host:
-                  type: string
-            canary:
+            service:
               properties:
-                name:
-                  type: string
-                host:
-                  type: string
+                port:
+                  type: number
             canaryAnalysis:
               properties:
                 threshold:

charts/flagger/templates/deployment.yaml

@@ -37,24 +37,31 @@ spec:
           - -log-level=info
           - -control-loop-interval={{ .Values.controlLoopInterval }}
           - -metrics-server={{ .Values.metricsServer }}
+          {{- if .Values.slack.url }}
+          - -slack-url={{ .Values.slack.url }}
+          - -slack-user={{ .Values.slack.user }}
+          - -slack-channel={{ .Values.slack.channel }}
+          {{- end }}
           livenessProbe:
             exec:
               command:
               - wget
               - --quiet
               - --tries=1
-              - --timeout=2
+              - --timeout=4
               - --spider
               - http://localhost:8080/healthz
+            timeoutSeconds: 5
           readinessProbe:
             exec:
               command:
               - wget
               - --quiet
               - --tries=1
-              - --timeout=2
+              - --timeout=4
               - --spider
               - http://localhost:8080/healthz
+            timeoutSeconds: 5
           resources:
 {{ toYaml .Values.resources | indent 12 }}
     {{- with .Values.nodeSelector }}

charts/flagger/values.yaml

@@ -1,13 +1,19 @@
 # Default values for flagger.
 
 image:
-  repository: stefanprodan/flagger
-  tag: 0.0.1
+  repository: quay.io/stefanprodan/flagger
+  tag: 0.1.0
   pullPolicy: IfNotPresent
 
 controlLoopInterval: "10s"
 metricsServer: "http://prometheus.istio-system.svc.cluster.local:9090"
 
+slack:
+  user: flagger
+  channel:
+  # incoming webhook https://api.slack.com/incoming-webhooks
+  url:
+
 crd:
   create: true
 

charts/grafana/Chart.yaml

@@ -1,6 +1,6 @@
 apiVersion: v1
 name: grafana
-version: 5.2.4
-appVersion: 5.2.0
-description: A Helm chart for monitoring progressive deployments powered by Istio and Flagger
+version: 0.1.0
+appVersion: 5.3.1
+description: A Grafana Helm chart for monitoring progressive deployments powered by Istio and Flagger
 home: https://github.com/stefanprodan/flagger

charts/grafana/dashboards/canary.json

@@ -21,7 +21,7 @@
   "links": [],
   "panels": [
     {
-      "content": "<div class=\"dashboard-header text-center\">\n<span>RED: $primary.$namespace</span>\n</div>",
+      "content": "<div class=\"dashboard-header text-center\">\n<span>RED: $canary.$namespace</span>\n</div>",
       "gridPos": {
         "h": 3,
         "w": 24,
@@ -568,7 +568,7 @@
       ]
     },
     {
-      "content": "<div class=\"dashboard-header text-center\">\n<span>USE: $primary.$namespace</span>\n</div>",
+      "content": "<div class=\"dashboard-header text-center\">\n<span>USE: $canary.$namespace</span>\n</div>",
       "gridPos": {
         "h": 3,
         "w": 24,
@@ -712,7 +712,7 @@
       "targets": [
         {
           "$$hashKey": "object:1685",
-          "expr": "sum(rate(container_cpu_usage_seconds_total{cpu=\"total\",namespace=\"$namespace\",pod_name=~\"$canary.*\", container_name!~\"POD|istio-proxy\"}[1m])) by (pod_name)",
+          "expr": "sum(rate(container_cpu_usage_seconds_total{cpu=\"total\",namespace=\"$namespace\",pod_name=~\"$canary.*\", pod_name!~\"$primary.*\", container_name!~\"POD|istio-proxy\"}[1m])) by (pod_name)",
           "format": "time_series",
           "hide": false,
           "intervalFactor": 1,
@@ -890,7 +890,7 @@
       "targets": [
         {
           "$$hashKey": "object:1685",
-          "expr": "sum(container_memory_working_set_bytes{namespace=\"$namespace\",pod_name=~\"$canary.*\", container_name!~\"POD|istio-proxy\"}) by (pod_name)",
+          "expr": "sum(container_memory_working_set_bytes{namespace=\"$namespace\",pod_name=~\"$canary.*\", pod_name!~\"$primary.*\", container_name!~\"POD|istio-proxy\"}) by (pod_name)",
           "format": "time_series",
           "hide": false,
           "interval": "",
@@ -1098,7 +1098,7 @@
       "targets": [
         {
           "$$hashKey": "object:2598",
-          "expr": "sum(rate (container_network_receive_bytes_total{namespace=\"$namespace\",pod_name=~\"$canary.*\"}[1m])) ",
+          "expr": "sum(rate (container_network_receive_bytes_total{namespace=\"$namespace\",pod_name=~\"$canary.*\",pod_name!~\"$primary.*\"}[1m])) ",
           "format": "time_series",
           "intervalFactor": 1,
           "legendFormat": "received",
@@ -1106,7 +1106,7 @@
         },
         {
           "$$hashKey": "object:3245",
-          "expr": "-sum (rate (container_network_transmit_bytes_total{namespace=\"$namespace\",pod_name=~\"$canary.*\"}[1m]))",
+          "expr": "-sum (rate (container_network_transmit_bytes_total{namespace=\"$namespace\",pod_name=~\"$canary.*\",pod_name!~\"$primary.*\"}[1m]))",
           "format": "time_series",
           "intervalFactor": 1,
           "legendFormat": "transmited",
@@ -1153,7 +1153,7 @@
       ]
     },
     {
-      "content": "<div class=\"dashboard-header text-center\">\n<span>IN/OUTBOUND: $primary.$namespace</span>\n</div>",
+      "content": "<div class=\"dashboard-header text-center\">\n<span>IN/OUTBOUND: $canary.$namespace</span>\n</div>",
       "gridPos": {
         "h": 3,
         "w": 24,
@@ -1653,7 +1653,7 @@
     ]
   },
   "timezone": "",
-  "title": "Flagger",
+  "title": "Canary analysis",
   "uid": "RdykD7tiz",
   "version": 2
 }

charts/grafana/values.yaml

@@ -6,7 +6,7 @@ replicaCount: 1
 
 image:
   repository: grafana/grafana
-  tag: 5.2.4
+  tag: 5.3.1
   pullPolicy: IfNotPresent
 
 service:

charts/podinfo-flagger/.helmignore

@@ -1,21 +0,0 @@
-# Patterns to ignore when building packages.
-# This supports shell glob matching, relative path matching, and
-# negation (prefixed with !). Only one pattern per line.
-.DS_Store
-# Common VCS dirs
-.git/
-.gitignore
-.bzr/
-.bzrignore
-.hg/
-.hgignore
-.svn/
-# Common backup files
-*.swp
-*.bak
-*.tmp
-*~
-# Various IDEs
-.project
-.idea/
-*.tmproj

charts/podinfo-flagger/Chart.yaml

@@ -1,12 +0,0 @@
-apiVersion: v1
-version: 2.0.0
-appVersion: 1.2.1
-engine: gotpl
-name: podinfo-flagger
-description: Podinfo Helm chart for Flagger progressive delivery
-home: https://github.com/stefanprodan/k8s-podinfo
-maintainers:
-- email: stefanprodan@users.noreply.github.com
-  name: stefanprodan
-sources:
-- https://github.com/stefanprodan/flagger

charts/podinfo-flagger/README.md

@@ -1,56 +0,0 @@
-# Podinfo Istio
-
-Podinfo is a tiny web application made with Go 
-that showcases best practices of running microservices in Kubernetes.
-
-## Installing the Chart
-
-Create an Istio enabled namespace:
-
-```console
-kubectl create namespace test
-kubectl label namespace test istio-injection=enabled
-```
-
-Create an Istio Gateway in the `istio-system` namespace named `public-gateway`:
-
-```yaml
-apiVersion: networking.istio.io/v1alpha3
-kind: Gateway
-metadata:
-  name: public-gateway
-  namespace: istio-system
-spec:
-  selector:
-    istio: ingressgateway
-  servers:
-  - port:
-      number: 80
-      name: http
-      protocol: HTTP
-    hosts:
-    - "*"
-    tls:
-      httpsRedirect: true
-  - port:
-      number: 443
-      name: https
-      protocol: HTTPS
-    hosts:
-    - "*"
-    tls:
-      mode: SIMPLE
-      privateKey: /etc/istio/ingressgateway-certs/tls.key
-      serverCertificate: /etc/istio/ingressgateway-certs/tls.crt
-```
-
-Create the `frontend` release by specifying the external domain name:
-
-```console
-helm upgrade frontend -i ./charts/podinfo-flagger \
-  --namespace=test \
-  --set gateway.enabled=true \
-  --set gateway.host=podinfo.example.com 
-```
-
-

charts/podinfo-flagger/templates/NOTES.txt

@@ -1 +0,0 @@
- {{ template "podinfo-flagger.fullname" . }} has been deployed successfully!

charts/podinfo-flagger/templates/_helpers.tpl

@@ -1,36 +0,0 @@
-{{/* vim: set filetype=mustache: */}}
-{{/*
-Expand the name of the chart.
-*/}}
-{{- define "podinfo-flagger.name" -}}
-{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" -}}
-{{- end -}}
-
-{{/*
-Create a default fully qualified app name.
-We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
-The release name is used as a full name.
-*/}}
-{{- define "podinfo-flagger.fullname" -}}
-{{- if .Values.fullnameOverride -}}
-{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" -}}
-{{- else -}}
-{{- .Release.Name | trunc 63 | trimSuffix "-" -}}
-{{- end -}}
-{{- end -}}
-
-{{- define "podinfo-flagger.primary" -}}
-{{- printf "%s-%s" .Release.Name "primary" | trunc 63 | trimSuffix "-" -}}
-{{- end -}}
-
-{{- define "podinfo-flagger.canary" -}}
-{{- printf "%s-%s" .Release.Name "canary" | trunc 63 | trimSuffix "-" -}}
-{{- end -}}
-
-{{/*
-Create chart name and version as used by the chart label.
-*/}}
-{{- define "podinfo-flagger.chart" -}}
-{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
-{{- end -}}
-

charts/podinfo-flagger/templates/canary-deployment.yaml

@@ -1,63 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ template "podinfo-flagger.canary" . }}
-  labels:
-    app: {{ template "podinfo-flagger.fullname" . }}
-    chart: {{ template "podinfo-flagger.chart" . }}
-    release: {{ .Release.Name }}
-    heritage: {{ .Release.Service }}
-spec:
-  strategy:
-    type: RollingUpdate
-    rollingUpdate:
-      maxUnavailable: 0
-  selector:
-    matchLabels:
-      app: {{ template "podinfo-flagger.canary" . }}
-  template:
-    metadata:
-      labels:
-        app: {{ template "podinfo-flagger.canary" . }}
-      annotations:
-        prometheus.io/scrape: "true"
-    spec:
-      terminationGracePeriodSeconds: 30
-      containers:
-        - name: podinfod
-          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
-          imagePullPolicy: {{ .Values.imagePullPolicy }}
-          command:
-            - ./podinfo
-            - --port={{ .Values.containerPort }}
-            - --level={{ .Values.logLevel }}
-          env:
-          - name: PODINFO_UI_COLOR
-            value: green
-          ports:
-            - name: http
-              containerPort: {{ .Values.containerPort }}
-              protocol: TCP
-          livenessProbe:
-            exec:
-              command:
-              - podcli
-              - check
-              - http
-              - localhost:{{ .Values.containerPort }}/healthz
-          readinessProbe:
-            exec:
-              command:
-              - podcli
-              - check
-              - http
-              - localhost:{{ .Values.containerPort }}/readyz
-            periodSeconds: 3
-          volumeMounts:
-          - name: data
-            mountPath: /data
-          resources:
-{{ toYaml .Values.resources | indent 12 }}
-      volumes:
-      - name: data
-        emptyDir: {}

charts/podinfo-flagger/templates/canary-hpa.yaml

@@ -1,21 +0,0 @@
-apiVersion: autoscaling/v2beta1
-kind: HorizontalPodAutoscaler
-metadata:
-  name: {{ template "podinfo-flagger.canary" . }}
-  labels:
-    app: {{ template "podinfo-flagger.fullname" . }}
-    chart: {{ template "podinfo-flagger.chart" . }}
-    release: {{ .Release.Name }}
-    heritage: {{ .Release.Service }}
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: {{ template "podinfo-flagger.canary" . }}
-  minReplicas: {{ .Values.hpa.minReplicas }}
-  maxReplicas: {{ .Values.hpa.maxReplicas }}
-  metrics:
-  - type: Resource
-    resource:
-      name: cpu
-      targetAverageUtilization: {{ .Values.hpa.targetAverageUtilization }}

charts/podinfo-flagger/templates/canary-service.yaml

@@ -1,18 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ template "podinfo-flagger.canary" . }}
-  labels:
-    app: {{ template "podinfo-flagger.fullname" . }}
-    chart: {{ template "podinfo-flagger.chart" . }}
-    release: {{ .Release.Name }}
-    heritage: {{ .Release.Service }}
-spec:
-  type: ClusterIP
-  ports:
-    - port: {{ .Values.containerPort }}
-      targetPort: http
-      protocol: TCP
-      name: http
-  selector:
-    app: {{ template "podinfo-flagger.canary" . }}

charts/podinfo-flagger/templates/primary-deployment.yaml

@@ -1,63 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ template "podinfo-flagger.primary" . }}
-  labels:
-    app: {{ template "podinfo-flagger.fullname" . }}
-    chart: {{ template "podinfo-flagger.chart" . }}
-    release: {{ .Release.Name }}
-    heritage: {{ .Release.Service }}
-spec:
-  strategy:
-    type: RollingUpdate
-    rollingUpdate:
-      maxUnavailable: 0
-  selector:
-    matchLabels:
-      app: {{ template "podinfo-flagger.primary" . }}
-  template:
-    metadata:
-      labels:
-        app: {{ template "podinfo-flagger.primary" . }}
-      annotations:
-        prometheus.io/scrape: "true"
-    spec:
-      terminationGracePeriodSeconds: 30
-      containers:
-        - name: podinfod
-          image: "quay.io/stefanprodan/podinfo:1.1.1"
-          imagePullPolicy: {{ .Values.imagePullPolicy }}
-          command:
-            - ./podinfo
-            - --port={{ .Values.containerPort }}
-            - --level={{ .Values.logLevel }}
-          env:
-          - name: PODINFO_UI_COLOR
-            value: blue
-          ports:
-            - name: http
-              containerPort: {{ .Values.containerPort }}
-              protocol: TCP
-          livenessProbe:
-            exec:
-              command:
-              - podcli
-              - check
-              - http
-              - localhost:{{ .Values.containerPort }}/healthz
-          readinessProbe:
-            exec:
-              command:
-              - podcli
-              - check
-              - http
-              - localhost:{{ .Values.containerPort }}/readyz
-            periodSeconds: 3
-          volumeMounts:
-          - name: data
-            mountPath: /data
-          resources:
-{{ toYaml .Values.resources | indent 12 }}
-      volumes:
-      - name: data
-        emptyDir: {}

charts/podinfo-flagger/templates/primary-hpa.yaml

@@ -1,21 +0,0 @@
-apiVersion: autoscaling/v2beta1
-kind: HorizontalPodAutoscaler
-metadata:
-  name: {{ template "podinfo-flagger.primary" . }}
-  labels:
-    app: {{ template "podinfo-flagger.fullname" . }}
-    chart: {{ template "podinfo-flagger.chart" . }}
-    release: {{ .Release.Name }}
-    heritage: {{ .Release.Service }}
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: {{ template "podinfo-flagger.primary" . }}
-  minReplicas: {{ .Values.hpa.minReplicas }}
-  maxReplicas: {{ .Values.hpa.maxReplicas }}
-  metrics:
-  - type: Resource
-    resource:
-      name: cpu
-      targetAverageUtilization: {{ .Values.hpa.targetAverageUtilization }}

charts/podinfo-flagger/templates/primary-service.yaml

@@ -1,18 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ template "podinfo-flagger.primary" . }}
-  labels:
-    app: {{ template "podinfo-flagger.fullname" . }}
-    chart: {{ template "podinfo-flagger.chart" . }}
-    release: {{ .Release.Name }}
-    heritage: {{ .Release.Service }}
-spec:
-  type: ClusterIP
-  ports:
-  - port: {{ .Values.containerPort }}
-    targetPort: http
-    protocol: TCP
-    name: http
-  selector:
-    app: {{ template "podinfo-flagger.primary" . }}

charts/podinfo-flagger/templates/virtual-service.yaml

@@ -1,30 +0,0 @@
-apiVersion: networking.istio.io/v1alpha3
-kind: VirtualService
-metadata:
-  name: {{ template "podinfo-flagger.fullname" . }}
-  labels:
-    app: {{ template "podinfo-flagger.fullname" . }}
-    chart: {{ template "podinfo-flagger.chart" . }}
-    release: {{ .Release.Name }}
-    heritage: {{ .Release.Service }}
-spec:
-  hosts:
-    - {{ template "podinfo-flagger.fullname" . }}
-{{- if .Values.gateway.enabled }}
-    - {{ .Values.gateway.host }}
-  gateways:
-  - {{ .Values.gateway.name }}
-{{- end }}
-  http:
-  - route:
-    - destination:
-        host: {{ template "podinfo-flagger.primary" . }}
-        port:
-          number: {{ .Values.containerPort }}
-      weight: 100
-    - destination:
-        host: {{ template "podinfo-flagger.canary" . }}
-        port:
-          number: {{ .Values.containerPort }}
-      weight: 0
-    timeout: {{ .Values.timeout }}

charts/podinfo-flagger/values.yaml

@@ -1,30 +0,0 @@
-# Default values for podinfo-flagger.
-
-image:
-  repository: quay.io/stefanprodan/podinfo
-  tag: "1.2.0"
-
-# enable the gateway when exposing the service outside the cluster
-gateway:
-  enabled: false
-  name: public-gateway.istio-system.svc.cluster.local
-  # external domain name
-  host:
-
-hpa:
-  minReplicas: 2
-  maxReplicas: 4
-  targetAverageUtilization: 99
-
-timeout: 30s
-logLevel: info
-containerPort: 9898
-imagePullPolicy: IfNotPresent
-
-resources:
-  limits:
-    cpu: 2000m
-    memory: 512Mi
-  requests:
-    cpu: 100m
-    memory: 64Mi

cmd/flagger/main.go

@@ -6,12 +6,13 @@ import (
 	"time"
 
 	_ "github.com/istio/glog"
-	sharedclientset "github.com/knative/pkg/client/clientset/versioned"
+	istioclientset "github.com/knative/pkg/client/clientset/versioned"
 	"github.com/knative/pkg/signals"
 	clientset "github.com/stefanprodan/flagger/pkg/client/clientset/versioned"
 	informers "github.com/stefanprodan/flagger/pkg/client/informers/externalversions"
 	"github.com/stefanprodan/flagger/pkg/controller"
 	"github.com/stefanprodan/flagger/pkg/logging"
+	"github.com/stefanprodan/flagger/pkg/notifier"
 	"github.com/stefanprodan/flagger/pkg/server"
 	"github.com/stefanprodan/flagger/pkg/version"
 	"k8s.io/client-go/kubernetes"
@@ -27,6 +28,9 @@ var (
 	controlLoopInterval time.Duration
 	logLevel            string
 	port                string
+	slackURL            string
+	slackUser           string
+	slackChannel        string
 )
 
 func init() {
@@ -36,6 +40,9 @@ func init() {
 	flag.DurationVar(&controlLoopInterval, "control-loop-interval", 10*time.Second, "wait interval between rollouts")
 	flag.StringVar(&logLevel, "log-level", "debug", "Log level can be: debug, info, warning, error.")
 	flag.StringVar(&port, "port", "8080", "Port to listen on.")
+	flag.StringVar(&slackURL, "slack-url", "", "Slack hook URL.")
+	flag.StringVar(&slackUser, "slack-user", "flagger", "Slack user name.")
+	flag.StringVar(&slackChannel, "slack-channel", "", "Slack channel.")
 }
 
 func main() {
@@ -59,18 +66,18 @@ func main() {
 		logger.Fatalf("Error building kubernetes clientset: %v", err)
 	}
 
-	sharedClient, err := sharedclientset.NewForConfig(cfg)
+	istioClient, err := istioclientset.NewForConfig(cfg)
 	if err != nil {
-		logger.Fatalf("Error building shared clientset: %v", err)
+		logger.Fatalf("Error building istio clientset: %v", err)
 	}
 
-	rolloutClient, err := clientset.NewForConfig(cfg)
+	flaggerClient, err := clientset.NewForConfig(cfg)
 	if err != nil {
 		logger.Fatalf("Error building example clientset: %s", err.Error())
 	}
 
-	rolloutInformerFactory := informers.NewSharedInformerFactory(rolloutClient, time.Second*30)
-	rolloutInformer := rolloutInformerFactory.Flagger().V1beta1().Canaries()
+	flaggerInformerFactory := informers.NewSharedInformerFactory(flaggerClient, time.Second*30)
+	canaryInformer := flaggerInformerFactory.Flagger().V1alpha1().Canaries()
 
 	logger.Infof("Starting flagger version %s revision %s", version.VERSION, version.REVISION)
 
@@ -88,24 +95,35 @@ func main() {
 		logger.Errorf("Metrics server %s unreachable %v", metricsServer, err)
 	}
 
+	var slack *notifier.Slack
+	if slackURL != "" {
+		slack, err = notifier.NewSlack(slackURL, slackUser, slackChannel)
+		if err != nil {
+			logger.Errorf("Notifier %v", err)
+		} else {
+			logger.Infof("Slack notifications enabled for channel %s", slack.Channel)
+		}
+	}
+
 	// start HTTP server
 	go server.ListenAndServe(port, 3*time.Second, logger, stopCh)
 
 	c := controller.NewController(
 		kubeClient,
-		sharedClient,
-		rolloutClient,
-		rolloutInformer,
+		istioClient,
+		flaggerClient,
+		canaryInformer,
 		controlLoopInterval,
 		metricsServer,
 		logger,
+		slack,
 	)
 
-	rolloutInformerFactory.Start(stopCh)
+	flaggerInformerFactory.Start(stopCh)
 
 	logger.Info("Waiting for informer caches to sync")
 	for _, synced := range []cache.InformerSynced{
-		rolloutInformer.Informer().HasSynced,
+		canaryInformer.Informer().HasSynced,
 	} {
 		if ok := cache.WaitForCacheSync(stopCh, synced); !ok {
 			logger.Fatalf("Failed to wait for cache sync")

code-of-conduct.md

@@ -0,0 +1,73 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior
+may be reported by contacting stefan.prodan(at)gmail.com. 
+All complaints will be reviewed and investigated and will result in a response that is deemed
+necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of
+an incident. Further details of specific enforcement policies may be
+posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org), version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+

docs/README.md

@@ -2,13 +2,12 @@
 
 [![build](https://travis-ci.org/stefanprodan/flagger.svg?branch=master)](https://travis-ci.org/stefanprodan/flagger)
 [![report](https://goreportcard.com/badge/github.com/stefanprodan/flagger)](https://goreportcard.com/report/github.com/stefanprodan/flagger)
+[![codecov](https://codecov.io/gh/stefanprodan/flagger/branch/master/graph/badge.svg)](https://codecov.io/gh/stefanprodan/flagger)
 [![license](https://img.shields.io/github/license/stefanprodan/flagger.svg)](https://github.com/stefanprodan/flagger/blob/master/LICENSE)
 [![release](https://img.shields.io/github/release/stefanprodan/flagger/all.svg)](https://github.com/stefanprodan/flagger/releases)
 
 Flagger is a Kubernetes operator that automates the promotion of canary deployments
 using Istio routing for traffic shifting and Prometheus metrics for canary analysis.
-The project is currently in experimental phase and it is expected that breaking changes 
-to the API will be made in the upcoming releases.
 
 ### Install 
 
@@ -19,7 +18,7 @@ Deploy Flagger in the `istio-system` namespace using Helm:
 
 ```bash
 # add the Helm repository
-helm repo add flagger https://stefanprodan.github.io/flagger
+helm repo add flagger https://flagger.app
 
 # install or upgrade
 helm upgrade -i flagger flagger/flagger \
@@ -32,10 +31,11 @@ Flagger is compatible with Kubernetes >1.10.0 and Istio >1.0.0.
 
 ### Usage
 
-Flagger requires two Kubernetes [deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/): 
-one for the version you want to upgrade called _primary_ and one for the _canary_.
-Each deployment must have a corresponding ClusterIP [service](https://kubernetes.io/docs/concepts/services-networking/service/) 
-that exposes a port named http or https. These services are used as destinations in a Istio [virtual service](https://istio.io/docs/reference/config/istio.networking.v1alpha3/#VirtualService).
+Flagger takes a Kubernetes deployment and creates a series of objects 
+(Kubernetes [deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/), 
+ClusterIP [services](https://kubernetes.io/docs/concepts/services-networking/service/) and 
+Istio [virtual services](https://istio.io/docs/reference/config/istio.networking.v1alpha3/#VirtualService)) 
+to drive the canary analysis and promotion.
 
 ![flagger-overview](https://raw.githubusercontent.com/stefanprodan/flagger/master/docs/diagrams/flagger-overview.png)
 
@@ -44,25 +44,25 @@ Gated canary promotion stages:
 * scan for canary deployments
 * check Istio virtual service routes are mapped to primary and canary ClusterIP services
 * check primary and canary deployments status
-    * halt rollout if a rolling update is underway
-    * halt rollout if pods are unhealthy
+    * halt advancement if a rolling update is underway
+    * halt advancement if pods are unhealthy
 * increase canary traffic weight percentage from 0% to 5% (step weight)
 * check canary HTTP request success rate and latency
-    * halt rollout if any metric is under the specified threshold
+    * halt advancement if any metric is under the specified threshold
     * increment the failed checks counter
 * check if the number of failed checks reached the threshold
     * route all traffic to primary
     * scale to zero the canary deployment and mark it as failed
     * wait for the canary deployment to be updated (revision bump) and start over
 * increase canary traffic weight by 5% (step weight) till it reaches 50% (max weight) 
-    * halt rollout while canary request success rate is under the threshold
-    * halt rollout while canary request duration P99 is over the threshold
-    * halt rollout if the primary or canary deployment becomes unhealthy 
-    * halt rollout while canary deployment is being scaled up/down by HPA
+    * halt advancement while canary request success rate is under the threshold
+    * halt advancement while canary request duration P99 is over the threshold
+    * halt advancement if the primary or canary deployment becomes unhealthy 
+    * halt advancement while canary deployment is being scaled up/down by HPA
 * promote canary to primary
     * copy canary deployment spec template over primary
 * wait for primary rolling update to finish
-    * halt rollout if pods are unhealthy
+    * halt advancement if pods are unhealthy
 * route all traffic to primary
 * scale to zero the canary deployment
 * mark rollout as finished
@@ -70,76 +70,43 @@ Gated canary promotion stages:
 
 You can change the canary analysis _max weight_ and the _step weight_ percentage in the Flagger's custom resource.
 
-Assuming the primary deployment is named _podinfo_ and the canary one _podinfo-canary_, Flagger will require 
-a virtual service configured with weight-based routing:
+For a deployment named _podinfo_, a canary promotion can be defined using Flagger's custom resource:
 
 ```yaml
-apiVersion: networking.istio.io/v1alpha3
-kind: VirtualService
-metadata:
-  name: podinfo
-spec:
-  hosts:
-  - podinfo
-  http:
-  - route:
-    - destination:
-        host: podinfo
-        port:
-          number: 9898
-      weight: 100
-    - destination:
-        host: podinfo-canary
-        port:
-          number: 9898
-      weight: 0
-```
-
-Primary and canary services should expose a port named http:
-
-```yaml
-apiVersion: v1
-kind: Service
-metadata:
-  name: podinfo-canary
-spec:
-  type: ClusterIP
-  selector:
-    app: podinfo-canary
-  ports:
-  - name: http
-    port: 9898
-    targetPort: 9898
-```
-
-Based on the two deployments, services and virtual service, a canary promotion can be defined using Flagger's custom resource:
-
-```yaml
-apiVersion: flagger.app/v1beta1
+apiVersion: flagger.app/v1alpha1
 kind: Canary
 metadata:
   name: podinfo
   namespace: test
 spec:
-  targetKind: Deployment
-  virtualService:
+  # deployment reference
+  targetRef:
+    apiVersion: apps/v1
+    kind: Deployment
     name: podinfo
-  primary:
+  # hpa reference (optional)
+  autoscalerRef:
+    apiVersion: autoscaling/v2beta1
+    kind: HorizontalPodAutoscaler
     name: podinfo
-    host: podinfo
-  canary:
-    name: podinfo-canary
-    host: podinfo-canary
+  service:
+    # container port
+    port: 9898
+    # Istio gateways (optional)
+    gateways:
+    - public-gateway.istio-system.svc.cluster.local
+    # Istio virtual service host names (optional)
+    hosts:
+    - app.istio.weavedx.com
   canaryAnalysis:
-    # max number of failed checks
-    # before rolling back the canary
-    threshold: 10
+    # max number of failed metric checks before rollback
+    threshold: 5
     # max traffic percentage routed to canary
     # percentage (0-100)
     maxWeight: 50
     # canary increment step
     # percentage (0-100)
-    stepWeight: 5
+    stepWeight: 10
     metrics:
     - name: istio_requests_total
       # minimum req success rate (non 5xx responses)
@@ -150,14 +117,14 @@ spec:
       # maximum req duration P99
       # milliseconds
       threshold: 500
-      interval: 1m
+      interval: 30s
 ```
 
 The canary analysis is using the following promql queries:
  
 _HTTP requests success rate percentage_
 
-```promql
+```
 sum(
     rate(
         istio_requests_total{
@@ -182,7 +149,7 @@ sum(
 
 _HTTP requests milliseconds duration P99_
 
-```promql
+```
 histogram_quantile(0.99, 
   sum(
     irate(
@@ -198,8 +165,6 @@ histogram_quantile(0.99,
 
 ### Automated canary analysis, promotions and rollbacks
 
-![flagger-canary](https://raw.githubusercontent.com/stefanprodan/flagger/master/docs/diagrams/flagger-canary-hpa.png)
-
 Create a test namespace with Istio sidecar injection enabled:
 
 ```bash
@@ -208,66 +173,72 @@ export REPO=https://raw.githubusercontent.com/stefanprodan/flagger/master
 kubectl apply -f ${REPO}/artifacts/namespaces/test.yaml
 ```
 
-Create the primary deployment, service and hpa:
+Create a deployment and a horizontal pod autoscaler:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/workloads/primary-deployment.yaml
-kubectl apply -f ${REPO}/artifacts/workloads/primary-service.yaml
-kubectl apply -f ${REPO}/artifacts/workloads/primary-hpa.yaml
+kubectl apply -f ${REPO}/artifacts/canaries/deployment.yaml
+kubectl apply -f ${REPO}/artifacts/canaries/hpa.yaml
 ```
 
-Create the canary deployment, service and hpa:
+Create a canary promotion custom resource (replace the Istio gateway and the internet domain with your own):
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/workloads/canary-deployment.yaml
-kubectl apply -f ${REPO}/artifacts/workloads/canary-service.yaml
-kubectl apply -f ${REPO}/artifacts/workloads/canary-hpa.yaml
+kubectl apply -f ${REPO}/artifacts/canaries/canary.yaml
 ```
 
-Create a virtual service (replace the Istio gateway and the internet domain with your own):
+After a couple of seconds Flagger will create the canary objects:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/workloads/virtual-service.yaml
+# applied 
+deployment.apps/podinfo
+horizontalpodautoscaler.autoscaling/podinfo
+canary.flagger.app/podinfo
+# generated 
+deployment.apps/podinfo-primary
+horizontalpodautoscaler.autoscaling/podinfo-primary
+service/podinfo
+service/podinfo-canary
+service/podinfo-primary
+virtualservice.networking.istio.io/podinfo
 ```
 
-Create a canary promotion custom resource:
+![flagger-canary-steps](https://raw.githubusercontent.com/stefanprodan/flagger/master/docs/diagrams/flagger-canary-steps.png)
+
+Trigger a canary deployment by updating the container image:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/rollouts/podinfo.yaml
+kubectl -n test set image deployment/podinfo \
+podinfod=quay.io/stefanprodan/podinfo:1.2.1
 ```
 
-Canary promotion output:
+Flagger detects that the deployment revision changed and starts a new rollout:
 
 ```
 kubectl -n test describe canary/podinfo
 
 Status:
-  Canary Revision:  16271121
-  Failed Checks:    6
+  Canary Revision:  19871136
+  Failed Checks:    0
   State:            finished
 Events:
   Type     Reason  Age   From     Message
   ----     ------  ----  ----     -------
-  Normal   Synced  3m    flagger  Starting canary deployment for podinfo.test
+  Normal   Synced  3m    flagger  New revision detected podinfo.test
+  Normal   Synced  3m    flagger  Scaling up podinfo.test
+  Warning  Synced  3m    flagger  Waiting for podinfo.test rollout to finish: 0 of 1 updated replicas are available
   Normal   Synced  3m    flagger  Advance podinfo.test canary weight 5
   Normal   Synced  3m    flagger  Advance podinfo.test canary weight 10
   Normal   Synced  3m    flagger  Advance podinfo.test canary weight 15
-  Warning  Synced  3m    flagger  Halt podinfo.test advancement request duration 2.525s > 500ms
-  Warning  Synced  3m    flagger  Halt podinfo.test advancement request duration 1.567s > 500ms
-  Warning  Synced  3m    flagger  Halt podinfo.test advancement request duration 823ms > 500ms
   Normal   Synced  2m    flagger  Advance podinfo.test canary weight 20
   Normal   Synced  2m    flagger  Advance podinfo.test canary weight 25
   Normal   Synced  1m    flagger  Advance podinfo.test canary weight 30
-  Warning  Synced  1m    flagger  Halt podinfo.test advancement success rate 82.33% < 99%
-  Warning  Synced  1m    flagger  Halt podinfo.test advancement success rate 87.22% < 99%
-  Warning  Synced  1m    flagger  Halt podinfo.test advancement success rate 94.74% < 99%
   Normal   Synced  1m    flagger  Advance podinfo.test canary weight 35
   Normal   Synced  55s   flagger  Advance podinfo.test canary weight 40
   Normal   Synced  45s   flagger  Advance podinfo.test canary weight 45
   Normal   Synced  35s   flagger  Advance podinfo.test canary weight 50
-  Normal   Synced  25s   flagger  Copying podinfo-canary.test template spec to podinfo.test
-  Warning  Synced  15s   flagger  Waiting for podinfo.test rollout to finish: 1 of 2 updated replicas are available
-  Normal   Synced  5s    flagger  Promotion completed! Scaling down podinfo-canary.test
+  Normal   Synced  25s   flagger  Copying podinfo.test template spec to podinfo-primary.test
+  Warning  Synced  15s   flagger  Waiting for podinfo-primary.test rollout to finish: 1 of 2 updated replicas are available
+  Normal   Synced  5s    flagger  Promotion completed! Scaling down podinfo.test
 ```
 
 During the canary analysis you can generate HTTP 500 errors and high latency to test if Flagger pauses the rollout.
@@ -313,45 +284,8 @@ Events:
   Normal   Synced  2m    flagger  Halt podinfo.test advancement success rate 55.06% < 99%
   Normal   Synced  2m    flagger  Halt podinfo.test advancement success rate 47.00% < 99%
   Normal   Synced  2m    flagger  (combined from similar events): Halt podinfo.test advancement success rate 38.08% < 99%
-  Warning  Synced  1m    flagger  Rolling back podinfo-canary.test failed checks threshold reached 10
-  Warning  Synced  1m    flagger  Canary failed! Scaling down podinfo-canary.test
-```
-
-Trigger a new canary deployment by updating the canary image:
-
-```bash
-kubectl -n test set image deployment/podinfo-canary \
-podinfod=quay.io/stefanprodan/podinfo:1.2.1
-```
-
-Steer detects that the canary revision changed and starts a new rollout:
-
-```
-kubectl -n test describe canary/podinfo
-
-Status:
-  Canary Revision:  19871136
-  Failed Checks:    0
-  State:            finished
-Events:
-  Type     Reason  Age   From     Message
-  ----     ------  ----  ----     -------
-  Normal   Synced  3m    flagger  New revision detected podinfo-canary.test old 17211012 new 17246876
-  Normal   Synced  3m    flagger  Scaling up podinfo.test
-  Warning  Synced  3m    flagger  Waiting for podinfo.test rollout to finish: 0 of 1 updated replicas are available
-  Normal   Synced  3m    flagger  Advance podinfo.test canary weight 5
-  Normal   Synced  3m    flagger  Advance podinfo.test canary weight 10
-  Normal   Synced  3m    flagger  Advance podinfo.test canary weight 15
-  Normal   Synced  2m    flagger  Advance podinfo.test canary weight 20
-  Normal   Synced  2m    flagger  Advance podinfo.test canary weight 25
-  Normal   Synced  1m    flagger  Advance podinfo.test canary weight 30
-  Normal   Synced  1m    flagger  Advance podinfo.test canary weight 35
-  Normal   Synced  55s   flagger  Advance podinfo.test canary weight 40
-  Normal   Synced  45s   flagger  Advance podinfo.test canary weight 45
-  Normal   Synced  35s   flagger  Advance podinfo.test canary weight 50
-  Normal   Synced  25s   flagger  Copying podinfo-canary.test template spec to podinfo.test
-  Warning  Synced  15s   flagger  Waiting for podinfo.test rollout to finish: 1 of 2 updated replicas are available
-  Normal   Synced  5s    flagger  Promotion completed! Scaling down podinfo-canary.test
+  Warning  Synced  1m    flagger  Rolling back podinfo.test failed checks threshold reached 10
+  Warning  Synced  1m    flagger  Canary failed! Scaling down podinfo.test
 ```
 
 ### Monitoring
@@ -388,18 +322,55 @@ Advance podinfo.test canary weight 40
 Halt podinfo.test advancement request duration 1.515s > 500ms
 Advance podinfo.test canary weight 45
 Advance podinfo.test canary weight 50
-Copying podinfo-canary.test template spec to podinfo-primary.test
-Scaling down podinfo-canary.test
-Promotion completed! podinfo-canary.test revision 81289
+Copying podinfo.test template spec to podinfo-primary.test
+Halt podinfo-primary.test advancement waiting for rollout to finish: 1 old replicas are pending termination
+Scaling down podinfo.test
+Promotion completed! podinfo.test
 ```
 
+Flagger exposes Prometheus metrics that can be used to determine the canary analysis status and the destination weight values:
+
+```bash
+# Canaries total gauge
+flagger_canary_total{namespace="test"} 1
+
+# Canary promotion last known status gauge
+# 0 - running, 1 - successful, 2 - failed
+flagger_canary_status{name="podinfo" namespace="test"} 1
+
+# Canary traffic weight gauge
+flagger_canary_weight{workload="podinfo-primary" namespace="test"} 95
+flagger_canary_weight{workload="podinfo" namespace="test"} 5
+
+# Seconds spent performing canary analysis histogram
+flagger_canary_duration_seconds_bucket{name="podinfo",namespace="test",le="10"} 6
+flagger_canary_duration_seconds_bucket{name="podinfo",namespace="test",le="+Inf"} 6
+flagger_canary_duration_seconds_sum{name="podinfo",namespace="test"} 17.3561329
+flagger_canary_duration_seconds_count{name="podinfo",namespace="test"} 6
+```
+
+### Alerting
+
+Flagger can be configured to send Slack notifications:
+
+```bash
+helm upgrade -i flagger flagger/flagger \
+--namespace=istio-system \
+--set slack.url=https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK \
+--set slack.channel=general \
+--set slack.user=flagger
+```
+
+Once configured with a Slack incoming webhook, Flagger will post messages when a canary deployment has been initialized,
+when a new revision has been detected and if the canary analysis failed or succeeded.
+
+![flagger-slack](https://raw.githubusercontent.com/stefanprodan/flagger/master/docs/screens/slack-notifications.png)
+
 ### Roadmap
 
-* Extend the canary analysis and promotion to other types than Kubernetes deployments such as Flux Helm releases or OpenFaaS functions
 * Extend the validation mechanism to support other metrics than HTTP success rate and latency
 * Add support for comparing the canary metrics to the primary ones and do the validation based on the derivation between the two
-* Alerting: Trigger Alertmanager on successful or failed promotions (Prometheus instrumentation of the canary analysis)  
-* Reporting: publish canary analysis results to Slack/Jira/etc
+* Extend the canary analysis and promotion to other types than Kubernetes deployments such as Flux Helm releases or OpenFaaS functions
 
 ### Contributing
 

docs/_config.yaml

@@ -4,7 +4,7 @@ remote_theme: errordeveloper/simple-project-homepage
 repository: stefanprodan/flagger
 by_weaveworks: true
 
-url: "https://stefanprodan.github.io/flagger"
+url: "https://flagger.app"
 baseurl: "/"
 
 twitter:
@@ -15,7 +15,7 @@ author:
 # Set default og:image
 defaults:
 - scope: {path: ""}
-  values: {image: "logo/logo-flagger.png"}
+  values: {image: "diagrams/flagger-overview.png"}
 
 # See: https://material.io/guidelines/style/color.html
 # Use color-name-value, like pink-200 or deep-purple-100
@@ -51,14 +51,4 @@ plugins:
 
 exclude:
 - CNAME
-- Dockerfile
-- Gopkg.lock
-- Gopkg.toml
-- LICENSE
-- Makefile
-- add-model.sh
-- build
-- cmd
-- pkg
-- tag_release.sh
-- vendor
+

docs/index.yaml

@@ -2,60 +2,27 @@ apiVersion: v1
 entries:
   flagger:
   - apiVersion: v1
-    appVersion: 0.0.1
-    created: 2018-10-07T13:00:10.107115+03:00
+    appVersion: 0.1.0
+    created: 2018-11-25T20:52:59.226156+02:00
     description: Flagger is a Kubernetes operator that automates the promotion of
       canary deployments using Istio routing for traffic shifting and Prometheus metrics
       for canary analysis.
-    digest: ddf0eda9975979bdfc26f10c7b3c15f4a31ebe0484be3285fbaec99b893871be
+    digest: 03e05634149e13ddfddae6757266d65c271878a026c21c7d1429c16712bf3845
     home: https://github.com/stefanprodan/flagger
     name: flagger
     urls:
-    - https://stefanprodan.github.io/flagger/flagger-0.0.1.tgz
-    version: 0.0.1
+    - https://stefanprodan.github.io/flagger/flagger-0.1.0.tgz
+    version: 0.1.0
   grafana:
   - apiVersion: v1
-    appVersion: 5.2.0
-    created: 2018-10-07T13:00:10.10763+03:00
-    description: A Helm chart for monitoring progressive deployments powered by Istio
-      and Flagger
-    digest: 1e19e9010d2939e19d0f8465287676b185f4772f5df5a75092a8fce0b4a50e5e
+    appVersion: 5.3.1
+    created: 2018-11-25T20:52:59.226488+02:00
+    description: A Grafana Helm chart for monitoring progressive deployments powered
+      by Istio and Flagger
+    digest: 12ad252512006e91b6eb359c4e0c73e7f01f74f3c07c85bb1e66780bed6747f5
     home: https://github.com/stefanprodan/flagger
     name: grafana
     urls:
-    - https://stefanprodan.github.io/flagger/grafana-5.2.4.tgz
-    version: 5.2.4
-  podinfo-flagger:
-  - apiVersion: v1
-    appVersion: 1.2.1
-    created: 2018-10-07T13:00:10.108001+03:00
-    description: Podinfo Helm chart for Flagger progressive delivery
-    digest: 35ce41d10df123a785ba359491668a143c5918ce6d3d24f5b545ca2cb9134d91
-    engine: gotpl
-    home: https://github.com/stefanprodan/k8s-podinfo
-    maintainers:
-    - email: stefanprodan@users.noreply.github.com
-      name: stefanprodan
-    name: podinfo-flagger
-    sources:
-    - https://github.com/stefanprodan/flagger
-    urls:
-    - https://stefanprodan.github.io/flagger/podinfo-flagger-2.0.0.tgz
-    version: 2.0.0
-  - apiVersion: v1
-    appVersion: 1.2.1
-    created: 2018-10-04T14:48:57.586403+03:00
-    description: Podinfo Helm chart for Flagger progressive delivery
-    digest: f559f387aa45005be085af207b8b4c91776e489fcb6ca7e60f20913ecd21184e
-    engine: gotpl
-    home: https://github.com/stefanprodan/k8s-podinfo
-    maintainers:
-    - email: stefanprodan@users.noreply.github.com
-      name: stefanprodan
-    name: podinfo-flagger
-    sources:
-    - https://github.com/stefanprodan/flagger
-    urls:
-    - https://stefanprodan.github.io/flagger/podinfo-flagger-1.2.1.tgz
-    version: 1.2.1
-generated: 2018-10-07T13:00:10.106238+03:00
+    - https://stefanprodan.github.io/flagger/grafana-0.1.0.tgz
+    version: 0.1.0
+generated: 2018-11-25T20:52:59.225755+02:00

hack/update-codegen.sh

@@ -23,6 +23,6 @@ CODEGEN_PKG=${CODEGEN_PKG:-$(cd ${SCRIPT_ROOT}; ls -d -1 ./vendor/k8s.io/code-ge
 
 ${CODEGEN_PKG}/generate-groups.sh "deepcopy,client,informer,lister" \
   github.com/stefanprodan/flagger/pkg/client github.com/stefanprodan/flagger/pkg/apis \
-  flagger:v1beta1 \
+  flagger:v1alpha1 \
   --go-header-file ${SCRIPT_ROOT}/hack/boilerplate.go.txt
 

pkg/apis/flagger/v1alpha1/doc.go

@@ -16,6 +16,6 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package
 
-// Package v1beta1 is the v1beta1 version of the API.
+// Package v1alpha1 is the v1alpha1 version of the API.
 // +groupName=flagger.app
-package v1beta1
+package v1alpha1

pkg/apis/flagger/v1alpha1/register.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package v1beta1
+package v1alpha1
 
 import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -25,7 +25,7 @@ import (
 )
 
 // SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = schema.GroupVersion{Group: rollout.GroupName, Version: "v1beta1"}
+var SchemeGroupVersion = schema.GroupVersion{Group: rollout.GroupName, Version: "v1alpha1"}
 
 // Kind takes an unqualified kind and returns back a Group qualified GroupKind
 func Kind(kind string) schema.GroupKind {

pkg/apis/flagger/v1alpha1/types.go

@@ -14,12 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package v1beta1
+package v1alpha1
 
 import (
+	hpav1 "k8s.io/api/autoscaling/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
+const CanaryKind = "Canary"
+
 // +genclient
 // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 
@@ -34,40 +37,17 @@ type Canary struct {
 
 // CanarySpec is the spec for a Canary resource
 type CanarySpec struct {
-	TargetKind     string         `json:"targetKind"`
-	Primary        Target         `json:"primary"`
-	Canary         Target         `json:"canary"`
+	// reference to target resource
+	TargetRef hpav1.CrossVersionObjectReference `json:"targetRef"`
+
+	// reference to autoscaling resource
+	AutoscalerRef hpav1.CrossVersionObjectReference `json:"autoscalerRef"`
+
+	// virtual service spec
+	Service CanaryService `json:"service"`
+
+	// metrics and thresholds
 	CanaryAnalysis CanaryAnalysis `json:"canaryAnalysis"`
-	VirtualService VirtualService `json:"virtualService"`
-}
-
-type Target struct {
-	Name string `json:"name"`
-	Host string `json:"host"`
-}
-
-type VirtualService struct {
-	Name string `json:"name"`
-}
-
-type CanaryAnalysis struct {
-	Threshold  int      `json:"threshold"`
-	MaxWeight  int      `json:"maxWeight"`
-	StepWeight int      `json:"stepWeight"`
-	Metrics    []Metric `json:"metrics"`
-}
-
-type Metric struct {
-	Name      string `json:"name"`
-	Interval  string `json:"interval"`
-	Threshold int    `json:"threshold"`
-}
-
-// CanaryStatus is the status for a Canary resource
-type CanaryStatus struct {
-	State          string `json:"state"`
-	CanaryRevision string `json:"canaryRevision"`
-	FailedChecks   int    `json:"failedChecks"`
 }
 
 // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
@@ -79,3 +59,35 @@ type CanaryList struct {
 
 	Items []Canary `json:"items"`
 }
+
+// CanaryStatus is used for state persistence (read-only)
+type CanaryStatus struct {
+	State          string `json:"state"`
+	CanaryRevision string `json:"canaryRevision"`
+	FailedChecks   int    `json:"failedChecks"`
+	// +optional
+	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
+}
+
+// CanaryService is used to create ClusterIP services
+// and Istio Virtual Service
+type CanaryService struct {
+	Port     int32    `json:"port"`
+	Gateways []string `json:"gateways"`
+	Hosts    []string `json:"hosts"`
+}
+
+// CanaryAnalysis is used to describe how the analysis should be done
+type CanaryAnalysis struct {
+	Threshold  int            `json:"threshold"`
+	MaxWeight  int            `json:"maxWeight"`
+	StepWeight int            `json:"stepWeight"`
+	Metrics    []CanaryMetric `json:"metrics"`
+}
+
+// CanaryMetric hold the reference to Istio metrics used for canary analysis
+type CanaryMetric struct {
+	Name      string `json:"name"`
+	Interval  string `json:"interval"`
+	Threshold int    `json:"threshold"`
+}

pkg/apis/flagger/v1alpha1/zz_generated.deepcopy.go

@@ -18,7 +18,7 @@ limitations under the License.
 
 // Code generated by deepcopy-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 import (
 	runtime "k8s.io/apimachinery/pkg/runtime"
@@ -30,7 +30,7 @@ func (in *Canary) DeepCopyInto(out *Canary) {
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
 	in.Spec.DeepCopyInto(&out.Spec)
-	out.Status = in.Status
+	in.Status.DeepCopyInto(&out.Status)
 	return
 }
 
@@ -57,7 +57,7 @@ func (in *CanaryAnalysis) DeepCopyInto(out *CanaryAnalysis) {
 	*out = *in
 	if in.Metrics != nil {
 		in, out := &in.Metrics, &out.Metrics
-		*out = make([]Metric, len(*in))
+		*out = make([]CanaryMetric, len(*in))
 		copy(*out, *in)
 	}
 	return
@@ -106,13 +106,55 @@ func (in *CanaryList) DeepCopyObject() runtime.Object {
 	return nil
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *CanaryMetric) DeepCopyInto(out *CanaryMetric) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CanaryMetric.
+func (in *CanaryMetric) DeepCopy() *CanaryMetric {
+	if in == nil {
+		return nil
+	}
+	out := new(CanaryMetric)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *CanaryService) DeepCopyInto(out *CanaryService) {
+	*out = *in
+	if in.Gateways != nil {
+		in, out := &in.Gateways, &out.Gateways
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.Hosts != nil {
+		in, out := &in.Hosts, &out.Hosts
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CanaryService.
+func (in *CanaryService) DeepCopy() *CanaryService {
+	if in == nil {
+		return nil
+	}
+	out := new(CanaryService)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *CanarySpec) DeepCopyInto(out *CanarySpec) {
 	*out = *in
-	out.Primary = in.Primary
-	out.Canary = in.Canary
+	out.TargetRef = in.TargetRef
+	out.AutoscalerRef = in.AutoscalerRef
+	in.Service.DeepCopyInto(&out.Service)
 	in.CanaryAnalysis.DeepCopyInto(&out.CanaryAnalysis)
-	out.VirtualService = in.VirtualService
 	return
 }
 
@@ -129,6 +171,7 @@ func (in *CanarySpec) DeepCopy() *CanarySpec {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *CanaryStatus) DeepCopyInto(out *CanaryStatus) {
 	*out = *in
+	in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
 	return
 }
 
@@ -141,51 +184,3 @@ func (in *CanaryStatus) DeepCopy() *CanaryStatus {
 	in.DeepCopyInto(out)
 	return out
 }
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *Metric) DeepCopyInto(out *Metric) {
-	*out = *in
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Metric.
-func (in *Metric) DeepCopy() *Metric {
-	if in == nil {
-		return nil
-	}
-	out := new(Metric)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *Target) DeepCopyInto(out *Target) {
-	*out = *in
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Target.
-func (in *Target) DeepCopy() *Target {
-	if in == nil {
-		return nil
-	}
-	out := new(Target)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *VirtualService) DeepCopyInto(out *VirtualService) {
-	*out = *in
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualService.
-func (in *VirtualService) DeepCopy() *VirtualService {
-	if in == nil {
-		return nil
-	}
-	out := new(VirtualService)
-	in.DeepCopyInto(out)
-	return out
-}

pkg/client/clientset/versioned/clientset.go

@@ -19,7 +19,7 @@ limitations under the License.
 package versioned
 
 import (
-	flaggerv1beta1 "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/typed/flagger/v1beta1"
+	flaggerv1alpha1 "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/typed/flagger/v1alpha1"
 	discovery "k8s.io/client-go/discovery"
 	rest "k8s.io/client-go/rest"
 	flowcontrol "k8s.io/client-go/util/flowcontrol"
@@ -27,27 +27,27 @@ import (
 
 type Interface interface {
 	Discovery() discovery.DiscoveryInterface
-	FlaggerV1beta1() flaggerv1beta1.FlaggerV1beta1Interface
+	FlaggerV1alpha1() flaggerv1alpha1.FlaggerV1alpha1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Flagger() flaggerv1beta1.FlaggerV1beta1Interface
+	Flagger() flaggerv1alpha1.FlaggerV1alpha1Interface
 }
 
 // Clientset contains the clients for groups. Each group has exactly one
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	flaggerV1beta1 *flaggerv1beta1.FlaggerV1beta1Client
+	flaggerV1alpha1 *flaggerv1alpha1.FlaggerV1alpha1Client
 }
 
-// FlaggerV1beta1 retrieves the FlaggerV1beta1Client
-func (c *Clientset) FlaggerV1beta1() flaggerv1beta1.FlaggerV1beta1Interface {
-	return c.flaggerV1beta1
+// FlaggerV1alpha1 retrieves the FlaggerV1alpha1Client
+func (c *Clientset) FlaggerV1alpha1() flaggerv1alpha1.FlaggerV1alpha1Interface {
+	return c.flaggerV1alpha1
 }
 
 // Deprecated: Flagger retrieves the default version of FlaggerClient.
 // Please explicitly pick a version.
-func (c *Clientset) Flagger() flaggerv1beta1.FlaggerV1beta1Interface {
-	return c.flaggerV1beta1
+func (c *Clientset) Flagger() flaggerv1alpha1.FlaggerV1alpha1Interface {
+	return c.flaggerV1alpha1
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -66,7 +66,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.flaggerV1beta1, err = flaggerv1beta1.NewForConfig(&configShallowCopy)
+	cs.flaggerV1alpha1, err = flaggerv1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.flaggerV1beta1 = flaggerv1beta1.NewForConfigOrDie(c)
+	cs.flaggerV1alpha1 = flaggerv1alpha1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.flaggerV1beta1 = flaggerv1beta1.New(c)
+	cs.flaggerV1alpha1 = flaggerv1alpha1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs

pkg/client/clientset/versioned/fake/clientset_generated.go

@@ -20,8 +20,8 @@ package fake
 
 import (
 	clientset "github.com/stefanprodan/flagger/pkg/client/clientset/versioned"
-	flaggerv1beta1 "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/typed/flagger/v1beta1"
-	fakeflaggerv1beta1 "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/typed/flagger/v1beta1/fake"
+	flaggerv1alpha1 "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/typed/flagger/v1alpha1"
+	fakeflaggerv1alpha1 "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/typed/flagger/v1alpha1/fake"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/discovery"
@@ -71,12 +71,12 @@ func (c *Clientset) Discovery() discovery.DiscoveryInterface {
 
 var _ clientset.Interface = &Clientset{}
 
-// FlaggerV1beta1 retrieves the FlaggerV1beta1Client
-func (c *Clientset) FlaggerV1beta1() flaggerv1beta1.FlaggerV1beta1Interface {
-	return &fakeflaggerv1beta1.FakeFlaggerV1beta1{Fake: &c.Fake}
+// FlaggerV1alpha1 retrieves the FlaggerV1alpha1Client
+func (c *Clientset) FlaggerV1alpha1() flaggerv1alpha1.FlaggerV1alpha1Interface {
+	return &fakeflaggerv1alpha1.FakeFlaggerV1alpha1{Fake: &c.Fake}
 }
 
-// Flagger retrieves the FlaggerV1beta1Client
-func (c *Clientset) Flagger() flaggerv1beta1.FlaggerV1beta1Interface {
-	return &fakeflaggerv1beta1.FakeFlaggerV1beta1{Fake: &c.Fake}
+// Flagger retrieves the FlaggerV1alpha1Client
+func (c *Clientset) Flagger() flaggerv1alpha1.FlaggerV1alpha1Interface {
+	return &fakeflaggerv1alpha1.FakeFlaggerV1alpha1{Fake: &c.Fake}
 }

pkg/client/clientset/versioned/fake/register.go

@@ -19,7 +19,7 @@ limitations under the License.
 package fake
 
 import (
-	flaggerv1beta1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	flaggerv1alpha1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
@@ -50,5 +50,5 @@ func init() {
 // After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
 // correctly.
 func AddToScheme(scheme *runtime.Scheme) {
-	flaggerv1beta1.AddToScheme(scheme)
+	flaggerv1alpha1.AddToScheme(scheme)
 }

pkg/client/clientset/versioned/scheme/register.go

@@ -19,7 +19,7 @@ limitations under the License.
 package scheme
 
 import (
-	flaggerv1beta1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	flaggerv1alpha1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
@@ -50,5 +50,5 @@ func init() {
 // After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
 // correctly.
 func AddToScheme(scheme *runtime.Scheme) {
-	flaggerv1beta1.AddToScheme(scheme)
+	flaggerv1alpha1.AddToScheme(scheme)
 }

pkg/client/clientset/versioned/typed/flagger/v1alpha1/canary.go

@@ -16,10 +16,10 @@ limitations under the License.
 
 // Code generated by client-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 import (
-	v1beta1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	v1alpha1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	scheme "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/scheme"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	types "k8s.io/apimachinery/pkg/types"
@@ -35,15 +35,15 @@ type CanariesGetter interface {
 
 // CanaryInterface has methods to work with Canary resources.
 type CanaryInterface interface {
-	Create(*v1beta1.Canary) (*v1beta1.Canary, error)
-	Update(*v1beta1.Canary) (*v1beta1.Canary, error)
-	UpdateStatus(*v1beta1.Canary) (*v1beta1.Canary, error)
+	Create(*v1alpha1.Canary) (*v1alpha1.Canary, error)
+	Update(*v1alpha1.Canary) (*v1alpha1.Canary, error)
+	UpdateStatus(*v1alpha1.Canary) (*v1alpha1.Canary, error)
 	Delete(name string, options *v1.DeleteOptions) error
 	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
-	Get(name string, options v1.GetOptions) (*v1beta1.Canary, error)
-	List(opts v1.ListOptions) (*v1beta1.CanaryList, error)
+	Get(name string, options v1.GetOptions) (*v1alpha1.Canary, error)
+	List(opts v1.ListOptions) (*v1alpha1.CanaryList, error)
 	Watch(opts v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Canary, err error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Canary, err error)
 	CanaryExpansion
 }
 
@@ -54,7 +54,7 @@ type canaries struct {
 }
 
 // newCanaries returns a Canaries
-func newCanaries(c *FlaggerV1beta1Client, namespace string) *canaries {
+func newCanaries(c *FlaggerV1alpha1Client, namespace string) *canaries {
 	return &canaries{
 		client: c.RESTClient(),
 		ns:     namespace,
@@ -62,8 +62,8 @@ func newCanaries(c *FlaggerV1beta1Client, namespace string) *canaries {
 }
 
 // Get takes name of the canary, and returns the corresponding canary object, and an error if there is any.
-func (c *canaries) Get(name string, options v1.GetOptions) (result *v1beta1.Canary, err error) {
-	result = &v1beta1.Canary{}
+func (c *canaries) Get(name string, options v1.GetOptions) (result *v1alpha1.Canary, err error) {
+	result = &v1alpha1.Canary{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("canaries").
@@ -75,8 +75,8 @@ func (c *canaries) Get(name string, options v1.GetOptions) (result *v1beta1.Cana
 }
 
 // List takes label and field selectors, and returns the list of Canaries that match those selectors.
-func (c *canaries) List(opts v1.ListOptions) (result *v1beta1.CanaryList, err error) {
-	result = &v1beta1.CanaryList{}
+func (c *canaries) List(opts v1.ListOptions) (result *v1alpha1.CanaryList, err error) {
+	result = &v1alpha1.CanaryList{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("canaries").
@@ -97,8 +97,8 @@ func (c *canaries) Watch(opts v1.ListOptions) (watch.Interface, error) {
 }
 
 // Create takes the representation of a canary and creates it.  Returns the server's representation of the canary, and an error, if there is any.
-func (c *canaries) Create(canary *v1beta1.Canary) (result *v1beta1.Canary, err error) {
-	result = &v1beta1.Canary{}
+func (c *canaries) Create(canary *v1alpha1.Canary) (result *v1alpha1.Canary, err error) {
+	result = &v1alpha1.Canary{}
 	err = c.client.Post().
 		Namespace(c.ns).
 		Resource("canaries").
@@ -109,8 +109,8 @@ func (c *canaries) Create(canary *v1beta1.Canary) (result *v1beta1.Canary, err e
 }
 
 // Update takes the representation of a canary and updates it. Returns the server's representation of the canary, and an error, if there is any.
-func (c *canaries) Update(canary *v1beta1.Canary) (result *v1beta1.Canary, err error) {
-	result = &v1beta1.Canary{}
+func (c *canaries) Update(canary *v1alpha1.Canary) (result *v1alpha1.Canary, err error) {
+	result = &v1alpha1.Canary{}
 	err = c.client.Put().
 		Namespace(c.ns).
 		Resource("canaries").
@@ -124,8 +124,8 @@ func (c *canaries) Update(canary *v1beta1.Canary) (result *v1beta1.Canary, err e
 // UpdateStatus was generated because the type contains a Status member.
 // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
 
-func (c *canaries) UpdateStatus(canary *v1beta1.Canary) (result *v1beta1.Canary, err error) {
-	result = &v1beta1.Canary{}
+func (c *canaries) UpdateStatus(canary *v1alpha1.Canary) (result *v1alpha1.Canary, err error) {
+	result = &v1alpha1.Canary{}
 	err = c.client.Put().
 		Namespace(c.ns).
 		Resource("canaries").
@@ -160,8 +160,8 @@ func (c *canaries) DeleteCollection(options *v1.DeleteOptions, listOptions v1.Li
 }
 
 // Patch applies the patch and returns the patched canary.
-func (c *canaries) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Canary, err error) {
-	result = &v1beta1.Canary{}
+func (c *canaries) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Canary, err error) {
+	result = &v1alpha1.Canary{}
 	err = c.client.Patch(pt).
 		Namespace(c.ns).
 		Resource("canaries").

pkg/client/clientset/versioned/typed/flagger/v1alpha1/doc.go

@@ -17,4 +17,4 @@ limitations under the License.
 // Code generated by client-gen. DO NOT EDIT.
 
 // This package has the automatically generated typed clients.
-package v1beta1
+package v1alpha1

pkg/client/clientset/versioned/typed/flagger/v1alpha1/fake/fake_canary.go

@@ -19,7 +19,7 @@ limitations under the License.
 package fake
 
 import (
-	v1beta1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	v1alpha1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
@@ -30,29 +30,29 @@ import (
 
 // FakeCanaries implements CanaryInterface
 type FakeCanaries struct {
-	Fake *FakeFlaggerV1beta1
+	Fake *FakeFlaggerV1alpha1
 	ns   string
 }
 
-var canariesResource = schema.GroupVersionResource{Group: "flagger.app", Version: "v1beta1", Resource: "canaries"}
+var canariesResource = schema.GroupVersionResource{Group: "flagger.app", Version: "v1alpha1", Resource: "canaries"}
 
-var canariesKind = schema.GroupVersionKind{Group: "flagger.app", Version: "v1beta1", Kind: "Canary"}
+var canariesKind = schema.GroupVersionKind{Group: "flagger.app", Version: "v1alpha1", Kind: "Canary"}
 
 // Get takes name of the canary, and returns the corresponding canary object, and an error if there is any.
-func (c *FakeCanaries) Get(name string, options v1.GetOptions) (result *v1beta1.Canary, err error) {
+func (c *FakeCanaries) Get(name string, options v1.GetOptions) (result *v1alpha1.Canary, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewGetAction(canariesResource, c.ns, name), &v1beta1.Canary{})
+		Invokes(testing.NewGetAction(canariesResource, c.ns, name), &v1alpha1.Canary{})
 
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*v1beta1.Canary), err
+	return obj.(*v1alpha1.Canary), err
 }
 
 // List takes label and field selectors, and returns the list of Canaries that match those selectors.
-func (c *FakeCanaries) List(opts v1.ListOptions) (result *v1beta1.CanaryList, err error) {
+func (c *FakeCanaries) List(opts v1.ListOptions) (result *v1alpha1.CanaryList, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewListAction(canariesResource, canariesKind, c.ns, opts), &v1beta1.CanaryList{})
+		Invokes(testing.NewListAction(canariesResource, canariesKind, c.ns, opts), &v1alpha1.CanaryList{})
 
 	if obj == nil {
 		return nil, err
@@ -62,8 +62,8 @@ func (c *FakeCanaries) List(opts v1.ListOptions) (result *v1beta1.CanaryList, er
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.CanaryList{ListMeta: obj.(*v1beta1.CanaryList).ListMeta}
-	for _, item := range obj.(*v1beta1.CanaryList).Items {
+	list := &v1alpha1.CanaryList{ListMeta: obj.(*v1alpha1.CanaryList).ListMeta}
+	for _, item := range obj.(*v1alpha1.CanaryList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
 		}
@@ -79,43 +79,43 @@ func (c *FakeCanaries) Watch(opts v1.ListOptions) (watch.Interface, error) {
 }
 
 // Create takes the representation of a canary and creates it.  Returns the server's representation of the canary, and an error, if there is any.
-func (c *FakeCanaries) Create(canary *v1beta1.Canary) (result *v1beta1.Canary, err error) {
+func (c *FakeCanaries) Create(canary *v1alpha1.Canary) (result *v1alpha1.Canary, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewCreateAction(canariesResource, c.ns, canary), &v1beta1.Canary{})
+		Invokes(testing.NewCreateAction(canariesResource, c.ns, canary), &v1alpha1.Canary{})
 
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*v1beta1.Canary), err
+	return obj.(*v1alpha1.Canary), err
 }
 
 // Update takes the representation of a canary and updates it. Returns the server's representation of the canary, and an error, if there is any.
-func (c *FakeCanaries) Update(canary *v1beta1.Canary) (result *v1beta1.Canary, err error) {
+func (c *FakeCanaries) Update(canary *v1alpha1.Canary) (result *v1alpha1.Canary, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewUpdateAction(canariesResource, c.ns, canary), &v1beta1.Canary{})
+		Invokes(testing.NewUpdateAction(canariesResource, c.ns, canary), &v1alpha1.Canary{})
 
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*v1beta1.Canary), err
+	return obj.(*v1alpha1.Canary), err
 }
 
 // UpdateStatus was generated because the type contains a Status member.
 // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
-func (c *FakeCanaries) UpdateStatus(canary *v1beta1.Canary) (*v1beta1.Canary, error) {
+func (c *FakeCanaries) UpdateStatus(canary *v1alpha1.Canary) (*v1alpha1.Canary, error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewUpdateSubresourceAction(canariesResource, "status", c.ns, canary), &v1beta1.Canary{})
+		Invokes(testing.NewUpdateSubresourceAction(canariesResource, "status", c.ns, canary), &v1alpha1.Canary{})
 
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*v1beta1.Canary), err
+	return obj.(*v1alpha1.Canary), err
 }
 
 // Delete takes name of the canary and deletes it. Returns an error if one occurs.
 func (c *FakeCanaries) Delete(name string, options *v1.DeleteOptions) error {
 	_, err := c.Fake.
-		Invokes(testing.NewDeleteAction(canariesResource, c.ns, name), &v1beta1.Canary{})
+		Invokes(testing.NewDeleteAction(canariesResource, c.ns, name), &v1alpha1.Canary{})
 
 	return err
 }
@@ -124,17 +124,17 @@ func (c *FakeCanaries) Delete(name string, options *v1.DeleteOptions) error {
 func (c *FakeCanaries) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
 	action := testing.NewDeleteCollectionAction(canariesResource, c.ns, listOptions)
 
-	_, err := c.Fake.Invokes(action, &v1beta1.CanaryList{})
+	_, err := c.Fake.Invokes(action, &v1alpha1.CanaryList{})
 	return err
 }
 
 // Patch applies the patch and returns the patched canary.
-func (c *FakeCanaries) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Canary, err error) {
+func (c *FakeCanaries) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Canary, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(canariesResource, c.ns, name, data, subresources...), &v1beta1.Canary{})
+		Invokes(testing.NewPatchSubresourceAction(canariesResource, c.ns, name, data, subresources...), &v1alpha1.Canary{})
 
 	if obj == nil {
 		return nil, err
 	}
-	return obj.(*v1beta1.Canary), err
+	return obj.(*v1alpha1.Canary), err
 }

pkg/client/clientset/versioned/typed/flagger/v1alpha1/fake/fake_flagger_client.go

@@ -19,22 +19,22 @@ limitations under the License.
 package fake
 
 import (
-	v1beta1 "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/typed/flagger/v1beta1"
+	v1alpha1 "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/typed/flagger/v1alpha1"
 	rest "k8s.io/client-go/rest"
 	testing "k8s.io/client-go/testing"
 )
 
-type FakeFlaggerV1beta1 struct {
+type FakeFlaggerV1alpha1 struct {
 	*testing.Fake
 }
 
-func (c *FakeFlaggerV1beta1) Canaries(namespace string) v1beta1.CanaryInterface {
+func (c *FakeFlaggerV1alpha1) Canaries(namespace string) v1alpha1.CanaryInterface {
 	return &FakeCanaries{c, namespace}
 }
 
 // RESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *FakeFlaggerV1beta1) RESTClient() rest.Interface {
+func (c *FakeFlaggerV1alpha1) RESTClient() rest.Interface {
 	var ret *rest.RESTClient
 	return ret
 }

pkg/client/clientset/versioned/typed/flagger/v1alpha1/flagger_client.go

@@ -16,31 +16,31 @@ limitations under the License.
 
 // Code generated by client-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 import (
-	v1beta1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	v1alpha1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	"github.com/stefanprodan/flagger/pkg/client/clientset/versioned/scheme"
 	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	rest "k8s.io/client-go/rest"
 )
 
-type FlaggerV1beta1Interface interface {
+type FlaggerV1alpha1Interface interface {
 	RESTClient() rest.Interface
 	CanariesGetter
 }
 
-// FlaggerV1beta1Client is used to interact with features provided by the flagger.app group.
-type FlaggerV1beta1Client struct {
+// FlaggerV1alpha1Client is used to interact with features provided by the flagger.app group.
+type FlaggerV1alpha1Client struct {
 	restClient rest.Interface
 }
 
-func (c *FlaggerV1beta1Client) Canaries(namespace string) CanaryInterface {
+func (c *FlaggerV1alpha1Client) Canaries(namespace string) CanaryInterface {
 	return newCanaries(c, namespace)
 }
 
-// NewForConfig creates a new FlaggerV1beta1Client for the given config.
-func NewForConfig(c *rest.Config) (*FlaggerV1beta1Client, error) {
+// NewForConfig creates a new FlaggerV1alpha1Client for the given config.
+func NewForConfig(c *rest.Config) (*FlaggerV1alpha1Client, error) {
 	config := *c
 	if err := setConfigDefaults(&config); err != nil {
 		return nil, err
@@ -49,12 +49,12 @@ func NewForConfig(c *rest.Config) (*FlaggerV1beta1Client, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &FlaggerV1beta1Client{client}, nil
+	return &FlaggerV1alpha1Client{client}, nil
 }
 
-// NewForConfigOrDie creates a new FlaggerV1beta1Client for the given config and
+// NewForConfigOrDie creates a new FlaggerV1alpha1Client for the given config and
 // panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *FlaggerV1beta1Client {
+func NewForConfigOrDie(c *rest.Config) *FlaggerV1alpha1Client {
 	client, err := NewForConfig(c)
 	if err != nil {
 		panic(err)
@@ -62,13 +62,13 @@ func NewForConfigOrDie(c *rest.Config) *FlaggerV1beta1Client {
 	return client
 }
 
-// New creates a new FlaggerV1beta1Client for the given RESTClient.
-func New(c rest.Interface) *FlaggerV1beta1Client {
-	return &FlaggerV1beta1Client{c}
+// New creates a new FlaggerV1alpha1Client for the given RESTClient.
+func New(c rest.Interface) *FlaggerV1alpha1Client {
+	return &FlaggerV1alpha1Client{c}
 }
 
 func setConfigDefaults(config *rest.Config) error {
-	gv := v1beta1.SchemeGroupVersion
+	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
 	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
@@ -82,7 +82,7 @@ func setConfigDefaults(config *rest.Config) error {
 
 // RESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *FlaggerV1beta1Client) RESTClient() rest.Interface {
+func (c *FlaggerV1alpha1Client) RESTClient() rest.Interface {
 	if c == nil {
 		return nil
 	}

pkg/client/clientset/versioned/typed/flagger/v1alpha1/generated_expansion.go

@@ -16,6 +16,6 @@ limitations under the License.
 
 // Code generated by client-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 type CanaryExpansion interface{}

pkg/client/informers/externalversions/flagger/interface.go

@@ -19,14 +19,14 @@ limitations under the License.
 package flagger
 
 import (
-	v1beta1 "github.com/stefanprodan/flagger/pkg/client/informers/externalversions/flagger/v1beta1"
+	v1alpha1 "github.com/stefanprodan/flagger/pkg/client/informers/externalversions/flagger/v1alpha1"
 	internalinterfaces "github.com/stefanprodan/flagger/pkg/client/informers/externalversions/internalinterfaces"
 )
 
 // Interface provides access to each of this group's versions.
 type Interface interface {
-	// V1beta1 provides access to shared informers for resources in V1beta1.
-	V1beta1() v1beta1.Interface
+	// V1alpha1 provides access to shared informers for resources in V1alpha1.
+	V1alpha1() v1alpha1.Interface
 }
 
 type group struct {
@@ -40,7 +40,7 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
 	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
 }
 
-// V1beta1 returns a new v1beta1.Interface.
-func (g *group) V1beta1() v1beta1.Interface {
-	return v1beta1.New(g.factory, g.namespace, g.tweakListOptions)
+// V1alpha1 returns a new v1alpha1.Interface.
+func (g *group) V1alpha1() v1alpha1.Interface {
+	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
 }

pkg/client/informers/externalversions/flagger/v1alpha1/canary.go

@@ -16,15 +16,15 @@ limitations under the License.
 
 // Code generated by informer-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 import (
 	time "time"
 
-	flaggerv1beta1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	flaggerv1alpha1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	versioned "github.com/stefanprodan/flagger/pkg/client/clientset/versioned"
 	internalinterfaces "github.com/stefanprodan/flagger/pkg/client/informers/externalversions/internalinterfaces"
-	v1beta1 "github.com/stefanprodan/flagger/pkg/client/listers/flagger/v1beta1"
+	v1alpha1 "github.com/stefanprodan/flagger/pkg/client/listers/flagger/v1alpha1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -35,7 +35,7 @@ import (
 // Canaries.
 type CanaryInformer interface {
 	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.CanaryLister
+	Lister() v1alpha1.CanaryLister
 }
 
 type canaryInformer struct {
@@ -61,16 +61,16 @@ func NewFilteredCanaryInformer(client versioned.Interface, namespace string, res
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.FlaggerV1beta1().Canaries(namespace).List(options)
+				return client.FlaggerV1alpha1().Canaries(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.FlaggerV1beta1().Canaries(namespace).Watch(options)
+				return client.FlaggerV1alpha1().Canaries(namespace).Watch(options)
 			},
 		},
-		&flaggerv1beta1.Canary{},
+		&flaggerv1alpha1.Canary{},
 		resyncPeriod,
 		indexers,
 	)
@@ -81,9 +81,9 @@ func (f *canaryInformer) defaultInformer(client versioned.Interface, resyncPerio
 }
 
 func (f *canaryInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&flaggerv1beta1.Canary{}, f.defaultInformer)
+	return f.factory.InformerFor(&flaggerv1alpha1.Canary{}, f.defaultInformer)
 }
 
-func (f *canaryInformer) Lister() v1beta1.CanaryLister {
-	return v1beta1.NewCanaryLister(f.Informer().GetIndexer())
+func (f *canaryInformer) Lister() v1alpha1.CanaryLister {
+	return v1alpha1.NewCanaryLister(f.Informer().GetIndexer())
 }

pkg/client/informers/externalversions/flagger/v1alpha1/interface.go

@@ -16,7 +16,7 @@ limitations under the License.
 
 // Code generated by informer-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 import (
 	internalinterfaces "github.com/stefanprodan/flagger/pkg/client/informers/externalversions/internalinterfaces"

pkg/client/informers/externalversions/generic.go

@@ -21,7 +21,7 @@ package externalversions
 import (
 	"fmt"
 
-	v1beta1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	v1alpha1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
 	cache "k8s.io/client-go/tools/cache"
 )
@@ -52,9 +52,9 @@ func (f *genericInformer) Lister() cache.GenericLister {
 // TODO extend this to unknown resources with a client pool
 func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
 	switch resource {
-	// Group=flagger.app, Version=v1beta1
-	case v1beta1.SchemeGroupVersion.WithResource("canaries"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Flagger().V1beta1().Canaries().Informer()}, nil
+	// Group=flagger.app, Version=v1alpha1
+	case v1alpha1.SchemeGroupVersion.WithResource("canaries"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Flagger().V1alpha1().Canaries().Informer()}, nil
 
 	}
 

pkg/client/listers/flagger/v1alpha1/canary.go

@@ -16,10 +16,10 @@ limitations under the License.
 
 // Code generated by lister-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 import (
-	v1beta1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	v1alpha1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/client-go/tools/cache"
@@ -28,7 +28,7 @@ import (
 // CanaryLister helps list Canaries.
 type CanaryLister interface {
 	// List lists all Canaries in the indexer.
-	List(selector labels.Selector) (ret []*v1beta1.Canary, err error)
+	List(selector labels.Selector) (ret []*v1alpha1.Canary, err error)
 	// Canaries returns an object that can list and get Canaries.
 	Canaries(namespace string) CanaryNamespaceLister
 	CanaryListerExpansion
@@ -45,9 +45,9 @@ func NewCanaryLister(indexer cache.Indexer) CanaryLister {
 }
 
 // List lists all Canaries in the indexer.
-func (s *canaryLister) List(selector labels.Selector) (ret []*v1beta1.Canary, err error) {
+func (s *canaryLister) List(selector labels.Selector) (ret []*v1alpha1.Canary, err error) {
 	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1beta1.Canary))
+		ret = append(ret, m.(*v1alpha1.Canary))
 	})
 	return ret, err
 }
@@ -60,9 +60,9 @@ func (s *canaryLister) Canaries(namespace string) CanaryNamespaceLister {
 // CanaryNamespaceLister helps list and get Canaries.
 type CanaryNamespaceLister interface {
 	// List lists all Canaries in the indexer for a given namespace.
-	List(selector labels.Selector) (ret []*v1beta1.Canary, err error)
+	List(selector labels.Selector) (ret []*v1alpha1.Canary, err error)
 	// Get retrieves the Canary from the indexer for a given namespace and name.
-	Get(name string) (*v1beta1.Canary, error)
+	Get(name string) (*v1alpha1.Canary, error)
 	CanaryNamespaceListerExpansion
 }
 
@@ -74,21 +74,21 @@ type canaryNamespaceLister struct {
 }
 
 // List lists all Canaries in the indexer for a given namespace.
-func (s canaryNamespaceLister) List(selector labels.Selector) (ret []*v1beta1.Canary, err error) {
+func (s canaryNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.Canary, err error) {
 	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1beta1.Canary))
+		ret = append(ret, m.(*v1alpha1.Canary))
 	})
 	return ret, err
 }
 
 // Get retrieves the Canary from the indexer for a given namespace and name.
-func (s canaryNamespaceLister) Get(name string) (*v1beta1.Canary, error) {
+func (s canaryNamespaceLister) Get(name string) (*v1alpha1.Canary, error) {
 	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
 	if err != nil {
 		return nil, err
 	}
 	if !exists {
-		return nil, errors.NewNotFound(v1beta1.Resource("canary"), name)
+		return nil, errors.NewNotFound(v1alpha1.Resource("canary"), name)
 	}
-	return obj.(*v1beta1.Canary), nil
+	return obj.(*v1alpha1.Canary), nil
 }

pkg/client/listers/flagger/v1alpha1/expansion_generated.go

@@ -16,7 +16,7 @@ limitations under the License.
 
 // Code generated by lister-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 // CanaryListerExpansion allows custom methods to be added to
 // CanaryLister.

pkg/controller/controller.go

@@ -7,11 +7,12 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	istioclientset "github.com/knative/pkg/client/clientset/versioned"
-	flaggerv1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
+	flaggerv1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
 	clientset "github.com/stefanprodan/flagger/pkg/client/clientset/versioned"
 	flaggerscheme "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/scheme"
-	flaggerinformers "github.com/stefanprodan/flagger/pkg/client/informers/externalversions/flagger/v1beta1"
-	flaggerlisters "github.com/stefanprodan/flagger/pkg/client/listers/flagger/v1beta1"
+	flaggerinformers "github.com/stefanprodan/flagger/pkg/client/informers/externalversions/flagger/v1alpha1"
+	flaggerlisters "github.com/stefanprodan/flagger/pkg/client/listers/flagger/v1alpha1"
+	"github.com/stefanprodan/flagger/pkg/notifier"
 	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -27,28 +28,34 @@ import (
 
 const controllerAgentName = "flagger"
 
+// Controller is managing the canary objects and schedules canary deployments
 type Controller struct {
 	kubeClient    kubernetes.Interface
 	istioClient   istioclientset.Interface
-	rolloutClient clientset.Interface
-	rolloutLister flaggerlisters.CanaryLister
-	rolloutSynced cache.InformerSynced
-	rolloutWindow time.Duration
+	flaggerClient clientset.Interface
+	flaggerLister flaggerlisters.CanaryLister
+	flaggerSynced cache.InformerSynced
+	flaggerWindow time.Duration
 	workqueue     workqueue.RateLimitingInterface
-	recorder      record.EventRecorder
+	eventRecorder record.EventRecorder
 	logger        *zap.SugaredLogger
-	metricsServer string
-	rollouts      *sync.Map
+	canaries      *sync.Map
+	deployer      CanaryDeployer
+	router        CanaryRouter
+	observer      CanaryObserver
+	recorder      CanaryRecorder
+	notifier      *notifier.Slack
 }
 
 func NewController(
 	kubeClient kubernetes.Interface,
 	istioClient istioclientset.Interface,
-	rolloutClient clientset.Interface,
-	rolloutInformer flaggerinformers.CanaryInformer,
-	rolloutWindow time.Duration,
+	flaggerClient clientset.Interface,
+	flaggerInformer flaggerinformers.CanaryInformer,
+	flaggerWindow time.Duration,
 	metricServer string,
 	logger *zap.SugaredLogger,
+	notifier *notifier.Slack,
 
 ) *Controller {
 	logger.Debug("Creating event broadcaster")
@@ -58,25 +65,49 @@ func NewController(
 	eventBroadcaster.StartRecordingToSink(&typedcorev1.EventSinkImpl{
 		Interface: kubeClient.CoreV1().Events(""),
 	})
-	recorder := eventBroadcaster.NewRecorder(
+	eventRecorder := eventBroadcaster.NewRecorder(
 		scheme.Scheme, corev1.EventSource{Component: controllerAgentName})
 
+	deployer := CanaryDeployer{
+		logger:        logger,
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		flaggerClient: flaggerClient,
+	}
+
+	router := CanaryRouter{
+		logger:        logger,
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		flaggerClient: flaggerClient,
+	}
+
+	observer := CanaryObserver{
+		metricsServer: metricServer,
+	}
+
+	recorder := NewCanaryRecorder(true)
+
 	ctrl := &Controller{
 		kubeClient:    kubeClient,
 		istioClient:   istioClient,
-		rolloutClient: rolloutClient,
-		rolloutLister: rolloutInformer.Lister(),
-		rolloutSynced: rolloutInformer.Informer().HasSynced,
+		flaggerClient: flaggerClient,
+		flaggerLister: flaggerInformer.Lister(),
+		flaggerSynced: flaggerInformer.Informer().HasSynced,
 		workqueue:     workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerAgentName),
-		recorder:      recorder,
+		eventRecorder: eventRecorder,
 		logger:        logger,
-		rollouts:      new(sync.Map),
-		metricsServer: metricServer,
-		rolloutWindow: rolloutWindow,
+		canaries:      new(sync.Map),
+		flaggerWindow: flaggerWindow,
+		deployer:      deployer,
+		router:        router,
+		observer:      observer,
+		recorder:      recorder,
+		notifier:      notifier,
 	}
 
-	rolloutInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
-		AddFunc: ctrl.enqueueRollout,
+	flaggerInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
+		AddFunc: ctrl.enqueue,
 		UpdateFunc: func(old, new interface{}) {
 			oldRoll, ok := checkCustomResourceType(old, logger)
 			if !ok {
@@ -89,14 +120,14 @@ func NewController(
 
 			if diff := cmp.Diff(newRoll.Spec, oldRoll.Spec); diff != "" {
 				ctrl.logger.Debugf("Diff detected %s.%s %s", oldRoll.Name, oldRoll.Namespace, diff)
-				ctrl.enqueueRollout(new)
+				ctrl.enqueue(new)
 			}
 		},
 		DeleteFunc: func(old interface{}) {
 			r, ok := checkCustomResourceType(old, logger)
 			if ok {
 				ctrl.logger.Infof("Deleting %s.%s from cache", r.Name, r.Namespace)
-				ctrl.rollouts.Delete(fmt.Sprintf("%s.%s", r.Name, r.Namespace))
+				ctrl.canaries.Delete(fmt.Sprintf("%s.%s", r.Name, r.Namespace))
 			}
 		},
 	})
@@ -104,11 +135,12 @@ func NewController(
 	return ctrl
 }
 
+// Run starts the K8s workers and the canary scheduler
 func (c *Controller) Run(threadiness int, stopCh <-chan struct{}) error {
 	defer utilruntime.HandleCrash()
 	defer c.workqueue.ShutDown()
 
-	c.logger.Info("Starting controller")
+	c.logger.Info("Starting operator")
 
 	for i := 0; i < threadiness; i++ {
 		go wait.Until(func() {
@@ -117,20 +149,18 @@ func (c *Controller) Run(threadiness int, stopCh <-chan struct{}) error {
 		}, time.Second, stopCh)
 	}
 
-	c.logger.Info("Started workers")
+	c.logger.Info("Started operator workers")
 
-	tickChan := time.NewTicker(c.rolloutWindow).C
+	tickChan := time.NewTicker(c.flaggerWindow).C
 	for {
 		select {
 		case <-tickChan:
-			c.doRollouts()
+			c.scheduleCanaries()
 		case <-stopCh:
-			c.logger.Info("Shutting down workers")
+			c.logger.Info("Shutting down operator workers")
 			return nil
 		}
 	}
-
-	return nil
 }
 
 func (c *Controller) processNextWorkItem() bool {
@@ -174,19 +204,28 @@ func (c *Controller) syncHandler(key string) error {
 		utilruntime.HandleError(fmt.Errorf("invalid resource key: %s", key))
 		return nil
 	}
-	rollout, err := c.rolloutLister.Canaries(namespace).Get(name)
+	cd, err := c.flaggerLister.Canaries(namespace).Get(name)
 	if errors.IsNotFound(err) {
-		utilruntime.HandleError(fmt.Errorf("rollout '%s' in work queue no longer exists", key))
+		utilruntime.HandleError(fmt.Errorf("'%s' in work queue no longer exists", key))
 		return nil
 	}
 
-	c.rollouts.Store(fmt.Sprintf("%s.%s", rollout.Name, rollout.Namespace), rollout)
+	c.canaries.Store(fmt.Sprintf("%s.%s", cd.Name, cd.Namespace), cd)
+
+	//if cd.Spec.TargetRef.Kind == "Deployment" {
+	//	err = c.bootstrapDeployment(cd)
+	//	if err != nil {
+	//		c.logger.Warnf("%s.%s bootstrap error %v", cd.Name, cd.Namespace, err)
+	//		return err
+	//	}
+	//}
+
 	c.logger.Infof("Synced %s", key)
 
 	return nil
 }
 
-func (c *Controller) enqueueRollout(obj interface{}) {
+func (c *Controller) enqueue(obj interface{}) {
 	var key string
 	var err error
 	if key, err = cache.MetaNamespaceKeyFunc(obj); err != nil {
@@ -196,21 +235,6 @@ func (c *Controller) enqueueRollout(obj interface{}) {
 	c.workqueue.AddRateLimited(key)
 }
 
-func (c *Controller) recordEventInfof(r *flaggerv1.Canary, template string, args ...interface{}) {
-	c.logger.Infof(template, args...)
-	c.recorder.Event(r, corev1.EventTypeNormal, "Synced", fmt.Sprintf(template, args...))
-}
-
-func (c *Controller) recordEventErrorf(r *flaggerv1.Canary, template string, args ...interface{}) {
-	c.logger.Errorf(template, args...)
-	c.recorder.Event(r, corev1.EventTypeWarning, "Synced", fmt.Sprintf(template, args...))
-}
-
-func (c *Controller) recordEventWarningf(r *flaggerv1.Canary, template string, args ...interface{}) {
-	c.logger.Infof(template, args...)
-	c.recorder.Event(r, corev1.EventTypeWarning, "Synced", fmt.Sprintf(template, args...))
-}
-
 func checkCustomResourceType(obj interface{}, logger *zap.SugaredLogger) (flaggerv1.Canary, bool) {
 	var roll *flaggerv1.Canary
 	var ok bool
@@ -220,3 +244,33 @@ func checkCustomResourceType(obj interface{}, logger *zap.SugaredLogger) (flagge
 	}
 	return *roll, true
 }
+
+func (c *Controller) recordEventInfof(r *flaggerv1.Canary, template string, args ...interface{}) {
+	c.logger.Infof(template, args...)
+	c.eventRecorder.Event(r, corev1.EventTypeNormal, "Synced", fmt.Sprintf(template, args...))
+}
+
+func (c *Controller) recordEventErrorf(r *flaggerv1.Canary, template string, args ...interface{}) {
+	c.logger.Errorf(template, args...)
+	c.eventRecorder.Event(r, corev1.EventTypeWarning, "Synced", fmt.Sprintf(template, args...))
+}
+
+func (c *Controller) recordEventWarningf(r *flaggerv1.Canary, template string, args ...interface{}) {
+	c.logger.Infof(template, args...)
+	c.eventRecorder.Event(r, corev1.EventTypeWarning, "Synced", fmt.Sprintf(template, args...))
+}
+
+func (c *Controller) sendNotification(workload string, namespace string, message string, warn bool) {
+	if c.notifier == nil {
+		return
+	}
+
+	err := c.notifier.Post(workload, namespace, message, warn)
+	if err != nil {
+		c.logger.Error(err)
+	}
+}
+
+func int32p(i int32) *int32 {
+	return &i
+}

pkg/controller/deployer.go

@@ -0,0 +1,358 @@
+package controller
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	istioclientset "github.com/knative/pkg/client/clientset/versioned"
+	flaggerv1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
+	clientset "github.com/stefanprodan/flagger/pkg/client/clientset/versioned"
+	"go.uber.org/zap"
+	appsv1 "k8s.io/api/apps/v1"
+	hpav1 "k8s.io/api/autoscaling/v2beta1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/kubernetes"
+)
+
+// CanaryDeployer is managing the operations for Kubernetes deployment kind
+type CanaryDeployer struct {
+	kubeClient    kubernetes.Interface
+	istioClient   istioclientset.Interface
+	flaggerClient clientset.Interface
+	logger        *zap.SugaredLogger
+}
+
+// Promote copies the pod spec from canary to primary
+func (c *CanaryDeployer) Promote(cd *flaggerv1.Canary) error {
+	canary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(cd.Spec.TargetRef.Name, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("deployment %s.%s not found", cd.Spec.TargetRef.Name, cd.Namespace)
+		}
+		return fmt.Errorf("deployment %s.%s query error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+
+	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
+	primary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(primaryName, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("deployment %s.%s not found", primaryName, cd.Namespace)
+		}
+		return fmt.Errorf("deployment %s.%s query error %v", primaryName, cd.Namespace, err)
+	}
+
+	primary.Spec.MinReadySeconds = canary.Spec.MinReadySeconds
+	primary.Spec.RevisionHistoryLimit = canary.Spec.RevisionHistoryLimit
+	primary.Spec.Strategy = canary.Spec.Strategy
+	primary.Spec.Template.Spec = canary.Spec.Template.Spec
+	_, err = c.kubeClient.AppsV1().Deployments(primary.Namespace).Update(primary)
+	if err != nil {
+		return fmt.Errorf("updating template spec %s.%s failed: %v", primary.GetName(), primary.Namespace, err)
+
+	}
+
+	return nil
+}
+
+// IsReady checks the primary and canary deployment status and returns an error if
+// the deployments are in the middle of a rolling update or if the pods are unhealthy
+func (c *CanaryDeployer) IsReady(cd *flaggerv1.Canary) error {
+	canary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(cd.Spec.TargetRef.Name, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("deployment %s.%s not found", cd.Spec.TargetRef.Name, cd.Namespace)
+		}
+		return fmt.Errorf("deployment %s.%s query error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+	if msg, healthy := c.getDeploymentStatus(canary); !healthy {
+		return fmt.Errorf("Halt %s.%s advancement %s", cd.Name, cd.Namespace, msg)
+	}
+
+	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
+	primary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(primaryName, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("deployment %s.%s not found", primaryName, cd.Namespace)
+		}
+		return fmt.Errorf("deployment %s.%s query error %v", primaryName, cd.Namespace, err)
+	}
+	if msg, healthy := c.getDeploymentStatus(primary); !healthy {
+		return fmt.Errorf("Halt %s.%s advancement %s", cd.Name, cd.Namespace, msg)
+	}
+
+	if primary.Spec.Replicas == int32p(0) {
+		return fmt.Errorf("halt %s.%s advancement %s",
+			cd.Name, cd.Namespace, "primary deployment is scaled to zero")
+	}
+	return nil
+}
+
+// IsNewSpec returns true if the canary deployment pod spec has changed
+func (c *CanaryDeployer) IsNewSpec(cd *flaggerv1.Canary) (bool, error) {
+	canary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(cd.Spec.TargetRef.Name, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return false, fmt.Errorf("deployment %s.%s not found", cd.Spec.TargetRef.Name, cd.Namespace)
+		}
+		return false, fmt.Errorf("deployment %s.%s query error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+
+	if cd.Status.CanaryRevision == "" {
+		return true, nil
+	}
+
+	newSpec := &canary.Spec.Template.Spec
+	oldSpecJson, err := base64.StdEncoding.DecodeString(cd.Status.CanaryRevision)
+	if err != nil {
+		return false, err
+	}
+	oldSpec := &corev1.PodSpec{}
+	err = json.Unmarshal(oldSpecJson, oldSpec)
+	if err != nil {
+		return false, fmt.Errorf("%s.%s unmarshal error %v", cd.Name, cd.Namespace, err)
+	}
+
+	if diff := cmp.Diff(*newSpec, *oldSpec, cmpopts.IgnoreUnexported(resource.Quantity{})); diff != "" {
+		//fmt.Println(diff)
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// SetFailedChecks updates the canary failed checks counter
+func (c *CanaryDeployer) SetFailedChecks(cd *flaggerv1.Canary, val int) error {
+	cd.Status.FailedChecks = val
+	cd.Status.LastTransitionTime = metav1.Now()
+	cd, err := c.flaggerClient.FlaggerV1alpha1().Canaries(cd.Namespace).Update(cd)
+	if err != nil {
+		return fmt.Errorf("deployment %s.%s update error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+	return nil
+}
+
+// SetState updates the canary status state
+func (c *CanaryDeployer) SetState(cd *flaggerv1.Canary, state string) error {
+	cd.Status.State = state
+	cd.Status.LastTransitionTime = metav1.Now()
+	cd, err := c.flaggerClient.FlaggerV1alpha1().Canaries(cd.Namespace).Update(cd)
+	if err != nil {
+		return fmt.Errorf("deployment %s.%s update error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+	return nil
+}
+
+// SyncStatus encodes the canary pod spec and updates the canary status
+func (c *CanaryDeployer) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatus) error {
+	canary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(cd.Spec.TargetRef.Name, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("deployment %s.%s not found", cd.Spec.TargetRef.Name, cd.Namespace)
+		}
+		return fmt.Errorf("deployment %s.%s query error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+
+	specJson, err := json.Marshal(canary.Spec.Template.Spec)
+	if err != nil {
+		return fmt.Errorf("deployment %s.%s marshal error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+
+	specEnc := base64.StdEncoding.EncodeToString(specJson)
+	cd.Status.State = status.State
+	cd.Status.FailedChecks = status.FailedChecks
+	cd.Status.CanaryRevision = specEnc
+	cd.Status.LastTransitionTime = metav1.Now()
+	cd, err = c.flaggerClient.FlaggerV1alpha1().Canaries(cd.Namespace).Update(cd)
+	if err != nil {
+		return fmt.Errorf("deployment %s.%s update error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+	return nil
+}
+
+// Scale sets the canary deployment replicas
+func (c *CanaryDeployer) Scale(cd *flaggerv1.Canary, replicas int32) error {
+	canary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(cd.Spec.TargetRef.Name, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("deployment %s.%s not found", cd.Spec.TargetRef.Name, cd.Namespace)
+		}
+		return fmt.Errorf("deployment %s.%s query error %v", cd.Spec.TargetRef.Name, cd.Namespace, err)
+	}
+	canary.Spec.Replicas = int32p(replicas)
+	canary, err = c.kubeClient.AppsV1().Deployments(canary.Namespace).Update(canary)
+	if err != nil {
+		return fmt.Errorf("scaling %s.%s to %v failed: %v", canary.GetName(), canary.Namespace, replicas, err)
+	}
+	return nil
+}
+
+// Sync creates the primary deployment and hpa
+// and scales to zero the canary deployment
+func (c *CanaryDeployer) Sync(cd *flaggerv1.Canary) error {
+	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
+	if err := c.createPrimaryDeployment(cd); err != nil {
+		return fmt.Errorf("creating deployment %s.%s failed: %v", primaryName, cd.Namespace, err)
+	}
+
+	if cd.Status.State == "" {
+		c.logger.Infof("Scaling down %s.%s", cd.Spec.TargetRef.Name, cd.Namespace)
+		if err := c.Scale(cd, 0); err != nil {
+			return err
+		}
+	}
+
+	if cd.Spec.AutoscalerRef.Kind == "HorizontalPodAutoscaler" {
+		if err := c.createPrimaryHpa(cd); err != nil {
+			return fmt.Errorf("creating hpa %s.%s failed: %v", primaryName, cd.Namespace, err)
+		}
+	}
+	return nil
+}
+
+func (c *CanaryDeployer) createPrimaryDeployment(cd *flaggerv1.Canary) error {
+	canaryName := cd.Spec.TargetRef.Name
+	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
+
+	canaryDep, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(canaryName, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("deployment %s.%s not found, retrying", canaryName, cd.Namespace)
+		}
+		return err
+	}
+
+	primaryDep, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(primaryName, metav1.GetOptions{})
+	if errors.IsNotFound(err) {
+		primaryDep = &appsv1.Deployment{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:        primaryName,
+				Annotations: canaryDep.Annotations,
+				Namespace:   cd.Namespace,
+				OwnerReferences: []metav1.OwnerReference{
+					*metav1.NewControllerRef(cd, schema.GroupVersionKind{
+						Group:   flaggerv1.SchemeGroupVersion.Group,
+						Version: flaggerv1.SchemeGroupVersion.Version,
+						Kind:    flaggerv1.CanaryKind,
+					}),
+				},
+			},
+			Spec: appsv1.DeploymentSpec{
+				MinReadySeconds:      canaryDep.Spec.MinReadySeconds,
+				RevisionHistoryLimit: canaryDep.Spec.RevisionHistoryLimit,
+				Replicas:             canaryDep.Spec.Replicas,
+				Strategy:             canaryDep.Spec.Strategy,
+				Selector: &metav1.LabelSelector{
+					MatchLabels: map[string]string{
+						"app": primaryName,
+					},
+				},
+				Template: corev1.PodTemplateSpec{
+					ObjectMeta: metav1.ObjectMeta{
+						Labels:      map[string]string{"app": primaryName},
+						Annotations: canaryDep.Spec.Template.Annotations,
+					},
+					Spec: canaryDep.Spec.Template.Spec,
+				},
+			},
+		}
+
+		_, err = c.kubeClient.AppsV1().Deployments(cd.Namespace).Create(primaryDep)
+		if err != nil {
+			return err
+		}
+
+		c.logger.Infof("Deployment %s.%s created", primaryDep.GetName(), cd.Namespace)
+	}
+
+	return nil
+}
+
+func (c *CanaryDeployer) createPrimaryHpa(cd *flaggerv1.Canary) error {
+	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
+	hpa, err := c.kubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Get(cd.Spec.AutoscalerRef.Name, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("HorizontalPodAutoscaler %s.%s not found, retrying",
+				cd.Spec.AutoscalerRef.Name, cd.Namespace)
+		}
+		return err
+	}
+	primaryHpaName := fmt.Sprintf("%s-primary", cd.Spec.AutoscalerRef.Name)
+	primaryHpa, err := c.kubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Get(primaryHpaName, metav1.GetOptions{})
+
+	if errors.IsNotFound(err) {
+		primaryHpa = &hpav1.HorizontalPodAutoscaler{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      primaryHpaName,
+				Namespace: cd.Namespace,
+				OwnerReferences: []metav1.OwnerReference{
+					*metav1.NewControllerRef(cd, schema.GroupVersionKind{
+						Group:   flaggerv1.SchemeGroupVersion.Group,
+						Version: flaggerv1.SchemeGroupVersion.Version,
+						Kind:    flaggerv1.CanaryKind,
+					}),
+				},
+			},
+			Spec: hpav1.HorizontalPodAutoscalerSpec{
+				ScaleTargetRef: hpav1.CrossVersionObjectReference{
+					Name:       primaryName,
+					Kind:       hpa.Spec.ScaleTargetRef.Kind,
+					APIVersion: hpa.Spec.ScaleTargetRef.APIVersion,
+				},
+				MinReplicas: hpa.Spec.MinReplicas,
+				MaxReplicas: hpa.Spec.MaxReplicas,
+				Metrics:     hpa.Spec.Metrics,
+			},
+		}
+
+		_, err = c.kubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Create(primaryHpa)
+		if err != nil {
+			return err
+		}
+		c.logger.Infof("HorizontalPodAutoscaler %s.%s created", primaryHpa.GetName(), cd.Namespace)
+	}
+
+	return nil
+}
+
+func (c *CanaryDeployer) getDeploymentStatus(deployment *appsv1.Deployment) (string, bool) {
+	if deployment.Generation <= deployment.Status.ObservedGeneration {
+		cond := c.getDeploymentCondition(deployment.Status, appsv1.DeploymentProgressing)
+		if cond != nil && cond.Reason == "ProgressDeadlineExceeded" {
+			return fmt.Sprintf("deployment %q exceeded its progress deadline", deployment.GetName()), false
+		} else if deployment.Spec.Replicas != nil && deployment.Status.UpdatedReplicas < *deployment.Spec.Replicas {
+			return fmt.Sprintf("waiting for rollout to finish: %d out of %d new replicas have been updated",
+				deployment.Status.UpdatedReplicas, *deployment.Spec.Replicas), false
+		} else if deployment.Status.Replicas > deployment.Status.UpdatedReplicas {
+			return fmt.Sprintf("waiting for rollout to finish: %d old replicas are pending termination",
+				deployment.Status.Replicas-deployment.Status.UpdatedReplicas), false
+		} else if deployment.Status.AvailableReplicas < deployment.Status.UpdatedReplicas {
+			return fmt.Sprintf("waiting for rollout to finish: %d of %d updated replicas are available",
+				deployment.Status.AvailableReplicas, deployment.Status.UpdatedReplicas), false
+		}
+	} else {
+		return "waiting for rollout to finish: observed deployment generation less then desired generation", false
+	}
+
+	return "ready", true
+}
+
+func (c *CanaryDeployer) getDeploymentCondition(
+	status appsv1.DeploymentStatus,
+	conditionType appsv1.DeploymentConditionType,
+) *appsv1.DeploymentCondition {
+	for i := range status.Conditions {
+		c := status.Conditions[i]
+		if c.Type == conditionType {
+			return &c
+		}
+	}
+	return nil
+}

pkg/controller/deployer_test.go

@@ -0,0 +1,476 @@
+package controller
+
+import (
+	"testing"
+
+	"github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
+	fakeFlagger "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/fake"
+	"github.com/stefanprodan/flagger/pkg/logging"
+	appsv1 "k8s.io/api/apps/v1"
+	hpav1 "k8s.io/api/autoscaling/v1"
+	hpav2 "k8s.io/api/autoscaling/v2beta1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes/fake"
+)
+
+func newTestCanary() *v1alpha1.Canary {
+	cd := &v1alpha1.Canary{
+		TypeMeta: metav1.TypeMeta{APIVersion: v1alpha1.SchemeGroupVersion.String()},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "podinfo",
+		},
+		Spec: v1alpha1.CanarySpec{
+			TargetRef: hpav1.CrossVersionObjectReference{
+				Name:       "podinfo",
+				APIVersion: "apps/v1",
+				Kind:       "Deployment",
+			},
+			AutoscalerRef: hpav1.CrossVersionObjectReference{
+				Name:       "podinfo",
+				APIVersion: "autoscaling/v2beta1",
+				Kind:       "HorizontalPodAutoscaler",
+			}, Service: v1alpha1.CanaryService{
+				Port: 9898,
+			}, CanaryAnalysis: v1alpha1.CanaryAnalysis{
+				Threshold:  10,
+				StepWeight: 10,
+				MaxWeight:  50,
+				Metrics: []v1alpha1.CanaryMetric{
+					{
+						Name:      "istio_requests_total",
+						Threshold: 99,
+						Interval:  "1m",
+					},
+					{
+						Name:      "istio_request_duration_seconds_bucket",
+						Threshold: 500,
+						Interval:  "1m",
+					},
+				},
+			},
+		},
+	}
+	return cd
+}
+
+func newTestDeployment() *appsv1.Deployment {
+	d := &appsv1.Deployment{
+		TypeMeta: metav1.TypeMeta{APIVersion: appsv1.SchemeGroupVersion.String()},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "podinfo",
+		},
+		Spec: appsv1.DeploymentSpec{
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{
+					"app": "podinfo",
+				},
+			},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"app": "podinfo",
+					},
+				},
+				Spec: corev1.PodSpec{
+					Containers: []corev1.Container{
+						{
+							Name:  "podinfo",
+							Image: "quay.io/stefanprodan/podinfo:1.2.0",
+							Ports: []corev1.ContainerPort{
+								{
+									Name:          "http",
+									ContainerPort: 9898,
+									Protocol:      corev1.ProtocolTCP,
+								},
+							},
+							Command: []string{
+								"./podinfo",
+								"--port=9898",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	return d
+}
+
+func newTestDeploymentUpdated() *appsv1.Deployment {
+	d := &appsv1.Deployment{
+		TypeMeta: metav1.TypeMeta{APIVersion: appsv1.SchemeGroupVersion.String()},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "podinfo",
+		},
+		Spec: appsv1.DeploymentSpec{
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{
+					"app": "podinfo",
+				},
+			},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"app": "podinfo",
+					},
+				},
+				Spec: corev1.PodSpec{
+					Containers: []corev1.Container{
+						{
+							Name:  "podinfo",
+							Image: "quay.io/stefanprodan/podinfo:1.2.1",
+							Ports: []corev1.ContainerPort{
+								{
+									Name:          "http",
+									ContainerPort: 9898,
+									Protocol:      corev1.ProtocolTCP,
+								},
+							},
+							Command: []string{
+								"./podinfo",
+								"--port=9898",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	return d
+}
+
+func newTestHPA() *hpav2.HorizontalPodAutoscaler {
+	h := &hpav2.HorizontalPodAutoscaler{
+		TypeMeta: metav1.TypeMeta{APIVersion: hpav2.SchemeGroupVersion.String()},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "podinfo",
+		},
+		Spec: hpav2.HorizontalPodAutoscalerSpec{
+			ScaleTargetRef: hpav2.CrossVersionObjectReference{
+				Name:       "podinfo",
+				APIVersion: "apps/v1",
+				Kind:       "Deployment",
+			},
+			Metrics: []hpav2.MetricSpec{
+				{
+					Type: "Resource",
+					Resource: &hpav2.ResourceMetricSource{
+						Name:                     "cpu",
+						TargetAverageUtilization: int32p(99),
+					},
+				},
+			},
+		},
+	}
+
+	return h
+}
+
+func TestCanaryDeployer_Sync(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := &CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+
+	err := deployer.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	depPrimary, err := kubeClient.AppsV1().Deployments("default").Get("podinfo-primary", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	primaryImage := depPrimary.Spec.Template.Spec.Containers[0].Image
+	sourceImage := dep.Spec.Template.Spec.Containers[0].Image
+	if primaryImage != sourceImage {
+		t.Errorf("Got image %s wanted %s", primaryImage, sourceImage)
+	}
+
+	hpaPrimary, err := kubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers("default").Get("podinfo-primary", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if hpaPrimary.Spec.ScaleTargetRef.Name != depPrimary.Name {
+		t.Errorf("Got HPA target %s wanted %s", hpaPrimary.Spec.ScaleTargetRef.Name, depPrimary.Name)
+	}
+}
+
+func TestCanaryDeployer_IsNewSpec(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	dep2 := newTestDeploymentUpdated()
+
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := &CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+
+	err := deployer.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	_, err = kubeClient.AppsV1().Deployments("default").Update(dep2)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	isNew, err := deployer.IsNewSpec(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if !isNew {
+		t.Errorf("Got %v wanted %v", isNew, true)
+	}
+}
+
+func TestCanaryDeployer_Promote(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	dep2 := newTestDeploymentUpdated()
+
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := &CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+
+	err := deployer.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	_, err = kubeClient.AppsV1().Deployments("default").Update(dep2)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	err = deployer.Promote(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	depPrimary, err := kubeClient.AppsV1().Deployments("default").Get("podinfo-primary", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	primaryImage := depPrimary.Spec.Template.Spec.Containers[0].Image
+	sourceImage := dep2.Spec.Template.Spec.Containers[0].Image
+	if primaryImage != sourceImage {
+		t.Errorf("Got image %s wanted %s", primaryImage, sourceImage)
+	}
+}
+
+func TestCanaryDeployer_IsReady(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := &CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+
+	err := deployer.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	err = deployer.IsReady(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+}
+
+func TestCanaryDeployer_SetFailedChecks(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := &CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+
+	err := deployer.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	err = deployer.SetFailedChecks(canary, 1)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	res, err := flaggerClient.FlaggerV1alpha1().Canaries("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if res.Status.FailedChecks != 1 {
+		t.Errorf("Got %v wanted %v", res.Status.FailedChecks, 1)
+	}
+}
+
+func TestCanaryDeployer_SetState(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := &CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+
+	err := deployer.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	err = deployer.SetState(canary, "running")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	res, err := flaggerClient.FlaggerV1alpha1().Canaries("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if res.Status.State != "running" {
+		t.Errorf("Got %v wanted %v", res.Status.State, "running")
+	}
+}
+
+func TestCanaryDeployer_SyncStatus(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := &CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+
+	err := deployer.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	status := v1alpha1.CanaryStatus{
+		State:        "running",
+		FailedChecks: 2,
+	}
+	err = deployer.SyncStatus(canary, status)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	res, err := flaggerClient.FlaggerV1alpha1().Canaries("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if res.Status.State != status.State {
+		t.Errorf("Got state %v wanted %v", res.Status.State, status.State)
+	}
+
+	if res.Status.FailedChecks != status.FailedChecks {
+		t.Errorf("Got failed checks %v wanted %v", res.Status.FailedChecks, status.FailedChecks)
+	}
+}
+
+func TestCanaryDeployer_Scale(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := &CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+
+	err := deployer.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	err = deployer.Scale(canary, 2)
+
+	c, err := kubeClient.AppsV1().Deployments("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if *c.Spec.Replicas != 2 {
+		t.Errorf("Got replicas %v wanted %v", *c.Spec.Replicas, 2)
+	}
+
+}

pkg/controller/deployment.go

@@ -1,433 +0,0 @@
-package controller
-
-import (
-	"fmt"
-	"time"
-
-	istiov1alpha3 "github.com/knative/pkg/apis/istio/v1alpha3"
-	flaggerv1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1beta1"
-	appsv1 "k8s.io/api/apps/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-func (c *Controller) doRollouts() {
-	c.rollouts.Range(func(key interface{}, value interface{}) bool {
-		r := value.(*flaggerv1.Canary)
-		if r.Spec.TargetKind == "Deployment" {
-			go c.advanceDeploymentRollout(r.Name, r.Namespace)
-		}
-		return true
-	})
-}
-
-func (c *Controller) advanceDeploymentRollout(name string, namespace string) {
-	// gate stage: check if the rollout exists
-	r, ok := c.getRollout(name, namespace)
-	if !ok {
-		return
-	}
-
-	// set max weight default value to 100%
-	maxWeight := 100
-	if r.Spec.CanaryAnalysis.MaxWeight > 0 {
-		maxWeight = r.Spec.CanaryAnalysis.MaxWeight
-	}
-
-	// gate stage: check if canary deployment exists and is healthy
-	canary, ok := c.getCanaryDeployment(r, r.Spec.Canary.Name, r.Namespace)
-	if !ok {
-		return
-	}
-
-	// gate stage: check if primary deployment exists and is healthy
-	primary, ok := c.getDeployment(r, r.Spec.Primary.Name, r.Namespace)
-	if !ok {
-		return
-	}
-
-	// gate stage: check if virtual service exists
-	// and if it contains weighted destination routes to the primary and canary services
-	vs, primaryRoute, canaryRoute, ok := c.getVirtualService(r)
-	if !ok {
-		return
-	}
-
-	// gate stage: check if rollout should start (canary revision has changes) or continue
-	if ok := c.checkRolloutStatus(r, canary); !ok {
-		return
-	}
-
-	// gate stage: check if the number of failed checks reached the threshold
-	if r.Status.State == "running" && r.Status.FailedChecks >= r.Spec.CanaryAnalysis.Threshold {
-		c.recordEventWarningf(r, "Rolling back %s.%s failed checks threshold reached %v",
-			r.Spec.Canary.Name, r.Namespace, r.Status.FailedChecks)
-
-		// route all traffic back to primary
-		primaryRoute.Weight = 100
-		canaryRoute.Weight = 0
-		if ok := c.updateVirtualServiceRoutes(r, vs, primaryRoute, canaryRoute); !ok {
-			return
-		}
-
-		c.recordEventWarningf(r, "Canary failed! Scaling down %s.%s",
-			canary.GetName(), canary.Namespace)
-
-		// shutdown canary
-		c.scaleToZeroCanary(r)
-
-		// mark rollout as failed
-		c.updateRolloutStatus(r, "promotion-failed")
-		return
-	}
-
-	// gate stage: check if the canary success rate is above the threshold
-	// skip check if no traffic is routed to canary
-	if canaryRoute.Weight == 0 {
-		c.recordEventInfof(r, "Starting canary deployment for %s.%s", r.Name, r.Namespace)
-	} else {
-		if ok := c.checkDeploymentMetrics(r); !ok {
-			c.updateRolloutFailedChecks(r, r.Status.FailedChecks+1)
-			return
-		}
-	}
-
-	// routing stage: increase canary traffic percentage
-	if canaryRoute.Weight < maxWeight {
-		primaryRoute.Weight -= r.Spec.CanaryAnalysis.StepWeight
-		if primaryRoute.Weight < 0 {
-			primaryRoute.Weight = 0
-		}
-		canaryRoute.Weight += r.Spec.CanaryAnalysis.StepWeight
-		if primaryRoute.Weight > 100 {
-			primaryRoute.Weight = 100
-		}
-
-		if ok := c.updateVirtualServiceRoutes(r, vs, primaryRoute, canaryRoute); !ok {
-			return
-		}
-
-		c.recordEventInfof(r, "Advance %s.%s canary weight %v", r.Name, r.Namespace, canaryRoute.Weight)
-
-		// promotion stage: override primary.template.spec with the canary spec
-		if canaryRoute.Weight == maxWeight {
-			c.recordEventInfof(r, "Copying %s.%s template spec to %s.%s",
-				canary.GetName(), canary.Namespace, primary.GetName(), primary.Namespace)
-
-			primary.Spec.Template.Spec = canary.Spec.Template.Spec
-			_, err := c.kubeClient.AppsV1().Deployments(primary.Namespace).Update(primary)
-			if err != nil {
-				c.recordEventErrorf(r, "Updating template spec %s.%s failed: %v", primary.GetName(), primary.Namespace, err)
-				return
-			}
-		}
-	} else {
-		// final stage: route all traffic back to primary
-		primaryRoute.Weight = 100
-		canaryRoute.Weight = 0
-		if ok := c.updateVirtualServiceRoutes(r, vs, primaryRoute, canaryRoute); !ok {
-			return
-		}
-
-		// final stage: mark rollout as finished and scale canary to zero replicas
-		c.recordEventInfof(r, "Scaling down %s.%s", canary.GetName(), canary.Namespace)
-		c.scaleToZeroCanary(r)
-		c.updateRolloutStatus(r, "promotion-finished")
-	}
-}
-
-func (c *Controller) getRollout(name string, namespace string) (*flaggerv1.Canary, bool) {
-	r, err := c.rolloutClient.FlaggerV1beta1().Canaries(namespace).Get(name, v1.GetOptions{})
-	if err != nil {
-		c.logger.Errorf("Canary %s.%s not found", name, namespace)
-		return nil, false
-	}
-
-	return r, true
-}
-
-func (c *Controller) checkRolloutStatus(r *flaggerv1.Canary, canary *appsv1.Deployment) bool {
-	var err error
-	if r.Status.State == "" {
-		r.Status = flaggerv1.CanaryStatus{
-			State:          "running",
-			CanaryRevision: canary.ResourceVersion,
-			FailedChecks:   0,
-		}
-		r, err = c.rolloutClient.FlaggerV1beta1().Canaries(r.Namespace).Update(r)
-		if err != nil {
-			c.logger.Errorf("Canary %s.%s status update failed: %v", r.Name, r.Namespace, err)
-			return false
-		}
-		return true
-	}
-
-	if r.Status.State == "running" {
-		return true
-	}
-
-	if r.Status.State == "promotion-finished" {
-		c.setCanaryRevision(r, "finished")
-		c.logger.Infof("Promotion completed! %s.%s revision %s", r.Spec.Canary.Name, r.Namespace,
-			c.getDeploymentRevision(r.Spec.Canary.Name, r.Namespace))
-		return false
-	}
-
-	if r.Status.State == "promotion-failed" {
-		c.setCanaryRevision(r, "failed")
-		c.logger.Infof("Promotion failed! %s.%s revision %s", r.Spec.Canary.Name, r.Namespace,
-			c.getDeploymentRevision(r.Spec.Canary.Name, r.Namespace))
-		return false
-	}
-
-	if r.Status.CanaryRevision != canary.ResourceVersion {
-		c.recordEventInfof(r, "New revision detected %s.%s old %s new %s",
-			canary.GetName(), canary.Namespace, r.Status.CanaryRevision, canary.ResourceVersion)
-		canary.Spec.Replicas = int32p(1)
-		canary, err = c.kubeClient.AppsV1().Deployments(canary.Namespace).Update(canary)
-		if err != nil {
-			c.recordEventErrorf(r, "Scaling up %s.%s failed: %v", canary.GetName(), canary.Namespace, err)
-			return false
-		}
-		r.Status = flaggerv1.CanaryStatus{
-			State:          "running",
-			CanaryRevision: canary.ResourceVersion,
-			FailedChecks:   0,
-		}
-		r, err = c.rolloutClient.FlaggerV1beta1().Canaries(r.Namespace).Update(r)
-		if err != nil {
-			c.logger.Errorf("Canary %s.%s status update failed: %v", r.Name, r.Namespace, err)
-			return false
-		}
-		c.recordEventInfof(r, "Scaling up %s.%s", canary.GetName(), canary.Namespace)
-
-		return false
-	}
-
-	return false
-}
-
-func (c *Controller) updateRolloutStatus(r *flaggerv1.Canary, status string) bool {
-	var err error
-	r.Status.State = status
-	r, err = c.rolloutClient.FlaggerV1beta1().Canaries(r.Namespace).Update(r)
-	if err != nil {
-		c.logger.Errorf("Canary %s.%s status update failed: %v", r.Name, r.Namespace, err)
-		return false
-	}
-	return true
-}
-
-func (c *Controller) updateRolloutFailedChecks(r *flaggerv1.Canary, val int) bool {
-	var err error
-	r.Status.FailedChecks = val
-	r, err = c.rolloutClient.FlaggerV1beta1().Canaries(r.Namespace).Update(r)
-	if err != nil {
-		c.logger.Errorf("Canary %s.%s status update failed: %v", r.Name, r.Namespace, err)
-		return false
-	}
-	return true
-}
-
-func (c *Controller) getDeployment(r *flaggerv1.Canary, name string, namespace string) (*appsv1.Deployment, bool) {
-	dep, err := c.kubeClient.AppsV1().Deployments(namespace).Get(name, v1.GetOptions{})
-	if err != nil {
-		c.recordEventErrorf(r, "Deployment %s.%s not found", name, namespace)
-		return nil, false
-	}
-
-	if msg, healthy := getDeploymentStatus(dep); !healthy {
-		c.recordEventWarningf(r, "Halt %s.%s advancement %s", dep.GetName(), dep.Namespace, msg)
-		return nil, false
-	}
-
-	if dep.Spec.Replicas == nil || *dep.Spec.Replicas == 0 {
-		return nil, false
-	}
-
-	return dep, true
-}
-
-func (c *Controller) getCanaryDeployment(r *flaggerv1.Canary, name string, namespace string) (*appsv1.Deployment, bool) {
-	dep, err := c.kubeClient.AppsV1().Deployments(namespace).Get(name, v1.GetOptions{})
-	if err != nil {
-		c.recordEventErrorf(r, "Deployment %s.%s not found", name, namespace)
-		return nil, false
-	}
-
-	if msg, healthy := getDeploymentStatus(dep); !healthy {
-		c.recordEventWarningf(r, "Halt %s.%s advancement %s", dep.GetName(), dep.Namespace, msg)
-		return nil, false
-	}
-
-	return dep, true
-}
-
-func (c *Controller) getDeploymentRevision(name string, namespace string) string {
-	dep, err := c.kubeClient.AppsV1().Deployments(namespace).Get(name, v1.GetOptions{})
-	if err != nil {
-		c.logger.Errorf("Deployment %s.%s not found", name, namespace)
-		return ""
-	}
-
-	return dep.ResourceVersion
-}
-
-func (c *Controller) checkDeploymentMetrics(r *flaggerv1.Canary) bool {
-	for _, metric := range r.Spec.CanaryAnalysis.Metrics {
-		if metric.Name == "istio_requests_total" {
-			val, err := c.getDeploymentCounter(r.Spec.Canary.Name, r.Namespace, metric.Name, metric.Interval)
-			if err != nil {
-				c.recordEventErrorf(r, "Metrics server %s query failed: %v", c.metricsServer, err)
-				return false
-			}
-			if float64(metric.Threshold) > val {
-				c.recordEventWarningf(r, "Halt %s.%s advancement success rate %.2f%% < %v%%",
-					r.Name, r.Namespace, val, metric.Threshold)
-				return false
-			}
-		}
-
-		if metric.Name == "istio_request_duration_seconds_bucket" {
-			val, err := c.GetDeploymentHistogram(r.Spec.Canary.Name, r.Namespace, metric.Name, metric.Interval)
-			if err != nil {
-				c.recordEventErrorf(r, "Metrics server %s query failed: %v", c.metricsServer, err)
-				return false
-			}
-			t := time.Duration(metric.Threshold) * time.Millisecond
-			if val > t {
-				c.recordEventWarningf(r, "Halt %s.%s advancement request duration %v > %v",
-					r.Name, r.Namespace, val, t)
-				return false
-			}
-		}
-	}
-
-	return true
-}
-
-func (c *Controller) scaleToZeroCanary(r *flaggerv1.Canary) {
-	canary, err := c.kubeClient.AppsV1().Deployments(r.Namespace).Get(r.Spec.Canary.Name, v1.GetOptions{})
-	if err != nil {
-		c.recordEventErrorf(r, "Deployment %s.%s not found", r.Spec.Canary.Name, r.Namespace)
-		return
-	}
-	//HPA https://github.com/kubernetes/kubernetes/pull/29212
-	canary.Spec.Replicas = int32p(0)
-	canary, err = c.kubeClient.AppsV1().Deployments(canary.Namespace).Update(canary)
-	if err != nil {
-		c.recordEventErrorf(r, "Scaling down %s.%s failed: %v", canary.GetName(), canary.Namespace, err)
-		return
-	}
-}
-
-func (c *Controller) setCanaryRevision(r *flaggerv1.Canary, status string) {
-	canaryRevision := c.getDeploymentRevision(r.Spec.Canary.Name, r.Namespace)
-	r, ok := c.getRollout(r.Name, r.Namespace)
-	if !ok {
-		return
-	}
-	r.Status = flaggerv1.CanaryStatus{
-		State:          status,
-		CanaryRevision: canaryRevision,
-		FailedChecks:   r.Status.FailedChecks,
-	}
-	r, err := c.rolloutClient.FlaggerV1beta1().Canaries(r.Namespace).Update(r)
-	if err != nil {
-		c.logger.Errorf("Canary %s.%s status update failed: %v", r.Name, r.Namespace, err)
-	}
-	//c.logger.Infof("Canary %s.%s status %+v", r.Spec.Canary.Name, r.Namespace, r.Status)
-}
-
-func (c *Controller) getVirtualService(r *flaggerv1.Canary) (
-	vs *istiov1alpha3.VirtualService,
-	primary istiov1alpha3.DestinationWeight,
-	canary istiov1alpha3.DestinationWeight,
-	ok bool,
-) {
-	var err error
-	vs, err = c.istioClient.NetworkingV1alpha3().VirtualServices(r.Namespace).Get(r.Spec.VirtualService.Name, v1.GetOptions{})
-	if err != nil {
-		c.recordEventErrorf(r, "VirtualService %s.%s not found", r.Spec.VirtualService.Name, r.Namespace)
-		return
-	}
-
-	for _, http := range vs.Spec.Http {
-		for _, route := range http.Route {
-			if route.Destination.Host == r.Spec.Primary.Host {
-				primary = route
-			}
-			if route.Destination.Host == r.Spec.Canary.Host {
-				canary = route
-			}
-		}
-	}
-
-	if primary.Weight == 0 && canary.Weight == 0 {
-		c.recordEventErrorf(r, "VirtualService %s.%s does not contain routes for %s and %s",
-			r.Spec.VirtualService.Name, r.Namespace, r.Spec.Primary.Host, r.Spec.Canary.Host)
-		return
-	}
-
-	ok = true
-	return
-}
-
-func (c *Controller) updateVirtualServiceRoutes(
-	r *flaggerv1.Canary,
-	vs *istiov1alpha3.VirtualService,
-	primary istiov1alpha3.DestinationWeight,
-	canary istiov1alpha3.DestinationWeight,
-) bool {
-	vs.Spec.Http = []istiov1alpha3.HTTPRoute{
-		{
-			Route: []istiov1alpha3.DestinationWeight{primary, canary},
-		},
-	}
-
-	var err error
-	vs, err = c.istioClient.NetworkingV1alpha3().VirtualServices(r.Namespace).Update(vs)
-	if err != nil {
-		c.recordEventErrorf(r, "VirtualService %s.%s update failed: %v", r.Spec.VirtualService.Name, r.Namespace, err)
-		return false
-	}
-	return true
-}
-
-func getDeploymentStatus(deployment *appsv1.Deployment) (string, bool) {
-	if deployment.Generation <= deployment.Status.ObservedGeneration {
-		cond := getDeploymentCondition(deployment.Status, appsv1.DeploymentProgressing)
-		if cond != nil && cond.Reason == "ProgressDeadlineExceeded" {
-			return fmt.Sprintf("deployment %q exceeded its progress deadline", deployment.GetName()), false
-		} else if deployment.Spec.Replicas != nil && deployment.Status.UpdatedReplicas < *deployment.Spec.Replicas {
-			return fmt.Sprintf("waiting for rollout to finish: %d out of %d new replicas have been updated",
-				deployment.Status.UpdatedReplicas, *deployment.Spec.Replicas), false
-		} else if deployment.Status.Replicas > deployment.Status.UpdatedReplicas {
-			return fmt.Sprintf("waiting for rollout to finish: %d old replicas are pending termination",
-				deployment.Status.Replicas-deployment.Status.UpdatedReplicas), false
-		} else if deployment.Status.AvailableReplicas < deployment.Status.UpdatedReplicas {
-			return fmt.Sprintf("waiting for rollout to finish: %d of %d updated replicas are available",
-				deployment.Status.AvailableReplicas, deployment.Status.UpdatedReplicas), false
-		}
-	} else {
-		return "waiting for rollout to finish: observed deployment generation less then desired generation", false
-	}
-
-	return "ready", true
-}
-
-func getDeploymentCondition(
-	status appsv1.DeploymentStatus,
-	conditionType appsv1.DeploymentConditionType,
-) *appsv1.DeploymentCondition {
-	for i := range status.Conditions {
-		c := status.Conditions[i]
-		if c.Type == conditionType {
-			return &c
-		}
-	}
-	return nil
-}
-
-func int32p(i int32) *int32 {
-	return &i
-}

pkg/controller/observer.go

@@ -11,7 +11,12 @@ import (
 	"time"
 )
 
-type VectorQueryResponse struct {
+// CanaryObserver is used to query the Istio Prometheus db
+type CanaryObserver struct {
+	metricsServer string
+}
+
+type vectorQueryResponse struct {
 	Data struct {
 		Result []struct {
 			Metric struct {
@@ -23,7 +28,7 @@ type VectorQueryResponse struct {
 	}
 }
 
-func (c *Controller) queryMetric(query string) (*VectorQueryResponse, error) {
+func (c *CanaryObserver) queryMetric(query string) (*vectorQueryResponse, error) {
 	promURL, err := url.Parse(c.metricsServer)
 	if err != nil {
 		return nil, err
@@ -59,7 +64,7 @@ func (c *Controller) queryMetric(query string) (*VectorQueryResponse, error) {
 		return nil, fmt.Errorf("error response: %s", string(b))
 	}
 
-	var values VectorQueryResponse
+	var values vectorQueryResponse
 	err = json.Unmarshal(b, &values)
 	if err != nil {
 		return nil, fmt.Errorf("error unmarshaling result: %s, '%s'", err.Error(), string(b))
@@ -68,8 +73,12 @@ func (c *Controller) queryMetric(query string) (*VectorQueryResponse, error) {
 	return &values, nil
 }
 
-// istio_requests_total
-func (c *Controller) getDeploymentCounter(name string, namespace string, metric string, interval string) (float64, error) {
+// GetDeploymentCounter returns the requests success rate using istio_requests_total metric
+func (c *CanaryObserver) GetDeploymentCounter(name string, namespace string, metric string, interval string) (float64, error) {
+	if c.metricsServer == "fake" {
+		return 100, nil
+	}
+
 	var rate *float64
 	querySt := url.QueryEscape(`sum(rate(` +
 		metric + `{reporter="destination",destination_workload_namespace=~"` +
@@ -101,8 +110,11 @@ func (c *Controller) getDeploymentCounter(name string, namespace string, metric
 	return *rate, nil
 }
 
-// istio_request_duration_seconds_bucket
-func (c *Controller) GetDeploymentHistogram(name string, namespace string, metric string, interval string) (time.Duration, error) {
+// GetDeploymentHistogram returns the 99P requests delay using istio_request_duration_seconds_bucket metrics
+func (c *CanaryObserver) GetDeploymentHistogram(name string, namespace string, metric string, interval string) (time.Duration, error) {
+	if c.metricsServer == "fake" {
+		return 1, nil
+	}
 	var rate *float64
 	querySt := url.QueryEscape(`histogram_quantile(0.99, sum(rate(` +
 		metric + `{reporter="destination",destination_workload=~"` +
@@ -132,6 +144,8 @@ func (c *Controller) GetDeploymentHistogram(name string, namespace string, metri
 	return ms, nil
 }
 
+// CheckMetricsServer call Prometheus status endpoint and returns an error if
+// the API is unreachable
 func CheckMetricsServer(address string) (bool, error) {
 	promURL, err := url.Parse(address)
 	if err != nil {

pkg/controller/recorder.go

@@ -0,0 +1,90 @@
+package controller
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	flaggerv1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
+)
+
+// CanaryRecorder records the canary analysis as Prometheus metrics
+type CanaryRecorder struct {
+	duration *prometheus.HistogramVec
+	total    *prometheus.GaugeVec
+	status   *prometheus.GaugeVec
+	weight   *prometheus.GaugeVec
+}
+
+// NewCanaryRecorder creates a new recorder and registers the Prometheus metrics
+func NewCanaryRecorder(register bool) CanaryRecorder {
+	duration := prometheus.NewHistogramVec(prometheus.HistogramOpts{
+		Subsystem: controllerAgentName,
+		Name:      "canary_duration_seconds",
+		Help:      "Seconds spent performing canary analysis.",
+		Buckets:   prometheus.DefBuckets,
+	}, []string{"name", "namespace"})
+
+	total := prometheus.NewGaugeVec(prometheus.GaugeOpts{
+		Subsystem: controllerAgentName,
+		Name:      "canary_total",
+		Help:      "Total number of canary object",
+	}, []string{"namespace"})
+
+	// 0 - running, 1 - successful, 2 - failed
+	status := prometheus.NewGaugeVec(prometheus.GaugeOpts{
+		Subsystem: controllerAgentName,
+		Name:      "canary_status",
+		Help:      "Last canary analysis result",
+	}, []string{"name", "namespace"})
+
+	weight := prometheus.NewGaugeVec(prometheus.GaugeOpts{
+		Subsystem: controllerAgentName,
+		Name:      "canary_weight",
+		Help:      "The virtual service destination weight current value",
+	}, []string{"workload", "namespace"})
+
+	if register {
+		prometheus.MustRegister(duration)
+		prometheus.MustRegister(total)
+		prometheus.MustRegister(status)
+		prometheus.MustRegister(weight)
+	}
+
+	return CanaryRecorder{
+		duration: duration,
+		total:    total,
+		status:   status,
+		weight:   weight,
+	}
+}
+
+// SetDuration sets the time spent in seconds performing canary analysis
+func (cr *CanaryRecorder) SetDuration(cd *flaggerv1.Canary, duration time.Duration) {
+	cr.duration.WithLabelValues(cd.Spec.TargetRef.Name, cd.Namespace).Observe(duration.Seconds())
+}
+
+// SetTotal sets the total number of canaries per namespace
+func (cr *CanaryRecorder) SetTotal(namespace string, total int) {
+	cr.total.WithLabelValues(namespace).Set(float64(total))
+}
+
+// SetStatus sets the last known canary analysis status
+func (cr *CanaryRecorder) SetStatus(cd *flaggerv1.Canary) {
+	status := 1
+	switch cd.Status.State {
+	case "running":
+		status = 0
+	case "failed":
+		status = 2
+	default:
+		status = 1
+	}
+	cr.status.WithLabelValues(cd.Spec.TargetRef.Name, cd.Namespace).Set(float64(status))
+}
+
+// SetWeight sets the weight values for primary and canary destinations
+func (cr *CanaryRecorder) SetWeight(cd *flaggerv1.Canary, primary int, canary int) {
+	cr.weight.WithLabelValues(fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name), cd.Namespace).Set(float64(primary))
+	cr.weight.WithLabelValues(cd.Spec.TargetRef.Name, cd.Namespace).Set(float64(canary))
+}

pkg/controller/router.go

@@ -0,0 +1,287 @@
+package controller
+
+import (
+	"fmt"
+
+	istiov1alpha3 "github.com/knative/pkg/apis/istio/v1alpha3"
+	istioclientset "github.com/knative/pkg/client/clientset/versioned"
+	flaggerv1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
+	clientset "github.com/stefanprodan/flagger/pkg/client/clientset/versioned"
+	"go.uber.org/zap"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/apis/meta/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/intstr"
+	"k8s.io/client-go/kubernetes"
+)
+
+// CanaryRouter is managing the operations for Kubernetes service kind
+// and Istio virtual services
+type CanaryRouter struct {
+	kubeClient    kubernetes.Interface
+	istioClient   istioclientset.Interface
+	flaggerClient clientset.Interface
+	logger        *zap.SugaredLogger
+}
+
+// Sync creates the primary and canary ClusterIP services
+// and sets up a virtual service with routes for the two services
+// all traffic goes to primary
+func (c *CanaryRouter) Sync(cd *flaggerv1.Canary) error {
+	err := c.createServices(cd)
+	if err != nil {
+		return err
+	}
+	err = c.createVirtualService(cd)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *CanaryRouter) createServices(cd *flaggerv1.Canary) error {
+	canaryName := cd.Spec.TargetRef.Name
+	primaryName := fmt.Sprintf("%s-primary", canaryName)
+	canaryService, err := c.kubeClient.CoreV1().Services(cd.Namespace).Get(canaryName, metav1.GetOptions{})
+	if errors.IsNotFound(err) {
+		canaryService = &corev1.Service{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      canaryName,
+				Namespace: cd.Namespace,
+				OwnerReferences: []metav1.OwnerReference{
+					*metav1.NewControllerRef(cd, schema.GroupVersionKind{
+						Group:   flaggerv1.SchemeGroupVersion.Group,
+						Version: flaggerv1.SchemeGroupVersion.Version,
+						Kind:    flaggerv1.CanaryKind,
+					}),
+				},
+			},
+			Spec: corev1.ServiceSpec{
+				Type:     corev1.ServiceTypeClusterIP,
+				Selector: map[string]string{"app": canaryName},
+				Ports: []corev1.ServicePort{
+					{
+						Name:     "http",
+						Protocol: corev1.ProtocolTCP,
+						Port:     cd.Spec.Service.Port,
+						TargetPort: intstr.IntOrString{
+							Type:   intstr.Int,
+							IntVal: cd.Spec.Service.Port,
+						},
+					},
+				},
+			},
+		}
+
+		_, err = c.kubeClient.CoreV1().Services(cd.Namespace).Create(canaryService)
+		if err != nil {
+			return err
+		}
+		c.logger.Infof("Service %s.%s created", canaryService.GetName(), cd.Namespace)
+	}
+
+	canaryTestServiceName := fmt.Sprintf("%s-canary", cd.Spec.TargetRef.Name)
+	canaryTestService, err := c.kubeClient.CoreV1().Services(cd.Namespace).Get(canaryTestServiceName, metav1.GetOptions{})
+	if errors.IsNotFound(err) {
+		canaryTestService = &corev1.Service{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      canaryTestServiceName,
+				Namespace: cd.Namespace,
+				OwnerReferences: []metav1.OwnerReference{
+					*metav1.NewControllerRef(cd, schema.GroupVersionKind{
+						Group:   flaggerv1.SchemeGroupVersion.Group,
+						Version: flaggerv1.SchemeGroupVersion.Version,
+						Kind:    flaggerv1.CanaryKind,
+					}),
+				},
+			},
+			Spec: corev1.ServiceSpec{
+				Type:     corev1.ServiceTypeClusterIP,
+				Selector: map[string]string{"app": canaryName},
+				Ports: []corev1.ServicePort{
+					{
+						Name:     "http",
+						Protocol: corev1.ProtocolTCP,
+						Port:     cd.Spec.Service.Port,
+						TargetPort: intstr.IntOrString{
+							Type:   intstr.Int,
+							IntVal: cd.Spec.Service.Port,
+						},
+					},
+				},
+			},
+		}
+
+		_, err = c.kubeClient.CoreV1().Services(cd.Namespace).Create(canaryTestService)
+		if err != nil {
+			return err
+		}
+		c.logger.Infof("Service %s.%s created", canaryTestService.GetName(), cd.Namespace)
+	}
+
+	primaryService, err := c.kubeClient.CoreV1().Services(cd.Namespace).Get(primaryName, metav1.GetOptions{})
+	if errors.IsNotFound(err) {
+		primaryService = &corev1.Service{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      primaryName,
+				Namespace: cd.Namespace,
+				OwnerReferences: []metav1.OwnerReference{
+					*metav1.NewControllerRef(cd, schema.GroupVersionKind{
+						Group:   flaggerv1.SchemeGroupVersion.Group,
+						Version: flaggerv1.SchemeGroupVersion.Version,
+						Kind:    flaggerv1.CanaryKind,
+					}),
+				},
+			},
+			Spec: corev1.ServiceSpec{
+				Type:     corev1.ServiceTypeClusterIP,
+				Selector: map[string]string{"app": primaryName},
+				Ports: []corev1.ServicePort{
+					{
+						Name:     "http",
+						Protocol: corev1.ProtocolTCP,
+						Port:     cd.Spec.Service.Port,
+						TargetPort: intstr.IntOrString{
+							Type:   intstr.Int,
+							IntVal: cd.Spec.Service.Port,
+						},
+					},
+				},
+			},
+		}
+
+		_, err = c.kubeClient.CoreV1().Services(cd.Namespace).Create(primaryService)
+		if err != nil {
+			return err
+		}
+
+		c.logger.Infof("Service %s.%s created", primaryService.GetName(), cd.Namespace)
+	}
+
+	return nil
+}
+
+func (c *CanaryRouter) createVirtualService(cd *flaggerv1.Canary) error {
+	canaryName := cd.Spec.TargetRef.Name
+	primaryName := fmt.Sprintf("%s-primary", canaryName)
+	hosts := append(cd.Spec.Service.Hosts, canaryName)
+	gateways := append(cd.Spec.Service.Gateways, "mesh")
+	virtualService, err := c.istioClient.NetworkingV1alpha3().VirtualServices(cd.Namespace).Get(canaryName, metav1.GetOptions{})
+	if errors.IsNotFound(err) {
+		virtualService = &istiov1alpha3.VirtualService{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      cd.Name,
+				Namespace: cd.Namespace,
+				OwnerReferences: []metav1.OwnerReference{
+					*metav1.NewControllerRef(cd, schema.GroupVersionKind{
+						Group:   flaggerv1.SchemeGroupVersion.Group,
+						Version: flaggerv1.SchemeGroupVersion.Version,
+						Kind:    flaggerv1.CanaryKind,
+					}),
+				},
+			},
+			Spec: istiov1alpha3.VirtualServiceSpec{
+				Hosts:    hosts,
+				Gateways: gateways,
+				Http: []istiov1alpha3.HTTPRoute{
+					{
+						Route: []istiov1alpha3.DestinationWeight{
+							{
+								Destination: istiov1alpha3.Destination{
+									Host: primaryName,
+									Port: istiov1alpha3.PortSelector{
+										Number: uint32(cd.Spec.Service.Port),
+									},
+								},
+								Weight: 100,
+							},
+							{
+								Destination: istiov1alpha3.Destination{
+									Host: canaryName,
+									Port: istiov1alpha3.PortSelector{
+										Number: uint32(cd.Spec.Service.Port),
+									},
+								},
+								Weight: 0,
+							},
+						},
+					},
+				},
+			},
+		}
+
+		_, err = c.istioClient.NetworkingV1alpha3().VirtualServices(cd.Namespace).Create(virtualService)
+		if err != nil {
+			return fmt.Errorf("VirtualService %s.%s create error %v", cd.Name, cd.Namespace, err)
+		}
+		c.logger.Infof("VirtualService %s.%s created", virtualService.GetName(), cd.Namespace)
+	}
+
+	return nil
+}
+
+// GetRoutes returns the destinations weight for primary and canary
+func (c *CanaryRouter) GetRoutes(cd *flaggerv1.Canary) (
+	primary istiov1alpha3.DestinationWeight,
+	canary istiov1alpha3.DestinationWeight,
+	err error,
+) {
+	vs := &istiov1alpha3.VirtualService{}
+	vs, err = c.istioClient.NetworkingV1alpha3().VirtualServices(cd.Namespace).Get(cd.Name, v1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			err = fmt.Errorf("VirtualService %s.%s not found", cd.Name, cd.Namespace)
+			return
+		}
+		err = fmt.Errorf("VirtualService %s.%s query error %v", cd.Name, cd.Namespace, err)
+		return
+	}
+
+	for _, http := range vs.Spec.Http {
+		for _, route := range http.Route {
+			if route.Destination.Host == fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name) {
+				primary = route
+			}
+			if route.Destination.Host == cd.Spec.TargetRef.Name {
+				canary = route
+			}
+		}
+	}
+
+	if primary.Weight == 0 && canary.Weight == 0 {
+		err = fmt.Errorf("VirtualService %s.%s does not contain routes for %s and %s",
+			cd.Name, cd.Namespace, fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name), cd.Spec.TargetRef.Name)
+	}
+
+	return
+}
+
+// SetRoutes updates the destinations weight for primary and canary
+func (c *CanaryRouter) SetRoutes(
+	cd *flaggerv1.Canary,
+	primary istiov1alpha3.DestinationWeight,
+	canary istiov1alpha3.DestinationWeight,
+) error {
+	vs, err := c.istioClient.NetworkingV1alpha3().VirtualServices(cd.Namespace).Get(cd.Name, v1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("VirtualService %s.%s not found", cd.Name, cd.Namespace)
+
+		}
+		return fmt.Errorf("VirtualService %s.%s query error %v", cd.Name, cd.Namespace, err)
+	}
+	vs.Spec.Http = []istiov1alpha3.HTTPRoute{
+		{
+			Route: []istiov1alpha3.DestinationWeight{primary, canary},
+		},
+	}
+
+	vs, err = c.istioClient.NetworkingV1alpha3().VirtualServices(cd.Namespace).Update(vs)
+	if err != nil {
+		return fmt.Errorf("VirtualService %s.%s update failed: %v", cd.Name, cd.Namespace, err)
+
+	}
+	return nil
+}

pkg/controller/router_test.go

@@ -0,0 +1,177 @@
+package controller
+
+import (
+	"fmt"
+	"testing"
+
+	istiov1alpha3 "github.com/knative/pkg/apis/istio/v1alpha3"
+	fakeIstio "github.com/knative/pkg/client/clientset/versioned/fake"
+	fakeFlagger "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/fake"
+	"github.com/stefanprodan/flagger/pkg/logging"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes/fake"
+)
+
+func TestCanaryRouter_Sync(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+	istioClient := fakeIstio.NewSimpleClientset()
+
+	logger, _ := logging.NewLogger("debug")
+
+	router := &CanaryRouter{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		logger:        logger,
+	}
+
+	err := router.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	canarySvc, err := kubeClient.CoreV1().Services("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if canarySvc.Spec.Ports[0].Name != "http" {
+		t.Errorf("Got svc port name %s wanted %s", canarySvc.Spec.Ports[0].Name, "http")
+	}
+
+	if canarySvc.Spec.Ports[0].Port != 9898 {
+		t.Errorf("Got svc port %v wanted %v", canarySvc.Spec.Ports[0].Port, 9898)
+	}
+
+	primarySvc, err := kubeClient.CoreV1().Services("default").Get("podinfo-primary", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if primarySvc.Spec.Ports[0].Name != "http" {
+		t.Errorf("Got primary svc port name %s wanted %s", primarySvc.Spec.Ports[0].Name, "http")
+	}
+
+	if primarySvc.Spec.Ports[0].Port != 9898 {
+		t.Errorf("Got primary svc port %v wanted %v", primarySvc.Spec.Ports[0].Port, 9898)
+	}
+
+	vs, err := istioClient.NetworkingV1alpha3().VirtualServices("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if len(vs.Spec.Http) != 1 {
+		t.Errorf("Got Istio VS Http %v wanted %v", len(vs.Spec.Http), 1)
+	}
+
+	if len(vs.Spec.Http[0].Route) != 2 {
+		t.Errorf("Got Istio VS routes %v wanted %v", len(vs.Spec.Http[0].Route), 2)
+	}
+}
+
+func TestCanaryRouter_GetRoutes(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+	istioClient := fakeIstio.NewSimpleClientset()
+
+	logger, _ := logging.NewLogger("debug")
+
+	router := &CanaryRouter{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		logger:        logger,
+	}
+
+	err := router.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	p, c, err := router.GetRoutes(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if p.Weight != 100 {
+		t.Errorf("Got primary weight %v wanted %v", p.Weight, 100)
+	}
+
+	if c.Weight != 0 {
+		t.Errorf("Got canary weight %v wanted %v", c.Weight, 0)
+	}
+}
+
+func TestCanaryRouter_SetRoutes(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+	istioClient := fakeIstio.NewSimpleClientset()
+
+	logger, _ := logging.NewLogger("debug")
+
+	router := &CanaryRouter{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		logger:        logger,
+	}
+
+	err := router.Sync(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	p, c, err := router.GetRoutes(canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	p.Weight = 50
+	c.Weight = 50
+
+	err = router.SetRoutes(canary, p, c)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	vs, err := istioClient.NetworkingV1alpha3().VirtualServices("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	pRoute := istiov1alpha3.DestinationWeight{}
+	cRoute := istiov1alpha3.DestinationWeight{}
+
+	for _, http := range vs.Spec.Http {
+		for _, route := range http.Route {
+			if route.Destination.Host == fmt.Sprintf("%s-primary", canary.Spec.TargetRef.Name) {
+				pRoute = route
+			}
+			if route.Destination.Host == canary.Spec.TargetRef.Name {
+				cRoute = route
+			}
+		}
+	}
+
+	if pRoute.Weight != p.Weight {
+		t.Errorf("Got primary weight %v wanted %v", pRoute.Weight, c.Weight)
+	}
+
+	if cRoute.Weight != c.Weight {
+		t.Errorf("Got canary weight %v wanted %v", cRoute.Weight, c.Weight)
+	}
+}

pkg/controller/scheduler.go

@@ -0,0 +1,257 @@
+package controller
+
+import (
+	"fmt"
+	"time"
+
+	flaggerv1 "github.com/stefanprodan/flagger/pkg/apis/flagger/v1alpha1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func (c *Controller) scheduleCanaries() {
+	stats := make(map[string]int)
+	c.canaries.Range(func(key interface{}, value interface{}) bool {
+		r := value.(*flaggerv1.Canary)
+		if r.Spec.TargetRef.Kind == "Deployment" {
+			go c.advanceCanary(r.Name, r.Namespace)
+		}
+
+		t, ok := stats[r.Namespace]
+		if !ok {
+			stats[r.Namespace] = 1
+		} else {
+			stats[r.Namespace] = t + 1
+		}
+		return true
+	})
+	for k, v := range stats {
+		c.recorder.SetTotal(k, v)
+	}
+}
+
+func (c *Controller) advanceCanary(name string, namespace string) {
+	begin := time.Now()
+	// check if the canary exists
+	cd, err := c.flaggerClient.FlaggerV1alpha1().Canaries(namespace).Get(name, v1.GetOptions{})
+	if err != nil {
+		c.logger.Errorf("Canary %s.%s not found", name, namespace)
+		return
+	}
+
+	// create primary deployment and hpa if needed
+	if err := c.deployer.Sync(cd); err != nil {
+		c.recordEventWarningf(cd, "%v", err)
+		return
+	}
+
+	// create ClusterIP services and virtual service if needed
+	if err := c.router.Sync(cd); err != nil {
+		c.recordEventWarningf(cd, "%v", err)
+		return
+	}
+
+	// set max weight default value to 100%
+	maxWeight := 100
+	if cd.Spec.CanaryAnalysis.MaxWeight > 0 {
+		maxWeight = cd.Spec.CanaryAnalysis.MaxWeight
+	}
+
+	// check primary and canary deployments status
+	if err := c.deployer.IsReady(cd); err != nil {
+		c.recordEventWarningf(cd, "%v", err)
+		return
+	}
+
+	// check if virtual service exists
+	// and if it contains weighted destination routes to the primary and canary services
+	primaryRoute, canaryRoute, err := c.router.GetRoutes(cd)
+	if err != nil {
+		c.recordEventWarningf(cd, "%v", err)
+		return
+	}
+
+	c.recorder.SetWeight(cd, primaryRoute.Weight, canaryRoute.Weight)
+
+	// check if canary analysis should start (canary revision has changes) or continue
+	if ok := c.checkCanaryStatus(cd, c.deployer); !ok {
+		return
+	}
+
+	defer func() {
+		c.recorder.SetDuration(cd, time.Since(begin))
+	}()
+
+	// check if the number of failed checks reached the threshold
+	if cd.Status.State == "running" && cd.Status.FailedChecks >= cd.Spec.CanaryAnalysis.Threshold {
+		c.recordEventWarningf(cd, "Rolling back %s.%s failed checks threshold reached %v",
+			cd.Name, cd.Namespace, cd.Status.FailedChecks)
+
+		// route all traffic back to primary
+		primaryRoute.Weight = 100
+		canaryRoute.Weight = 0
+		if err := c.router.SetRoutes(cd, primaryRoute, canaryRoute); err != nil {
+			c.recordEventWarningf(cd, "%v", err)
+			return
+		}
+
+		c.recorder.SetWeight(cd, primaryRoute.Weight, canaryRoute.Weight)
+		c.recordEventWarningf(cd, "Canary failed! Scaling down %s.%s",
+			cd.Spec.TargetRef.Name, cd.Namespace)
+
+		// shutdown canary
+		if err := c.deployer.Scale(cd, 0); err != nil {
+			c.recordEventWarningf(cd, "%v", err)
+			return
+		}
+
+		// mark canary as failed
+		if err := c.deployer.SetState(cd, "failed"); err != nil {
+			c.logger.Errorf("%v", err)
+			return
+		}
+		c.recorder.SetStatus(cd)
+		c.sendNotification(cd.Spec.TargetRef.Name, cd.Namespace,
+			"Canary analysis failed, rollback finished.", true)
+		return
+	}
+
+	// check if the canary success rate is above the threshold
+	// skip check if no traffic is routed to canary
+	if canaryRoute.Weight == 0 {
+		c.recordEventInfof(cd, "Starting canary deployment for %s.%s", cd.Name, cd.Namespace)
+	} else {
+		if ok := c.checkCanaryMetrics(cd); !ok {
+			if err := c.deployer.SetFailedChecks(cd, cd.Status.FailedChecks+1); err != nil {
+				c.recordEventWarningf(cd, "%v", err)
+				return
+			}
+			return
+		}
+	}
+
+	// increase canary traffic percentage
+	if canaryRoute.Weight < maxWeight {
+		primaryRoute.Weight -= cd.Spec.CanaryAnalysis.StepWeight
+		if primaryRoute.Weight < 0 {
+			primaryRoute.Weight = 0
+		}
+		canaryRoute.Weight += cd.Spec.CanaryAnalysis.StepWeight
+		if primaryRoute.Weight > 100 {
+			primaryRoute.Weight = 100
+		}
+
+		if err := c.router.SetRoutes(cd, primaryRoute, canaryRoute); err != nil {
+			c.recordEventWarningf(cd, "%v", err)
+			return
+		}
+
+		c.recorder.SetWeight(cd, primaryRoute.Weight, canaryRoute.Weight)
+		c.recordEventInfof(cd, "Advance %s.%s canary weight %v", cd.Name, cd.Namespace, canaryRoute.Weight)
+
+		// promote canary
+		primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
+		if canaryRoute.Weight == maxWeight {
+			c.recordEventInfof(cd, "Copying %s.%s template spec to %s.%s",
+				cd.Spec.TargetRef.Name, cd.Namespace, primaryName, cd.Namespace)
+			if err := c.deployer.Promote(cd); err != nil {
+				c.recordEventWarningf(cd, "%v", err)
+				return
+			}
+		}
+	} else {
+		// route all traffic back to primary
+		primaryRoute.Weight = 100
+		canaryRoute.Weight = 0
+		if err := c.router.SetRoutes(cd, primaryRoute, canaryRoute); err != nil {
+			c.recordEventWarningf(cd, "%v", err)
+			return
+		}
+
+		c.recorder.SetWeight(cd, primaryRoute.Weight, canaryRoute.Weight)
+		c.recordEventInfof(cd, "Promotion completed! Scaling down %s.%s", cd.Spec.TargetRef.Name, cd.Namespace)
+
+		// shutdown canary
+		if err := c.deployer.Scale(cd, 0); err != nil {
+			c.recordEventWarningf(cd, "%v", err)
+			return
+		}
+
+		// update status
+		if err := c.deployer.SetState(cd, "finished"); err != nil {
+			c.recordEventWarningf(cd, "%v", err)
+			return
+		}
+		c.recorder.SetStatus(cd)
+		c.sendNotification(cd.Spec.TargetRef.Name, cd.Namespace,
+			"Canary analysis completed successfully, promotion finished.", false)
+	}
+}
+
+func (c *Controller) checkCanaryStatus(cd *flaggerv1.Canary, deployer CanaryDeployer) bool {
+	c.recorder.SetStatus(cd)
+	if cd.Status.State == "running" {
+		return true
+	}
+
+	if cd.Status.State == "" {
+		if err := deployer.SyncStatus(cd, flaggerv1.CanaryStatus{State: "initialized"}); err != nil {
+			c.logger.Errorf("%v", err)
+			return false
+		}
+		c.recorder.SetStatus(cd)
+		c.recordEventInfof(cd, "Initialization done! %s.%s", cd.Name, cd.Namespace)
+		c.sendNotification(cd.Spec.TargetRef.Name, cd.Namespace,
+			"New deployment detected, initialization completed.", false)
+		return false
+	}
+
+	if diff, err := deployer.IsNewSpec(cd); diff {
+		c.recordEventInfof(cd, "New revision detected! Scaling up %s.%s", cd.Spec.TargetRef.Name, cd.Namespace)
+		c.sendNotification(cd.Spec.TargetRef.Name, cd.Namespace,
+			"New revision detected, starting canary analysis.", false)
+		if err = deployer.Scale(cd, 1); err != nil {
+			c.recordEventErrorf(cd, "%v", err)
+			return false
+		}
+		if err := deployer.SyncStatus(cd, flaggerv1.CanaryStatus{State: "running"}); err != nil {
+			c.logger.Errorf("%v", err)
+			return false
+		}
+		c.recorder.SetStatus(cd)
+		return false
+	}
+	return false
+}
+
+func (c *Controller) checkCanaryMetrics(r *flaggerv1.Canary) bool {
+	for _, metric := range r.Spec.CanaryAnalysis.Metrics {
+		if metric.Name == "istio_requests_total" {
+			val, err := c.observer.GetDeploymentCounter(r.Spec.TargetRef.Name, r.Namespace, metric.Name, metric.Interval)
+			if err != nil {
+				c.recordEventErrorf(r, "Metrics server %s query failed: %v", c.observer.metricsServer, err)
+				return false
+			}
+			if float64(metric.Threshold) > val {
+				c.recordEventWarningf(r, "Halt %s.%s advancement success rate %.2f%% < %v%%",
+					r.Name, r.Namespace, val, metric.Threshold)
+				return false
+			}
+		}
+
+		if metric.Name == "istio_request_duration_seconds_bucket" {
+			val, err := c.observer.GetDeploymentHistogram(r.Spec.TargetRef.Name, r.Namespace, metric.Name, metric.Interval)
+			if err != nil {
+				c.recordEventErrorf(r, "Metrics server %s query failed: %v", c.observer.metricsServer, err)
+				return false
+			}
+			t := time.Duration(metric.Threshold) * time.Millisecond
+			if val > t {
+				c.recordEventWarningf(r, "Halt %s.%s advancement request duration %v > %v",
+					r.Name, r.Namespace, val, t)
+				return false
+			}
+		}
+	}
+
+	return true
+}

pkg/controller/scheduler_test.go

@@ -0,0 +1,144 @@
+package controller
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	fakeIstio "github.com/knative/pkg/client/clientset/versioned/fake"
+	fakeFlagger "github.com/stefanprodan/flagger/pkg/client/clientset/versioned/fake"
+	informers "github.com/stefanprodan/flagger/pkg/client/informers/externalversions"
+	"github.com/stefanprodan/flagger/pkg/logging"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes/fake"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/client-go/util/workqueue"
+)
+
+var (
+	alwaysReady        = func() bool { return true }
+	noResyncPeriodFunc = func() time.Duration { return 0 }
+)
+
+func TestScheduler_Init(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+	istioClient := fakeIstio.NewSimpleClientset()
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+	router := CanaryRouter{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		logger:        logger,
+	}
+	observer := CanaryObserver{
+		metricsServer: "fake",
+	}
+
+	flaggerInformerFactory := informers.NewSharedInformerFactory(flaggerClient, noResyncPeriodFunc())
+	flaggerInformer := flaggerInformerFactory.Flagger().V1alpha1().Canaries()
+
+	ctrl := &Controller{
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		flaggerClient: flaggerClient,
+		flaggerLister: flaggerInformer.Lister(),
+		flaggerSynced: flaggerInformer.Informer().HasSynced,
+		workqueue:     workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerAgentName),
+		eventRecorder: &record.FakeRecorder{},
+		logger:        logger,
+		canaries:      new(sync.Map),
+		flaggerWindow: time.Second,
+		deployer:      deployer,
+		router:        router,
+		observer:      observer,
+		recorder:      NewCanaryRecorder(false),
+	}
+	ctrl.flaggerSynced = alwaysReady
+
+	ctrl.advanceCanary("podinfo", "default")
+
+	_, err := kubeClient.AppsV1().Deployments("default").Get("podinfo-primary", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+}
+
+func TestScheduler_NewRevision(t *testing.T) {
+	canary := newTestCanary()
+	dep := newTestDeployment()
+	hpa := newTestHPA()
+
+	flaggerClient := fakeFlagger.NewSimpleClientset(canary)
+	kubeClient := fake.NewSimpleClientset(dep, hpa)
+	istioClient := fakeIstio.NewSimpleClientset()
+
+	logger, _ := logging.NewLogger("debug")
+	deployer := CanaryDeployer{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+	}
+	router := CanaryRouter{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		logger:        logger,
+	}
+	observer := CanaryObserver{
+		metricsServer: "fake",
+	}
+
+	flaggerInformerFactory := informers.NewSharedInformerFactory(flaggerClient, noResyncPeriodFunc())
+	flaggerInformer := flaggerInformerFactory.Flagger().V1alpha1().Canaries()
+
+	ctrl := &Controller{
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		flaggerClient: flaggerClient,
+		flaggerLister: flaggerInformer.Lister(),
+		flaggerSynced: flaggerInformer.Informer().HasSynced,
+		workqueue:     workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerAgentName),
+		eventRecorder: &record.FakeRecorder{},
+		logger:        logger,
+		canaries:      new(sync.Map),
+		flaggerWindow: time.Second,
+		deployer:      deployer,
+		router:        router,
+		observer:      observer,
+		recorder:      NewCanaryRecorder(false),
+	}
+	ctrl.flaggerSynced = alwaysReady
+
+	// init
+	ctrl.advanceCanary("podinfo", "default")
+
+	// update
+	dep2 := newTestDeploymentUpdated()
+	_, err := kubeClient.AppsV1().Deployments("default").Update(dep2)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	// detect changes
+	ctrl.advanceCanary("podinfo", "default")
+
+	c, err := kubeClient.AppsV1().Deployments("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if *c.Spec.Replicas != 1 {
+		t.Errorf("Got canary replicas %v wanted %v", *c.Spec.Replicas, 1)
+	}
+}

pkg/logging/logger.go

@@ -8,6 +8,7 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
+// NewLogger returns a zap sugared logger configured with json format and caller id
 func NewLogger(logLevel string) (*zap.SugaredLogger, error) {
 	level := zap.NewAtomicLevelAt(zapcore.InfoLevel)
 	switch logLevel {
@@ -59,6 +60,7 @@ func NewLogger(logLevel string) (*zap.SugaredLogger, error) {
 	return logger.Sugar(), nil
 }
 
+// Console writes to stdout if the console env var exists
 func Console(a ...interface{}) (n int, err error) {
 	if os.Getenv("console") != "" {
 		return fmt.Fprintln(os.Stdout, a...)

pkg/notifier/slack.go

@@ -0,0 +1,102 @@
+package notifier
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+)
+
+// Slack holds the hook URL
+type Slack struct {
+	URL       string
+	Username  string
+	Channel   string
+	IconEmoji string
+}
+
+// SlackPayload holds the channel and attachments
+type SlackPayload struct {
+	Channel     string            `json:"channel"`
+	Username    string            `json:"username"`
+	IconUrl     string            `json:"icon_url"`
+	IconEmoji   string            `json:"icon_emoji"`
+	Text        string            `json:"text,omitempty"`
+	Attachments []SlackAttachment `json:"attachments,omitempty"`
+}
+
+// SlackAttachment holds the markdown message body
+type SlackAttachment struct {
+	Color      string   `json:"color"`
+	AuthorName string   `json:"author_name"`
+	Text       string   `json:"text"`
+	MrkdwnIn   []string `json:"mrkdwn_in"`
+}
+
+// NewSlack validates the Slack URL and returns a Slack object
+func NewSlack(hookURL string, username string, channel string) (*Slack, error) {
+	_, err := url.ParseRequestURI(hookURL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid Slack hook URL %s", hookURL)
+	}
+
+	if username == "" {
+		return nil, errors.New("empty Slack username")
+	}
+
+	if channel == "" {
+		return nil, errors.New("empty Slack channel")
+	}
+
+	return &Slack{
+		Channel:   channel,
+		URL:       hookURL,
+		Username:  username,
+		IconEmoji: ":rocket:",
+	}, nil
+}
+
+// Post Slack message
+func (s *Slack) Post(workload string, namespace string, message string, warn bool) error {
+	payload := SlackPayload{
+		Channel:  s.Channel,
+		Username: s.Username,
+	}
+
+	color := "good"
+	if warn {
+		color = "danger"
+	}
+
+	a := SlackAttachment{
+		Color:      color,
+		AuthorName: fmt.Sprintf("%s.%s", workload, namespace),
+		Text:       message,
+		MrkdwnIn:   []string{"text"},
+	}
+
+	payload.Attachments = []SlackAttachment{a}
+
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("marshalling slack payload failed %v", err)
+	}
+
+	b := bytes.NewBuffer(data)
+
+	if res, err := http.Post(s.URL, "application/json", b); err != nil {
+		return fmt.Errorf("sending data to slack failed %v", err)
+	} else {
+		defer res.Body.Close()
+		statusCode := res.StatusCode
+		if statusCode != 200 {
+			body, _ := ioutil.ReadAll(res.Body)
+			return fmt.Errorf("sending data to slack failed %v", string(body))
+		}
+	}
+
+	return nil
+}

pkg/server/server.go

@@ -9,6 +9,7 @@ import (
 	"go.uber.org/zap"
 )
 
+// ListenAndServe starts a web server and waits for SIGTERM
 func ListenAndServe(port string, timeout time.Duration, logger *zap.SugaredLogger, stopCh <-chan struct{}) {
 	mux := http.DefaultServeMux
 	mux.Handle("/metrics", promhttp.Handler())

pkg/version/version.go

@@ -1,4 +1,4 @@
 package version
 
-var VERSION = "0.0.1"
+var VERSION = "0.1.0"
 var REVISION = "unknown"

vendor/github.com/fatih/color/LICENSE.md

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 Fatih Arslan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/fatih/color/color.go

@@ -1,603 +0,0 @@
-package color
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/mattn/go-colorable"
-	"github.com/mattn/go-isatty"
-)
-
-var (
-	// NoColor defines if the output is colorized or not. It's dynamically set to
-	// false or true based on the stdout's file descriptor referring to a terminal
-	// or not. This is a global option and affects all colors. For more control
-	// over each color block use the methods DisableColor() individually.
-	NoColor = os.Getenv("TERM") == "dumb" ||
-		(!isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()))
-
-	// Output defines the standard output of the print functions. By default
-	// os.Stdout is used.
-	Output = colorable.NewColorableStdout()
-
-	// Error defines a color supporting writer for os.Stderr.
-	Error = colorable.NewColorableStderr()
-
-	// colorsCache is used to reduce the count of created Color objects and
-	// allows to reuse already created objects with required Attribute.
-	colorsCache   = make(map[Attribute]*Color)
-	colorsCacheMu sync.Mutex // protects colorsCache
-)
-
-// Color defines a custom color object which is defined by SGR parameters.
-type Color struct {
-	params  []Attribute
-	noColor *bool
-}
-
-// Attribute defines a single SGR Code
-type Attribute int
-
-const escape = "\x1b"
-
-// Base attributes
-const (
-	Reset Attribute = iota
-	Bold
-	Faint
-	Italic
-	Underline
-	BlinkSlow
-	BlinkRapid
-	ReverseVideo
-	Concealed
-	CrossedOut
-)
-
-// Foreground text colors
-const (
-	FgBlack Attribute = iota + 30
-	FgRed
-	FgGreen
-	FgYellow
-	FgBlue
-	FgMagenta
-	FgCyan
-	FgWhite
-)
-
-// Foreground Hi-Intensity text colors
-const (
-	FgHiBlack Attribute = iota + 90
-	FgHiRed
-	FgHiGreen
-	FgHiYellow
-	FgHiBlue
-	FgHiMagenta
-	FgHiCyan
-	FgHiWhite
-)
-
-// Background text colors
-const (
-	BgBlack Attribute = iota + 40
-	BgRed
-	BgGreen
-	BgYellow
-	BgBlue
-	BgMagenta
-	BgCyan
-	BgWhite
-)
-
-// Background Hi-Intensity text colors
-const (
-	BgHiBlack Attribute = iota + 100
-	BgHiRed
-	BgHiGreen
-	BgHiYellow
-	BgHiBlue
-	BgHiMagenta
-	BgHiCyan
-	BgHiWhite
-)
-
-// New returns a newly created color object.
-func New(value ...Attribute) *Color {
-	c := &Color{params: make([]Attribute, 0)}
-	c.Add(value...)
-	return c
-}
-
-// Set sets the given parameters immediately. It will change the color of
-// output with the given SGR parameters until color.Unset() is called.
-func Set(p ...Attribute) *Color {
-	c := New(p...)
-	c.Set()
-	return c
-}
-
-// Unset resets all escape attributes and clears the output. Usually should
-// be called after Set().
-func Unset() {
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(Output, "%s[%dm", escape, Reset)
-}
-
-// Set sets the SGR sequence.
-func (c *Color) Set() *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(Output, c.format())
-	return c
-}
-
-func (c *Color) unset() {
-	if c.isNoColorSet() {
-		return
-	}
-
-	Unset()
-}
-
-func (c *Color) setWriter(w io.Writer) *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(w, c.format())
-	return c
-}
-
-func (c *Color) unsetWriter(w io.Writer) {
-	if c.isNoColorSet() {
-		return
-	}
-
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(w, "%s[%dm", escape, Reset)
-}
-
-// Add is used to chain SGR parameters. Use as many as parameters to combine
-// and create custom color objects. Example: Add(color.FgRed, color.Underline).
-func (c *Color) Add(value ...Attribute) *Color {
-	c.params = append(c.params, value...)
-	return c
-}
-
-func (c *Color) prepend(value Attribute) {
-	c.params = append(c.params, 0)
-	copy(c.params[1:], c.params[0:])
-	c.params[0] = value
-}
-
-// Fprint formats using the default formats for its operands and writes to w.
-// Spaces are added between operands when neither is a string.
-// It returns the number of bytes written and any write error encountered.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprint(w, a...)
-}
-
-// Print formats using the default formats for its operands and writes to
-// standard output. Spaces are added between operands when neither is a
-// string. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Print(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprint(Output, a...)
-}
-
-// Fprintf formats according to a format specifier and writes to w.
-// It returns the number of bytes written and any write error encountered.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprintf(w, format, a...)
-}
-
-// Printf formats according to a format specifier and writes to standard output.
-// It returns the number of bytes written and any write error encountered.
-// This is the standard fmt.Printf() method wrapped with the given color.
-func (c *Color) Printf(format string, a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintf(Output, format, a...)
-}
-
-// Fprintln formats using the default formats for its operands and writes to w.
-// Spaces are always added between operands and a newline is appended.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprintln(w, a...)
-}
-
-// Println formats using the default formats for its operands and writes to
-// standard output. Spaces are always added between operands and a newline is
-// appended. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Println(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintln(Output, a...)
-}
-
-// Sprint is just like Print, but returns a string instead of printing it.
-func (c *Color) Sprint(a ...interface{}) string {
-	return c.wrap(fmt.Sprint(a...))
-}
-
-// Sprintln is just like Println, but returns a string instead of printing it.
-func (c *Color) Sprintln(a ...interface{}) string {
-	return c.wrap(fmt.Sprintln(a...))
-}
-
-// Sprintf is just like Printf, but returns a string instead of printing it.
-func (c *Color) Sprintf(format string, a ...interface{}) string {
-	return c.wrap(fmt.Sprintf(format, a...))
-}
-
-// FprintFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprint().
-func (c *Color) FprintFunc() func(w io.Writer, a ...interface{}) {
-	return func(w io.Writer, a ...interface{}) {
-		c.Fprint(w, a...)
-	}
-}
-
-// PrintFunc returns a new function that prints the passed arguments as
-// colorized with color.Print().
-func (c *Color) PrintFunc() func(a ...interface{}) {
-	return func(a ...interface{}) {
-		c.Print(a...)
-	}
-}
-
-// FprintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprintf().
-func (c *Color) FprintfFunc() func(w io.Writer, format string, a ...interface{}) {
-	return func(w io.Writer, format string, a ...interface{}) {
-		c.Fprintf(w, format, a...)
-	}
-}
-
-// PrintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Printf().
-func (c *Color) PrintfFunc() func(format string, a ...interface{}) {
-	return func(format string, a ...interface{}) {
-		c.Printf(format, a...)
-	}
-}
-
-// FprintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprintln().
-func (c *Color) FprintlnFunc() func(w io.Writer, a ...interface{}) {
-	return func(w io.Writer, a ...interface{}) {
-		c.Fprintln(w, a...)
-	}
-}
-
-// PrintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Println().
-func (c *Color) PrintlnFunc() func(a ...interface{}) {
-	return func(a ...interface{}) {
-		c.Println(a...)
-	}
-}
-
-// SprintFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprint(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output, example:
-//
-//	put := New(FgYellow).SprintFunc()
-//	fmt.Fprintf(color.Output, "This is a %s", put("warning"))
-func (c *Color) SprintFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprint(a...))
-	}
-}
-
-// SprintfFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintf(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output.
-func (c *Color) SprintfFunc() func(format string, a ...interface{}) string {
-	return func(format string, a ...interface{}) string {
-		return c.wrap(fmt.Sprintf(format, a...))
-	}
-}
-
-// SprintlnFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintln(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output.
-func (c *Color) SprintlnFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprintln(a...))
-	}
-}
-
-// sequence returns a formatted SGR sequence to be plugged into a "\x1b[...m"
-// an example output might be: "1;36" -> bold cyan
-func (c *Color) sequence() string {
-	format := make([]string, len(c.params))
-	for i, v := range c.params {
-		format[i] = strconv.Itoa(int(v))
-	}
-
-	return strings.Join(format, ";")
-}
-
-// wrap wraps the s string with the colors attributes. The string is ready to
-// be printed.
-func (c *Color) wrap(s string) string {
-	if c.isNoColorSet() {
-		return s
-	}
-
-	return c.format() + s + c.unformat()
-}
-
-func (c *Color) format() string {
-	return fmt.Sprintf("%s[%sm", escape, c.sequence())
-}
-
-func (c *Color) unformat() string {
-	return fmt.Sprintf("%s[%dm", escape, Reset)
-}
-
-// DisableColor disables the color output. Useful to not change any existing
-// code and still being able to output. Can be used for flags like
-// "--no-color". To enable back use EnableColor() method.
-func (c *Color) DisableColor() {
-	c.noColor = boolPtr(true)
-}
-
-// EnableColor enables the color output. Use it in conjunction with
-// DisableColor(). Otherwise this method has no side effects.
-func (c *Color) EnableColor() {
-	c.noColor = boolPtr(false)
-}
-
-func (c *Color) isNoColorSet() bool {
-	// check first if we have user setted action
-	if c.noColor != nil {
-		return *c.noColor
-	}
-
-	// if not return the global option, which is disabled by default
-	return NoColor
-}
-
-// Equals returns a boolean value indicating whether two colors are equal.
-func (c *Color) Equals(c2 *Color) bool {
-	if len(c.params) != len(c2.params) {
-		return false
-	}
-
-	for _, attr := range c.params {
-		if !c2.attrExists(attr) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c *Color) attrExists(a Attribute) bool {
-	for _, attr := range c.params {
-		if attr == a {
-			return true
-		}
-	}
-
-	return false
-}
-
-func boolPtr(v bool) *bool {
-	return &v
-}
-
-func getCachedColor(p Attribute) *Color {
-	colorsCacheMu.Lock()
-	defer colorsCacheMu.Unlock()
-
-	c, ok := colorsCache[p]
-	if !ok {
-		c = New(p)
-		colorsCache[p] = c
-	}
-
-	return c
-}
-
-func colorPrint(format string, p Attribute, a ...interface{}) {
-	c := getCachedColor(p)
-
-	if !strings.HasSuffix(format, "\n") {
-		format += "\n"
-	}
-
-	if len(a) == 0 {
-		c.Print(format)
-	} else {
-		c.Printf(format, a...)
-	}
-}
-
-func colorString(format string, p Attribute, a ...interface{}) string {
-	c := getCachedColor(p)
-
-	if len(a) == 0 {
-		return c.SprintFunc()(format)
-	}
-
-	return c.SprintfFunc()(format, a...)
-}
-
-// Black is a convenient helper function to print with black foreground. A
-// newline is appended to format by default.
-func Black(format string, a ...interface{}) { colorPrint(format, FgBlack, a...) }
-
-// Red is a convenient helper function to print with red foreground. A
-// newline is appended to format by default.
-func Red(format string, a ...interface{}) { colorPrint(format, FgRed, a...) }
-
-// Green is a convenient helper function to print with green foreground. A
-// newline is appended to format by default.
-func Green(format string, a ...interface{}) { colorPrint(format, FgGreen, a...) }
-
-// Yellow is a convenient helper function to print with yellow foreground.
-// A newline is appended to format by default.
-func Yellow(format string, a ...interface{}) { colorPrint(format, FgYellow, a...) }
-
-// Blue is a convenient helper function to print with blue foreground. A
-// newline is appended to format by default.
-func Blue(format string, a ...interface{}) { colorPrint(format, FgBlue, a...) }
-
-// Magenta is a convenient helper function to print with magenta foreground.
-// A newline is appended to format by default.
-func Magenta(format string, a ...interface{}) { colorPrint(format, FgMagenta, a...) }
-
-// Cyan is a convenient helper function to print with cyan foreground. A
-// newline is appended to format by default.
-func Cyan(format string, a ...interface{}) { colorPrint(format, FgCyan, a...) }
-
-// White is a convenient helper function to print with white foreground. A
-// newline is appended to format by default.
-func White(format string, a ...interface{}) { colorPrint(format, FgWhite, a...) }
-
-// BlackString is a convenient helper function to return a string with black
-// foreground.
-func BlackString(format string, a ...interface{}) string { return colorString(format, FgBlack, a...) }
-
-// RedString is a convenient helper function to return a string with red
-// foreground.
-func RedString(format string, a ...interface{}) string { return colorString(format, FgRed, a...) }
-
-// GreenString is a convenient helper function to return a string with green
-// foreground.
-func GreenString(format string, a ...interface{}) string { return colorString(format, FgGreen, a...) }
-
-// YellowString is a convenient helper function to return a string with yellow
-// foreground.
-func YellowString(format string, a ...interface{}) string { return colorString(format, FgYellow, a...) }
-
-// BlueString is a convenient helper function to return a string with blue
-// foreground.
-func BlueString(format string, a ...interface{}) string { return colorString(format, FgBlue, a...) }
-
-// MagentaString is a convenient helper function to return a string with magenta
-// foreground.
-func MagentaString(format string, a ...interface{}) string {
-	return colorString(format, FgMagenta, a...)
-}
-
-// CyanString is a convenient helper function to return a string with cyan
-// foreground.
-func CyanString(format string, a ...interface{}) string { return colorString(format, FgCyan, a...) }
-
-// WhiteString is a convenient helper function to return a string with white
-// foreground.
-func WhiteString(format string, a ...interface{}) string { return colorString(format, FgWhite, a...) }
-
-// HiBlack is a convenient helper function to print with hi-intensity black foreground. A
-// newline is appended to format by default.
-func HiBlack(format string, a ...interface{}) { colorPrint(format, FgHiBlack, a...) }
-
-// HiRed is a convenient helper function to print with hi-intensity red foreground. A
-// newline is appended to format by default.
-func HiRed(format string, a ...interface{}) { colorPrint(format, FgHiRed, a...) }
-
-// HiGreen is a convenient helper function to print with hi-intensity green foreground. A
-// newline is appended to format by default.
-func HiGreen(format string, a ...interface{}) { colorPrint(format, FgHiGreen, a...) }
-
-// HiYellow is a convenient helper function to print with hi-intensity yellow foreground.
-// A newline is appended to format by default.
-func HiYellow(format string, a ...interface{}) { colorPrint(format, FgHiYellow, a...) }
-
-// HiBlue is a convenient helper function to print with hi-intensity blue foreground. A
-// newline is appended to format by default.
-func HiBlue(format string, a ...interface{}) { colorPrint(format, FgHiBlue, a...) }
-
-// HiMagenta is a convenient helper function to print with hi-intensity magenta foreground.
-// A newline is appended to format by default.
-func HiMagenta(format string, a ...interface{}) { colorPrint(format, FgHiMagenta, a...) }
-
-// HiCyan is a convenient helper function to print with hi-intensity cyan foreground. A
-// newline is appended to format by default.
-func HiCyan(format string, a ...interface{}) { colorPrint(format, FgHiCyan, a...) }
-
-// HiWhite is a convenient helper function to print with hi-intensity white foreground. A
-// newline is appended to format by default.
-func HiWhite(format string, a ...interface{}) { colorPrint(format, FgHiWhite, a...) }
-
-// HiBlackString is a convenient helper function to return a string with hi-intensity black
-// foreground.
-func HiBlackString(format string, a ...interface{}) string {
-	return colorString(format, FgHiBlack, a...)
-}
-
-// HiRedString is a convenient helper function to return a string with hi-intensity red
-// foreground.
-func HiRedString(format string, a ...interface{}) string { return colorString(format, FgHiRed, a...) }
-
-// HiGreenString is a convenient helper function to return a string with hi-intensity green
-// foreground.
-func HiGreenString(format string, a ...interface{}) string {
-	return colorString(format, FgHiGreen, a...)
-}
-
-// HiYellowString is a convenient helper function to return a string with hi-intensity yellow
-// foreground.
-func HiYellowString(format string, a ...interface{}) string {
-	return colorString(format, FgHiYellow, a...)
-}
-
-// HiBlueString is a convenient helper function to return a string with hi-intensity blue
-// foreground.
-func HiBlueString(format string, a ...interface{}) string { return colorString(format, FgHiBlue, a...) }
-
-// HiMagentaString is a convenient helper function to return a string with hi-intensity magenta
-// foreground.
-func HiMagentaString(format string, a ...interface{}) string {
-	return colorString(format, FgHiMagenta, a...)
-}
-
-// HiCyanString is a convenient helper function to return a string with hi-intensity cyan
-// foreground.
-func HiCyanString(format string, a ...interface{}) string { return colorString(format, FgHiCyan, a...) }
-
-// HiWhiteString is a convenient helper function to return a string with hi-intensity white
-// foreground.
-func HiWhiteString(format string, a ...interface{}) string {
-	return colorString(format, FgHiWhite, a...)
-}

vendor/github.com/fatih/color/doc.go

@@ -1,133 +0,0 @@
-/*
-Package color is an ANSI color package to output colorized or SGR defined
-output to the standard output. The API can be used in several way, pick one
-that suits you.
-
-Use simple and default helper functions with predefined foreground colors:
-
-    color.Cyan("Prints text in cyan.")
-
-    // a newline will be appended automatically
-    color.Blue("Prints %s in blue.", "text")
-
-    // More default foreground colors..
-    color.Red("We have red")
-    color.Yellow("Yellow color too!")
-    color.Magenta("And many others ..")
-
-    // Hi-intensity colors
-    color.HiGreen("Bright green color.")
-    color.HiBlack("Bright black means gray..")
-    color.HiWhite("Shiny white color!")
-
-However there are times where custom color mixes are required. Below are some
-examples to create custom color objects and use the print functions of each
-separate color object.
-
-    // Create a new color object
-    c := color.New(color.FgCyan).Add(color.Underline)
-    c.Println("Prints cyan text with an underline.")
-
-    // Or just add them to New()
-    d := color.New(color.FgCyan, color.Bold)
-    d.Printf("This prints bold cyan %s\n", "too!.")
-
-
-    // Mix up foreground and background colors, create new mixes!
-    red := color.New(color.FgRed)
-
-    boldRed := red.Add(color.Bold)
-    boldRed.Println("This will print text in bold red.")
-
-    whiteBackground := red.Add(color.BgWhite)
-    whiteBackground.Println("Red text with White background.")
-
-    // Use your own io.Writer output
-    color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
-
-    blue := color.New(color.FgBlue)
-    blue.Fprint(myWriter, "This will print text in blue.")
-
-You can create PrintXxx functions to simplify even more:
-
-    // Create a custom print function for convenient
-    red := color.New(color.FgRed).PrintfFunc()
-    red("warning")
-    red("error: %s", err)
-
-    // Mix up multiple attributes
-    notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
-    notice("don't forget this...")
-
-You can also FprintXxx functions to pass your own io.Writer:
-
-    blue := color.New(FgBlue).FprintfFunc()
-    blue(myWriter, "important notice: %s", stars)
-
-    // Mix up with multiple attributes
-    success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
-    success(myWriter, don't forget this...")
-
-
-Or create SprintXxx functions to mix strings with other non-colorized strings:
-
-    yellow := New(FgYellow).SprintFunc()
-    red := New(FgRed).SprintFunc()
-
-    fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Printf("this %s rocks!\n", info("package"))
-
-Windows support is enabled by default. All Print functions work as intended.
-However only for color.SprintXXX functions, user should use fmt.FprintXXX and
-set the output to color.Output:
-
-    fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Fprintf(color.Output, "this %s rocks!\n", info("package"))
-
-Using with existing code is possible. Just use the Set() method to set the
-standard output to the given parameters. That way a rewrite of an existing
-code is not required.
-
-    // Use handy standard colors.
-    color.Set(color.FgYellow)
-
-    fmt.Println("Existing text will be now in Yellow")
-    fmt.Printf("This one %s\n", "too")
-
-    color.Unset() // don't forget to unset
-
-    // You can mix up parameters
-    color.Set(color.FgMagenta, color.Bold)
-    defer color.Unset() // use it in your function
-
-    fmt.Println("All text will be now bold magenta.")
-
-There might be a case where you want to disable color output (for example to
-pipe the standard output of your app to somewhere else). `Color` has support to
-disable colors both globally and for single color definition. For example
-suppose you have a CLI app and a `--no-color` bool flag. You can easily disable
-the color output with:
-
-    var flagNoColor = flag.Bool("no-color", false, "Disable color output")
-
-    if *flagNoColor {
-    	color.NoColor = true // disables colorized output
-    }
-
-It also has support for single color definitions (local). You can
-disable/enable color output on the fly:
-
-     c := color.New(color.FgCyan)
-     c.Println("Prints cyan text")
-
-     c.DisableColor()
-     c.Println("This is printed without any color")
-
-     c.EnableColor()
-     c.Println("This prints again cyan...")
-*/
-package color

vendor/github.com/google/go-cmp/cmp/cmpopts/equate.go

@@ -0,0 +1,89 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// Package cmpopts provides common options for the cmp package.
+package cmpopts
+
+import (
+	"math"
+	"reflect"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func equateAlways(_, _ interface{}) bool { return true }
+
+// EquateEmpty returns a Comparer option that determines all maps and slices
+// with a length of zero to be equal, regardless of whether they are nil.
+//
+// EquateEmpty can be used in conjunction with SortSlices and SortMaps.
+func EquateEmpty() cmp.Option {
+	return cmp.FilterValues(isEmpty, cmp.Comparer(equateAlways))
+}
+
+func isEmpty(x, y interface{}) bool {
+	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+	return (x != nil && y != nil && vx.Type() == vy.Type()) &&
+		(vx.Kind() == reflect.Slice || vx.Kind() == reflect.Map) &&
+		(vx.Len() == 0 && vy.Len() == 0)
+}
+
+// EquateApprox returns a Comparer option that determines float32 or float64
+// values to be equal if they are within a relative fraction or absolute margin.
+// This option is not used when either x or y is NaN or infinite.
+//
+// The fraction determines that the difference of two values must be within the
+// smaller fraction of the two values, while the margin determines that the two
+// values must be within some absolute margin.
+// To express only a fraction or only a margin, use 0 for the other parameter.
+// The fraction and margin must be non-negative.
+//
+// The mathematical expression used is equivalent to:
+//	|x-y| ≤ max(fraction*min(|x|, |y|), margin)
+//
+// EquateApprox can be used in conjunction with EquateNaNs.
+func EquateApprox(fraction, margin float64) cmp.Option {
+	if margin < 0 || fraction < 0 || math.IsNaN(margin) || math.IsNaN(fraction) {
+		panic("margin or fraction must be a non-negative number")
+	}
+	a := approximator{fraction, margin}
+	return cmp.Options{
+		cmp.FilterValues(areRealF64s, cmp.Comparer(a.compareF64)),
+		cmp.FilterValues(areRealF32s, cmp.Comparer(a.compareF32)),
+	}
+}
+
+type approximator struct{ frac, marg float64 }
+
+func areRealF64s(x, y float64) bool {
+	return !math.IsNaN(x) && !math.IsNaN(y) && !math.IsInf(x, 0) && !math.IsInf(y, 0)
+}
+func areRealF32s(x, y float32) bool {
+	return areRealF64s(float64(x), float64(y))
+}
+func (a approximator) compareF64(x, y float64) bool {
+	relMarg := a.frac * math.Min(math.Abs(x), math.Abs(y))
+	return math.Abs(x-y) <= math.Max(a.marg, relMarg)
+}
+func (a approximator) compareF32(x, y float32) bool {
+	return a.compareF64(float64(x), float64(y))
+}
+
+// EquateNaNs returns a Comparer option that determines float32 and float64
+// NaN values to be equal.
+//
+// EquateNaNs can be used in conjunction with EquateApprox.
+func EquateNaNs() cmp.Option {
+	return cmp.Options{
+		cmp.FilterValues(areNaNsF64s, cmp.Comparer(equateAlways)),
+		cmp.FilterValues(areNaNsF32s, cmp.Comparer(equateAlways)),
+	}
+}
+
+func areNaNsF64s(x, y float64) bool {
+	return math.IsNaN(x) && math.IsNaN(y)
+}
+func areNaNsF32s(x, y float32) bool {
+	return areNaNsF64s(float64(x), float64(y))
+}

vendor/github.com/google/go-cmp/cmp/cmpopts/ignore.go

@@ -0,0 +1,145 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmpopts
+
+import (
+	"fmt"
+	"reflect"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+// IgnoreFields returns an Option that ignores exported fields of the
+// given names on a single struct type.
+// The struct type is specified by passing in a value of that type.
+//
+// The name may be a dot-delimited string (e.g., "Foo.Bar") to ignore a
+// specific sub-field that is embedded or nested within the parent struct.
+//
+// This does not handle unexported fields; use IgnoreUnexported instead.
+func IgnoreFields(typ interface{}, names ...string) cmp.Option {
+	sf := newStructFilter(typ, names...)
+	return cmp.FilterPath(sf.filter, cmp.Ignore())
+}
+
+// IgnoreTypes returns an Option that ignores all values assignable to
+// certain types, which are specified by passing in a value of each type.
+func IgnoreTypes(typs ...interface{}) cmp.Option {
+	tf := newTypeFilter(typs...)
+	return cmp.FilterPath(tf.filter, cmp.Ignore())
+}
+
+type typeFilter []reflect.Type
+
+func newTypeFilter(typs ...interface{}) (tf typeFilter) {
+	for _, typ := range typs {
+		t := reflect.TypeOf(typ)
+		if t == nil {
+			// This occurs if someone tries to pass in sync.Locker(nil)
+			panic("cannot determine type; consider using IgnoreInterfaces")
+		}
+		tf = append(tf, t)
+	}
+	return tf
+}
+func (tf typeFilter) filter(p cmp.Path) bool {
+	if len(p) < 1 {
+		return false
+	}
+	t := p.Last().Type()
+	for _, ti := range tf {
+		if t.AssignableTo(ti) {
+			return true
+		}
+	}
+	return false
+}
+
+// IgnoreInterfaces returns an Option that ignores all values or references of
+// values assignable to certain interface types. These interfaces are specified
+// by passing in an anonymous struct with the interface types embedded in it.
+// For example, to ignore sync.Locker, pass in struct{sync.Locker}{}.
+func IgnoreInterfaces(ifaces interface{}) cmp.Option {
+	tf := newIfaceFilter(ifaces)
+	return cmp.FilterPath(tf.filter, cmp.Ignore())
+}
+
+type ifaceFilter []reflect.Type
+
+func newIfaceFilter(ifaces interface{}) (tf ifaceFilter) {
+	t := reflect.TypeOf(ifaces)
+	if ifaces == nil || t.Name() != "" || t.Kind() != reflect.Struct {
+		panic("input must be an anonymous struct")
+	}
+	for i := 0; i < t.NumField(); i++ {
+		fi := t.Field(i)
+		switch {
+		case !fi.Anonymous:
+			panic("struct cannot have named fields")
+		case fi.Type.Kind() != reflect.Interface:
+			panic("embedded field must be an interface type")
+		case fi.Type.NumMethod() == 0:
+			// This matches everything; why would you ever want this?
+			panic("cannot ignore empty interface")
+		default:
+			tf = append(tf, fi.Type)
+		}
+	}
+	return tf
+}
+func (tf ifaceFilter) filter(p cmp.Path) bool {
+	if len(p) < 1 {
+		return false
+	}
+	t := p.Last().Type()
+	for _, ti := range tf {
+		if t.AssignableTo(ti) {
+			return true
+		}
+		if t.Kind() != reflect.Ptr && reflect.PtrTo(t).AssignableTo(ti) {
+			return true
+		}
+	}
+	return false
+}
+
+// IgnoreUnexported returns an Option that only ignores the immediate unexported
+// fields of a struct, including anonymous fields of unexported types.
+// In particular, unexported fields within the struct's exported fields
+// of struct types, including anonymous fields, will not be ignored unless the
+// type of the field itself is also passed to IgnoreUnexported.
+func IgnoreUnexported(typs ...interface{}) cmp.Option {
+	ux := newUnexportedFilter(typs...)
+	return cmp.FilterPath(ux.filter, cmp.Ignore())
+}
+
+type unexportedFilter struct{ m map[reflect.Type]bool }
+
+func newUnexportedFilter(typs ...interface{}) unexportedFilter {
+	ux := unexportedFilter{m: make(map[reflect.Type]bool)}
+	for _, typ := range typs {
+		t := reflect.TypeOf(typ)
+		if t == nil || t.Kind() != reflect.Struct {
+			panic(fmt.Sprintf("invalid struct type: %T", typ))
+		}
+		ux.m[t] = true
+	}
+	return ux
+}
+func (xf unexportedFilter) filter(p cmp.Path) bool {
+	sf, ok := p.Index(-1).(cmp.StructField)
+	if !ok {
+		return false
+	}
+	return xf.m[p.Index(-2).Type()] && !isExported(sf.Name())
+}
+
+// isExported reports whether the identifier is exported.
+func isExported(id string) bool {
+	r, _ := utf8.DecodeRuneInString(id)
+	return unicode.IsUpper(r)
+}

vendor/github.com/google/go-cmp/cmp/cmpopts/sort.go

@@ -0,0 +1,146 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmpopts
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/internal/function"
+)
+
+// SortSlices returns a Transformer option that sorts all []V.
+// The less function must be of the form "func(T, T) bool" which is used to
+// sort any slice with element type V that is assignable to T.
+//
+// The less function must be:
+//	• Deterministic: less(x, y) == less(x, y)
+//	• Irreflexive: !less(x, x)
+//	• Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
+//
+// The less function does not have to be "total". That is, if !less(x, y) and
+// !less(y, x) for two elements x and y, their relative order is maintained.
+//
+// SortSlices can be used in conjunction with EquateEmpty.
+func SortSlices(less interface{}) cmp.Option {
+	vf := reflect.ValueOf(less)
+	if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
+		panic(fmt.Sprintf("invalid less function: %T", less))
+	}
+	ss := sliceSorter{vf.Type().In(0), vf}
+	return cmp.FilterValues(ss.filter, cmp.Transformer("Sort", ss.sort))
+}
+
+type sliceSorter struct {
+	in  reflect.Type  // T
+	fnc reflect.Value // func(T, T) bool
+}
+
+func (ss sliceSorter) filter(x, y interface{}) bool {
+	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+	if !(x != nil && y != nil && vx.Type() == vy.Type()) ||
+		!(vx.Kind() == reflect.Slice && vx.Type().Elem().AssignableTo(ss.in)) ||
+		(vx.Len() <= 1 && vy.Len() <= 1) {
+		return false
+	}
+	// Check whether the slices are already sorted to avoid an infinite
+	// recursion cycle applying the same transform to itself.
+	ok1 := sliceIsSorted(x, func(i, j int) bool { return ss.less(vx, i, j) })
+	ok2 := sliceIsSorted(y, func(i, j int) bool { return ss.less(vy, i, j) })
+	return !ok1 || !ok2
+}
+func (ss sliceSorter) sort(x interface{}) interface{} {
+	src := reflect.ValueOf(x)
+	dst := reflect.MakeSlice(src.Type(), src.Len(), src.Len())
+	for i := 0; i < src.Len(); i++ {
+		dst.Index(i).Set(src.Index(i))
+	}
+	sortSliceStable(dst.Interface(), func(i, j int) bool { return ss.less(dst, i, j) })
+	ss.checkSort(dst)
+	return dst.Interface()
+}
+func (ss sliceSorter) checkSort(v reflect.Value) {
+	start := -1 // Start of a sequence of equal elements.
+	for i := 1; i < v.Len(); i++ {
+		if ss.less(v, i-1, i) {
+			// Check that first and last elements in v[start:i] are equal.
+			if start >= 0 && (ss.less(v, start, i-1) || ss.less(v, i-1, start)) {
+				panic(fmt.Sprintf("incomparable values detected: want equal elements: %v", v.Slice(start, i)))
+			}
+			start = -1
+		} else if start == -1 {
+			start = i
+		}
+	}
+}
+func (ss sliceSorter) less(v reflect.Value, i, j int) bool {
+	vx, vy := v.Index(i), v.Index(j)
+	return ss.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
+}
+
+// SortMaps returns a Transformer option that flattens map[K]V types to be a
+// sorted []struct{K, V}. The less function must be of the form
+// "func(T, T) bool" which is used to sort any map with key K that is
+// assignable to T.
+//
+// Flattening the map into a slice has the property that cmp.Equal is able to
+// use Comparers on K or the K.Equal method if it exists.
+//
+// The less function must be:
+//	• Deterministic: less(x, y) == less(x, y)
+//	• Irreflexive: !less(x, x)
+//	• Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
+//	• Total: if x != y, then either less(x, y) or less(y, x)
+//
+// SortMaps can be used in conjunction with EquateEmpty.
+func SortMaps(less interface{}) cmp.Option {
+	vf := reflect.ValueOf(less)
+	if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
+		panic(fmt.Sprintf("invalid less function: %T", less))
+	}
+	ms := mapSorter{vf.Type().In(0), vf}
+	return cmp.FilterValues(ms.filter, cmp.Transformer("Sort", ms.sort))
+}
+
+type mapSorter struct {
+	in  reflect.Type  // T
+	fnc reflect.Value // func(T, T) bool
+}
+
+func (ms mapSorter) filter(x, y interface{}) bool {
+	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+	return (x != nil && y != nil && vx.Type() == vy.Type()) &&
+		(vx.Kind() == reflect.Map && vx.Type().Key().AssignableTo(ms.in)) &&
+		(vx.Len() != 0 || vy.Len() != 0)
+}
+func (ms mapSorter) sort(x interface{}) interface{} {
+	src := reflect.ValueOf(x)
+	outType := mapEntryType(src.Type())
+	dst := reflect.MakeSlice(reflect.SliceOf(outType), src.Len(), src.Len())
+	for i, k := range src.MapKeys() {
+		v := reflect.New(outType).Elem()
+		v.Field(0).Set(k)
+		v.Field(1).Set(src.MapIndex(k))
+		dst.Index(i).Set(v)
+	}
+	sortSlice(dst.Interface(), func(i, j int) bool { return ms.less(dst, i, j) })
+	ms.checkSort(dst)
+	return dst.Interface()
+}
+func (ms mapSorter) checkSort(v reflect.Value) {
+	for i := 1; i < v.Len(); i++ {
+		if !ms.less(v, i-1, i) {
+			panic(fmt.Sprintf("partial order detected: want %v < %v", v.Index(i-1), v.Index(i)))
+		}
+	}
+}
+func (ms mapSorter) less(v reflect.Value, i, j int) bool {
+	vx, vy := v.Index(i).Field(0), v.Index(j).Field(0)
+	if !hasReflectStructOf {
+		vx, vy = vx.Elem(), vy.Elem()
+	}
+	return ms.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
+}

vendor/github.com/google/go-cmp/cmp/cmpopts/sort_go17.go

@@ -0,0 +1,46 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// +build !go1.8
+
+package cmpopts
+
+import (
+	"reflect"
+	"sort"
+)
+
+const hasReflectStructOf = false
+
+func mapEntryType(reflect.Type) reflect.Type {
+	return reflect.TypeOf(struct{ K, V interface{} }{})
+}
+
+func sliceIsSorted(slice interface{}, less func(i, j int) bool) bool {
+	return sort.IsSorted(reflectSliceSorter{reflect.ValueOf(slice), less})
+}
+func sortSlice(slice interface{}, less func(i, j int) bool) {
+	sort.Sort(reflectSliceSorter{reflect.ValueOf(slice), less})
+}
+func sortSliceStable(slice interface{}, less func(i, j int) bool) {
+	sort.Stable(reflectSliceSorter{reflect.ValueOf(slice), less})
+}
+
+type reflectSliceSorter struct {
+	slice reflect.Value
+	less  func(i, j int) bool
+}
+
+func (ss reflectSliceSorter) Len() int {
+	return ss.slice.Len()
+}
+func (ss reflectSliceSorter) Less(i, j int) bool {
+	return ss.less(i, j)
+}
+func (ss reflectSliceSorter) Swap(i, j int) {
+	vi := ss.slice.Index(i).Interface()
+	vj := ss.slice.Index(j).Interface()
+	ss.slice.Index(i).Set(reflect.ValueOf(vj))
+	ss.slice.Index(j).Set(reflect.ValueOf(vi))
+}

vendor/github.com/google/go-cmp/cmp/cmpopts/sort_go18.go

@@ -0,0 +1,31 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// +build go1.8
+
+package cmpopts
+
+import (
+	"reflect"
+	"sort"
+)
+
+const hasReflectStructOf = true
+
+func mapEntryType(t reflect.Type) reflect.Type {
+	return reflect.StructOf([]reflect.StructField{
+		{Name: "K", Type: t.Key()},
+		{Name: "V", Type: t.Elem()},
+	})
+}
+
+func sliceIsSorted(slice interface{}, less func(i, j int) bool) bool {
+	return sort.SliceIsSorted(slice, less)
+}
+func sortSlice(slice interface{}, less func(i, j int) bool) {
+	sort.Slice(slice, less)
+}
+func sortSliceStable(slice interface{}, less func(i, j int) bool) {
+	sort.SliceStable(slice, less)
+}