New Platform and Legacy platform servers integration

docs/development/core/server/kibana-plugin-server.httpservicestart.islistening.md

@@ -4,10 +4,10 @@
 
 ## HttpServiceStart.isListening property
 
-Indicates if http server is listening on a port
+Indicates if http server is listening on a given port
 
 <b>Signature:</b>
 
 ```typescript
-isListening: () => boolean;
+isListening: (port: number) => boolean;
 ```

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

@@ -15,5 +15,5 @@ export interface HttpServiceStart
 
 |  Property | Type | Description |
 |  --- | --- | --- |
-|  [isListening](./kibana-plugin-server.httpservicestart.islistening.md) | <code>() =&gt; boolean</code> | Indicates if http server is listening on a port |
+|  [isListening](./kibana-plugin-server.httpservicestart.islistening.md) | <code>(port: number) =&gt; boolean</code> | Indicates if http server is listening on a given port |
 

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

@@ -15,6 +15,5 @@ export interface InternalCoreStart
 
 |  Property | Type | Description |
 |  --- | --- | --- |
-|  [http](./kibana-plugin-server.internalcorestart.http.md) | <code>HttpServiceStart</code> |  |
 |  [plugins](./kibana-plugin-server.internalcorestart.plugins.md) | <code>PluginsServiceStart</code> |  |
 

packages/kbn-test/src/functional_tests/lib/run_kibana_server.js

@@ -31,7 +31,7 @@ export async function runKibanaServer({ procs, config, options }) {
       ...process.env,
     },
     cwd: installDir || KIBANA_ROOT,
-    wait: /Server running/,
+    wait: /http server running/,
   });
 }
 

src/cli/serve/integration_tests/reload_logging_config.test.js

@@ -181,7 +181,7 @@ describe('Server logging configuration', function () {
         '--logging.json', 'false'
       ]);
 
-      watchFileUntil(logPath, /Server running at/, 2 * minute)
+      watchFileUntil(logPath, /http server running/, 2 * minute)
         .then(() => {
           // once the server is running, archive the log file and issue SIGHUP
           fs.renameSync(logPath, logPathArchived);

src/core/server/http/http_server.test.ts

@@ -62,6 +62,13 @@ test('listening after started', async () => {
   await server.start();
 
   expect(server.isListening()).toBe(true);
+  expect(loggingServiceMock.collect(logger).info).toMatchInlineSnapshot(`
+Array [
+  Array [
+    "http server running",
+  ],
+]
+`);
 });
 
 test('200 OK with body', async () => {
@@ -580,11 +587,10 @@ test('returns server and connection options on start', async () => {
     ...config,
     port: 12345,
   };
-  const { options, server: innerServer } = await server.setup(configWithPort);
+  const { server: innerServer } = await server.setup(configWithPort);
 
   expect(innerServer).toBeDefined();
   expect(innerServer).toBe((server as any).server);
-  expect(options).toMatchSnapshot();
 });
 
 test('registers registerOnPostAuth interceptor several times', async () => {

src/core/server/http/http_server.ts

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { Request, Server, ServerOptions } from 'hapi';
+import { Request, Server } from 'hapi';
 
 import { Logger } from '../logging';
 import { HttpConfig } from './http_config';
@@ -37,7 +37,6 @@ import { BasePath } from './base_path_service';
 
 export interface HttpServerSetup {
   server: Server;
-  options: ServerOptions;
   registerRouter: (router: Router) => void;
   /**
    * To define custom authentication and/or authorization mechanism for incoming requests.
@@ -114,7 +113,6 @@ export class HttpServer {
     this.setupBasePathRewrite(config, basePathService);
 
     return {
-      options: serverOptions,
       registerRouter: this.registerRouter.bind(this),
       registerOnPreAuth: this.registerOnPreAuth.bind(this),
       registerOnPostAuth: this.registerOnPostAuth.bind(this),
@@ -156,7 +154,8 @@ export class HttpServer {
 
     await this.server.start();
     const serverPath = this.config!.rewriteBasePath || this.config!.basePath || '';
-    this.log.debug(`http server running at ${this.server.info.uri}${serverPath}`);
+    this.log.info('http server running');
+    this.log.debug(`http server listening on ${this.server.info.uri}${serverPath}`);
   }
 
   public async stop() {
@@ -231,6 +230,9 @@ export class HttpServer {
       authenticate: adoptToHapiAuthFormat(fn, (req, { state, headers }) => {
         this.authState.set(req, state);
         this.authHeaders.set(req, headers);
+        // we mutate headers only for the backward compatibility with the legacy platform.
+        // where some plugin read directly from headers to identify whether a user is authenticated.
+        Object.assign(req.headers, headers);
       }),
     }));
     this.server.auth.strategy('session', 'login');

src/core/server/http/http_service.mock.ts

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { Server, ServerOptions } from 'hapi';
+import { Server } from 'hapi';
 import { HttpService } from './http_service';
 import { HttpServerSetup } from './http_server';
 import { HttpServiceSetup } from './http_service';
@@ -27,7 +27,6 @@ type ServiceSetupMockType = jest.Mocked<HttpServiceSetup> & {
 };
 const createSetupContractMock = () => {
   const setupContract: ServiceSetupMockType = {
-    options: ({} as unknown) as ServerOptions,
     // we can mock some hapi server method when we need it
     server: {} as Server,
     registerOnPreAuth: jest.fn(),

src/core/server/http/http_service.test.ts

@@ -23,6 +23,7 @@ import { noop } from 'lodash';
 import { BehaviorSubject } from 'rxjs';
 import { HttpService, Router } from '.';
 import { HttpConfigType, config } from './http_config';
+import { httpServerMock } from './http_server.mocks';
 import { Config, ConfigService, Env, ObjectToConfigAdapter } from '../config';
 import { loggingServiceMock } from '../logging/logging_service.mock';
 import { getEnvOptions } from '../config/__mocks__/env';
@@ -43,6 +44,11 @@ const createConfigService = (value: Partial<HttpConfigType> = {}) => {
   configService.setSchema(config.path, config.schema);
   return configService;
 };
+const fakeHapiServer = {
+  start: noop,
+  stop: noop,
+  route: noop,
+};
 
 afterEach(() => {
   jest.clearAllMocks();
@@ -56,9 +62,9 @@ test('creates and sets up http server', async () => {
 
   const httpServer = {
     isListening: () => false,
-    setup: jest.fn(),
+    setup: jest.fn().mockReturnValue({ server: fakeHapiServer }),
     start: jest.fn(),
-    stop: noop,
+    stop: jest.fn(),
   };
   mockHttpServer.mockImplementation(() => httpServer);
 
@@ -69,11 +75,62 @@ test('creates and sets up http server', async () => {
   expect(httpServer.setup).not.toHaveBeenCalled();
 
   await service.setup();
-  expect(httpServer.setup).toHaveBeenCalledTimes(1);
+  expect(httpServer.setup).toHaveBeenCalled();
   expect(httpServer.start).not.toHaveBeenCalled();
 
   await service.start();
-  expect(httpServer.start).toHaveBeenCalledTimes(1);
+  expect(httpServer.start).toHaveBeenCalled();
+});
+
+test('spins up notReady server until started if configured with `autoListen:true`', async () => {
+  const configService = createConfigService();
+  const httpServer = {
+    isListening: () => false,
+    setup: jest.fn(),
+    start: jest.fn(),
+    stop: jest.fn(),
+  };
+  const notReadyHapiServer = {
+    start: jest.fn(),
+    stop: jest.fn(),
+    route: jest.fn(),
+  };
+
+  mockHttpServer
+    .mockImplementationOnce(() => httpServer)
+    .mockImplementationOnce(() => ({
+      setup: () => ({ server: notReadyHapiServer }),
+    }));
+
+  const service = new HttpService({
+    configService,
+    env: new Env('.', getEnvOptions()),
+    logger,
+  });
+
+  await service.setup();
+
+  const mockResponse: any = {
+    code: jest.fn().mockImplementation(() => mockResponse),
+    header: jest.fn().mockImplementation(() => mockResponse),
+  };
+  const mockResponseToolkit = {
+    response: jest.fn().mockReturnValue(mockResponse),
+  };
+
+  const [[{ handler }]] = notReadyHapiServer.route.mock.calls;
+  const response503 = await handler(httpServerMock.createRawRequest(), mockResponseToolkit);
+  expect(response503).toBe(mockResponse);
+  expect({
+    body: mockResponseToolkit.response.mock.calls,
+    code: mockResponse.code.mock.calls,
+    header: mockResponse.header.mock.calls,
+  }).toMatchSnapshot('503 response');
+
+  await service.start();
+
+  expect(httpServer.start).toBeCalledTimes(1);
+  expect(notReadyHapiServer.stop).toBeCalledTimes(1);
 });
 
 // this is an integration test!
@@ -121,7 +178,7 @@ test('logs error if already set up', async () => {
 
   const httpServer = {
     isListening: () => true,
-    setup: jest.fn(),
+    setup: jest.fn().mockReturnValue({ server: fakeHapiServer }),
     start: noop,
     stop: noop,
   };
@@ -139,7 +196,7 @@ test('stops http server', async () => {
 
   const httpServer = {
     isListening: () => false,
-    setup: noop,
+    setup: jest.fn().mockReturnValue({ server: fakeHapiServer }),
     start: noop,
     stop: jest.fn(),
   };
@@ -157,13 +214,39 @@ test('stops http server', async () => {
   expect(httpServer.stop).toHaveBeenCalledTimes(1);
 });
 
+test('stops not ready server if it is running', async () => {
+  const configService = createConfigService();
+  const mockHapiServer = {
+    start: jest.fn(),
+    stop: jest.fn(),
+    route: jest.fn(),
+  };
+  const httpServer = {
+    isListening: () => false,
+    setup: jest.fn().mockReturnValue({ server: mockHapiServer }),
+    start: noop,
+    stop: jest.fn(),
+  };
+  mockHttpServer.mockImplementation(() => httpServer);
+
+  const service = new HttpService({ configService, env, logger });
+
+  await service.setup();
+
+  await service.stop();
+
+  expect(mockHapiServer.stop).toHaveBeenCalledTimes(1);
+});
+
 test('register route handler', async () => {
   const configService = createConfigService();
 
   const registerRouterMock = jest.fn();
   const httpServer = {
     isListening: () => false,
-    setup: () => ({ registerRouter: registerRouterMock }),
+    setup: jest
+      .fn()
+      .mockReturnValue({ server: fakeHapiServer, registerRouter: registerRouterMock }),
     start: noop,
     stop: noop,
   };
@@ -181,10 +264,7 @@ test('register route handler', async () => {
 
 test('returns http server contract on setup', async () => {
   const configService = createConfigService();
-  const httpServer = {
-    server: {},
-    options: { someOption: true },
-  };
+  const httpServer = { server: fakeHapiServer, options: { someOption: true } };
 
   mockHttpServer.mockImplementation(() => ({
     isListening: () => false,