[Response Ops][Alerting] Adding ability to run actions for backfill rule runs

x-pack/platform/plugins/shared/actions/server/create_execute_function.test.ts

@@ -16,6 +16,7 @@ import {
   asSavedObjectExecutionSource,
 } from './lib/action_execution_source';
 import { actionsConfigMock } from './actions_config.mock';
+import { TaskPriority } from '@kbn/task-manager-plugin/server';
 
 const mockTaskManager = taskManagerMock.createStart();
 const savedObjectsClient = savedObjectsClientMock.create();
@@ -1189,4 +1190,210 @@ describe('bulkExecute()', () => {
       ]
     `);
   });
+
+  test('uses priority if specified', async () => {
+    mockTaskManager.aggregate.mockResolvedValue({
+      took: 1,
+      timed_out: false,
+      _shards: { total: 1, successful: 1, skipped: 0, failed: 0 },
+      hits: { total: { value: 2, relation: 'eq' }, max_score: null, hits: [] },
+      aggregations: {},
+    });
+    mockActionsConfig.getMaxQueued.mockReturnValueOnce(3);
+    const executeFn = createBulkExecutionEnqueuerFunction({
+      taskManager: mockTaskManager,
+      actionTypeRegistry: actionTypeRegistryMock.create(),
+      isESOCanEncrypt: true,
+      inMemoryConnectors: [],
+      configurationUtilities: mockActionsConfig,
+      logger: mockLogger,
+    });
+    savedObjectsClient.bulkGet.mockResolvedValueOnce({
+      saved_objects: [
+        { id: '123', type: 'action', attributes: { actionTypeId: 'mock-action' }, references: [] },
+      ],
+    });
+    savedObjectsClient.bulkCreate.mockResolvedValueOnce({
+      saved_objects: [
+        { id: '234', type: 'action_task_params', attributes: { actionId: '123' }, references: [] },
+      ],
+    });
+    expect(
+      await executeFn(savedObjectsClient, [
+        {
+          id: '123',
+          params: { baz: false },
+          spaceId: 'default',
+          executionId: '123abc',
+          apiKey: null,
+          source: asHttpRequestExecutionSource(request),
+          actionTypeId: 'mock-action',
+          priority: TaskPriority.Low,
+        },
+        {
+          id: '123',
+          params: { baz: false },
+          spaceId: 'default',
+          executionId: '456xyz',
+          apiKey: null,
+          source: asHttpRequestExecutionSource(request),
+          actionTypeId: 'mock-action',
+        },
+      ])
+    ).toMatchInlineSnapshot(`
+      Object {
+        "errors": true,
+        "items": Array [
+          Object {
+            "actionTypeId": "mock-action",
+            "id": "123",
+            "response": "success",
+            "uuid": undefined,
+          },
+          Object {
+            "actionTypeId": "mock-action",
+            "id": "123",
+            "response": "queuedActionsLimitError",
+            "uuid": undefined,
+          },
+        ],
+      }
+    `);
+    expect(mockTaskManager.bulkSchedule).toHaveBeenCalledTimes(1);
+    expect(mockTaskManager.bulkSchedule.mock.calls[0]).toMatchInlineSnapshot(`
+      Array [
+        Array [
+          Object {
+            "params": Object {
+              "actionTaskParamsId": "234",
+              "spaceId": "default",
+            },
+            "priority": 1,
+            "scope": Array [
+              "actions",
+            ],
+            "state": Object {},
+            "taskType": "actions:mock-action",
+          },
+        ],
+      ]
+    `);
+  });
+
+  test('uses apiKeyId if specified', async () => {
+    mockTaskManager.aggregate.mockResolvedValue({
+      took: 1,
+      timed_out: false,
+      _shards: { total: 1, successful: 1, skipped: 0, failed: 0 },
+      hits: { total: { value: 2, relation: 'eq' }, max_score: null, hits: [] },
+      aggregations: {},
+    });
+    mockActionsConfig.getMaxQueued.mockReturnValueOnce(3);
+    const executeFn = createBulkExecutionEnqueuerFunction({
+      taskManager: mockTaskManager,
+      actionTypeRegistry: actionTypeRegistryMock.create(),
+      isESOCanEncrypt: true,
+      inMemoryConnectors: [],
+      configurationUtilities: mockActionsConfig,
+      logger: mockLogger,
+    });
+    savedObjectsClient.bulkGet.mockResolvedValueOnce({
+      saved_objects: [
+        { id: '123', type: 'action', attributes: { actionTypeId: 'mock-action' }, references: [] },
+      ],
+    });
+    savedObjectsClient.bulkCreate.mockResolvedValueOnce({
+      saved_objects: [
+        { id: '234', type: 'action_task_params', attributes: { actionId: '123' }, references: [] },
+      ],
+    });
+    expect(
+      await executeFn(savedObjectsClient, [
+        {
+          id: '123',
+          params: { baz: false },
+          spaceId: 'default',
+          executionId: '123abc',
+          apiKey: null,
+          source: asHttpRequestExecutionSource(request),
+          actionTypeId: 'mock-action',
+          apiKeyId: '235qgbdbqet',
+        },
+        {
+          id: '123',
+          params: { baz: false },
+          spaceId: 'default',
+          executionId: '456xyz',
+          apiKey: null,
+          source: asHttpRequestExecutionSource(request),
+          actionTypeId: 'mock-action',
+          apiKeyId: '235qgbdbqet',
+        },
+      ])
+    ).toMatchInlineSnapshot(`
+      Object {
+        "errors": true,
+        "items": Array [
+          Object {
+            "actionTypeId": "mock-action",
+            "id": "123",
+            "response": "success",
+            "uuid": undefined,
+          },
+          Object {
+            "actionTypeId": "mock-action",
+            "id": "123",
+            "response": "queuedActionsLimitError",
+            "uuid": undefined,
+          },
+        ],
+      }
+    `);
+
+    expect(savedObjectsClient.bulkCreate).toHaveBeenCalledWith(
+      [
+        {
+          attributes: {
+            actionId: '123',
+            apiKey: null,
+            apiKeyId: '235qgbdbqet',
+            consumer: undefined,
+            executionId: '123abc',
+            params: {
+              baz: false,
+            },
+            relatedSavedObjects: undefined,
+            source: 'HTTP_REQUEST',
+          },
+          references: [
+            {
+              id: '123',
+              name: 'actionRef',
+              type: 'action',
+            },
+          ],
+          type: 'action_task_params',
+        },
+      ],
+      { refresh: false }
+    );
+    expect(mockTaskManager.bulkSchedule).toHaveBeenCalledTimes(1);
+    expect(mockTaskManager.bulkSchedule.mock.calls[0]).toMatchInlineSnapshot(`
+      Array [
+        Array [
+          Object {
+            "params": Object {
+              "actionTaskParamsId": "234",
+              "spaceId": "default",
+            },
+            "scope": Array [
+              "actions",
+            ],
+            "state": Object {},
+            "taskType": "actions:mock-action",
+          },
+        ],
+      ]
+    `);
+  });
 });

x-pack/platform/plugins/shared/actions/server/create_execute_function.ts

@@ -6,7 +6,7 @@
  */
 
 import { SavedObjectsBulkResponse, SavedObjectsClientContract, Logger } from '@kbn/core/server';
-import { TaskManagerStartContract } from '@kbn/task-manager-plugin/server';
+import { TaskPriority, TaskManagerStartContract } from '@kbn/task-manager-plugin/server';
 import { RawAction, ActionTypeRegistryContract, InMemoryConnector } from './types';
 import { ACTION_TASK_PARAMS_SAVED_OBJECT_TYPE } from './constants/saved_objects';
 import { ExecuteOptions as ActionExecutorOptions } from './lib/action_executor';
@@ -28,9 +28,11 @@ export interface ExecuteOptions
   id: string;
   uuid?: string;
   spaceId: string;
+  apiKeyId?: string;
   apiKey: string | null;
   executionId: string;
   actionTypeId: string;
+  priority?: TaskPriority;
 }
 
 interface ActionTaskParams
@@ -166,15 +168,17 @@ export function createBulkExecutionEnqueuerFunction({
           executionId: actionToExecute.executionId,
           consumer: actionToExecute.consumer,
           relatedSavedObjects: relatedSavedObjectWithRefs,
+          apiKeyId: actionToExecute.apiKeyId,
           ...(actionToExecute.source ? { source: actionToExecute.source.type } : {}),
         },
         references: taskReferences,
       };
     });
+
     const actionTaskParamsRecords: SavedObjectsBulkResponse<ActionTaskParams> =
       await unsecuredSavedObjectsClient.bulkCreate(actions, { refresh: false });
 
-    const taskInstances = actionTaskParamsRecords.saved_objects.map((so) => {
+    const taskInstances = actionTaskParamsRecords.saved_objects.map((so, index) => {
       const actionId = so.attributes.actionId;
       return {
         taskType: `actions:${actionTypeIds[actionId]}`,
@@ -184,6 +188,7 @@ export function createBulkExecutionEnqueuerFunction({
         },
         state: {},
         scope: ['actions'],
+        ...(runnableActions[index]?.priority ? { priority: runnableActions[index].priority } : {}),
       };
     });
 

x-pack/platform/plugins/shared/alerting/server/application/backfill/methods/delete/delete_backfill.test.ts

@@ -85,8 +85,8 @@ const mockAdHocRunSO: SavedObject<AdHocRunSO> = {
       name: fakeRuleName,
       tags: ['foo'],
       alertTypeId: 'myType',
-      // @ts-expect-error
       params: {},
+      actions: [],
       apiKeyOwner: 'user',
       apiKeyCreatedByUser: false,
       consumer: 'myApp',