Introduce config to cap service related polling interval

The maximum polling interval was hardcoded to 24h when set on the job. Though, the exponential backoff calculation did not take this into account.
Now the maximum can be configured through `broker_client_maximum_async_poll_interval_seconds` and will be taken into account for all scenarios. Default is still 24h and the config is optional.

Author: svkrieger

app/jobs/reoccurring_job.rb

@@ -35,7 +35,7 @@ def polling_interval_seconds
 
       def polling_interval_seconds=(interval)
         interval = interval.to_i if interval.is_a? String
-        @polling_interval = interval.clamp(default_polling_interval_seconds, 24.hours)
+        @polling_interval = interval.clamp(default_polling_interval_seconds, maximum_polling_interval)
       end
 
       private
@@ -58,8 +58,16 @@ def default_polling_exponential_backoff
         Config.config.get(:broker_client_async_poll_exponential_backoff_rate)
       end
 
+      def maximum_polling_interval
+        Config.config.get(:broker_client_max_async_poll_interval_seconds) || 24.hours
+      end
+
       def next_execution_in
-        [polling_interval_seconds, default_polling_interval_seconds * (default_polling_exponential_backoff**retry_number)].max
+        # use larger polling_interval. Either from job or calculated.
+        polling_interval = [polling_interval_seconds, default_polling_interval_seconds * (default_polling_exponential_backoff**retry_number)].max
+
+        # cap polling interval at maximum_polling_interval
+        [polling_interval, maximum_polling_interval].min
       end
 
       def next_enqueue_would_exceed_maximum_duration?

lib/cloud_controller/config_schemas/base/api_schema.rb

@@ -208,6 +208,7 @@ class ApiSchema < VCAP::Config
             broker_client_default_async_poll_interval_seconds: Integer,
             broker_client_max_async_poll_duration_minutes: Integer,
             broker_client_async_poll_exponential_backoff_rate: Numeric,
+            optional(:broker_client_max_async_poll_interval_seconds) => Integer,
             optional(:broker_client_response_parser) => {
               log_errors: bool,
               log_validators: bool,

lib/cloud_controller/config_schemas/base/worker_schema.rb

@@ -115,6 +115,7 @@ class WorkerSchema < VCAP::Config
             broker_client_default_async_poll_interval_seconds: Integer,
             broker_client_max_async_poll_duration_minutes: Integer,
             broker_client_async_poll_exponential_backoff_rate: Numeric,
+            optional(:broker_client_max_async_poll_interval_seconds) => Integer,
             optional(:broker_client_response_parser) => {
               log_errors: bool,
               log_validators: bool,

spec/unit/jobs/reoccurring_job_spec.rb

@@ -109,7 +109,7 @@ def perform
         end
       end
 
-      it 'keeps the polling interval within the bounds' do
+      it 'keeps the polling interval within the default bounds' do
         job = FakeJob.new
         job.polling_interval_seconds = 5
         expect(job.polling_interval_seconds).to eq(60)
@@ -118,6 +118,18 @@ def perform
         expect(job.polling_interval_seconds).to eq(24.hours)
       end
 
+      context 'when maximum polling interval is configured' do
+        before do
+          TestConfig.config[:broker_client_max_async_poll_interval_seconds] = 1800
+        end
+
+        it 'limits the polling interval to the configured maximum' do
+          job = FakeJob.new
+          job.polling_interval_seconds = 10.days
+          expect(job.polling_interval_seconds).to eq(1800)
+        end
+      end
+
       describe 'exponential backoff rate' do
         context 'when changing exponential backoff rate only' do
           before do
@@ -295,6 +307,51 @@ def perform
                 execute_all_jobs(expected_successes: 1, expected_failures: 0)
               end
             end
+
+            context 'when maximum polling interval is configured' do
+              before do
+                TestConfig.config[:broker_client_max_async_poll_interval_seconds] = 18
+              end
+
+              it 'limits the polling interval to the configured maximum' do
+                enqueued_time = 0
+
+                Timecop.freeze do
+                  Jobs::Enqueuer.new(queue: Jobs::Queues.generic).enqueue_pollable(fake_job)
+                  execute_all_jobs(expected_successes: 1, expected_failures: 0)
+                  enqueued_time = Time.now
+                end
+
+                # the job should run after 15s (15s > 5s (5 * 2^0))
+                Timecop.freeze(14.seconds.after(enqueued_time)) do
+                  execute_all_jobs(expected_successes: 0, expected_failures: 0)
+                end
+
+                Timecop.freeze(16.seconds.after(enqueued_time)) do
+                  enqueued_time = Time.now
+                  execute_all_jobs(expected_successes: 1, expected_failures: 0)
+                end
+
+                # the job should run after 15s (15s > 10s (5 * 2^1))
+                Timecop.freeze(14.seconds.after(enqueued_time)) do
+                  execute_all_jobs(expected_successes: 0, expected_failures: 0)
+                end
+
+                Timecop.freeze(16.seconds.after(enqueued_time)) do
+                  enqueued_time = Time.now
+                  execute_all_jobs(expected_successes: 1, expected_failures: 0)
+                end
+
+                # the job should run after 18s (capped at )
+                Timecop.freeze(17.seconds.after(enqueued_time)) do
+                  execute_all_jobs(expected_successes: 0, expected_failures: 0)
+                end
+
+                Timecop.freeze(19.seconds.after(enqueued_time)) do
+                  execute_all_jobs(expected_successes: 1, expected_failures: 0)
+                end
+              end
+            end
           end
         end