Merge pull request #400 from weaveworks/release-0.21.0

Release 0.21.0

.circleci/config.yml

@@ -92,6 +92,17 @@ jobs:
       - run: test/e2e-kubernetes.sh
       - run: test/e2e-kubernetes-tests.sh
 
+  e2e-kubernetes-svc-testing:
+    machine: true
+    steps:
+      - checkout
+      - attach_workspace:
+          at: /tmp/bin
+      - run: test/container-build.sh
+      - run: test/e2e-kind.sh
+      - run: test/e2e-kubernetes.sh
+      - run: test/e2e-kubernetes-svc-tests.sh
+
   e2e-smi-istio-testing:
     machine: true
     steps:
@@ -139,6 +150,17 @@ jobs:
       - run: test/e2e-linkerd.sh
       - run: test/e2e-linkerd-tests.sh
 
+  e2e-contour-testing:
+    machine: true
+    steps:
+      - checkout
+      - attach_workspace:
+          at: /tmp/bin
+      - run: test/container-build.sh
+      - run: test/e2e-kind.sh
+      - run: test/e2e-contour.sh
+      - run: test/e2e-contour-tests.sh
+
   push-helm-charts:
     docker:
       - image: circleci/golang:1.13
@@ -204,6 +226,9 @@ workflows:
       - e2e-linkerd-testing:
           requires:
             - build-binary
+      - e2e-contour-testing:
+          requires:
+            - build-binary
       - push-container:
           requires:
             - build-binary

CHANGELOG.md

@@ -2,6 +2,43 @@
 
 All notable changes to this project are documented in this file.
 
+## 0.21.0 (2020-01-06) 
+
+Adds support for Contour ingress controller
+
+#### Features
+
+- Add support for Contour ingress controller [#397](https://github.com/weaveworks/flagger/pull/397)
+- Add support for Envoy managed by Crossover via SMI [#386](https://github.com/weaveworks/flagger/pull/386)
+- Extend canary target ref to Kubernetes Service kind [#372](https://github.com/weaveworks/flagger/pull/372)
+
+#### Improvements 
+
+- Add Prometheus operator PodMonitor template to Helm chart [#399](https://github.com/weaveworks/flagger/pull/399)
+- Update e2e tests to Kubernetes v1.16 [#390](https://github.com/weaveworks/flagger/pull/390)
+
+## 0.20.4 (2019-12-03) 
+
+Adds support for taking over a running deployment without disruption
+
+#### Improvements 
+
+- Add initialization phase to Kubernetes router [#384](https://github.com/weaveworks/flagger/pull/384)
+- Add canary controller interface and Kubernetes deployment kind implementation [#378](https://github.com/weaveworks/flagger/pull/378)
+
+#### Fixes
+
+- Skip primary check on skip analysis [#380](https://github.com/weaveworks/flagger/pull/380)
+
+## 0.20.3 (2019-11-13) 
+
+Adds wrk to load tester tools and the App Mesh gateway chart to Flagger Helm repository
+
+#### Improvements 
+
+- Add wrk to load tester tools [#368](https://github.com/weaveworks/flagger/pull/368)
+- Add App Mesh gateway chart [#365](https://github.com/weaveworks/flagger/pull/365)
+
 ## 0.20.2 (2019-11-07) 
 
 Adds support for exposing canaries outside the cluster using App Mesh Gateway annotations 

Dockerfile.loadtester

@@ -1,44 +1,64 @@
-FROM bats/bats:v1.1.0
+FROM alpine:3.10.3 as build
 
-RUN addgroup -S app \
-    && adduser -S -g app app \
-    && apk --no-cache add ca-certificates curl jq
-
-WORKDIR /home/app
+RUN apk --no-cache add alpine-sdk perl curl
 
 RUN curl -sSLo hey "https://storage.googleapis.com/hey-release/hey_linux_amd64" && \
 chmod +x hey && mv hey /usr/local/bin/hey
 
-# verify hey works
-RUN hey -n 1 -c 1 https://flagger.app > /dev/null && echo $? | grep 0
-
-RUN curl -sSL "https://get.helm.sh/helm-v2.15.1-linux-amd64.tar.gz" | tar xvz && \
+RUN HELM2_VERSION=2.16.1 && \
+curl -sSL "https://get.helm.sh/helm-v${HELM2_VERSION}-linux-amd64.tar.gz" | tar xvz && \
 chmod +x linux-amd64/helm && mv linux-amd64/helm /usr/local/bin/helm && \
-chmod +x linux-amd64/tiller && mv linux-amd64/tiller /usr/local/bin/tiller && \
-rm -rf linux-amd64
+chmod +x linux-amd64/tiller && mv linux-amd64/tiller /usr/local/bin/tiller
 
-RUN curl -sSL "https://get.helm.sh/helm-v3.0.0-rc.2-linux-amd64.tar.gz" | tar xvz && \
-chmod +x linux-amd64/helm && mv linux-amd64/helm /usr/local/bin/helmv3 && \
-rm -rf linux-amd64
+RUN HELM3_VERSION=3.0.1 && \
+curl -sSL "https://get.helm.sh/helm-v${HELM3_VERSION}-linux-amd64.tar.gz" | tar xvz && \
+chmod +x linux-amd64/helm && mv linux-amd64/helm /usr/local/bin/helmv3
 
 RUN GRPC_HEALTH_PROBE_VERSION=v0.3.1 && \
 wget -qO /usr/local/bin/grpc_health_probe https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/${GRPC_HEALTH_PROBE_VERSION}/grpc_health_probe-linux-amd64 && \
 chmod +x /usr/local/bin/grpc_health_probe
 
-RUN curl -sSL "https://github.com/bojand/ghz/releases/download/v0.39.0/ghz_0.39.0_Linux_x86_64.tar.gz" | tar xz -C /tmp && \
-mv /tmp/ghz /usr/local/bin && chmod +x /usr/local/bin/ghz && rm -rf /tmp/ghz-web
+RUN GHZ_VERSION=0.39.0 && \
+curl -sSL "https://github.com/bojand/ghz/releases/download/v${GHZ_VERSION}/ghz_${GHZ_VERSION}_Linux_x86_64.tar.gz" | tar xz -C /tmp && \
+mv /tmp/ghz /usr/local/bin && chmod +x /usr/local/bin/ghz
 
+RUN HELM_TILLER_VERSION=0.9.3 && \
+curl -sSL "https://github.com/rimusz/helm-tiller/archive/v${HELM_TILLER_VERSION}.tar.gz" | tar xz -C /tmp && \
+mv /tmp/helm-tiller-${HELM_TILLER_VERSION} /tmp/helm-tiller
+
+RUN WRK_VERSION=4.0.2 && \
+cd /tmp && git clone -b ${WRK_VERSION} https://github.com/wg/wrk
+RUN cd /tmp/wrk && make
+
+FROM bats/bats:v1.1.0
+
+RUN addgroup -S app && \
+adduser -S -g app app && \
+apk --no-cache add ca-certificates curl jq libgcc
+
+WORKDIR /home/app
+
+COPY --from=build /usr/local/bin/hey /usr/local/bin/
+COPY --from=build /tmp/wrk/wrk /usr/local/bin/
+COPY --from=build /usr/local/bin/helm /usr/local/bin/
+COPY --from=build /usr/local/bin/tiller /usr/local/bin/
+COPY --from=build /usr/local/bin/ghz /usr/local/bin/
+COPY --from=build /usr/local/bin/helmv3 /usr/local/bin/
+COPY --from=build /usr/local/bin/grpc_health_probe /usr/local/bin/
+COPY --from=build /tmp/helm-tiller /tmp/helm-tiller
 ADD https://raw.githubusercontent.com/grpc/grpc-proto/master/grpc/health/v1/health.proto /tmp/ghz/health.proto
 
-RUN ls /tmp
-
 COPY ./bin/loadtester .
 
 RUN chown -R app:app ./
 
 USER app
 
-RUN curl -sSL "https://github.com/rimusz/helm-tiller/archive/v0.9.3.tar.gz" | tar xvz && \
-helm init --client-only && helm plugin install helm-tiller-0.9.3 && helm plugin list
+# test load generator tools
+RUN hey -n 1 -c 1 https://flagger.app > /dev/null && echo $? | grep 0
+RUN wrk -d 1s -c 1 -t 1 https://flagger.app > /dev/null && echo $? | grep 0
+
+# install Helm v2 plugins
+RUN helm init --client-only && helm plugin install /tmp/helm-tiller
 
 ENTRYPOINT ["./loadtester"]

README.md

@@ -7,7 +7,7 @@
 [![release](https://img.shields.io/github/release/weaveworks/flagger/all.svg)](https://github.com/weaveworks/flagger/releases)
 
 Flagger is a Kubernetes operator that automates the promotion of canary deployments
-using Istio, Linkerd, App Mesh, NGINX or Gloo routing for traffic shifting and Prometheus metrics for canary analysis.
+using Istio, Linkerd, App Mesh, NGINX, Contour or Gloo routing for traffic shifting and Prometheus metrics for canary analysis.
 The canary analysis can be extended with webhooks for running acceptance tests,
 load tests or any other custom validation.
 
@@ -43,6 +43,8 @@ Flagger documentation can be found at [docs.flagger.app](https://docs.flagger.ap
   * [App Mesh canary deployments](https://docs.flagger.app/usage/appmesh-progressive-delivery)
   * [NGINX ingress controller canary deployments](https://docs.flagger.app/usage/nginx-progressive-delivery)
   * [Gloo ingress controller canary deployments](https://docs.flagger.app/usage/gloo-progressive-delivery)
+  * [Contour Canary Deployments](https://docs.flagger.app/usage/contour-progressive-delivery)
+  * [Crossover canary deployments](https://docs.flagger.app/usage/crossover-progressive-delivery)
   * [Blue/Green deployments](https://docs.flagger.app/usage/blue-green)
   * [Monitoring](https://docs.flagger.app/usage/monitoring)
   * [Alerting](https://docs.flagger.app/usage/alerting)
@@ -68,7 +70,7 @@ metadata:
   namespace: test
 spec:
   # service mesh provider (optional)
-  # can be: kubernetes, istio, linkerd, appmesh, nginx, gloo, supergloo
+  # can be: kubernetes, istio, linkerd, appmesh, nginx, contour, gloo, supergloo
   provider: istio
   # deployment reference
   targetRef:
@@ -149,21 +151,21 @@ For more details on how the canary analysis and promotion works please [read the
 
 ## Features
 
-| Feature                                      | Istio              | Linkerd            | App Mesh           | NGINX              | Gloo               | Kubernetes CNI     |
-| -------------------------------------------- | ------------------ | ------------------ |------------------  |------------------  |------------------  |------------------  |
-| Canary deployments (weighted traffic)        | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_minus_sign: |
-| A/B testing (headers and cookies routing)    | :heavy_check_mark: | :heavy_minus_sign: | :heavy_check_mark: | :heavy_check_mark: | :heavy_minus_sign: | :heavy_minus_sign: |
-| Blue/Green deployments (traffic switch)      | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
-| Webhooks (acceptance/load testing)           | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
-| Manual gating (approve/pause/resume)         | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
-| Request success rate check (L7 metric)       | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_minus_sign: |
-| Request duration check (L7 metric)           | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_minus_sign: |
-| Custom promql checks                         | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
-| Traffic policy, CORS, retries and timeouts   | :heavy_check_mark: | :heavy_minus_sign: | :heavy_minus_sign: | :heavy_minus_sign: | :heavy_minus_sign: | :heavy_minus_sign: |
+| Feature                                      | Istio              | Linkerd            | App Mesh           | NGINX              | Gloo               | Contour            | CNI                |
+| -------------------------------------------- | ------------------ | ------------------ |------------------  |------------------  |------------------  |------------------  |------------------  |
+| Canary deployments (weighted traffic)        | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_minus_sign: |
+| A/B testing (headers and cookies routing)    | :heavy_check_mark: | :heavy_minus_sign: | :heavy_check_mark: | :heavy_check_mark: | :heavy_minus_sign: | :heavy_check_mark: | :heavy_minus_sign: |
+| Blue/Green deployments (traffic switch)      | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
+| Webhooks (acceptance/load testing)           | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
+| Manual gating (approve/pause/resume)         | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
+| Request success rate check (L7 metric)       | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_minus_sign: |
+| Request duration check (L7 metric)           | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_minus_sign: |
+| Custom promql checks                         | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
+| Traffic policy, CORS, retries and timeouts   | :heavy_check_mark: | :heavy_minus_sign: | :heavy_minus_sign: | :heavy_minus_sign: | :heavy_minus_sign: | :heavy_check_mark: | :heavy_minus_sign: |
 
 ## Roadmap
 
-* Integrate with other ingress controllers like Contour, HAProxy, ALB
+* Integrate with other service mesh like Consul Connect and ingress controllers like HAProxy, ALB
 * Add support for comparing the canary metrics to the primary ones and do the validation based on the derivation between the two
 
 ## Contributing
@@ -174,9 +176,9 @@ When submitting bug reports please include as much details as possible:
 
 * which Flagger version
 * which Flagger CRD version
-* which Kubernetes/Istio version
-* what configuration (canary, virtual service and workloads definitions)
-* what happened (Flagger, Istio Pilot and Proxy logs)
+* which Kubernetes version
+* what configuration (canary, ingress and workloads definitions)
+* what happened (Flagger and Proxy logs)
 
 ## Getting Help
 

artifacts/flagger/account.yaml

@@ -81,6 +81,11 @@ rules:
       - virtualservices
       - gateways
     verbs: ["*"]
+  - apiGroups:
+      - projectcontour.io
+    resources:
+      - httpproxies
+    verbs: ["*"]
   - nonResourceURLs:
       - /version
     verbs:

artifacts/flagger/deployment.yaml

@@ -22,7 +22,7 @@ spec:
       serviceAccountName: flagger
       containers:
       - name: flagger
-        image: weaveworks/flagger:0.20.2
+        image: weaveworks/flagger:0.21.0
         imagePullPolicy: IfNotPresent
         ports:
         - name: http

artifacts/loadtester/deployment.yaml

@@ -17,7 +17,7 @@ spec:
     spec:
       containers:
         - name: loadtester
-          image: weaveworks/flagger-loadtester:0.11.0
+          image: weaveworks/flagger-loadtester:0.12.1
           imagePullPolicy: IfNotPresent
           ports:
             - name: http

charts/appmesh-gateway/.helmignore

@@ -0,0 +1,21 @@
+# 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/appmesh-gateway/Chart.yaml

@@ -0,0 +1,19 @@
+apiVersion: v1
+name: appmesh-gateway
+description: Flagger Gateway for AWS App Mesh is an edge L7 load balancer that exposes applications outside the mesh.
+version: 1.1.1
+appVersion: 1.1.0
+home: https://flagger.app
+icon: https://raw.githubusercontent.com/weaveworks/flagger/master/docs/logo/weaveworks.png
+sources:
+  - https://github.com/stefanprodan/appmesh-gateway
+maintainers:
+  - name: Stefan Prodan
+    url: https://github.com/stefanprodan
+    email: stefanprodan@users.noreply.github.com
+keywords:
+  - flagger
+  - appmesh
+  - envoy
+  - gateway
+  - ingress

charts/appmesh-gateway/README.md

@@ -0,0 +1,87 @@
+# Flagger Gateway for App Mesh
+
+[Flagger Gateway for App Mesh](https://github.com/stefanprodan/appmesh-gateway) is an
+Envoy-powered load balancer that exposes applications outside the mesh.
+The gateway facilitates canary deployments and A/B testing for user-facing web applications running on AWS App Mesh.
+
+## Prerequisites
+
+* Kubernetes >= 1.13
+* [App Mesh controller](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller) >= 0.2.0
+* [App Mesh inject](https://github.com/aws/eks-charts/tree/master/stable/appmesh-inject) >= 0.2.0
+
+## Installing the Chart
+
+Add Flagger Helm repository:
+
+```console
+$ helm repo add flagger https://flagger.app
+```
+
+Create a namespace with App Mesh sidecar injection enabled:
+
+```sh
+kubectl create ns flagger-system
+kubectl label namespace test appmesh.k8s.aws/sidecarInjectorWebhook=enabled
+```
+
+Install App Mesh Gateway for an existing mesh:
+
+```sh
+helm upgrade -i appmesh-gateway flagger/appmesh-gateway \
+--namespace flagger-system \
+--set mesh.name=global
+```
+
+Optionally you can create a mesh at install time:
+  
+```sh
+helm upgrade -i appmesh-gateway flagger/appmesh-gateway \
+--namespace flagger-system \
+--set mesh.name=global \
+--set mesh.create=true
+```
+
+The [configuration](#configuration) section lists the parameters that can be configured during installation.
+
+## Uninstalling the Chart
+
+To uninstall/delete the `appmesh-gateway` deployment:
+
+```console
+helm delete --purge appmesh-gateway
+```
+
+The command removes all the Kubernetes components associated with the chart and deletes the release.
+
+## Configuration
+
+The following tables lists the configurable parameters of the chart and their default values.
+
+Parameter | Description | Default
+--- | --- | ---
+`service.type` |  When set to LoadBalancer it creates an AWS NLB | `LoadBalancer`
+`proxy.access_log_path` | to enable the access logs, set it to `/dev/stdout` | `/dev/null`
+`proxy.image.repository` | image repository | `envoyproxy/envoy`
+`proxy.image.tag` | image tag | `<VERSION>`
+`proxy.image.pullPolicy` | image pull policy | `IfNotPresent`
+`controller.image.repository` | image repository | `weaveworks/flagger-appmesh-gateway`
+`controller.image.tag` | image tag | `<VERSION>`
+`controller.image.pullPolicy` | image pull policy | `IfNotPresent`
+`resources.requests/cpu` | pod CPU request | `100m`
+`resources.requests/memory` | pod memory request | `128Mi`
+`resources.limits/memory` | pod memory limit | `2Gi`
+`nodeSelector` | node labels for pod assignment | `{}`
+`tolerations` | list of node taints to tolerate | `[]`
+`rbac.create` | if `true`, create and use RBAC resources | `true`
+`rbac.pspEnabled` | If `true`, create and use a restricted pod security policy | `false`
+`serviceAccount.create` | If `true`, create a new service account | `true`
+`serviceAccount.name` | Service account to be used | None
+`mesh.create` | If `true`, create mesh custom resource | `false`
+`mesh.name` | The name of the mesh to use | `global`
+`mesh.discovery` | The service discovery type to use, can be dns or cloudmap | `dns`
+`hpa.enabled` | `true` if HPA resource should be created, metrics-server is required | `true`
+`hpa.maxReplicas` | number of max replicas | `3`
+`hpa.cpu` |  average total CPU usage per pod (1-100) | `99`
+`hpa.memory` |  average memory usage per pod (100Mi-1Gi) | None
+`discovery.optIn` | `true` if only services with the 'expose' annotation are discoverable | `true`

charts/appmesh-gateway/templates/NOTES.txt

@@ -0,0 +1 @@
+App Mesh Gateway installed!

charts/appmesh-gateway/templates/_helpers.tpl

@@ -0,0 +1,56 @@
+{{/* vim: set filetype=mustache: */}}
+{{/*
+Expand the name of the chart.
+*/}}
+{{- define "appmesh-gateway.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).
+If release name contains chart name it will be used as a full name.
+*/}}
+{{- define "appmesh-gateway.fullname" -}}
+{{- if .Values.fullnameOverride -}}
+{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" -}}
+{{- else -}}
+{{- $name := default .Chart.Name .Values.nameOverride -}}
+{{- if contains $name .Release.Name -}}
+{{- .Release.Name | trunc 63 | trimSuffix "-" -}}
+{{- else -}}
+{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" -}}
+{{- end -}}
+{{- end -}}
+{{- end -}}
+
+{{/*
+Create chart name and version as used by the chart label.
+*/}}
+{{- define "appmesh-gateway.chart" -}}
+{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
+{{- end -}}
+
+{{/*
+Common labels
+*/}}
+{{- define "appmesh-gateway.labels" -}}
+app.kubernetes.io/name: {{ include "appmesh-gateway.name" . }}
+helm.sh/chart: {{ include "appmesh-gateway.chart" . }}
+app.kubernetes.io/instance: {{ .Release.Name }}
+{{- if .Chart.AppVersion }}
+app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
+{{- end }}
+app.kubernetes.io/managed-by: {{ .Release.Service }}
+{{- end -}}
+
+{{/*
+Create the name of the service account to use
+*/}}
+{{- define "appmesh-gateway.serviceAccountName" -}}
+{{- if .Values.serviceAccount.create -}}
+    {{ default (include "appmesh-gateway.fullname" .) .Values.serviceAccount.name }}
+{{- else -}}
+    {{ default "default" .Values.serviceAccount.name }}
+{{- end -}}
+{{- end -}}

charts/appmesh-gateway/templates/account.yaml

@@ -0,0 +1,8 @@
+{{- if .Values.serviceAccount.create }}
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: {{ template "appmesh-gateway.serviceAccountName" . }}
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+{{- end }}

charts/appmesh-gateway/templates/config.yaml

@@ -0,0 +1,41 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+data:
+  envoy.yaml: |-
+    admin:
+      access_log_path: {{ .Values.proxy.access_log_path }}
+      address:
+        socket_address:
+          address: 0.0.0.0
+          port_value: 8081
+
+    dynamic_resources:
+      ads_config:
+        api_type: GRPC
+        grpc_services:
+          - envoy_grpc:
+              cluster_name: xds
+      cds_config:
+        ads: {}
+      lds_config:
+        ads: {}
+
+    static_resources:
+      clusters:
+        - name: xds
+          connect_timeout: 0.50s
+          type: static
+          http2_protocol_options: {}
+          load_assignment:
+            cluster_name: xds
+            endpoints:
+              - lb_endpoints:
+                  - endpoint:
+                      address:
+                        socket_address:
+                          address: 127.0.0.1
+                          port_value: 18000

charts/appmesh-gateway/templates/deployment.yaml

@@ -0,0 +1,144 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  strategy:
+    type: Recreate
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: {{ include "appmesh-gateway.name" . }}
+      app.kubernetes.io/instance: {{ .Release.Name }}
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: {{ include "appmesh-gateway.name" . }}
+        app.kubernetes.io/instance: {{ .Release.Name }}
+        app.kubernetes.io/part-of: appmesh
+      annotations:
+        prometheus.io/scrape: "true"
+        prometheus.io/path: "/stats/prometheus"
+        prometheus.io/port: "8081"
+        # exclude inbound traffic on port 8080
+        appmesh.k8s.aws/ports: "444"
+        # exclude egress traffic to xDS server and Kubernetes API
+        appmesh.k8s.aws/egressIgnoredPorts: "18000,22,443"
+        checksum/config: {{ include (print $.Template.BasePath "/config.yaml") . | sha256sum | quote }}
+    spec:
+      serviceAccountName: {{ include "appmesh-gateway.serviceAccountName" . }}
+      terminationGracePeriodSeconds: 45
+      affinity:
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+            - podAffinityTerm:
+                labelSelector:
+                  matchLabels:
+                    app.kubernetes.io/name: {{ include "appmesh-gateway.name" . }}
+                topologyKey: kubernetes.io/hostname
+              weight: 100
+      volumes:
+      - name: appmesh-gateway-config
+        configMap:
+          name: {{ template "appmesh-gateway.fullname" . }}
+      containers:
+        - name: controller
+          image: "{{ .Values.controller.image.repository }}:{{ .Values.controller.image.tag }}"
+          imagePullPolicy: {{ .Values.controller.image.pullPolicy }}
+          securityContext:
+            readOnlyRootFilesystem: true
+            runAsUser: 10001
+            capabilities:
+              drop:
+                - ALL
+              add:
+                - NET_BIND_SERVICE
+          command:
+            - ./flagger-appmesh-gateway
+            - --opt-in={{ .Values.discovery.optIn }}
+            - --gateway-mesh={{ .Values.mesh.name }}
+            - --gateway-name=$(POD_SERVICE_ACCOUNT)
+            - --gateway-namespace=$(POD_NAMESPACE)
+          env:
+            - name: POD_SERVICE_ACCOUNT
+              valueFrom:
+                fieldRef:
+                  fieldPath: spec.serviceAccountName
+            - name: POD_NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+          ports:
+            - name: grpc
+              containerPort: 18000
+              protocol: TCP
+          livenessProbe:
+            initialDelaySeconds: 5
+            tcpSocket:
+              port: grpc
+          readinessProbe:
+            initialDelaySeconds: 5
+            tcpSocket:
+              port: grpc
+          resources:
+            limits:
+              memory: 1Gi
+            requests:
+              cpu: 10m
+              memory: 32Mi
+        - name: proxy
+          image: "{{ .Values.proxy.image.repository }}:{{ .Values.proxy.image.tag }}"
+          imagePullPolicy: {{ .Values.proxy.image.pullPolicy }}
+          securityContext:
+            capabilities:
+              drop:
+                - ALL
+              add:
+                - NET_BIND_SERVICE
+          args:
+            - -c
+            - /config/envoy.yaml
+            - --service-cluster $(POD_NAMESPACE)
+            - --service-node $(POD_NAME)
+            - --log-level info
+            - --base-id 1234
+          ports:
+            - name: admin
+              containerPort: 8081
+              protocol: TCP
+            - name: http
+              containerPort: 8080
+              protocol: TCP
+          livenessProbe:
+            initialDelaySeconds: 5
+            tcpSocket:
+              port: admin
+          readinessProbe:
+            initialDelaySeconds: 5
+            httpGet:
+              path: /ready
+              port: admin
+          env:
+            - name: POD_NAME
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.name
+            - name: POD_NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+          volumeMounts:
+            - name: appmesh-gateway-config
+              mountPath: /config
+          resources:
+{{ toYaml .Values.resources | indent 12 }}
+    {{- with .Values.nodeSelector }}
+      nodeSelector:
+{{ toYaml . | indent 8 }}
+    {{- end }}
+    {{- with .Values.tolerations }}
+      tolerations:
+{{ toYaml . | indent 8 }}
+    {{- end }}

charts/appmesh-gateway/templates/hpa.yaml

@@ -0,0 +1,28 @@
+{{- if .Values.hpa.enabled }}
+apiVersion: autoscaling/v2beta1
+kind: HorizontalPodAutoscaler
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: {{ template "appmesh-gateway.fullname" . }}
+  minReplicas: {{ .Values.replicaCount }}
+  maxReplicas: {{ .Values.hpa.maxReplicas }}
+  metrics:
+    {{- if .Values.hpa.cpu }}
+    - type: Resource
+      resource:
+        name: cpu
+        targetAverageUtilization: {{ .Values.hpa.cpu }}
+    {{- end }}
+    {{- if .Values.hpa.memory }}
+    - type: Resource
+      resource:
+        name: memory
+        targetAverageValue: {{ .Values.hpa.memory }}
+    {{- end }}
+{{- end }}

charts/appmesh-gateway/templates/mesh.yaml

@@ -0,0 +1,12 @@
+{{- if .Values.mesh.create }}
+apiVersion: appmesh.k8s.aws/v1beta1
+kind: Mesh
+metadata:
+    name: {{ .Values.mesh.name }}
+    annotations:
+        helm.sh/resource-policy: keep
+    labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+spec:
+    serviceDiscoveryType: {{ .Values.mesh.discovery }}
+{{- end }}

charts/appmesh-gateway/templates/psp.yaml

@@ -0,0 +1,57 @@
+{{- if .Values.rbac.pspEnabled }}
+apiVersion: policy/v1beta1
+kind: PodSecurityPolicy
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+  annotations:
+    seccomp.security.alpha.kubernetes.io/allowedProfileNames: '*'
+spec:
+  privileged: false
+  hostIPC: false
+  hostNetwork: false
+  hostPID: false
+  readOnlyRootFilesystem: false
+  allowPrivilegeEscalation: false
+  allowedCapabilities:
+    - '*'
+  fsGroup:
+    rule: RunAsAny
+  runAsUser:
+    rule: RunAsAny
+  seLinux:
+    rule: RunAsAny
+  supplementalGroups:
+    rule: RunAsAny
+  volumes:
+    - '*'
+---
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}-psp
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+rules:
+  - apiGroups: ['policy']
+    resources: ['podsecuritypolicies']
+    verbs:     ['use']
+    resourceNames:
+      - {{ template "appmesh-gateway.fullname" . }}
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}-psp
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: {{ template "appmesh-gateway.fullname" . }}-psp
+subjects:
+  - kind: ServiceAccount
+    name: {{ template "appmesh-gateway.serviceAccountName" . }}
+    namespace: {{ .Release.Namespace }}
+{{- end }}

charts/appmesh-gateway/templates/rbac.yaml

@@ -0,0 +1,39 @@
+{{- if .Values.rbac.create }}
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRole
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+rules:
+  - apiGroups:
+      - ""
+    resources:
+      - services
+    verbs: ["*"]
+  - apiGroups:
+      - appmesh.k8s.aws
+    resources:
+      - meshes
+      - meshes/status
+      - virtualnodes
+      - virtualnodes/status
+      - virtualservices
+      - virtualservices/status
+    verbs: ["*"]
+---
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRoleBinding
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: {{ template "appmesh-gateway.fullname" . }}
+subjects:
+- name: {{ template "appmesh-gateway.serviceAccountName" . }}
+  namespace: {{ .Release.Namespace }}
+  kind: ServiceAccount
+{{- end }}

charts/appmesh-gateway/templates/service.yaml

@@ -0,0 +1,24 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ template "appmesh-gateway.fullname" . }}
+  annotations:
+    gateway.appmesh.k8s.aws/expose: "false"
+    {{- if eq .Values.service.type "LoadBalancer" }}
+    service.beta.kubernetes.io/aws-load-balancer-type: "nlb"
+    {{- end }}
+  labels:
+{{ include "appmesh-gateway.labels" . | indent 4 }}
+spec:
+  type: {{ .Values.service.type }}
+  {{- if eq .Values.service.type "LoadBalancer" }}
+  externalTrafficPolicy: Local
+  {{- end }}
+  ports:
+    - port: {{ .Values.service.port }}
+      targetPort: http
+      protocol: TCP
+      name: http
+  selector:
+    app.kubernetes.io/name: {{ include "appmesh-gateway.name" . }}
+    app.kubernetes.io/instance: {{ .Release.Name }}

charts/appmesh-gateway/values.yaml

@@ -0,0 +1,69 @@
+# Default values for appmesh-gateway.
+# This is a YAML-formatted file.
+# Declare variables to be passed into your templates.
+
+replicaCount: 1
+discovery:
+  # discovery.optIn `true` if only services with the 'expose' annotation are discoverable
+  optIn: true
+
+proxy:
+  access_log_path: /dev/null
+  image:
+    repository: docker.io/envoyproxy/envoy
+    tag: v1.12.0
+    pullPolicy: IfNotPresent
+
+controller:
+  image:
+    repository: weaveworks/flagger-appmesh-gateway
+    tag: v1.1.0
+    pullPolicy: IfNotPresent
+
+nameOverride: ""
+fullnameOverride: ""
+
+service:
+  # service.type: When set to LoadBalancer it creates an AWS NLB
+  type: LoadBalancer
+  port: 80
+
+hpa:
+  # hpa.enabled `true` if HPA resource should be created, metrics-server is required
+  enabled: true
+  maxReplicas: 3
+  # hpa.cpu average total CPU usage per pod (1-100)
+  cpu: 99
+  # hpa.memory average memory usage per pod (100Mi-1Gi)
+  memory:
+
+resources:
+  limits:
+    memory: 2Gi
+  requests:
+    cpu: 100m
+    memory: 128Mi
+
+nodeSelector: {}
+
+tolerations: []
+
+serviceAccount:
+  # serviceAccount.create: Whether to create a service account or not
+  create: true
+  # serviceAccount.name: The name of the service account to create or use
+  name: ""
+
+rbac:
+  # rbac.create: `true` if rbac resources should be created
+  create: true
+  # rbac.pspEnabled: `true` if PodSecurityPolicy resources should be created
+  pspEnabled: false
+
+mesh:
+  # mesh.create: `true` if mesh resource should be created
+  create: false
+  # mesh.name: The name of the mesh to use
+  name: "global"
+  # mesh.discovery: The service discovery type to use, can be dns or cloudmap
+  discovery: dns

charts/flagger/Chart.yaml

@@ -1,21 +1,23 @@
 apiVersion: v1
 name: flagger
-version: 0.20.2
-appVersion: 0.20.2
+version: 0.21.0
+appVersion: 0.21.0
 kubeVersion: ">=1.11.0-0"
 engine: gotpl
-description: Flagger is a Kubernetes operator that automates the promotion of canary deployments using Istio, Linkerd, App Mesh, Gloo or NGINX routing for traffic shifting and Prometheus metrics for canary analysis.
-home: https://docs.flagger.app
-icon: https://raw.githubusercontent.com/weaveworks/flagger/master/docs/logo/flagger-icon.png
+description: Flagger is a progressive delivery operator for Kubernetes
+home: https://flagger.app
+icon: https://raw.githubusercontent.com/weaveworks/flagger/master/docs/logo/weaveworks.png
 sources:
-- https://github.com/weaveworks/flagger
+  - https://github.com/weaveworks/flagger
 maintainers:
-- name: stefanprodan
-  url: https://github.com/stefanprodan
-  email: stefanprodan@users.noreply.github.com
+  - name: stefanprodan
+    url: https://github.com/stefanprodan
+    email: stefanprodan@users.noreply.github.com
 keywords:
-- canary
-- istio
-- appmesh
-- linkerd
-- gitops
+  - flagger
+  - istio
+  - appmesh
+  - linkerd
+  - gloo
+  - gitops
+  - canary

charts/flagger/README.md

@@ -1,7 +1,8 @@
 # Flagger
 
-[Flagger](https://github.com/weaveworks/flagger) is a Kubernetes operator that automates the promotion of 
-canary deployments using Istio, Linkerd, App Mesh, NGINX or Gloo routing for traffic shifting and Prometheus metrics for canary analysis. 
+[Flagger](https://github.com/weaveworks/flagger) is a Kubernetes operator that automates the promotion of canary
+deployments using Istio, Linkerd, App Mesh, NGINX or Gloo routing for traffic shifting and Prometheus metrics for canary analysis. 
+
 Flagger implements a control loop that gradually shifts traffic to the canary while measuring key performance indicators
 like HTTP requests success rate, requests average duration and pods health.
 Based on the KPIs analysis a canary is promoted or aborted and the analysis result is published to Slack or MS Teams.
@@ -45,6 +46,16 @@ $ helm upgrade -i flagger flagger/flagger \
     --set metricsServer=http://linkerd-prometheus:9090
 ```
 
+To install the chart with the release name `flagger` for AWS App Mesh:
+
+```console
+$ helm upgrade -i flagger flagger/flagger \
+    --namespace=appmesh-system \
+    --set crd.create=false \
+    --set meshProvider=appmesh \
+    --set metricsServer=http://appmesh-prometheus:9090
+```
+
 The [configuration](#configuration) section lists the parameters that can be configured during installation.
 
 ## Uninstalling the Chart
@@ -73,6 +84,10 @@ Parameter | Description | Default
 `slack.channel` | Slack channel | None
 `slack.user` | Slack username | `flagger`
 `msteams.url` | Microsoft Teams incoming webhook | None
+`podMonitor.enabled` | if `true`, create a PodMonitor for [monitoring the metrics](https://docs.flagger.app/usage/monitoring#metrics) | `false`
+`podMonitor.namespace` | the namespace where the PodMonitor is created | the same namespace 
+`podMonitor.interval` | interval at which metrics should be scraped | `15s` 
+`podMonitor.podMonitor` | additional labels to add to the PodMonitor | `{}`
 `leaderElection.enabled` | leader election must be enabled when running more than one replica | `false`
 `leaderElection.replicaCount` | number of replicas | `1`
 `ingressAnnotationsPrefix` | annotations prefix for ingresses | `custom.ingress.kubernetes.io`
@@ -91,7 +106,7 @@ Specify each parameter using the `--set key=value[,key=value]` argument to `helm
 
 ```console
 $ helm upgrade -i flagger flagger/flagger \
-  --namespace istio-system \
+  --namespace flagger-system \
   --set crd.create=false \
   --set slack.url=https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK \
   --set slack.channel=general

charts/flagger/templates/podmonitor.yaml

@@ -0,0 +1,27 @@
+{{- if .Values.podMonitor.enabled }}
+apiVersion: monitoring.coreos.com/v1
+kind: PodMonitor
+metadata:
+  labels:
+    helm.sh/chart: {{ template "flagger.chart" . }}
+    app.kubernetes.io/name: {{ template "flagger.name" . }}
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Release.Name }}
+    {{- range $k, $v := .Values.podMonitor.additionalLabels }}
+    {{ $k }}: {{ $v | quote }}
+    {{- end }}
+  name: {{ include "flagger.fullname" . }}
+  namespace: {{ .Values.podMonitor.namespace | default .Release.Namespace }}
+spec:
+  podMetricsEndpoints:
+  - interval: {{ .Values.podMonitor.interval }}
+    path: /metrics
+    port: http
+  namespaceSelector:
+    matchNames:
+    - {{ .Release.Namespace }}
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: {{ template "flagger.name" . }}
+      app.kubernetes.io/instance: {{ .Release.Name }}
+{{- end }}

charts/flagger/templates/rbac.yaml

@@ -77,6 +77,11 @@ rules:
       - virtualservices
       - gateways
     verbs: ["*"]
+  - apiGroups:
+      - projectcontour.io
+    resources:
+      - httpproxies
+    verbs: ["*"]
   - nonResourceURLs:
       - /version
     verbs:

charts/flagger/values.yaml

@@ -2,13 +2,14 @@
 
 image:
   repository: weaveworks/flagger
-  tag: 0.20.2
+  tag: 0.21.0
   pullPolicy: IfNotPresent
   pullSecret:
 
 podAnnotations:
   prometheus.io/scrape: "true"
   prometheus.io/port: "8080"
+  appmesh.k8s.aws/sidecarInjectorWebhook: disabled
 
 metricsServer: "http://prometheus:9090"
 
@@ -32,6 +33,12 @@ msteams:
   # MS Teams incoming webhook URL
   url:
 
+podMonitor:
+  enabled: false
+  namespace:
+  interval: 15s
+  additionalLabels: {}
+
 #env:
 #- name: SLACK_URL
 #  valueFrom:

charts/grafana/Chart.yaml

@@ -1,13 +1,20 @@
 apiVersion: v1
 name: grafana
-version: 1.3.0
-appVersion: 6.2.5
+version: 1.4.0
+appVersion: 6.5.1
 description: Grafana dashboards for monitoring Flagger canary deployments
-icon: https://raw.githubusercontent.com/weaveworks/flagger/master/docs/logo/flagger-icon.png
+icon: https://raw.githubusercontent.com/weaveworks/flagger/master/docs/logo/weaveworks.png
 home: https://flagger.app
 sources:
-- https://github.com/weaveworks/flagger
+  - https://github.com/weaveworks/flagger
 maintainers:
-- name: stefanprodan
-  url: https://github.com/stefanprodan
-  email: stefanprodan@users.noreply.github.com
+  - name: stefanprodan
+    url: https://github.com/stefanprodan
+    email: stefanprodan@users.noreply.github.com
+keywords:
+  - flagger
+  - grafana
+  - canary
+  - istio
+  - appmesh
+

charts/grafana/README.md

@@ -1,13 +1,12 @@
 # Flagger Grafana
 
-Grafana dashboards for monitoring progressive deployments powered by Istio, Prometheus and Flagger.
+Grafana dashboards for monitoring progressive deployments powered by Flagger and Prometheus.
 
 ![flagger-grafana](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/grafana-canary-analysis.png)
 
 ## Prerequisites
 
 * Kubernetes >= 1.11
-* Istio >= 1.0
 * Prometheus >= 2.6
 
 ## Installing the Chart
@@ -18,14 +17,20 @@ Add Flagger Helm repository:
 helm repo add flagger https://flagger.app
 ```
 
-To install the chart with the release name `flagger-grafana`:
+To install the chart for Istio run:
 
 ```console
 helm upgrade -i flagger-grafana flagger/grafana \
 --namespace=istio-system \
---set url=http://prometheus:9090 \
---set user=admin \
---set password=admin
+--set url=http://prometheus:9090
+```
+
+To install the chart for AWS App Mesh run:
+
+```console
+helm upgrade -i flagger-grafana flagger/grafana \
+--namespace=appmesh-system \
+--set url=http://appmesh-prometheus:9090
 ```
 
 The command deploys Grafana on the Kubernetes cluster in the default namespace.
@@ -56,10 +61,7 @@ Parameter | Description | Default
 `affinity` | node/pod affinities | `node`
 `nodeSelector` | node labels for pod assignment | `{}`
 `service.type` | type of service | `ClusterIP`
-`url` | Prometheus URL, used when Weave Cloud token is empty | `http://prometheus:9090`
-`token` | Weave Cloud token | `none`
-`user` | Grafana admin username | `admin`
-`password` | Grafana admin password | `admin`
+`url` | Prometheus URL | `http://prometheus:9090`
 
 Specify each parameter using the `--set key=value[,key=value]` argument to `helm install`. For example,
 

charts/grafana/templates/deployment.yaml

@@ -1,4 +1,4 @@
-apiVersion: apps/v1beta2
+apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: {{ template "grafana.fullname" . }}

charts/grafana/values.yaml

@@ -6,7 +6,7 @@ replicaCount: 1
 
 image:
   repository: grafana/grafana
-  tag: 6.2.5
+  tag: 6.5.1
   pullPolicy: IfNotPresent
 
 podAnnotations: {}

charts/loadtester/Chart.yaml

@@ -1,12 +1,12 @@
 apiVersion: v1
 name: loadtester
-version: 0.11.0
-appVersion: 0.11.0
+version: 0.12.1
+appVersion: 0.12.1
 kubeVersion: ">=1.11.0-0"
 engine: gotpl
 description: Flagger's load testing services based on rakyll/hey and bojand/ghz that generates traffic during canary analysis when configured as a webhook.
 home: https://docs.flagger.app
-icon: https://raw.githubusercontent.com/weaveworks/flagger/master/docs/logo/flagger-icon.png
+icon: https://raw.githubusercontent.com/weaveworks/flagger/master/docs/logo/weaveworks.png
 sources:
   - https://github.com/weaveworks/flagger
 maintainers:
@@ -14,8 +14,10 @@ maintainers:
     url: https://github.com/stefanprodan
     email: stefanprodan@users.noreply.github.com
 keywords:
-  - canary
+  - flagger
   - istio
   - appmesh
+  - linkerd
+  - gloo
   - gitops
   - load testing

charts/loadtester/values.yaml

@@ -2,7 +2,7 @@ replicaCount: 1
 
 image:
   repository: weaveworks/flagger-loadtester
-  tag: 0.11.0
+  tag: 0.12.1
   pullPolicy: IfNotPresent
 
 podAnnotations:

charts/podinfo/Chart.yaml

@@ -3,10 +3,12 @@ version: 3.1.0
 appVersion: 3.1.0
 name: podinfo
 engine: gotpl
-description: Flagger canary deployment demo chart
-home: https://flagger.app
-maintainers:
-- email: stefanprodan@users.noreply.github.com
-  name: stefanprodan
+description: Flagger canary deployment demo application
+home: https://docs.flagger.app
+icon: https://raw.githubusercontent.com/weaveworks/flagger/master/docs/logo/weaveworks.png
 sources:
-- https://github.com/weaveworks/flagger
+  - https://github.com/stefanprodan/podinfo
+maintainers:
+  - name: stefanprodan
+    url: https://github.com/stefanprodan
+    email: stefanprodan@users.noreply.github.com

cmd/flagger/main.go

@@ -10,16 +10,6 @@ import (
 	"time"
 
 	"github.com/Masterminds/semver"
-	clientset "github.com/weaveworks/flagger/pkg/client/clientset/versioned"
-	informers "github.com/weaveworks/flagger/pkg/client/informers/externalversions"
-	"github.com/weaveworks/flagger/pkg/controller"
-	"github.com/weaveworks/flagger/pkg/logger"
-	"github.com/weaveworks/flagger/pkg/metrics"
-	"github.com/weaveworks/flagger/pkg/notifier"
-	"github.com/weaveworks/flagger/pkg/router"
-	"github.com/weaveworks/flagger/pkg/server"
-	"github.com/weaveworks/flagger/pkg/signals"
-	"github.com/weaveworks/flagger/pkg/version"
 	"go.uber.org/zap"
 	"k8s.io/apimachinery/pkg/util/uuid"
 	"k8s.io/client-go/kubernetes"
@@ -30,6 +20,18 @@ import (
 	"k8s.io/client-go/tools/leaderelection/resourcelock"
 	"k8s.io/client-go/transport"
 	_ "k8s.io/code-generator/cmd/client-gen/generators"
+
+	"github.com/weaveworks/flagger/pkg/canary"
+	clientset "github.com/weaveworks/flagger/pkg/client/clientset/versioned"
+	informers "github.com/weaveworks/flagger/pkg/client/informers/externalversions"
+	"github.com/weaveworks/flagger/pkg/controller"
+	"github.com/weaveworks/flagger/pkg/logger"
+	"github.com/weaveworks/flagger/pkg/metrics"
+	"github.com/weaveworks/flagger/pkg/notifier"
+	"github.com/weaveworks/flagger/pkg/router"
+	"github.com/weaveworks/flagger/pkg/server"
+	"github.com/weaveworks/flagger/pkg/signals"
+	"github.com/weaveworks/flagger/pkg/version"
 )
 
 var (
@@ -159,7 +161,7 @@ func main() {
 		logger.Infof("Watching namespace %s", namespace)
 	}
 
-	observerFactory, err := metrics.NewFactory(metricsServer, meshProvider, 5*time.Second)
+	observerFactory, err := metrics.NewFactory(metricsServer, 5*time.Second)
 	if err != nil {
 		logger.Fatalf("Error building prometheus client: %s", err.Error())
 	}
@@ -178,6 +180,12 @@ func main() {
 	go server.ListenAndServe(port, 3*time.Second, logger, stopCh)
 
 	routerFactory := router.NewFactory(cfg, kubeClient, flaggerClient, ingressAnnotationsPrefix, logger, meshClient)
+	configTracker := canary.ConfigTracker{
+		Logger:        logger,
+		KubeClient:    kubeClient,
+		FlaggerClient: flaggerClient,
+	}
+	canaryFactory := canary.NewFactory(kubeClient, flaggerClient, configTracker, labels, logger)
 
 	c := controller.NewController(
 		kubeClient,
@@ -187,11 +195,11 @@ func main() {
 		controlLoopInterval,
 		logger,
 		notifierClient,
+		canaryFactory,
 		routerFactory,
 		observerFactory,
 		meshProvider,
 		version.VERSION,
-		labels,
 	)
 
 	flaggerInformerFactory.Start(stopCh)

cmd/loadtester/main.go

@@ -10,7 +10,7 @@ import (
 	"time"
 )
 
-var VERSION = "0.11.0"
+var VERSION = "0.12.1"
 var (
 	logLevel          string
 	port              string

docs/gitbook/README.md

@@ -5,7 +5,7 @@ description: Flagger is a progressive delivery Kubernetes operator
 # Introduction
 
 [Flagger](https://github.com/weaveworks/flagger) is a **Kubernetes** operator that automates the promotion of canary 
-deployments using **Istio**, **Linkerd**, **App Mesh**, **NGINX** or **Gloo** routing for traffic shifting and **Prometheus** metrics for canary analysis.
+deployments using **Istio**, **Linkerd**, **App Mesh**, **NGINX**, **Contour** or **Gloo** routing for traffic shifting and **Prometheus** metrics for canary analysis.
 The canary analysis can be extended with webhooks for running system integration/acceptance tests, load tests, or any other custom validation.
 
 Flagger implements a control loop that gradually shifts traffic to the canary while measuring key performance 
@@ -16,7 +16,7 @@ Based on analysis of the **KPIs** a canary is promoted or aborted, and the analy
 
 Flagger can be configured with Kubernetes custom resources and is compatible with 
 any CI/CD solutions made for Kubernetes. Since Flagger is declarative and reacts to Kubernetes events, 
-it can be used in **GitOps** pipelines together with Weave Flux or JenkinsX.
+it can be used in **GitOps** pipelines together with Flux CD or JenkinsX.
 
 This project is sponsored by [Weaveworks](https://www.weave.works/)
 

docs/gitbook/SUMMARY.md

@@ -19,6 +19,8 @@
 * [App Mesh Canary Deployments](usage/appmesh-progressive-delivery.md)
 * [NGINX Canary Deployments](usage/nginx-progressive-delivery.md)
 * [Gloo Canary Deployments](usage/gloo-progressive-delivery.md)
+* [Contour Canary Deployments](usage/contour-progressive-delivery.md)
+* [Crossover Canary Deployments](usage/crossover-progressive-delivery.md)
 * [Blue/Green Deployments](usage/blue-green.md)
 * [Monitoring](usage/monitoring.md)
 * [Alerting](usage/alerting.md)

docs/gitbook/faq.md

@@ -6,13 +6,13 @@
 
 Flagger can run automated application analysis, promotion and rollback for the following deployment strategies:
 * Canary (progressive traffic shifting)
-    * Istio, Linkerd, App Mesh, NGINX, Gloo
+    * Istio, Linkerd, App Mesh, NGINX, Contour, Gloo
 * Canary (traffic mirroring)
     * Istio
 * A/B Testing (HTTP headers and cookies traffic routing)
-    * Istio, App Mesh, NGINX
+    * Istio, App Mesh, NGINX, Contour
 * Blue/Green (traffic switch)
-    * Kubernetes CNI, Istio, Linkerd, App Mesh, NGINX, Gloo
+    * Kubernetes CNI, Istio, Linkerd, App Mesh, NGINX, Contour, Gloo
 
 For Canary deployments and A/B testing you'll need a Layer 7 traffic management solution like a service mesh or an ingress controller.
 For Blue/Green deployments no service mesh or ingress controller is required.
@@ -58,6 +58,21 @@ App Mesh example:
 
 Note that App Mesh supports a single condition.
 
+Contour example:
+
+```yaml
+  canaryAnalysis:
+    interval: 1m
+    threshold: 10
+    iterations: 2
+    match:
+      - headers:
+          user-agent:
+            prefix: "Chrome"
+```
+
+Note that Contour does not support regex, you can use prefix, suffix or exact.
+
 NGINX example:
 
 ```yaml

docs/gitbook/how-it-works.md

@@ -386,7 +386,7 @@ sum(
 )
 ```
 
-Envoy query (App Mesh or Gloo):
+Envoy query (App Mesh, Contour or Gloo):
 
 ```javascript
 sum(
@@ -439,7 +439,7 @@ histogram_quantile(0.99,
 )
 ```
 
-Envoy query (App Mesh or Gloo):
+Envoy query (App Mesh, Contour or Gloo):
 
 ```javascript
 histogram_quantile(0.99, 

docs/gitbook/install/flagger-install-on-eks-appmesh.md

@@ -12,7 +12,7 @@ The App Mesh integration with EKS is made out of the following components:
     * `virtualservice.appmesh.k8s.aws` defines the routing rules for a workload inside the mesh
 * CRD controller - keeps the custom resources in sync with the App Mesh control plane
 * Admission controller - injects the Envoy sidecar and assigns Kubernetes pods to App Mesh virtual nodes
-* Metrics server - Prometheus instance that collects and stores Envoy's metrics
+* Telemetry service - Prometheus instance that collects and stores Envoy's metrics
 
 ### Create a Kubernetes cluster
 
@@ -79,7 +79,8 @@ Install the Horizontal Pod Autoscaler (HPA) metrics provider:
 
 ```bash
 helm upgrade -i metrics-server stable/metrics-server \
---namespace kube-system
+--namespace kube-system \
+--set args[0]=--kubelet-preferred-address-types=InternalIP
 ```
 
 After a minute, the metrics API should report CPU and memory usage for pods.
@@ -100,7 +101,7 @@ kubectl create ns appmesh-system
 Apply the App Mesh CRDs:
 
 ```sh
-kubectl apply -f https://raw.githubusercontent.com/aws/eks-charts/master/stable/appmesh-controller/crds/crds.yaml
+kubectl apply -k github.com/aws/eks-charts/stable/appmesh-controller//crds
 ```
 
 Add the EKS repository to Helm:
@@ -113,10 +114,10 @@ Install the App Mesh CRD controller:
 
 ```sh
 helm upgrade -i appmesh-controller eks/appmesh-controller \
---wait --namespace appmesh-system --version 0.2.0
+--wait --namespace appmesh-system
 ```
 
-Install the App Mesh admission controller:
+Install the App Mesh admission controller and create a mesh called `global`:
 
 ```sh
 helm upgrade -i appmesh-inject eks/appmesh-inject \

docs/gitbook/install/flagger-install-on-kubernetes.md

@@ -43,6 +43,16 @@ helm upgrade -i flagger flagger/flagger \
 --set metricsServer=http://linkerd-prometheus:9090
 ```
 
+Deploy Flagger for App Mesh:
+
+```bash
+helm upgrade -i flagger flagger/flagger \
+--namespace=appmesh-system \
+--set crd.create=false \
+--set meshProvider=appmesh \
+--set metricsServer=http://appmesh-prometheus:9090
+```
+
 You can install Flagger in any namespace as long as it can talk to the Prometheus service on port 9090.
 
 Enable **Slack** notifications:
@@ -159,7 +169,7 @@ Install Flagger for AWS App Mesh:
 kubectl apply -k github.com/weaveworks/flagger//kustomize/appmesh
 ```
 
-This deploys Flagger and Prometheus (configured to scrape the App Mesh Envoy sidecars) in the `appmesh-system` namespace.
+This deploys Flagger and sets the metrics server URL to App Mesh's Prometheus instance.
 
 Install Flagger for Linkerd:
 

docs/gitbook/tutorials/zero-downtime-deployments.md

@@ -27,7 +27,7 @@ You application should expose a HTTP endpoint that Kubernetes can call to determ
 your app transitioned to a broken state from which it can't recover and needs to be restarted.
 
 ```yaml
-readinessProbe:
+livenessProbe:
   exec:
     command:
     - wget
@@ -49,7 +49,7 @@ You application should expose a HTTP endpoint that Kubernetes can call to determ
 your app is ready to receive traffic.
 
 ```yaml
-livenessProbe:
+readinessProbe:
   exec:
     command:
     - wget

docs/gitbook/usage/appmesh-progressive-delivery.md

@@ -14,22 +14,33 @@ The only App Mesh object you need to create by yourself is the mesh resource.
 Create a mesh called `global`:
 
 ```bash
-export REPO=https://raw.githubusercontent.com/weaveworks/flagger/master
-
-kubectl apply -f ${REPO}/artifacts/appmesh/global-mesh.yaml
+cat << EOF | kubectl apply -f -
+apiVersion: appmesh.k8s.aws/v1beta1
+kind: Mesh
+metadata:
+  name: global
+spec:
+  serviceDiscoveryType: dns
+EOF
 ```
 
 Create a test namespace with App Mesh sidecar injection enabled:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/namespaces/test.yaml
+cat << EOF | kubectl apply -f -
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: test
+  labels:
+    appmesh.k8s.aws/sidecarInjectorWebhook: enabled
+EOF
 ```
 
 Create a deployment and a horizontal pod autoscaler:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/appmesh/deployment.yaml
-kubectl apply -f ${REPO}/artifacts/appmesh/hpa.yaml
+kubectl apply -k github.com/weaveworks/flagger//kustomize/podinfo
 ```
 
 Deploy the load testing service to generate traffic during the canary analysis:
@@ -72,20 +83,25 @@ spec:
     portName: http
     # App Mesh reference
     meshName: global
+    # App Mesh ingress (optional)
+    hosts:
+      - "*"
+    # App Mesh ingress timeout (optional)
+    timeout: 5s
     # App Mesh egress (optional) 
     backends:
       - backend.test
     # App Mesh retry policy (optional)
     retries:
       attempts: 3
-      perTryTimeout: 1s
+      perTryTimeout: 5s
       retryOn: "gateway-error,client-error,stream-error"
   # define the canary analysis timing and KPIs
   canaryAnalysis:
     # schedule interval (default 60s)
-    interval: 10s
+    interval: 1m
     # max number of failed metric checks before rollback
-    threshold: 10
+    threshold: 5
     # max traffic percentage routed to canary
     # percentage (0-100)
     maxWeight: 50
@@ -166,37 +182,42 @@ The App Mesh specific settings are:
 App Mesh blocks all egress traffic by default. If your application needs to call another service, you have to create an
 App Mesh virtual service for it and add the virtual service name to the backend list.
 
-### Setup App Mesh ingress (optional)
+### Setup App Mesh Gateway (optional)
 
-In order to expose the podinfo app outside the mesh you'll be using an Envoy ingress and an AWS classic load balancer.
-The ingress binds to an internet domain and forwards the calls into the mesh through the App Mesh sidecar.
-If podinfo becomes unavailable due to a HPA downscaling or a node restart,
-the ingress will retry the calls for a short period of time.
+In order to expose the podinfo app outside the mesh you'll be using an Envoy-powered ingress gateway and an AWS network load balancer.
+The gateway binds to an internet domain and forwards the calls into the mesh through the App Mesh sidecar.
+If podinfo becomes unavailable due to a cluster downscaling or a node restart,
+the gateway will retry the calls for a short period of time.
 
-Deploy the ingress and the AWS ELB service:
+Deploy the gateway behind an AWS NLB:
 
 ```bash
-kubectl apply -f ${REPO}/artifacts/appmesh/ingress.yaml
+helm upgrade -i appmesh-gateway flagger/appmesh-gateway \
+--namespace test \
+--set mesh.name=global
 ```
 
-Find the ingress public address:
+Find the gateway public address:
 
 ```bash
-kubectl -n test describe svc/ingress | grep Ingress
-
-LoadBalancer Ingress:     yyy-xx.us-west-2.elb.amazonaws.com
+export URL="http://$(kubectl -n test get svc/appmesh-gateway -ojson | jq -r ".status.loadBalancer.ingress[].hostname")"
+echo $URL
 ```
 
-Wait for the ELB to become active:
+Wait for the NLB to become active:
 
 ```bash
- watch curl -sS ${INGRESS_URL}
+ watch curl -sS $URL
 ```
 
 Open your browser and navigate to the ingress address to access podinfo UI.
 
 ### Automated canary promotion
 
+A canary deployment is triggered by changes in any of the following objects:
+* Deployment PodSpec (container image, command, ports, env, resources, etc)
+* ConfigMaps and Secrets mounted as volumes or mapped to environment variables
+
 Trigger a canary deployment by updating the container image:
 
 ```bash
@@ -237,11 +258,6 @@ When the canary analysis starts, Flagger will call the pre-rollout webhooks befo
 
 **Note** that if you apply new changes to the deployment during the canary analysis, Flagger will restart the analysis.
 
-A canary deployment is triggered by changes in any of the following objects:
-* Deployment PodSpec (container image, command, ports, env, resources, etc)
-* ConfigMaps mounted as volumes or mapped to environment variables
-* Secrets mounted as volumes or mapped to environment variables
-
 During the analysis the canary’s progress can be monitored with Grafana. The App Mesh dashboard URL is 
 http://localhost:3000/d/flagger-appmesh/appmesh-canary?refresh=10s&orgId=1&var-namespace=test&var-primary=podinfo-primary&var-canary=podinfo
 
@@ -264,7 +280,7 @@ If you’ve enabled the Slack notifications, you should receive the following me
 
 ### Automated rollback
 
-During the canary analysis you can generate HTTP 500 errors to test if Flagger pauses the rollout.
+During the canary analysis you can generate HTTP 500 errors or high latency to test if Flagger pauses the rollout.
 
 Trigger a canary deployment:
 
@@ -295,25 +311,20 @@ When the number of failed checks reaches the canary analysis threshold, the traf
 the canary is scaled to zero and the rollout is marked as failed.
 
 ```text
-kubectl -n test describe canary/podinfo
+kubectl -n appmesh-system logs deploy/flagger -f | jq .msg
 
-Status:
-  Canary Weight:         0
-  Failed Checks:         5
-  Phase:                 Failed
-Events:
- Starting canary analysis for podinfo.test
- Pre-rollout check acceptance-test passed
- Advance podinfo.test canary weight 5
- Advance podinfo.test canary weight 10
- Advance podinfo.test canary weight 15
- Halt podinfo.test advancement success rate 69.17% < 99%
- Halt podinfo.test advancement success rate 61.39% < 99%
- Halt podinfo.test advancement success rate 55.06% < 99%
- Halt podinfo.test advancement request duration 1.20s > 0.5s
- Halt podinfo.test advancement request duration 1.45s > 0.5s
- Rolling back podinfo.test failed checks threshold reached 5
- Canary failed! Scaling down podinfo.test
+New revision detected! Starting canary analysis for podinfo.test
+Pre-rollout check acceptance-test passed
+Advance podinfo.test canary weight 5
+Advance podinfo.test canary weight 10
+Advance podinfo.test canary weight 15
+Halt podinfo.test advancement success rate 69.17% < 99%
+Halt podinfo.test advancement success rate 61.39% < 99%
+Halt podinfo.test advancement success rate 55.06% < 99%
+Halt podinfo.test advancement request duration 1.20s > 0.5s
+Halt podinfo.test advancement request duration 1.45s > 0.5s
+Rolling back podinfo.test failed checks threshold reached 5
+Canary failed! Scaling down podinfo.test
 ```
 
 If you’ve enabled the Slack notifications, you’ll receive a message if the progress deadline is exceeded, 
@@ -334,7 +345,7 @@ Edit the canary analysis, remove the max/step weight and add the match condition
 ```yaml
   canaryAnalysis:
     interval: 1m
-    threshold: 10
+    threshold: 5
     iterations: 10
     match:
     - headers:

docs/gitbook/usage/contour-progressive-delivery.md

@@ -0,0 +1,434 @@
+# Contour Canary Deployments
+
+This guide shows you how to use [Contour](https://projectcontour.io/) ingress controller and Flagger to automate canary releases and A/B testing. 
+
+![Flagger Contour Overview](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/diagrams/flagger-contour-overview.png)
+
+### Prerequisites
+
+Flagger requires a Kubernetes cluster **v1.11** or newer and Contour **v1.0** or newer.
+
+Install Contour on a cluster with LoadBalancer support:
+
+```bash
+kubectl apply -f https://projectcontour.io/quickstart/contour.yaml
+```
+
+The above command will deploy Contour and an Envoy daemonset in the `projectcontour` namespace.
+
+Find the external address of Contour's Envoy load balancer:
+
+```bash
+export ADDRESS="$(kubectl -n projectcontour get svc/envoy -ojson \
+| jq -r ".status.loadBalancer.ingress[].hostname")"
+echo $ADDRESS
+```
+
+Configure your DNS server with a CNAME record (AWS) or A record (GKE) and point a domain e.g. `app.example.com` to the LB address.
+
+Install Flagger using Kustomize (kubectl 1.14) in the `projectcontour` namespace:
+
+```bash
+kubectl apply -k github.com/weaveworks/flagger//kustomize/contour
+```
+
+The above command will deploy Flagger and Prometheus configured to scrape the Contour's Envoy instances.
+You can also enable Slack or MS Teams notifications,
+see the Kustomize install [docs](https://docs.flagger.app/install/flagger-install-on-kubernetes#install-flagger-with-kustomize).
+
+Or you can install Flagger using Helm:
+
+```sh
+helm repo add flagger https://flagger.app
+
+helm upgrade -i flagger flagger/flagger \
+--namespace projectcontour \
+--set meshProvider=contour \
+--set prometheus.install=true \
+--set slack.url=https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK \
+--set slack.channel=general \
+--set slack.user=flagger
+```
+
+### Bootstrap
+
+Flagger takes a Kubernetes deployment and optionally a horizontal pod autoscaler (HPA), 
+then creates a series of objects (Kubernetes deployments, ClusterIP services and Contour HTTPProxy). 
+These objects expose the application in the cluster and drive the canary analysis and promotion.
+
+Create a test namespace:
+
+```bash
+kubectl create ns test
+```
+
+Install the load testing service to generate traffic during the canary analysis:
+
+```bash
+kubectl apply -k github.com/weaveworks/flagger//kustomize/tester
+```
+
+Create a deployment and a horizontal pod autoscaler:
+
+```bash
+kubectl apply -k github.com/weaveworks/flagger//kustomize/podinfo
+```
+
+Create a canary custom resource (replace `app.example.com` with your own domain):
+
+```yaml
+apiVersion: flagger.app/v1alpha3
+kind: Canary
+metadata:
+  name: podinfo
+  namespace: test
+spec:
+  # deployment reference
+  targetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: podinfo
+  # HPA reference
+  autoscalerRef:
+    apiVersion: autoscaling/v2beta1
+    kind: HorizontalPodAutoscaler
+    name: podinfo
+  service:
+    # service port
+    port: 80
+    # container port
+    targetPort: 9898
+    # Contour request timeout
+    timeout: 15s
+    # Contour retry policy
+    retries:
+      attempts: 3
+      perTryTimeout: 5s
+  # define the canary analysis timing and KPIs
+  canaryAnalysis:
+    # schedule interval (default 60s)
+    interval: 30s
+    # 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
+    # Contour Prometheus checks
+    metrics:
+    - name: request-success-rate
+      # minimum req success rate (non 5xx responses)
+      # percentage (0-100)
+      threshold: 99
+      interval: 1m
+    - name: request-duration
+      # maximum req duration P99 in milliseconds
+      threshold: 500
+      interval: 30s
+    # testing
+    webhooks:
+    - name: acceptance-test
+      type: pre-rollout
+      url: http://flagger-loadtester.test/
+      timeout: 30s
+      metadata:
+        type: bash
+        cmd: "curl -sd 'test' http://podinfo-canary.test/token | grep token"
+    - name: load-test
+      url: http://flagger-loadtester.test/
+      type: rollout
+      timeout: 5s
+      metadata:
+        cmd: "hey -z 1m -q 10 -c 2 -host app.example.com http://envoy.projectcontour"
+```
+
+Save the above resource as podinfo-canary.yaml and then apply it:
+
+```bash
+kubectl apply -f ./podinfo-canary.yaml
+```
+
+The canary analysis will run for five minutes while validating the HTTP metrics and rollout hooks every half a minute.
+
+After a couple of seconds Flagger will create the canary objects:
+
+```bash
+# 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
+httpproxy.projectcontour.io/podinfo
+```
+
+After the boostrap, the podinfo deployment will be scaled to zero and the traffic to `podinfo.test` will be routed
+to the primary pods. During the canary analysis, the `podinfo-canary.test` address can be used to target directly the canary pods.
+
+### Expose the app outside the cluster
+
+Create a HTTPProxy definition and include the podinfo proxy generated by Flagger (replace `app.example.com` with your own domain):
+
+```yaml
+apiVersion: projectcontour.io/v1
+kind: HTTPProxy
+metadata:
+  name: podinfo-ingress
+  namespace: test
+spec:
+  virtualhost:
+    fqdn: app.example.com
+  includes:
+    - name: podinfo
+      namespace: test
+      conditions:
+        - prefix: /
+```
+
+Save the above resource as podinfo-ingress.yaml and then apply it:
+
+```bash
+kubectl apply -f ./podinfo-ingress.yaml
+```
+
+Verify that Contour processed the proxy definition with:
+
+```sh
+kubectl -n test get httpproxies
+
+NAME              FQDN                STATUS
+podinfo                               valid
+podinfo-ingress   app.example.com     valid
+```
+
+Now you can access podinfo UI using your domain address.
+
+Note that you should be using HTTPS when exposing production workloads on internet.
+You can obtain free TLS certs from Let's Encrypt, read this [guide](https://github.com/stefanprodan/eks-envoy-ingress)
+on how to configure cert-manager to secure Contour with TLS certificates.
+
+### Automated canary promotion
+
+Flagger implements a control loop that gradually shifts traffic to the canary while measuring key performance indicators
+like HTTP requests success rate, requests average duration and pod health.
+Based on analysis of the KPIs a canary is promoted or aborted.
+
+![Flagger Canary Stages](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/diagrams/flagger-canary-steps.png)
+
+A canary deployment is triggered by changes in any of the following objects:
+* Deployment PodSpec (container image, command, ports, env, resources, etc)
+* ConfigMaps and Secrets mounted as volumes or mapped to environment variables
+
+Trigger a canary deployment by updating the container image:
+
+```bash
+kubectl -n test set image deployment/podinfo \
+podinfod=stefanprodan/podinfo:3.1.1
+```
+
+Flagger detects that the deployment revision changed and starts a new rollout:
+
+```text
+kubectl -n test describe canary/podinfo
+
+Status:
+  Canary Weight:         0
+  Failed Checks:         0
+  Phase:                 Succeeded
+Events:
+ New revision detected! Scaling up podinfo.test
+ Waiting for podinfo.test rollout to finish: 0 of 1 updated replicas are available
+ Pre-rollout check acceptance-test passed
+ Advance podinfo.test canary weight 5
+ Advance podinfo.test canary weight 10
+ Advance podinfo.test canary weight 15
+ Advance podinfo.test canary weight 20
+ Advance podinfo.test canary weight 25
+ Advance podinfo.test canary weight 30
+ Advance podinfo.test canary weight 35
+ Advance podinfo.test canary weight 40
+ Advance podinfo.test canary weight 45
+ Advance podinfo.test canary weight 50
+ Copying podinfo.test template spec to podinfo-primary.test
+ Waiting for podinfo-primary.test rollout to finish: 1 of 2 updated replicas are available
+ Routing all traffic to primary
+ Promotion completed! Scaling down podinfo.test
+```
+
+When the canary analysis starts, Flagger will call the pre-rollout webhooks before routing traffic to the canary.
+
+**Note** that if you apply new changes to the deployment during the canary analysis, Flagger will restart the analysis.
+
+You can monitor all canaries with:
+
+```bash
+watch kubectl get canaries --all-namespaces
+
+NAMESPACE   NAME      STATUS        WEIGHT   LASTTRANSITIONTIME
+test        podinfo   Progressing   15       2019-12-20T14:05:07Z
+```
+
+If you’ve enabled the Slack notifications, you should receive the following messages:
+
+![Flagger Slack Notifications](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/slack-canary-notifications.png)
+
+### Automated rollback
+
+During the canary analysis you can generate HTTP 500 errors or high latency to test if Flagger pauses the rollout.
+
+Trigger a canary deployment:
+
+```bash
+kubectl -n test set image deployment/podinfo \
+podinfod=stefanprodan/podinfo:3.1.2
+```
+
+Exec into the load tester pod with:
+
+```bash
+kubectl -n test exec -it deploy/flagger-loadtester bash
+```
+
+Generate HTTP 500 errors:
+
+```bash
+hey -z 1m -c 5 -q 5 http://app.example.com/status/500
+```
+
+Generate latency:
+
+```bash
+watch -n 1 curl http://app.example.com/delay/1
+```
+
+When the number of failed checks reaches the canary analysis threshold, the traffic is routed back to the primary, 
+the canary is scaled to zero and the rollout is marked as failed.
+
+```text
+kubectl -n projectcontour logs deploy/flagger -f | jq .msg
+
+New revision detected! Starting canary analysis for podinfo.test
+Pre-rollout check acceptance-test passed
+Advance podinfo.test canary weight 5
+Advance podinfo.test canary weight 10
+Advance podinfo.test canary weight 15
+Halt podinfo.test advancement success rate 69.17% < 99%
+Halt podinfo.test advancement success rate 61.39% < 99%
+Halt podinfo.test advancement success rate 55.06% < 99%
+Halt podinfo.test advancement request duration 1.20s > 500ms
+Halt podinfo.test advancement request duration 1.45s > 500ms
+Rolling back podinfo.test failed checks threshold reached 5
+Canary failed! Scaling down podinfo.test
+```
+
+If you’ve enabled the Slack notifications, you’ll receive a message if the progress deadline is exceeded, 
+or if the analysis reached the maximum number of failed checks:
+
+![Flagger Slack Notifications](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/slack-canary-failed.png)
+
+### A/B Testing 
+
+Besides weighted routing, Flagger can be configured to route traffic to the canary based on HTTP match conditions.
+In an A/B testing scenario, you'll be using HTTP headers or cookies to target a certain segment of your users.
+This is particularly useful for frontend applications that require session affinity.
+
+![Flagger A/B Testing Stages](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/diagrams/flagger-abtest-steps.png)
+
+Edit the canary analysis, remove the max/step weight and add the match conditions and iterations:
+
+```yaml
+canaryAnalysis:
+  interval: 1m
+  threshold: 5
+  iterations: 10
+  match:
+  - headers:
+      x-canary:
+        exact: "insider"
+  webhooks:
+  - name: load-test
+    url: http://flagger-loadtester.test/
+    metadata:
+      cmd: "hey -z 1m -q 5 -c 5 -H 'X-Canary: insider' -host app.example.com http://envoy.projectcontour"
+```
+
+The above configuration will run an analysis for ten minutes targeting users that have a `X-Canary: insider` header.
+
+You can also use a HTTP cookie. To target all users with a cookie set to `insider`, the match condition should be:
+
+```yaml
+match:
+- headers:
+    cookie:
+      suffix: "insider"
+webhooks:
+- name: load-test
+  url: http://flagger-loadtester.test/
+  metadata:
+    cmd: "hey -z 1m -q 5 -c 5 -H 'Cookie: canary=insider' -host app.example.com http://envoy.projectcontour"
+```
+
+Trigger a canary deployment by updating the container image:
+
+```bash
+kubectl -n test set image deployment/podinfo \
+podinfod=stefanprodan/podinfo:3.1.3
+```
+
+Flagger detects that the deployment revision changed and starts the A/B test:
+
+```text
+kubectl -n appmesh-system logs deploy/flagger -f | jq .msg
+
+New revision detected! Starting canary analysis for podinfo.test
+Advance podinfo.test canary iteration 1/10
+Advance podinfo.test canary iteration 2/10
+Advance podinfo.test canary iteration 3/10
+Advance podinfo.test canary iteration 4/10
+Advance podinfo.test canary iteration 5/10
+Advance podinfo.test canary iteration 6/10
+Advance podinfo.test canary iteration 7/10
+Advance podinfo.test canary iteration 8/10
+Advance podinfo.test canary iteration 9/10
+Advance podinfo.test canary iteration 10/10
+Copying podinfo.test template spec to podinfo-primary.test
+Waiting for podinfo-primary.test rollout to finish: 1 of 2 updated replicas are available
+Routing all traffic to primary
+Promotion completed! Scaling down podinfo.test
+```
+
+The web browser user agent header allows user segmentation based on device or OS.
+
+For example, if you want to route all mobile users to the canary instance:
+
+```yaml
+match:
+- headers:
+    user-agent:
+      prefix: "Mobile"
+```
+
+Or if you want to target only Android users:
+
+```yaml
+match:
+- headers:
+    user-agent:
+      prefix: "Android"
+```
+
+Or a specific browser version:
+
+```yaml
+match:
+- headers:
+    user-agent:
+      suffix: "Firefox/71.0"
+```

docs/gitbook/usage/crossover-progressive-delivery.md

@@ -0,0 +1,319 @@
+# Envoy/Crossover Canary Deployments
+
+This guide shows you how to use Envoy, [Crossover](https://github.com/mumoshu/crossover) and Flagger to automate canary deployments.
+
+Crossover is a minimal Envoy xDS implementation supports [Service Mesh Interface](https://smi-spec.io/).
+
+### Prerequisites
+
+Flagger requires a Kubernetes cluster **v1.11** or newer and Envoy paired with [Crossover](https://github.com/mumoshu/crossover) sidecar.
+
+Create a test namespace:
+
+```bash
+kubectl create ns test
+```
+
+Install Envoy along with the Crossover sidecar with Helm:
+
+```bash
+helm repo add crossover https://mumoshu.github.io/crossover
+
+helm upgrade --install envoy crossover/envoy \
+  --namespace test \
+  -f <(cat <<EOF
+smi:
+  apiVersions:
+    trafficSplits: v1alpha1
+upstreams:
+  podinfo:
+    smi:
+      enabled: true
+    backends:
+      podinfo-primary:
+        port: 9898
+        weight: 100
+      podinfo-canary:
+        port: 9898
+        weight: 0
+EOF
+)
+```
+
+Install Flagger and the Prometheus add-on in the same namespace as Envoy:
+
+```bash
+helm repo add flagger https://flagger.app
+
+helm upgrade -i flagger flagger/flagger \
+--namespace test \
+--set prometheus.install=true \
+--set meshProvider=smi:crossover
+```
+
+Optionally you can enable Slack notifications:
+
+```bash
+helm upgrade -i flagger flagger/flagger \
+--reuse-values \
+--namespace test \
+--set slack.url=https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK \
+--set slack.channel=general \
+--set slack.user=flagger
+```
+
+### Bootstrap
+
+Flagger takes a Kubernetes deployment and optionally a horizontal pod autoscaler (HPA), 
+then creates a series of objects (Kubernetes deployments, ClusterIP services, SMI traffic splits). 
+These objects expose the application on the mesh and drive the canary analysis and promotion.
+There's no SMI object you need to create by yourself.
+
+Create a deployment and a horizontal pod autoscaler:
+
+```bash
+kubectl apply -k github.com/weaveworks/flagger//kustomize/podinfo
+```
+
+Deploy the load testing service to generate traffic during the canary analysis:
+
+```bash
+helm upgrade -i flagger-loadtester flagger/loadtester \
+--namespace=test
+```
+
+Create a canary custom resource:
+
+```yaml
+apiVersion: flagger.app/v1alpha3
+kind: Canary
+metadata:
+  name: podinfo
+  namespace: test
+spec:
+  # specify mesh provider if it isn't the default one
+  # provider: "smi:crossover"
+  # deployment reference
+  targetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: podinfo
+  # the maximum time in seconds for the canary deployment
+  # to make progress before it is rollback (default 600s)
+  progressDeadlineSeconds: 60
+  # HPA reference (optional)
+  autoscalerRef:
+    apiVersion: autoscaling/v2beta1
+    kind: HorizontalPodAutoscaler
+    name: podinfo
+  service:
+    # ClusterIP port number
+    port: 9898
+    # container port number or name (optional)
+    targetPort: 9898
+  # define the canary analysis timing and KPIs
+  canaryAnalysis:
+    # schedule interval (default 60s)
+    interval: 1m
+    # 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
+    # App Mesh Prometheus checks
+    metrics:
+    - name: request-success-rate
+      # minimum req success rate (non 5xx responses)
+      # percentage (0-100)
+      threshold: 99
+      interval: 1m
+    - name: request-duration
+      # maximum req duration P99
+      # milliseconds
+      threshold: 500
+      interval: 30s
+    # testing (optional)
+    webhooks:
+    - name: acceptance-test
+      type: pre-rollout
+      url: http://flagger-loadtester.test/
+      timeout: 30s
+      metadata:
+        type: bash
+        cmd: "curl -sd 'test' http://podinfo-canary.test:9898/token | grep token"
+    - name: load-test
+      url: http://flagger-loadtester.test/
+      timeout: 5s
+      metadata:
+        cmd: "hey -z 1m -q 10 -c 2 -H 'Host: podinfo.test' http://envoy.test:10000/"
+```
+
+Save the above resource as podinfo-canary.yaml and then apply it:
+
+```bash
+kubectl apply -f ./podinfo-canary.yaml
+```
+
+After a couple of seconds Flagger will create the canary objects:
+
+```bash
+# 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
+trafficsplits.split.smi-spec.io/podinfo
+```
+
+After the boostrap, the podinfo deployment will be scaled to zero and the traffic to `podinfo.test` will be routed
+to the primary pods. During the canary analysis, the `podinfo-canary.test` address can be used to target directly the canary pods.
+
+### Automated canary promotion
+
+Flagger implements a control loop that gradually shifts traffic to the canary while measuring key performance indicators like HTTP requests success rate, requests average duration and pod health. Based on analysis of the KPIs a canary is promoted or aborted, and the analysis result is published to Slack.
+
+![Flagger Canary Stages](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/diagrams/flagger-canary-steps.png)
+
+A canary deployment is triggered by changes in any of the following objects:
+
+* Deployment PodSpec (container image, command, ports, env, resources, etc)
+* ConfigMaps and Secrets mounted as volumes or mapped to environment variables
+
+Trigger a canary deployment by updating the container image:
+
+```bash
+kubectl -n test set image deployment/podinfo \
+podinfod=stefanprodan/podinfo:3.1.5
+```
+
+Flagger detects that the deployment revision changed and starts a new rollout:
+
+```text
+kubectl -n test describe canary/podinfo
+
+Status:
+  Canary Weight:         0
+  Failed Checks:         0
+  Phase:                 Succeeded
+Events:
+ New revision detected! Scaling up podinfo.test
+ Waiting for podinfo.test rollout to finish: 0 of 1 updated replicas are available
+ Pre-rollout check acceptance-test passed
+ Advance podinfo.test canary weight 5
+ Advance podinfo.test canary weight 10
+ Advance podinfo.test canary weight 15
+ Advance podinfo.test canary weight 20
+ Advance podinfo.test canary weight 25
+ Advance podinfo.test canary weight 30
+ Advance podinfo.test canary weight 35
+ Advance podinfo.test canary weight 40
+ Advance podinfo.test canary weight 45
+ Advance podinfo.test canary weight 50
+ Copying podinfo.test template spec to podinfo-primary.test
+ Waiting for podinfo-primary.test rollout to finish: 1 of 2 updated replicas are available
+ Routing all traffic to primary
+ Promotion completed! Scaling down podinfo.test
+```
+
+When the canary analysis starts, Flagger will call the pre-rollout webhooks before routing traffic to the canary.
+
+**Note** that if you apply new changes to the deployment during the canary analysis, Flagger will restart the analysis.
+
+During the analysis the canary’s progress can be monitored with Grafana.
+
+Flagger comes with a Grafana dashboard made for canary analysis. Install Grafana with Helm:
+
+```bash
+helm upgrade -i flagger-grafana flagger/grafana \
+--namespace=test \
+--set url=http://flagger-prometheus:9090
+```
+
+Run:
+
+```bash
+kubectl port-forward --namespace test svc/flagger-grafana 3000:80
+```
+
+The Envoy dashboard URL is 
+http://localhost:3000/d/flagger-envoy/envoy-canary?refresh=10s&orgId=1&var-namespace=test&var-target=podinfo
+
+![Envoy Canary Dashboard](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/flagger-grafana-appmesh.png)
+
+You can monitor all canaries with:
+
+```bash
+watch kubectl get canaries --all-namespaces
+
+NAMESPACE   NAME      STATUS        WEIGHT   LASTTRANSITIONTIME
+test        podinfo   Progressing   15       2019-10-02T14:05:07Z
+prod        frontend  Succeeded     0        2019-10-02T16:15:07Z
+prod        backend   Failed        0        2019-10-02T17:05:07Z
+```
+
+If you’ve enabled the Slack notifications, you should receive the following messages:
+
+![Flagger Slack Notifications](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/slack-canary-notifications.png)
+
+### Automated rollback
+
+During the canary analysis you can generate HTTP 500 errors or high latency to test if Flagger pauses the rollout.
+
+Trigger a canary deployment:
+
+```bash
+kubectl -n test set image deployment/podinfo \
+podinfod=stefanprodan/podinfo:3.1.2
+```
+
+Exec into the load tester pod with:
+
+```bash
+kubectl -n test exec -it deploy/flagger-loadtester bash
+```
+
+Generate HTTP 500 errors:
+
+```bash
+hey -z 1m -c 5 -q 5 -H 'Host: podinfo.test' http://envoy.test:10000/status/500
+```
+
+Generate latency:
+
+```bash
+watch -n 1 curl -H 'Host: podinfo.test' http://envoy.test:10000/delay/1
+```
+
+When the number of failed checks reaches the canary analysis threshold, the traffic is routed back to the primary, 
+the canary is scaled to zero and the rollout is marked as failed.
+
+```text
+kubectl -n test logs deploy/flagger -f | jq .msg
+
+New revision detected! Starting canary analysis for podinfo.test
+Pre-rollout check acceptance-test passed
+Advance podinfo.test canary weight 5
+Advance podinfo.test canary weight 10
+Advance podinfo.test canary weight 15
+Halt podinfo.test advancement success rate 69.17% < 99%
+Halt podinfo.test advancement success rate 61.39% < 99%
+Halt podinfo.test advancement success rate 55.06% < 99%
+Halt podinfo.test advancement request duration 1.20s > 0.5s
+Halt podinfo.test advancement request duration 1.45s > 0.5s
+Rolling back podinfo.test failed checks threshold reached 5
+Canary failed! Scaling down podinfo.test
+```
+
+If you’ve enabled the Slack notifications, you’ll receive a message if the progress deadline is exceeded, 
+or if the analysis reached the maximum number of failed checks:
+
+![Flagger Slack Notifications](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/slack-canary-failed.png)

hack/update-codegen.sh

@@ -30,7 +30,7 @@ chmod +x ${CODEGEN_PKG}/generate-groups.sh
 
 ${CODEGEN_PKG}/generate-groups.sh all \
     github.com/weaveworks/flagger/pkg/client github.com/weaveworks/flagger/pkg/apis \
-    "flagger:v1alpha3 appmesh:v1beta1 istio:v1alpha3 smi:v1alpha1 gloo:v1" \
+    "flagger:v1alpha3 appmesh:v1beta1 istio:v1alpha3 smi:v1alpha1 gloo:v1 projectcontour:v1" \
     --output-base "${TEMP_DIR}" \
     --go-header-file ${SCRIPT_ROOT}/hack/boilerplate.go.txt
 

kustomize/README.md

@@ -25,7 +25,7 @@ Install Flagger for AWS App Mesh:
 kubectl apply -k github.com/weaveworks/flagger//kustomize/appmesh
 ```
 
-This deploys Flagger and Prometheus (configured to scrape the App Mesh Envoy sidecars) in the `appmesh-system` namespace.
+This deploys Flagger in the `appmesh-system` namespace and sets the metrics server URL to App Mesh Prometheus instance.
 
 Install Flagger for Linkerd:
 
@@ -41,6 +41,14 @@ If you want to install a specific Flagger release, add the version number to the
 kubectl apply -k github.com/weaveworks/flagger//kustomize/linkerd?ref=0.18.0
 ```
 
+Install Flagger for Contour:
+
+```bash
+kubectl apply -k github.com/weaveworks/flagger//kustomize/contour
+```
+
+This deploys Flagger and Prometheus in the `projectcontour` namespace and sets Prometheus to scrape Contour's Envoy instances.
+
 ## Generic installer
 
 Install Flagger and Prometheus:

kustomize/appmesh/kustomization.yaml

@@ -1,6 +1,5 @@
 namespace: appmesh-system
 bases:
   - ../base/flagger
-  - ../base/prometheus
 patchesStrategicMerge:
   - patch.yaml

kustomize/appmesh/patch.yaml

@@ -10,7 +10,20 @@ spec:
           args:
             - -log-level=info
             - -mesh-provider=appmesh
-            - -metrics-server=http://flagger-prometheus:9090
+            - -metrics-server=http://appmesh-prometheus:9090
             - -slack-user=flagger
             - -slack-channel=
             - -slack-url=
+---
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRoleBinding
+metadata:
+  name: flagger
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: flagger
+subjects:
+  - kind: ServiceAccount
+    name: flagger
+    namespace: appmesh-system

kustomize/base/flagger/deployment.yaml

@@ -20,7 +20,7 @@ spec:
       serviceAccountName: flagger
       containers:
       - name: flagger
-        image: weaveworks/flagger:0.16.0
+        image: weaveworks/flagger:0.21.0
         imagePullPolicy: IfNotPresent
         ports:
         - name: http

kustomize/base/flagger/kustomization.yaml

@@ -8,4 +8,4 @@ resources:
   - deployment.yaml
 images:
   - name: weaveworks/flagger
-    newTag: 0.20.2
+    newTag: 0.21.0

kustomize/base/flagger/rbac.yaml

@@ -71,6 +71,11 @@ rules:
       - virtualservices
       - gateways
     verbs: ["*"]
+  - apiGroups:
+      - projectcontour.io
+    resources:
+      - httpproxies
+    verbs: ["*"]
   - nonResourceURLs:
       - /version
     verbs:

kustomize/contour/kustomization.yaml

@@ -0,0 +1,8 @@
+namespace: projectcontour
+resources:
+  - namespace.yaml
+bases:
+  - ../base/flagger/
+  - ../base/prometheus/
+patchesStrategicMerge:
+  - patch.yaml

kustomize/contour/namespace.yaml

@@ -0,0 +1,5 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: projectcontour
+

kustomize/contour/patch.yaml

@@ -0,0 +1,16 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: flagger
+spec:
+  template:
+    spec:
+      containers:
+        - name: flagger
+          args:
+            - -log-level=info
+            - -mesh-provider=contour
+            - -metrics-server=http://flagger-prometheus:9090
+            - -slack-user=flagger
+            - -slack-channel=
+            - -slack-url=

kustomize/istio/patch.yaml

@@ -14,3 +14,17 @@ spec:
             - -slack-user=flagger
             - -slack-channel=
             - -slack-url=
+---
+---
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRoleBinding
+metadata:
+  name: flagger
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: flagger
+subjects:
+  - kind: ServiceAccount
+    name: flagger
+    namespace: istio-system

kustomize/linkerd/patch.yaml

@@ -14,3 +14,16 @@ spec:
             - -slack-user=flagger
             - -slack-channel=
             - -slack-url=
+---
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRoleBinding
+metadata:
+  name: flagger
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: flagger
+subjects:
+  - kind: ServiceAccount
+    name: flagger
+    namespace: linkerd

kustomize/podinfo/deployment.yaml

@@ -46,6 +46,9 @@ spec:
         - --level=info
         - --random-delay=false
         - --random-error=false
+        env:
+        - name: PODINFO_UI_COLOR
+          value: "#34577c"
         livenessProbe:
           exec:
             command:

kustomize/tester/deployment.yaml

@@ -18,7 +18,7 @@ spec:
     spec:
       containers:
         - name: loadtester
-          image: weaveworks/flagger-loadtester:0.11.0
+          image: weaveworks/flagger-loadtester:0.12.1
           imagePullPolicy: IfNotPresent
           ports:
             - name: http

pkg/apis/projectcontour/register.go

@@ -0,0 +1,5 @@
+package projectcontour
+
+const (
+	GroupName = "projectcontour.io"
+)

pkg/apis/projectcontour/v1/doc.go

@@ -0,0 +1,5 @@
+// +k8s:deepcopy-gen=package
+
+// Package v1 is the v1 version of the API.
+// +groupName=projectcontour.io
+package v1

pkg/apis/projectcontour/v1/httpproxy.go

@@ -0,0 +1,340 @@
+// Copyright © 2019 VMware
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// source: https://github.com/projectcontour/contour/blob/master/apis/projectcontour/v1/httpproxy.go
+package v1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// HTTPProxySpec defines the spec of the CRD.
+type HTTPProxySpec struct {
+	// Virtualhost appears at most once. If it is present, the object is considered
+	// to be a "root".
+	// +optional
+	VirtualHost *VirtualHost `json:"virtualhost,omitempty"`
+	// Routes are the ingress routes. If TCPProxy is present, Routes is ignored.
+	//  +optional
+	Routes []Route `json:"routes,omitempty"`
+	// TCPProxy holds TCP proxy information.
+	// +optional
+	TCPProxy *TCPProxy `json:"tcpproxy,omitempty"`
+	// Includes allow for specific routing configuration to be appended to another HTTPProxy in another namespace.
+	// +optional
+	Includes []Include `json:"includes,omitempty"`
+}
+
+// Include describes a set of policies that can be applied to an HTTPProxy in a namespace.
+type Include struct {
+	// Name of the HTTPProxy
+	Name string `json:"name"`
+	// Namespace of the HTTPProxy to include. Defaults to the current namespace if not supplied.
+	// +optional
+	Namespace string `json:"namespace,omitempty"`
+	// Conditions are a set of routing properties that is applied to an HTTPProxy in a namespace.
+	// +optional
+	Conditions []Condition `json:"conditions,omitempty"`
+}
+
+// Condition are policies that are applied on top of HTTPProxies.
+// One of Prefix or Header must be provided.
+type Condition struct {
+	// Prefix defines a prefix match for a request.
+	// +optional
+	Prefix string `json:"prefix,omitempty"`
+
+	// Header specifies the header condition to match.
+	// +optional
+	Header *HeaderCondition `json:"header,omitempty"`
+}
+
+// HeaderCondition specifies the header condition to match.
+// Name is required. Only one of Present or Contains must
+// be provided.
+type HeaderCondition struct {
+
+	// Name is the name of the header to match on. Name is required.
+	// Header names are case insensitive.
+	Name string `json:"name"`
+
+	// Present is true if the Header is present in the request.
+	// +optional
+	Present bool `json:"present,omitempty"`
+
+	// Contains is true if the Header containing this string is present
+	// in the request.
+	// +optional
+	Contains string `json:"contains,omitempty"`
+
+	// NotContains is true if the Header containing this string is not present
+	// in the request.
+	// +optional
+	NotContains string `json:"notcontains,omitempty"`
+
+	// Exact is true if the Header containing this string matches exactly
+	// in the request.
+	// +optional
+	Exact string `json:"exact,omitempty"`
+
+	// NotExact is true if the Header containing this string doesn't match exactly
+	// in the request.
+	// +optional
+	NotExact string `json:"notexact,omitempty"`
+}
+
+// VirtualHost appears at most once. If it is present, the object is considered
+// to be a "root".
+type VirtualHost struct {
+	// The fully qualified domain name of the root of the ingress tree
+	// all leaves of the DAG rooted at this object relate to the fqdn
+	Fqdn string `json:"fqdn"`
+	// If present describes tls properties. The CNI names that will be matched on
+	// are described in fqdn, the tls.secretName secret must contain a
+	// matching certificate
+	// +optional
+	TLS *TLS `json:"tls,omitempty"`
+}
+
+// TLS describes tls properties. The CNI names that will be matched on
+// are described in fqdn, the tls.secretName secret must contain a
+// matching certificate unless tls.passthrough is set to true.
+type TLS struct {
+	// required, the name of a secret in the current namespace
+	SecretName string `json:"secretName,omitempty"`
+	// Minimum TLS version this vhost should negotiate
+	// +optional
+	MinimumProtocolVersion string `json:"minimumProtocolVersion,omitempty"`
+	// If Passthrough is set to true, the SecretName will be ignored
+	// and the encrypted handshake will be passed through to the
+	// backing cluster.
+	// +optional
+	Passthrough bool `json:"passthrough,omitempty"`
+}
+
+// Route contains the set of routes for a virtual host.
+type Route struct {
+	// Conditions are a set of routing properties that is applied to an HTTPProxy in a namespace.
+	// +optional
+	Conditions []Condition `json:"conditions,omitempty"`
+	// Services are the services to proxy traffic.
+	Services []Service `json:"services,omitempty"`
+	// Enables websocket support for the route.
+	// +optional
+	EnableWebsockets bool `json:"enableWebsockets,omitempty"`
+	// Allow this path to respond to insecure requests over HTTP which are normally
+	// not permitted when a `virtualhost.tls` block is present.
+	// +optional
+	PermitInsecure bool `json:"permitInsecure,omitempty"`
+	// The timeout policy for this route.
+	// +optional
+	TimeoutPolicy *TimeoutPolicy `json:"timeoutPolicy,omitempty"`
+	// The retry policy for this route.
+	// +optional
+	RetryPolicy *RetryPolicy `json:"retryPolicy,omitempty"`
+	// The health check policy for this route.
+	// +optional
+	HealthCheckPolicy *HTTPHealthCheckPolicy `json:"healthCheckPolicy,omitempty"`
+	// The load balancing policy for this route.
+	// +optional
+	LoadBalancerPolicy *LoadBalancerPolicy `json:"loadBalancerPolicy,omitempty"`
+	// The policy for rewriting the path of the request URL
+	// after the request has been routed to a Service.
+	//
+	// +kubebuilder:validation:Optional
+	PathRewrite *PathRewritePolicy `json:"pathRewritePolicy,omitempty"`
+}
+
+func (r *Route) GetPrefixReplacements() []ReplacePrefix {
+	if r.PathRewrite != nil {
+		return r.PathRewrite.ReplacePrefix
+	}
+
+	return nil
+}
+
+// TCPProxy contains the set of services to proxy TCP connections.
+type TCPProxy struct {
+	// The load balancing policy for the backend services.
+	// +optional
+	LoadBalancerPolicy *LoadBalancerPolicy `json:"loadBalancerPolicy,omitempty"`
+	// Services are the services to proxy traffic
+	Services []Service `json:"services,omitempty"`
+
+	// Include specifies that this tcpproxy should be delegated to another HTTPProxy.
+	// +optional
+	Include *TCPProxyInclude `json:"includes,omitempty"`
+}
+
+// TCPProxyInclude describes a target HTTPProxy document which contains the TCPProxy details.
+type TCPProxyInclude struct {
+	// Name of the child HTTPProxy
+	Name string `json:"name"`
+	// Namespace of the HTTPProxy to include. Defaults to the current namespace if not supplied.
+	// +optional
+	Namespace string `json:"namespace,omitempty"`
+}
+
+// Service defines an Kubernetes Service to proxy traffic.
+type Service struct {
+	// Name is the name of Kubernetes service to proxy traffic.
+	// Names defined here will be used to look up corresponding endpoints which contain the ips to route.
+	Name string `json:"name"`
+	// Port (defined as Integer) to proxy traffic to since a service can have multiple defined.
+	Port int `json:"port"`
+	// Weight defines percentage of traffic to balance traffic
+	// +optional
+	Weight uint32 `json:"weight,omitempty"`
+	// UpstreamValidation defines how to verify the backend service's certificate
+	// +optional
+	UpstreamValidation *UpstreamValidation `json:"validation,omitempty"`
+	// If Mirror is true the Service will receive a read only mirror of the traffic for this route.
+	Mirror bool `json:"mirror,omitempty"`
+}
+
+// HTTPHealthCheckPolicy defines health checks on the upstream service.
+type HTTPHealthCheckPolicy struct {
+	// HTTP endpoint used to perform health checks on upstream service
+	Path string `json:"path"`
+	// The value of the host header in the HTTP health check request.
+	// If left empty (default value), the name "contour-envoy-healthcheck"
+	// will be used.
+	Host string `json:"host,omitempty"`
+	// The interval (seconds) between health checks
+	// +optional
+	IntervalSeconds int64 `json:"intervalSeconds"`
+	// The time to wait (seconds) for a health check response
+	// +optional
+	TimeoutSeconds int64 `json:"timeoutSeconds"`
+	// The number of unhealthy health checks required before a host is marked unhealthy
+	// +optional
+	UnhealthyThresholdCount uint32 `json:"unhealthyThresholdCount"`
+	// The number of healthy health checks required before a host is marked healthy
+	// +optional
+	HealthyThresholdCount uint32 `json:"healthyThresholdCount"`
+}
+
+// TimeoutPolicy defines the attributes associated with timeout.
+type TimeoutPolicy struct {
+	// TimeoutPolicy durations are expressed as per the format specified in the ParseDuration documentation: https://godoc.org/time#ParseDuration
+	// Example input values: "300ms", "5s", "1m". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+	// The string 'infinity' is also a valid input and specifies no timeout.
+
+	// Timeout for receiving a response from the server after processing a request from client.
+	// If not supplied the timeout duration is undefined.
+	// +optional
+	Response string `json:"response,omitempty"`
+
+	// Timeout after which if there are no active requests for this route, the connection between
+	// Envoy and the backend will be closed. If not specified, there is no per-route idle timeout.
+	// +optional
+	Idle string `json:"idle,omitempty"`
+}
+
+// RetryPolicy defines the attributes associated with retrying policy.
+type RetryPolicy struct {
+	// NumRetries is maximum allowed number of retries.
+	// If not supplied, the number of retries is one.
+	// +optional
+	NumRetries uint32 `json:"count"`
+	// PerTryTimeout specifies the timeout per retry attempt.
+	// Ignored if NumRetries is not supplied.
+	PerTryTimeout string `json:"perTryTimeout,omitempty"`
+}
+
+// ReplacePrefix describes a path prefix replacement.
+type ReplacePrefix struct {
+	// Prefix specifies the URL path prefix to be replaced.
+	//
+	// If Prefix is specified, it must exactly match the Condition
+	// prefix that is rendered by the chain of including HTTPProxies
+	// and only that path prefix will be replaced by Replacement.
+	// This allows HTTPProxies that are included through multiple
+	// roots to only replace specific path prefixes, leaving others
+	// unmodified.
+	//
+	// If Prefix is not specified, all routing prefixes rendered
+	// by the include chain will be replaced.
+	//
+	// +kubebuilder:validation:Optional
+	// +kubebuilder:validation:MinLength=1
+	Prefix string `json:"prefix,omitempty"`
+
+	// Replacement is the string that the routing path prefix
+	// will be replaced with. This must not be empty.
+	//
+	// +kubebuilder:validation:Required
+	// +kubebuilder:validation:MinLength=1
+	Replacement string `json:"replacement"`
+}
+
+// PathRewritePolicy specifies how a request URL path should be
+// rewritten. This rewriting takes place after a request is routed
+// and has no subsequent effects on the proxy's routing decision.
+// No HTTP headers or body content is rewritten.
+//
+// Exactly one field in this struct may be specified.
+type PathRewritePolicy struct {
+	// ReplacePrefix describes how the path prefix should be replaced.
+	// +kubebuilder:validation:Optional
+	ReplacePrefix []ReplacePrefix `json:"replacePrefix,omitempty"`
+}
+
+// LoadBalancerPolicy defines the load balancing policy.
+type LoadBalancerPolicy struct {
+	Strategy string `json:"strategy,omitempty"`
+}
+
+// UpstreamValidation defines how to verify the backend service's certificate
+type UpstreamValidation struct {
+	// Name of the Kubernetes secret be used to validate the certificate presented by the backend
+	CACertificate string `json:"caSecret"`
+	// Key which is expected to be present in the 'subjectAltName' of the presented certificate
+	SubjectName string `json:"subjectName"`
+}
+
+// Status reports the current state of the HTTPProxy.
+type Status struct {
+	// +optional
+	CurrentStatus string `json:"currentStatus,omitempty"`
+	// +optional
+	Description string `json:"description,omitempty"`
+}
+
+// +genclient
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// HTTPProxy is an Ingress CRD specification
+// +k8s:openapi-gen=true
+// +kubebuilder:printcolumn:name="FQDN",type="string",JSONPath=".spec.virtualhost.fqdn",description="Fully qualified domain name"
+// +kubebuilder:printcolumn:name="TLS Secret",type="string",JSONPath=".spec.virtualhost.tls.secretName",description="Secret with TLS credentials"
+// +kubebuilder:printcolumn:name="Status",type="string",JSONPath=".status.currentStatus",description="The current status of the HTTPProxy"
+// +kubebuilder:printcolumn:name="Status Description",type="string",JSONPath=".status.description",description="Description of the current status"
+// +kubebuilder:resource:scope=Namespaced,path=httpproxies,shortName=proxy;proxies,singular=httpproxy
+type HTTPProxy struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata"`
+
+	Spec HTTPProxySpec `json:"spec"`
+	// +optional
+	Status Status `json:"status,omitempty"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// HTTPProxyList is a list of HTTPProxies.
+type HTTPProxyList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata"`
+	Items           []HTTPProxy `json:"items"`
+}

pkg/apis/projectcontour/v1/register.go

@@ -0,0 +1,37 @@
+package v1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+
+	"github.com/weaveworks/flagger/pkg/apis/projectcontour"
+)
+
+// SchemeGroupVersion is the GroupVersion for the Contour API
+var SchemeGroupVersion = schema.GroupVersion{Group: projectcontour.GroupName, Version: "v1"}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) schema.GroupKind {
+	return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource gets an Contour GroupResource for a specified resource
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+var (
+	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
+	AddToScheme   = SchemeBuilder.AddToScheme
+)
+
+// Adds the list of known types to Scheme.
+func addKnownTypes(scheme *runtime.Scheme) error {
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&HTTPProxy{},
+		&HTTPProxyList{},
+	)
+	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
+	return nil
+}

pkg/apis/projectcontour/v1/zz_generated.deepcopy.go

@@ -0,0 +1,481 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by deepcopy-gen. DO NOT EDIT.
+
+package v1
+
+import (
+	runtime "k8s.io/apimachinery/pkg/runtime"
+)
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Condition) DeepCopyInto(out *Condition) {
+	*out = *in
+	if in.Header != nil {
+		in, out := &in.Header, &out.Header
+		*out = new(HeaderCondition)
+		**out = **in
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Condition.
+func (in *Condition) DeepCopy() *Condition {
+	if in == nil {
+		return nil
+	}
+	out := new(Condition)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *HTTPHealthCheckPolicy) DeepCopyInto(out *HTTPHealthCheckPolicy) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPHealthCheckPolicy.
+func (in *HTTPHealthCheckPolicy) DeepCopy() *HTTPHealthCheckPolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(HTTPHealthCheckPolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *HTTPProxy) DeepCopyInto(out *HTTPProxy) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	out.Status = in.Status
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPProxy.
+func (in *HTTPProxy) DeepCopy() *HTTPProxy {
+	if in == nil {
+		return nil
+	}
+	out := new(HTTPProxy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *HTTPProxy) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *HTTPProxyList) DeepCopyInto(out *HTTPProxyList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ListMeta.DeepCopyInto(&out.ListMeta)
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]HTTPProxy, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPProxyList.
+func (in *HTTPProxyList) DeepCopy() *HTTPProxyList {
+	if in == nil {
+		return nil
+	}
+	out := new(HTTPProxyList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *HTTPProxyList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *HTTPProxySpec) DeepCopyInto(out *HTTPProxySpec) {
+	*out = *in
+	if in.VirtualHost != nil {
+		in, out := &in.VirtualHost, &out.VirtualHost
+		*out = new(VirtualHost)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Routes != nil {
+		in, out := &in.Routes, &out.Routes
+		*out = make([]Route, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.TCPProxy != nil {
+		in, out := &in.TCPProxy, &out.TCPProxy
+		*out = new(TCPProxy)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Includes != nil {
+		in, out := &in.Includes, &out.Includes
+		*out = make([]Include, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPProxySpec.
+func (in *HTTPProxySpec) DeepCopy() *HTTPProxySpec {
+	if in == nil {
+		return nil
+	}
+	out := new(HTTPProxySpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *HeaderCondition) DeepCopyInto(out *HeaderCondition) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HeaderCondition.
+func (in *HeaderCondition) DeepCopy() *HeaderCondition {
+	if in == nil {
+		return nil
+	}
+	out := new(HeaderCondition)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Include) DeepCopyInto(out *Include) {
+	*out = *in
+	if in.Conditions != nil {
+		in, out := &in.Conditions, &out.Conditions
+		*out = make([]Condition, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Include.
+func (in *Include) DeepCopy() *Include {
+	if in == nil {
+		return nil
+	}
+	out := new(Include)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *LoadBalancerPolicy) DeepCopyInto(out *LoadBalancerPolicy) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerPolicy.
+func (in *LoadBalancerPolicy) DeepCopy() *LoadBalancerPolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(LoadBalancerPolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PathRewritePolicy) DeepCopyInto(out *PathRewritePolicy) {
+	*out = *in
+	if in.ReplacePrefix != nil {
+		in, out := &in.ReplacePrefix, &out.ReplacePrefix
+		*out = make([]ReplacePrefix, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PathRewritePolicy.
+func (in *PathRewritePolicy) DeepCopy() *PathRewritePolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(PathRewritePolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ReplacePrefix) DeepCopyInto(out *ReplacePrefix) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplacePrefix.
+func (in *ReplacePrefix) DeepCopy() *ReplacePrefix {
+	if in == nil {
+		return nil
+	}
+	out := new(ReplacePrefix)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RetryPolicy) DeepCopyInto(out *RetryPolicy) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RetryPolicy.
+func (in *RetryPolicy) DeepCopy() *RetryPolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(RetryPolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Route) DeepCopyInto(out *Route) {
+	*out = *in
+	if in.Conditions != nil {
+		in, out := &in.Conditions, &out.Conditions
+		*out = make([]Condition, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.Services != nil {
+		in, out := &in.Services, &out.Services
+		*out = make([]Service, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.TimeoutPolicy != nil {
+		in, out := &in.TimeoutPolicy, &out.TimeoutPolicy
+		*out = new(TimeoutPolicy)
+		**out = **in
+	}
+	if in.RetryPolicy != nil {
+		in, out := &in.RetryPolicy, &out.RetryPolicy
+		*out = new(RetryPolicy)
+		**out = **in
+	}
+	if in.HealthCheckPolicy != nil {
+		in, out := &in.HealthCheckPolicy, &out.HealthCheckPolicy
+		*out = new(HTTPHealthCheckPolicy)
+		**out = **in
+	}
+	if in.LoadBalancerPolicy != nil {
+		in, out := &in.LoadBalancerPolicy, &out.LoadBalancerPolicy
+		*out = new(LoadBalancerPolicy)
+		**out = **in
+	}
+	if in.PathRewrite != nil {
+		in, out := &in.PathRewrite, &out.PathRewrite
+		*out = new(PathRewritePolicy)
+		(*in).DeepCopyInto(*out)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Route.
+func (in *Route) DeepCopy() *Route {
+	if in == nil {
+		return nil
+	}
+	out := new(Route)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Service) DeepCopyInto(out *Service) {
+	*out = *in
+	if in.UpstreamValidation != nil {
+		in, out := &in.UpstreamValidation, &out.UpstreamValidation
+		*out = new(UpstreamValidation)
+		**out = **in
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Service.
+func (in *Service) DeepCopy() *Service {
+	if in == nil {
+		return nil
+	}
+	out := new(Service)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Status) DeepCopyInto(out *Status) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Status.
+func (in *Status) DeepCopy() *Status {
+	if in == nil {
+		return nil
+	}
+	out := new(Status)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TCPProxy) DeepCopyInto(out *TCPProxy) {
+	*out = *in
+	if in.LoadBalancerPolicy != nil {
+		in, out := &in.LoadBalancerPolicy, &out.LoadBalancerPolicy
+		*out = new(LoadBalancerPolicy)
+		**out = **in
+	}
+	if in.Services != nil {
+		in, out := &in.Services, &out.Services
+		*out = make([]Service, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.Include != nil {
+		in, out := &in.Include, &out.Include
+		*out = new(TCPProxyInclude)
+		**out = **in
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPProxy.
+func (in *TCPProxy) DeepCopy() *TCPProxy {
+	if in == nil {
+		return nil
+	}
+	out := new(TCPProxy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TCPProxyInclude) DeepCopyInto(out *TCPProxyInclude) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPProxyInclude.
+func (in *TCPProxyInclude) DeepCopy() *TCPProxyInclude {
+	if in == nil {
+		return nil
+	}
+	out := new(TCPProxyInclude)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TLS) DeepCopyInto(out *TLS) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLS.
+func (in *TLS) DeepCopy() *TLS {
+	if in == nil {
+		return nil
+	}
+	out := new(TLS)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TimeoutPolicy) DeepCopyInto(out *TimeoutPolicy) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TimeoutPolicy.
+func (in *TimeoutPolicy) DeepCopy() *TimeoutPolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(TimeoutPolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *UpstreamValidation) DeepCopyInto(out *UpstreamValidation) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UpstreamValidation.
+func (in *UpstreamValidation) DeepCopy() *UpstreamValidation {
+	if in == nil {
+		return nil
+	}
+	out := new(UpstreamValidation)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *VirtualHost) DeepCopyInto(out *VirtualHost) {
+	*out = *in
+	if in.TLS != nil {
+		in, out := &in.TLS, &out.TLS
+		*out = new(TLS)
+		**out = **in
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualHost.
+func (in *VirtualHost) DeepCopy() *VirtualHost {
+	if in == nil {
+		return nil
+	}
+	out := new(VirtualHost)
+	in.DeepCopyInto(out)
+	return out
+}

pkg/canary/controller.go

@@ -0,0 +1,22 @@
+package canary
+
+import (
+	flaggerv1 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
+)
+
+type Controller interface {
+	IsPrimaryReady(canary *flaggerv1.Canary) (bool, error)
+	IsCanaryReady(canary *flaggerv1.Canary) (bool, error)
+	GetMetadata(canary *flaggerv1.Canary) (string, map[string]int32, error)
+	SyncStatus(canary *flaggerv1.Canary, status flaggerv1.CanaryStatus) error
+	SetStatusFailedChecks(canary *flaggerv1.Canary, val int) error
+	SetStatusWeight(canary *flaggerv1.Canary, val int) error
+	SetStatusIterations(canary *flaggerv1.Canary, val int) error
+	SetStatusPhase(canary *flaggerv1.Canary, phase flaggerv1.CanaryPhase) error
+	Initialize(canary *flaggerv1.Canary, skipLivenessChecks bool) error
+	Promote(canary *flaggerv1.Canary) error
+	HasTargetChanged(canary *flaggerv1.Canary) (bool, error)
+	HaveDependenciesChanged(canary *flaggerv1.Canary) (bool, error)
+	Scale(canary *flaggerv1.Canary, replicas int32) error
+	ScaleFromZero(canary *flaggerv1.Canary) error
+}

pkg/canary/deployment_controller.go

@@ -6,7 +6,6 @@ import (
 	"io"
 
 	"github.com/google/go-cmp/cmp"
-	"github.com/mitchellh/hashstructure"
 	"go.uber.org/zap"
 	appsv1 "k8s.io/api/apps/v1"
 	hpav1 "k8s.io/api/autoscaling/v2beta1"
@@ -21,52 +20,53 @@ import (
 	clientset "github.com/weaveworks/flagger/pkg/client/clientset/versioned"
 )
 
-// Deployer is managing the operations for Kubernetes deployment kind
-type Deployer struct {
-	KubeClient    kubernetes.Interface
-	FlaggerClient clientset.Interface
-	Logger        *zap.SugaredLogger
-	ConfigTracker ConfigTracker
-	Labels        []string
+// DeploymentController is managing the operations for Kubernetes Deployment kind
+type DeploymentController struct {
+	kubeClient    kubernetes.Interface
+	flaggerClient clientset.Interface
+	logger        *zap.SugaredLogger
+	configTracker ConfigTracker
+	labels        []string
 }
 
 // Initialize creates the primary deployment, hpa,
 // scales to zero the canary deployment and returns the pod selector label and container ports
-func (c *Deployer) Initialize(cd *flaggerv1.Canary, skipLivenessChecks bool) (label string, ports map[string]int32, err error) {
+func (c *DeploymentController) Initialize(cd *flaggerv1.Canary, skipLivenessChecks bool) (err error) {
 	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
-	label, ports, err = c.createPrimaryDeployment(cd)
+
+	err = c.createPrimaryDeployment(cd)
 	if err != nil {
-		return "", ports, fmt.Errorf("creating deployment %s.%s failed: %v", primaryName, cd.Namespace, err)
+		return fmt.Errorf("creating deployment %s.%s failed: %v", primaryName, cd.Namespace, err)
 	}
 
 	if cd.Status.Phase == "" || cd.Status.Phase == flaggerv1.CanaryPhaseInitializing {
-		if !skipLivenessChecks {
+		if !skipLivenessChecks && !cd.Spec.SkipAnalysis {
 			_, readyErr := c.IsPrimaryReady(cd)
 			if readyErr != nil {
-				return "", ports, readyErr
+				return readyErr
 			}
 		}
 
-		c.Logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Infof("Scaling down %s.%s", cd.Spec.TargetRef.Name, cd.Namespace)
+		c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Infof("Scaling down %s.%s", cd.Spec.TargetRef.Name, cd.Namespace)
 		if err := c.Scale(cd, 0); err != nil {
-			return "", ports, err
+			return err
 		}
 	}
 
 	if cd.Spec.AutoscalerRef != nil && cd.Spec.AutoscalerRef.Kind == "HorizontalPodAutoscaler" {
 		if err := c.reconcilePrimaryHpa(cd, true); err != nil {
-			return "", ports, fmt.Errorf("creating HorizontalPodAutoscaler %s.%s failed: %v", primaryName, cd.Namespace, err)
+			return fmt.Errorf("creating HorizontalPodAutoscaler %s.%s failed: %v", primaryName, cd.Namespace, err)
 		}
 	}
-	return label, ports, nil
+	return nil
 }
 
 // Promote copies the pod spec, secrets and config maps from canary to primary
-func (c *Deployer) Promote(cd *flaggerv1.Canary) error {
+func (c *DeploymentController) Promote(cd *flaggerv1.Canary) error {
 	targetName := cd.Spec.TargetRef.Name
 	primaryName := fmt.Sprintf("%s-primary", targetName)
 
-	canary, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	canary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return fmt.Errorf("deployment %s.%s not found", targetName, cd.Namespace)
@@ -80,7 +80,7 @@ func (c *Deployer) Promote(cd *flaggerv1.Canary) error {
 			targetName, cd.Namespace, targetName)
 	}
 
-	primary, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(primaryName, metav1.GetOptions{})
+	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)
@@ -89,11 +89,11 @@ func (c *Deployer) Promote(cd *flaggerv1.Canary) error {
 	}
 
 	// promote secrets and config maps
-	configRefs, err := c.ConfigTracker.GetTargetConfigs(cd)
+	configRefs, err := c.configTracker.GetTargetConfigs(cd)
 	if err != nil {
 		return err
 	}
-	if err := c.ConfigTracker.CreatePrimaryConfigs(cd, configRefs); err != nil {
+	if err := c.configTracker.CreatePrimaryConfigs(cd, configRefs); err != nil {
 		return err
 	}
 
@@ -104,7 +104,7 @@ func (c *Deployer) Promote(cd *flaggerv1.Canary) error {
 	primaryCopy.Spec.Strategy = canary.Spec.Strategy
 
 	// update spec with primary secrets and config maps
-	primaryCopy.Spec.Template.Spec = c.ConfigTracker.ApplyPrimaryConfigs(canary.Spec.Template.Spec, configRefs)
+	primaryCopy.Spec.Template.Spec = c.configTracker.ApplyPrimaryConfigs(canary.Spec.Template.Spec, configRefs)
 
 	// update pod annotations to ensure a rolling update
 	annotations, err := c.makeAnnotations(canary.Spec.Template.Annotations)
@@ -116,7 +116,7 @@ func (c *Deployer) Promote(cd *flaggerv1.Canary) error {
 	primaryCopy.Spec.Template.Labels = makePrimaryLabels(canary.Spec.Template.Labels, primaryName, label)
 
 	// apply update
-	_, err = c.KubeClient.AppsV1().Deployments(cd.Namespace).Update(primaryCopy)
+	_, err = c.kubeClient.AppsV1().Deployments(cd.Namespace).Update(primaryCopy)
 	if err != nil {
 		return fmt.Errorf("updating deployment %s.%s template spec failed: %v",
 			primaryCopy.GetName(), primaryCopy.Namespace, err)
@@ -132,10 +132,10 @@ func (c *Deployer) Promote(cd *flaggerv1.Canary) error {
 	return nil
 }
 
-// HasDeploymentChanged returns true if the canary deployment pod spec has changed
-func (c *Deployer) HasDeploymentChanged(cd *flaggerv1.Canary) (bool, error) {
+// HasTargetChanged returns true if the canary deployment pod spec has changed
+func (c *DeploymentController) HasTargetChanged(cd *flaggerv1.Canary) (bool, error) {
 	targetName := cd.Spec.TargetRef.Name
-	canary, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	canary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return false, fmt.Errorf("deployment %s.%s not found", targetName, cd.Namespace)
@@ -143,31 +143,13 @@ func (c *Deployer) HasDeploymentChanged(cd *flaggerv1.Canary) (bool, error) {
 		return false, fmt.Errorf("deployment %s.%s query error %v", targetName, cd.Namespace, err)
 	}
 
-	if cd.Status.LastAppliedSpec == "" {
-		return true, nil
-	}
-
-	newHash, err := hashstructure.Hash(canary.Spec.Template, nil)
-	if err != nil {
-		return false, fmt.Errorf("hash error %v", err)
-	}
-
-	// do not trigger a canary deployment on manual rollback
-	if cd.Status.LastPromotedSpec == fmt.Sprintf("%d", newHash) {
-		return false, nil
-	}
-
-	if cd.Status.LastAppliedSpec != fmt.Sprintf("%d", newHash) {
-		return true, nil
-	}
-
-	return false, nil
+	return hasSpecChanged(cd, canary.Spec.Template)
 }
 
 // Scale sets the canary deployment replicas
-func (c *Deployer) Scale(cd *flaggerv1.Canary, replicas int32) error {
+func (c *DeploymentController) Scale(cd *flaggerv1.Canary, replicas int32) error {
 	targetName := cd.Spec.TargetRef.Name
-	dep, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	dep, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return fmt.Errorf("deployment %s.%s not found", targetName, cd.Namespace)
@@ -178,16 +160,16 @@ func (c *Deployer) Scale(cd *flaggerv1.Canary, replicas int32) error {
 	depCopy := dep.DeepCopy()
 	depCopy.Spec.Replicas = int32p(replicas)
 
-	_, err = c.KubeClient.AppsV1().Deployments(dep.Namespace).Update(depCopy)
+	_, err = c.kubeClient.AppsV1().Deployments(dep.Namespace).Update(depCopy)
 	if err != nil {
 		return fmt.Errorf("scaling %s.%s to %v failed: %v", depCopy.GetName(), depCopy.Namespace, replicas, err)
 	}
 	return nil
 }
 
-func (c *Deployer) ScaleUp(cd *flaggerv1.Canary) error {
+func (c *DeploymentController) ScaleFromZero(cd *flaggerv1.Canary) error {
 	targetName := cd.Spec.TargetRef.Name
-	dep, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	dep, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return fmt.Errorf("deployment %s.%s not found", targetName, cd.Namespace)
@@ -202,18 +184,18 @@ func (c *Deployer) ScaleUp(cd *flaggerv1.Canary) error {
 	depCopy := dep.DeepCopy()
 	depCopy.Spec.Replicas = replicas
 
-	_, err = c.KubeClient.AppsV1().Deployments(dep.Namespace).Update(depCopy)
+	_, err = c.kubeClient.AppsV1().Deployments(dep.Namespace).Update(depCopy)
 	if err != nil {
 		return fmt.Errorf("scaling %s.%s to %v failed: %v", depCopy.GetName(), depCopy.Namespace, replicas, err)
 	}
 	return nil
 }
 
-func (c *Deployer) createPrimaryDeployment(cd *flaggerv1.Canary) (string, map[string]int32, error) {
+// GetMetadata returns the pod label selector and svc ports
+func (c *DeploymentController) GetMetadata(cd *flaggerv1.Canary) (string, map[string]int32, error) {
 	targetName := cd.Spec.TargetRef.Name
-	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
 
-	canaryDep, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	canaryDep, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return "", nil, fmt.Errorf("deployment %s.%s not found, retrying", targetName, cd.Namespace)
@@ -236,19 +218,39 @@ func (c *Deployer) createPrimaryDeployment(cd *flaggerv1.Canary) (string, map[st
 		ports = p
 	}
 
-	primaryDep, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(primaryName, metav1.GetOptions{})
+	return label, ports, nil
+}
+func (c *DeploymentController) createPrimaryDeployment(cd *flaggerv1.Canary) error {
+	targetName := cd.Spec.TargetRef.Name
+	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
+
+	canaryDep, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("deployment %s.%s not found, retrying", targetName, cd.Namespace)
+		}
+		return err
+	}
+
+	label, err := c.getSelectorLabel(canaryDep)
+	if err != nil {
+		return fmt.Errorf("invalid label selector! Deployment %s.%s spec.selector.matchLabels must contain selector 'app: %s'",
+			targetName, cd.Namespace, targetName)
+	}
+
+	primaryDep, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(primaryName, metav1.GetOptions{})
 	if errors.IsNotFound(err) {
 		// create primary secrets and config maps
-		configRefs, err := c.ConfigTracker.GetTargetConfigs(cd)
+		configRefs, err := c.configTracker.GetTargetConfigs(cd)
 		if err != nil {
-			return "", nil, err
+			return err
 		}
-		if err := c.ConfigTracker.CreatePrimaryConfigs(cd, configRefs); err != nil {
-			return "", nil, err
+		if err := c.configTracker.CreatePrimaryConfigs(cd, configRefs); err != nil {
+			return err
 		}
 		annotations, err := c.makeAnnotations(canaryDep.Spec.Template.Annotations)
 		if err != nil {
-			return "", nil, err
+			return err
 		}
 
 		replicas := int32(1)
@@ -289,25 +291,25 @@ func (c *Deployer) createPrimaryDeployment(cd *flaggerv1.Canary) (string, map[st
 						Annotations: annotations,
 					},
 					// update spec with the primary secrets and config maps
-					Spec: c.ConfigTracker.ApplyPrimaryConfigs(canaryDep.Spec.Template.Spec, configRefs),
+					Spec: c.configTracker.ApplyPrimaryConfigs(canaryDep.Spec.Template.Spec, configRefs),
 				},
 			},
 		}
 
-		_, err = c.KubeClient.AppsV1().Deployments(cd.Namespace).Create(primaryDep)
+		_, err = c.kubeClient.AppsV1().Deployments(cd.Namespace).Create(primaryDep)
 		if err != nil {
-			return "", nil, err
+			return err
 		}
 
-		c.Logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Infof("Deployment %s.%s created", primaryDep.GetName(), cd.Namespace)
+		c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Infof("Deployment %s.%s created", primaryDep.GetName(), cd.Namespace)
 	}
 
-	return label, ports, nil
+	return nil
 }
 
-func (c *Deployer) reconcilePrimaryHpa(cd *flaggerv1.Canary, init bool) error {
+func (c *DeploymentController) reconcilePrimaryHpa(cd *flaggerv1.Canary, init bool) 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{})
+	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",
@@ -328,7 +330,7 @@ func (c *Deployer) reconcilePrimaryHpa(cd *flaggerv1.Canary, init bool) error {
 	}
 
 	primaryHpaName := fmt.Sprintf("%s-primary", cd.Spec.AutoscalerRef.Name)
-	primaryHpa, err := c.KubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Get(primaryHpaName, metav1.GetOptions{})
+	primaryHpa, err := c.kubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Get(primaryHpaName, metav1.GetOptions{})
 
 	// create HPA
 	if errors.IsNotFound(err) {
@@ -348,11 +350,11 @@ func (c *Deployer) reconcilePrimaryHpa(cd *flaggerv1.Canary, init bool) error {
 			Spec: hpaSpec,
 		}
 
-		_, err = c.KubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Create(primaryHpa)
+		_, err = c.kubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Create(primaryHpa)
 		if err != nil {
 			return err
 		}
-		c.Logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Infof("HorizontalPodAutoscaler %s.%s created", primaryHpa.GetName(), cd.Namespace)
+		c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Infof("HorizontalPodAutoscaler %s.%s created", primaryHpa.GetName(), cd.Namespace)
 		return nil
 	}
 
@@ -370,11 +372,11 @@ func (c *Deployer) reconcilePrimaryHpa(cd *flaggerv1.Canary, init bool) error {
 			hpaClone.Spec.MinReplicas = hpaSpec.MinReplicas
 			hpaClone.Spec.Metrics = hpaSpec.Metrics
 
-			_, upErr := c.KubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Update(hpaClone)
+			_, upErr := c.kubeClient.AutoscalingV2beta1().HorizontalPodAutoscalers(cd.Namespace).Update(hpaClone)
 			if upErr != nil {
 				return upErr
 			}
-			c.Logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Infof("HorizontalPodAutoscaler %s.%s updated", primaryHpa.GetName(), cd.Namespace)
+			c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Infof("HorizontalPodAutoscaler %s.%s updated", primaryHpa.GetName(), cd.Namespace)
 		}
 	}
 
@@ -382,7 +384,7 @@ func (c *Deployer) reconcilePrimaryHpa(cd *flaggerv1.Canary, init bool) error {
 }
 
 // makeAnnotations appends an unique ID to annotations map
-func (c *Deployer) makeAnnotations(annotations map[string]string) (map[string]string, error) {
+func (c *DeploymentController) makeAnnotations(annotations map[string]string) (map[string]string, error) {
 	idKey := "flagger-id"
 	res := make(map[string]string)
 	uuid := make([]byte, 16)
@@ -405,8 +407,8 @@ func (c *Deployer) makeAnnotations(annotations map[string]string) (map[string]st
 }
 
 // getSelectorLabel returns the selector match label
-func (c *Deployer) getSelectorLabel(deployment *appsv1.Deployment) (string, error) {
-	for _, l := range c.Labels {
+func (c *DeploymentController) getSelectorLabel(deployment *appsv1.Deployment) (string, error) {
+	for _, l := range c.labels {
 		if _, ok := deployment.Spec.Selector.MatchLabels[l]; ok {
 			return l, nil
 		}
@@ -420,8 +422,12 @@ var sidecars = map[string]bool{
 	"envoy":       true,
 }
 
+func (c *DeploymentController) HaveDependenciesChanged(cd *flaggerv1.Canary) (bool, error) {
+	return c.configTracker.HasConfigChanged(cd)
+}
+
 // getPorts returns a list of all container ports
-func (c *Deployer) getPorts(cd *flaggerv1.Canary, deployment *appsv1.Deployment) (map[string]int32, error) {
+func (c *DeploymentController) getPorts(cd *flaggerv1.Canary, deployment *appsv1.Deployment) (map[string]int32, error) {
 	ports := make(map[string]int32)
 
 	for _, container := range deployment.Spec.Template.Spec.Containers {

pkg/canary/deployment_controller_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestCanaryDeployer_Sync(t *testing.T) {
 	mocks := SetupMocks()
-	_, _, err := mocks.deployer.Initialize(mocks.canary, true)
+	err := mocks.deployer.Initialize(mocks.canary, true)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -96,7 +96,7 @@ func TestCanaryDeployer_Sync(t *testing.T) {
 
 func TestCanaryDeployer_IsNewSpec(t *testing.T) {
 	mocks := SetupMocks()
-	_, _, err := mocks.deployer.Initialize(mocks.canary, true)
+	err := mocks.deployer.Initialize(mocks.canary, true)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -107,7 +107,7 @@ func TestCanaryDeployer_IsNewSpec(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 
-	isNew, err := mocks.deployer.HasDeploymentChanged(mocks.canary)
+	isNew, err := mocks.deployer.HasTargetChanged(mocks.canary)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -119,7 +119,7 @@ func TestCanaryDeployer_IsNewSpec(t *testing.T) {
 
 func TestCanaryDeployer_Promote(t *testing.T) {
 	mocks := SetupMocks()
-	_, _, err := mocks.deployer.Initialize(mocks.canary, true)
+	err := mocks.deployer.Initialize(mocks.canary, true)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -185,7 +185,7 @@ func TestCanaryDeployer_Promote(t *testing.T) {
 
 func TestCanaryDeployer_IsReady(t *testing.T) {
 	mocks := SetupMocks()
-	_, _, err := mocks.deployer.Initialize(mocks.canary, true)
+	err := mocks.deployer.Initialize(mocks.canary, true)
 	if err != nil {
 		t.Error("Expected primary readiness check to fail")
 	}
@@ -203,7 +203,7 @@ func TestCanaryDeployer_IsReady(t *testing.T) {
 
 func TestCanaryDeployer_SetFailedChecks(t *testing.T) {
 	mocks := SetupMocks()
-	_, _, err := mocks.deployer.Initialize(mocks.canary, true)
+	err := mocks.deployer.Initialize(mocks.canary, true)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -225,7 +225,7 @@ func TestCanaryDeployer_SetFailedChecks(t *testing.T) {
 
 func TestCanaryDeployer_SetState(t *testing.T) {
 	mocks := SetupMocks()
-	_, _, err := mocks.deployer.Initialize(mocks.canary, true)
+	err := mocks.deployer.Initialize(mocks.canary, true)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -247,7 +247,7 @@ func TestCanaryDeployer_SetState(t *testing.T) {
 
 func TestCanaryDeployer_SyncStatus(t *testing.T) {
 	mocks := SetupMocks()
-	_, _, err := mocks.deployer.Initialize(mocks.canary, true)
+	err := mocks.deployer.Initialize(mocks.canary, true)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -286,7 +286,7 @@ func TestCanaryDeployer_SyncStatus(t *testing.T) {
 
 func TestCanaryDeployer_Scale(t *testing.T) {
 	mocks := SetupMocks()
-	_, _, err := mocks.deployer.Initialize(mocks.canary, true)
+	err := mocks.deployer.Initialize(mocks.canary, true)
 	if err != nil {
 		t.Fatal(err.Error())
 	}

pkg/canary/factory.go

@@ -0,0 +1,59 @@
+package canary
+
+import (
+	"go.uber.org/zap"
+	"k8s.io/client-go/kubernetes"
+
+	clientset "github.com/weaveworks/flagger/pkg/client/clientset/versioned"
+)
+
+type Factory struct {
+	kubeClient    kubernetes.Interface
+	flaggerClient clientset.Interface
+	logger        *zap.SugaredLogger
+	configTracker ConfigTracker
+	labels        []string
+}
+
+func NewFactory(kubeClient kubernetes.Interface,
+	flaggerClient clientset.Interface,
+	configTracker ConfigTracker,
+	labels []string,
+	logger *zap.SugaredLogger) *Factory {
+	return &Factory{
+		kubeClient:    kubeClient,
+		flaggerClient: flaggerClient,
+		logger:        logger,
+		configTracker: configTracker,
+		labels:        labels,
+	}
+}
+
+func (factory *Factory) Controller(kind string) Controller {
+	deploymentCtrl := &DeploymentController{
+		logger:        factory.logger,
+		kubeClient:    factory.kubeClient,
+		flaggerClient: factory.flaggerClient,
+		labels:        factory.labels,
+		configTracker: ConfigTracker{
+			Logger:        factory.logger,
+			KubeClient:    factory.kubeClient,
+			FlaggerClient: factory.flaggerClient,
+		},
+	}
+	serviceCtrl := &ServiceController{
+		logger:        factory.logger,
+		kubeClient:    factory.kubeClient,
+		flaggerClient: factory.flaggerClient,
+	}
+
+	switch {
+	case kind == "Deployment":
+		return deploymentCtrl
+	case kind == "Service":
+		return serviceCtrl
+	default:
+		return deploymentCtrl
+	}
+
+}

pkg/canary/mock.go

@@ -20,7 +20,7 @@ type Mocks struct {
 	canary        *flaggerv1.Canary
 	kubeClient    kubernetes.Interface
 	flaggerClient clientset.Interface
-	deployer      Deployer
+	deployer      DeploymentController
 	logger        *zap.SugaredLogger
 }
 
@@ -43,12 +43,12 @@ func SetupMocks() Mocks {
 
 	logger, _ := logger.NewLogger("debug")
 
-	deployer := Deployer{
-		FlaggerClient: flaggerClient,
-		KubeClient:    kubeClient,
-		Logger:        logger,
-		Labels:        []string{"app", "name"},
-		ConfigTracker: ConfigTracker{
+	deployer := DeploymentController{
+		flaggerClient: flaggerClient,
+		kubeClient:    kubeClient,
+		logger:        logger,
+		labels:        []string{"app", "name"},
+		configTracker: ConfigTracker{
 			Logger:        logger,
 			KubeClient:    kubeClient,
 			FlaggerClient: flaggerClient,

pkg/canary/ready.go

@@ -14,9 +14,9 @@ import (
 // IsPrimaryReady checks the primary deployment status and returns an error if
 // the deployment is in the middle of a rolling update or if the pods are unhealthy
 // it will return a non retriable error if the rolling update is stuck
-func (c *Deployer) IsPrimaryReady(cd *flaggerv1.Canary) (bool, error) {
+func (c *DeploymentController) IsPrimaryReady(cd *flaggerv1.Canary) (bool, error) {
 	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
-	primary, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(primaryName, metav1.GetOptions{})
+	primary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(primaryName, metav1.GetOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return true, fmt.Errorf("deployment %s.%s not found", primaryName, cd.Namespace)
@@ -39,9 +39,9 @@ func (c *Deployer) IsPrimaryReady(cd *flaggerv1.Canary) (bool, error) {
 // IsCanaryReady checks the primary deployment status and returns an error if
 // the deployment is in the middle of a rolling update or if the pods are unhealthy
 // it will return a non retriable error if the rolling update is stuck
-func (c *Deployer) IsCanaryReady(cd *flaggerv1.Canary) (bool, error) {
+func (c *DeploymentController) IsCanaryReady(cd *flaggerv1.Canary) (bool, error) {
 	targetName := cd.Spec.TargetRef.Name
-	canary, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	canary, err := c.kubeClient.AppsV1().Deployments(cd.Namespace).Get(targetName, metav1.GetOptions{})
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return true, fmt.Errorf("deployment %s.%s not found", targetName, cd.Namespace)
@@ -64,7 +64,7 @@ func (c *Deployer) IsCanaryReady(cd *flaggerv1.Canary) (bool, error) {
 
 // isDeploymentReady determines if a deployment is ready by checking the status conditions
 // if a deployment has exceeded the progress deadline it returns a non retriable error
-func (c *Deployer) isDeploymentReady(deployment *appsv1.Deployment, deadline int) (bool, error) {
+func (c *DeploymentController) isDeploymentReady(deployment *appsv1.Deployment, deadline int) (bool, error) {
 	retriable := true
 	if deployment.Generation <= deployment.Status.ObservedGeneration {
 		progress := c.getDeploymentCondition(deployment.Status, appsv1.DeploymentProgressing)
@@ -99,7 +99,7 @@ func (c *Deployer) isDeploymentReady(deployment *appsv1.Deployment, deadline int
 	return true, nil
 }
 
-func (c *Deployer) getDeploymentCondition(
+func (c *DeploymentController) getDeploymentCondition(
 	status appsv1.DeploymentStatus,
 	conditionType appsv1.DeploymentConditionType,
 ) *appsv1.DeploymentCondition {

pkg/canary/service_controller.go

@@ -0,0 +1,247 @@
+package canary
+
+import (
+	"fmt"
+
+	ex "github.com/pkg/errors"
+	"go.uber.org/zap"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/kubernetes"
+
+	flaggerv1 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
+	clientset "github.com/weaveworks/flagger/pkg/client/clientset/versioned"
+)
+
+// ServiceController is managing the operations for Kubernetes service kind
+type ServiceController struct {
+	kubeClient    kubernetes.Interface
+	flaggerClient clientset.Interface
+	logger        *zap.SugaredLogger
+}
+
+// SetStatusFailedChecks updates the canary failed checks counter
+func (c *ServiceController) SetStatusFailedChecks(cd *flaggerv1.Canary, val int) error {
+	return setStatusFailedChecks(c.flaggerClient, cd, val)
+}
+
+// SetStatusWeight updates the canary status weight value
+func (c *ServiceController) SetStatusWeight(cd *flaggerv1.Canary, val int) error {
+	return setStatusWeight(c.flaggerClient, cd, val)
+}
+
+// SetStatusIterations updates the canary status iterations value
+func (c *ServiceController) SetStatusIterations(cd *flaggerv1.Canary, val int) error {
+	return setStatusIterations(c.flaggerClient, cd, val)
+}
+
+// SetStatusPhase updates the canary status phase
+func (c *ServiceController) SetStatusPhase(cd *flaggerv1.Canary, phase flaggerv1.CanaryPhase) error {
+	return setStatusPhase(c.flaggerClient, cd, phase)
+}
+
+// GetMetadata returns the pod label selector and svc ports
+func (c *ServiceController) GetMetadata(cd *flaggerv1.Canary) (string, map[string]int32, error) {
+	return "", nil, nil
+}
+
+// Initialize creates or updates the primary and canary services to prepare for the canary release process targeted on the K8s service
+func (c *ServiceController) Initialize(cd *flaggerv1.Canary, skipLivenessChecks bool) (err error) {
+	targetName := cd.Spec.TargetRef.Name
+	primaryName := fmt.Sprintf("%s-primary", targetName)
+	canaryName := fmt.Sprintf("%s-canary", targetName)
+
+	svc, err := c.kubeClient.CoreV1().Services(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	if err != nil {
+		return err
+	}
+
+	// canary svc
+	err = c.reconcileCanaryService(cd, canaryName, svc)
+	if err != nil {
+		return err
+	}
+
+	// primary svc
+	err = c.reconcilePrimaryService(cd, primaryName, svc)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *ServiceController) reconcileCanaryService(canary *flaggerv1.Canary, name string, src *corev1.Service) error {
+	current, err := c.kubeClient.CoreV1().Services(canary.Namespace).Get(name, metav1.GetOptions{})
+	if errors.IsNotFound(err) {
+		return c.createService(canary, name, src)
+	}
+
+	if err != nil {
+		return fmt.Errorf("service %s query error %v", name, err)
+	}
+
+	new := buildService(canary, name, src)
+
+	if new.Spec.Type == "ClusterIP" {
+		// We can't change this immutable field
+		new.Spec.ClusterIP = current.Spec.ClusterIP
+	}
+
+	// We can't change this immutable field
+	new.ObjectMeta.UID = current.ObjectMeta.UID
+
+	new.ObjectMeta.ResourceVersion = current.ObjectMeta.ResourceVersion
+
+	_, err = c.kubeClient.CoreV1().Services(canary.Namespace).Update(new)
+	if err != nil {
+		return err
+	}
+
+	c.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).
+		Infof("Service %s.%s updated", new.GetName(), canary.Namespace)
+	return nil
+}
+
+func (c *ServiceController) reconcilePrimaryService(canary *flaggerv1.Canary, name string, src *corev1.Service) error {
+	_, err := c.kubeClient.CoreV1().Services(canary.Namespace).Get(name, metav1.GetOptions{})
+	if errors.IsNotFound(err) {
+		return c.createService(canary, name, src)
+	}
+
+	if err != nil {
+		return fmt.Errorf("service %s query error %v", name, err)
+	}
+
+	return nil
+}
+
+func (c *ServiceController) createService(canary *flaggerv1.Canary, name string, src *corev1.Service) error {
+	svc := buildService(canary, name, src)
+
+	if svc.Spec.Type == "ClusterIP" {
+		// Reset and let K8s assign the IP. Otherwise we get an error due to the IP is already assigned
+		svc.Spec.ClusterIP = ""
+	}
+
+	// Let K8s set this. Otherwise K8s API complains with "resourceVersion should not be set on objects to be created"
+	svc.ObjectMeta.ResourceVersion = ""
+
+	_, err := c.kubeClient.CoreV1().Services(canary.Namespace).Create(svc)
+	if err != nil {
+		return err
+	}
+
+	c.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).
+		Infof("Service %s.%s created", svc.GetName(), canary.Namespace)
+	return nil
+}
+
+func buildService(canary *flaggerv1.Canary, name string, src *corev1.Service) *corev1.Service {
+	svc := src.DeepCopy()
+	svc.ObjectMeta.Name = name
+	svc.ObjectMeta.Namespace = canary.Namespace
+	svc.ObjectMeta.OwnerReferences = []metav1.OwnerReference{
+		*metav1.NewControllerRef(canary, schema.GroupVersionKind{
+			Group:   flaggerv1.SchemeGroupVersion.Group,
+			Version: flaggerv1.SchemeGroupVersion.Version,
+			Kind:    flaggerv1.CanaryKind,
+		}),
+	}
+	_, exists := svc.ObjectMeta.Annotations["kubectl.kubernetes.io/last-applied-configuration"]
+	if exists {
+		// Leaving this results in updates from flagger to this svc never succeed due to resourceVersion mismatch:
+		//   Operation cannot be fulfilled on services "mysvc-canary": the object has been modified; please apply your changes to the latest version and try again
+		delete(svc.ObjectMeta.Annotations, "kubectl.kubernetes.io/last-applied-configuration")
+	}
+
+	return svc
+}
+
+// Promote copies target's spec from canary to primary
+func (c *ServiceController) Promote(cd *flaggerv1.Canary) error {
+	targetName := cd.Spec.TargetRef.Name
+	primaryName := fmt.Sprintf("%s-primary", targetName)
+
+	canary, err := c.kubeClient.CoreV1().Services(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("service %s.%s not found", targetName, cd.Namespace)
+		}
+		return fmt.Errorf("service %s.%s query error %v", targetName, cd.Namespace, err)
+	}
+
+	primary, err := c.kubeClient.CoreV1().Services(cd.Namespace).Get(primaryName, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("service %s.%s not found", primaryName, cd.Namespace)
+		}
+		return fmt.Errorf("service %s.%s query error %v", primaryName, cd.Namespace, err)
+	}
+
+	primaryCopy := canary.DeepCopy()
+	primaryCopy.ObjectMeta.Name = primary.ObjectMeta.Name
+	if primaryCopy.Spec.Type == "ClusterIP" {
+		primaryCopy.Spec.ClusterIP = primary.Spec.ClusterIP
+	}
+	primaryCopy.ObjectMeta.ResourceVersion = primary.ObjectMeta.ResourceVersion
+	primaryCopy.ObjectMeta.UID = primary.ObjectMeta.UID
+
+	// apply update
+	_, err = c.kubeClient.CoreV1().Services(cd.Namespace).Update(primaryCopy)
+	if err != nil {
+		return fmt.Errorf("updating service %s.%s spec failed: %v",
+			primaryCopy.GetName(), primaryCopy.Namespace, err)
+	}
+
+	return nil
+}
+
+// HasServiceChanged returns true if the canary service spec has changed
+func (c *ServiceController) HasTargetChanged(cd *flaggerv1.Canary) (bool, error) {
+	targetName := cd.Spec.TargetRef.Name
+	canary, err := c.kubeClient.CoreV1().Services(cd.Namespace).Get(targetName, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return false, fmt.Errorf("service %s.%s not found", targetName, cd.Namespace)
+		}
+		return false, fmt.Errorf("service %s.%s query error %v", targetName, cd.Namespace, err)
+	}
+
+	return hasSpecChanged(cd, canary.Spec)
+}
+
+// Scale sets the canary deployment replicas
+func (c *ServiceController) Scale(cd *flaggerv1.Canary, replicas int32) error {
+	return nil
+}
+
+func (c *ServiceController) ScaleFromZero(cd *flaggerv1.Canary) error {
+	return nil
+}
+
+func (c *ServiceController) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatus) error {
+	dep, err := c.kubeClient.CoreV1().Services(cd.Namespace).Get(cd.Spec.TargetRef.Name, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return fmt.Errorf("service %s.%s not found", cd.Spec.TargetRef.Name, cd.Namespace)
+		}
+		return ex.Wrap(err, "SyncStatus service query error")
+	}
+
+	return syncCanaryStatus(c.flaggerClient, cd, status, dep.Spec, func(cdCopy *flaggerv1.Canary) {})
+}
+
+func (c *ServiceController) HaveDependenciesChanged(cd *flaggerv1.Canary) (bool, error) {
+	return false, nil
+}
+
+func (c *ServiceController) IsPrimaryReady(cd *flaggerv1.Canary) (bool, error) {
+	return true, nil
+}
+
+func (c *ServiceController) IsCanaryReady(cd *flaggerv1.Canary) (bool, error) {
+	return true, nil
+}

pkg/canary/spec.go

@@ -0,0 +1,30 @@
+package canary
+
+import (
+	"fmt"
+
+	"github.com/mitchellh/hashstructure"
+	"github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
+)
+
+func hasSpecChanged(cd *v1alpha3.Canary, spec interface{}) (bool, error) {
+	if cd.Status.LastAppliedSpec == "" {
+		return true, nil
+	}
+
+	newHash, err := hashstructure.Hash(spec, nil)
+	if err != nil {
+		return false, fmt.Errorf("hash error %v", err)
+	}
+
+	// do not trigger a canary deployment on manual rollback
+	if cd.Status.LastPromotedSpec == fmt.Sprintf("%d", newHash) {
+		return false, nil
+	}
+
+	if cd.Status.LastAppliedSpec != fmt.Sprintf("%d", newHash) {
+		return true, nil
+	}
+
+	return false, nil
+}

pkg/canary/status.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/mitchellh/hashstructure"
 	ex "github.com/pkg/errors"
+	"github.com/weaveworks/flagger/pkg/client/clientset/versioned"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -14,8 +15,8 @@ import (
 )
 
 // SyncStatus encodes the canary pod spec and updates the canary status
-func (c *Deployer) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatus) error {
-	dep, err := c.KubeClient.AppsV1().Deployments(cd.Namespace).Get(cd.Spec.TargetRef.Name, metav1.GetOptions{})
+func (c *DeploymentController) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatus) error {
+	dep, 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)
@@ -23,12 +24,18 @@ func (c *Deployer) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatu
 		return ex.Wrap(err, "SyncStatus deployment query error")
 	}
 
-	configs, err := c.ConfigTracker.GetConfigRefs(cd)
+	configs, err := c.configTracker.GetConfigRefs(cd)
 	if err != nil {
 		return ex.Wrap(err, "SyncStatus configs query error")
 	}
 
-	hash, err := hashstructure.Hash(dep.Spec.Template, nil)
+	return syncCanaryStatus(c.flaggerClient, cd, status, dep.Spec.Template, func(cdCopy *flaggerv1.Canary) {
+		cdCopy.Status.TrackedConfigs = configs
+	})
+}
+
+func syncCanaryStatus(flaggerClient versioned.Interface, cd *flaggerv1.Canary, status flaggerv1.CanaryStatus, canaryResource interface{}, setAll func(cdCopy *flaggerv1.Canary)) error {
+	hash, err := hashstructure.Hash(canaryResource, nil)
 	if err != nil {
 		return ex.Wrap(err, "SyncStatus hash error")
 	}
@@ -37,7 +44,7 @@ func (c *Deployer) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatu
 	err = retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
 		var selErr error
 		if !firstTry {
-			cd, selErr = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
+			cd, selErr = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
 			if selErr != nil {
 				return selErr
 			}
@@ -49,13 +56,13 @@ func (c *Deployer) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatu
 		cdCopy.Status.Iterations = status.Iterations
 		cdCopy.Status.LastAppliedSpec = fmt.Sprintf("%d", hash)
 		cdCopy.Status.LastTransitionTime = metav1.Now()
-		cdCopy.Status.TrackedConfigs = configs
+		setAll(cdCopy)
 
-		if ok, conditions := c.MakeStatusConditions(cd.Status, status.Phase); ok {
+		if ok, conditions := MakeStatusConditions(cd.Status, status.Phase); ok {
 			cdCopy.Status.Conditions = conditions
 		}
 
-		_, err = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
+		_, err = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
 		firstTry = false
 		return
 	})
@@ -66,12 +73,16 @@ func (c *Deployer) SyncStatus(cd *flaggerv1.Canary, status flaggerv1.CanaryStatu
 }
 
 // SetStatusFailedChecks updates the canary failed checks counter
-func (c *Deployer) SetStatusFailedChecks(cd *flaggerv1.Canary, val int) error {
+func (c *DeploymentController) SetStatusFailedChecks(cd *flaggerv1.Canary, val int) error {
+	return setStatusFailedChecks(c.flaggerClient, cd, val)
+}
+
+func setStatusFailedChecks(flaggerClient versioned.Interface, cd *flaggerv1.Canary, val int) error {
 	firstTry := true
 	err := retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
 		var selErr error
 		if !firstTry {
-			cd, selErr = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
+			cd, selErr = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
 			if selErr != nil {
 				return selErr
 			}
@@ -80,7 +91,7 @@ func (c *Deployer) SetStatusFailedChecks(cd *flaggerv1.Canary, val int) error {
 		cdCopy.Status.FailedChecks = val
 		cdCopy.Status.LastTransitionTime = metav1.Now()
 
-		_, err = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
+		_, err = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
 		firstTry = false
 		return
 	})
@@ -91,12 +102,16 @@ func (c *Deployer) SetStatusFailedChecks(cd *flaggerv1.Canary, val int) error {
 }
 
 // SetStatusWeight updates the canary status weight value
-func (c *Deployer) SetStatusWeight(cd *flaggerv1.Canary, val int) error {
+func (c *DeploymentController) SetStatusWeight(cd *flaggerv1.Canary, val int) error {
+	return setStatusWeight(c.flaggerClient, cd, val)
+}
+
+func setStatusWeight(flaggerClient versioned.Interface, cd *flaggerv1.Canary, val int) error {
 	firstTry := true
 	err := retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
 		var selErr error
 		if !firstTry {
-			cd, selErr = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
+			cd, selErr = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
 			if selErr != nil {
 				return selErr
 			}
@@ -105,7 +120,7 @@ func (c *Deployer) SetStatusWeight(cd *flaggerv1.Canary, val int) error {
 		cdCopy.Status.CanaryWeight = val
 		cdCopy.Status.LastTransitionTime = metav1.Now()
 
-		_, err = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
+		_, err = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
 		firstTry = false
 		return
 	})
@@ -116,12 +131,16 @@ func (c *Deployer) SetStatusWeight(cd *flaggerv1.Canary, val int) error {
 }
 
 // SetStatusIterations updates the canary status iterations value
-func (c *Deployer) SetStatusIterations(cd *flaggerv1.Canary, val int) error {
+func (c *DeploymentController) SetStatusIterations(cd *flaggerv1.Canary, val int) error {
+	return setStatusIterations(c.flaggerClient, cd, val)
+}
+
+func setStatusIterations(flaggerClient versioned.Interface, cd *flaggerv1.Canary, val int) error {
 	firstTry := true
 	err := retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
 		var selErr error
 		if !firstTry {
-			cd, selErr = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
+			cd, selErr = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
 			if selErr != nil {
 				return selErr
 			}
@@ -131,7 +150,7 @@ func (c *Deployer) SetStatusIterations(cd *flaggerv1.Canary, val int) error {
 		cdCopy.Status.Iterations = val
 		cdCopy.Status.LastTransitionTime = metav1.Now()
 
-		_, err = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
+		_, err = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
 		firstTry = false
 		return
 	})
@@ -143,12 +162,16 @@ func (c *Deployer) SetStatusIterations(cd *flaggerv1.Canary, val int) error {
 }
 
 // SetStatusPhase updates the canary status phase
-func (c *Deployer) SetStatusPhase(cd *flaggerv1.Canary, phase flaggerv1.CanaryPhase) error {
+func (c *DeploymentController) SetStatusPhase(cd *flaggerv1.Canary, phase flaggerv1.CanaryPhase) error {
+	return setStatusPhase(c.flaggerClient, cd, phase)
+}
+
+func setStatusPhase(flaggerClient versioned.Interface, cd *flaggerv1.Canary, phase flaggerv1.CanaryPhase) error {
 	firstTry := true
 	err := retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
 		var selErr error
 		if !firstTry {
-			cd, selErr = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
+			cd, selErr = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).Get(cd.GetName(), metav1.GetOptions{})
 			if selErr != nil {
 				return selErr
 			}
@@ -167,11 +190,11 @@ func (c *Deployer) SetStatusPhase(cd *flaggerv1.Canary, phase flaggerv1.CanaryPh
 			cdCopy.Status.LastPromotedSpec = cd.Status.LastAppliedSpec
 		}
 
-		if ok, conditions := c.MakeStatusConditions(cdCopy.Status, phase); ok {
+		if ok, conditions := MakeStatusConditions(cdCopy.Status, phase); ok {
 			cdCopy.Status.Conditions = conditions
 		}
 
-		_, err = c.FlaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
+		_, err = flaggerClient.FlaggerV1alpha3().Canaries(cd.Namespace).UpdateStatus(cdCopy)
 		firstTry = false
 		return
 	})
@@ -181,8 +204,8 @@ func (c *Deployer) SetStatusPhase(cd *flaggerv1.Canary, phase flaggerv1.CanaryPh
 	return nil
 }
 
-// GetStatusCondition returns a condition based on type
-func (c *Deployer) getStatusCondition(status flaggerv1.CanaryStatus, conditionType flaggerv1.CanaryConditionType) *flaggerv1.CanaryCondition {
+// getStatusCondition returns a condition based on type
+func getStatusCondition(status flaggerv1.CanaryStatus, conditionType flaggerv1.CanaryConditionType) *flaggerv1.CanaryCondition {
 	for i := range status.Conditions {
 		c := status.Conditions[i]
 		if c.Type == conditionType {
@@ -193,9 +216,9 @@ func (c *Deployer) getStatusCondition(status flaggerv1.CanaryStatus, conditionTy
 }
 
 // MakeStatusCondition updates the canary status conditions based on canary phase
-func (c *Deployer) MakeStatusConditions(canaryStatus flaggerv1.CanaryStatus,
+func MakeStatusConditions(canaryStatus flaggerv1.CanaryStatus,
 	phase flaggerv1.CanaryPhase) (bool, []flaggerv1.CanaryCondition) {
-	currentCondition := c.getStatusCondition(canaryStatus, flaggerv1.PromotedType)
+	currentCondition := getStatusCondition(canaryStatus, flaggerv1.PromotedType)
 
 	message := "New deployment detected, starting initialization."
 	status := corev1.ConditionUnknown

pkg/client/clientset/versioned/clientset.go

@@ -23,6 +23,7 @@ import (
 	flaggerv1alpha3 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/flagger/v1alpha3"
 	gloov1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/gloo/v1"
 	networkingv1alpha3 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/istio/v1alpha3"
+	projectcontourv1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/projectcontour/v1"
 	splitv1alpha1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/smi/v1alpha1"
 	discovery "k8s.io/client-go/discovery"
 	rest "k8s.io/client-go/rest"
@@ -35,6 +36,7 @@ type Interface interface {
 	FlaggerV1alpha3() flaggerv1alpha3.FlaggerV1alpha3Interface
 	GlooV1() gloov1.GlooV1Interface
 	NetworkingV1alpha3() networkingv1alpha3.NetworkingV1alpha3Interface
+	ProjectcontourV1() projectcontourv1.ProjectcontourV1Interface
 	SplitV1alpha1() splitv1alpha1.SplitV1alpha1Interface
 }
 
@@ -46,6 +48,7 @@ type Clientset struct {
 	flaggerV1alpha3    *flaggerv1alpha3.FlaggerV1alpha3Client
 	glooV1             *gloov1.GlooV1Client
 	networkingV1alpha3 *networkingv1alpha3.NetworkingV1alpha3Client
+	projectcontourV1   *projectcontourv1.ProjectcontourV1Client
 	splitV1alpha1      *splitv1alpha1.SplitV1alpha1Client
 }
 
@@ -69,6 +72,11 @@ func (c *Clientset) NetworkingV1alpha3() networkingv1alpha3.NetworkingV1alpha3In
 	return c.networkingV1alpha3
 }
 
+// ProjectcontourV1 retrieves the ProjectcontourV1Client
+func (c *Clientset) ProjectcontourV1() projectcontourv1.ProjectcontourV1Interface {
+	return c.projectcontourV1
+}
+
 // SplitV1alpha1 retrieves the SplitV1alpha1Client
 func (c *Clientset) SplitV1alpha1() splitv1alpha1.SplitV1alpha1Interface {
 	return c.splitV1alpha1
@@ -106,6 +114,10 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
+	cs.projectcontourV1, err = projectcontourv1.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
 	cs.splitV1alpha1, err = splitv1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
@@ -126,6 +138,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 	cs.flaggerV1alpha3 = flaggerv1alpha3.NewForConfigOrDie(c)
 	cs.glooV1 = gloov1.NewForConfigOrDie(c)
 	cs.networkingV1alpha3 = networkingv1alpha3.NewForConfigOrDie(c)
+	cs.projectcontourV1 = projectcontourv1.NewForConfigOrDie(c)
 	cs.splitV1alpha1 = splitv1alpha1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
@@ -139,6 +152,7 @@ func New(c rest.Interface) *Clientset {
 	cs.flaggerV1alpha3 = flaggerv1alpha3.New(c)
 	cs.glooV1 = gloov1.New(c)
 	cs.networkingV1alpha3 = networkingv1alpha3.New(c)
+	cs.projectcontourV1 = projectcontourv1.New(c)
 	cs.splitV1alpha1 = splitv1alpha1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)

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

@@ -28,6 +28,8 @@ import (
 	fakegloov1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/gloo/v1/fake"
 	networkingv1alpha3 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/istio/v1alpha3"
 	fakenetworkingv1alpha3 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/istio/v1alpha3/fake"
+	projectcontourv1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/projectcontour/v1"
+	fakeprojectcontourv1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/projectcontour/v1/fake"
 	splitv1alpha1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/smi/v1alpha1"
 	fakesplitv1alpha1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/smi/v1alpha1/fake"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -104,6 +106,11 @@ func (c *Clientset) NetworkingV1alpha3() networkingv1alpha3.NetworkingV1alpha3In
 	return &fakenetworkingv1alpha3.FakeNetworkingV1alpha3{Fake: &c.Fake}
 }
 
+// ProjectcontourV1 retrieves the ProjectcontourV1Client
+func (c *Clientset) ProjectcontourV1() projectcontourv1.ProjectcontourV1Interface {
+	return &fakeprojectcontourv1.FakeProjectcontourV1{Fake: &c.Fake}
+}
+
 // SplitV1alpha1 retrieves the SplitV1alpha1Client
 func (c *Clientset) SplitV1alpha1() splitv1alpha1.SplitV1alpha1Interface {
 	return &fakesplitv1alpha1.FakeSplitV1alpha1{Fake: &c.Fake}

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

@@ -23,6 +23,7 @@ import (
 	flaggerv1alpha3 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
 	gloov1 "github.com/weaveworks/flagger/pkg/apis/gloo/v1"
 	networkingv1alpha3 "github.com/weaveworks/flagger/pkg/apis/istio/v1alpha3"
+	projectcontourv1 "github.com/weaveworks/flagger/pkg/apis/projectcontour/v1"
 	splitv1alpha1 "github.com/weaveworks/flagger/pkg/apis/smi/v1alpha1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
@@ -39,6 +40,7 @@ var localSchemeBuilder = runtime.SchemeBuilder{
 	flaggerv1alpha3.AddToScheme,
 	gloov1.AddToScheme,
 	networkingv1alpha3.AddToScheme,
+	projectcontourv1.AddToScheme,
 	splitv1alpha1.AddToScheme,
 }
 

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

@@ -23,6 +23,7 @@ import (
 	flaggerv1alpha3 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
 	gloov1 "github.com/weaveworks/flagger/pkg/apis/gloo/v1"
 	networkingv1alpha3 "github.com/weaveworks/flagger/pkg/apis/istio/v1alpha3"
+	projectcontourv1 "github.com/weaveworks/flagger/pkg/apis/projectcontour/v1"
 	splitv1alpha1 "github.com/weaveworks/flagger/pkg/apis/smi/v1alpha1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
@@ -39,6 +40,7 @@ var localSchemeBuilder = runtime.SchemeBuilder{
 	flaggerv1alpha3.AddToScheme,
 	gloov1.AddToScheme,
 	networkingv1alpha3.AddToScheme,
+	projectcontourv1.AddToScheme,
 	splitv1alpha1.AddToScheme,
 }
 

pkg/client/clientset/versioned/typed/projectcontour/v1/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated typed clients.
+package v1

pkg/client/clientset/versioned/typed/projectcontour/v1/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// Package fake has the automatically generated clients.
+package fake

pkg/client/clientset/versioned/typed/projectcontour/v1/fake/fake_httpproxy.go

@@ -0,0 +1,140 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	projectcontourv1 "github.com/weaveworks/flagger/pkg/apis/projectcontour/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeHTTPProxies implements HTTPProxyInterface
+type FakeHTTPProxies struct {
+	Fake *FakeProjectcontourV1
+	ns   string
+}
+
+var httpproxiesResource = schema.GroupVersionResource{Group: "projectcontour.io", Version: "v1", Resource: "httpproxies"}
+
+var httpproxiesKind = schema.GroupVersionKind{Group: "projectcontour.io", Version: "v1", Kind: "HTTPProxy"}
+
+// Get takes name of the hTTPProxy, and returns the corresponding hTTPProxy object, and an error if there is any.
+func (c *FakeHTTPProxies) Get(name string, options v1.GetOptions) (result *projectcontourv1.HTTPProxy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(httpproxiesResource, c.ns, name), &projectcontourv1.HTTPProxy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*projectcontourv1.HTTPProxy), err
+}
+
+// List takes label and field selectors, and returns the list of HTTPProxies that match those selectors.
+func (c *FakeHTTPProxies) List(opts v1.ListOptions) (result *projectcontourv1.HTTPProxyList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(httpproxiesResource, httpproxiesKind, c.ns, opts), &projectcontourv1.HTTPProxyList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &projectcontourv1.HTTPProxyList{ListMeta: obj.(*projectcontourv1.HTTPProxyList).ListMeta}
+	for _, item := range obj.(*projectcontourv1.HTTPProxyList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested hTTPProxies.
+func (c *FakeHTTPProxies) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(httpproxiesResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a hTTPProxy and creates it.  Returns the server's representation of the hTTPProxy, and an error, if there is any.
+func (c *FakeHTTPProxies) Create(hTTPProxy *projectcontourv1.HTTPProxy) (result *projectcontourv1.HTTPProxy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(httpproxiesResource, c.ns, hTTPProxy), &projectcontourv1.HTTPProxy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*projectcontourv1.HTTPProxy), err
+}
+
+// Update takes the representation of a hTTPProxy and updates it. Returns the server's representation of the hTTPProxy, and an error, if there is any.
+func (c *FakeHTTPProxies) Update(hTTPProxy *projectcontourv1.HTTPProxy) (result *projectcontourv1.HTTPProxy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(httpproxiesResource, c.ns, hTTPProxy), &projectcontourv1.HTTPProxy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*projectcontourv1.HTTPProxy), 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 *FakeHTTPProxies) UpdateStatus(hTTPProxy *projectcontourv1.HTTPProxy) (*projectcontourv1.HTTPProxy, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(httpproxiesResource, "status", c.ns, hTTPProxy), &projectcontourv1.HTTPProxy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*projectcontourv1.HTTPProxy), err
+}
+
+// Delete takes name of the hTTPProxy and deletes it. Returns an error if one occurs.
+func (c *FakeHTTPProxies) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(httpproxiesResource, c.ns, name), &projectcontourv1.HTTPProxy{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeHTTPProxies) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(httpproxiesResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &projectcontourv1.HTTPProxyList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched hTTPProxy.
+func (c *FakeHTTPProxies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *projectcontourv1.HTTPProxy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(httpproxiesResource, c.ns, name, pt, data, subresources...), &projectcontourv1.HTTPProxy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*projectcontourv1.HTTPProxy), err
+}

pkg/client/clientset/versioned/typed/projectcontour/v1/fake/fake_projectcontour_client.go

@@ -0,0 +1,40 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1 "github.com/weaveworks/flagger/pkg/client/clientset/versioned/typed/projectcontour/v1"
+	rest "k8s.io/client-go/rest"
+	testing "k8s.io/client-go/testing"
+)
+
+type FakeProjectcontourV1 struct {
+	*testing.Fake
+}
+
+func (c *FakeProjectcontourV1) HTTPProxies(namespace string) v1.HTTPProxyInterface {
+	return &FakeHTTPProxies{c, namespace}
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeProjectcontourV1) RESTClient() rest.Interface {
+	var ret *rest.RESTClient
+	return ret
+}

pkg/client/clientset/versioned/typed/projectcontour/v1/generated_expansion.go

@@ -0,0 +1,21 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1
+
+type HTTPProxyExpansion interface{}

pkg/client/clientset/versioned/typed/projectcontour/v1/httpproxy.go

@@ -0,0 +1,191 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1
+
+import (
+	"time"
+
+	v1 "github.com/weaveworks/flagger/pkg/apis/projectcontour/v1"
+	scheme "github.com/weaveworks/flagger/pkg/client/clientset/versioned/scheme"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	rest "k8s.io/client-go/rest"
+)
+
+// HTTPProxiesGetter has a method to return a HTTPProxyInterface.
+// A group's client should implement this interface.
+type HTTPProxiesGetter interface {
+	HTTPProxies(namespace string) HTTPProxyInterface
+}
+
+// HTTPProxyInterface has methods to work with HTTPProxy resources.
+type HTTPProxyInterface interface {
+	Create(*v1.HTTPProxy) (*v1.HTTPProxy, error)
+	Update(*v1.HTTPProxy) (*v1.HTTPProxy, error)
+	UpdateStatus(*v1.HTTPProxy) (*v1.HTTPProxy, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	DeleteCollection(options *metav1.DeleteOptions, listOptions metav1.ListOptions) error
+	Get(name string, options metav1.GetOptions) (*v1.HTTPProxy, error)
+	List(opts metav1.ListOptions) (*v1.HTTPProxyList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.HTTPProxy, err error)
+	HTTPProxyExpansion
+}
+
+// hTTPProxies implements HTTPProxyInterface
+type hTTPProxies struct {
+	client rest.Interface
+	ns     string
+}
+
+// newHTTPProxies returns a HTTPProxies
+func newHTTPProxies(c *ProjectcontourV1Client, namespace string) *hTTPProxies {
+	return &hTTPProxies{
+		client: c.RESTClient(),
+		ns:     namespace,
+	}
+}
+
+// Get takes name of the hTTPProxy, and returns the corresponding hTTPProxy object, and an error if there is any.
+func (c *hTTPProxies) Get(name string, options metav1.GetOptions) (result *v1.HTTPProxy, err error) {
+	result = &v1.HTTPProxy{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("httpproxies").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of HTTPProxies that match those selectors.
+func (c *hTTPProxies) List(opts metav1.ListOptions) (result *v1.HTTPProxyList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &v1.HTTPProxyList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("httpproxies").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested hTTPProxies.
+func (c *hTTPProxies) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	opts.Watch = true
+	return c.client.Get().
+		Namespace(c.ns).
+		Resource("httpproxies").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch()
+}
+
+// Create takes the representation of a hTTPProxy and creates it.  Returns the server's representation of the hTTPProxy, and an error, if there is any.
+func (c *hTTPProxies) Create(hTTPProxy *v1.HTTPProxy) (result *v1.HTTPProxy, err error) {
+	result = &v1.HTTPProxy{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("httpproxies").
+		Body(hTTPProxy).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a hTTPProxy and updates it. Returns the server's representation of the hTTPProxy, and an error, if there is any.
+func (c *hTTPProxies) Update(hTTPProxy *v1.HTTPProxy) (result *v1.HTTPProxy, err error) {
+	result = &v1.HTTPProxy{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("httpproxies").
+		Name(hTTPProxy.Name).
+		Body(hTTPProxy).
+		Do().
+		Into(result)
+	return
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+
+func (c *hTTPProxies) UpdateStatus(hTTPProxy *v1.HTTPProxy) (result *v1.HTTPProxy, err error) {
+	result = &v1.HTTPProxy{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("httpproxies").
+		Name(hTTPProxy.Name).
+		SubResource("status").
+		Body(hTTPProxy).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the hTTPProxy and deletes it. Returns an error if one occurs.
+func (c *hTTPProxies) Delete(name string, options *metav1.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("httpproxies").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *hTTPProxies) DeleteCollection(options *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
+	var timeout time.Duration
+	if listOptions.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("httpproxies").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched hTTPProxy.
+func (c *hTTPProxies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.HTTPProxy, err error) {
+	result = &v1.HTTPProxy{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("httpproxies").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

pkg/client/clientset/versioned/typed/projectcontour/v1/projectcontour_client.go

@@ -0,0 +1,89 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1
+
+import (
+	v1 "github.com/weaveworks/flagger/pkg/apis/projectcontour/v1"
+	"github.com/weaveworks/flagger/pkg/client/clientset/versioned/scheme"
+	rest "k8s.io/client-go/rest"
+)
+
+type ProjectcontourV1Interface interface {
+	RESTClient() rest.Interface
+	HTTPProxiesGetter
+}
+
+// ProjectcontourV1Client is used to interact with features provided by the projectcontour.io group.
+type ProjectcontourV1Client struct {
+	restClient rest.Interface
+}
+
+func (c *ProjectcontourV1Client) HTTPProxies(namespace string) HTTPProxyInterface {
+	return newHTTPProxies(c, namespace)
+}
+
+// NewForConfig creates a new ProjectcontourV1Client for the given config.
+func NewForConfig(c *rest.Config) (*ProjectcontourV1Client, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &ProjectcontourV1Client{client}, nil
+}
+
+// NewForConfigOrDie creates a new ProjectcontourV1Client for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *ProjectcontourV1Client {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new ProjectcontourV1Client for the given RESTClient.
+func New(c rest.Interface) *ProjectcontourV1Client {
+	return &ProjectcontourV1Client{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	gv := v1.SchemeGroupVersion
+	config.GroupVersion = &gv
+	config.APIPath = "/apis"
+	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+
+	return nil
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *ProjectcontourV1Client) RESTClient() rest.Interface {
+	if c == nil {
+		return nil
+	}
+	return c.restClient
+}

pkg/client/informers/externalversions/factory.go

@@ -29,6 +29,7 @@ import (
 	gloo "github.com/weaveworks/flagger/pkg/client/informers/externalversions/gloo"
 	internalinterfaces "github.com/weaveworks/flagger/pkg/client/informers/externalversions/internalinterfaces"
 	istio "github.com/weaveworks/flagger/pkg/client/informers/externalversions/istio"
+	projectcontour "github.com/weaveworks/flagger/pkg/client/informers/externalversions/projectcontour"
 	smi "github.com/weaveworks/flagger/pkg/client/informers/externalversions/smi"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
@@ -180,6 +181,7 @@ type SharedInformerFactory interface {
 	Flagger() flagger.Interface
 	Gloo() gloo.Interface
 	Networking() istio.Interface
+	Projectcontour() projectcontour.Interface
 	Split() smi.Interface
 }
 
@@ -199,6 +201,10 @@ func (f *sharedInformerFactory) Networking() istio.Interface {
 	return istio.New(f, f.namespace, f.tweakListOptions)
 }
 
+func (f *sharedInformerFactory) Projectcontour() projectcontour.Interface {
+	return projectcontour.New(f, f.namespace, f.tweakListOptions)
+}
+
 func (f *sharedInformerFactory) Split() smi.Interface {
 	return smi.New(f, f.namespace, f.tweakListOptions)
 }

pkg/client/informers/externalversions/generic.go

@@ -25,6 +25,7 @@ import (
 	v1alpha3 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
 	v1 "github.com/weaveworks/flagger/pkg/apis/gloo/v1"
 	istiov1alpha3 "github.com/weaveworks/flagger/pkg/apis/istio/v1alpha3"
+	projectcontourv1 "github.com/weaveworks/flagger/pkg/apis/projectcontour/v1"
 	v1alpha1 "github.com/weaveworks/flagger/pkg/apis/smi/v1alpha1"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
 	cache "k8s.io/client-go/tools/cache"
@@ -78,6 +79,10 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 	case istiov1alpha3.SchemeGroupVersion.WithResource("virtualservices"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1alpha3().VirtualServices().Informer()}, nil
 
+		// Group=projectcontour.io, Version=v1
+	case projectcontourv1.SchemeGroupVersion.WithResource("httpproxies"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Projectcontour().V1().HTTPProxies().Informer()}, nil
+
 		// Group=split.smi-spec.io, Version=v1alpha1
 	case v1alpha1.SchemeGroupVersion.WithResource("trafficsplits"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Split().V1alpha1().TrafficSplits().Informer()}, nil

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

@@ -0,0 +1,46 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package projectcontour
+
+import (
+	internalinterfaces "github.com/weaveworks/flagger/pkg/client/informers/externalversions/internalinterfaces"
+	v1 "github.com/weaveworks/flagger/pkg/client/informers/externalversions/projectcontour/v1"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1 provides access to shared informers for resources in V1.
+	V1() v1.Interface
+}
+
+type group struct {
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// V1 returns a new v1.Interface.
+func (g *group) V1() v1.Interface {
+	return v1.New(g.factory, g.namespace, g.tweakListOptions)
+}

pkg/client/informers/externalversions/projectcontour/v1/httpproxy.go

@@ -0,0 +1,89 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1
+
+import (
+	time "time"
+
+	projectcontourv1 "github.com/weaveworks/flagger/pkg/apis/projectcontour/v1"
+	versioned "github.com/weaveworks/flagger/pkg/client/clientset/versioned"
+	internalinterfaces "github.com/weaveworks/flagger/pkg/client/informers/externalversions/internalinterfaces"
+	v1 "github.com/weaveworks/flagger/pkg/client/listers/projectcontour/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// HTTPProxyInformer provides access to a shared informer and lister for
+// HTTPProxies.
+type HTTPProxyInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.HTTPProxyLister
+}
+
+type hTTPProxyInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewHTTPProxyInformer constructs a new informer for HTTPProxy type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewHTTPProxyInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredHTTPProxyInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredHTTPProxyInformer constructs a new informer for HTTPProxy type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredHTTPProxyInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ProjectcontourV1().HTTPProxies(namespace).List(options)
+			},
+			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ProjectcontourV1().HTTPProxies(namespace).Watch(options)
+			},
+		},
+		&projectcontourv1.HTTPProxy{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *hTTPProxyInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredHTTPProxyInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *hTTPProxyInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&projectcontourv1.HTTPProxy{}, f.defaultInformer)
+}
+
+func (f *hTTPProxyInformer) Lister() v1.HTTPProxyLister {
+	return v1.NewHTTPProxyLister(f.Informer().GetIndexer())
+}

pkg/client/informers/externalversions/projectcontour/v1/interface.go

@@ -0,0 +1,45 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1
+
+import (
+	internalinterfaces "github.com/weaveworks/flagger/pkg/client/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// HTTPProxies returns a HTTPProxyInformer.
+	HTTPProxies() HTTPProxyInformer
+}
+
+type version struct {
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// HTTPProxies returns a HTTPProxyInformer.
+func (v *version) HTTPProxies() HTTPProxyInformer {
+	return &hTTPProxyInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}

pkg/client/listers/projectcontour/v1/expansion_generated.go

@@ -0,0 +1,27 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package v1
+
+// HTTPProxyListerExpansion allows custom methods to be added to
+// HTTPProxyLister.
+type HTTPProxyListerExpansion interface{}
+
+// HTTPProxyNamespaceListerExpansion allows custom methods to be added to
+// HTTPProxyNamespaceLister.
+type HTTPProxyNamespaceListerExpansion interface{}

pkg/client/listers/projectcontour/v1/httpproxy.go

@@ -0,0 +1,94 @@
+/*
+Copyright The Flagger Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package v1
+
+import (
+	v1 "github.com/weaveworks/flagger/pkg/apis/projectcontour/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+)
+
+// HTTPProxyLister helps list HTTPProxies.
+type HTTPProxyLister interface {
+	// List lists all HTTPProxies in the indexer.
+	List(selector labels.Selector) (ret []*v1.HTTPProxy, err error)
+	// HTTPProxies returns an object that can list and get HTTPProxies.
+	HTTPProxies(namespace string) HTTPProxyNamespaceLister
+	HTTPProxyListerExpansion
+}
+
+// hTTPProxyLister implements the HTTPProxyLister interface.
+type hTTPProxyLister struct {
+	indexer cache.Indexer
+}
+
+// NewHTTPProxyLister returns a new HTTPProxyLister.
+func NewHTTPProxyLister(indexer cache.Indexer) HTTPProxyLister {
+	return &hTTPProxyLister{indexer: indexer}
+}
+
+// List lists all HTTPProxies in the indexer.
+func (s *hTTPProxyLister) List(selector labels.Selector) (ret []*v1.HTTPProxy, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*v1.HTTPProxy))
+	})
+	return ret, err
+}
+
+// HTTPProxies returns an object that can list and get HTTPProxies.
+func (s *hTTPProxyLister) HTTPProxies(namespace string) HTTPProxyNamespaceLister {
+	return hTTPProxyNamespaceLister{indexer: s.indexer, namespace: namespace}
+}
+
+// HTTPProxyNamespaceLister helps list and get HTTPProxies.
+type HTTPProxyNamespaceLister interface {
+	// List lists all HTTPProxies in the indexer for a given namespace.
+	List(selector labels.Selector) (ret []*v1.HTTPProxy, err error)
+	// Get retrieves the HTTPProxy from the indexer for a given namespace and name.
+	Get(name string) (*v1.HTTPProxy, error)
+	HTTPProxyNamespaceListerExpansion
+}
+
+// hTTPProxyNamespaceLister implements the HTTPProxyNamespaceLister
+// interface.
+type hTTPProxyNamespaceLister struct {
+	indexer   cache.Indexer
+	namespace string
+}
+
+// List lists all HTTPProxies in the indexer for a given namespace.
+func (s hTTPProxyNamespaceLister) List(selector labels.Selector) (ret []*v1.HTTPProxy, err error) {
+	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
+		ret = append(ret, m.(*v1.HTTPProxy))
+	})
+	return ret, err
+}
+
+// Get retrieves the HTTPProxy from the indexer for a given namespace and name.
+func (s hTTPProxyNamespaceLister) Get(name string) (*v1.HTTPProxy, error) {
+	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(v1.Resource("httpproxy"), name)
+	}
+	return obj.(*v1.HTTPProxy), nil
+}

pkg/controller/controller.go

@@ -45,9 +45,9 @@ type Controller struct {
 	logger          *zap.SugaredLogger
 	canaries        *sync.Map
 	jobs            map[string]CanaryJob
-	deployer        canary.Deployer
 	recorder        metrics.Recorder
 	notifier        notifier.Interface
+	canaryFactory   *canary.Factory
 	routerFactory   *router.Factory
 	observerFactory *metrics.Factory
 	meshProvider    string
@@ -61,11 +61,11 @@ func NewController(
 	flaggerWindow time.Duration,
 	logger *zap.SugaredLogger,
 	notifier notifier.Interface,
+	canaryFactory *canary.Factory,
 	routerFactory *router.Factory,
 	observerFactory *metrics.Factory,
 	meshProvider string,
 	version string,
-	labels []string,
 ) *Controller {
 	logger.Debug("Creating event broadcaster")
 	flaggerscheme.AddToScheme(scheme.Scheme)
@@ -76,19 +76,6 @@ func NewController(
 	})
 	eventRecorder := eventBroadcaster.NewRecorder(
 		scheme.Scheme, corev1.EventSource{Component: controllerAgentName})
-
-	deployer := canary.Deployer{
-		Logger:        logger,
-		KubeClient:    kubeClient,
-		FlaggerClient: flaggerClient,
-		Labels:        labels,
-		ConfigTracker: canary.ConfigTracker{
-			Logger:        logger,
-			KubeClient:    kubeClient,
-			FlaggerClient: flaggerClient,
-		},
-	}
-
 	recorder := metrics.NewRecorder(controllerAgentName, true)
 	recorder.SetInfo(version, meshProvider)
 
@@ -104,10 +91,10 @@ func NewController(
 		canaries:        new(sync.Map),
 		jobs:            map[string]CanaryJob{},
 		flaggerWindow:   flaggerWindow,
-		deployer:        deployer,
 		observerFactory: observerFactory,
 		recorder:        recorder,
 		notifier:        notifier,
+		canaryFactory:   canaryFactory,
 		routerFactory:   routerFactory,
 		meshProvider:    meshProvider,
 	}
@@ -218,7 +205,7 @@ func (c *Controller) syncHandler(key string) error {
 
 	// set status condition for new canaries
 	if cd.Status.Conditions == nil {
-		if ok, conditions := c.deployer.MakeStatusConditions(cd.Status, flaggerv1.CanaryPhaseInitializing); ok {
+		if ok, conditions := canary.MakeStatusConditions(cd.Status, flaggerv1.CanaryPhaseInitializing); ok {
 			cdCopy := cd.DeepCopy()
 			cdCopy.Status.Conditions = conditions
 			cdCopy.Status.LastTransitionTime = metav1.Now()

pkg/controller/controller_test.go

@@ -10,6 +10,7 @@ import (
 	hpav2 "k8s.io/api/autoscaling/v2beta1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/kubernetes/fake"
 	"k8s.io/client-go/tools/record"
@@ -37,7 +38,7 @@ type Mocks struct {
 	kubeClient    kubernetes.Interface
 	meshClient    clientset.Interface
 	flaggerClient clientset.Interface
-	deployer      canary.Deployer
+	deployer      canary.Controller
 	ctrl          *Controller
 	logger        *zap.SugaredLogger
 	router        router.Interface
@@ -52,6 +53,7 @@ func SetupMocks(c *flaggerv1.Canary) Mocks {
 	// init kube clientset and register mock objects
 	kubeClient := fake.NewSimpleClientset(
 		newTestDeployment(),
+		newTestService(),
 		newTestHPA(),
 		NewTestConfigMap(),
 		NewTestConfigMapEnv(),
@@ -63,19 +65,6 @@ func SetupMocks(c *flaggerv1.Canary) Mocks {
 
 	logger, _ := logger.NewLogger("debug")
 
-	// init controller helpers
-	deployer := canary.Deployer{
-		Logger:        logger,
-		KubeClient:    kubeClient,
-		FlaggerClient: flaggerClient,
-		Labels:        []string{"app", "name"},
-		ConfigTracker: canary.ConfigTracker{
-			Logger:        logger,
-			KubeClient:    kubeClient,
-			FlaggerClient: flaggerClient,
-		},
-	}
-
 	// init controller
 	flaggerInformerFactory := informers.NewSharedInformerFactory(flaggerClient, noResyncPeriodFunc())
 	flaggerInformer := flaggerInformerFactory.Flagger().V1alpha3().Canaries()
@@ -84,7 +73,15 @@ func SetupMocks(c *flaggerv1.Canary) Mocks {
 	rf := router.NewFactory(nil, kubeClient, flaggerClient, "annotationsPrefix", logger, flaggerClient)
 
 	// init observer
-	observerFactory, _ := metrics.NewFactory("fake", "istio", 5*time.Second)
+	observerFactory, _ := metrics.NewFactory("fake", 5*time.Second)
+
+	// init canary factory
+	configTracker := canary.ConfigTracker{
+		Logger:        logger,
+		KubeClient:    kubeClient,
+		FlaggerClient: flaggerClient,
+	}
+	canaryFactory := canary.NewFactory(kubeClient, flaggerClient, configTracker, []string{"app", "name"}, logger)
 
 	ctrl := &Controller{
 		kubeClient:      kubeClient,
@@ -97,7 +94,7 @@ func SetupMocks(c *flaggerv1.Canary) Mocks {
 		logger:          logger,
 		canaries:        new(sync.Map),
 		flaggerWindow:   time.Second,
-		deployer:        deployer,
+		canaryFactory:   canaryFactory,
 		observerFactory: observerFactory,
 		recorder:        metrics.NewRecorder(controllerAgentName, false),
 		routerFactory:   rf,
@@ -108,7 +105,7 @@ func SetupMocks(c *flaggerv1.Canary) Mocks {
 
 	return Mocks{
 		canary:        c,
-		deployer:      deployer,
+		deployer:      canaryFactory.Controller("Deployment"),
 		logger:        logger,
 		flaggerClient: flaggerClient,
 		meshClient:    flaggerClient,
@@ -560,6 +557,58 @@ func newTestDeploymentV2() *appsv1.Deployment {
 	return d
 }
 
+func newTestService() *corev1.Service {
+	d := &corev1.Service{
+		TypeMeta: metav1.TypeMeta{APIVersion: appsv1.SchemeGroupVersion.String()},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "podinfo",
+		},
+		Spec: corev1.ServiceSpec{
+			Selector: map[string]string{
+				"app": "podinfo",
+			},
+			Type: corev1.ServiceTypeClusterIP,
+			Ports: []corev1.ServicePort{
+				{
+					Name:       "http",
+					Port:       9898,
+					Protocol:   corev1.ProtocolTCP,
+					TargetPort: intstr.FromString("http"),
+				},
+			},
+		},
+	}
+
+	return d
+}
+
+func newTestServiceV2() *corev1.Service {
+	d := &corev1.Service{
+		TypeMeta: metav1.TypeMeta{APIVersion: appsv1.SchemeGroupVersion.String()},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "podinfo",
+		},
+		Spec: corev1.ServiceSpec{
+			Selector: map[string]string{
+				"app": "podinfo-v2",
+			},
+			Type: corev1.ServiceTypeClusterIP,
+			Ports: []corev1.ServicePort{
+				{
+					Name:       "http",
+					Port:       9898,
+					Protocol:   corev1.ProtocolTCP,
+					TargetPort: intstr.FromString("http"),
+				},
+			},
+		},
+	}
+
+	return d
+}
+
 func newTestHPA() *hpav2.HorizontalPodAutoscaler {
 	h := &hpav2.HorizontalPodAutoscaler{
 		TypeMeta: metav1.TypeMeta{APIVersion: hpav2.SchemeGroupVersion.String()},

pkg/controller/scheduler.go

@@ -2,16 +2,21 @@ package controller
 
 import (
 	"fmt"
-	"github.com/weaveworks/flagger/pkg/metrics"
 	"strings"
 	"time"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	flaggerv1 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
+	"github.com/weaveworks/flagger/pkg/canary"
+	"github.com/weaveworks/flagger/pkg/metrics"
 	"github.com/weaveworks/flagger/pkg/router"
 )
 
+const (
+	MetricsProviderServiceSuffix = ":service"
+)
+
 // scheduleCanaries synchronises the canary map with the jobs map,
 // for new canaries new jobs are created and started
 // for the removed canaries the jobs are stopped and deleted
@@ -89,43 +94,51 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 		return
 	}
 
-	primaryName := fmt.Sprintf("%s-primary", cd.Spec.TargetRef.Name)
-
 	// override the global provider if one is specified in the canary spec
 	provider := c.meshProvider
 	if cd.Spec.Provider != "" {
 		provider = cd.Spec.Provider
 	}
 
-	// create primary deployment and hpa if needed
-	// skip primary check for Istio since the deployment will become ready after the ClusterIP are created
-	skipPrimaryCheck := false
-	if skipLivenessChecks || strings.Contains(provider, "istio") || strings.Contains(provider, "appmesh") {
-		skipPrimaryCheck = true
-	}
-	labelSelector, ports, err := c.deployer.Initialize(cd, skipPrimaryCheck)
+	// init controller based on target kind
+	canaryController := c.canaryFactory.Controller(cd.Spec.TargetRef.Kind)
+	labelSelector, ports, err := canaryController.GetMetadata(cd)
 	if err != nil {
 		c.recordEventWarningf(cd, "%v", err)
 		return
 	}
 
-	// init routers
-	meshRouter := c.routerFactory.MeshRouter(provider)
-
-	// create or update ClusterIP services
-	if err := c.routerFactory.KubernetesRouter(labelSelector, map[string]string{}, ports).Reconcile(cd); err != nil {
+	// init Kubernetes router
+	router := c.routerFactory.KubernetesRouter(cd.Spec.TargetRef.Kind, labelSelector, map[string]string{}, ports)
+	if err := router.Initialize(cd); err != nil {
 		c.recordEventWarningf(cd, "%v", err)
 		return
 	}
 
-	// create or update virtual service
+	// create primary deployment and hpa
+	err = canaryController.Initialize(cd, skipLivenessChecks)
+	if err != nil {
+		c.recordEventWarningf(cd, "%v", err)
+		return
+	}
+
+	// init mesh router
+	meshRouter := c.routerFactory.MeshRouter(provider)
+
+	// create or update svc
+	if err := router.Reconcile(cd); err != nil {
+		c.recordEventWarningf(cd, "%v", err)
+		return
+	}
+
+	// create or update mesh routes
 	if err := meshRouter.Reconcile(cd); err != nil {
 		c.recordEventWarningf(cd, "%v", err)
 		return
 	}
 
-	// check for deployment spec or configs changes
-	shouldAdvance, err := c.shouldAdvance(cd)
+	// check for changes
+	shouldAdvance, err := c.shouldAdvance(cd, canaryController)
 	if err != nil {
 		c.recordEventWarningf(cd, "%v", err)
 		return
@@ -137,7 +150,7 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 	}
 
 	// check gates
-	if isApproved := c.runConfirmRolloutHooks(cd); !isApproved {
+	if isApproved := c.runConfirmRolloutHooks(cd, canaryController); !isApproved {
 		return
 	}
 
@@ -148,8 +161,8 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 	}
 
 	// check primary deployment status
-	if !skipLivenessChecks {
-		if _, err := c.deployer.IsPrimaryReady(cd); err != nil {
+	if !skipLivenessChecks && !cd.Spec.SkipAnalysis {
+		if _, err := canaryController.IsPrimaryReady(cd); err != nil {
 			c.recordEventWarningf(cd, "%v", err)
 			return
 		}
@@ -165,12 +178,12 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 	c.recorder.SetWeight(cd, primaryWeight, canaryWeight)
 
 	// check if canary analysis should start (canary revision has changes) or continue
-	if ok := c.checkCanaryStatus(cd, shouldAdvance); !ok {
+	if ok := c.checkCanaryStatus(cd, canaryController, shouldAdvance); !ok {
 		return
 	}
 
 	// check if canary revision changed during analysis
-	if restart := c.hasCanaryRevisionChanged(cd); restart {
+	if restart := c.hasCanaryRevisionChanged(cd, canaryController); restart {
 		c.recordEventInfof(cd, "New revision detected! Restarting analysis for %s.%s",
 			cd.Spec.TargetRef.Name, cd.Namespace)
 
@@ -189,21 +202,17 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 			FailedChecks: 0,
 			Iterations:   0,
 		}
-		if err := c.deployer.SyncStatus(cd, status); err != nil {
+		if err := canaryController.SyncStatus(cd, status); err != nil {
 			c.recordEventWarningf(cd, "%v", err)
 			return
 		}
 		return
 	}
 
-	defer func() {
-		c.recorder.SetDuration(cd, time.Since(begin))
-	}()
-
 	// check canary deployment status
 	var retriable = true
 	if !skipLivenessChecks {
-		retriable, err = c.deployer.IsCanaryReady(cd)
+		retriable, err = canaryController.IsCanaryReady(cd)
 		if err != nil && retriable {
 			c.recordEventWarningf(cd, "%v", err)
 			return
@@ -211,7 +220,7 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 	}
 
 	// check if analysis should be skipped
-	if skip := c.shouldSkipAnalysis(cd, meshRouter, primaryWeight, canaryWeight); skip {
+	if skip := c.shouldSkipAnalysis(cd, canaryController, meshRouter, primaryWeight, canaryWeight); skip {
 		return
 	}
 
@@ -227,7 +236,7 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 		}
 
 		// update status phase
-		if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhaseFinalising); err != nil {
+		if err := canaryController.SetStatusPhase(cd, flaggerv1.CanaryPhaseFinalising); err != nil {
 			c.recordEventWarningf(cd, "%v", err)
 			return
 		}
@@ -237,13 +246,13 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 
 	// scale canary to zero if promotion has finished
 	if cd.Status.Phase == flaggerv1.CanaryPhaseFinalising {
-		if err := c.deployer.Scale(cd, 0); err != nil {
+		if err := canaryController.Scale(cd, 0); err != nil {
 			c.recordEventWarningf(cd, "%v", err)
 			return
 		}
 
 		// set status to succeeded
-		if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhaseSucceeded); err != nil {
+		if err := canaryController.SetStatusPhase(cd, flaggerv1.CanaryPhaseSucceeded); err != nil {
 			c.recordEventWarningf(cd, "%v", err)
 			return
 		}
@@ -286,13 +295,13 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 			cd.Name, cd.Namespace)
 
 		// shutdown canary
-		if err := c.deployer.Scale(cd, 0); err != nil {
+		if err := canaryController.Scale(cd, 0); err != nil {
 			c.recordEventWarningf(cd, "%v", err)
 			return
 		}
 
 		// mark canary as failed
-		if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseFailed, CanaryWeight: 0}); err != nil {
+		if err := canaryController.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseFailed, CanaryWeight: 0}); err != nil {
 			c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Errorf("%v", err)
 			return
 		}
@@ -302,6 +311,11 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 		return
 	}
 
+	// record analysis duration
+	defer func() {
+		c.recorder.SetDuration(cd, time.Since(begin))
+	}()
+
 	// check if the canary success rate is above the threshold
 	// skip check if no traffic is routed or mirrored to canary
 	if canaryWeight == 0 && cd.Status.Iterations == 0 &&
@@ -310,15 +324,15 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 
 		// run pre-rollout web hooks
 		if ok := c.runPreRolloutHooks(cd); !ok {
-			if err := c.deployer.SetStatusFailedChecks(cd, cd.Status.FailedChecks+1); err != nil {
+			if err := canaryController.SetStatusFailedChecks(cd, cd.Status.FailedChecks+1); err != nil {
 				c.recordEventWarningf(cd, "%v", err)
 				return
 			}
 			return
 		}
 	} else {
-		if ok := c.analyseCanary(cd); !ok {
-			if err := c.deployer.SetStatusFailedChecks(cd, cd.Status.FailedChecks+1); err != nil {
+		if ok := c.runAnalysis(cd); !ok {
+			if err := canaryController.SetStatusFailedChecks(cd, cd.Status.FailedChecks+1); err != nil {
 				c.recordEventWarningf(cd, "%v", err)
 				return
 			}
@@ -341,255 +355,267 @@ func (c *Controller) advanceCanary(name string, namespace string, skipLivenessCh
 
 	// strategy: A/B testing
 	if len(cd.Spec.CanaryAnalysis.Match) > 0 && cd.Spec.CanaryAnalysis.Iterations > 0 {
-		// route traffic to canary and increment iterations
-		if cd.Spec.CanaryAnalysis.Iterations > cd.Status.Iterations {
-			if err := meshRouter.SetRoutes(cd, 0, 100, false); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-			c.recorder.SetWeight(cd, 0, 100)
-
-			if err := c.deployer.SetStatusIterations(cd, cd.Status.Iterations+1); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-			c.recordEventInfof(cd, "Advance %s.%s canary iteration %v/%v",
-				cd.Name, cd.Namespace, cd.Status.Iterations+1, cd.Spec.CanaryAnalysis.Iterations)
-			return
-		}
-
-		// check promotion gate
-		if promote := c.runConfirmPromotionHooks(cd); !promote {
-			return
-		}
-
-		// promote canary - max iterations reached
-		if cd.Spec.CanaryAnalysis.Iterations == cd.Status.Iterations {
-			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
-			}
-
-			// update status phase
-			if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhasePromoting); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-			return
-		}
-
+		c.runAB(cd, canaryController, meshRouter, provider)
 		return
 	}
 
 	// strategy: Blue/Green
 	if cd.Spec.CanaryAnalysis.Iterations > 0 {
-		// increment iterations
-		if cd.Spec.CanaryAnalysis.Iterations > cd.Status.Iterations {
-			// If in "mirror" mode, mirror requests during the entire B/G canary test
-			if provider != "kubernetes" &&
-				cd.Spec.CanaryAnalysis.Mirror == true && mirrored == false {
-				if err := meshRouter.SetRoutes(cd, 100, 0, true); err != nil {
-					c.recordEventWarningf(cd, "%v", err)
-				}
-				c.logger.With("canary", fmt.Sprintf("%s.%s", name, namespace)).
-					Infof("Start traffic mirroring")
-			}
-			if err := c.deployer.SetStatusIterations(cd, cd.Status.Iterations+1); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-			c.recordEventInfof(cd, "Advance %s.%s canary iteration %v/%v",
-				cd.Name, cd.Namespace, cd.Status.Iterations+1, cd.Spec.CanaryAnalysis.Iterations)
-			return
-		}
-
-		// check promotion gate
-		if promote := c.runConfirmPromotionHooks(cd); !promote {
-			return
-		}
-
-		// route all traffic to canary - max iterations reached
-		if cd.Spec.CanaryAnalysis.Iterations == cd.Status.Iterations {
-			if provider != "kubernetes" {
-				if cd.Spec.CanaryAnalysis.Mirror {
-					c.recordEventInfof(cd, "Stop traffic mirroring and route all traffic to canary")
-				} else {
-					c.recordEventInfof(cd, "Routing all traffic to canary")
-				}
-				if err := meshRouter.SetRoutes(cd, 0, 100, false); err != nil {
-					c.recordEventWarningf(cd, "%v", err)
-					return
-				}
-				c.recorder.SetWeight(cd, 0, 100)
-			}
-
-			// increment iterations
-			if err := c.deployer.SetStatusIterations(cd, cd.Status.Iterations+1); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-			return
-		}
-
-		// promote canary - max iterations reached
-		if cd.Spec.CanaryAnalysis.Iterations < cd.Status.Iterations {
-			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
-			}
-
-			// update status phase
-			if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhasePromoting); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-			return
-		}
-
+		c.runBlueGreen(cd, canaryController, meshRouter, provider, mirrored)
 		return
 	}
 
 	// strategy: Canary progressive traffic increase
 	if cd.Spec.CanaryAnalysis.StepWeight > 0 {
-		// increase traffic weight
-		if canaryWeight < maxWeight {
-			// If in "mirror" mode, do one step of mirroring before shifting traffic to canary.
-			// When mirroring, all requests go to primary and canary, but only responses from
-			// primary go back to the user.
-			if cd.Spec.CanaryAnalysis.Mirror && canaryWeight == 0 {
-				if mirrored == false {
-					mirrored = true
-					primaryWeight = 100
-					canaryWeight = 0
-				} else {
-					mirrored = false
-					primaryWeight = 100 - cd.Spec.CanaryAnalysis.StepWeight
-					canaryWeight = cd.Spec.CanaryAnalysis.StepWeight
-				}
-				c.logger.With("canary", fmt.Sprintf("%s.%s", name, namespace)).
-					Infof("Running mirror step %d/%d/%t", primaryWeight, canaryWeight, mirrored)
-			} else {
-
-				primaryWeight -= cd.Spec.CanaryAnalysis.StepWeight
-				if primaryWeight < 0 {
-					primaryWeight = 0
-				}
-				canaryWeight += cd.Spec.CanaryAnalysis.StepWeight
-				if canaryWeight > 100 {
-					canaryWeight = 100
-				}
-			}
-
-			if err := meshRouter.SetRoutes(cd, primaryWeight, canaryWeight, mirrored); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-
-			if err := c.deployer.SetStatusWeight(cd, canaryWeight); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-
-			c.recorder.SetWeight(cd, primaryWeight, canaryWeight)
-			c.recordEventInfof(cd, "Advance %s.%s canary weight %v", cd.Name, cd.Namespace, canaryWeight)
-			return
-		}
-
-		// promote canary - max weight reached
-		if canaryWeight >= maxWeight {
-			// check promotion gate
-			if promote := c.runConfirmPromotionHooks(cd); !promote {
-				return
-			}
-
-			// update primary spec
-			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
-			}
-
-			// update status phase
-			if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhasePromoting); err != nil {
-				c.recordEventWarningf(cd, "%v", err)
-				return
-			}
-
-			return
-		}
-
+		c.runCanary(cd, canaryController, meshRouter, provider, mirrored, canaryWeight, primaryWeight, maxWeight)
 	}
 
 }
 
-func (c *Controller) shouldSkipAnalysis(cd *flaggerv1.Canary, meshRouter router.Interface, primaryWeight int, canaryWeight int) bool {
-	if !cd.Spec.SkipAnalysis {
+func (c *Controller) runCanary(canary *flaggerv1.Canary, canaryController canary.Controller, meshRouter router.Interface, provider string, mirrored bool, canaryWeight int, primaryWeight int, maxWeight int) {
+	primaryName := fmt.Sprintf("%s-primary", canary.Spec.TargetRef.Name)
+
+	// increase traffic weight
+	if canaryWeight < maxWeight {
+		// If in "mirror" mode, do one step of mirroring before shifting traffic to canary.
+		// When mirroring, all requests go to primary and canary, but only responses from
+		// primary go back to the user.
+		if canary.Spec.CanaryAnalysis.Mirror && canaryWeight == 0 {
+			if mirrored == false {
+				mirrored = true
+				primaryWeight = 100
+				canaryWeight = 0
+			} else {
+				mirrored = false
+				primaryWeight = 100 - canary.Spec.CanaryAnalysis.StepWeight
+				canaryWeight = canary.Spec.CanaryAnalysis.StepWeight
+			}
+			c.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).
+				Infof("Running mirror step %d/%d/%t", primaryWeight, canaryWeight, mirrored)
+		} else {
+
+			primaryWeight -= canary.Spec.CanaryAnalysis.StepWeight
+			if primaryWeight < 0 {
+				primaryWeight = 0
+			}
+			canaryWeight += canary.Spec.CanaryAnalysis.StepWeight
+			if canaryWeight > 100 {
+				canaryWeight = 100
+			}
+		}
+
+		if err := meshRouter.SetRoutes(canary, primaryWeight, canaryWeight, mirrored); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+
+		if err := canaryController.SetStatusWeight(canary, canaryWeight); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+
+		c.recorder.SetWeight(canary, primaryWeight, canaryWeight)
+		c.recordEventInfof(canary, "Advance %s.%s canary weight %v", canary.Name, canary.Namespace, canaryWeight)
+		return
+	}
+
+	// promote canary - max weight reached
+	if canaryWeight >= maxWeight {
+		// check promotion gate
+		if promote := c.runConfirmPromotionHooks(canary); !promote {
+			return
+		}
+
+		// update primary spec
+		c.recordEventInfof(canary, "Copying %s.%s template spec to %s.%s",
+			canary.Spec.TargetRef.Name, canary.Namespace, primaryName, canary.Namespace)
+		if err := canaryController.Promote(canary); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+
+		// update status phase
+		if err := canaryController.SetStatusPhase(canary, flaggerv1.CanaryPhasePromoting); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+	}
+}
+
+func (c *Controller) runAB(canary *flaggerv1.Canary, canaryController canary.Controller, meshRouter router.Interface, provider string) {
+	primaryName := fmt.Sprintf("%s-primary", canary.Spec.TargetRef.Name)
+
+	// route traffic to canary and increment iterations
+	if canary.Spec.CanaryAnalysis.Iterations > canary.Status.Iterations {
+		if err := meshRouter.SetRoutes(canary, 0, 100, false); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+		c.recorder.SetWeight(canary, 0, 100)
+
+		if err := canaryController.SetStatusIterations(canary, canary.Status.Iterations+1); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+		c.recordEventInfof(canary, "Advance %s.%s canary iteration %v/%v",
+			canary.Name, canary.Namespace, canary.Status.Iterations+1, canary.Spec.CanaryAnalysis.Iterations)
+		return
+	}
+
+	// check promotion gate
+	if promote := c.runConfirmPromotionHooks(canary); !promote {
+		return
+	}
+
+	// promote canary - max iterations reached
+	if canary.Spec.CanaryAnalysis.Iterations == canary.Status.Iterations {
+		c.recordEventInfof(canary, "Copying %s.%s template spec to %s.%s",
+			canary.Spec.TargetRef.Name, canary.Namespace, primaryName, canary.Namespace)
+		if err := canaryController.Promote(canary); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+
+		// update status phase
+		if err := canaryController.SetStatusPhase(canary, flaggerv1.CanaryPhasePromoting); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+	}
+}
+
+func (c *Controller) runBlueGreen(canary *flaggerv1.Canary, canaryController canary.Controller, meshRouter router.Interface, provider string, mirrored bool) {
+	primaryName := fmt.Sprintf("%s-primary", canary.Spec.TargetRef.Name)
+
+	// increment iterations
+	if canary.Spec.CanaryAnalysis.Iterations > canary.Status.Iterations {
+		// If in "mirror" mode, mirror requests during the entire B/G canary test
+		if provider != "kubernetes" &&
+			canary.Spec.CanaryAnalysis.Mirror == true && mirrored == false {
+			if err := meshRouter.SetRoutes(canary, 100, 0, true); err != nil {
+				c.recordEventWarningf(canary, "%v", err)
+			}
+			c.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).
+				Infof("Start traffic mirroring")
+		}
+		if err := canaryController.SetStatusIterations(canary, canary.Status.Iterations+1); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+		c.recordEventInfof(canary, "Advance %s.%s canary iteration %v/%v",
+			canary.Name, canary.Namespace, canary.Status.Iterations+1, canary.Spec.CanaryAnalysis.Iterations)
+		return
+	}
+
+	// check promotion gate
+	if promote := c.runConfirmPromotionHooks(canary); !promote {
+		return
+	}
+
+	// route all traffic to canary - max iterations reached
+	if canary.Spec.CanaryAnalysis.Iterations == canary.Status.Iterations {
+		if provider != "kubernetes" {
+			if canary.Spec.CanaryAnalysis.Mirror {
+				c.recordEventInfof(canary, "Stop traffic mirroring and route all traffic to canary")
+			} else {
+				c.recordEventInfof(canary, "Routing all traffic to canary")
+			}
+			if err := meshRouter.SetRoutes(canary, 0, 100, false); err != nil {
+				c.recordEventWarningf(canary, "%v", err)
+				return
+			}
+			c.recorder.SetWeight(canary, 0, 100)
+		}
+
+		// increment iterations
+		if err := canaryController.SetStatusIterations(canary, canary.Status.Iterations+1); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+		return
+	}
+
+	// promote canary - max iterations reached
+	if canary.Spec.CanaryAnalysis.Iterations < canary.Status.Iterations {
+		c.recordEventInfof(canary, "Copying %s.%s template spec to %s.%s",
+			canary.Spec.TargetRef.Name, canary.Namespace, primaryName, canary.Namespace)
+		if err := canaryController.Promote(canary); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+
+		// update status phase
+		if err := canaryController.SetStatusPhase(canary, flaggerv1.CanaryPhasePromoting); err != nil {
+			c.recordEventWarningf(canary, "%v", err)
+			return
+		}
+	}
+
+}
+
+func (c *Controller) shouldSkipAnalysis(canary *flaggerv1.Canary, canaryController canary.Controller, meshRouter router.Interface, primaryWeight int, canaryWeight int) bool {
+	if !canary.Spec.SkipAnalysis {
 		return false
 	}
 
 	// route all traffic to primary
 	primaryWeight = 100
 	canaryWeight = 0
-	if err := meshRouter.SetRoutes(cd, primaryWeight, canaryWeight, false); err != nil {
-		c.recordEventWarningf(cd, "%v", err)
+	if err := meshRouter.SetRoutes(canary, primaryWeight, canaryWeight, false); err != nil {
+		c.recordEventWarningf(canary, "%v", err)
 		return false
 	}
-	c.recorder.SetWeight(cd, primaryWeight, canaryWeight)
+	c.recorder.SetWeight(canary, primaryWeight, canaryWeight)
 
 	// copy spec and configs from canary to primary
-	c.recordEventInfof(cd, "Copying %s.%s template spec to %s-primary.%s",
-		cd.Spec.TargetRef.Name, cd.Namespace, cd.Spec.TargetRef.Name, cd.Namespace)
-	if err := c.deployer.Promote(cd); err != nil {
-		c.recordEventWarningf(cd, "%v", err)
+	c.recordEventInfof(canary, "Copying %s.%s template spec to %s-primary.%s",
+		canary.Spec.TargetRef.Name, canary.Namespace, canary.Spec.TargetRef.Name, canary.Namespace)
+	if err := canaryController.Promote(canary); err != nil {
+		c.recordEventWarningf(canary, "%v", err)
 		return false
 	}
 
 	// shutdown canary
-	if err := c.deployer.Scale(cd, 0); err != nil {
-		c.recordEventWarningf(cd, "%v", err)
+	if err := canaryController.Scale(canary, 0); err != nil {
+		c.recordEventWarningf(canary, "%v", err)
 		return false
 	}
 
 	// update status phase
-	if err := c.deployer.SetStatusPhase(cd, flaggerv1.CanaryPhaseSucceeded); err != nil {
-		c.recordEventWarningf(cd, "%v", err)
+	if err := canaryController.SetStatusPhase(canary, flaggerv1.CanaryPhaseSucceeded); err != nil {
+		c.recordEventWarningf(canary, "%v", err)
 		return false
 	}
 
 	// notify
-	c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseSucceeded)
-	c.recordEventInfof(cd, "Promotion completed! Canary analysis was skipped for %s.%s",
-		cd.Spec.TargetRef.Name, cd.Namespace)
-	c.sendNotification(cd, "Canary analysis was skipped, promotion finished.",
+	c.recorder.SetStatus(canary, flaggerv1.CanaryPhaseSucceeded)
+	c.recordEventInfof(canary, "Promotion completed! Canary analysis was skipped for %s.%s",
+		canary.Spec.TargetRef.Name, canary.Namespace)
+	c.sendNotification(canary, "Canary analysis was skipped, promotion finished.",
 		false, false)
 
 	return true
 }
 
-func (c *Controller) shouldAdvance(cd *flaggerv1.Canary) (bool, error) {
-	if cd.Status.LastAppliedSpec == "" ||
-		cd.Status.Phase == flaggerv1.CanaryPhaseInitializing ||
-		cd.Status.Phase == flaggerv1.CanaryPhaseProgressing ||
-		cd.Status.Phase == flaggerv1.CanaryPhaseWaiting ||
-		cd.Status.Phase == flaggerv1.CanaryPhasePromoting ||
-		cd.Status.Phase == flaggerv1.CanaryPhaseFinalising {
+func (c *Controller) shouldAdvance(canary *flaggerv1.Canary, canaryController canary.Controller) (bool, error) {
+	if canary.Status.LastAppliedSpec == "" ||
+		canary.Status.Phase == flaggerv1.CanaryPhaseInitializing ||
+		canary.Status.Phase == flaggerv1.CanaryPhaseProgressing ||
+		canary.Status.Phase == flaggerv1.CanaryPhaseWaiting ||
+		canary.Status.Phase == flaggerv1.CanaryPhasePromoting ||
+		canary.Status.Phase == flaggerv1.CanaryPhaseFinalising {
 		return true, nil
 	}
 
-	newDep, err := c.deployer.HasDeploymentChanged(cd)
+	newTarget, err := canaryController.HasTargetChanged(canary)
 	if err != nil {
 		return false, err
 	}
-	if newDep {
-		return newDep, nil
+	if newTarget {
+		return newTarget, nil
 	}
 
-	newCfg, err := c.deployer.ConfigTracker.HasConfigChanged(cd)
+	newCfg, err := canaryController.HaveDependenciesChanged(canary)
 	if err != nil {
 		return false, err
 	}
@@ -598,63 +624,63 @@ func (c *Controller) shouldAdvance(cd *flaggerv1.Canary) (bool, error) {
 
 }
 
-func (c *Controller) checkCanaryStatus(cd *flaggerv1.Canary, shouldAdvance bool) bool {
-	c.recorder.SetStatus(cd, cd.Status.Phase)
-	if cd.Status.Phase == flaggerv1.CanaryPhaseProgressing ||
-		cd.Status.Phase == flaggerv1.CanaryPhasePromoting ||
-		cd.Status.Phase == flaggerv1.CanaryPhaseFinalising {
+func (c *Controller) checkCanaryStatus(canary *flaggerv1.Canary, canaryController canary.Controller, shouldAdvance bool) bool {
+	c.recorder.SetStatus(canary, canary.Status.Phase)
+	if canary.Status.Phase == flaggerv1.CanaryPhaseProgressing ||
+		canary.Status.Phase == flaggerv1.CanaryPhasePromoting ||
+		canary.Status.Phase == flaggerv1.CanaryPhaseFinalising {
 		return true
 	}
 
-	if cd.Status.Phase == "" || cd.Status.Phase == flaggerv1.CanaryPhaseInitializing {
-		if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseInitialized}); err != nil {
-			c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Errorf("%v", err)
+	if canary.Status.Phase == "" || canary.Status.Phase == flaggerv1.CanaryPhaseInitializing {
+		if err := canaryController.SyncStatus(canary, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseInitialized}); err != nil {
+			c.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).Errorf("%v", err)
 			return false
 		}
-		c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseInitialized)
-		c.recordEventInfof(cd, "Initialization done! %s.%s", cd.Name, cd.Namespace)
-		c.sendNotification(cd, "New deployment detected, initialization completed.",
+		c.recorder.SetStatus(canary, flaggerv1.CanaryPhaseInitialized)
+		c.recordEventInfof(canary, "Initialization done! %s.%s", canary.Name, canary.Namespace)
+		c.sendNotification(canary, "New deployment detected, initialization completed.",
 			true, false)
 		return false
 	}
 
 	if shouldAdvance {
-		c.recordEventInfof(cd, "New revision detected! Scaling up %s.%s", cd.Spec.TargetRef.Name, cd.Namespace)
-		c.sendNotification(cd, "New revision detected, starting canary analysis.",
+		c.recordEventInfof(canary, "New revision detected! Scaling up %s.%s", canary.Spec.TargetRef.Name, canary.Namespace)
+		c.sendNotification(canary, "New revision detected, starting canary analysis.",
 			true, false)
-		if err := c.deployer.ScaleUp(cd); err != nil {
-			c.recordEventErrorf(cd, "%v", err)
+		if err := canaryController.ScaleFromZero(canary); err != nil {
+			c.recordEventErrorf(canary, "%v", err)
 			return false
 		}
-		if err := c.deployer.SyncStatus(cd, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseProgressing}); err != nil {
-			c.logger.With("canary", fmt.Sprintf("%s.%s", cd.Name, cd.Namespace)).Errorf("%v", err)
+		if err := canaryController.SyncStatus(canary, flaggerv1.CanaryStatus{Phase: flaggerv1.CanaryPhaseProgressing}); err != nil {
+			c.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).Errorf("%v", err)
 			return false
 		}
-		c.recorder.SetStatus(cd, flaggerv1.CanaryPhaseProgressing)
+		c.recorder.SetStatus(canary, flaggerv1.CanaryPhaseProgressing)
 		return false
 	}
 	return false
 }
 
-func (c *Controller) hasCanaryRevisionChanged(cd *flaggerv1.Canary) bool {
-	if cd.Status.Phase == flaggerv1.CanaryPhaseProgressing {
-		if diff, _ := c.deployer.HasDeploymentChanged(cd); diff {
+func (c *Controller) hasCanaryRevisionChanged(canary *flaggerv1.Canary, canaryController canary.Controller) bool {
+	if canary.Status.Phase == flaggerv1.CanaryPhaseProgressing {
+		if diff, _ := canaryController.HasTargetChanged(canary); diff {
 			return true
 		}
-		if diff, _ := c.deployer.ConfigTracker.HasConfigChanged(cd); diff {
+		if diff, _ := canaryController.HaveDependenciesChanged(canary); diff {
 			return true
 		}
 	}
 	return false
 }
 
-func (c *Controller) runConfirmRolloutHooks(canary *flaggerv1.Canary) bool {
+func (c *Controller) runConfirmRolloutHooks(canary *flaggerv1.Canary, canaryController canary.Controller) bool {
 	for _, webhook := range canary.Spec.CanaryAnalysis.Webhooks {
 		if webhook.Type == flaggerv1.ConfirmRolloutHook {
 			err := CallWebhook(canary.Name, canary.Namespace, flaggerv1.CanaryPhaseProgressing, webhook)
 			if err != nil {
 				if canary.Status.Phase != flaggerv1.CanaryPhaseWaiting {
-					if err := c.deployer.SetStatusPhase(canary, flaggerv1.CanaryPhaseWaiting); err != nil {
+					if err := canaryController.SetStatusPhase(canary, flaggerv1.CanaryPhaseWaiting); err != nil {
 						c.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).Errorf("%v", err)
 					}
 					c.recordEventWarningf(canary, "Halt %s.%s advancement waiting for approval %s",
@@ -664,7 +690,7 @@ func (c *Controller) runConfirmRolloutHooks(canary *flaggerv1.Canary) bool {
 				return false
 			} else {
 				if canary.Status.Phase == flaggerv1.CanaryPhaseWaiting {
-					if err := c.deployer.SetStatusPhase(canary, flaggerv1.CanaryPhaseProgressing); err != nil {
+					if err := canaryController.SetStatusPhase(canary, flaggerv1.CanaryPhaseProgressing); err != nil {
 						c.logger.With("canary", fmt.Sprintf("%s.%s", canary.Name, canary.Namespace)).Errorf("%v", err)
 						return false
 					}
@@ -725,7 +751,7 @@ func (c *Controller) runPostRolloutHooks(canary *flaggerv1.Canary, phase flagger
 	return true
 }
 
-func (c *Controller) analyseCanary(r *flaggerv1.Canary) bool {
+func (c *Controller) runAnalysis(r *flaggerv1.Canary) bool {
 	// run external checks
 	for _, webhook := range r.Spec.CanaryAnalysis.Webhooks {
 		if webhook.Type == "" || webhook.Type == flaggerv1.RolloutHook {
@@ -739,15 +765,27 @@ func (c *Controller) analyseCanary(r *flaggerv1.Canary) bool {
 	}
 
 	// override the global provider if one is specified in the canary spec
-	metricsProvider := c.meshProvider
+	var metricsProvider string
+	// set the metrics provider to Crossover Prometheus when Crossover is the mesh provider
+	// For example, `crossover` metrics provider should be used for `smi:crossover` mesh provider
+	if strings.Contains(c.meshProvider, "crossover") {
+		metricsProvider = "crossover"
+	} else {
+		metricsProvider = c.meshProvider
+	}
+
 	if r.Spec.Provider != "" {
 		metricsProvider = r.Spec.Provider
 
-		// set the metrics server to Linkerd Prometheus when Linkerd is the default mesh provider
+		// set the metrics provider to Linkerd Prometheus when Linkerd is the default mesh provider
 		if strings.Contains(c.meshProvider, "linkerd") {
 			metricsProvider = "linkerd"
 		}
 	}
+	// set the metrics provider to query Prometheus for the canary Kubernetes service if the canary target is Service
+	if r.Spec.TargetRef.Kind == "Service" {
+		metricsProvider = metricsProvider + MetricsProviderServiceSuffix
+	}
 
 	// create observer based on the mesh provider
 	observerFactory := c.observerFactory
@@ -757,7 +795,7 @@ func (c *Controller) analyseCanary(r *flaggerv1.Canary) bool {
 	if r.Spec.MetricsServer != "" {
 		metricsServer = r.Spec.MetricsServer
 		var err error
-		observerFactory, err = metrics.NewFactory(metricsServer, metricsProvider, 5*time.Second)
+		observerFactory, err = metrics.NewFactory(metricsServer, 5*time.Second)
 		if err != nil {
 			c.recordEventErrorf(r, "Error building Prometheus client for %s %v", r.Spec.MetricsServer, err)
 			return false
@@ -775,8 +813,8 @@ func (c *Controller) analyseCanary(r *flaggerv1.Canary) bool {
 			val, err := observer.GetRequestSuccessRate(r.Spec.TargetRef.Name, r.Namespace, metric.Interval)
 			if err != nil {
 				if strings.Contains(err.Error(), "no values found") {
-					c.recordEventWarningf(r, "Halt advancement no values found for metric %s probably %s.%s is not receiving traffic",
-						metric.Name, r.Spec.TargetRef.Name, r.Namespace)
+					c.recordEventWarningf(r, "Halt advancement no values found for %s metric %s probably %s.%s is not receiving traffic",
+						metricsProvider, metric.Name, r.Spec.TargetRef.Name, r.Namespace)
 				} else {
 					c.recordEventErrorf(r, "Metrics server %s query failed: %v", metricsServer, err)
 				}
@@ -795,8 +833,8 @@ func (c *Controller) analyseCanary(r *flaggerv1.Canary) bool {
 			val, err := observer.GetRequestDuration(r.Spec.TargetRef.Name, r.Namespace, metric.Interval)
 			if err != nil {
 				if strings.Contains(err.Error(), "no values found") {
-					c.recordEventWarningf(r, "Halt advancement no values found for metric %s probably %s.%s is not receiving traffic",
-						metric.Name, r.Spec.TargetRef.Name, r.Namespace)
+					c.recordEventWarningf(r, "Halt advancement no values found for %s metric %s probably %s.%s is not receiving traffic",
+						metricsProvider, metric.Name, r.Spec.TargetRef.Name, r.Namespace)
 				} else {
 					c.recordEventErrorf(r, "Metrics server %s query failed: %v", metricsServer, err)
 				}

pkg/controller/scheduler_svc_test.go

@@ -0,0 +1,166 @@
+package controller
+
+import (
+	"testing"
+
+	hpav1 "k8s.io/api/autoscaling/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	flaggerv1 "github.com/weaveworks/flagger/pkg/apis/flagger/v1alpha3"
+)
+
+func TestScheduler_ServicePromotion(t *testing.T) {
+	mocks := SetupMocks(newTestServiceCanary())
+
+	// init
+	mocks.ctrl.advanceCanary("podinfo", "default", true)
+
+	// check initialized status
+	c, err := mocks.flaggerClient.FlaggerV1alpha3().Canaries("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if c.Status.Phase != flaggerv1.CanaryPhaseInitialized {
+		t.Errorf("Got canary state %v wanted %v", c.Status.Phase, flaggerv1.CanaryPhaseInitialized)
+	}
+
+	// update
+	svc2 := newTestServiceV2()
+	_, err = mocks.kubeClient.CoreV1().Services("default").Update(svc2)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	// detect service spec changes
+	mocks.ctrl.advanceCanary("podinfo", "default", true)
+
+	primaryWeight, canaryWeight, mirrored, err := mocks.router.GetRoutes(mocks.canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	primaryWeight = 60
+	canaryWeight = 40
+	err = mocks.router.SetRoutes(mocks.canary, primaryWeight, canaryWeight, mirrored)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	// advance
+	mocks.ctrl.advanceCanary("podinfo", "default", true)
+
+	// check progressing status
+	c, err = mocks.flaggerClient.FlaggerV1alpha3().Canaries("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if c.Status.Phase != flaggerv1.CanaryPhaseProgressing {
+		t.Errorf("Got canary state %v wanted %v", c.Status.Phase, flaggerv1.CanaryPhaseProgressing)
+	}
+
+	// promote
+	mocks.ctrl.advanceCanary("podinfo", "default", true)
+
+	// check promoting status
+	c, err = mocks.flaggerClient.FlaggerV1alpha3().Canaries("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if c.Status.Phase != flaggerv1.CanaryPhasePromoting {
+		t.Errorf("Got canary state %v wanted %v", c.Status.Phase, flaggerv1.CanaryPhasePromoting)
+	}
+
+	// finalise
+	mocks.ctrl.advanceCanary("podinfo", "default", true)
+
+	primaryWeight, canaryWeight, mirrored, err = mocks.router.GetRoutes(mocks.canary)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if primaryWeight != 100 {
+		t.Errorf("Got primary route %v wanted %v", primaryWeight, 100)
+	}
+
+	if canaryWeight != 0 {
+		t.Errorf("Got canary route %v wanted %v", canaryWeight, 0)
+	}
+
+	if mirrored != false {
+		t.Errorf("Got mirrored %v wanted %v", mirrored, false)
+	}
+
+	primarySvc, err := mocks.kubeClient.CoreV1().Services("default").Get("podinfo-primary", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	primaryLabelValue := primarySvc.Spec.Selector["app"]
+	canaryLabelValue := svc2.Spec.Selector["app"]
+	if primaryLabelValue != canaryLabelValue {
+		t.Errorf("Got primary selector label value %v wanted %v", primaryLabelValue, canaryLabelValue)
+	}
+
+	// check finalising status
+	c, err = mocks.flaggerClient.FlaggerV1alpha3().Canaries("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if c.Status.Phase != flaggerv1.CanaryPhaseFinalising {
+		t.Errorf("Got canary state %v wanted %v", c.Status.Phase, flaggerv1.CanaryPhaseFinalising)
+	}
+
+	// scale canary to zero
+	mocks.ctrl.advanceCanary("podinfo", "default", true)
+
+	c, err = mocks.flaggerClient.FlaggerV1alpha3().Canaries("default").Get("podinfo", metav1.GetOptions{})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if c.Status.Phase != flaggerv1.CanaryPhaseSucceeded {
+		t.Errorf("Got canary state %v wanted %v", c.Status.Phase, flaggerv1.CanaryPhaseSucceeded)
+	}
+}
+
+func newTestServiceCanary() *flaggerv1.Canary {
+	cd := &flaggerv1.Canary{
+		TypeMeta: metav1.TypeMeta{APIVersion: flaggerv1.SchemeGroupVersion.String()},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "podinfo",
+		},
+		Spec: flaggerv1.CanarySpec{
+			TargetRef: hpav1.CrossVersionObjectReference{
+				Name:       "podinfo",
+				APIVersion: "core/v1",
+				Kind:       "Service",
+			},
+			Service: flaggerv1.CanaryService{
+				Port: 9898,
+			},
+			CanaryAnalysis: flaggerv1.CanaryAnalysis{
+				Threshold:  10,
+				StepWeight: 10,
+				MaxWeight:  50,
+				Metrics: []flaggerv1.CanaryMetric{
+					{
+						Name:      "istio_requests_total",
+						Threshold: 99,
+						Interval:  "1m",
+					},
+					{
+						Name:      "istio_request_duration_seconds_bucket",
+						Threshold: 500,
+						Interval:  "1m",
+					},
+				},
+			},
+		},
+	}
+	return cd
+}

pkg/metrics/appmesh.go

@@ -4,7 +4,7 @@ import (
 	"time"
 )
 
-var envoyQueries = map[string]string{
+var appMeshQueries = map[string]string{
 	"request-success-rate": `
 	sum(
 		rate(
@@ -39,12 +39,12 @@ var envoyQueries = map[string]string{
 	)`,
 }
 
-type EnvoyObserver struct {
+type AppMeshObserver struct {
 	client *PrometheusClient
 }
 
-func (ob *EnvoyObserver) GetRequestSuccessRate(name string, namespace string, interval string) (float64, error) {
-	query, err := ob.client.RenderQuery(name, namespace, interval, envoyQueries["request-success-rate"])
+func (ob *AppMeshObserver) GetRequestSuccessRate(name string, namespace string, interval string) (float64, error) {
+	query, err := ob.client.RenderQuery(name, namespace, interval, appMeshQueries["request-success-rate"])
 	if err != nil {
 		return 0, err
 	}
@@ -57,8 +57,8 @@ func (ob *EnvoyObserver) GetRequestSuccessRate(name string, namespace string, in
 	return value, nil
 }
 
-func (ob *EnvoyObserver) GetRequestDuration(name string, namespace string, interval string) (time.Duration, error) {
-	query, err := ob.client.RenderQuery(name, namespace, interval, envoyQueries["request-duration"])
+func (ob *AppMeshObserver) GetRequestDuration(name string, namespace string, interval string) (time.Duration, error) {
+	query, err := ob.client.RenderQuery(name, namespace, interval, appMeshQueries["request-duration"])
 	if err != nil {
 		return 0, err
 	}