[RAM] 142183 create bulk delete on rules

x-pack/plugins/alerting/server/authorization/alerting_authorization.ts

@@ -51,6 +51,7 @@ export enum WriteOperations {
   UnmuteAlert = 'unmuteAlert',
   Snooze = 'snooze',
   BulkEdit = 'bulkEdit',
+  BulkDelete = 'bulkDelete',
   Unsnooze = 'unsnooze',
 }
 

x-pack/plugins/alerting/server/routes/bulk_delete_rules.test.ts

@@ -0,0 +1,126 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { httpServiceMock } from '@kbn/core/server/mocks';
+
+import { bulkDeleteRulesRoute } from './bulk_delete_rules';
+import { licenseStateMock } from '../lib/license_state.mock';
+import { mockHandlerArguments } from './_mock_handler_arguments';
+import { rulesClientMock } from '../rules_client.mock';
+import { RuleTypeDisabledError } from '../lib/errors/rule_type_disabled';
+import { verifyApiAccess } from '../lib/license_api_access';
+
+const rulesClient = rulesClientMock.create();
+
+jest.mock('../lib/license_api_access', () => ({
+  verifyApiAccess: jest.fn(),
+}));
+
+beforeEach(() => {
+  jest.resetAllMocks();
+});
+
+describe('bulkDeleteRulesRoute', () => {
+  const bulkDeleteRequest = { filter: '' };
+  const bulkDeleteResult = { errors: [], total: 1, taskIdsFailedToBeDeleted: [] };
+
+  it('should delete rules with proper parameters', async () => {
+    const licenseState = licenseStateMock.create();
+    const router = httpServiceMock.createRouter();
+
+    bulkDeleteRulesRoute({ router, licenseState });
+
+    const [config, handler] = router.patch.mock.calls[0];
+
+    expect(config.path).toBe('/internal/alerting/rules/_bulk_delete');
+
+    rulesClient.bulkDeleteRules.mockResolvedValueOnce(bulkDeleteResult);
+
+    const [context, req, res] = mockHandlerArguments(
+      { rulesClient },
+      {
+        body: bulkDeleteRequest,
+      },
+      ['ok']
+    );
+
+    expect(await handler(context, req, res)).toEqual({
+      body: bulkDeleteResult,
+    });
+
+    expect(rulesClient.bulkDeleteRules).toHaveBeenCalledTimes(1);
+    expect(rulesClient.bulkDeleteRules.mock.calls[0]).toEqual([bulkDeleteRequest]);
+
+    expect(res.ok).toHaveBeenCalled();
+  });
+
+  it('ensures the license allows bulk deleting rules', async () => {
+    const licenseState = licenseStateMock.create();
+    const router = httpServiceMock.createRouter();
+
+    rulesClient.bulkDeleteRules.mockResolvedValueOnce(bulkDeleteResult);
+
+    bulkDeleteRulesRoute({ router, licenseState });
+
+    const [, handler] = router.patch.mock.calls[0];
+
+    const [context, req, res] = mockHandlerArguments(
+      { rulesClient },
+      {
+        body: bulkDeleteRequest,
+      }
+    );
+
+    await handler(context, req, res);
+
+    expect(verifyApiAccess).toHaveBeenCalledWith(licenseState);
+  });
+
+  it('ensures the license check prevents bulk deleting rules', async () => {
+    const licenseState = licenseStateMock.create();
+    const router = httpServiceMock.createRouter();
+
+    (verifyApiAccess as jest.Mock).mockImplementation(() => {
+      throw new Error('Failure');
+    });
+
+    bulkDeleteRulesRoute({ router, licenseState });
+
+    const [, handler] = router.patch.mock.calls[0];
+
+    const [context, req, res] = mockHandlerArguments(
+      { rulesClient },
+      {
+        body: bulkDeleteRequest,
+      }
+    );
+
+    expect(handler(context, req, res)).rejects.toMatchInlineSnapshot(`[Error: Failure]`);
+  });
+
+  it('ensures the rule type gets validated for the license', async () => {
+    const licenseState = licenseStateMock.create();
+    const router = httpServiceMock.createRouter();
+
+    bulkDeleteRulesRoute({ router, licenseState });
+
+    const [, handler] = router.patch.mock.calls[0];
+
+    rulesClient.bulkDeleteRules.mockRejectedValue(
+      new RuleTypeDisabledError('Fail', 'license_invalid')
+    );
+
+    const [context, req, res] = mockHandlerArguments({ rulesClient }, { params: {}, body: {} }, [
+      'ok',
+      'forbidden',
+    ]);
+
+    await handler(context, req, res);
+
+    expect(res.forbidden).toHaveBeenCalledWith({ body: { message: 'Fail' } });
+  });
+});

x-pack/plugins/alerting/server/routes/bulk_delete_rules.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { schema } from '@kbn/config-schema';
+import { IRouter } from '@kbn/core/server';
+import { verifyAccessAndContext, handleDisabledApiKeysError } from './lib';
+import { ILicenseState, RuleTypeDisabledError } from '../lib';
+import { AlertingRequestHandlerContext, INTERNAL_BASE_ALERTING_API_PATH } from '../types';
+
+export const bulkDeleteRulesRoute = ({
+  router,
+  licenseState,
+}: {
+  router: IRouter<AlertingRequestHandlerContext>;
+  licenseState: ILicenseState;
+}) => {
+  router.patch(
+    {
+      path: `${INTERNAL_BASE_ALERTING_API_PATH}/rules/_bulk_delete`,
+      validate: {
+        body: schema.object({
+          filter: schema.maybe(schema.string()),
+          ids: schema.maybe(schema.arrayOf(schema.string(), { minSize: 1, maxSize: 1000 })),
+        }),
+      },
+    },
+    handleDisabledApiKeysError(
+      router.handleLegacyErrors(
+        verifyAccessAndContext(licenseState, async (context, req, res) => {
+          const rulesClient = (await context.alerting).getRulesClient();
+          const { filter, ids } = req.body;
+
+          try {
+            const result = await rulesClient.bulkDeleteRules({ filter, ids });
+            return res.ok({ body: result });
+          } catch (e) {
+            if (e instanceof RuleTypeDisabledError) {
+              return e.sendResponse(res);
+            }
+            throw e;
+          }
+        })
+      )
+    )
+  );
+};

x-pack/plugins/alerting/server/routes/index.ts

@@ -38,6 +38,7 @@ import { bulkEditInternalRulesRoute } from './bulk_edit_rules';
 import { snoozeRuleRoute } from './snooze_rule';
 import { unsnoozeRuleRoute } from './unsnooze_rule';
 import { runSoonRoute } from './run_soon';
+import { bulkDeleteRulesRoute } from './bulk_delete_rules';
 
 export interface RouteOptions {
   router: IRouter<AlertingRequestHandlerContext>;
@@ -76,6 +77,7 @@ export function defineRoutes(opts: RouteOptions) {
   unmuteAlertRoute(router, licenseState);
   updateRuleApiKeyRoute(router, licenseState);
   bulkEditInternalRulesRoute(router, licenseState);
+  bulkDeleteRulesRoute({ router, licenseState });
   snoozeRuleRoute(router, licenseState);
   unsnoozeRuleRoute(router, licenseState);
   runSoonRoute(router, licenseState);

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

@@ -36,6 +36,7 @@ const createRulesClientMock = () => {
     getActionErrorLog: jest.fn(),
     getSpaceId: jest.fn(),
     bulkEdit: jest.fn(),
+    bulkDeleteRules: jest.fn(),
     snooze: jest.fn(),
     unsnooze: jest.fn(),
     calculateIsSnoozedUntil: jest.fn(),

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

@@ -8,5 +8,6 @@
 export { mapSortField } from './map_sort_field';
 export { validateOperationOnAttributes } from './validate_attributes';
 export { retryIfBulkEditConflicts } from './retry_if_bulk_edit_conflicts';
+export { retryIfBulkDeleteConflicts } from './retry_if_bulk_delete_conflicts';
 export { applyBulkEditOperation } from './apply_bulk_edit_operation';
 export { buildKueryNodeFilter } from './build_kuery_node_filter';

x-pack/plugins/alerting/server/rules_client/lib/retry_if_bulk_delete_conflicts.test.ts

@@ -0,0 +1,100 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { KueryNode } from '@kbn/es-query';
+import { loggingSystemMock } from '@kbn/core/server/mocks';
+
+import { retryIfBulkDeleteConflicts } from './retry_if_bulk_delete_conflicts';
+import { RETRY_IF_CONFLICTS_ATTEMPTS } from './wait_before_next_retry';
+
+const mockFilter: KueryNode = {
+  type: 'function',
+  value: 'mock',
+};
+
+const mockLogger = loggingSystemMock.create().get();
+
+const mockSuccessfulResult = {
+  apiKeysToInvalidate: ['apiKey1'],
+  errors: [],
+  taskIdsToDelete: ['taskId1'],
+};
+
+const error409 = {
+  message: 'some fake message',
+  status: 409,
+  rule: {
+    id: 'fake_rule_id',
+    name: 'fake rule name',
+  },
+};
+
+const getOperationConflictsTimes = (times: number) => {
+  return async () => {
+    conflictOperationMock();
+    times--;
+    if (times >= 0) {
+      return {
+        apiKeysToInvalidate: [],
+        taskIdsToDelete: [],
+        errors: [error409],
+      };
+    }
+    return mockSuccessfulResult;
+  };
+};
+
+const OperationSuccessful = async () => mockSuccessfulResult;
+const conflictOperationMock = jest.fn();
+
+describe('retryIfBulkDeleteConflicts', () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  test('should work when operation is successful', async () => {
+    const result = await retryIfBulkDeleteConflicts(mockLogger, OperationSuccessful, mockFilter);
+
+    expect(result).toEqual(mockSuccessfulResult);
+  });
+
+  test('should throw error when operation fails', async () => {
+    await expect(
+      retryIfBulkDeleteConflicts(
+        mockLogger,
+        async () => {
+          throw Error('Test failure');
+        },
+        mockFilter
+      )
+    ).rejects.toThrowError('Test failure');
+  });
+
+  test(`should return conflict errors when number of retries exceeds ${RETRY_IF_CONFLICTS_ATTEMPTS}`, async () => {
+    const result = await retryIfBulkDeleteConflicts(
+      mockLogger,
+      getOperationConflictsTimes(RETRY_IF_CONFLICTS_ATTEMPTS + 1),
+      mockFilter
+    );
+
+    expect(result.errors).toEqual([error409]);
+    expect(mockLogger.warn).toBeCalledWith('Bulk delete rules conflicts, exceeded retries');
+  });
+
+  for (let i = 1; i <= RETRY_IF_CONFLICTS_ATTEMPTS; i++) {
+    test(`should work when operation conflicts ${i} times`, async () => {
+      const result = await retryIfBulkDeleteConflicts(
+        mockLogger,
+        getOperationConflictsTimes(i),
+        mockFilter
+      );
+
+      expect(conflictOperationMock.mock.calls.length).toBe(i + 1);
+      expect(result).toStrictEqual(mockSuccessfulResult);
+    });
+  }
+});