Ingest setup upgrade

x-pack/plugins/ingest_manager/server/routes/epm/handlers.ts

@@ -13,7 +13,9 @@ import {
   GetCategoriesResponse,
   GetPackagesResponse,
   GetLimitedPackagesResponse,
+  BulkInstallPackageInfo,
   BulkInstallPackagesResponse,
+  IBulkInstallPackageError,
 } from '../../../common';
 import {
   GetCategoriesRequestSchema,
@@ -26,21 +28,21 @@ import {
   BulkUpgradePackagesFromRegistryRequestSchema,
 } from '../../types';
 import {
+  BulkInstallResponse,
+  bulkInstallPackages,
   getCategories,
   getPackages,
   getFile,
   getPackageInfo,
+  handleInstallPackageFailure,
   installPackage,
+  isBulkInstallError,
   removeInstallation,
   getLimitedPackages,
   getInstallationObject,
 } from '../../services/epm/packages';
-import { defaultIngestErrorHandler } from '../../errors';
+import { defaultIngestErrorHandler, ingestErrorToResponseOptions } from '../../errors';
 import { splitPkgKey } from '../../services/epm/registry';
-import {
-  handleInstallPackageFailure,
-  bulkInstallPackages,
-} from '../../services/epm/packages/install';
 
 export const getCategoriesHandler: RequestHandler<
   undefined,
@@ -171,20 +173,36 @@ export const installPackageFromRegistryHandler: RequestHandler<
   }
 };
 
+const bulkInstallServiceResponseToHttpEntry = (
+  result: BulkInstallResponse
+): BulkInstallPackageInfo | IBulkInstallPackageError => {
+  if (isBulkInstallError(result)) {
+    const { statusCode, body } = ingestErrorToResponseOptions(result.error);
+    return {
+      name: result.name,
+      statusCode,
+      error: body.message,
+    };
+  } else {
+    return result;
+  }
+};
+
 export const bulkInstallPackagesFromRegistryHandler: RequestHandler<
   undefined,
   undefined,
   TypeOf<typeof BulkUpgradePackagesFromRegistryRequestSchema.body>
 > = async (context, request, response) => {
   const savedObjectsClient = context.core.savedObjects.client;
   const callCluster = context.core.elasticsearch.legacy.client.callAsCurrentUser;
-  const res = await bulkInstallPackages({
+  const bulkInstalledResponses = await bulkInstallPackages({
     savedObjectsClient,
     callCluster,
     packagesToUpgrade: request.body.packages,
   });
+  const payload = bulkInstalledResponses.map(bulkInstallServiceResponseToHttpEntry);
   const body: BulkInstallPackagesResponse = {
-    response: res,
+    response: payload,
   };
   return response.ok({ body });
 };

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

@@ -0,0 +1,61 @@
+/*
+ * 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 { SavedObjectsClientContract } from 'src/core/server';
+import { CallESAsCurrentUser } from '../../../types';
+import * as Registry from '../registry';
+import { getInstallationObject } from './index';
+import { BulkInstallResponse, IBulkInstallPackageError, upgradePackage } from './install';
+
+interface BulkInstallPackagesParams {
+  savedObjectsClient: SavedObjectsClientContract;
+  packagesToUpgrade: string[];
+  callCluster: CallESAsCurrentUser;
+}
+
+export async function bulkInstallPackages({
+  savedObjectsClient,
+  packagesToUpgrade,
+  callCluster,
+}: BulkInstallPackagesParams): Promise<BulkInstallResponse[]> {
+  const installedAndLatestPromises = packagesToUpgrade.map((pkgToUpgrade) =>
+    Promise.all([
+      getInstallationObject({ savedObjectsClient, pkgName: pkgToUpgrade }),
+      Registry.fetchFindLatestPackage(pkgToUpgrade),
+    ])
+  );
+  const installedAndLatestResults = await Promise.allSettled(installedAndLatestPromises);
+  const installResponsePromises = installedAndLatestResults.map(async (result, index) => {
+    const pkgToUpgrade = packagesToUpgrade[index];
+    if (result.status === 'fulfilled') {
+      const [installedPkg, latestPkg] = result.value;
+      return upgradePackage({
+        savedObjectsClient,
+        callCluster,
+        installedPkg,
+        latestPkg,
+        pkgToUpgrade,
+      });
+    } else {
+      return { name: pkgToUpgrade, error: result.reason };
+    }
+  });
+  const installResults = await Promise.allSettled(installResponsePromises);
+  const installResponses = installResults.map((result, index) => {
+    const pkgToUpgrade = packagesToUpgrade[index];
+    if (result.status === 'fulfilled') {
+      return result.value;
+    } else {
+      return { name: pkgToUpgrade, error: result.reason };
+    }
+  });
+
+  return installResponses;
+}
+
+export function isBulkInstallError(test: any): test is IBulkInstallPackageError {
+  return 'error' in test && test.error instanceof Error;
+}

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

@@ -0,0 +1,110 @@
+/*
+ * 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 { ElasticsearchAssetType, Installation, KibanaAssetType } from '../../../types';
+import { SavedObject } from 'src/core/server';
+
+jest.mock('./install');
+jest.mock('./bulk_install_packages');
+jest.mock('./get', () => ({
+  ...(jest.requireActual('./get') as {}),
+  getInstallation: jest.fn(async () => {
+    return mockInstallation.attributes;
+  }),
+}));
+import { bulkInstallPackages } from './bulk_install_packages';
+const { ensureInstalledDefaultPackages } = jest.requireActual('./install');
+import { savedObjectsClientMock } from 'src/core/server/mocks';
+import { appContextService } from '../../app_context';
+import { createAppContextStartContractMock } from '../../../mocks';
+
+// if we add this assertion, TS will type check the return value
+// and the editor will also know about .mockImplementation, .mock.calls, etc
+const mockedBulkInstallPackages = bulkInstallPackages as jest.MockedFunction<
+  typeof bulkInstallPackages
+>;
+
+const mockInstallation: SavedObject<Installation> = {
+  id: 'test-pkg',
+  references: [],
+  type: 'epm-packages',
+  attributes: {
+    id: 'test-pkg',
+    installed_kibana: [{ type: KibanaAssetType.dashboard, id: 'dashboard-1' }],
+    installed_es: [{ type: ElasticsearchAssetType.ingestPipeline, id: 'pipeline' }],
+    es_index_patterns: { pattern: 'pattern-name' },
+    name: 'test packagek',
+    version: '1.0.0',
+    install_status: 'installed',
+    install_version: '1.0.0',
+    install_started_at: new Date().toISOString(),
+  },
+};
+
+describe('ensureInstalledDefaultPackages', () => {
+  beforeEach(async () => {
+    appContextService.start(createAppContextStartContractMock());
+  });
+  afterEach(async () => {
+    appContextService.stop();
+  });
+  it('should return an array of Installation objects when successful', async () => {
+    mockedBulkInstallPackages.mockImplementationOnce(async function () {
+      return [
+        {
+          name: 'blah',
+          assets: [],
+          newVersion: '',
+          oldVersion: '',
+          statusCode: 200,
+        },
+      ];
+    });
+    const soClient = savedObjectsClientMock.create();
+    const resp = await ensureInstalledDefaultPackages(soClient, jest.fn());
+    expect(resp).toEqual([mockInstallation.attributes]);
+  });
+  it('should throw the first Error it finds', async () => {
+    class SomeCustomError extends Error {}
+    mockedBulkInstallPackages.mockImplementationOnce(async function () {
+      return [
+        {
+          name: 'success one',
+          assets: [],
+          newVersion: '',
+          oldVersion: '',
+          statusCode: 200,
+        },
+        {
+          name: 'success two',
+          assets: [],
+          newVersion: '',
+          oldVersion: '',
+          statusCode: 200,
+        },
+        {
+          name: 'failure one',
+          error: new SomeCustomError('abc 123'),
+        },
+        {
+          name: 'success three',
+          assets: [],
+          newVersion: '',
+          oldVersion: '',
+          statusCode: 200,
+        },
+        {
+          name: 'failure two',
+          error: new Error('zzz'),
+        },
+      ];
+    });
+    const soClient = savedObjectsClientMock.create();
+    const installPromise = ensureInstalledDefaultPackages(soClient, jest.fn());
+    expect(installPromise).rejects.toThrow(SomeCustomError);
+    expect(installPromise).rejects.toThrow('abc 123');
+  });
+});

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

@@ -0,0 +1,101 @@
+/*
+ * 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 { SavedObject } from 'src/core/server';
+import { ElasticsearchAssetType, Installation, KibanaAssetType } from '../../../types';
+import { getInstallType } from './install';
+
+const mockInstallation: SavedObject<Installation> = {
+  id: 'test-pkg',
+  references: [],
+  type: 'epm-packages',
+  attributes: {
+    id: 'test-pkg',
+    installed_kibana: [{ type: KibanaAssetType.dashboard, id: 'dashboard-1' }],
+    installed_es: [{ type: ElasticsearchAssetType.ingestPipeline, id: 'pipeline' }],
+    es_index_patterns: { pattern: 'pattern-name' },
+    name: 'test packagek',
+    version: '1.0.0',
+    install_status: 'installed',
+    install_version: '1.0.0',
+    install_started_at: new Date().toISOString(),
+  },
+};
+const mockInstallationUpdateFail: SavedObject<Installation> = {
+  id: 'test-pkg',
+  references: [],
+  type: 'epm-packages',
+  attributes: {
+    id: 'test-pkg',
+    installed_kibana: [{ type: KibanaAssetType.dashboard, id: 'dashboard-1' }],
+    installed_es: [{ type: ElasticsearchAssetType.ingestPipeline, id: 'pipeline' }],
+    es_index_patterns: { pattern: 'pattern-name' },
+    name: 'test packagek',
+    version: '1.0.0',
+    install_status: 'installing',
+    install_version: '1.0.1',
+    install_started_at: new Date().toISOString(),
+  },
+};
+
+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 });
+    expect(installTypeInstall).toBe('install');
+
+    // @ts-expect-error can only be 'install' if no installedPkg given
+    expect(installTypeInstall === 'update').toBe(false);
+    // @ts-expect-error can only be 'install' if no installedPkg given
+    expect(installTypeInstall === 'reinstall').toBe(false);
+    // @ts-expect-error can only be 'install' if no installedPkg given
+    expect(installTypeInstall === 'reupdate').toBe(false);
+    // @ts-expect-error can only be 'install' if no installedPkg given
+    expect(installTypeInstall === 'rollback').toBe(false);
+  });
+
+  it('should return correct type when installing the same version', () => {
+    const installTypeReinstall = getInstallType({
+      pkgVersion: '1.0.0',
+      installedPkg: mockInstallation,
+    });
+    expect(installTypeReinstall).toBe('reinstall');
+
+    // @ts-expect-error cannot be 'install' if given installedPkg
+    expect(installTypeReinstall === 'install').toBe(false);
+  });
+
+  it('should return correct type when moving from one version to another', () => {
+    const installTypeUpdate = getInstallType({
+      pkgVersion: '1.0.1',
+      installedPkg: mockInstallation,
+    });
+    expect(installTypeUpdate).toBe('update');
+
+    // @ts-expect-error cannot be 'install' if given installedPkg
+    expect(installTypeUpdate === 'install').toBe(false);
+  });
+
+  it('should return correct type when update fails and trys again', () => {
+    const installTypeReupdate = getInstallType({
+      pkgVersion: '1.0.1',
+      installedPkg: mockInstallationUpdateFail,
+    });
+    expect(installTypeReupdate).toBe('reupdate');
+
+    // @ts-expect-error cannot be 'install' if given installedPkg
+    expect(installTypeReupdate === 'install').toBe(false);
+  });
+
+  it('should return correct type when attempting to rollback from a failed update', () => {
+    const installTypeRollback = getInstallType({
+      pkgVersion: '1.0.0',
+      installedPkg: mockInstallationUpdateFail,
+    });
+    expect(installTypeRollback).toBe('rollback');
+
+    // @ts-expect-error cannot be 'install' if given installedPkg
+    expect(installTypeRollback === 'install').toBe(false);
+  });
+});

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

@@ -12,6 +12,8 @@ import {
   InstallationStatus,
   KibanaAssetType,
 } from '../../../types';
+
+export { bulkInstallPackages, isBulkInstallError } from './bulk_install_packages';
 export {
   getCategories,
   getFile,
@@ -23,7 +25,13 @@ export {
   SearchParams,
 } from './get';
 
-export { installPackage, ensureInstalledPackage } from './install';
+export {
+  BulkInstallResponse,
+  handleInstallPackageFailure,
+  installPackage,
+  IBulkInstallPackageError,
+  ensureInstalledPackage,
+} from './install';
 export { removeInstallation } from './remove';
 
 type RequiredPackage = 'system' | 'endpoint';