Merge branch 'master' into newplatform/query-string-input/cleanup

.ci/Jenkinsfile_flaky

@@ -3,10 +3,13 @@
 library 'kibana-pipeline-library'
 kibanaLibrary.load()
 
-// Looks like 'oss:ciGroup:1' or 'oss:firefoxSmoke'
-def JOB_PARTS = params.CI_GROUP.split(':')
+def CI_GROUP_PARAM = params.CI_GROUP
+
+// Looks like 'oss:ciGroup:1', 'oss:firefoxSmoke', or 'all:serverMocha'
+def JOB_PARTS = CI_GROUP_PARAM.split(':')
 def IS_XPACK = JOB_PARTS[0] == 'xpack'
 def JOB = JOB_PARTS[1]
+def NEED_BUILD = JOB != 'serverMocha'
 def CI_GROUP = JOB_PARTS.size() > 2 ? JOB_PARTS[2] : ''
 def EXECUTIONS = params.NUMBER_EXECUTIONS.toInteger()
 def AGENT_COUNT = getAgentCount(EXECUTIONS)
@@ -31,13 +34,15 @@ stage("Kibana Pipeline") {
               print "Agent ${agentNumberInside} - ${agentExecutions} executions"
 
               kibanaPipeline.withWorkers('flaky-test-runner', {
-                if (!IS_XPACK) {
-                  kibanaPipeline.buildOss()
-                  if (CI_GROUP == '1') {
-                    runbld("./test/scripts/jenkins_build_kbn_tp_sample_panel_action.sh", "Build kbn tp sample panel action for ciGroup1")
+                if (NEED_BUILD) {
+                  if (!IS_XPACK) {
+                    kibanaPipeline.buildOss()
+                    if (CI_GROUP == '1') {
+                      runbld("./test/scripts/jenkins_build_kbn_tp_sample_panel_action.sh", "Build kbn tp sample panel action for ciGroup1")
+                    }
+                  } else {
+                    kibanaPipeline.buildXpack()
                   }
-                } else {
-                  kibanaPipeline.buildXpack()
                 }
               }, getWorkerMap(agentNumberInside, agentExecutions, worker, workerFailures))()
             }
@@ -61,7 +66,17 @@ stage("Kibana Pipeline") {
 
 def getWorkerFromParams(isXpack, job, ciGroup) {
   if (!isXpack) {
-    if (job == 'firefoxSmoke') {
+    if (job == 'serverMocha') {
+      return kibanaPipeline.getPostBuildWorker('serverMocha', {
+        kibanaPipeline.bash(
+          """
+            source src/dev/ci_setup/setup_env.sh
+            node scripts/mocha
+          """,
+          "run `node scripts/mocha`"
+        )
+      })
+    } else if (job == 'firefoxSmoke') {
       return kibanaPipeline.getPostBuildWorker('firefoxSmoke', { runbld('./test/scripts/jenkins_firefox_smoke.sh', 'Execute kibana-firefoxSmoke') })
     } else if(job == 'visualRegression') {
       return kibanaPipeline.getPostBuildWorker('visualRegression', { runbld('./test/scripts/jenkins_visual_regression.sh', 'Execute kibana-visualRegression') })

docs/development/core/server/kibana-plugin-server.pluginsservicesetup.md

@@ -16,6 +16,5 @@ export interface PluginsServiceSetup
 |  Property | Type | Description |
 |  --- | --- | --- |
 |  [contracts](./kibana-plugin-server.pluginsservicesetup.contracts.md) | <code>Map&lt;PluginName, unknown&gt;</code> |  |
-|  [uiPluginConfigs](./kibana-plugin-server.pluginsservicesetup.uipluginconfigs.md) | <code>Map&lt;PluginName, Observable&lt;unknown&gt;&gt;</code> |  |
-|  [uiPlugins](./kibana-plugin-server.pluginsservicesetup.uiplugins.md) | <code>{</code><br/><code>        public: Map&lt;PluginName, DiscoveredPlugin&gt;;</code><br/><code>        internal: Map&lt;PluginName, DiscoveredPluginInternal&gt;;</code><br/><code>    }</code> |  |
+|  [uiPlugins](./kibana-plugin-server.pluginsservicesetup.uiplugins.md) | <code>{</code><br/><code>        internal: Map&lt;PluginName, InternalPluginInfo&gt;;</code><br/><code>        public: Map&lt;PluginName, DiscoveredPlugin&gt;;</code><br/><code>        browserConfigs: Map&lt;PluginName, Observable&lt;unknown&gt;&gt;;</code><br/><code>    }</code> |  |
 

docs/development/core/server/kibana-plugin-server.pluginsservicesetup.uiplugins.md

@@ -8,7 +8,8 @@
 
 ```typescript
 uiPlugins: {
+        internal: Map<PluginName, InternalPluginInfo>;
         public: Map<PluginName, DiscoveredPlugin>;
-        internal: Map<PluginName, DiscoveredPluginInternal>;
+        browserConfigs: Map<PluginName, Observable<unknown>>;
     };
 ```

src/core/server/legacy/legacy_service.test.ts

@@ -41,7 +41,7 @@ import { configServiceMock } from '../config/config_service.mock';
 
 import { BasePathProxyServer } from '../http';
 import { loggingServiceMock } from '../logging/logging_service.mock';
-import { DiscoveredPlugin, DiscoveredPluginInternal } from '../plugins';
+import { DiscoveredPlugin } from '../plugins';
 
 import { KibanaMigrator } from '../saved_objects/migrations';
 import { ISavedObjectsClientProvider } from '../saved_objects';
@@ -84,9 +84,9 @@ beforeEach(() => {
         contracts: new Map([['plugin-id', 'plugin-value']]),
         uiPlugins: {
           public: new Map([['plugin-id', {} as DiscoveredPlugin]]),
-          internal: new Map([['plugin-id', {} as DiscoveredPluginInternal]]),
+          internal: new Map([['plugin-id', { entryPointPath: 'path/to/plugin/public' }]]),
+          browserConfigs: new Map(),
         },
-        uiPluginConfigs: new Map(),
       },
     },
     plugins: { 'plugin-id': 'plugin-value' },

src/core/server/legacy/legacy_service.ts

@@ -278,7 +278,6 @@ export class LegacyService implements CoreService<LegacyServiceSetup> {
           hapiServer: setupDeps.core.http.server,
           kibanaMigrator: startDeps.core.savedObjects.migrator,
           uiPlugins: setupDeps.core.plugins.uiPlugins,
-          uiPluginConfigs: setupDeps.core.plugins.uiPluginConfigs,
           elasticsearch: setupDeps.core.elasticsearch,
           uiSettings: setupDeps.core.uiSettings,
           savedObjectsClientProvider: startDeps.core.savedObjects.clientProvider,

src/core/server/plugins/plugins_service.mock.ts

@@ -30,10 +30,10 @@ const createServiceMock = () => {
   mocked.setup.mockResolvedValue({
     contracts: new Map(),
     uiPlugins: {
-      public: new Map(),
+      browserConfigs: new Map(),
       internal: new Map(),
+      public: new Map(),
     },
-    uiPluginConfigs: new Map(),
   });
   mocked.start.mockResolvedValue({ contracts: new Map() });
   return mocked;

src/core/server/plugins/plugins_service.test.ts

@@ -33,11 +33,12 @@ import { PluginsService } from './plugins_service';
 import { PluginsSystem } from './plugins_system';
 import { config } from './plugins_config';
 import { take } from 'rxjs/operators';
-import { DiscoveredPluginInternal } from './types';
+import { DiscoveredPlugin } from './types';
 
 const MockPluginsSystem: jest.Mock<PluginsSystem> = PluginsSystem as any;
 
 let pluginsService: PluginsService;
+let config$: BehaviorSubject<Config>;
 let configService: ConfigService;
 let coreId: symbol;
 let env: Env;
@@ -107,11 +108,10 @@ describe('PluginsService', () => {
     coreId = Symbol('core');
     env = Env.createDefault(getEnvOptions());
 
-    configService = new ConfigService(
-      new BehaviorSubject<Config>(new ObjectToConfigAdapter({ plugins: { initialize: true } })),
-      env,
-      logger
+    config$ = new BehaviorSubject<Config>(
+      new ObjectToConfigAdapter({ plugins: { initialize: true } })
     );
+    configService = new ConfigService(config$, env, logger);
     await configService.setSchema(config.path, config.schema);
     pluginsService = new PluginsService({ coreId, env, logger, configService });
 
@@ -198,7 +198,7 @@ describe('PluginsService', () => {
         .mockImplementation(path => Promise.resolve(!path.includes('disabled')));
 
       mockPluginSystem.setupPlugins.mockResolvedValue(new Map());
-      mockPluginSystem.uiPlugins.mockReturnValue({ public: new Map(), internal: new Map() });
+      mockPluginSystem.uiPlugins.mockReturnValue(new Map());
 
       mockDiscover.mockReturnValue({
         error$: from([]),
@@ -390,11 +390,10 @@ describe('PluginsService', () => {
   });
 
   describe('#generateUiPluginsConfigs()', () => {
-    const pluginToDiscoveredEntry = (plugin: PluginWrapper): [string, DiscoveredPluginInternal] => [
+    const pluginToDiscoveredEntry = (plugin: PluginWrapper): [string, DiscoveredPlugin] => [
       plugin.name,
       {
         id: plugin.name,
-        path: plugin.path,
         configPath: plugin.manifest.configPath,
         requiredPlugins: [],
         optionalPlugins: [],
@@ -427,15 +426,14 @@ describe('PluginsService', () => {
         error$: from([]),
         plugin$: from([plugin]),
       });
-      mockPluginSystem.uiPlugins.mockReturnValue({
-        public: new Map([pluginToDiscoveredEntry(plugin)]),
-        internal: new Map([pluginToDiscoveredEntry(plugin)]),
-      });
+      mockPluginSystem.uiPlugins.mockReturnValue(new Map([pluginToDiscoveredEntry(plugin)]));
 
       await pluginsService.discover();
-      const { uiPluginConfigs } = await pluginsService.setup(setupDeps);
+      const {
+        uiPlugins: { browserConfigs },
+      } = await pluginsService.setup(setupDeps);
 
-      const uiConfig$ = uiPluginConfigs.get('plugin-with-expose');
+      const uiConfig$ = browserConfigs.get('plugin-with-expose');
       expect(uiConfig$).toBeDefined();
 
       const uiConfig = await uiConfig$!.pipe(take(1)).toPromise();
@@ -468,15 +466,55 @@ describe('PluginsService', () => {
         error$: from([]),
         plugin$: from([plugin]),
       });
-      mockPluginSystem.uiPlugins.mockReturnValue({
-        public: new Map([pluginToDiscoveredEntry(plugin)]),
-        internal: new Map([pluginToDiscoveredEntry(plugin)]),
-      });
+      mockPluginSystem.uiPlugins.mockReturnValue(new Map([pluginToDiscoveredEntry(plugin)]));
 
       await pluginsService.discover();
-      const { uiPluginConfigs } = await pluginsService.setup(setupDeps);
+      const {
+        uiPlugins: { browserConfigs },
+      } = await pluginsService.setup(setupDeps);
 
-      expect([...uiPluginConfigs.entries()]).toHaveLength(0);
+      expect([...browserConfigs.entries()]).toHaveLength(0);
+    });
+  });
+
+  describe('#setup()', () => {
+    describe('uiPlugins.internal', () => {
+      it('includes disabled plugins', async () => {
+        mockDiscover.mockReturnValue({
+          error$: from([]),
+          plugin$: from([
+            createPlugin('plugin-1', {
+              path: 'path-1',
+              version: 'some-version',
+              configPath: 'plugin1',
+            }),
+            createPlugin('plugin-2', {
+              path: 'path-2',
+              version: 'some-version',
+              configPath: 'plugin2',
+            }),
+          ]),
+        });
+
+        mockPluginSystem.uiPlugins.mockReturnValue(new Map());
+
+        config$.next(
+          new ObjectToConfigAdapter({ plugins: { initialize: true }, plugin1: { enabled: false } })
+        );
+
+        await pluginsService.discover();
+        const { uiPlugins } = await pluginsService.setup({} as any);
+        expect(uiPlugins.internal).toMatchInlineSnapshot(`
+          Map {
+            "plugin-1" => Object {
+              "entryPointPath": "path-1/public",
+            },
+            "plugin-2" => Object {
+              "entryPointPath": "path-2/public",
+            },
+          }
+        `);
+      });
     });
   });
 

src/core/server/plugins/plugins_service.ts

@@ -25,12 +25,7 @@ import { CoreContext } from '../core_context';
 import { Logger } from '../logging';
 import { discover, PluginDiscoveryError, PluginDiscoveryErrorType } from './discovery';
 import { PluginWrapper } from './plugin';
-import {
-  DiscoveredPlugin,
-  DiscoveredPluginInternal,
-  PluginConfigDescriptor,
-  PluginName,
-} from './types';
+import { DiscoveredPlugin, PluginConfigDescriptor, PluginName, InternalPluginInfo } from './types';
 import { PluginsConfig, PluginsConfigType } from './plugins_config';
 import { PluginsSystem } from './plugins_system';
 import { InternalCoreSetup } from '../internal_types';
@@ -41,10 +36,22 @@ import { pick } from '../../utils';
 export interface PluginsServiceSetup {
   contracts: Map<PluginName, unknown>;
   uiPlugins: {
+    /**
+     * Paths to all discovered ui plugin entrypoints on the filesystem, even if
+     * disabled.
+     */
+    internal: Map<PluginName, InternalPluginInfo>;
+
+    /**
+     * Information needed by client-side to load plugins and wire dependencies.
+     */
     public: Map<PluginName, DiscoveredPlugin>;
-    internal: Map<PluginName, DiscoveredPluginInternal>;
+
+    /**
+     * Configuration for plugins to be exposed to the client-side.
+     */
+    browserConfigs: Map<PluginName, Observable<unknown>>;
   };
-  uiPluginConfigs: Map<PluginName, Observable<unknown>>;
 }
 
 /** @public */
@@ -65,6 +72,7 @@ export class PluginsService implements CoreService<PluginsServiceSetup, PluginsS
   private readonly configService: IConfigService;
   private readonly config$: Observable<PluginsConfig>;
   private readonly pluginConfigDescriptors = new Map<PluginName, PluginConfigDescriptor>();
+  private readonly uiPluginInternalInfo = new Map<PluginName, InternalPluginInfo>();
 
   constructor(private readonly coreContext: CoreContext) {
     this.log = coreContext.logger.get('plugins-service');
@@ -103,8 +111,11 @@ export class PluginsService implements CoreService<PluginsServiceSetup, PluginsS
     const uiPlugins = this.pluginsSystem.uiPlugins();
     return {
       contracts,
-      uiPlugins,
-      uiPluginConfigs: this.generateUiPluginsConfigs(uiPlugins.public),
+      uiPlugins: {
+        internal: this.uiPluginInternalInfo,
+        public: uiPlugins,
+        browserConfigs: this.generateUiPluginsConfigs(uiPlugins),
+      },
     };
   }
 
@@ -196,6 +207,10 @@ export class PluginsService implements CoreService<PluginsServiceSetup, PluginsS
             throw new Error(`Plugin with id "${plugin.name}" is already registered!`);
           }
 
+          if (plugin.includesUiPlugin) {
+            this.uiPluginInternalInfo.set(plugin.name, { entryPointPath: `${plugin.path}/public` });
+          }
+
           pluginEnableStatuses.set(plugin.name, { plugin, isEnabled });
         })
       )

src/core/server/plugins/plugins_system.test.ts

@@ -323,13 +323,8 @@ test('`setupPlugins` only setups plugins that have server side', async () => {
   expect(thirdPluginToRun.setup).toHaveBeenCalledTimes(1);
 });
 
-test('`uiPlugins` returns empty Maps before plugins are added', async () => {
-  expect(pluginsSystem.uiPlugins()).toMatchInlineSnapshot(`
-    Object {
-      "internal": Map {},
-      "public": Map {},
-    }
-  `);
+test('`uiPlugins` returns empty Map before plugins are added', async () => {
+  expect(pluginsSystem.uiPlugins()).toMatchInlineSnapshot(`Map {}`);
 });
 
 test('`uiPlugins` returns ordered Maps of all plugin manifests', async () => {
@@ -351,7 +346,7 @@ test('`uiPlugins` returns ordered Maps of all plugin manifests', async () => {
     pluginsSystem.addPlugin(plugin);
   });
 
-  expect([...pluginsSystem.uiPlugins().internal.keys()]).toMatchInlineSnapshot(`
+  expect([...pluginsSystem.uiPlugins().keys()]).toMatchInlineSnapshot(`
     Array [
       "order-0",
       "order-1",
@@ -380,7 +375,7 @@ test('`uiPlugins` returns only ui plugin dependencies', async () => {
     pluginsSystem.addPlugin(plugin);
   });
 
-  const plugin = pluginsSystem.uiPlugins().internal.get('ui-plugin')!;
+  const plugin = pluginsSystem.uiPlugins().get('ui-plugin')!;
   expect(plugin.requiredPlugins).toEqual(['req-ui']);
   expect(plugin.optionalPlugins).toEqual(['opt-ui']);
 });