Add support for GeoIP processor databases in Ingest Pipelines

config/serverless.yml

@@ -111,6 +111,9 @@ xpack.index_management.enableMappingsSourceFieldSection: false
 # Disable toggle for enabling data retention in DSL form from Index Management UI
 xpack.index_management.enableTogglingDataRetention: false
 
+# Disable Manage Processors UI in Ingest Pipelines
+xpack.ingest_pipelines.enableManageProcessors: false
+
 # Keep deeplinks visible so that they are shown in the sidenav
 dev_tools.deeplinks.navLinkStatus: visible
 management.deeplinks.navLinkStatus: visible

test/plugin_functional/test_suites/core_plugins/rendering.ts

@@ -304,6 +304,7 @@ export default function ({ getService }: PluginFunctionalProviderContext) {
         'xpack.ml.nlp.enabled (boolean)',
         'xpack.osquery.actionEnabled (boolean?)',
         'xpack.remote_clusters.ui.enabled (boolean?)',
+        'xpack.ingest_pipelines.enableManageProcessors (boolean?|never)',
         /**
          * NOTE: The Reporting plugin is currently disabled in functional tests (see test/functional/config.base.js).
          * It will be re-enabled once #102552 is completed.

x-pack/plugins/ingest_pipelines/__jest__/client_integration/helpers/http_requests.ts

@@ -73,12 +73,27 @@ const registerHttpRequestMockHelpers = (
   const setParseCsvResponse = (response?: object, error?: ResponseError) =>
     mockResponse('POST', `${API_BASE_PATH}/parse_csv`, response, error);
 
+  const setLoadGeoipDatabasesResponse = (response?: object[], error?: ResponseError) =>
+    mockResponse('GET', `${API_BASE_PATH}/geoip_database`, response, error);
+
+  const setDeleteGeoipDatabaseResponse = (
+    databaseName: string,
+    response?: object,
+    error?: ResponseError
+  ) => mockResponse('DELETE', `${API_BASE_PATH}/geoip_database/${databaseName}`, response, error);
+
+  const setCreateGeoipDatabaseResponse = (response?: object, error?: ResponseError) =>
+    mockResponse('POST', `${API_BASE_PATH}/geoip_database`, response, error);
+
   return {
     setLoadPipelinesResponse,
     setLoadPipelineResponse,
     setDeletePipelineResponse,
     setCreatePipelineResponse,
     setParseCsvResponse,
+    setLoadGeoipDatabasesResponse,
+    setDeleteGeoipDatabaseResponse,
+    setCreateGeoipDatabaseResponse,
   };
 };
 

x-pack/plugins/ingest_pipelines/__jest__/client_integration/helpers/index.ts

@@ -10,8 +10,9 @@ import { setup as pipelinesCreateSetup } from './pipelines_create.helpers';
 import { setup as pipelinesCloneSetup } from './pipelines_clone.helpers';
 import { setup as pipelinesEditSetup } from './pipelines_edit.helpers';
 import { setup as pipelinesCreateFromCsvSetup } from './pipelines_create_from_csv.helpers';
+import { setup as manageProcessorsSetup } from './manage_processors.helpers';
 
-export { nextTick, getRandomString, findTestSubject } from '@kbn/test-jest-helpers';
+export { getRandomString, findTestSubject } from '@kbn/test-jest-helpers';
 
 export { setupEnvironment } from './setup_environment';
 
@@ -21,4 +22,5 @@ export const pageHelpers = {
   pipelinesClone: { setup: pipelinesCloneSetup },
   pipelinesEdit: { setup: pipelinesEditSetup },
   pipelinesCreateFromCsv: { setup: pipelinesCreateFromCsvSetup },
+  manageProcessors: { setup: manageProcessorsSetup },
 };

x-pack/plugins/ingest_pipelines/__jest__/client_integration/helpers/manage_processors.helpers.ts

@@ -0,0 +1,121 @@
+/*
+ * 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 { act } from 'react-dom/test-utils';
+import { HttpSetup } from '@kbn/core/public';
+
+import { registerTestBed, TestBed, AsyncTestBedConfig } from '@kbn/test-jest-helpers';
+import { ManageProcessors } from '../../../public/application/sections';
+import { WithAppDependencies } from './setup_environment';
+import { getManageProcessorsPath, ROUTES } from '../../../public/application/services/navigation';
+
+const testBedConfig: AsyncTestBedConfig = {
+  memoryRouter: {
+    initialEntries: [getManageProcessorsPath()],
+    componentRoutePath: ROUTES.manageProcessors,
+  },
+  doMountAsync: true,
+};
+
+export type ManageProcessorsTestBed = TestBed<ManageProcessorsTestSubjects> & {
+  actions: ReturnType<typeof createActions>;
+};
+
+const createActions = (testBed: TestBed) => {
+  const { component, find, form } = testBed;
+
+  const clickDeleteDatabaseButton = async (index: number) => {
+    const allDeleteButtons = find('deleteGeoipDatabaseButton');
+    const deleteButton = allDeleteButtons.at(index);
+    await act(async () => {
+      deleteButton.simulate('click');
+    });
+
+    component.update();
+  };
+
+  const confirmDeletingDatabase = async () => {
+    await act(async () => {
+      form.setInputValue('geoipDatabaseConfirmation', 'delete');
+    });
+
+    component.update();
+
+    const confirmButton: HTMLButtonElement | null = document.body.querySelector(
+      '[data-test-subj="deleteGeoipDatabaseSubmit"]'
+    );
+
+    expect(confirmButton).not.toBe(null);
+    expect(confirmButton!.disabled).toBe(false);
+    expect(confirmButton!.textContent).toContain('Delete');
+
+    await act(async () => {
+      confirmButton!.click();
+    });
+
+    component.update();
+  };
+
+  const clickAddDatabaseButton = async () => {
+    const button = find('addGeoipDatabaseButton');
+    await act(async () => {
+      button.simulate('click');
+    });
+
+    component.update();
+  };
+
+  const fillOutDatabaseValues = async (maxmind: string, databaseName: string) => {
+    await act(async () => {
+      form.setInputValue('addDatabaseMaxmind', maxmind);
+    });
+    await act(async () => {
+      form.setInputValue('addDatabaseName', databaseName);
+    });
+  };
+
+  const confirmAddingDatabase = async () => {
+    const button: HTMLButtonElement | null = document.body.querySelector(
+      '[data-test-subj="addGeoipDatabaseSubmit"]'
+    );
+    await act(async () => {
+      button!.click();
+    });
+
+    component.update();
+  };
+
+  return {
+    clickDeleteDatabaseButton,
+    confirmDeletingDatabase,
+    clickAddDatabaseButton,
+    fillOutDatabaseValues,
+    confirmAddingDatabase,
+  };
+};
+
+export const setup = async (httpSetup: HttpSetup): Promise<ManageProcessorsTestBed> => {
+  const initTestBed = registerTestBed(
+    WithAppDependencies(ManageProcessors, httpSetup),
+    testBedConfig
+  );
+  const testBed = await initTestBed();
+
+  return {
+    ...testBed,
+    actions: createActions(testBed),
+  };
+};
+
+export type ManageProcessorsTestSubjects =
+  | 'manageProcessorsTitle'
+  | 'addGeoipDatabaseButton'
+  | 'geoipDatabaseList'
+  | 'deleteGeoipDatabaseButton'
+  | 'geoipDatabaseConfirmation'
+  | 'geoipEmptyListPrompt'
+  | 'geoipListLoadingError';

x-pack/plugins/ingest_pipelines/__jest__/client_integration/helpers/setup_environment.tsx

@@ -70,6 +70,9 @@ const appServices = {
   },
   overlays: overlayServiceMock.createStartContract(),
   http: httpServiceMock.createStartContract({ basePath: '/mock' }),
+  config: {
+    enableManageProcessors: true,
+  },
 };
 
 export const setupEnvironment = () => {

x-pack/plugins/ingest_pipelines/__jest__/client_integration/manage_processors.test.tsx

@@ -0,0 +1,150 @@
+/*
+ * 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 { act } from 'react-dom/test-utils';
+
+import { ManageProcessorsTestBed } from './helpers/manage_processors.helpers';
+
+import { setupEnvironment, pageHelpers } from './helpers';
+import type { GeoipDatabase } from '../../common/types';
+import { API_BASE_PATH } from '../../common/constants';
+
+const { setup } = pageHelpers.manageProcessors;
+
+describe('<ManageProcessors />', () => {
+  const { httpSetup, httpRequestsMockHelpers } = setupEnvironment();
+  let testBed: ManageProcessorsTestBed;
+
+  describe('With databases', () => {
+    beforeEach(async () => {
+      await act(async () => {
+        testBed = await setup(httpSetup);
+      });
+
+      testBed.component.update();
+    });
+
+    const database1: GeoipDatabase = {
+      name: 'GeoIP2-Anonymous-IP',
+      id: 'geoip2-anonymous-ip',
+      type: 'maxmind',
+    };
+
+    const database2: GeoipDatabase = {
+      name: 'GeoIP2-City',
+      id: 'geoip2-city',
+      type: 'maxmind',
+    };
+
+    const database3 = {
+      name: 'GeoIP2-Country',
+      id: 'geoip2-country',
+      type: 'maxmind',
+    };
+
+    const databases = [database1, database2, database3];
+
+    httpRequestsMockHelpers.setLoadGeoipDatabasesResponse(databases);
+
+    test('renders the list of databases', async () => {
+      const { exists, find, table } = testBed;
+
+      // Page title
+      expect(exists('manageProcessorsTitle')).toBe(true);
+      expect(find('manageProcessorsTitle').text()).toEqual('Manage Processors');
+
+      // Add database button
+      expect(exists('addGeoipDatabaseButton')).toBe(true);
+
+      // Table has columns for database name and type
+      const { tableCellsValues } = table.getMetaData('geoipDatabaseList');
+      tableCellsValues.forEach((row, i) => {
+        const database = databases[i];
+
+        expect(row).toEqual([database.name, 'MaxMind', 'Delete']);
+      });
+    });
+
+    test('deletes a database', async () => {
+      const { actions } = testBed;
+      const { name: databaseName } = database1;
+      httpRequestsMockHelpers.setDeleteGeoipDatabaseResponse(databaseName, {});
+
+      await actions.clickDeleteDatabaseButton(0);
+
+      await actions.confirmDeletingDatabase();
+
+      expect(httpSetup.delete).toHaveBeenLastCalledWith(
+        `${API_BASE_PATH}/geoip_database/${databaseName.toLowerCase()}`,
+        expect.anything()
+      );
+    });
+  });
+
+  describe('Creates a database', () => {
+    it('creates a database when none with the same name exists', async () => {
+      const { actions } = testBed;
+      const databaseName = 'GeoIP2-ISP';
+      const maxmind = '123456';
+      httpRequestsMockHelpers.setCreateGeoipDatabaseResponse({
+        name: databaseName,
+        id: databaseName.toLowerCase(),
+      });
+
+      await actions.clickAddDatabaseButton();
+
+      await actions.fillOutDatabaseValues(maxmind, databaseName);
+
+      await actions.confirmAddingDatabase();
+
+      expect(httpSetup.post).toHaveBeenLastCalledWith(`${API_BASE_PATH}/geoip_database`, {
+        asSystemRequest: undefined,
+        body: '{"maxmind":"123456","databaseName":"GeoIP2-ISP"}',
+        query: undefined,
+        version: undefined,
+      });
+    });
+  });
+
+  describe('No databases', () => {
+    test('displays an empty prompt', async () => {
+      httpRequestsMockHelpers.setLoadGeoipDatabasesResponse([]);
+
+      await act(async () => {
+        testBed = await setup(httpSetup);
+      });
+      const { exists, component } = testBed;
+      component.update();
+
+      expect(exists('geoipEmptyListPrompt')).toBe(true);
+    });
+  });
+
+  describe('Error handling', () => {
+    beforeEach(async () => {
+      const error = {
+        statusCode: 500,
+        error: 'Internal server error',
+        message: 'Internal server error',
+      };
+
+      httpRequestsMockHelpers.setLoadGeoipDatabasesResponse(undefined, error);
+
+      await act(async () => {
+        testBed = await setup(httpSetup);
+      });
+
+      testBed.component.update();
+    });
+
+    test('displays an error callout', async () => {
+      const { exists } = testBed;
+
+      expect(exists('geoipListLoadingError')).toBe(true);
+    });
+  });
+});

x-pack/plugins/ingest_pipelines/common/types.ts

@@ -28,16 +28,15 @@ export interface Pipeline {
   deprecated?: boolean;
 }
 
-export interface PipelinesByName {
-  [key: string]: {
-    description: string;
-    version?: number;
-    processors: Processor[];
-    on_failure?: Processor[];
-  };
-}
-
 export enum FieldCopyAction {
   Copy = 'copy',
   Rename = 'rename',
 }
+
+export type DatabaseType = 'maxmind' | 'ipinfo' | 'web' | 'local' | 'unknown';
+
+export interface GeoipDatabase {
+  name: string;
+  id: string;
+  type: DatabaseType;
+}