Move BasePathProxy to new platform.

Author: azasypkin

package.json

@@ -130,6 +130,7 @@
     "glob-all": "3.0.1",
     "good-squeeze": "2.1.0",
     "h2o2": "5.1.1",
+    "h2o2-latest": "npm:[email protected]",
     "handlebars": "4.0.5",
     "hapi": "14.2.0",
     "hapi-latest": "npm:[email protected]",

src/cli/cluster/base_path_proxy.js

@@ -18,123 +18,47 @@
  */
 
 import { Server } from 'hapi';
-import { notFound } from 'boom';
-import { map, sample } from 'lodash';
-import { map as promiseMap, fromNode } from 'bluebird';
-import { Agent as HttpsAgent } from 'https';
-import { readFileSync } from 'fs';
-
-import { setupConnection } from '../../server/http/setup_connection';
-import { registerHapiPlugins } from '../../server/http/register_hapi_plugins';
+import { createBasePathProxy } from '../../core';
 import { setupLogging } from '../../server/logging';
 
-const alphabet = 'abcdefghijklmnopqrztuvwxyz'.split('');
+export async function configureBasePathProxy(config) {
+  // New platform forwards all logs to the legacy platform so we need HapiJS server
+  // here just for logging purposes and nothing else.
+  const server = new Server();
+  setupLogging(server, config);
+
+  const basePathProxy = createBasePathProxy({ server, config });
+
+  await basePathProxy.configure({
+    isKibanaPath: (path) => {
+      const isApp = path.startsWith('app/');
+      const isKnownShortPath = ['login', 'logout', 'status'].includes(path);
+
+      return isApp || isKnownShortPath;
+    },
+
+    blockUntil: () => {
+      // Wait until `serverWorker either crashes or starts to listen.
+      // The `serverWorker` property should be set by the ClusterManager
+      // once it creates the worker.
+      const serverWorker = basePathProxy.serverWorker;
+      if (serverWorker.listening || serverWorker.crashed) {
+        return Promise.resolve();
+      }
 
-export default class BasePathProxy {
-  constructor(clusterManager, config) {
-    this.clusterManager = clusterManager;
-    this.server = new Server();
+      return new Promise((resolve) => {
+        const done = () => {
+          serverWorker.removeListener('listening', done);
+          serverWorker.removeListener('crashed', done);
 
-    this.targetPort = config.get('dev.basePathProxyTarget');
-    this.basePath = config.get('server.basePath');
+          resolve();
+        };
 
-    const sslEnabled = config.get('server.ssl.enabled');
-    if (sslEnabled) {
-      this.proxyAgent = new HttpsAgent({
-        key: readFileSync(config.get('server.ssl.key')),
-        passphrase: config.get('server.ssl.keyPassphrase'),
-        cert: readFileSync(config.get('server.ssl.certificate')),
-        ca: map(config.get('server.ssl.certificateAuthorities'), readFileSync),
-        rejectUnauthorized: false
+        serverWorker.on('listening', done);
+        serverWorker.on('crashed', done);
       });
     }
+  });
 
-    if (!this.basePath) {
-      this.basePath = `/${sample(alphabet, 3).join('')}`;
-      config.set('server.basePath', this.basePath);
-    }
-
-    const ONE_GIGABYTE = 1024 * 1024 * 1024;
-    config.set('server.maxPayloadBytes', ONE_GIGABYTE);
-
-    setupLogging(this.server, config);
-    setupConnection(this.server, config);
-    registerHapiPlugins(this.server, config);
-
-    this.setupRoutes();
-  }
-
-  setupRoutes() {
-    const { clusterManager, server, basePath, targetPort } = this;
-
-    server.route({
-      method: 'GET',
-      path: '/',
-      handler(req, reply) {
-        return reply.redirect(basePath);
-      }
-    });
-
-    server.route({
-      method: '*',
-      path: `${basePath}/{kbnPath*}`,
-      config: {
-        pre: [
-          (req, reply) => {
-            promiseMap(clusterManager.workers, worker => {
-              if (worker.type === 'server' && !worker.listening && !worker.crashed) {
-                return fromNode(cb => {
-                  const done = () => {
-                    worker.removeListener('listening', done);
-                    worker.removeListener('crashed', done);
-                    cb();
-                  };
-
-                  worker.on('listening', done);
-                  worker.on('crashed', done);
-                });
-              }
-            })
-              .return(undefined)
-              .nodeify(reply);
-          }
-        ],
-      },
-      handler: {
-        proxy: {
-          passThrough: true,
-          xforward: true,
-          agent: this.proxyAgent,
-          protocol: server.info.protocol,
-          host: server.info.host,
-          port: targetPort,
-        }
-      }
-    });
-
-    server.route({
-      method: '*',
-      path: `/{oldBasePath}/{kbnPath*}`,
-      handler(req, reply) {
-        const { oldBasePath, kbnPath = '' } = req.params;
-
-        const isGet = req.method === 'get';
-        const isBasePath = oldBasePath.length === 3;
-        const isApp = kbnPath.startsWith('app/');
-        const isKnownShortPath = ['login', 'logout', 'status'].includes(kbnPath);
-
-        if (isGet && isBasePath && (isApp || isKnownShortPath)) {
-          return reply.redirect(`${basePath}/${kbnPath}`);
-        }
-
-        return reply(notFound());
-      }
-    });
-  }
-
-  async listen() {
-    await fromNode(cb => this.server.start(cb));
-    this.server.log(['listening', 'info'], `basePath Proxy running at ${this.server.info.uri}${this.basePath}`);
-  }
-
+  return basePathProxy;
 }

src/cli/cluster/cluster_manager.js

@@ -22,9 +22,9 @@ import { debounce, invoke, bindAll, once, uniq } from 'lodash';
 
 import Log from '../log';
 import Worker from './worker';
-import BasePathProxy from './base_path_proxy';
 import { Config } from '../../server/config/config';
 import { transformDeprecations } from '../../server/config/transform_deprecations';
+import { configureBasePathProxy } from './base_path_proxy';
 
 process.env.kbnWorkerType = 'managr';
 
@@ -33,10 +33,14 @@ export default class ClusterManager {
     const transformedSettings = transformDeprecations(settings);
     const config = await Config.withDefaultSchema(transformedSettings);
 
-    return new ClusterManager(opts, config);
+    const basePathProxy = opts.basePath
+      ? await configureBasePathProxy(config)
+      : undefined;
+
+    return new ClusterManager(opts, config, basePathProxy);
   }
 
-  constructor(opts, config) {
+  constructor(opts, config, basePathProxy) {
     this.log = new Log(opts.quiet, opts.silent);
     this.addedCount = 0;
     this.inReplMode = !!opts.repl;
@@ -47,8 +51,8 @@ export default class ClusterManager {
       '--server.autoListen=false',
     ];
 
-    if (opts.basePath) {
-      this.basePathProxy = new BasePathProxy(this, config);
+    if (basePathProxy) {
+      this.basePathProxy = basePathProxy;
 
       optimizerArgv.push(
         `--server.basePath=${this.basePathProxy.basePath}`,
@@ -78,6 +82,10 @@ export default class ClusterManager {
       })
     ];
 
+    // Pass server worker to the basepath proxy so that it can hold off the
+    // proxying until server worker is ready.
+    this.basePathProxy.serverWorker = this.server;
+
     // broker messages between workers
     this.workers.forEach((worker) => {
       worker.on('broadcast', (msg) => {
@@ -120,7 +128,7 @@ export default class ClusterManager {
     this.setupManualRestart();
     invoke(this.workers, 'start');
     if (this.basePathProxy) {
-      this.basePathProxy.listen();
+      this.basePathProxy.start();
     }
   }
 

src/core/index.ts

@@ -17,4 +17,7 @@
  * under the License.
  */
 
-export { injectIntoKbnServer } from './server/legacy_compat';
+export {
+  injectIntoKbnServer,
+  createBasePathProxy,
+} from './server/legacy_compat';

src/core/server/dev/dev_config.ts

@@ -0,0 +1,44 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { schema, TypeOf } from '../config/schema';
+
+const createDevSchema = schema.object({
+  basePathProxyTarget: schema.number({
+    defaultValue: 5603,
+  }),
+});
+
+type DevConfigType = TypeOf<typeof createDevSchema>;
+
+export class DevConfig {
+  /**
+   * @internal
+   */
+  public static schema = createDevSchema;
+
+  public basePathProxyTargetPort: number;
+
+  /**
+   * @internal
+   */
+  constructor(config: DevConfigType) {
+    this.basePathProxyTargetPort = config.basePathProxyTarget;
+  }
+}

src/core/server/dev/index.ts

@@ -0,0 +1,20 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export { DevConfig } from './dev_config';