[Uptime] Shim server for new platform

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,13 @@ export const uptime = (kibana: any) =>
       home: ['plugins/uptime/register_feature'],
     },
     init(server: KibanaServer) {
-      initServerWithKibana(server);
+      const initializerContext = {} as PluginInitializerContext;
+      const { elasticsearch, xpack_main } = server.plugins;
+      plugin(initializerContext).setup({
+        elasticsearch,
+        usageCollector: server.usage,
+        xpack: xpack_main,
+        route: (arg: any) => server.route(arg),
+      });
     },
   });

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 { KibanaCore } from './lib/adapters/framework';
 
 export interface KibanaRouteOptions {
   path: string;
@@ -28,13 +29,12 @@ export interface KibanaServer extends Server {
   };
 }
 
-export const initServerWithKibana = (server: KibanaServer) => {
+export const initServerWithKibana = (server: KibanaCore) => {
   const libs = compose(server);
-  server.usage.collectorSet.register(KibanaTelemetryAdapter.initUsageCollector(server));
+  server.usageCollector.collectorSet.register(KibanaTelemetryAdapter.initUsageCollector(server));
   initUptimeServer(libs);
 
-  const xpackMainPlugin = server.plugins.xpack_main;
-  xpackMainPlugin.registerFeature({
+  server.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

@@ -29,6 +29,13 @@ export interface UMFrameworkRouteOptions<
   config?: any;
 }
 
+export interface KibanaCore {
+  elasticsearch: any;
+  usageCollector: any;
+  xpack: any;
+  route: 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,20 @@
  */
 
 import { GraphQLSchema } from 'graphql';
-import { Server } from 'hapi';
+import { Request, ResponseToolkit } from 'hapi';
+import { runHttpQuery } from 'apollo-server-core';
+import { KibanaCore } 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: KibanaCore) {
+    this.server = server;
   }
 
   public registerRoute<
@@ -30,18 +29,46 @@ 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,
     });
   }
 }

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

@@ -5,19 +5,23 @@
  */
 
 import { KibanaTelemetryAdapter } from '../kibana_telemetry_adapter';
+import { KibanaCore } from '../../framework';
 
 describe('KibanaTelemetryAdapter', () => {
-  let server: any;
+  let server: KibanaCore;
   let collector: { type: string; fetch: () => Promise<any>; isReady: () => boolean };
   beforeEach(() => {
     server = {
-      usage: {
+      elasticsearch: {},
+      route: {},
+      usageCollector: {
         collectorSet: {
           makeUsageCollector: (val: any) => {
             collector = val;
           },
         },
       },
+      xpack: {},
     };
   });
 

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

@@ -4,6 +4,8 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
+import { KibanaCore } from '../framework';
+
 interface UptimeTelemetry {
   overview_page: number;
   monitor_page: number;
@@ -19,8 +21,8 @@ const BUCKET_SIZE = 3600;
 const BUCKET_NUMBER = 24;
 
 export class KibanaTelemetryAdapter {
-  public static initUsageCollector(server: any) {
-    const { collectorSet } = server.usage;
+  public static initUsageCollector(server: KibanaCore) {
+    const { collectorSet } = server.usageCollector;
     return collectorSet.makeUsageCollector({
       type: 'uptime',
       fetch: async () => {

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

@@ -13,13 +13,14 @@ import { UMAuthDomain, UMMonitorsDomain, UMPingsDomain } from '../domains';
 import { UMDomainLibs, UMServerLibs } from '../lib';
 import { UMMonitorStatesDomain } from '../domains/monitor_states';
 import { ElasticsearchMonitorStatesAdapter } from '../adapters/monitor_states';
+import { KibanaCore } from '../adapters/framework';
 
-export function compose(hapiServer: any): UMServerLibs {
-  const framework = new UMKibanaBackendFrameworkAdapter(hapiServer);
-  const database = new UMKibanaDatabaseAdapter(hapiServer.plugins.elasticsearch);
+export function compose(server: KibanaCore): UMServerLibs {
+  const framework = new UMKibanaBackendFrameworkAdapter(server);
+  const database = new UMKibanaDatabaseAdapter(server.elasticsearch);
 
   const pingsDomain = new UMPingsDomain(new ElasticsearchPingsAdapter(database), {});
-  const authDomain = new UMAuthDomain(new UMXPackAuthAdapter(hapiServer.plugins.xpack_main), {});
+  const authDomain = new UMAuthDomain(new UMXPackAuthAdapter(server.xpack), {});
   const monitorsDomain = new UMMonitorsDomain(new ElasticsearchMonitorsAdapter(database), {});
   const monitorStatesDomain = new UMMonitorStatesDomain(
     new ElasticsearchMonitorStatesAdapter(database),
@@ -33,11 +34,9 @@ export function compose(hapiServer: any): UMServerLibs {
     pings: pingsDomain,
   };
 
-  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 { KibanaCore } from './lib/adapters/framework';
+
+export function plugin(initializerContext: PluginInitializerContext) {
+  return new Plugin();
+}
+
+export class Plugin {
+  public setup(core: KibanaCore) {
+    initServerWithKibana(core);
+  }
+}