feat: make a configurable poll interval (#225)

* make a configurable poll interval

* add comment

Author: zreigz

cmd/agent/agent.go

@@ -19,6 +19,8 @@ import (
 	"github.com/pluralsh/deployment-operator/pkg/controller/service"
 )
 
+const pollInterval = time.Second * 30
+
 func runAgent(opt *options, config *rest.Config, ctx context.Context, k8sClient ctrclient.Client) (*controller.ControllerManager, *service.ServiceReconciler, *pipelinegates.GateReconciler) {
 	r, err := time.ParseDuration(opt.refreshInterval)
 	if err != nil {
@@ -48,7 +50,7 @@ func runAgent(opt *options, config *rest.Config, ctx context.Context, k8sClient
 		Do:    sr,
 		Queue: sr.SvcQueue,
 	})
-	gr, err := pipelinegates.NewGateReconciler(mgr.GetClient(), k8sClient, config, r, opt.clusterId)
+	gr, err := pipelinegates.NewGateReconciler(mgr.GetClient(), k8sClient, config, r, pollInterval, opt.clusterId)
 	if err != nil {
 		setupLog.Errorw("unable to create gate reconciler", "error", err)
 		os.Exit(1)
@@ -79,7 +81,7 @@ func runAgent(opt *options, config *rest.Config, ctx context.Context, k8sClient
 		os.Exit(1)
 	}
 
-	s := stacks.NewStackReconciler(mgr.GetClient(), k8sClient, r, namespace, opt.consoleUrl, opt.deployToken)
+	s := stacks.NewStackReconciler(mgr.GetClient(), k8sClient, r, pollInterval, namespace, opt.consoleUrl, opt.deployToken)
 	mgr.AddController(&controller.Controller{
 		Name:  "Stack Controller",
 		Do:    s,

pkg/controller/controller.go

@@ -33,6 +33,9 @@ type Reconciler interface {
 
 	// ShutdownQueue containing Console resources.
 	ShutdownQueue()
+
+	// GetPollInterval returns custom poll interval. If 0 then controller manager use default from the options.
+	GetPollInterval() time.Duration
 }
 
 type Controller struct {

pkg/controller/controller_manager.go

@@ -83,8 +83,13 @@ func (cm *ControllerManager) Start() error {
 		go func() {
 			defer controller.Do.ShutdownQueue()
 			defer controller.Do.WipeCache()
+
+			pollInterval := cm.Refresh
+			if controllerPollInterval := controller.Do.GetPollInterval(); controllerPollInterval > 0 {
+				pollInterval = controllerPollInterval
+			}
 			//nolint:all
-			_ = wait.PollImmediateInfinite(cm.Refresh, func() (done bool, err error) {
+			_ = wait.PollImmediateInfinite(pollInterval, func() (done bool, err error) {
 				return controller.Do.Poll(cm.ctx)
 			})
 		}()

pkg/controller/namespaces/reconciler.go

@@ -41,6 +41,10 @@ func NewNamespaceReconciler(consoleClient client.Client, k8sClient ctrlclient.Cl
 	}
 }
 
+func (n *NamespaceReconciler) GetPollInterval() time.Duration {
+	return 0 // use default poll interval
+}
+
 func (n *NamespaceReconciler) GetPublisher() (string, websocket.Publisher) {
 	return "namespace.event", &socketPublisher{
 		restoreQueue: n.NamespaceQueue,

pkg/controller/pipelinegates/reconciler.go

@@ -36,9 +36,10 @@ type GateReconciler struct {
 	discoveryClient   *discovery.DiscoveryClient
 	pinger            *ping.Pinger
 	operatorNamespace string
+	PollInterval      time.Duration
 }
 
-func NewGateReconciler(consoleClient client.Client, k8sClient ctrlclient.Client, config *rest.Config, refresh time.Duration, clusterId string) (*GateReconciler, error) {
+func NewGateReconciler(consoleClient client.Client, k8sClient ctrlclient.Client, config *rest.Config, refresh, pollInterval time.Duration, clusterId string) (*GateReconciler, error) {
 	utils.DisableClientLimits(config)
 
 	discoveryClient, err := discovery.NewDiscoveryClientForConfig(config)
@@ -74,9 +75,14 @@ func NewGateReconciler(consoleClient client.Client, k8sClient ctrlclient.Client,
 		discoveryClient:   discoveryClient,
 		pinger:            ping.New(consoleClient, discoveryClient, f),
 		operatorNamespace: namespace,
+		PollInterval:      pollInterval,
 	}, nil
 }
 
+func (s *GateReconciler) GetPollInterval() time.Duration {
+	return s.PollInterval
+}
+
 func (s *GateReconciler) WipeCache() {
 	s.GateCache.Wipe()
 }

pkg/controller/restore/reconciler.go

@@ -63,6 +63,10 @@ func NewRestoreReconciler(consoleClient client.Client, k8sClient ctrlclient.Clie
 	}
 }
 
+func (s *RestoreReconciler) GetPollInterval() time.Duration {
+	return 0 // use default poll interval
+}
+
 func (s *RestoreReconciler) GetPublisher() (string, websocket.Publisher) {
 	return "restore.event", &socketPublisher{
 		restoreQueue: s.RestoreQueue,

pkg/controller/service/reconciler.go

@@ -155,6 +155,10 @@ func CapabilitiesAPIVersions(discoveryClient *discovery.DiscoveryClient) error {
 	return nil
 }
 
+func (s *ServiceReconciler) GetPollInterval() time.Duration {
+	return 0 // use default poll interval
+}
+
 func (s *ServiceReconciler) GetPublisher() (string, websocket.Publisher) {
 	return "service.event", &socketPublisher{
 		svcQueue: s.SvcQueue,

pkg/controller/stacks/job_test.go

@@ -15,7 +15,7 @@ func TestGetDefaultContainerImage(t *testing.T) {
 	var kClient client.Client
 	fakeConsoleClient := mocks.NewClientMock(t)
 	namespace := "default"
-	reconciler := NewStackReconciler(fakeConsoleClient, kClient, time.Minute, namespace, "", "")
+	reconciler := NewStackReconciler(fakeConsoleClient, kClient, time.Minute, 0, namespace, "", "")
 	run := &console.StackRunFragment{
 		Type: console.StackTypeTerraform,
 		Configuration: &console.StackConfigurationFragment{

pkg/controller/stacks/reconciler.go

@@ -25,22 +25,28 @@ type StackReconciler struct {
 	Namespace     string
 	ConsoleURL    string
 	DeployToken   string
+	PollInterval  time.Duration
 }
 
-func NewStackReconciler(consoleClient client.Client, k8sClient ctrlclient.Client, refresh time.Duration, namespace, consoleURL, deployToken string) *StackReconciler {
+func NewStackReconciler(consoleClient client.Client, k8sClient ctrlclient.Client, refresh, pollInterval time.Duration, namespace, consoleURL, deployToken string) *StackReconciler {
 	return &StackReconciler{
 		ConsoleClient: consoleClient,
 		K8sClient:     k8sClient,
 		StackQueue:    workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()),
 		StackCache: client.NewCache[console.StackRunFragment](refresh, func(id string) (*console.StackRunFragment, error) {
 			return consoleClient.GetStackRun(id)
 		}),
-		Namespace:   namespace,
-		ConsoleURL:  consoleURL,
-		DeployToken: deployToken,
+		Namespace:    namespace,
+		ConsoleURL:   consoleURL,
+		DeployToken:  deployToken,
+		PollInterval: pollInterval,
 	}
 }
 
+func (r *StackReconciler) GetPollInterval() time.Duration {
+	return r.PollInterval
+}
+
 func (r *StackReconciler) GetPublisher() (string, websocket.Publisher) {
 	return "stack.run.event", &socketPublisher{
 		stackRunQueue: r.StackQueue,

pkg/controller/stacks/reconciler_test.go

@@ -73,7 +73,7 @@ var _ = Describe("Reconciler", Ordered, func() {
 				GqlErrors: &gqlerror.List{gqlerror.Errorf(errors2.ErrorNotFound.String())},
 			})
 
-			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, namespace, "", "")
+			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, 0, namespace, "", "")
 
 			_, err := reconciler.Reconcile(ctx, stackRunId)
 			Expect(err).NotTo(HaveOccurred())
@@ -85,7 +85,7 @@ var _ = Describe("Reconciler", Ordered, func() {
 				GqlErrors: &gqlerror.List{gqlerror.Errorf("unknown error")},
 			})
 
-			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, namespace, "", "")
+			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, 0, namespace, "", "")
 
 			_, err := reconciler.Reconcile(ctx, stackRunId)
 			Expect(err).To(HaveOccurred())
@@ -100,7 +100,7 @@ var _ = Describe("Reconciler", Ordered, func() {
 				Status:   console.StackStatusPending,
 			}, nil)
 
-			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, namespace, "", "")
+			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, 0, namespace, "", "")
 
 			_, err := reconciler.Reconcile(ctx, stackRunId)
 			Expect(err).NotTo(HaveOccurred())
@@ -118,7 +118,7 @@ var _ = Describe("Reconciler", Ordered, func() {
 			fakeConsoleClient.On("GetStackRun", mock.Anything).Return(stackRun, nil)
 			fakeConsoleClient.On("UpdateStackRun", mock.Anything, mock.Anything).Return(nil)
 
-			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, namespace, "", "")
+			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, 0, namespace, "", "")
 
 			_, err := reconciler.Reconcile(ctx, stackRunId)
 			Expect(err).NotTo(HaveOccurred())
@@ -157,7 +157,7 @@ var _ = Describe("Reconciler", Ordered, func() {
 			fakeConsoleClient.On("GetStackRun", mock.Anything).Return(stackRun, nil)
 			fakeConsoleClient.On("UpdateStackRun", mock.Anything, mock.Anything).Return(nil)
 
-			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, namespace, "", "")
+			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, 0, namespace, "", "")
 
 			_, err := reconciler.Reconcile(ctx, stackRunId)
 			Expect(err).NotTo(HaveOccurred())
@@ -213,7 +213,7 @@ var _ = Describe("Reconciler", Ordered, func() {
 			fakeConsoleClient.On("GetStackRun", mock.Anything).Return(stackRun, nil)
 			fakeConsoleClient.On("UpdateStackRun", mock.Anything, mock.Anything).Return(nil)
 
-			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, namespace, "", "")
+			reconciler := stacks.NewStackReconciler(fakeConsoleClient, kClient, time.Minute, 0, namespace, "", "")
 
 			_, err = reconciler.Reconcile(ctx, stackRunId)
 			Expect(err).NotTo(HaveOccurred())