[Upgrade Assistant] Server-side batch reindexing

x-pack/plugins/upgrade_assistant/server/lib/es_version_precheck.ts

@@ -90,9 +90,9 @@ export const esVersionCheck = async (
   }
 };
 
-export const versionCheckHandlerWrapper = (handler: RequestHandler<any, any, any>) => async (
+export const versionCheckHandlerWrapper = <P, Q, B>(handler: RequestHandler<P, Q, B>) => async (
   ctx: RequestHandlerContext,
-  request: KibanaRequest,
+  request: KibanaRequest<P, Q, B>,
   response: KibanaResponseFactory
 ) => {
   const errorResponse = await esVersionCheck(ctx, response);

x-pack/plugins/upgrade_assistant/server/routes/reindex_indices/index.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 { createReindexWorker, registerReindexIndicesRoutes } from './reindex_indices';

x-pack/plugins/upgrade_assistant/server/routes/reindex_indices/reindex_handler.ts

@@ -0,0 +1,63 @@
+/*
+ * 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.
+ */
+
+import { IScopedClusterClient, Logger, SavedObjectsClientContract } from 'kibana/server';
+
+import { LicensingPluginSetup } from '../../../../licensing/server';
+
+import { ReindexStatus } from '../../../common/types';
+
+import { reindexActionsFactory } from '../../lib/reindexing/reindex_actions';
+import { reindexServiceFactory, ReindexWorker } from '../../lib/reindexing';
+import { CredentialStore } from '../../lib/reindexing/credential_store';
+
+export const SYMBOL_FORBIDDEN = Symbol('Forbidden');
+
+interface ReindexHandlerArgs {
+  savedObjects: SavedObjectsClientContract;
+  dataClient: IScopedClusterClient;
+  indexName: string;
+  log: Logger;
+  licensing: LicensingPluginSetup;
+  headers: Record<string, any>;
+  credentialStore: CredentialStore;
+  getWorker: () => ReindexWorker;
+}
+
+export const reindexHandler = async ({
+  credentialStore,
+  dataClient,
+  headers,
+  indexName,
+  licensing,
+  log,
+  savedObjects,
+  getWorker,
+}: ReindexHandlerArgs) => {
+  const callAsCurrentUser = dataClient.callAsCurrentUser.bind(dataClient);
+  const reindexActions = reindexActionsFactory(savedObjects, callAsCurrentUser);
+  const reindexService = reindexServiceFactory(callAsCurrentUser, reindexActions, log, licensing);
+
+  if (!(await reindexService.hasRequiredPrivileges(indexName))) {
+    throw SYMBOL_FORBIDDEN;
+  }
+
+  const existingOp = await reindexService.findReindexOperation(indexName);
+
+  // If the reindexOp already exists and it's paused, resume it. Otherwise create a new one.
+  const reindexOp =
+    existingOp && existingOp.attributes.status === ReindexStatus.paused
+      ? await reindexService.resumeReindexOperation(indexName)
+      : await reindexService.createReindexOperation(indexName);
+
+  // Add users credentials for the worker to use
+  credentialStore.set(reindexOp, headers);
+
+  // Kick the worker on this node to immediately pickup the new reindex operation.
+  getWorker().forceRefresh();
+
+  return reindexOp.attributes;
+};

x-pack/plugins/upgrade_assistant/server/routes/reindex_indices.test.ts → x-pack/plugins/upgrade_assistant/server/routes/reindex_indices/reindex_indices.test.ts

@@ -5,9 +5,9 @@
  */
 
 import { kibanaResponseFactory } from 'src/core/server';
-import { licensingMock } from '../../../licensing/server/mocks';
-import { createMockRouter, MockRouter, routeHandlerContextMock } from './__mocks__/routes.mock';
-import { createRequestMock } from './__mocks__/request.mock';
+import { licensingMock } from '../../../../licensing/server/mocks';
+import { createMockRouter, MockRouter, routeHandlerContextMock } from '../__mocks__/routes.mock';
+import { createRequestMock } from '../__mocks__/request.mock';
 
 const mockReindexService = {
   hasRequiredPrivileges: jest.fn(),
@@ -21,18 +21,23 @@ const mockReindexService = {
   cancelReindexing: jest.fn(),
 };
 
-jest.mock('../lib/es_version_precheck', () => ({
+jest.mock('../../lib/es_version_precheck', () => ({
   versionCheckHandlerWrapper: (a: any) => a,
 }));
 
-jest.mock('../lib/reindexing', () => {
+jest.mock('../../lib/reindexing', () => {
   return {
     reindexServiceFactory: () => mockReindexService,
   };
 });
 
-import { IndexGroup, ReindexSavedObject, ReindexStatus, ReindexWarning } from '../../common/types';
-import { credentialStoreFactory } from '../lib/reindexing/credential_store';
+import {
+  IndexGroup,
+  ReindexSavedObject,
+  ReindexStatus,
+  ReindexWarning,
+} from '../../../common/types';
+import { credentialStoreFactory } from '../../lib/reindexing/credential_store';
 import { registerReindexIndicesRoutes } from './reindex_indices';
 
 /**
@@ -76,7 +81,7 @@ describe('reindex API', () => {
   });
 
   afterEach(() => {
-    jest.resetAllMocks();
+    jest.clearAllMocks();
   });
 
   describe('GET /api/upgrade_assistant/reindex/{indexName}', () => {
@@ -255,6 +260,88 @@ describe('reindex API', () => {
     });
   });
 
+  describe('POST /api/upgrade_assistant/reindex/batch', () => {
+    it('creates a collection of index operations', async () => {
+      mockReindexService.createReindexOperation
+        .mockResolvedValueOnce({
+          attributes: { indexName: 'theIndex1' },
+        })
+        .mockResolvedValueOnce({
+          attributes: { indexName: 'theIndex2' },
+        })
+        .mockResolvedValueOnce({
+          attributes: { indexName: 'theIndex3' },
+        });
+
+      const resp = await routeDependencies.router.getHandler({
+        method: 'post',
+        pathPattern: '/api/upgrade_assistant/reindex/batch',
+      })(
+        routeHandlerContextMock,
+        createRequestMock({ body: { indexNames: ['theIndex1', 'theIndex2', 'theIndex3'] } }),
+        kibanaResponseFactory
+      );
+
+      // It called create correctly
+      expect(mockReindexService.createReindexOperation).toHaveBeenNthCalledWith(1, 'theIndex1');
+      expect(mockReindexService.createReindexOperation).toHaveBeenNthCalledWith(2, 'theIndex2');
+      expect(mockReindexService.createReindexOperation).toHaveBeenNthCalledWith(3, 'theIndex3');
+
+      // It returned the right results
+      expect(resp.status).toEqual(200);
+      const data = resp.payload;
+      expect(data).toEqual({
+        errors: [],
+        successes: [
+          { indexName: 'theIndex1' },
+          { indexName: 'theIndex2' },
+          { indexName: 'theIndex3' },
+        ],
+      });
+    });
+
+    it('gracefully handles partial successes', async () => {
+      mockReindexService.createReindexOperation
+        .mockResolvedValueOnce({
+          attributes: { indexName: 'theIndex1' },
+        })
+        .mockRejectedValueOnce(new Error('oops!'));
+
+      mockReindexService.hasRequiredPrivileges
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false)
+        .mockResolvedValueOnce(true);
+
+      const resp = await routeDependencies.router.getHandler({
+        method: 'post',
+        pathPattern: '/api/upgrade_assistant/reindex/batch',
+      })(
+        routeHandlerContextMock,
+        createRequestMock({ body: { indexNames: ['theIndex1', 'theIndex2', 'theIndex3'] } }),
+        kibanaResponseFactory
+      );
+
+      // It called create correctly
+      expect(mockReindexService.createReindexOperation).toHaveBeenCalledTimes(2);
+      expect(mockReindexService.createReindexOperation).toHaveBeenNthCalledWith(1, 'theIndex1');
+      expect(mockReindexService.createReindexOperation).toHaveBeenNthCalledWith(2, 'theIndex3');
+
+      // It returned the right results
+      expect(resp.status).toEqual(200);
+      const data = resp.payload;
+      expect(data).toEqual({
+        errors: [
+          {
+            indexName: 'theIndex2',
+            message: 'You do not have adequate privileges to reindex "theIndex2".',
+          },
+          { indexName: 'theIndex3', message: 'oops!' },
+        ],
+        successes: [{ indexName: 'theIndex1' }],
+      });
+    });
+  });
+
   describe('POST /api/upgrade_assistant/reindex/{indexName}/cancel', () => {
     it('returns a 501', async () => {
       mockReindexService.cancelReindexing.mockResolvedValueOnce({});