[ML] New Platform Migration - server (#38360)

* wip: pull out all server dependencies

* create new platform plugin

* shim newPlatform plugin into legacy init

* update server tests for migration refactor

* cleanup interfaces

* Only add ML links for sample data sets if full license from - 38120

* update test and fix typescript errors

* Remove unused types

x-pack/plugins/ml/index.ts

@@ -0,0 +1,94 @@
+/*
+ * 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 { resolve } from 'path';
+import { i18n } from '@kbn/i18n';
+import KbnServer, { Server } from 'src/legacy/server/kbn_server';
+import { plugin } from './server/new_platform';
+import {
+  MlInitializerContext,
+  MlCoreSetup,
+  MlHttpServiceSetup,
+} from './server/new_platform/plugin';
+// @ts-ignore: could not find declaration file for module
+import mappings from './mappings';
+
+interface MlServer extends Server {
+  addAppLinksToSampleDataset: () => {};
+}
+
+export const ml = (kibana: any) => {
+  return new kibana.Plugin({
+    require: ['kibana', 'elasticsearch', 'xpack_main'],
+    id: 'ml',
+    configPrefix: 'xpack.ml',
+    publicDir: resolve(__dirname, 'public'),
+
+    uiExports: {
+      app: {
+        title: i18n.translate('xpack.ml.mlNavTitle', {
+          defaultMessage: 'Machine Learning',
+        }),
+        description: i18n.translate('xpack.ml.mlNavDescription', {
+          defaultMessage: 'Machine Learning for the Elastic Stack',
+        }),
+        icon: 'plugins/ml/ml.svg',
+        euiIconType: 'machineLearningApp',
+        main: 'plugins/ml/app',
+      },
+      styleSheetPaths: resolve(__dirname, 'public/index.scss'),
+      hacks: ['plugins/ml/hacks/toggle_app_link_in_nav'],
+      savedObjectSchemas: {
+        'ml-telemetry': {
+          isNamespaceAgnostic: true,
+        },
+      },
+      mappings,
+      home: ['plugins/ml/register_feature'],
+      injectDefaultVars(server: any) {
+        const config = server.config();
+        return {
+          mlEnabled: config.get('xpack.ml.enabled'),
+        };
+      },
+    },
+
+    async init(server: MlServer) {
+      const kbnServer = (server as unknown) as KbnServer;
+
+      const initializerContext = ({
+        legacyConfig: server.config(),
+        logger: {
+          get(...contextParts: string[]) {
+            return kbnServer.newPlatform.coreContext.logger.get('plugins', 'ml', ...contextParts);
+          },
+        },
+      } as unknown) as MlInitializerContext;
+
+      const mlHttpService: MlHttpServiceSetup = {
+        ...kbnServer.newPlatform.setup.core.http,
+        route: server.route.bind(server),
+      };
+
+      const core: MlCoreSetup = {
+        addAppLinksToSampleDataset: server.addAppLinksToSampleDataset,
+        injectUiAppVars: server.injectUiAppVars,
+        http: mlHttpService,
+        savedObjects: server.savedObjects,
+        usage: server.usage,
+      };
+
+      const plugins = {
+        elasticsearch: server.plugins.elasticsearch,
+        security: server.plugins.security,
+        xpackMain: server.plugins.xpack_main,
+        ml: this,
+      };
+
+      plugin(initializerContext).setup(core, plugins);
+    },
+  });
+};

x-pack/plugins/ml/server/client/call_with_internal_user_factory.d.ts

@@ -4,6 +4,6 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import { Server } from 'hapi';
+import { ElasticsearchPlugin } from 'src/legacy/core_plugins/elasticsearch';
 
-export function callWithInternalUserFactory(server: Server): any;
+export function callWithInternalUserFactory(elasticsearchPlugin: ElasticsearchPlugin): any;

x-pack/plugins/ml/server/client/call_with_internal_user_factory.js

@@ -8,13 +8,13 @@
 
 import { once } from 'lodash';
 
-const _callWithInternalUser = once((server) => {
-  const { callWithInternalUser } = server.plugins.elasticsearch.getCluster('admin');
+const _callWithInternalUser = once((elasticsearchPlugin) => {
+  const { callWithInternalUser } = elasticsearchPlugin.getCluster('admin');
   return callWithInternalUser;
 });
 
-export const callWithInternalUserFactory = (server) => {
+export const callWithInternalUserFactory = (elasticsearchPlugin) => {
   return (...args) => {
-    return _callWithInternalUser(server)(...args);
+    return _callWithInternalUser(elasticsearchPlugin)(...args);
   };
 };

x-pack/plugins/ml/server/client/call_with_internal_user_factory.test.ts

@@ -8,25 +8,21 @@ import { callWithInternalUserFactory } from './call_with_internal_user_factory';
 
 describe('call_with_internal_user_factory', () => {
   describe('callWithInternalUserFactory', () => {
-    let server: any;
+    let elasticsearchPlugin: any;
     let callWithInternalUser: any;
 
     beforeEach(() => {
       callWithInternalUser = jest.fn();
-      server = {
-        plugins: {
-          elasticsearch: {
-            getCluster: jest.fn(() => ({ callWithInternalUser })),
-          },
-        },
+      elasticsearchPlugin = {
+        getCluster: jest.fn(() => ({ callWithInternalUser })),
       };
     });
 
     it('should use internal user "admin"', () => {
-      const callWithInternalUserInstance = callWithInternalUserFactory(server);
+      const callWithInternalUserInstance = callWithInternalUserFactory(elasticsearchPlugin);
       callWithInternalUserInstance();
 
-      expect(server.plugins.elasticsearch.getCluster).toHaveBeenCalledWith('admin');
+      expect(elasticsearchPlugin.getCluster).toHaveBeenCalledWith('admin');
     });
   });
 });

x-pack/plugins/ml/server/client/call_with_request_factory.js

@@ -9,15 +9,15 @@
 import { once } from 'lodash';
 import { elasticsearchJsPlugin } from './elasticsearch_ml';
 
-const callWithRequest = once((server) => {
+const callWithRequest = once((elasticsearchPlugin) => {
   const config = { plugins: [ elasticsearchJsPlugin ] };
-  const cluster = server.plugins.elasticsearch.createCluster('ml', config);
+  const cluster = elasticsearchPlugin.createCluster('ml', config);
 
   return cluster.callWithRequest;
 });
 
-export const callWithRequestFactory = (server, request) => {
+export const callWithRequestFactory = (elasticsearchPlugin, request) => {
   return (...args) => {
-    return callWithRequest(server)(request, ...args);
+    return callWithRequest(elasticsearchPlugin)(request, ...args);
   };
 };

x-pack/plugins/ml/server/client/log.js

@@ -6,6 +6,6 @@
 
 export let mlLog = () => {};
 
-export function initMlServerLog(server) {
-  mlLog = (level, message) => server.log(['ml', level], message);
+export function initMlServerLog(log) {
+  mlLog = (level, message) => log(['ml', level], message);
 }

x-pack/plugins/ml/server/lib/__tests__/security_utils.js

@@ -13,33 +13,29 @@ import {
 
 describe('ML - security utils', () => {
 
-  function mockServerFactory(isAvailable = true, isEnabled = true) {
+  function mockXpackMainPluginFactory(isAvailable = true, isEnabled = true) {
     return {
-      plugins: {
-        xpack_main: {
-          info: {
-            isAvailable: () => isAvailable,
-            feature: () => ({
-              isEnabled: () => isEnabled
-            })
-          }
-        }
+      info: {
+        isAvailable: () => isAvailable,
+        feature: () => ({
+          isEnabled: () => isEnabled
+        })
       }
     };
   }
 
   describe('isSecurityDisabled', () => {
 
     it('returns not disabled for given mock server object #1', () => {
-      expect(isSecurityDisabled(mockServerFactory())).to.be(false);
+      expect(isSecurityDisabled(mockXpackMainPluginFactory())).to.be(false);
     });
 
     it('returns not disabled for given mock server object #2', () => {
-      expect(isSecurityDisabled(mockServerFactory(false))).to.be(false);
+      expect(isSecurityDisabled(mockXpackMainPluginFactory(false))).to.be(false);
     });
 
     it('returns disabled for given mock server object #3', () => {
-      expect(isSecurityDisabled(mockServerFactory(true, false))).to.be(true);
+      expect(isSecurityDisabled(mockXpackMainPluginFactory(true, false))).to.be(true);
     });
 
   });