*: add peer VPN support

This commit adds support for defining arbitrary peers that should have
access to the VPN. In k8s, this is accomplished using the new Peer CRD.

pkg/k8s/apis/kilo/register.go

@@ -0,0 +1,20 @@
+// Copyright 2019 the Kilo 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 kilo
+
+const (
+	// GroupName contains the API group name for Kilo API group.
+	GroupName = "kilo"
+)

pkg/k8s/apis/kilo/v1alpha1/doc.go

@@ -0,0 +1,19 @@
+// Copyright 2019 the Kilo 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,register
+
+// Package v1alpha1 is the v1alpha1 version of the API.
+// +groupName=kilo
+package v1alpha1

pkg/k8s/apis/kilo/v1alpha1/register.go

@@ -0,0 +1,49 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+var (
+	// SchemeBuilder exposes an API scheme builder for this API version.
+	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
+	// AddToScheme exposes an AddToScheme func for this API version.
+	AddToScheme = SchemeBuilder.AddToScheme
+)
+
+// GroupName is the group name used in this package.
+const GroupName = "kilo.squat.ai"
+
+// SchemeGroupVersion is the group version used to register these objects.
+var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
+
+// Resource takes an unqualified resource and returns a Group-qualified GroupResource.
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+// addKnownTypes adds the set of types defined in this package to the supplied scheme.
+func addKnownTypes(scheme *runtime.Scheme) error {
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&Peer{},
+		&PeerList{},
+	)
+	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
+	return nil
+}

pkg/k8s/apis/kilo/v1alpha1/types.go

@@ -0,0 +1,143 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	// PeerKind is the API kind for the peer resource.
+	PeerKind = "Peer"
+	// PeerPlural is the plural name for the peer resource.
+	PeerPlural = "peers"
+)
+
+// PeerShortNames are convenient shortnames for the peer resource.
+var PeerShortNames = []string{"peer"}
+
+// +genclient
+// +genclient:nonNamespaced
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+// +k8s:openapi-gen=true
+
+// Peer is a WireGuard peer that should have access to the VPN.
+type Peer struct {
+	metav1.TypeMeta `json:",inline"`
+	// Standard object’s metadata. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
+	// +k8s:openapi-gen=false
+	metav1.ObjectMeta `json:"metadata"`
+	// Specification of the desired behavior of the Kilo Peer. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
+	Spec PeerSpec `json:"spec"`
+}
+
+// PeerSpec is the description and configuration of a peer.
+// +k8s:openapi-gen=true
+type PeerSpec struct {
+	// AllowedIPs is the list of IP addresses that are allowed
+	// for the given peer's tunnel.
+	AllowedIPs []string `json:"allowedIPs"`
+	// Endpoint is the initial endpoint for connections to the peer.
+	// +optional
+	Endpoint *PeerEndpoint `json:"endpoint"`
+	// PersistentKeepalive is the interval in seconds of the emission
+	// of keepalive packets to the peer. This defaults to 0, which
+	// disables the feature.
+	PersistentKeepalive int `json:"persistentKeepalive"`
+	// PublicKey is the WireGuard public key for the node.
+	PublicKey string `json:"publicKey"`
+}
+
+// PeerEndpoint represents a WireGuard enpoint, which is a ip:port tuple.
+type PeerEndpoint struct {
+	// IP must be a valid IP address.
+	IP string `json:"ip"`
+	// Port must be a valid port number.
+	Port uint32 `json:"port"`
+}
+
+// PeerName is the peer resource's FQDN.
+var PeerName = PeerPlural + "." + GroupName
+
+// AsOwner creates a new owner reference for the peer to apply to dependent resource.
+func (p *Peer) AsOwner() metav1.OwnerReference {
+	trueVar := true
+	return metav1.OwnerReference{
+		APIVersion:         p.APIVersion,
+		Kind:               p.Kind,
+		Name:               p.Name,
+		UID:                p.UID,
+		BlockOwnerDeletion: &trueVar,
+		Controller:         &trueVar,
+	}
+}
+
+// Copy creates a deep copy of the peer.
+func (p *Peer) Copy() *Peer {
+	new := Peer{}
+	b, err := json.Marshal(*p)
+	if err != nil {
+		panic(err)
+	}
+	err = json.Unmarshal(b, &new)
+	if err != nil {
+		panic(err)
+	}
+	return &new
+}
+
+// Validate ensures that all the fields of a peer's spec are valid.
+func (p *Peer) Validate() error {
+	for _, ip := range p.Spec.AllowedIPs {
+		if _, n, err := net.ParseCIDR(ip); err != nil {
+			return fmt.Errorf("failed to parse %q as a valid IP address: %v", ip, err)
+		} else if n == nil {
+			return fmt.Errorf("got invalid IP address for %q", ip)
+		}
+	}
+	if p.Spec.Endpoint != nil {
+		if net.ParseIP(p.Spec.Endpoint.IP) == nil {
+			return fmt.Errorf("failed to parse %q as a valid IP address", p.Spec.Endpoint.IP)
+		}
+		if p.Spec.Endpoint.Port == 0 {
+			return fmt.Errorf("port must be a valid UDP port number, got %d", p.Spec.Endpoint.Port)
+		}
+	}
+	if p.Spec.PersistentKeepalive < 0 {
+		return fmt.Errorf("persistent keepalive must be greater than or equal to zero; got %q", p.Spec.PersistentKeepalive)
+	}
+	if len(p.Spec.PublicKey) == 0 {
+		return errors.New("public keys cannot be empty")
+	}
+	return nil
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// PeerList is a list of peers.
+type PeerList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata"`
+	// List of peers.
+	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md
+	Items []Peer `json:"items"`
+}

pkg/k8s/apis/kilo/v1alpha1/zz_generated.deepcopy.go

@@ -0,0 +1,125 @@
+// +build !ignore_autogenerated
+
+// Copyright 2019 the Kilo 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 v1alpha1
+
+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 *Peer) DeepCopyInto(out *Peer) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Peer.
+func (in *Peer) DeepCopy() *Peer {
+	if in == nil {
+		return nil
+	}
+	out := new(Peer)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *Peer) 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 *PeerEndpoint) DeepCopyInto(out *PeerEndpoint) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PeerEndpoint.
+func (in *PeerEndpoint) DeepCopy() *PeerEndpoint {
+	if in == nil {
+		return nil
+	}
+	out := new(PeerEndpoint)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PeerList) DeepCopyInto(out *PeerList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]Peer, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PeerList.
+func (in *PeerList) DeepCopy() *PeerList {
+	if in == nil {
+		return nil
+	}
+	out := new(PeerList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *PeerList) 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 *PeerSpec) DeepCopyInto(out *PeerSpec) {
+	*out = *in
+	if in.AllowedIPs != nil {
+		in, out := &in.AllowedIPs, &out.AllowedIPs
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.Endpoint != nil {
+		in, out := &in.Endpoint, &out.Endpoint
+		*out = new(PeerEndpoint)
+		**out = **in
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PeerSpec.
+func (in *PeerSpec) DeepCopy() *PeerSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(PeerSpec)
+	in.DeepCopyInto(out)
+	return out
+}

pkg/k8s/backend.go

@@ -24,7 +24,11 @@ import (
 	"strings"
 	"time"
 
+	crdutils "github.com/ant31/crd-validation/pkg"
 	v1 "k8s.io/api/core/v1"
+	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
+	apiextensions "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/strategicpatch"
@@ -33,7 +37,12 @@ import (
 	v1listers "k8s.io/client-go/listers/core/v1"
 	"k8s.io/client-go/tools/cache"
 
+	"github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	kiloclient "github.com/squat/kilo/pkg/k8s/clientset/versioned"
+	v1alpha1informers "github.com/squat/kilo/pkg/k8s/informers/kilo/v1alpha1"
+	v1alpha1listers "github.com/squat/kilo/pkg/k8s/listers/kilo/v1alpha1"
 	"github.com/squat/kilo/pkg/mesh"
+	"github.com/squat/kilo/pkg/wireguard"
 )
 
 const (
@@ -52,43 +61,74 @@ const (
 )
 
 type backend struct {
+	nodes *nodeBackend
+	peers *peerBackend
+}
+
+// Nodes implements the mesh.Backend interface.
+func (b *backend) Nodes() mesh.NodeBackend {
+	return b.nodes
+}
+
+// Peers implements the mesh.Backend interface.
+func (b *backend) Peers() mesh.PeerBackend {
+	return b.peers
+}
+
+type nodeBackend struct {
 	client   kubernetes.Interface
-	events   chan *mesh.Event
+	events   chan *mesh.NodeEvent
 	informer cache.SharedIndexInformer
 	lister   v1listers.NodeLister
 }
 
+type peerBackend struct {
+	client           kiloclient.Interface
+	extensionsClient apiextensions.Interface
+	events           chan *mesh.PeerEvent
+	informer         cache.SharedIndexInformer
+	lister           v1alpha1listers.PeerLister
+}
+
 // New creates a new instance of a mesh.Backend.
-func New(client kubernetes.Interface) mesh.Backend {
-	informer := v1informers.NewNodeInformer(client, 5*time.Minute, nil)
+func New(c kubernetes.Interface, kc kiloclient.Interface, ec apiextensions.Interface) mesh.Backend {
+	ni := v1informers.NewNodeInformer(c, 5*time.Minute, nil)
+	pi := v1alpha1informers.NewPeerInformer(kc, 5*time.Minute, nil)
 
-	b := &backend{
-		client:   client,
-		events:   make(chan *mesh.Event),
-		informer: informer,
-		lister:   v1listers.NewNodeLister(informer.GetIndexer()),
+	return &backend{
+		&nodeBackend{
+			client:   c,
+			events:   make(chan *mesh.NodeEvent),
+			informer: ni,
+			lister:   v1listers.NewNodeLister(ni.GetIndexer()),
+		},
+		&peerBackend{
+			client:           kc,
+			extensionsClient: ec,
+			events:           make(chan *mesh.PeerEvent),
+			informer:         pi,
+			lister:           v1alpha1listers.NewPeerLister(pi.GetIndexer()),
+		},
 	}
-
-	return b
 }
 
 // CleanUp removes configuration applied to the backend.
-func (b *backend) CleanUp(name string) error {
+func (nb *nodeBackend) CleanUp(name string) error {
 	patch := []byte("[" + strings.Join([]string{
 		fmt.Sprintf(jsonRemovePatch, path.Join("/metadata", "annotations", strings.Replace(externalIPAnnotationKey, "/", jsonPatchSlash, 1))),
 		fmt.Sprintf(jsonRemovePatch, path.Join("/metadata", "annotations", strings.Replace(internalIPAnnotationKey, "/", jsonPatchSlash, 1))),
 		fmt.Sprintf(jsonRemovePatch, path.Join("/metadata", "annotations", strings.Replace(keyAnnotationKey, "/", jsonPatchSlash, 1))),
 		fmt.Sprintf(jsonRemovePatch, path.Join("/metadata", "annotations", strings.Replace(lastSeenAnnotationKey, "/", jsonPatchSlash, 1))),
 	}, ",") + "]")
-	if _, err := b.client.CoreV1().Nodes().Patch(name, types.JSONPatchType, patch); err != nil {
+	if _, err := nb.client.CoreV1().Nodes().Patch(name, types.JSONPatchType, patch); err != nil {
 		return fmt.Errorf("failed to patch node: %v", err)
 	}
 	return nil
 }
 
 // Get gets a single Node by name.
-func (b *backend) Get(name string) (*mesh.Node, error) {
-	n, err := b.lister.Get(name)
+func (nb *nodeBackend) Get(name string) (*mesh.Node, error) {
+	n, err := nb.lister.Get(name)
 	if err != nil {
 		return nil, err
 	}
@@ -97,14 +137,14 @@ func (b *backend) Get(name string) (*mesh.Node, error) {
 
 // Init initializes the backend; for this backend that means
 // syncing the informer cache.
-func (b *backend) Init(stop <-chan struct{}) error {
-	go b.informer.Run(stop)
+func (nb *nodeBackend) Init(stop <-chan struct{}) error {
+	go nb.informer.Run(stop)
 	if ok := cache.WaitForCacheSync(stop, func() bool {
-		return b.informer.HasSynced()
+		return nb.informer.HasSynced()
 	}); !ok {
 		return errors.New("failed to start sync node cache")
 	}
-	b.informer.AddEventHandler(
+	nb.informer.AddEventHandler(
 		cache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				n, ok := obj.(*v1.Node)
@@ -112,7 +152,7 @@ func (b *backend) Init(stop <-chan struct{}) error {
 					// Failed to decode Node; ignoring...
 					return
 				}
-				b.events <- &mesh.Event{Type: mesh.AddEvent, Node: translateNode(n)}
+				nb.events <- &mesh.NodeEvent{Type: mesh.AddEvent, Node: translateNode(n)}
 			},
 			UpdateFunc: func(_, obj interface{}) {
 				n, ok := obj.(*v1.Node)
@@ -120,7 +160,7 @@ func (b *backend) Init(stop <-chan struct{}) error {
 					// Failed to decode Node; ignoring...
 					return
 				}
-				b.events <- &mesh.Event{Type: mesh.UpdateEvent, Node: translateNode(n)}
+				nb.events <- &mesh.NodeEvent{Type: mesh.UpdateEvent, Node: translateNode(n)}
 			},
 			DeleteFunc: func(obj interface{}) {
 				n, ok := obj.(*v1.Node)
@@ -128,7 +168,7 @@ func (b *backend) Init(stop <-chan struct{}) error {
 					// Failed to decode Node; ignoring...
 					return
 				}
-				b.events <- &mesh.Event{Type: mesh.DeleteEvent, Node: translateNode(n)}
+				nb.events <- &mesh.NodeEvent{Type: mesh.DeleteEvent, Node: translateNode(n)}
 			},
 		},
 	)
@@ -136,8 +176,8 @@ func (b *backend) Init(stop <-chan struct{}) error {
 }
 
 // List gets all the Nodes in the cluster.
-func (b *backend) List() ([]*mesh.Node, error) {
-	ns, err := b.lister.List(labels.Everything())
+func (nb *nodeBackend) List() ([]*mesh.Node, error) {
+	ns, err := nb.lister.List(labels.Everything())
 	if err != nil {
 		return nil, err
 	}
@@ -149,8 +189,8 @@ func (b *backend) List() ([]*mesh.Node, error) {
 }
 
 // Set sets the fields of a node.
-func (b *backend) Set(name string, node *mesh.Node) error {
-	old, err := b.lister.Get(name)
+func (nb *nodeBackend) Set(name string, node *mesh.Node) error {
+	old, err := nb.lister.Get(name)
 	if err != nil {
 		return fmt.Errorf("failed to find node: %v", err)
 	}
@@ -171,15 +211,15 @@ func (b *backend) Set(name string, node *mesh.Node) error {
 	if err != nil {
 		return fmt.Errorf("failed to create patch for node %q: %v", n.Name, err)
 	}
-	if _, err = b.client.CoreV1().Nodes().Patch(name, types.StrategicMergePatchType, patch); err != nil {
+	if _, err = nb.client.CoreV1().Nodes().Patch(name, types.StrategicMergePatchType, patch); err != nil {
 		return fmt.Errorf("failed to patch node: %v", err)
 	}
 	return nil
 }
 
 // Watch returns a chan of node events.
-func (b *backend) Watch() <-chan *mesh.Event {
-	return b.events
+func (nb *nodeBackend) Watch() <-chan *mesh.NodeEvent {
+	return nb.events
 }
 
 // translateNode translates a Kubernetes Node to a mesh.Node.
@@ -214,7 +254,7 @@ func translateNode(node *v1.Node) *mesh.Node {
 	}
 	return &mesh.Node{
 		// ExternalIP and InternalIP should only ever fail to parse if the
-		// remote node's mesh has not yet set its IP address;
+		// remote node's agent has not yet set its IP address;
 		// in this case the IP will be nil and
 		// the mesh can wait for the node to be updated.
 		ExternalIP: normalizeIP(externalIP),
@@ -228,10 +268,179 @@ func translateNode(node *v1.Node) *mesh.Node {
 	}
 }
 
+// translatePeer translates a Peer CRD to a mesh.Peer.
+func translatePeer(peer *v1alpha1.Peer) *mesh.Peer {
+	if peer == nil {
+		return nil
+	}
+	var aips []*net.IPNet
+	for _, aip := range peer.Spec.AllowedIPs {
+		aip := normalizeIP(aip)
+		// Skip any invalid IPs.
+		if aip == nil {
+			continue
+		}
+		aips = append(aips, aip)
+	}
+	var endpoint *wireguard.Endpoint
+	if peer.Spec.Endpoint != nil {
+		ip := net.ParseIP(peer.Spec.Endpoint.IP)
+		if ip4 := ip.To4(); ip4 != nil {
+			ip = ip4
+		} else {
+			ip = ip.To16()
+		}
+		if peer.Spec.Endpoint.Port > 0 && ip != nil {
+			endpoint = &wireguard.Endpoint{
+				IP:   ip,
+				Port: peer.Spec.Endpoint.Port,
+			}
+		}
+	}
+	var key []byte
+	if len(peer.Spec.PublicKey) > 0 {
+		key = []byte(peer.Spec.PublicKey)
+	}
+	var pka int
+	if peer.Spec.PersistentKeepalive > 0 {
+		pka = peer.Spec.PersistentKeepalive
+	}
+	return &mesh.Peer{
+		Name: peer.Name,
+		Peer: wireguard.Peer{
+			AllowedIPs:          aips,
+			Endpoint:            endpoint,
+			PublicKey:           key,
+			PersistentKeepalive: pka,
+		},
+	}
+}
+
+// CleanUp removes configuration applied to the backend.
+func (pb *peerBackend) CleanUp(name string) error {
+	return nil
+}
+
+// Get gets a single Peer by name.
+func (pb *peerBackend) Get(name string) (*mesh.Peer, error) {
+	p, err := pb.lister.Get(name)
+	if err != nil {
+		return nil, err
+	}
+	return translatePeer(p), nil
+}
+
+// Init initializes the backend; for this backend that means
+// syncing the informer cache.
+func (pb *peerBackend) Init(stop <-chan struct{}) error {
+	// Register CRD.
+	crd := crdutils.NewCustomResourceDefinition(crdutils.Config{
+		SpecDefinitionName:    "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1.Peer",
+		EnableValidation:      true,
+		ResourceScope:         string(v1beta1.ClusterScoped),
+		Group:                 v1alpha1.GroupName,
+		Kind:                  v1alpha1.PeerKind,
+		Version:               v1alpha1.SchemeGroupVersion.Version,
+		Plural:                v1alpha1.PeerPlural,
+		ShortNames:            v1alpha1.PeerShortNames,
+		GetOpenAPIDefinitions: v1alpha1.GetOpenAPIDefinitions,
+	})
+	crd.Spec.Subresources.Scale = nil
+	crd.Spec.Subresources.Status = nil
+
+	_, err := pb.extensionsClient.ApiextensionsV1beta1().CustomResourceDefinitions().Create(crd)
+	if err != nil && !apierrors.IsAlreadyExists(err) {
+		return fmt.Errorf("failed to create CRD: %v", err)
+	}
+
+	go pb.informer.Run(stop)
+	if ok := cache.WaitForCacheSync(stop, func() bool {
+		return pb.informer.HasSynced()
+	}); !ok {
+		return errors.New("failed to start sync peer cache")
+	}
+	pb.informer.AddEventHandler(
+		cache.ResourceEventHandlerFuncs{
+			AddFunc: func(obj interface{}) {
+				p, ok := obj.(*v1alpha1.Peer)
+				if !ok || p.Validate() != nil {
+					// Failed to decode Peer; ignoring...
+					return
+				}
+				pb.events <- &mesh.PeerEvent{Type: mesh.AddEvent, Peer: translatePeer(p)}
+			},
+			UpdateFunc: func(_, obj interface{}) {
+				p, ok := obj.(*v1alpha1.Peer)
+				if !ok || p.Validate() != nil {
+					// Failed to decode Peer; ignoring...
+					return
+				}
+				pb.events <- &mesh.PeerEvent{Type: mesh.UpdateEvent, Peer: translatePeer(p)}
+			},
+			DeleteFunc: func(obj interface{}) {
+				p, ok := obj.(*v1alpha1.Peer)
+				if !ok || p.Validate() != nil {
+					// Failed to decode Peer; ignoring...
+					return
+				}
+				pb.events <- &mesh.PeerEvent{Type: mesh.DeleteEvent, Peer: translatePeer(p)}
+			},
+		},
+	)
+	return nil
+}
+
+// List gets all the Peers in the cluster.
+func (pb *peerBackend) List() ([]*mesh.Peer, error) {
+	ps, err := pb.lister.List(labels.Everything())
+	if err != nil {
+		return nil, err
+	}
+	peers := make([]*mesh.Peer, len(ps))
+	for i := range ps {
+		// Skip invalid peers.
+		if ps[i].Validate() != nil {
+			continue
+		}
+		peers[i] = translatePeer(ps[i])
+	}
+	return peers, nil
+}
+
+// Set sets the fields of a peer.
+func (pb *peerBackend) Set(name string, peer *mesh.Peer) error {
+	old, err := pb.lister.Get(name)
+	if err != nil {
+		return fmt.Errorf("failed to find peer: %v", err)
+	}
+	p := old.DeepCopy()
+	p.Spec.AllowedIPs = make([]string, len(peer.AllowedIPs))
+	for i := range peer.AllowedIPs {
+		p.Spec.AllowedIPs[i] = peer.AllowedIPs[i].String()
+	}
+	if peer.Endpoint != nil {
+		p.Spec.Endpoint = &v1alpha1.PeerEndpoint{
+			IP:   peer.Endpoint.IP.String(),
+			Port: peer.Endpoint.Port,
+		}
+	}
+	p.Spec.PersistentKeepalive = peer.PersistentKeepalive
+	p.Spec.PublicKey = string(peer.PublicKey)
+	if _, err = pb.client.KiloV1alpha1().Peers().Update(p); err != nil {
+		return fmt.Errorf("failed to update peer: %v", err)
+	}
+	return nil
+}
+
+// Watch returns a chan of peer events.
+func (pb *peerBackend) Watch() <-chan *mesh.PeerEvent {
+	return pb.events
+}
+
 func normalizeIP(ip string) *net.IPNet {
-	i, ipNet, _ := net.ParseCIDR(ip)
-	if ipNet == nil {
-		return ipNet
+	i, ipNet, err := net.ParseCIDR(ip)
+	if err != nil || ipNet == nil {
+		return nil
 	}
 	if ip4 := i.To4(); ip4 != nil {
 		ipNet.IP = ip4

pkg/k8s/backend_test.go

@@ -21,7 +21,9 @@ import (
 	"github.com/kylelemons/godebug/pretty"
 	v1 "k8s.io/api/core/v1"
 
+	"github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
 	"github.com/squat/kilo/pkg/mesh"
+	"github.com/squat/kilo/pkg/wireguard"
 )
 
 func TestTranslateNode(t *testing.T) {
@@ -152,3 +154,113 @@ func TestTranslateNode(t *testing.T) {
 		}
 	}
 }
+
+func TestTranslatePeer(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		out  *mesh.Peer
+		spec v1alpha1.PeerSpec
+	}{
+		{
+			name: "empty",
+			out:  &mesh.Peer{},
+		},
+		{
+			name: "invalid ips",
+			spec: v1alpha1.PeerSpec{
+				AllowedIPs: []string{
+					"10.0.0.1",
+					"foo",
+				},
+			},
+			out: &mesh.Peer{},
+		},
+		{
+			name: "valid ips",
+			spec: v1alpha1.PeerSpec{
+				AllowedIPs: []string{
+					"10.0.0.1/24",
+					"10.0.0.2/32",
+				},
+			},
+			out: &mesh.Peer{
+				Peer: wireguard.Peer{
+					AllowedIPs: []*net.IPNet{
+						{IP: net.ParseIP("10.0.0.1"), Mask: net.CIDRMask(24, 32)},
+						{IP: net.ParseIP("10.0.0.2"), Mask: net.CIDRMask(32, 32)},
+					},
+				},
+			},
+		},
+		{
+			name: "invalid endpoint ip",
+			spec: v1alpha1.PeerSpec{
+				Endpoint: &v1alpha1.PeerEndpoint{
+					IP:   "foo",
+					Port: mesh.DefaultKiloPort,
+				},
+			},
+			out: &mesh.Peer{},
+		},
+		{
+			name: "valid endpoint",
+			spec: v1alpha1.PeerSpec{
+				Endpoint: &v1alpha1.PeerEndpoint{
+					IP:   "10.0.0.1",
+					Port: mesh.DefaultKiloPort,
+				},
+			},
+			out: &mesh.Peer{
+				Peer: wireguard.Peer{
+					Endpoint: &wireguard.Endpoint{
+						IP:   net.ParseIP("10.0.0.1"),
+						Port: mesh.DefaultKiloPort,
+					},
+				},
+			},
+		},
+		{
+			name: "empty key",
+			spec: v1alpha1.PeerSpec{
+				PublicKey: "",
+			},
+			out: &mesh.Peer{},
+		},
+		{
+			name: "valid key",
+			spec: v1alpha1.PeerSpec{
+				PublicKey: "foo",
+			},
+			out: &mesh.Peer{
+				Peer: wireguard.Peer{
+					PublicKey: []byte("foo"),
+				},
+			},
+		},
+		{
+			name: "invalid keepalive",
+			spec: v1alpha1.PeerSpec{
+				PersistentKeepalive: -1,
+			},
+			out: &mesh.Peer{},
+		},
+		{
+			name: "valid keepalive",
+			spec: v1alpha1.PeerSpec{
+				PersistentKeepalive: 1,
+			},
+			out: &mesh.Peer{
+				Peer: wireguard.Peer{
+					PersistentKeepalive: 1,
+				},
+			},
+		},
+	} {
+		p := &v1alpha1.Peer{}
+		p.Spec = tc.spec
+		peer := translatePeer(p)
+		if diff := pretty.Compare(peer, tc.out); diff != "" {
+			t.Errorf("test case %q: got diff: %v", tc.name, diff)
+		}
+	}
+}

pkg/k8s/clientset/versioned/clientset.go

@@ -0,0 +1,88 @@
+// Copyright 2019 the Kilo 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 (
+	kilov1alpha1 "github.com/squat/kilo/pkg/k8s/clientset/versioned/typed/kilo/v1alpha1"
+	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
+	KiloV1alpha1() kilov1alpha1.KiloV1alpha1Interface
+}
+
+// Clientset contains the clients for groups. Each group has exactly one
+// version included in a Clientset.
+type Clientset struct {
+	*discovery.DiscoveryClient
+	kiloV1alpha1 *kilov1alpha1.KiloV1alpha1Client
+}
+
+// KiloV1alpha1 retrieves the KiloV1alpha1Client
+func (c *Clientset) KiloV1alpha1() kilov1alpha1.KiloV1alpha1Interface {
+	return c.kiloV1alpha1
+}
+
+// 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.kiloV1alpha1, err = kilov1alpha1.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.kiloV1alpha1 = kilov1alpha1.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.kiloV1alpha1 = kilov1alpha1.New(c)
+
+	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
+	return &cs
+}

pkg/k8s/clientset/versioned/doc.go

@@ -0,0 +1,18 @@
+// Copyright 2019 the Kilo 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/k8s/clientset/versioned/fake/clientset_generated.go

@@ -0,0 +1,75 @@
+// Copyright 2019 the Kilo 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/squat/kilo/pkg/k8s/clientset/versioned"
+	kilov1alpha1 "github.com/squat/kilo/pkg/k8s/clientset/versioned/typed/kilo/v1alpha1"
+	fakekilov1alpha1 "github.com/squat/kilo/pkg/k8s/clientset/versioned/typed/kilo/v1alpha1/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{}
+
+// KiloV1alpha1 retrieves the KiloV1alpha1Client
+func (c *Clientset) KiloV1alpha1() kilov1alpha1.KiloV1alpha1Interface {
+	return &fakekilov1alpha1.FakeKiloV1alpha1{Fake: &c.Fake}
+}

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

@@ -0,0 +1,18 @@
+// Copyright 2019 the Kilo 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/k8s/clientset/versioned/fake/register.go

@@ -0,0 +1,54 @@
+// Copyright 2019 the Kilo 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 (
+	kilov1alpha1 "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	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"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+)
+
+var scheme = runtime.NewScheme()
+var codecs = serializer.NewCodecFactory(scheme)
+var parameterCodec = runtime.NewParameterCodec(scheme)
+var localSchemeBuilder = runtime.SchemeBuilder{
+	kilov1alpha1.AddToScheme,
+}
+
+// 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.
+var AddToScheme = localSchemeBuilder.AddToScheme
+
+func init() {
+	v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: "v1"})
+	utilruntime.Must(AddToScheme(scheme))
+}

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

@@ -0,0 +1,18 @@
+// Copyright 2019 the Kilo 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/k8s/clientset/versioned/scheme/register.go

@@ -0,0 +1,54 @@
+// Copyright 2019 the Kilo 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 (
+	kilov1alpha1 "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	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"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+)
+
+var Scheme = runtime.NewScheme()
+var Codecs = serializer.NewCodecFactory(Scheme)
+var ParameterCodec = runtime.NewParameterCodec(Scheme)
+var localSchemeBuilder = runtime.SchemeBuilder{
+	kilov1alpha1.AddToScheme,
+}
+
+// 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.
+var AddToScheme = localSchemeBuilder.AddToScheme
+
+func init() {
+	v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"})
+	utilruntime.Must(AddToScheme(Scheme))
+}

pkg/k8s/clientset/versioned/typed/kilo/v1alpha1/doc.go

@@ -0,0 +1,18 @@
+// Copyright 2019 the Kilo 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 v1alpha1

pkg/k8s/clientset/versioned/typed/kilo/v1alpha1/fake/doc.go

@@ -0,0 +1,18 @@
+// Copyright 2019 the Kilo 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/k8s/clientset/versioned/typed/kilo/v1alpha1/fake/fake_kilo_client.go

@@ -0,0 +1,38 @@
+// Copyright 2019 the Kilo 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 (
+	v1alpha1 "github.com/squat/kilo/pkg/k8s/clientset/versioned/typed/kilo/v1alpha1"
+	rest "k8s.io/client-go/rest"
+	testing "k8s.io/client-go/testing"
+)
+
+type FakeKiloV1alpha1 struct {
+	*testing.Fake
+}
+
+func (c *FakeKiloV1alpha1) Peers() v1alpha1.PeerInterface {
+	return &FakePeers{c}
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeKiloV1alpha1) RESTClient() rest.Interface {
+	var ret *rest.RESTClient
+	return ret
+}

pkg/k8s/clientset/versioned/typed/kilo/v1alpha1/fake/fake_peer.go

@@ -0,0 +1,118 @@
+// Copyright 2019 the Kilo 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 (
+	v1alpha1 "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	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"
+)
+
+// FakePeers implements PeerInterface
+type FakePeers struct {
+	Fake *FakeKiloV1alpha1
+}
+
+var peersResource = schema.GroupVersionResource{Group: "kilo", Version: "v1alpha1", Resource: "peers"}
+
+var peersKind = schema.GroupVersionKind{Group: "kilo", Version: "v1alpha1", Kind: "Peer"}
+
+// Get takes name of the peer, and returns the corresponding peer object, and an error if there is any.
+func (c *FakePeers) Get(name string, options v1.GetOptions) (result *v1alpha1.Peer, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(peersResource, name), &v1alpha1.Peer{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.Peer), err
+}
+
+// List takes label and field selectors, and returns the list of Peers that match those selectors.
+func (c *FakePeers) List(opts v1.ListOptions) (result *v1alpha1.PeerList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(peersResource, peersKind, opts), &v1alpha1.PeerList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1alpha1.PeerList{ListMeta: obj.(*v1alpha1.PeerList).ListMeta}
+	for _, item := range obj.(*v1alpha1.PeerList).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 peers.
+func (c *FakePeers) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(peersResource, opts))
+}
+
+// Create takes the representation of a peer and creates it.  Returns the server's representation of the peer, and an error, if there is any.
+func (c *FakePeers) Create(peer *v1alpha1.Peer) (result *v1alpha1.Peer, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(peersResource, peer), &v1alpha1.Peer{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.Peer), err
+}
+
+// Update takes the representation of a peer and updates it. Returns the server's representation of the peer, and an error, if there is any.
+func (c *FakePeers) Update(peer *v1alpha1.Peer) (result *v1alpha1.Peer, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(peersResource, peer), &v1alpha1.Peer{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.Peer), err
+}
+
+// Delete takes name of the peer and deletes it. Returns an error if one occurs.
+func (c *FakePeers) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(peersResource, name), &v1alpha1.Peer{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakePeers) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(peersResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1alpha1.PeerList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched peer.
+func (c *FakePeers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Peer, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(peersResource, name, pt, data, subresources...), &v1alpha1.Peer{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha1.Peer), err
+}

pkg/k8s/clientset/versioned/typed/kilo/v1alpha1/generated_expansion.go

@@ -0,0 +1,19 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+type PeerExpansion interface{}

pkg/k8s/clientset/versioned/typed/kilo/v1alpha1/kilo_client.go

@@ -0,0 +1,88 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+import (
+	v1alpha1 "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	"github.com/squat/kilo/pkg/k8s/clientset/versioned/scheme"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	rest "k8s.io/client-go/rest"
+)
+
+type KiloV1alpha1Interface interface {
+	RESTClient() rest.Interface
+	PeersGetter
+}
+
+// KiloV1alpha1Client is used to interact with features provided by the kilo group.
+type KiloV1alpha1Client struct {
+	restClient rest.Interface
+}
+
+func (c *KiloV1alpha1Client) Peers() PeerInterface {
+	return newPeers(c)
+}
+
+// NewForConfig creates a new KiloV1alpha1Client for the given config.
+func NewForConfig(c *rest.Config) (*KiloV1alpha1Client, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &KiloV1alpha1Client{client}, nil
+}
+
+// NewForConfigOrDie creates a new KiloV1alpha1Client for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *KiloV1alpha1Client {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new KiloV1alpha1Client for the given RESTClient.
+func New(c rest.Interface) *KiloV1alpha1Client {
+	return &KiloV1alpha1Client{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	gv := v1alpha1.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 *KiloV1alpha1Client) RESTClient() rest.Interface {
+	if c == nil {
+		return nil
+	}
+	return c.restClient
+}

pkg/k8s/clientset/versioned/typed/kilo/v1alpha1/peer.go

@@ -0,0 +1,162 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+import (
+	"time"
+
+	v1alpha1 "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	scheme "github.com/squat/kilo/pkg/k8s/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"
+)
+
+// PeersGetter has a method to return a PeerInterface.
+// A group's client should implement this interface.
+type PeersGetter interface {
+	Peers() PeerInterface
+}
+
+// PeerInterface has methods to work with Peer resources.
+type PeerInterface interface {
+	Create(*v1alpha1.Peer) (*v1alpha1.Peer, error)
+	Update(*v1alpha1.Peer) (*v1alpha1.Peer, error)
+	Delete(name string, options *v1.DeleteOptions) error
+	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
+	Get(name string, options v1.GetOptions) (*v1alpha1.Peer, error)
+	List(opts v1.ListOptions) (*v1alpha1.PeerList, error)
+	Watch(opts v1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Peer, err error)
+	PeerExpansion
+}
+
+// peers implements PeerInterface
+type peers struct {
+	client rest.Interface
+}
+
+// newPeers returns a Peers
+func newPeers(c *KiloV1alpha1Client) *peers {
+	return &peers{
+		client: c.RESTClient(),
+	}
+}
+
+// Get takes name of the peer, and returns the corresponding peer object, and an error if there is any.
+func (c *peers) Get(name string, options v1.GetOptions) (result *v1alpha1.Peer, err error) {
+	result = &v1alpha1.Peer{}
+	err = c.client.Get().
+		Resource("peers").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Peers that match those selectors.
+func (c *peers) List(opts v1.ListOptions) (result *v1alpha1.PeerList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &v1alpha1.PeerList{}
+	err = c.client.Get().
+		Resource("peers").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested peers.
+func (c *peers) Watch(opts v1.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().
+		Resource("peers").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch()
+}
+
+// Create takes the representation of a peer and creates it.  Returns the server's representation of the peer, and an error, if there is any.
+func (c *peers) Create(peer *v1alpha1.Peer) (result *v1alpha1.Peer, err error) {
+	result = &v1alpha1.Peer{}
+	err = c.client.Post().
+		Resource("peers").
+		Body(peer).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a peer and updates it. Returns the server's representation of the peer, and an error, if there is any.
+func (c *peers) Update(peer *v1alpha1.Peer) (result *v1alpha1.Peer, err error) {
+	result = &v1alpha1.Peer{}
+	err = c.client.Put().
+		Resource("peers").
+		Name(peer.Name).
+		Body(peer).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the peer and deletes it. Returns an error if one occurs.
+func (c *peers) Delete(name string, options *v1.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("peers").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *peers) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	var timeout time.Duration
+	if listOptions.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Resource("peers").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched peer.
+func (c *peers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Peer, err error) {
+	result = &v1alpha1.Peer{}
+	err = c.client.Patch(pt).
+		Resource("peers").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

pkg/k8s/informers/factory.go

@@ -0,0 +1,178 @@
+// Copyright 2019 the Kilo 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 informers
+
+import (
+	reflect "reflect"
+	sync "sync"
+	time "time"
+
+	versioned "github.com/squat/kilo/pkg/k8s/clientset/versioned"
+	internalinterfaces "github.com/squat/kilo/pkg/k8s/informers/internalinterfaces"
+	kilo "github.com/squat/kilo/pkg/k8s/informers/kilo"
+	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
+
+	Kilo() kilo.Interface
+}
+
+func (f *sharedInformerFactory) Kilo() kilo.Interface {
+	return kilo.New(f, f.namespace, f.tweakListOptions)
+}

pkg/k8s/informers/generic.go

@@ -0,0 +1,60 @@
+// Copyright 2019 the Kilo 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 informers
+
+import (
+	"fmt"
+
+	v1alpha1 "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	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=kilo, Version=v1alpha1
+	case v1alpha1.SchemeGroupVersion.WithResource("peers"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Kilo().V1alpha1().Peers().Informer()}, nil
+
+	}
+
+	return nil, fmt.Errorf("no informer found for %v", resource)
+}

pkg/k8s/informers/internalinterfaces/factory_interfaces.go

@@ -0,0 +1,38 @@
+// Copyright 2019 the Kilo 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/squat/kilo/pkg/k8s/clientset/versioned"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// NewInformerFunc takes versioned.Interface and time.Duration to return a SharedIndexInformer.
+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
+}
+
+// TweakListOptionsFunc is a function that transforms a v1.ListOptions.
+type TweakListOptionsFunc func(*v1.ListOptions)

pkg/k8s/informers/kilo/interface.go

@@ -0,0 +1,44 @@
+// Copyright 2019 the Kilo 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 kilo
+
+import (
+	internalinterfaces "github.com/squat/kilo/pkg/k8s/informers/internalinterfaces"
+	v1alpha1 "github.com/squat/kilo/pkg/k8s/informers/kilo/v1alpha1"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1alpha1 provides access to shared informers for resources in V1alpha1.
+	V1alpha1() v1alpha1.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}
+}
+
+// V1alpha1 returns a new v1alpha1.Interface.
+func (g *group) V1alpha1() v1alpha1.Interface {
+	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
+}

pkg/k8s/informers/kilo/v1alpha1/interface.go

@@ -0,0 +1,43 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+import (
+	internalinterfaces "github.com/squat/kilo/pkg/k8s/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// Peers returns a PeerInformer.
+	Peers() PeerInformer
+}
+
+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}
+}
+
+// Peers returns a PeerInformer.
+func (v *version) Peers() PeerInformer {
+	return &peerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+}

pkg/k8s/informers/kilo/v1alpha1/peer.go

@@ -0,0 +1,86 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+import (
+	time "time"
+
+	kilov1alpha1 "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	versioned "github.com/squat/kilo/pkg/k8s/clientset/versioned"
+	internalinterfaces "github.com/squat/kilo/pkg/k8s/informers/internalinterfaces"
+	v1alpha1 "github.com/squat/kilo/pkg/k8s/listers/kilo/v1alpha1"
+	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"
+)
+
+// PeerInformer provides access to a shared informer and lister for
+// Peers.
+type PeerInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.PeerLister
+}
+
+type peerInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// NewPeerInformer constructs a new informer for Peer 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 NewPeerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredPeerInformer(client, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredPeerInformer constructs a new informer for Peer 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 NewFilteredPeerInformer(client versioned.Interface, 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.KiloV1alpha1().Peers().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.KiloV1alpha1().Peers().Watch(options)
+			},
+		},
+		&kilov1alpha1.Peer{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *peerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredPeerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *peerInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&kilov1alpha1.Peer{}, f.defaultInformer)
+}
+
+func (f *peerInformer) Lister() v1alpha1.PeerLister {
+	return v1alpha1.NewPeerLister(f.Informer().GetIndexer())
+}

pkg/k8s/listers/kilo/v1alpha1/expansion_generated.go

@@ -0,0 +1,21 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+// PeerListerExpansion allows custom methods to be added to
+// PeerLister.
+type PeerListerExpansion interface{}

pkg/k8s/listers/kilo/v1alpha1/peer.go

@@ -0,0 +1,63 @@
+// Copyright 2019 the Kilo 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 v1alpha1
+
+import (
+	v1alpha1 "github.com/squat/kilo/pkg/k8s/apis/kilo/v1alpha1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+)
+
+// PeerLister helps list Peers.
+type PeerLister interface {
+	// List lists all Peers in the indexer.
+	List(selector labels.Selector) (ret []*v1alpha1.Peer, err error)
+	// Get retrieves the Peer from the index for a given name.
+	Get(name string) (*v1alpha1.Peer, error)
+	PeerListerExpansion
+}
+
+// peerLister implements the PeerLister interface.
+type peerLister struct {
+	indexer cache.Indexer
+}
+
+// NewPeerLister returns a new PeerLister.
+func NewPeerLister(indexer cache.Indexer) PeerLister {
+	return &peerLister{indexer: indexer}
+}
+
+// List lists all Peers in the indexer.
+func (s *peerLister) List(selector labels.Selector) (ret []*v1alpha1.Peer, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*v1alpha1.Peer))
+	})
+	return ret, err
+}
+
+// Get retrieves the Peer from the index for a given name.
+func (s *peerLister) Get(name string) (*v1alpha1.Peer, error) {
+	obj, exists, err := s.indexer.GetByKey(name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(v1alpha1.Resource("peer"), name)
+	}
+	return obj.(*v1alpha1.Peer), nil
+}