[Rollup] Migrate to new ES client

src/plugins/es_ui_shared/__packages_do_not_import__/errors/handle_es_error.ts

@@ -36,7 +36,7 @@ export const handleEsError = ({
     return response.customError({
       statusCode,
       body: {
-        message: body.error?.reason,
+        message: body.error?.reason ?? error.message ?? 'Unknown error',
         attributes: {
           // The full original ES error object
           error: body.error,

x-pack/plugins/rollup/server/plugin.ts

@@ -19,25 +19,16 @@ import { i18n } from '@kbn/i18n';
 import { schema } from '@kbn/config-schema';
 
 import { PLUGIN, CONFIG_ROLLUPS } from '../common';
-import { Dependencies, RollupHandlerContext } from './types';
+import { Dependencies } from './types';
 import { registerApiRoutes } from './routes';
 import { License } from './services';
 import { registerRollupUsageCollector } from './collectors';
 import { rollupDataEnricher } from './rollup_data_enricher';
 import { IndexPatternsFetcher } from './shared_imports';
-import { elasticsearchJsPlugin } from './client/elasticsearch_rollup';
-import { isEsError } from './shared_imports';
+import { handleEsError } from './shared_imports';
 import { formatEsError } from './lib/format_es_error';
 import { getCapabilitiesForRollupIndices } from '../../../../src/plugins/data/server';
 
-async function getCustomEsClient(getStartServices: CoreSetup['getStartServices']) {
-  const [core] = await getStartServices();
-  // Extend the elasticsearchJs client with additional endpoints.
-  const esClientConfig = { plugins: [elasticsearchJsPlugin] };
-
-  return core.elasticsearch.legacy.createClient('rollup', esClientConfig);
-}
-
 export class RollupPlugin implements Plugin<void, void, any, any> {
   private readonly logger: Logger;
   private readonly globalConfig$: Observable<SharedGlobalConfig>;
@@ -82,21 +73,11 @@ export class RollupPlugin implements Plugin<void, void, any, any> {
       ],
     });
 
-    http.registerRouteHandlerContext<RollupHandlerContext, 'rollup'>(
-      'rollup',
-      async (context, request) => {
-        this.rollupEsClient = this.rollupEsClient ?? (await getCustomEsClient(getStartServices));
-        return {
-          client: this.rollupEsClient.asScoped(request),
-        };
-      }
-    );
-
     registerApiRoutes({
       router: http.createRouter(),
       license: this.license,
       lib: {
-        isEsError,
+        handleEsError,
         formatEsError,
         getCapabilitiesForRollupIndices,
       },

x-pack/plugins/rollup/server/routes/api/indices/register_get_route.ts

@@ -14,7 +14,7 @@ import { RouteDependencies } from '../../../types';
 export const registerGetRoute = ({
   router,
   license,
-  lib: { isEsError, formatEsError, getCapabilitiesForRollupIndices },
+  lib: { handleEsError, getCapabilitiesForRollupIndices },
 }: RouteDependencies) => {
   router.get(
     {
@@ -23,18 +23,13 @@ export const registerGetRoute = ({
     },
     license.guardApiRoute(async (context, request, response) => {
       try {
-        const data = await context.rollup!.client.callAsCurrentUser(
-          'rollup.rollupIndexCapabilities',
-          {
-            indexPattern: '_all',
-          }
-        );
+        const { client: clusterClient } = context.core.elasticsearch;
+        const { body: data } = await clusterClient.asCurrentUser.rollup.getRollupIndexCaps({
+          index: '_all',
+        });
         return response.ok({ body: getCapabilitiesForRollupIndices(data) });
       } catch (err) {
-        if (isEsError(err)) {
-          return response.customError({ statusCode: err.statusCode, body: err });
-        }
-        throw err;
+        return handleEsError({ error: err, response });
       }
     })
   );

x-pack/plugins/rollup/server/routes/api/indices/register_validate_index_pattern_route.ts

@@ -32,10 +32,6 @@ interface FieldCapability {
   scaled_float?: any;
 }
 
-interface FieldCapabilities {
-  fields: FieldCapability[];
-}
-
 function isNumericField(fieldCapability: FieldCapability) {
   const numericTypes = [
     'long',
@@ -59,7 +55,7 @@ function isNumericField(fieldCapability: FieldCapability) {
 export const registerValidateIndexPatternRoute = ({
   router,
   license,
-  lib: { isEsError, formatEsError },
+  lib: { handleEsError },
 }: RouteDependencies) => {
   router.get(
     {
@@ -71,16 +67,12 @@ export const registerValidateIndexPatternRoute = ({
       },
     },
     license.guardApiRoute(async (context, request, response) => {
+      const { client: clusterClient } = context.core.elasticsearch;
       try {
         const { indexPattern } = request.params;
-        const [fieldCapabilities, rollupIndexCapabilities]: [
-          FieldCapabilities,
-          { [key: string]: any }
-        ] = await Promise.all([
-          context.rollup!.client.callAsCurrentUser('rollup.fieldCapabilities', { indexPattern }),
-          context.rollup!.client.callAsCurrentUser('rollup.rollupIndexCapabilities', {
-            indexPattern,
-          }),
+        const [{ body: fieldCapabilities }, { body: rollupIndexCapabilities }] = await Promise.all([
+          clusterClient.asCurrentUser.fieldCaps({ index: indexPattern, fields: '*' }),
+          clusterClient.asCurrentUser.rollup.getRollupIndexCaps({ index: indexPattern }),
         ]);
 
         const doesMatchIndices = Object.entries(fieldCapabilities.fields).length !== 0;
@@ -92,23 +84,21 @@ export const registerValidateIndexPatternRoute = ({
 
         const fieldCapabilitiesEntries = Object.entries(fieldCapabilities.fields);
 
-        fieldCapabilitiesEntries.forEach(
-          ([fieldName, fieldCapability]: [string, FieldCapability]) => {
-            if (fieldCapability.date) {
-              dateFields.push(fieldName);
-              return;
-            }
+        fieldCapabilitiesEntries.forEach(([fieldName, fieldCapability]) => {
+          if (fieldCapability.date) {
+            dateFields.push(fieldName);
+            return;
+          }
 
-            if (isNumericField(fieldCapability)) {
-              numericFields.push(fieldName);
-              return;
-            }
+          if (isNumericField(fieldCapability)) {
+            numericFields.push(fieldName);
+            return;
+          }
 
-            if (fieldCapability.keyword) {
-              keywordFields.push(fieldName);
-            }
+          if (fieldCapability.keyword) {
+            keywordFields.push(fieldName);
           }
-        );
+        });
 
         const body = {
           doesMatchIndices,
@@ -132,11 +122,7 @@ export const registerValidateIndexPatternRoute = ({
           return response.ok({ body: notFoundBody });
         }
 
-        if (isEsError(err)) {
-          return response.customError({ statusCode: err.statusCode, body: err });
-        }
-
-        throw err;
+        return handleEsError({ error: err, response });
       }
     })
   );

x-pack/plugins/rollup/server/routes/api/jobs/register_create_route.ts

@@ -12,7 +12,7 @@ import { RouteDependencies } from '../../../types';
 export const registerCreateRoute = ({
   router,
   license,
-  lib: { isEsError, formatEsError },
+  lib: { handleEsError },
 }: RouteDependencies) => {
   router.put(
     {
@@ -29,21 +29,19 @@ export const registerCreateRoute = ({
       },
     },
     license.guardApiRoute(async (context, request, response) => {
+      const { client: clusterClient } = context.core.elasticsearch;
       try {
         const { id, ...rest } = request.body.job;
         // Create job.
-        await context.rollup!.client.callAsCurrentUser('rollup.createJob', {
+        await clusterClient.asCurrentUser.rollup.putJob({
           id,
           body: rest,
         });
         // Then request the newly created job.
-        const results = await context.rollup!.client.callAsCurrentUser('rollup.job', { id });
+        const { body: results } = await clusterClient.asCurrentUser.rollup.getJobs({ id });
         return response.ok({ body: results.jobs[0] });
       } catch (err) {
-        if (isEsError(err)) {
-          return response.customError({ statusCode: err.statusCode, body: err });
-        }
-        throw err;
+        return handleEsError({ error: err, response });
       }
     })
   );