Allow optional OSS to X-Pack dependencies

.eslintrc.js

@@ -470,11 +470,6 @@ module.exports = {
                 errorMessage:
                   'Server modules cannot be imported into client modules or shared modules.',
               },
-              {
-                target: ['src/**/*'],
-                from: ['x-pack/**/*'],
-                errorMessage: 'OSS cannot import x-pack files.',
-              },
               {
                 target: ['src/core/**/*'],
                 from: ['plugins/**/*', 'src/plugins/**/*'],

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

@@ -52,6 +52,21 @@ expect.addSnapshotSerializer(createAbsolutePathSerializer());
   });
 });
 
+const OSS_PLUGIN_PATH_POSIX = '/kibana/src/plugins/ossPlugin';
+const OSS_PLUGIN_PATH_WINDOWS = 'C:\\kibana\\src\\plugins\\ossPlugin';
+const XPACK_PLUGIN_PATH_POSIX = '/kibana/x-pack/plugins/xPackPlugin';
+const XPACK_PLUGIN_PATH_WINDOWS = 'C:\\kibana\\x-pack\\plugins\\xPackPlugin';
+[
+  OSS_PLUGIN_PATH_POSIX,
+  OSS_PLUGIN_PATH_WINDOWS,
+  XPACK_PLUGIN_PATH_POSIX,
+  XPACK_PLUGIN_PATH_WINDOWS,
+].forEach((path) => {
+  jest.doMock(join(path, 'server'), () => ({}), {
+    virtual: true,
+  });
+});
+
 const createPlugin = (
   id: string,
   {
@@ -247,6 +262,112 @@ describe('PluginsService', () => {
       expect(standardMockPluginSystem.setupPlugins).not.toHaveBeenCalled();
     });
 
+    describe('OSS to X-Pack dependencies', () => {
+      function mockDiscoveryResults({
+        ossPath,
+        xPackPath,
+        dependency,
+      }: {
+        ossPath: string;
+        xPackPath: string;
+        dependency: 'requiredPlugin' | 'requiredBundle' | 'optionalPlugin';
+      }) {
+        mockDiscover.mockReturnValue({
+          error$: from([]),
+          plugin$: from([
+            createPlugin('ossPlugin', {
+              path: ossPath,
+              version: 'some-version',
+              configPath: 'path',
+              requiredPlugins: dependency === 'requiredPlugin' ? ['xPackPlugin'] : [],
+              requiredBundles: dependency === 'requiredBundle' ? ['xPackPlugin'] : undefined,
+              optionalPlugins: dependency === 'optionalPlugin' ? ['xPackPlugin'] : [],
+            }),
+            createPlugin('xPackPlugin', {
+              path: xPackPath,
+              version: 'some-version',
+              configPath: 'path',
+              requiredPlugins: [],
+              optionalPlugins: [],
+            }),
+          ]),
+        });
+      }
+
+      async function expectError() {
+        await expect(pluginsService.discover({ environment: environmentPreboot })).rejects.toThrow(
+          `X-Pack plugin or bundle with id "xPackPlugin" is required by OSS plugin "ossPlugin", which is prohibited.`
+        );
+        expect(standardMockPluginSystem.addPlugin).not.toHaveBeenCalled();
+      }
+      async function expectSuccess() {
+        await expect(pluginsService.discover({ environment: environmentPreboot })).resolves.toEqual(
+          expect.anything()
+        );
+        expect(standardMockPluginSystem.addPlugin).toHaveBeenCalledTimes(2);
+      }
+
+      describe('throws if an OSS plugin requires an X-Pack plugin', () => {
+        it('in POSIX', async () => {
+          mockDiscoveryResults({
+            ossPath: OSS_PLUGIN_PATH_POSIX,
+            xPackPath: XPACK_PLUGIN_PATH_POSIX,
+            dependency: 'requiredPlugin',
+          });
+          await expectError();
+        });
+
+        it('in Windows', async () => {
+          mockDiscoveryResults({
+            ossPath: OSS_PLUGIN_PATH_WINDOWS,
+            xPackPath: XPACK_PLUGIN_PATH_WINDOWS,
+            dependency: 'requiredPlugin',
+          });
+          await expectError();
+        });
+      });
+
+      describe('throws if an OSS plugin requires an X-Pack bundle', () => {
+        it('in POSIX', async () => {
+          mockDiscoveryResults({
+            ossPath: OSS_PLUGIN_PATH_POSIX,
+            xPackPath: XPACK_PLUGIN_PATH_POSIX,
+            dependency: 'requiredBundle',
+          });
+          await expectError();
+        });
+
+        it('in Windows', async () => {
+          mockDiscoveryResults({
+            ossPath: OSS_PLUGIN_PATH_WINDOWS,
+            xPackPath: XPACK_PLUGIN_PATH_WINDOWS,
+            dependency: 'requiredBundle',
+          });
+          await expectError();
+        });
+      });
+
+      describe('does not throw if an OSS plugin has an optional dependency on an X-Pack plugin', () => {
+        it('in POSIX', async () => {
+          mockDiscoveryResults({
+            ossPath: OSS_PLUGIN_PATH_POSIX,
+            xPackPath: XPACK_PLUGIN_PATH_POSIX,
+            dependency: 'optionalPlugin',
+          });
+          await expectSuccess();
+        });
+
+        it('in Windows', async () => {
+          mockDiscoveryResults({
+            ossPath: OSS_PLUGIN_PATH_WINDOWS,
+            xPackPath: XPACK_PLUGIN_PATH_WINDOWS,
+            dependency: 'optionalPlugin',
+          });
+          await expectSuccess();
+        });
+      });
+    });
+
     it('properly detects plugins that should be disabled.', async () => {
       jest
         .spyOn(configService, 'isEnabledAtPath')

src/core/server/plugins/plugins_service.ts

@@ -86,6 +86,9 @@ export interface PluginsServiceDiscoverDeps {
   environment: InternalEnvironmentServicePreboot;
 }
 
+const OSS_PATH_REGEX = /[\/|\\]src[\/|\\]plugins[\/|\\]/; // Matches src/plugins directory on POSIX and Windows
+const XPACK_PATH_REGEX = /[\/|\\]x-pack[\/|\\]plugins[\/|\\]/; // Matches x-pack/plugins directory on POSIX and Windows
+
 /** @internal */
 export class PluginsService implements CoreService<PluginsServiceSetup, PluginsServiceStart> {
   private readonly log: Logger;
@@ -336,6 +339,18 @@ export class PluginsService implements CoreService<PluginsServiceSetup, PluginsS
         }
       }
 
+      // validate that OSS plugins do not have required dependencies on X-Pack plugins
+      if (OSS_PATH_REGEX.test(plugin.path)) {
+        for (const id of [...plugin.requiredPlugins, ...plugin.requiredBundles]) {
+          const requiredPlugin = pluginEnableStatuses.get(id);
+          if (requiredPlugin && XPACK_PATH_REGEX.test(requiredPlugin.plugin.path)) {
+            throw new Error(
+              `X-Pack plugin or bundle with id "${id}" is required by OSS plugin "${pluginName}", which is prohibited.`
+            );
+          }
+        }
+      }
+
       const pluginEnablement = this.shouldEnablePlugin(pluginName, pluginEnableStatuses);
 
       if (pluginEnablement.enabled) {