client: status subresource support

Author: droot

pkg/client/client.go

@@ -154,3 +154,36 @@ func (c *client) List(ctx context.Context, opts *ListOptions, obj runtime.Object
 		Do().
 		Into(obj)
 }
+
+// Status implements client.StatusClient
+func (c *client) Status() StatusWriter {
+	return &statusWriter{client: c}
+}
+
+// statusWriter is client.StatusWriter that writes status subresource
+type statusWriter struct {
+	client *client
+}
+
+// ensure statusWriter implements client.StatusWriter
+var _ StatusWriter = &statusWriter{}
+
+// Update implements client.StatusWriter
+func (sw *statusWriter) Update(_ context.Context, obj runtime.Object) error {
+	o, err := sw.client.cache.getObjMeta(obj)
+	if err != nil {
+		return err
+	}
+	// TODO(droot): examine the returned error and check if it error needs to be
+	// wrapped to improve the UX ?
+	// It will be nice to receive an error saying the object doesn't implement
+	// status subresource and check CRD definition
+	return o.Put().
+		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
+		Resource(o.resource()).
+		Name(o.GetName()).
+		SubResource("status").
+		Body(obj).
+		Do().
+		Into(obj)
+}

pkg/client/client_test.go

@@ -58,13 +58,15 @@ var _ = Describe("Client", func() {
 	var pod *corev1.Pod
 	var node *corev1.Node
 	var count uint64 = 0
+	var replicaCount int32 = 2
 	var ns = "default"
 
 	BeforeEach(func(done Done) {
 		atomic.AddUint64(&count, 1)
 		dep = &appsv1.Deployment{
 			ObjectMeta: metav1.ObjectMeta{Name: fmt.Sprintf("deployment-name-%v", count), Namespace: ns},
 			Spec: appsv1.DeploymentSpec{
+				Replicas: &replicaCount,
 				Selector: &metav1.LabelSelector{
 					MatchLabels: map[string]string{"foo": "bar"},
 				},
@@ -391,6 +393,119 @@ var _ = Describe("Client", func() {
 		})
 	})
 
+	Describe("StatusClient", func() {
+		It("should update status of an existing object", func(done Done) {
+			cl, err := client.New(cfg, client.Options{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cl).NotTo(BeNil())
+
+			By("initially creating a Deployment")
+			dep, err := clientset.AppsV1().Deployments(ns).Create(dep)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("updating the status of Deployment")
+			dep.Status.Replicas = 1
+			err = cl.Status().Update(context.TODO(), dep)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("validating updated Deployment has new status")
+			actual, err := clientset.AppsV1().Deployments(ns).Get(dep.Name, metav1.GetOptions{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(actual).NotTo(BeNil())
+			Expect(actual.Status.Replicas).To(BeEquivalentTo(1))
+
+			close(done)
+		})
+
+		It("should not update spec of an existing object", func(done Done) {
+			cl, err := client.New(cfg, client.Options{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cl).NotTo(BeNil())
+
+			By("initially creating a Deployment")
+			dep, err := clientset.AppsV1().Deployments(ns).Create(dep)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("updating the spec and status of Deployment")
+			var rc int32 = 1
+			dep.Status.Replicas = 1
+			dep.Spec.Replicas = &rc
+			err = cl.Status().Update(context.TODO(), dep)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("validating updated Deployment has new status and unchanged spec")
+			actual, err := clientset.AppsV1().Deployments(ns).Get(dep.Name, metav1.GetOptions{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(actual).NotTo(BeNil())
+			Expect(actual.Status.Replicas).To(BeEquivalentTo(1))
+			Expect(*actual.Spec.Replicas).To(BeEquivalentTo(replicaCount))
+
+			close(done)
+		})
+
+		It("should update an existing object non-namespace object", func(done Done) {
+			cl, err := client.New(cfg, client.Options{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cl).NotTo(BeNil())
+
+			node, err := clientset.CoreV1().Nodes().Create(node)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("updating status of the object")
+			node.Status.Phase = corev1.NodeRunning
+			err = cl.Status().Update(context.TODO(), node)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("validate updated Node had new annotation")
+			actual, err := clientset.CoreV1().Nodes().Get(node.Name, metav1.GetOptions{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(actual).NotTo(BeNil())
+			Expect(actual.Status.Phase).To(Equal(corev1.NodeRunning))
+
+			close(done)
+		})
+
+		It("should fail if the object does not exists", func(done Done) {
+			cl, err := client.New(cfg, client.Options{})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cl).NotTo(BeNil())
+
+			By("updating status of a non-existent object")
+			err = cl.Status().Update(context.TODO(), dep)
+			Expect(err).To(HaveOccurred())
+
+			close(done)
+		})
+
+		It("should fail if the object cannot be mapped to a GVK", func(done Done) {
+			By("creating client with empty Scheme")
+			emptyScheme := runtime.NewScheme()
+			cl, err := client.New(cfg, client.Options{Scheme: emptyScheme})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cl).NotTo(BeNil())
+
+			By("initially creating a Deployment")
+			dep, err := clientset.AppsV1().Deployments(ns).Create(dep)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("updating status of the Deployment")
+			dep.Status.Replicas = 1
+			err = cl.Status().Update(context.TODO(), dep)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("no kind is registered for the type"))
+
+			close(done)
+		})
+
+		It("should fail if the GVK cannot be mapped to a Resource", func() {
+
+		})
+
+		It("should fail if an API does not implement Status subresource", func() {
+
+		})
+	})
+
 	Describe("Delete", func() {
 		It("should delete an existing object from a go struct", func(done Done) {
 			cl, err := client.New(cfg, client.Options{})

pkg/client/fake/client.go

@@ -123,6 +123,10 @@ func (c *fakeClient) Update(ctx context.Context, obj runtime.Object) error {
 	return c.tracker.Update(gvr, obj, accessor.GetNamespace())
 }
 
+func (c *fakeClient) Status() client.StatusWriter {
+	return &fakeStatusWriter{client: c}
+}
+
 func getGVRFromObject(obj runtime.Object) (schema.GroupVersionResource, error) {
 	gvk, err := apiutil.GVKForObject(obj, scheme.Scheme)
 	if err != nil {
@@ -131,3 +135,13 @@ func getGVRFromObject(obj runtime.Object) (schema.GroupVersionResource, error) {
 	gvr, _ := meta.UnsafeGuessKindToResource(gvk)
 	return gvr, nil
 }
+
+type fakeStatusWriter struct {
+	client *fakeClient
+}
+
+func (sw *fakeStatusWriter) Update(ctx context.Context, obj runtime.Object) error {
+	// TODO(droot): This results in full update of the obj (spec + status). Need
+	// a way to update status field only.
+	return sw.client.Update(ctx, obj)
+}

pkg/client/interfaces.go

@@ -57,10 +57,25 @@ type Writer interface {
 	Update(ctx context.Context, obj runtime.Object) error
 }
 
+// StatusClient knows how to create a client which can update status subresource
+// for kubernetes objects.
+type StatusClient interface {
+	Status() StatusWriter
+}
+
+// StatusWriter knows how to update status subresource of a Kubernetes object.
+type StatusWriter interface {
+	// Update updates the fields corresponding to the status subresource for the
+	// given obj. obj must be a struct pointer so that obj can be updated
+	// with the content returned by the Server.
+	Update(ctx context.Context, obj runtime.Object) error
+}
+
 // Client knows how to perform CRUD operations on Kubernetes objects.
 type Client interface {
 	Reader
 	Writer
+	StatusClient
 }
 
 // IndexerFunc knows how to take an object and turn it into a series

pkg/client/split.go

@@ -17,9 +17,10 @@ limitations under the License.
 package client
 
 // DelegatingClient forms an interface Client by composing separate
-// read and write interfaces.  This way, you can have an Client that
+// reader, writer and statusclient interfaces.  This way, you can have an Client that
 // reads from a cache and writes to the API server.
 type DelegatingClient struct {
 	Reader
 	Writer
+	StatusClient
 }

pkg/manager/manager.go

@@ -132,7 +132,6 @@ func New(config *rest.Config, options Options) (Manager, error) {
 	cache, err := options.newCache(config, cache.Options{Scheme: options.Scheme, Mapper: mapper, Resync: options.SyncPeriod})
 	if err != nil {
 		return nil, err
-
 	}
 	// Create the recorder provider to inject event recorders for the components.
 	recorderProvider, err := options.newRecorderProvider(config, options.Scheme)
@@ -146,7 +145,7 @@ func New(config *rest.Config, options Options) (Manager, error) {
 		errChan:          make(chan error),
 		cache:            cache,
 		fieldIndexes:     cache,
-		client:           client.DelegatingClient{Reader: cache, Writer: writeObj},
+		client:           client.DelegatingClient{Reader: cache, Writer: writeObj, StatusClient: writeObj},
 		recorderProvider: recorderProvider,
 	}, nil
 }