[Ingest Manager] Ingest setup upgrade

x-pack/plugins/ingest_manager/common/types/rest_spec/epm.ts

@@ -74,7 +74,7 @@ export interface InstallPackageResponse {
 export interface IBulkInstallPackageError {
   name: string;
   statusCode: number;
-  error: string | Error;
+  error: string;
 }
 
 export interface BulkInstallPackageInfo {

x-pack/plugins/ingest_manager/server/errors/handlers.test.ts

@@ -14,6 +14,7 @@ import {
   RegistryError,
   PackageNotFoundError,
   defaultIngestErrorHandler,
+  BulkInstallPackagesError,
 } from './index';
 
 const LegacyESErrors = errors as Record<string, any>;
@@ -120,6 +121,44 @@ describe('defaultIngestErrorHandler', () => {
       expect(mockContract.logger?.error).toHaveBeenCalledWith(error.message);
     });
 
+    it('500: BulkInstallPackagesError', async () => {
+      const error = new BulkInstallPackagesError(500, '123');
+      const response = httpServerMock.createResponseFactory();
+
+      await defaultIngestErrorHandler({ error, response });
+
+      // response
+      expect(response.ok).toHaveBeenCalledTimes(0);
+      expect(response.customError).toHaveBeenCalledTimes(1);
+      expect(response.customError).toHaveBeenCalledWith({
+        statusCode: 500,
+        body: { message: error.message },
+      });
+
+      // logging
+      expect(mockContract.logger?.error).toHaveBeenCalledTimes(1);
+      expect(mockContract.logger?.error).toHaveBeenCalledWith(error.message);
+    });
+
+    it('400: BulkInstallPackagesError', async () => {
+      const error = new BulkInstallPackagesError(400, '123');
+      const response = httpServerMock.createResponseFactory();
+
+      await defaultIngestErrorHandler({ error, response });
+
+      // response
+      expect(response.ok).toHaveBeenCalledTimes(0);
+      expect(response.customError).toHaveBeenCalledTimes(1);
+      expect(response.customError).toHaveBeenCalledWith({
+        statusCode: 400,
+        body: { message: error.message },
+      });
+
+      // logging
+      expect(mockContract.logger?.error).toHaveBeenCalledTimes(1);
+      expect(mockContract.logger?.error).toHaveBeenCalledWith(error.message);
+    });
+
     it('400: IngestManagerError', async () => {
       const error = new IngestManagerError('123');
       const response = httpServerMock.createResponseFactory();

x-pack/plugins/ingest_manager/server/errors/handlers.ts

@@ -13,7 +13,12 @@ import {
 } from 'src/core/server';
 import { errors as LegacyESErrors } from 'elasticsearch';
 import { appContextService } from '../services';
-import { IngestManagerError, RegistryError, PackageNotFoundError } from './index';
+import {
+  IngestManagerError,
+  RegistryError,
+  PackageNotFoundError,
+  BulkInstallPackagesError,
+} from './index';
 
 type IngestErrorHandler = (
   params: IngestErrorHandlerParams
@@ -52,6 +57,9 @@ const getHTTPResponseCode = (error: IngestManagerError): number => {
   if (error instanceof PackageNotFoundError) {
     return 404; // Not Found
   }
+  if (error instanceof BulkInstallPackagesError) {
+    return error.statusCode;
+  }
 
   return 400; // Bad Request
 };

x-pack/plugins/ingest_manager/server/errors/index.ts

@@ -18,3 +18,9 @@ export class RegistryConnectionError extends RegistryError {}
 export class RegistryResponseError extends RegistryError {}
 export class PackageNotFoundError extends IngestManagerError {}
 export class PackageOutdatedError extends IngestManagerError {}
+
+export class BulkInstallPackagesError extends IngestManagerError {
+  constructor(public readonly statusCode: number, message?: string) {
+    super(message);
+  }
+}

x-pack/plugins/ingest_manager/server/services/epm/packages/install.test.ts

@@ -6,7 +6,32 @@
 
 import { ElasticsearchAssetType, Installation, KibanaAssetType } from '../../../types';
 import { SavedObject } from 'src/core/server';
-import { getInstallType } from './install';
+jest.mock('./install', () => ({
+  ...(jest.requireActual('./install') as {}),
+  bulkInstallPackages: jest.fn(async () => {
+    return [
+      {
+        name: 'blah',
+        assets: [],
+        newVersion: '',
+        oldVersion: '',
+        statusCode: 200,
+      },
+    ];
+  }),
+}));
+
+jest.mock('./get', () => ({
+  ...(jest.requireActual('./get') as {}),
+  getInstallation: jest.fn(async () => {
+    return mockInstallation.attributes;
+  }),
+}));
+import { getInstallType, ensureInstalledDefaultPackages } from './install';
+
+import { savedObjectsClientMock } from 'src/core/server/mocks';
+import { appContextService } from '../../app_context';
+import { createAppContextStartContractMock } from '../../../mocks';
 
 const mockInstallation: SavedObject<Installation> = {
   id: 'test-pkg',
@@ -41,6 +66,19 @@ const mockInstallationUpdateFail: SavedObject<Installation> = {
   },
 };
 describe('install', () => {
+  describe('ensureInstalledDefaultPackages', () => {
+    beforeEach(async () => {
+      appContextService.start(createAppContextStartContractMock());
+    });
+    afterEach(async () => {
+      appContextService.stop();
+    });
+    it('should return an array of Installation objects when successful', async () => {
+      const soClient = savedObjectsClientMock.create();
+      const resp = await ensureInstalledDefaultPackages(soClient, jest.fn());
+      expect(resp).toEqual([mockInstallation.attributes]);
+    });
+  });
   describe('getInstallType', () => {
     it('should return correct type when installing and no other version is currently installed', () => {
       const installTypeInstall = getInstallType({ pkgVersion: '1.0.0', installedPkg: undefined });

x-pack/plugins/ingest_manager/server/services/epm/packages/install.ts

@@ -40,6 +40,7 @@ import {
   IngestManagerError,
   PackageOutdatedError,
   ingestErrorToResponseOptions,
+  BulkInstallPackagesError,
 } from '../../../errors';
 import { getPackageSavedObjects } from './get';
 import { installTransformForDataset } from '../elasticsearch/transform/install';
@@ -63,22 +64,36 @@ export async function installLatestPackage(options: {
   }
 }
 
+function isBulkInstallError(resp: BulkInstallResponse): resp is IBulkInstallPackageError {
+  return 'error' in resp && resp.error !== undefined;
+}
+
 export async function ensureInstalledDefaultPackages(
   savedObjectsClient: SavedObjectsClientContract,
   callCluster: CallESAsCurrentUser
 ): Promise<Installation[]> {
   const installations = [];
-  for (const pkgName in DefaultPackages) {
-    if (!DefaultPackages.hasOwnProperty(pkgName)) continue;
-    const installation = ensureInstalledPackage({
-      savedObjectsClient,
-      pkgName,
-      callCluster,
-    });
-    installations.push(installation);
+  const bulkResponse = await bulkInstallPackages({
+    savedObjectsClient,
+    packagesToUpgrade: Object.values(DefaultPackages),
+    callCluster,
+  });
+
+  for (const resp of bulkResponse) {
+    if (isBulkInstallError(resp)) {
+      throw new BulkInstallPackagesError(resp.statusCode, resp.error);
+    } else {
+      installations.push(getInstallation({ savedObjectsClient, pkgName: resp.name }));
+    }
   }
 
-  return Promise.all(installations);
+  const retrievedInstallations = await Promise.all(installations);
+  return retrievedInstallations.map((installation, index) => {
+    if (!installation) {
+      throw new Error(`could not get installation ${bulkResponse[index].name} during setup`);
+    }
+    return installation;
+  });
 }
 
 export async function ensureInstalledPackage(options: {

x-pack/test/ingest_manager_api_integration/apis/epm/index.js

@@ -7,6 +7,7 @@
 export default function loadTests({ loadTestFile }) {
   describe('EPM Endpoints', () => {
     loadTestFile(require.resolve('./list'));
+    loadTestFile(require.resolve('./setup'));
     loadTestFile(require.resolve('./get'));
     loadTestFile(require.resolve('./file'));
     //loadTestFile(require.resolve('./template'));

x-pack/test/ingest_manager_api_integration/apis/epm/setup.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 expect from '@kbn/expect';
+import { FtrProviderContext } from '../../../api_integration/ftr_provider_context';
+import { skipIfNoDockerRegistry } from '../../helpers';
+import { GetInfoResponse, Installed } from '../../../../plugins/ingest_manager/common';
+
+export default function (providerContext: FtrProviderContext) {
+  const { getService } = providerContext;
+  const supertest = getService('supertest');
+  const log = getService('log');
+
+  describe('setup api', async () => {
+    skipIfNoDockerRegistry(providerContext);
+    describe('setup performs upgrades', async () => {
+      const oldEndpointVersion = '0.13.0';
+      beforeEach(async () => {
+        await supertest
+          .post(`/api/ingest_manager/epm/packages/endpoint-${oldEndpointVersion}`)
+          .set('kbn-xsrf', 'xxxx')
+          .send({ force: true })
+          .expect(200);
+      });
+      it('upgrades the endpoint package from 0.13.0 to the latest version available', async function () {
+        let { body }: { body: GetInfoResponse } = await supertest
+          .get(`/api/ingest_manager/epm/packages/endpoint-${oldEndpointVersion}`)
+          .expect(200);
+        const latestEndpointVersion = body.response.latestVersion;
+        log.info(`Endpoint package latest version: ${latestEndpointVersion}`);
+        // make sure we're actually doing an upgrade
+        expect(latestEndpointVersion).not.eql(oldEndpointVersion);
+        await supertest.post(`/api/ingest_manager/setup`).set('kbn-xsrf', 'xxxx').expect(200);
+
+        ({ body } = await supertest
+          .get(`/api/ingest_manager/epm/packages/endpoint-${latestEndpointVersion}`)
+          .expect(200));
+        expect(body.response).to.have.property('savedObject');
+        expect((body.response as Installed).savedObject.attributes.install_version).to.eql(
+          latestEndpointVersion
+        );
+      });
+    });
+  });
+}