Add Rollout kind and clientset

artifacts/crd/example.yaml

@@ -0,0 +1,24 @@
+apiVersion: apps.weave.works/v1beta1
+kind: Rollout
+metadata:
+  annotations:
+    apps.weave.works/canary-revision: ""
+    apps.weave.works/status: ""
+  name: podinfo
+  namespace: test
+spec:
+  targetKind: Deployment
+  primary:
+    name: podinfo
+    host: podinfo
+  canary:
+    name: podinfo-canary
+    host: podinfo-canary
+  virtualService:
+    name: podinfo
+    weight: 10
+  metric:
+    type: counter
+    name: istio_requests_total
+    interval: 1m
+    threshold: 99

artifacts/crd/rollout.yaml

@@ -0,0 +1,56 @@
+apiVersion: apiextensions.k8s.io/v1beta1
+kind: CustomResourceDefinition
+metadata:
+  name: rollouts.apps.weave.works
+spec:
+  group: apps.weave.works
+  version: v1beta1
+  versions:
+    - name: v1beta1
+      served: true
+      storage: true
+  names:
+    plural: rollouts
+    singular: rollout
+    kind: Rollout
+    shortNames:
+    - roll
+  scope: Namespaced
+  validation:
+    openAPIV3Schema:
+      properties:
+        spec:
+          required:
+            - primary
+            - canary
+            - virtualService
+          properties:
+            primary:
+              properties:
+                name:
+                  type: string
+                host:
+                  type: string
+            canary:
+              properties:
+                name:
+                  type: string
+                host:
+                  type: string
+            virtualService:
+              properties:
+                name:
+                  type: string
+                weight:
+                  type: number
+            metric:
+              properties:
+                type:
+                  type: string
+                name:
+                  type: string
+                interval:
+                  type: string
+                  pattern: "^[0-9]+(m)"
+                threshold:
+                  type: number

artifacts/workloads/deployment.yaml

@@ -67,9 +67,3 @@ spec:
           requests:
             cpu: 1m
             memory: 16Mi
-        volumeMounts:
-        - mountPath: /data
-          name: data
-      volumes:
-      - emptyDir: {}
-        name: data

pkg/apis/rollout/register.go

@@ -0,0 +1,21 @@
+/*
+Copyright 2018 The 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.
+*/
+
+package rollout
+
+const (
+	GroupName = "apps.weave.works"
+)

pkg/apis/rollout/v1beta1/doc.go

@@ -0,0 +1,21 @@
+/*
+Copyright 2018 The 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.
+*/
+
+// +k8s:deepcopy-gen=package
+
+// Package v1beta1 is the v1beta1 version of the API.
+// +groupName=apps.weave.works
+package v1beta1

pkg/apis/rollout/v1beta1/register.go

@@ -0,0 +1,53 @@
+/*
+Copyright 2018 The 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.
+*/
+
+package v1beta1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+
+	rollout "github.com/stefanprodan/steerer/pkg/apis/rollout"
+)
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = schema.GroupVersion{Group: rollout.GroupName, Version: "v1beta1"}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) schema.GroupKind {
+	return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+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,
+		&Rollout{},
+		&RolloutList{},
+	)
+	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
+	return nil
+}

pkg/apis/rollout/v1beta1/types.go

@@ -0,0 +1,75 @@
+/*
+Copyright 2017 The Kubernetes 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.
+*/
+
+package v1beta1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// +genclient
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// Rollout is a specification for a Rollout resource
+type Rollout struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   RolloutSpec   `json:"spec"`
+	Status RolloutStatus `json:"status"`
+}
+
+// RolloutSpec is the spec for a Rollout resource
+type RolloutSpec struct {
+	TargetKind     string         `json:"targetKind"`
+	Primary        Target         `json:"primary"`
+	Canary         Target         `json:"canary"`
+	VirtualService VirtualService `json:"virtualService"`
+	Metric         Metric         `json:"metric"`
+}
+
+type Target struct {
+	Name string `json:"name"`
+	Host string `json:"host"`
+}
+
+type VirtualService struct {
+	Name   string `json:"name"`
+	Weight int    `json:"weight"`
+}
+
+type Metric struct {
+	Type      string `json:"type"`
+	Name      string `json:"name"`
+	Interval  string `json:"interval"`
+	Threshold int    `json:"threshold"`
+}
+
+// RolloutStatus is the status for a Rollout resource
+type RolloutStatus struct {
+	State        string `json:"state"`
+	CanaryWeight int32  `json:"canary_weight"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// RolloutList is a list of Rollout resources
+type RolloutList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata"`
+
+	Items []Rollout `json:"items"`
+}

pkg/apis/rollout/v1beta1/zz_generated.deepcopy.go

@@ -0,0 +1,170 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright The 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 v1beta1
+
+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 *Metric) DeepCopyInto(out *Metric) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Metric.
+func (in *Metric) DeepCopy() *Metric {
+	if in == nil {
+		return nil
+	}
+	out := new(Metric)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Rollout) DeepCopyInto(out *Rollout) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	out.Spec = in.Spec
+	out.Status = in.Status
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Rollout.
+func (in *Rollout) DeepCopy() *Rollout {
+	if in == nil {
+		return nil
+	}
+	out := new(Rollout)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *Rollout) 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 *RolloutList) DeepCopyInto(out *RolloutList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]Rollout, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutList.
+func (in *RolloutList) DeepCopy() *RolloutList {
+	if in == nil {
+		return nil
+	}
+	out := new(RolloutList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *RolloutList) 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 *RolloutSpec) DeepCopyInto(out *RolloutSpec) {
+	*out = *in
+	out.Primary = in.Primary
+	out.Canary = in.Canary
+	out.VirtualService = in.VirtualService
+	out.Metric = in.Metric
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutSpec.
+func (in *RolloutSpec) DeepCopy() *RolloutSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(RolloutSpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RolloutStatus) DeepCopyInto(out *RolloutStatus) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RolloutStatus.
+func (in *RolloutStatus) DeepCopy() *RolloutStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(RolloutStatus)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Target) DeepCopyInto(out *Target) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Target.
+func (in *Target) DeepCopy() *Target {
+	if in == nil {
+		return nil
+	}
+	out := new(Target)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *VirtualService) DeepCopyInto(out *VirtualService) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualService.
+func (in *VirtualService) DeepCopy() *VirtualService {
+	if in == nil {
+		return nil
+	}
+	out := new(VirtualService)
+	in.DeepCopyInto(out)
+	return out
+}

pkg/client/clientset/versioned/clientset.go

@@ -0,0 +1,98 @@
+/*
+Copyright The 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 versioned
+
+import (
+	appsv1beta1 "github.com/stefanprodan/steerer/pkg/client/clientset/versioned/typed/rollout/v1beta1"
+	discovery "k8s.io/client-go/discovery"
+	rest "k8s.io/client-go/rest"
+	flowcontrol "k8s.io/client-go/util/flowcontrol"
+)
+
+type Interface interface {
+	Discovery() discovery.DiscoveryInterface
+	AppsV1beta1() appsv1beta1.AppsV1beta1Interface
+	// Deprecated: please explicitly pick a version if possible.
+	Apps() appsv1beta1.AppsV1beta1Interface
+}
+
+// Clientset contains the clients for groups. Each group has exactly one
+// version included in a Clientset.
+type Clientset struct {
+	*discovery.DiscoveryClient
+	appsV1beta1 *appsv1beta1.AppsV1beta1Client
+}
+
+// AppsV1beta1 retrieves the AppsV1beta1Client
+func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {
+	return c.appsV1beta1
+}
+
+// Deprecated: Apps retrieves the default version of AppsClient.
+// Please explicitly pick a version.
+func (c *Clientset) Apps() appsv1beta1.AppsV1beta1Interface {
+	return c.appsV1beta1
+}
+
+// Discovery retrieves the DiscoveryClient
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+	if c == nil {
+		return nil
+	}
+	return c.DiscoveryClient
+}
+
+// NewForConfig creates a new Clientset for the given config.
+func NewForConfig(c *rest.Config) (*Clientset, error) {
+	configShallowCopy := *c
+	if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
+		configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
+	}
+	var cs Clientset
+	var err error
+	cs.appsV1beta1, err = appsv1beta1.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+
+	cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+	return &cs, nil
+}
+
+// NewForConfigOrDie creates a new Clientset for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *Clientset {
+	var cs Clientset
+	cs.appsV1beta1 = appsv1beta1.NewForConfigOrDie(c)
+
+	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
+	return &cs
+}
+
+// New creates a new Clientset for the given RESTClient.
+func New(c rest.Interface) *Clientset {
+	var cs Clientset
+	cs.appsV1beta1 = appsv1beta1.New(c)
+
+	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
+	return &cs
+}

pkg/client/clientset/versioned/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright The 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 clientset.
+package versioned

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

@@ -0,0 +1,82 @@
+/*
+Copyright The 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 (
+	clientset "github.com/stefanprodan/steerer/pkg/client/clientset/versioned"
+	appsv1beta1 "github.com/stefanprodan/steerer/pkg/client/clientset/versioned/typed/rollout/v1beta1"
+	fakeappsv1beta1 "github.com/stefanprodan/steerer/pkg/client/clientset/versioned/typed/rollout/v1beta1/fake"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/discovery"
+	fakediscovery "k8s.io/client-go/discovery/fake"
+	"k8s.io/client-go/testing"
+)
+
+// NewSimpleClientset returns a clientset that will respond with the provided objects.
+// It's backed by a very simple object tracker that processes creates, updates and deletions as-is,
+// without applying any validations and/or defaults. It shouldn't be considered a replacement
+// for a real clientset and is mostly useful in simple unit tests.
+func NewSimpleClientset(objects ...runtime.Object) *Clientset {
+	o := testing.NewObjectTracker(scheme, codecs.UniversalDecoder())
+	for _, obj := range objects {
+		if err := o.Add(obj); err != nil {
+			panic(err)
+		}
+	}
+
+	cs := &Clientset{}
+	cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake}
+	cs.AddReactor("*", "*", testing.ObjectReaction(o))
+	cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
+		gvr := action.GetResource()
+		ns := action.GetNamespace()
+		watch, err := o.Watch(gvr, ns)
+		if err != nil {
+			return false, nil, err
+		}
+		return true, watch, nil
+	})
+
+	return cs
+}
+
+// Clientset implements clientset.Interface. Meant to be embedded into a
+// struct to get a default implementation. This makes faking out just the method
+// you want to test easier.
+type Clientset struct {
+	testing.Fake
+	discovery *fakediscovery.FakeDiscovery
+}
+
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+	return c.discovery
+}
+
+var _ clientset.Interface = &Clientset{}
+
+// AppsV1beta1 retrieves the AppsV1beta1Client
+func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {
+	return &fakeappsv1beta1.FakeAppsV1beta1{Fake: &c.Fake}
+}
+
+// Apps retrieves the AppsV1beta1Client
+func (c *Clientset) Apps() appsv1beta1.AppsV1beta1Interface {
+	return &fakeappsv1beta1.FakeAppsV1beta1{Fake: &c.Fake}
+}

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

@@ -0,0 +1,20 @@
+/*
+Copyright The 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 fake clientset.
+package fake

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

@@ -0,0 +1,54 @@
+/*
+Copyright The 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 (
+	appsv1beta1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+)
+
+var scheme = runtime.NewScheme()
+var codecs = serializer.NewCodecFactory(scheme)
+var parameterCodec = runtime.NewParameterCodec(scheme)
+
+func init() {
+	v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: "v1"})
+	AddToScheme(scheme)
+}
+
+// AddToScheme adds all types of this clientset into the given scheme. This allows composition
+// of clientsets, like in:
+//
+//   import (
+//     "k8s.io/client-go/kubernetes"
+//     clientsetscheme "k8s.io/client-go/kubernetes/scheme"
+//     aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"
+//   )
+//
+//   kclientset, _ := kubernetes.NewForConfig(c)
+//   aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)
+//
+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
+// correctly.
+func AddToScheme(scheme *runtime.Scheme) {
+	appsv1beta1.AddToScheme(scheme)
+}

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

@@ -0,0 +1,20 @@
+/*
+Copyright The 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 contains the scheme of the automatically generated clientset.
+package scheme

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

@@ -0,0 +1,54 @@
+/*
+Copyright The 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 scheme
+
+import (
+	appsv1beta1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+)
+
+var Scheme = runtime.NewScheme()
+var Codecs = serializer.NewCodecFactory(Scheme)
+var ParameterCodec = runtime.NewParameterCodec(Scheme)
+
+func init() {
+	v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"})
+	AddToScheme(Scheme)
+}
+
+// AddToScheme adds all types of this clientset into the given scheme. This allows composition
+// of clientsets, like in:
+//
+//   import (
+//     "k8s.io/client-go/kubernetes"
+//     clientsetscheme "k8s.io/client-go/kubernetes/scheme"
+//     aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"
+//   )
+//
+//   kclientset, _ := kubernetes.NewForConfig(c)
+//   aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)
+//
+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
+// correctly.
+func AddToScheme(scheme *runtime.Scheme) {
+	appsv1beta1.AddToScheme(scheme)
+}

pkg/client/clientset/versioned/typed/rollout/v1beta1/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright The 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 v1beta1

pkg/client/clientset/versioned/typed/rollout/v1beta1/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright The 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/rollout/v1beta1/fake/fake_rollout.go

@@ -0,0 +1,140 @@
+/*
+Copyright The 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 (
+	v1beta1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	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"
+)
+
+// FakeRollouts implements RolloutInterface
+type FakeRollouts struct {
+	Fake *FakeAppsV1beta1
+	ns   string
+}
+
+var rolloutsResource = schema.GroupVersionResource{Group: "apps.weave.works", Version: "v1beta1", Resource: "rollouts"}
+
+var rolloutsKind = schema.GroupVersionKind{Group: "apps.weave.works", Version: "v1beta1", Kind: "Rollout"}
+
+// Get takes name of the rollout, and returns the corresponding rollout object, and an error if there is any.
+func (c *FakeRollouts) Get(name string, options v1.GetOptions) (result *v1beta1.Rollout, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(rolloutsResource, c.ns, name), &v1beta1.Rollout{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Rollout), err
+}
+
+// List takes label and field selectors, and returns the list of Rollouts that match those selectors.
+func (c *FakeRollouts) List(opts v1.ListOptions) (result *v1beta1.RolloutList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(rolloutsResource, rolloutsKind, c.ns, opts), &v1beta1.RolloutList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.RolloutList{ListMeta: obj.(*v1beta1.RolloutList).ListMeta}
+	for _, item := range obj.(*v1beta1.RolloutList).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 rollouts.
+func (c *FakeRollouts) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(rolloutsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a rollout and creates it.  Returns the server's representation of the rollout, and an error, if there is any.
+func (c *FakeRollouts) Create(rollout *v1beta1.Rollout) (result *v1beta1.Rollout, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(rolloutsResource, c.ns, rollout), &v1beta1.Rollout{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Rollout), err
+}
+
+// Update takes the representation of a rollout and updates it. Returns the server's representation of the rollout, and an error, if there is any.
+func (c *FakeRollouts) Update(rollout *v1beta1.Rollout) (result *v1beta1.Rollout, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(rolloutsResource, c.ns, rollout), &v1beta1.Rollout{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Rollout), 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 *FakeRollouts) UpdateStatus(rollout *v1beta1.Rollout) (*v1beta1.Rollout, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(rolloutsResource, "status", c.ns, rollout), &v1beta1.Rollout{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Rollout), err
+}
+
+// Delete takes name of the rollout and deletes it. Returns an error if one occurs.
+func (c *FakeRollouts) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(rolloutsResource, c.ns, name), &v1beta1.Rollout{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeRollouts) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(rolloutsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.RolloutList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched rollout.
+func (c *FakeRollouts) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Rollout, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(rolloutsResource, c.ns, name, data, subresources...), &v1beta1.Rollout{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Rollout), err
+}

pkg/client/clientset/versioned/typed/rollout/v1beta1/fake/fake_rollout_client.go

@@ -0,0 +1,40 @@
+/*
+Copyright The 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 (
+	v1beta1 "github.com/stefanprodan/steerer/pkg/client/clientset/versioned/typed/rollout/v1beta1"
+	rest "k8s.io/client-go/rest"
+	testing "k8s.io/client-go/testing"
+)
+
+type FakeAppsV1beta1 struct {
+	*testing.Fake
+}
+
+func (c *FakeAppsV1beta1) Rollouts(namespace string) v1beta1.RolloutInterface {
+	return &FakeRollouts{c, namespace}
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeAppsV1beta1) RESTClient() rest.Interface {
+	var ret *rest.RESTClient
+	return ret
+}

pkg/client/clientset/versioned/typed/rollout/v1beta1/generated_expansion.go

@@ -0,0 +1,21 @@
+/*
+Copyright The 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 v1beta1
+
+type RolloutExpansion interface{}

pkg/client/clientset/versioned/typed/rollout/v1beta1/rollout.go

@@ -0,0 +1,174 @@
+/*
+Copyright The 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 v1beta1
+
+import (
+	v1beta1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	scheme "github.com/stefanprodan/steerer/pkg/client/clientset/versioned/scheme"
+	v1 "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"
+)
+
+// RolloutsGetter has a method to return a RolloutInterface.
+// A group's client should implement this interface.
+type RolloutsGetter interface {
+	Rollouts(namespace string) RolloutInterface
+}
+
+// RolloutInterface has methods to work with Rollout resources.
+type RolloutInterface interface {
+	Create(*v1beta1.Rollout) (*v1beta1.Rollout, error)
+	Update(*v1beta1.Rollout) (*v1beta1.Rollout, error)
+	UpdateStatus(*v1beta1.Rollout) (*v1beta1.Rollout, error)
+	Delete(name string, options *v1.DeleteOptions) error
+	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
+	Get(name string, options v1.GetOptions) (*v1beta1.Rollout, error)
+	List(opts v1.ListOptions) (*v1beta1.RolloutList, error)
+	Watch(opts v1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Rollout, err error)
+	RolloutExpansion
+}
+
+// rollouts implements RolloutInterface
+type rollouts struct {
+	client rest.Interface
+	ns     string
+}
+
+// newRollouts returns a Rollouts
+func newRollouts(c *AppsV1beta1Client, namespace string) *rollouts {
+	return &rollouts{
+		client: c.RESTClient(),
+		ns:     namespace,
+	}
+}
+
+// Get takes name of the rollout, and returns the corresponding rollout object, and an error if there is any.
+func (c *rollouts) Get(name string, options v1.GetOptions) (result *v1beta1.Rollout, err error) {
+	result = &v1beta1.Rollout{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("rollouts").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Rollouts that match those selectors.
+func (c *rollouts) List(opts v1.ListOptions) (result *v1beta1.RolloutList, err error) {
+	result = &v1beta1.RolloutList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("rollouts").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested rollouts.
+func (c *rollouts) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	opts.Watch = true
+	return c.client.Get().
+		Namespace(c.ns).
+		Resource("rollouts").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Watch()
+}
+
+// Create takes the representation of a rollout and creates it.  Returns the server's representation of the rollout, and an error, if there is any.
+func (c *rollouts) Create(rollout *v1beta1.Rollout) (result *v1beta1.Rollout, err error) {
+	result = &v1beta1.Rollout{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("rollouts").
+		Body(rollout).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a rollout and updates it. Returns the server's representation of the rollout, and an error, if there is any.
+func (c *rollouts) Update(rollout *v1beta1.Rollout) (result *v1beta1.Rollout, err error) {
+	result = &v1beta1.Rollout{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("rollouts").
+		Name(rollout.Name).
+		Body(rollout).
+		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 *rollouts) UpdateStatus(rollout *v1beta1.Rollout) (result *v1beta1.Rollout, err error) {
+	result = &v1beta1.Rollout{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("rollouts").
+		Name(rollout.Name).
+		SubResource("status").
+		Body(rollout).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the rollout and deletes it. Returns an error if one occurs.
+func (c *rollouts) Delete(name string, options *v1.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("rollouts").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *rollouts) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("rollouts").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched rollout.
+func (c *rollouts) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Rollout, err error) {
+	result = &v1beta1.Rollout{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("rollouts").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

pkg/client/clientset/versioned/typed/rollout/v1beta1/rollout_client.go

@@ -0,0 +1,90 @@
+/*
+Copyright The 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 v1beta1
+
+import (
+	v1beta1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	"github.com/stefanprodan/steerer/pkg/client/clientset/versioned/scheme"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	rest "k8s.io/client-go/rest"
+)
+
+type AppsV1beta1Interface interface {
+	RESTClient() rest.Interface
+	RolloutsGetter
+}
+
+// AppsV1beta1Client is used to interact with features provided by the apps.weave.works group.
+type AppsV1beta1Client struct {
+	restClient rest.Interface
+}
+
+func (c *AppsV1beta1Client) Rollouts(namespace string) RolloutInterface {
+	return newRollouts(c, namespace)
+}
+
+// NewForConfig creates a new AppsV1beta1Client for the given config.
+func NewForConfig(c *rest.Config) (*AppsV1beta1Client, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &AppsV1beta1Client{client}, nil
+}
+
+// NewForConfigOrDie creates a new AppsV1beta1Client for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *AppsV1beta1Client {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new AppsV1beta1Client for the given RESTClient.
+func New(c rest.Interface) *AppsV1beta1Client {
+	return &AppsV1beta1Client{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	gv := v1beta1.SchemeGroupVersion
+	config.GroupVersion = &gv
+	config.APIPath = "/apis"
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
+
+	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 *AppsV1beta1Client) RESTClient() rest.Interface {
+	if c == nil {
+		return nil
+	}
+	return c.restClient
+}

pkg/client/informers/externalversions/factory.go

@@ -0,0 +1,180 @@
+/*
+Copyright The 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 externalversions
+
+import (
+	reflect "reflect"
+	sync "sync"
+	time "time"
+
+	versioned "github.com/stefanprodan/steerer/pkg/client/clientset/versioned"
+	internalinterfaces "github.com/stefanprodan/steerer/pkg/client/informers/externalversions/internalinterfaces"
+	rollout "github.com/stefanprodan/steerer/pkg/client/informers/externalversions/rollout"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// SharedInformerOption defines the functional option type for SharedInformerFactory.
+type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory
+
+type sharedInformerFactory struct {
+	client           versioned.Interface
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	lock             sync.Mutex
+	defaultResync    time.Duration
+	customResync     map[reflect.Type]time.Duration
+
+	informers map[reflect.Type]cache.SharedIndexInformer
+	// startedInformers is used for tracking which informers have been started.
+	// This allows Start() to be called multiple times safely.
+	startedInformers map[reflect.Type]bool
+}
+
+// WithCustomResyncConfig sets a custom resync period for the specified informer types.
+func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		for k, v := range resyncConfig {
+			factory.customResync[reflect.TypeOf(k)] = v
+		}
+		return factory
+	}
+}
+
+// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory.
+func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		factory.tweakListOptions = tweakListOptions
+		return factory
+	}
+}
+
+// WithNamespace limits the SharedInformerFactory to the specified namespace.
+func WithNamespace(namespace string) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		factory.namespace = namespace
+		return factory
+	}
+}
+
+// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces.
+func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {
+	return NewSharedInformerFactoryWithOptions(client, defaultResync)
+}
+
+// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory.
+// Listers obtained via this SharedInformerFactory will be subject to the same filters
+// as specified here.
+// Deprecated: Please use NewSharedInformerFactoryWithOptions instead
+func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {
+	return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions))
+}
+
+// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options.
+func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory {
+	factory := &sharedInformerFactory{
+		client:           client,
+		namespace:        v1.NamespaceAll,
+		defaultResync:    defaultResync,
+		informers:        make(map[reflect.Type]cache.SharedIndexInformer),
+		startedInformers: make(map[reflect.Type]bool),
+		customResync:     make(map[reflect.Type]time.Duration),
+	}
+
+	// Apply all options
+	for _, opt := range options {
+		factory = opt(factory)
+	}
+
+	return factory
+}
+
+// Start initializes all requested informers.
+func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	for informerType, informer := range f.informers {
+		if !f.startedInformers[informerType] {
+			go informer.Run(stopCh)
+			f.startedInformers[informerType] = true
+		}
+	}
+}
+
+// WaitForCacheSync waits for all started informers' cache were synced.
+func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool {
+	informers := func() map[reflect.Type]cache.SharedIndexInformer {
+		f.lock.Lock()
+		defer f.lock.Unlock()
+
+		informers := map[reflect.Type]cache.SharedIndexInformer{}
+		for informerType, informer := range f.informers {
+			if f.startedInformers[informerType] {
+				informers[informerType] = informer
+			}
+		}
+		return informers
+	}()
+
+	res := map[reflect.Type]bool{}
+	for informType, informer := range informers {
+		res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced)
+	}
+	return res
+}
+
+// InternalInformerFor returns the SharedIndexInformer for obj using an internal
+// client.
+func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	informerType := reflect.TypeOf(obj)
+	informer, exists := f.informers[informerType]
+	if exists {
+		return informer
+	}
+
+	resyncPeriod, exists := f.customResync[informerType]
+	if !exists {
+		resyncPeriod = f.defaultResync
+	}
+
+	informer = newFunc(f.client, resyncPeriod)
+	f.informers[informerType] = informer
+
+	return informer
+}
+
+// SharedInformerFactory provides shared informers for resources in all known
+// API group versions.
+type SharedInformerFactory interface {
+	internalinterfaces.SharedInformerFactory
+	ForResource(resource schema.GroupVersionResource) (GenericInformer, error)
+	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool
+
+	Apps() rollout.Interface
+}
+
+func (f *sharedInformerFactory) Apps() rollout.Interface {
+	return rollout.New(f, f.namespace, f.tweakListOptions)
+}

pkg/client/informers/externalversions/generic.go

@@ -0,0 +1,62 @@
+/*
+Copyright The 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 externalversions
+
+import (
+	"fmt"
+
+	v1beta1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// GenericInformer is type of SharedIndexInformer which will locate and delegate to other
+// sharedInformers based on type
+type GenericInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() cache.GenericLister
+}
+
+type genericInformer struct {
+	informer cache.SharedIndexInformer
+	resource schema.GroupResource
+}
+
+// Informer returns the SharedIndexInformer.
+func (f *genericInformer) Informer() cache.SharedIndexInformer {
+	return f.informer
+}
+
+// Lister returns the GenericLister.
+func (f *genericInformer) Lister() cache.GenericLister {
+	return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource)
+}
+
+// ForResource gives generic access to a shared informer of the matching type
+// TODO extend this to unknown resources with a client pool
+func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
+	switch resource {
+	// Group=apps.weave.works, Version=v1beta1
+	case v1beta1.SchemeGroupVersion.WithResource("rollouts"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Apps().V1beta1().Rollouts().Informer()}, nil
+
+	}
+
+	return nil, fmt.Errorf("no informer found for %v", resource)
+}

pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go

@@ -0,0 +1,38 @@
+/*
+Copyright The 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 internalinterfaces
+
+import (
+	time "time"
+
+	versioned "github.com/stefanprodan/steerer/pkg/client/clientset/versioned"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer
+
+// SharedInformerFactory a small interface to allow for adding an informer without an import cycle
+type SharedInformerFactory interface {
+	Start(stopCh <-chan struct{})
+	InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
+}
+
+type TweakListOptionsFunc func(*v1.ListOptions)

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

@@ -0,0 +1,46 @@
+/*
+Copyright The 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 apps
+
+import (
+	internalinterfaces "github.com/stefanprodan/steerer/pkg/client/informers/externalversions/internalinterfaces"
+	v1beta1 "github.com/stefanprodan/steerer/pkg/client/informers/externalversions/rollout/v1beta1"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1beta1 provides access to shared informers for resources in V1beta1.
+	V1beta1() v1beta1.Interface
+}
+
+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}
+}
+
+// V1beta1 returns a new v1beta1.Interface.
+func (g *group) V1beta1() v1beta1.Interface {
+	return v1beta1.New(g.factory, g.namespace, g.tweakListOptions)
+}

pkg/client/informers/externalversions/rollout/v1beta1/interface.go

@@ -0,0 +1,45 @@
+/*
+Copyright The 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 v1beta1
+
+import (
+	internalinterfaces "github.com/stefanprodan/steerer/pkg/client/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// Rollouts returns a RolloutInformer.
+	Rollouts() RolloutInformer
+}
+
+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}
+}
+
+// Rollouts returns a RolloutInformer.
+func (v *version) Rollouts() RolloutInformer {
+	return &rolloutInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}

pkg/client/informers/externalversions/rollout/v1beta1/rollout.go

@@ -0,0 +1,89 @@
+/*
+Copyright The 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 v1beta1
+
+import (
+	time "time"
+
+	rolloutv1beta1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	versioned "github.com/stefanprodan/steerer/pkg/client/clientset/versioned"
+	internalinterfaces "github.com/stefanprodan/steerer/pkg/client/informers/externalversions/internalinterfaces"
+	v1beta1 "github.com/stefanprodan/steerer/pkg/client/listers/rollout/v1beta1"
+	v1 "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"
+)
+
+// RolloutInformer provides access to a shared informer and lister for
+// Rollouts.
+type RolloutInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1beta1.RolloutLister
+}
+
+type rolloutInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewRolloutInformer constructs a new informer for Rollout 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 NewRolloutInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredRolloutInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredRolloutInformer constructs a new informer for Rollout 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 NewFilteredRolloutInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.AppsV1beta1().Rollouts(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.AppsV1beta1().Rollouts(namespace).Watch(options)
+			},
+		},
+		&rolloutv1beta1.Rollout{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *rolloutInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredRolloutInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *rolloutInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&rolloutv1beta1.Rollout{}, f.defaultInformer)
+}
+
+func (f *rolloutInformer) Lister() v1beta1.RolloutLister {
+	return v1beta1.NewRolloutLister(f.Informer().GetIndexer())
+}

pkg/client/listers/rollout/v1beta1/expansion_generated.go

@@ -0,0 +1,27 @@
+/*
+Copyright The 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 v1beta1
+
+// RolloutListerExpansion allows custom methods to be added to
+// RolloutLister.
+type RolloutListerExpansion interface{}
+
+// RolloutNamespaceListerExpansion allows custom methods to be added to
+// RolloutNamespaceLister.
+type RolloutNamespaceListerExpansion interface{}

pkg/client/listers/rollout/v1beta1/rollout.go

@@ -0,0 +1,94 @@
+/*
+Copyright The 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 v1beta1
+
+import (
+	v1beta1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+)
+
+// RolloutLister helps list Rollouts.
+type RolloutLister interface {
+	// List lists all Rollouts in the indexer.
+	List(selector labels.Selector) (ret []*v1beta1.Rollout, err error)
+	// Rollouts returns an object that can list and get Rollouts.
+	Rollouts(namespace string) RolloutNamespaceLister
+	RolloutListerExpansion
+}
+
+// rolloutLister implements the RolloutLister interface.
+type rolloutLister struct {
+	indexer cache.Indexer
+}
+
+// NewRolloutLister returns a new RolloutLister.
+func NewRolloutLister(indexer cache.Indexer) RolloutLister {
+	return &rolloutLister{indexer: indexer}
+}
+
+// List lists all Rollouts in the indexer.
+func (s *rolloutLister) List(selector labels.Selector) (ret []*v1beta1.Rollout, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*v1beta1.Rollout))
+	})
+	return ret, err
+}
+
+// Rollouts returns an object that can list and get Rollouts.
+func (s *rolloutLister) Rollouts(namespace string) RolloutNamespaceLister {
+	return rolloutNamespaceLister{indexer: s.indexer, namespace: namespace}
+}
+
+// RolloutNamespaceLister helps list and get Rollouts.
+type RolloutNamespaceLister interface {
+	// List lists all Rollouts in the indexer for a given namespace.
+	List(selector labels.Selector) (ret []*v1beta1.Rollout, err error)
+	// Get retrieves the Rollout from the indexer for a given namespace and name.
+	Get(name string) (*v1beta1.Rollout, error)
+	RolloutNamespaceListerExpansion
+}
+
+// rolloutNamespaceLister implements the RolloutNamespaceLister
+// interface.
+type rolloutNamespaceLister struct {
+	indexer   cache.Indexer
+	namespace string
+}
+
+// List lists all Rollouts in the indexer for a given namespace.
+func (s rolloutNamespaceLister) List(selector labels.Selector) (ret []*v1beta1.Rollout, err error) {
+	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
+		ret = append(ret, m.(*v1beta1.Rollout))
+	})
+	return ret, err
+}
+
+// Get retrieves the Rollout from the indexer for a given namespace and name.
+func (s rolloutNamespaceLister) Get(name string) (*v1beta1.Rollout, error) {
+	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(v1beta1.Resource("rollout"), name)
+	}
+	return obj.(*v1beta1.Rollout), nil
+}

pkg/controller/controller.go

@@ -4,21 +4,24 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"sync"
+
+	"github.com/google/go-cmp/cmp"
 	sharedclientset "github.com/knative/pkg/client/clientset/versioned"
-	istioinformers "github.com/knative/pkg/client/informers/externalversions/istio/v1alpha3"
-	istiolisters "github.com/knative/pkg/client/listers/istio/v1alpha3"
+	rolloutv1 "github.com/stefanprodan/steerer/pkg/apis/rollout/v1beta1"
+	clientset "github.com/stefanprodan/steerer/pkg/client/clientset/versioned"
+	rolloutscheme "github.com/stefanprodan/steerer/pkg/client/clientset/versioned/scheme"
+	rolloutInformers "github.com/stefanprodan/steerer/pkg/client/informers/externalversions/rollout/v1beta1"
+	listers "github.com/stefanprodan/steerer/pkg/client/listers/rollout/v1beta1"
 	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
-	corev1informers "k8s.io/client-go/informers/core/v1"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/kubernetes/scheme"
 	typedcorev1 "k8s.io/client-go/kubernetes/typed/core/v1"
-	corev1listers "k8s.io/client-go/listers/core/v1"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/tools/record"
 	"k8s.io/client-go/util/workqueue"
@@ -27,49 +30,69 @@ import (
 const controllerAgentName = "steerer"
 
 type Controller struct {
-	kubeclientset        kubernetes.Interface
-	sharedclientset      sharedclientset.Interface
-	logger               *zap.SugaredLogger
-	serviceLister        corev1listers.ServiceLister
-	serviceSynced        cache.InformerSynced
-	virtualServiceLister istiolisters.VirtualServiceLister
-	virtualServiceSynced cache.InformerSynced
-	workqueue            workqueue.RateLimitingInterface
-	recorder             record.EventRecorder
+	kubeClient    kubernetes.Interface
+	istioClient   sharedclientset.Interface
+	rolloutClient clientset.Interface
+	rolloutLister listers.RolloutLister
+	rolloutSynced cache.InformerSynced
+	workqueue     workqueue.RateLimitingInterface
+	recorder      record.EventRecorder
+	logger        *zap.SugaredLogger
+	rollouts      *sync.Map
 }
 
 func NewController(
-	kubeclientset kubernetes.Interface,
-	sharedclientset sharedclientset.Interface,
+	kubeClient kubernetes.Interface,
+	istioClient sharedclientset.Interface,
+	rolloutClient clientset.Interface,
+	rolloutInformer rolloutInformers.RolloutInformer,
 	logger *zap.SugaredLogger,
-	serviceInformer corev1informers.ServiceInformer,
-	virtualServiceInformer istioinformers.VirtualServiceInformer,
 ) *Controller {
 	logger.Debug("Creating event broadcaster")
+	rolloutscheme.AddToScheme(scheme.Scheme)
 	eventBroadcaster := record.NewBroadcaster()
-	eventBroadcaster.StartLogging(logger.Named("event-broadcaster").Infof)
+	eventBroadcaster.StartLogging(logger.Named("event-broadcaster").Debugf)
 	eventBroadcaster.StartRecordingToSink(&typedcorev1.EventSinkImpl{
-		Interface: kubeclientset.CoreV1().Events(""),
+		Interface: kubeClient.CoreV1().Events(""),
 	})
 	recorder := eventBroadcaster.NewRecorder(
 		scheme.Scheme, corev1.EventSource{Component: controllerAgentName})
 
 	ctrl := &Controller{
-		kubeclientset:        kubeclientset,
-		sharedclientset:      sharedclientset,
-		logger:               logger,
-		serviceLister:        serviceInformer.Lister(),
-		serviceSynced:        serviceInformer.Informer().HasSynced,
-		virtualServiceLister: virtualServiceInformer.Lister(),
-		virtualServiceSynced: virtualServiceInformer.Informer().HasSynced,
-		workqueue:            workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerAgentName),
-		recorder:             recorder,
+		kubeClient:    kubeClient,
+		istioClient:   istioClient,
+		rolloutClient: rolloutClient,
+		rolloutLister: rolloutInformer.Lister(),
+		rolloutSynced: rolloutInformer.Informer().HasSynced,
+		workqueue:     workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), controllerAgentName),
+		recorder:      recorder,
+		logger:        logger,
+		rollouts:      new(sync.Map),
 	}
 
-	virtualServiceInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
-		AddFunc: ctrl.enqueueVirtualService,
+	rolloutInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
+		AddFunc: ctrl.enqueueRollout,
 		UpdateFunc: func(old, new interface{}) {
-			ctrl.enqueueVirtualService(new)
+			oldRoll, ok := checkCustomResourceType(old, logger)
+			if !ok {
+				return
+			}
+			newRoll, ok := checkCustomResourceType(new, logger)
+			if !ok {
+				return
+			}
+
+			if diff := cmp.Diff(newRoll.Spec, oldRoll.Spec); diff != "" {
+				ctrl.logger.Debugf("Diff detected %s.%s %s", oldRoll.Name, oldRoll.Namespace, diff)
+				ctrl.enqueueRollout(new)
+			}
+		},
+		DeleteFunc: func(old interface{}) {
+			r, ok := checkCustomResourceType(old, logger)
+			if ok {
+				ctrl.logger.Infof("Deleting %s.%s from cache", r.Name, r.Namespace)
+				ctrl.rollouts.Delete(fmt.Sprintf("%s.%s", r.Name, r.Namespace))
+			}
 		},
 	})
 
@@ -139,18 +162,20 @@ func (c *Controller) syncHandler(key string) error {
 		return nil
 	}
 
-	vs, err := c.virtualServiceLister.VirtualServices(namespace).Get(name)
+	rollout, err := c.rolloutLister.Rollouts(namespace).Get(name)
 	if errors.IsNotFound(err) {
-		utilruntime.HandleError(fmt.Errorf("VirtualServices '%s' in work queue no longer exists", key))
+		utilruntime.HandleError(fmt.Errorf("rollout '%s' in work queue no longer exists", key))
 		return nil
 	}
 
-	c.logger.Infof("VirtualService %s.%s", vs.Name, namespace)
+	c.logger.Infof("Adding %s.%s to cache", rollout.Name, rollout.Namespace)
+	c.rollouts.Store(fmt.Sprintf("%s.%s", rollout.Name, rollout.Namespace), rollout)
+	c.recorder.Event(rollout, corev1.EventTypeNormal, "Synced", "Rollout synced successfully with internal cache")
 
 	return nil
 }
 
-func (c *Controller) enqueueVirtualService(obj interface{}) {
+func (c *Controller) enqueueRollout(obj interface{}) {
 	var key string
 	var err error
 	if key, err = cache.MetaNamespaceKeyFunc(obj); err != nil {
@@ -178,49 +203,28 @@ func (c *Controller) handleObject(obj interface{}) {
 	}
 	c.logger.Debugf("Processing object: %s", object.GetName())
 	if ownerRef := metav1.GetControllerOf(object); ownerRef != nil {
-		if ownerRef.Kind != "VirtualService" {
+		if ownerRef.Kind != "Rollout" {
 			return
 		}
 
-		vs, err := c.serviceLister.Services(object.GetNamespace()).Get(ownerRef.Name)
+		vs, err := c.rolloutLister.Rollouts(object.GetNamespace()).Get(ownerRef.Name)
 		if err != nil {
 			c.logger.Debugf("ignoring orphaned object '%s' of '%s'", object.GetSelfLink(), ownerRef.Name)
 			return
 		}
 
-		c.enqueueVirtualService(vs)
+		c.enqueueRollout(vs)
 		return
 	}
 
 }
 
-func (c *Controller) CreateVirtualService(namespace string, name string, host string, port uint32, gateway string) error {
-	vs := &v1alpha3.VirtualService{
-		ObjectMeta: metav1.ObjectMeta{
-			Namespace: namespace,
-			Name:      name,
-		},
-		Spec: v1alpha3.VirtualServiceSpec{
-			Hosts: []string{host},
-			Http: []v1alpha3.HTTPRoute{
-				{
-					Route: []v1alpha3.DestinationWeight{
-						{
-							Destination: v1alpha3.Destination{
-								Host: host,
-							},
-							Weight: 100,
-						},
-					},
-				},
-			},
-		},
+func checkCustomResourceType(obj interface{}, logger *zap.SugaredLogger) (rolloutv1.Rollout, bool) {
+	var roll *rolloutv1.Rollout
+	var ok bool
+	if roll, ok = obj.(*rolloutv1.Rollout); !ok {
+		logger.Errorf("Event Watch received an invalid object: %#v", obj)
+		return rolloutv1.Rollout{}, false
 	}
-
-	if gateway != "" {
-		vs.Spec.Gateways = []string{gateway}
-	}
-
-	_, err := c.sharedclientset.NetworkingV1alpha3().VirtualServices(vs.Namespace).Create(vs)
-	return err
+	return *roll, true
 }

pkg/controller/deployment.go

@@ -0,0 +1,5 @@
+package controller
+
+func (c *Controller) doRollout() {
+
+}