[7.x] [Uptime] Shim server for new platform (#44938)

x-pack/legacy/plugins/uptime/index.ts

@@ -6,8 +6,9 @@
 
 import { i18n } from '@kbn/i18n';
 import { resolve } from 'path';
+import { PluginInitializerContext } from 'src/core/server';
 import { PLUGIN } from './common/constants';
-import { initServerWithKibana, KibanaServer } from './server';
+import { KibanaServer, plugin } from './server';
 
 export const uptime = (kibana: any) =>
   new kibana.Plugin({
@@ -33,6 +34,19 @@ export const uptime = (kibana: any) =>
       home: ['plugins/uptime/register_feature'],
     },
     init(server: KibanaServer) {
-      initServerWithKibana(server);
+      const initializerContext = {} as PluginInitializerContext;
+      const { savedObjects } = server;
+      const { elasticsearch, xpack_main } = server.plugins;
+      plugin(initializerContext).setup(
+        {
+          route: (arg: any) => server.route(arg),
+        },
+        {
+          elasticsearch,
+          savedObjects,
+          usageCollector: server.usage,
+          xpack: xpack_main,
+        }
+      );
     },
   });

x-pack/legacy/plugins/uptime/server/index.ts

@@ -5,3 +5,4 @@
  */
 
 export { initServerWithKibana, KibanaServer } from './kibana.index';
+export { plugin } from './plugin';

x-pack/legacy/plugins/uptime/server/kibana.index.ts

@@ -10,6 +10,7 @@ import { PLUGIN } from '../common/constants';
 import { KibanaTelemetryAdapter } from './lib/adapters/telemetry';
 import { compose } from './lib/compose/kibana';
 import { initUptimeServer } from './uptime_server';
+import { UptimeCorePlugins, UptimeCoreSetup } from './lib/adapters/framework';
 
 export interface KibanaRouteOptions {
   path: string;
@@ -28,13 +29,16 @@ export interface KibanaServer extends Server {
   };
 }
 
-export const initServerWithKibana = (server: KibanaServer) => {
-  const libs = compose(server);
-  server.usage.collectorSet.register(KibanaTelemetryAdapter.initUsageCollector(server));
+export const initServerWithKibana = (server: UptimeCoreSetup, plugins: UptimeCorePlugins) => {
+  const { usageCollector, xpack } = plugins;
+  const libs = compose(
+    server,
+    plugins
+  );
+  usageCollector.collectorSet.register(KibanaTelemetryAdapter.initUsageCollector(usageCollector));
   initUptimeServer(libs);
 
-  const xpackMainPlugin = server.plugins.xpack_main;
-  xpackMainPlugin.registerFeature({
+  xpack.registerFeature({
     id: PLUGIN.ID,
     name: i18n.translate('xpack.uptime.featureRegistry.uptimeFeatureName', {
       defaultMessage: 'Uptime',

x-pack/legacy/plugins/uptime/server/lib/adapters/framework/adapter_types.ts

@@ -8,6 +8,7 @@ import { GraphQLOptions } from 'apollo-server-core';
 import { GraphQLSchema } from 'graphql';
 import { Lifecycle, ResponseToolkit } from 'hapi';
 import { RouteOptions } from 'hapi';
+import { SavedObjectsLegacyService } from 'src/core/server';
 
 export interface UMFrameworkRequest {
   user: string;
@@ -29,6 +30,17 @@ export interface UMFrameworkRouteOptions<
   config?: any;
 }
 
+export interface UptimeCoreSetup {
+  route: any;
+}
+
+export interface UptimeCorePlugins {
+  elasticsearch: any;
+  savedObjects: SavedObjectsLegacyService<any>;
+  usageCollector: any;
+  xpack: any;
+}
+
 export type UMFrameworkRouteHandler<RouteRequest extends UMFrameworkRequest> = (
   request: UMFrameworkRequest,
   h: ResponseToolkit

x-pack/legacy/plugins/uptime/server/lib/adapters/framework/kibana_framework_adapter.ts

@@ -5,21 +5,24 @@
  */
 
 import { GraphQLSchema } from 'graphql';
-import { Server } from 'hapi';
+import { Request, ResponseToolkit } from 'hapi';
+import { runHttpQuery } from 'apollo-server-core';
+import { UptimeCorePlugins, UptimeCoreSetup } from './adapter_types';
 import {
   UMBackendFrameworkAdapter,
   UMFrameworkRequest,
   UMFrameworkResponse,
   UMFrameworkRouteOptions,
-  UMHapiGraphQLPluginOptions,
 } from './adapter_types';
-import { uptimeGraphQLHapiPlugin } from './apollo_framework_adapter';
+import { DEFAULT_GRAPHQL_PATH } from '../../../graphql';
 
 export class UMKibanaBackendFrameworkAdapter implements UMBackendFrameworkAdapter {
-  private server: Server;
-
-  constructor(hapiServer: Server) {
-    this.server = hapiServer;
+  constructor(
+    private readonly server: UptimeCoreSetup,
+    private readonly plugins: UptimeCorePlugins
+  ) {
+    this.server = server;
+    this.plugins = plugins;
   }
 
   public registerRoute<
@@ -30,24 +33,53 @@ export class UMKibanaBackendFrameworkAdapter implements UMBackendFrameworkAdapte
   }
 
   public registerGraphQLEndpoint(routePath: string, schema: GraphQLSchema): void {
-    this.server.register<UMHapiGraphQLPluginOptions>({
-      options: {
-        graphQLOptions: (req: any) => ({
-          context: { req },
-          schema,
-        }),
-        path: routePath,
-        route: {
-          tags: ['access:uptime'],
-        },
+    const options = {
+      graphQLOptions: (req: any) => ({
+        context: { req },
+        schema,
+      }),
+      path: routePath,
+      route: {
+        tags: ['access:uptime'],
+      },
+    };
+    this.server.route({
+      options: options.route,
+      handler: async (request: Request, h: ResponseToolkit) => {
+        try {
+          const { method } = request;
+          const query =
+            method === 'post'
+              ? (request.payload as Record<string, any>)
+              : (request.query as Record<string, any>);
+
+          const graphQLResponse = await runHttpQuery([request], {
+            method: method.toUpperCase(),
+            options: options.graphQLOptions,
+            query,
+          });
+
+          return h.response(graphQLResponse).type('application/json');
+        } catch (error) {
+          if (error.isGraphQLError === true) {
+            return h
+              .response(error.message)
+              .code(error.statusCode)
+              .type('application/json');
+          }
+          return h.response(error).type('application/json');
+        }
       },
-      plugin: uptimeGraphQLHapiPlugin,
+      method: ['get', 'post'],
+      path: options.path || DEFAULT_GRAPHQL_PATH,
+      vhost: undefined,
     });
   }
 
   public getSavedObjectsClient() {
-    const { SavedObjectsClient, getSavedObjectsRepository } = this.server.savedObjects;
-    const { callWithInternalUser } = this.server.plugins.elasticsearch.getCluster('admin');
+    const { elasticsearch, savedObjects } = this.plugins;
+    const { SavedObjectsClient, getSavedObjectsRepository } = savedObjects;
+    const { callWithInternalUser } = elasticsearch.getCluster('admin');
     const internalRepository = getSavedObjectsRepository(callWithInternalUser);
     return new SavedObjectsClient(internalRepository);
   }

x-pack/legacy/plugins/uptime/server/lib/adapters/saved_objects/kibana_saved_objects_adapter.ts

@@ -4,14 +4,15 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
+import { SavedObjectsLegacyService } from 'src/core/server';
 import { UMSavedObjectsAdapter } from './types';
 import uptimeIndexPattern from './heartbeat_index_pattern.json';
 
 export class UMKibanaSavedObjectsAdapter implements UMSavedObjectsAdapter {
   private readonly savedObjectsClient: any;
-  constructor(server: any) {
-    const { SavedObjectsClient, getSavedObjectsRepository } = server.savedObjects;
-    const { callWithInternalUser } = server.plugins.elasticsearch.getCluster('admin');
+  constructor(savedObjects: SavedObjectsLegacyService<any>, elasticsearch: any) {
+    const { SavedObjectsClient, getSavedObjectsRepository } = savedObjects;
+    const { callWithInternalUser } = elasticsearch.getCluster('admin');
     const internalRepository = getSavedObjectsRepository(callWithInternalUser);
     this.savedObjectsClient = new SavedObjectsClient(internalRepository);
   }

x-pack/legacy/plugins/uptime/server/lib/adapters/telemetry/__tests__/kibana_telemetry_adapter.test.ts

@@ -7,23 +7,21 @@
 import { KibanaTelemetryAdapter } from '../kibana_telemetry_adapter';
 
 describe('KibanaTelemetryAdapter', () => {
-  let server: any;
+  let telemetry: any;
   let collector: { type: string; fetch: () => Promise<any>; isReady: () => boolean };
   beforeEach(() => {
-    server = {
-      usage: {
-        collectorSet: {
-          makeUsageCollector: (val: any) => {
-            collector = val;
-          },
+    telemetry = {
+      collectorSet: {
+        makeUsageCollector: (val: any) => {
+          collector = val;
         },
       },
     };
   });
 
   it('collects monitor and overview data', async () => {
     expect.assertions(1);
-    KibanaTelemetryAdapter.initUsageCollector(server);
+    KibanaTelemetryAdapter.initUsageCollector(telemetry);
     KibanaTelemetryAdapter.countMonitor();
     KibanaTelemetryAdapter.countOverview();
     KibanaTelemetryAdapter.countOverview();
@@ -35,7 +33,7 @@ describe('KibanaTelemetryAdapter', () => {
     expect.assertions(1);
     // give a time of > 24 hours ago
     Date.now = jest.fn(() => 1559053560000);
-    KibanaTelemetryAdapter.initUsageCollector(server);
+    KibanaTelemetryAdapter.initUsageCollector(telemetry);
     KibanaTelemetryAdapter.countMonitor();
     KibanaTelemetryAdapter.countOverview();
     // give a time of now
@@ -49,7 +47,7 @@ describe('KibanaTelemetryAdapter', () => {
   });
 
   it('defaults ready to `true`', async () => {
-    KibanaTelemetryAdapter.initUsageCollector(server);
+    KibanaTelemetryAdapter.initUsageCollector(telemetry);
     expect(collector.isReady()).toBe(true);
   });
 });

x-pack/legacy/plugins/uptime/server/lib/adapters/telemetry/kibana_telemetry_adapter.ts

@@ -19,8 +19,8 @@ const BUCKET_SIZE = 3600;
 const BUCKET_NUMBER = 24;
 
 export class KibanaTelemetryAdapter {
-  public static initUsageCollector(server: any) {
-    const { collectorSet } = server.usage;
+  public static initUsageCollector(usageCollector: any) {
+    const { collectorSet } = usageCollector;
     return collectorSet.makeUsageCollector({
       type: 'uptime',
       fetch: async () => {

x-pack/legacy/plugins/uptime/server/lib/compose/kibana.ts

@@ -13,25 +13,26 @@ import { UMAuthDomain } from '../domains';
 import { UMDomainLibs, UMServerLibs } from '../lib';
 import { ElasticsearchMonitorStatesAdapter } from '../adapters/monitor_states';
 import { UMKibanaSavedObjectsAdapter } from '../adapters/saved_objects/kibana_saved_objects_adapter';
+import { UptimeCorePlugins, UptimeCoreSetup } from '../adapters/framework';
 
-export function compose(hapiServer: any): UMServerLibs {
-  const framework = new UMKibanaBackendFrameworkAdapter(hapiServer);
-  const database = new UMKibanaDatabaseAdapter(hapiServer.plugins.elasticsearch);
-  const authDomain = new UMAuthDomain(new UMXPackAuthAdapter(hapiServer.plugins.xpack_main), {});
+export function compose(server: UptimeCoreSetup, plugins: UptimeCorePlugins): UMServerLibs {
+  const { elasticsearch, savedObjects, xpack } = plugins;
+  const framework = new UMKibanaBackendFrameworkAdapter(server, plugins);
+  const database = new UMKibanaDatabaseAdapter(elasticsearch);
+
+  const authDomain = new UMAuthDomain(new UMXPackAuthAdapter(xpack), {});
 
   const domainLibs: UMDomainLibs = {
     auth: authDomain,
     monitors: new ElasticsearchMonitorsAdapter(database),
     monitorStates: new ElasticsearchMonitorStatesAdapter(database),
     pings: new ElasticsearchPingsAdapter(database),
-    savedObjects: new UMKibanaSavedObjectsAdapter(hapiServer),
+    savedObjects: new UMKibanaSavedObjectsAdapter(savedObjects, elasticsearch),
   };
 
-  const libs: UMServerLibs = {
+  return {
     framework,
     database,
     ...domainLibs,
   };
-
-  return libs;
 }

x-pack/legacy/plugins/uptime/server/plugin.ts

@@ -0,0 +1,19 @@
+/*
+ * 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 { PluginInitializerContext } from 'src/core/server';
+import { initServerWithKibana } from './kibana.index';
+import { UptimeCoreSetup, UptimeCorePlugins } from './lib/adapters/framework';
+
+export function plugin(initializerContext: PluginInitializerContext) {
+  return new Plugin();
+}
+
+export class Plugin {
+  public setup(core: UptimeCoreSetup, plugins: UptimeCorePlugins) {
+    initServerWithKibana(core, plugins);
+  }
+}