Add Limit and Continue functional list options for client

Author: rajathagasthya

pkg/client/client_test.go

@@ -1705,6 +1705,89 @@ var _ = Describe("Client", func() {
 				close(done)
 			}, serverSideTimeoutSeconds)
 
+			It("should filter results using limit and continue options", func() {
+
+				makeDeployment := func(suffix string) *appsv1.Deployment {
+					return &appsv1.Deployment{
+						ObjectMeta: metav1.ObjectMeta{
+							Name: fmt.Sprintf("deployment-%s", suffix),
+						},
+						Spec: appsv1.DeploymentSpec{
+							Selector: &metav1.LabelSelector{
+								MatchLabels: map[string]string{"foo": "bar"},
+							},
+							Template: corev1.PodTemplateSpec{
+								ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"foo": "bar"}},
+								Spec:       corev1.PodSpec{Containers: []corev1.Container{{Name: "nginx", Image: "nginx"}}},
+							},
+						},
+					}
+				}
+
+				By("creating 4 deployments")
+				dep1 := makeDeployment("1")
+				dep1, err := clientset.AppsV1().Deployments(ns).Create(dep1)
+				Expect(err).NotTo(HaveOccurred())
+				defer deleteDeployment(dep1, ns)
+
+				dep2 := makeDeployment("2")
+				dep2, err = clientset.AppsV1().Deployments(ns).Create(dep2)
+				Expect(err).NotTo(HaveOccurred())
+				defer deleteDeployment(dep2, ns)
+
+				dep3 := makeDeployment("3")
+				dep3, err = clientset.AppsV1().Deployments(ns).Create(dep3)
+				Expect(err).NotTo(HaveOccurred())
+				defer deleteDeployment(dep3, ns)
+
+				dep4 := makeDeployment("4")
+				dep4, err = clientset.AppsV1().Deployments(ns).Create(dep4)
+				Expect(err).NotTo(HaveOccurred())
+				defer deleteDeployment(dep4, ns)
+
+				cl, err := client.New(cfg, client.Options{})
+				Expect(err).NotTo(HaveOccurred())
+
+				By("listing 1 deployment when limit=1 is used")
+				deps := &appsv1.DeploymentList{}
+				err = cl.List(context.Background(), deps,
+					client.Limit(1),
+				)
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(deps.Items).To(HaveLen(1))
+				Expect(deps.Continue).NotTo(BeEmpty())
+				Expect(deps.Items[0].Name).To(Equal(dep1.Name))
+
+				continueToken := deps.Continue
+
+				By("listing the next deployment when previous continuation token is used and limit=1")
+				deps = &appsv1.DeploymentList{}
+				err = cl.List(context.Background(), deps,
+					client.Limit(1),
+					client.Continue(continueToken),
+				)
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(deps.Items).To(HaveLen(1))
+				Expect(deps.Continue).NotTo(BeEmpty())
+				Expect(deps.Items[0].Name).To(Equal(dep2.Name))
+
+				continueToken = deps.Continue
+
+				By("listing the 2 remaining deployments when previous continuation token is used without a limit")
+				deps = &appsv1.DeploymentList{}
+				err = cl.List(context.Background(), deps,
+					client.Continue(continueToken),
+				)
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(deps.Items).To(HaveLen(2))
+				Expect(deps.Continue).To(BeEmpty())
+				Expect(deps.Items[0].Name).To(Equal(dep3.Name))
+				Expect(deps.Items[1].Name).To(Equal(dep4.Name))
+			}, serverSideTimeoutSeconds)
+
 			PIt("should fail if the object doesn't have meta", func() {
 
 			})
@@ -2129,6 +2212,52 @@ var _ = Describe("Client", func() {
 			Expect(lo.Namespace).To(Equal("test"))
 		})
 
+		It("should be created from Limit", func() {
+			lo := &client.ListOptions{}
+			client.Limit(1)(lo)
+			Expect(lo).NotTo(BeNil())
+			Expect(lo.Limit).To(Equal(int64(1)))
+		})
+
+		It("should ignore Limit when converted to metav1.ListOptions and watch is true", func() {
+			lo := &client.ListOptions{
+				Limit: 1,
+				Raw: &metav1.ListOptions{Watch: true},
+			}
+			mlo := lo.AsListOptions()
+			Expect(mlo).NotTo(BeNil())
+			Expect(mlo.Limit).To(BeZero())
+		})
+
+		It("should be created from Continue", func() {
+			lo := &client.ListOptions{}
+			client.Continue("foo")(lo)
+			Expect(lo).NotTo(BeNil())
+			Expect(lo.Continue).To(Equal("foo"))
+		})
+
+		It("should ignore Continue token when converted to metav1.ListOptions and watch is true", func() {
+			lo := &client.ListOptions{
+				Continue: "foo",
+				Raw: &metav1.ListOptions{Watch: true},
+			}
+			mlo := lo.AsListOptions()
+			Expect(mlo).NotTo(BeNil())
+			Expect(mlo.Continue).To(BeEmpty())
+		})
+
+		It("should ignore both Limit and Continue token when converted to metav1.ListOptions and watch is true", func() {
+			lo := &client.ListOptions{
+				Limit: 1,
+				Continue: "foo",
+				Raw: &metav1.ListOptions{Watch: true},
+			}
+			mlo := lo.AsListOptions()
+			Expect(mlo).NotTo(BeNil())
+			Expect(mlo.Limit).To(BeZero())
+			Expect(mlo.Continue).To(BeEmpty())
+		})
+
 		It("should allow pre-built ListOptions", func() {
 			lo := &client.ListOptions{}
 			newLo := &client.ListOptions{}

pkg/client/options.go

@@ -169,9 +169,20 @@ type ListOptions struct {
 	// non-namespaced objects, or to list across all namespaces.
 	Namespace string
 
+	// Limit specifies the maximum number of results to return from the server. The server may
+	// not support this field on all resource types, but if it does and more results remain it
+	// will set the continue field on the returned list object. This field is not supported if watch
+	// is true in the Raw ListOptions.
+	Limit int64
+	// Continue is a token returned by the server that lets a client retrieve chunks of results
+	// from the server by specifying limit. The server may reject requests for continuation tokens
+	// it does not recognize and will return a 410 error if the token can no longer be used because
+	// it has expired. This field is not supported if watch is true in the Raw ListOptions.
+	Continue string
+
 	// Raw represents raw ListOptions, as passed to the API server.  Note
 	// that these may not be respected by all implementations of interface,
-	// and the LabelSelector and FieldSelector fields are ignored.
+	// and the LabelSelector, FieldSelector, Limit and Continue fields are ignored.
 	Raw *metav1.ListOptions
 }
 
@@ -212,6 +223,10 @@ func (o *ListOptions) AsListOptions() *metav1.ListOptions {
 	if o.FieldSelector != nil {
 		o.Raw.FieldSelector = o.FieldSelector.String()
 	}
+	if !o.Raw.Watch {
+		o.Raw.Limit = o.Limit
+		o.Raw.Continue = o.Continue
+	}
 	return o.Raw
 }
 
@@ -280,6 +295,22 @@ func InNamespace(ns string) ListOptionFunc {
 	}
 }
 
+// Limit is a functional option that sets the Limit field of
+// a ListOptions struct.
+func Limit(n int64) ListOptionFunc {
+	return func(opts *ListOptions) {
+		opts.Limit = n
+	}
+}
+
+// Continue is a functional option that sets the Continue field of
+// a ListOptions struct.
+func Continue(token string) ListOptionFunc {
+	return func(opts *ListOptions) {
+		opts.Continue = token
+	}
+}
+
 // UseListOptions is a functional option that replaces the fields of a
 // ListOptions struct with those of a different ListOptions struct.
 //