Create alerting plugin

src/legacy/server/saved_objects/service/saved_objects_client.ts

@@ -99,7 +99,14 @@ export interface MigrationVersion {
 }
 
 export interface SavedObjectAttributes {
-  [key: string]: SavedObjectAttributes | string | number | boolean | null;
+  [key: string]:
+    | SavedObjectAttributes
+    | SavedObjectAttributes[]
+    | string
+    | number
+    | boolean
+    | null
+    | undefined;
 }
 
 export interface VisualizationAttributes extends SavedObjectAttributes {

x-pack/index.js

@@ -42,6 +42,7 @@ import { ossTelemetry } from './plugins/oss_telemetry';
 import { encryptedSavedObjects } from './plugins/encrypted_saved_objects';
 import { snapshotRestore } from './plugins/snapshot_restore';
 import { actions } from './plugins/actions';
+import { alerting } from './plugins/alerting';
 
 module.exports = function (kibana) {
   return [
@@ -83,5 +84,6 @@ module.exports = function (kibana) {
     encryptedSavedObjects(kibana),
     snapshotRestore(kibana),
     actions(kibana),
+    alerting(kibana),
   ];
 };

x-pack/plugins/actions/common/constants.ts

@@ -0,0 +1,7 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+export const TASK_MANAGER_SCOPE = 'actions';

x-pack/plugins/actions/index.ts

@@ -8,13 +8,20 @@ import { Root } from 'joi';
 import mappings from './mappings.json';
 import { init } from './server';
 
-export { ActionsPlugin, ActionsClient } from './server';
+export { ActionsPlugin, ActionsClient, ActionTypeExecutorOptions } from './server';
 
 export function actions(kibana: any) {
   return new kibana.Plugin({
     id: 'actions',
     configPrefix: 'xpack.actions',
-    require: ['kibana', 'elasticsearch', 'encrypted_saved_objects'],
+    require: ['kibana', 'elasticsearch', 'task_manager', 'encrypted_saved_objects'],
+    isEnabled(config: any) {
+      return (
+        config.get('xpack.encrypted_saved_objects.enabled') === true &&
+        config.get('xpack.actions.enabled') === true &&
+        config.get('xpack.task_manager.enabled') === true
+      );
+    },
     config(Joi: Root) {
       return Joi.object()
         .keys({

x-pack/plugins/actions/server/__jest__/action_type_registry.test.ts

@@ -4,26 +4,66 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import Joi from 'joi';
+jest.mock('../get_create_task_runner_function', () => ({
+  getCreateTaskRunnerFunction: jest.fn(),
+}));
+
+import { taskManagerMock } from '../../../task_manager/task_manager.mock';
+import { encryptedSavedObjectsMock } from '../../../encrypted_saved_objects/server/plugin.mock';
 import { ActionTypeRegistry } from '../action_type_registry';
+import { SavedObjectsClientMock } from '../../../../../src/legacy/server/saved_objects/service/saved_objects_client.mock';
+
+const mockTaskManager = taskManagerMock.create();
 
 const services = {
   log: jest.fn(),
+  callCluster: jest.fn(),
+  savedObjectsClient: SavedObjectsClientMock.create(),
 };
 const actionTypeRegistryParams = {
   services,
+  taskManager: mockTaskManager,
+  encryptedSavedObjectsPlugin: encryptedSavedObjectsMock.create(),
 };
 
+beforeEach(() => jest.resetAllMocks());
+
 describe('register()', () => {
   test('able to register action types', () => {
     const executor = jest.fn();
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { getCreateTaskRunnerFunction } = require('../get_create_task_runner_function');
+    getCreateTaskRunnerFunction.mockReturnValueOnce(jest.fn());
     const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
     actionTypeRegistry.register({
       id: 'my-action-type',
       name: 'My action type',
       executor,
     });
     expect(actionTypeRegistry.has('my-action-type')).toEqual(true);
+    expect(mockTaskManager.registerTaskDefinitions).toHaveBeenCalledTimes(1);
+    expect(mockTaskManager.registerTaskDefinitions.mock.calls[0]).toMatchInlineSnapshot(`
+Array [
+  Object {
+    "actions:my-action-type": Object {
+      "createTaskRunner": [MockFunction],
+      "title": "My action type",
+      "type": "actions:my-action-type",
+    },
+  },
+]
+`);
+    expect(getCreateTaskRunnerFunction).toHaveBeenCalledTimes(1);
+    const call = getCreateTaskRunnerFunction.mock.calls[0][0];
+    expect(call.actionType).toMatchInlineSnapshot(`
+Object {
+  "executor": [MockFunction],
+  "id": "my-action-type",
+  "name": "My action type",
+}
+`);
+    expect(call.encryptedSavedObjectsPlugin).toBeTruthy();
+    expect(call.services).toBeTruthy();
   });
 
   test('throws error if action type already registered', () => {
@@ -115,106 +155,6 @@ describe('list()', () => {
   });
 });
 
-describe('validateParams()', () => {
-  test('should pass when validation not defined', () => {
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      async executor() {},
-    });
-    actionTypeRegistry.validateParams('my-action-type', {});
-  });
-
-  test('should validate and pass when params is valid', () => {
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      validate: {
-        params: Joi.object()
-          .keys({
-            param1: Joi.string().required(),
-          })
-          .required(),
-      },
-      async executor() {},
-    });
-    actionTypeRegistry.validateParams('my-action-type', { param1: 'value' });
-  });
-
-  test('should validate and throw error when params is invalid', () => {
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      validate: {
-        params: Joi.object()
-          .keys({
-            param1: Joi.string().required(),
-          })
-          .required(),
-      },
-      async executor() {},
-    });
-    expect(() =>
-      actionTypeRegistry.validateParams('my-action-type', {})
-    ).toThrowErrorMatchingInlineSnapshot(
-      `"child \\"param1\\" fails because [\\"param1\\" is required]"`
-    );
-  });
-});
-
-describe('validateActionTypeConfig()', () => {
-  test('should pass when validation not defined', () => {
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      async executor() {},
-    });
-    actionTypeRegistry.validateActionTypeConfig('my-action-type', {});
-  });
-
-  test('should validate and pass when actionTypeConfig is valid', () => {
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      validate: {
-        actionTypeConfig: Joi.object()
-          .keys({
-            param1: Joi.string().required(),
-          })
-          .required(),
-      },
-      async executor() {},
-    });
-    actionTypeRegistry.validateActionTypeConfig('my-action-type', { param1: 'value' });
-  });
-
-  test('should validate and throw error when actionTypeConfig is invalid', () => {
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      validate: {
-        actionTypeConfig: Joi.object()
-          .keys({
-            param1: Joi.string().required(),
-          })
-          .required(),
-      },
-      async executor() {},
-    });
-    expect(() =>
-      actionTypeRegistry.validateActionTypeConfig('my-action-type', {})
-    ).toThrowErrorMatchingInlineSnapshot(
-      `"child \\"param1\\" fails because [\\"param1\\" is required]"`
-    );
-  });
-});
-
 describe('has()', () => {
   test('returns false for unregistered action types', () => {
     const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
@@ -232,110 +172,3 @@ describe('has()', () => {
     expect(actionTypeRegistry.has('my-action-type'));
   });
 });
-
-describe('execute()', () => {
-  test('calls the executor with proper params', async () => {
-    const executor = jest.fn().mockResolvedValueOnce({ success: true });
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      executor,
-    });
-    await actionTypeRegistry.execute({
-      id: 'my-action-type',
-      actionTypeConfig: { foo: true },
-      params: { bar: false },
-    });
-    expect(executor).toMatchInlineSnapshot(`
-[MockFunction] {
-  "calls": Array [
-    Array [
-      Object {
-        "actionTypeConfig": Object {
-          "foo": true,
-        },
-        "params": Object {
-          "bar": false,
-        },
-        "services": Object {
-          "log": [MockFunction],
-        },
-      },
-    ],
-  ],
-  "results": Array [
-    Object {
-      "type": "return",
-      "value": Promise {},
-    },
-  ],
-}
-`);
-  });
-
-  test('validates params', async () => {
-    const executor = jest.fn().mockResolvedValueOnce({ success: true });
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      executor,
-      validate: {
-        params: Joi.object()
-          .keys({
-            param1: Joi.string().required(),
-          })
-          .required(),
-      },
-    });
-    await expect(
-      actionTypeRegistry.execute({
-        id: 'my-action-type',
-        actionTypeConfig: {},
-        params: {},
-      })
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"child \\"param1\\" fails because [\\"param1\\" is required]"`
-    );
-  });
-
-  test('validates actionTypeConfig', async () => {
-    const executor = jest.fn().mockResolvedValueOnce({ success: true });
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    actionTypeRegistry.register({
-      id: 'my-action-type',
-      name: 'My action type',
-      executor,
-      validate: {
-        actionTypeConfig: Joi.object()
-          .keys({
-            param1: Joi.string().required(),
-          })
-          .required(),
-      },
-    });
-    await expect(
-      actionTypeRegistry.execute({
-        id: 'my-action-type',
-        actionTypeConfig: {},
-        params: {},
-      })
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"child \\"param1\\" fails because [\\"param1\\" is required]"`
-    );
-  });
-
-  test('throws error if action type not registered', async () => {
-    const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
-    await expect(
-      actionTypeRegistry.execute({
-        id: 'my-action-type',
-        actionTypeConfig: { foo: true },
-        params: { bar: false },
-      })
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"Action type \\"my-action-type\\" is not registered."`
-    );
-  });
-});