[RAM] refactors RulesClient.update, by using new Task Manager API bulkUpdateSchedules

x-pack/plugins/alerting/server/rules_client/rules_client.ts

@@ -1245,20 +1245,23 @@ export class RulesClient {
       (async () => {
         if (
           updateResult.scheduledTaskId &&
+          updateResult.schedule &&
           !isEqual(alertSavedObject.attributes.schedule, updateResult.schedule)
         ) {
-          this.taskManager
-            .runNow(updateResult.scheduledTaskId)
-            .then(() => {
-              this.logger.debug(
-                `Alert update has rescheduled the underlying task: ${updateResult.scheduledTaskId}`
-              );
-            })
-            .catch((err: Error) => {
-              this.logger.error(
-                `Alert update failed to run its underlying task. TaskManager runNow failed with Error: ${err.message}`
-              );
-            });
+          try {
+            const { tasks } = await this.taskManager.bulkUpdateSchedules(
+              [updateResult.scheduledTaskId],
+              updateResult.schedule
+            );
+
+            this.logger.debug(
+              `Rule update has rescheduled the underlying task: ${updateResult.scheduledTaskId} to run at: ${tasks?.[0]?.runAt}`
+            );
+          } catch (err) {
+            this.logger.error(
+              `Rule update failed to run its underlying task. TaskManager bulkUpdateSchedules failed with Error: ${err.message}`
+            );
+          }
         }
       })(),
     ]);

x-pack/plugins/alerting/server/rules_client/tests/update.test.ts

@@ -17,7 +17,6 @@ import { RecoveredActionGroup } from '../../../common';
 import { encryptedSavedObjectsMock } from '@kbn/encrypted-saved-objects-plugin/server/mocks';
 import { actionsAuthorizationMock } from '@kbn/actions-plugin/server/mocks';
 import { AlertingAuthorization } from '../../authorization/alerting_authorization';
-import { resolvable } from '../../test_utils';
 import { ActionsAuthorization, ActionsClient } from '@kbn/actions-plugin/server';
 import { TaskStatus } from '@kbn/task-manager-plugin/server';
 import { auditLoggerMock } from '@kbn/security-plugin/server/audit/mocks';
@@ -1585,7 +1584,7 @@ describe('update()', () => {
       taskManager.runNow.mockReturnValueOnce(Promise.resolve({ id: alertId }));
     }
 
-    test('updating the alert schedule should rerun the task immediately', async () => {
+    test('updating the alert schedule should call taskManager.bulkUpdateSchedules', async () => {
       const alertId = uuid.v4();
       const taskId = uuid.v4();
 
@@ -1614,10 +1613,10 @@ describe('update()', () => {
         },
       });
 
-      expect(taskManager.runNow).toHaveBeenCalledWith(taskId);
+      expect(taskManager.bulkUpdateSchedules).toHaveBeenCalledWith([taskId], { interval: '1m' });
     });
 
-    test('updating the alert without changing the schedule should not rerun the task', async () => {
+    test('updating the alert without changing the schedule should not call taskManager.bulkUpdateSchedules', async () => {
       const alertId = uuid.v4();
       const taskId = uuid.v4();
 
@@ -1646,55 +1645,17 @@ describe('update()', () => {
         },
       });
 
-      expect(taskManager.runNow).not.toHaveBeenCalled();
+      expect(taskManager.bulkUpdateSchedules).not.toHaveBeenCalled();
     });
 
-    test('updating the alert should not wait for the rerun the task to complete', async () => {
+    test('logs when update of schedule of an alerts underlying task fails', async () => {
       const alertId = uuid.v4();
       const taskId = uuid.v4();
 
       mockApiCalls(alertId, taskId, { interval: '1m' }, { interval: '30s' });
 
-      const resolveAfterAlertUpdatedCompletes = resolvable<{ id: string }>();
-
-      taskManager.runNow.mockReset();
-      taskManager.runNow.mockReturnValue(resolveAfterAlertUpdatedCompletes);
-
-      await rulesClient.update({
-        id: alertId,
-        data: {
-          schedule: { interval: '1m' },
-          name: 'abc',
-          tags: ['foo'],
-          params: {
-            bar: true,
-          },
-          throttle: null,
-          notifyWhen: null,
-          actions: [
-            {
-              group: 'default',
-              id: '1',
-              params: {
-                foo: true,
-              },
-            },
-          ],
-        },
-      });
-
-      expect(taskManager.runNow).toHaveBeenCalled();
-      resolveAfterAlertUpdatedCompletes.resolve({ id: alertId });
-    });
-
-    test('logs when the rerun of an alerts underlying task fails', async () => {
-      const alertId = uuid.v4();
-      const taskId = uuid.v4();
-
-      mockApiCalls(alertId, taskId, { interval: '1m' }, { interval: '30s' });
-
-      taskManager.runNow.mockReset();
-      taskManager.runNow.mockRejectedValue(new Error('Failed to run alert'));
+      taskManager.bulkUpdateSchedules.mockReset();
+      taskManager.bulkUpdateSchedules.mockRejectedValue(new Error('Failed to run alert'));
 
       await rulesClient.update({
         id: alertId,
@@ -1719,10 +1680,10 @@ describe('update()', () => {
         },
       });
 
-      expect(taskManager.runNow).toHaveBeenCalled();
+      expect(taskManager.bulkUpdateSchedules).toHaveBeenCalled();
 
       expect(rulesClientParams.logger.error).toHaveBeenCalledWith(
-        `Alert update failed to run its underlying task. TaskManager runNow failed with Error: Failed to run alert`
+        `Rule update failed to run its underlying task. TaskManager bulkUpdateSchedules failed with Error: Failed to run alert`
       );
     });
   });