web/jupyter.js

"use strict";
/*
 * Copyright 2015 Google Inc. All rights reserved.
 *
 * Licensed 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.
 */
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.handleRequest = exports.handleSocket = exports.close = exports.init = void 0;
var childProcess = require("child_process");
var httpProxy = require("http-proxy");
var path = require("path");
var logging = require("./logging");
/**
 * Singleton tracking the jupyter server instance we manage.
 */
var jupyterServer = null;
/**
 * The maximum number of times we'll restart jupyter; we set a limit to avoid
 * users being stuck with a slow-crash-looping server.
 */
var remainingJupyterServerRestarts = 20;
/**
 * The application settings instance.
 */
var appSettings;
/*
 * This list of levels should match the ones used by Python:
 *   https://docs.python.org/3/library/logging.html#logging-levels
 */
var LogLevels;
(function (LogLevels) {
    LogLevels["CRITICAL"] = "CRITICAL";
    LogLevels["ERROR"] = "ERROR";
    LogLevels["WARNING"] = "WARNING";
    LogLevels["INFO"] = "INFO";
    LogLevels["DEBUG"] = "DEBUG";
    LogLevels["NOTSET"] = "NOTSET";
})(LogLevels || (LogLevels = {}));
function pipeOutput(stream) {
    stream.setEncoding('utf8');
    // The format we parse here corresponds to the log format we set in our
    // jupyter configuration.
    var logger = logging.getJupyterLogger();
    stream.on('data', function (data) {
        var e_1, _a;
        try {
            for (var _b = __values(data.split('\n')), _c = _b.next(); !_c.done; _c = _b.next()) {
                var line = _c.value;
                if (line.trim().length === 0) {
                    continue;
                }
                var parts = line.split('|', 3);
                if (parts.length !== 3) {
                    // Non-logging messages (eg tracebacks) get logged as warnings.
                    logger.warn(line);
                    continue;
                }
                var level = parts[1];
                var message = parts[2];
                // We need to map Python's log levels to those used by bunyan.
                if (level === LogLevels.CRITICAL || level === LogLevels.ERROR) {
                    logger.error(message);
                }
                else if (level === LogLevels.WARNING) {
                    logger.warn(message);
                }
                else if (level === LogLevels.INFO) {
                    logger.info(message);
                }
                else {
                    // We map DEBUG, NOTSET, and any unknown log levels to debug.
                    logger.debug(message);
                }
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_1) throw e_1.error; }
        }
    });
}
function createJupyterServer() {
    var e_2, _a;
    if (!remainingJupyterServerRestarts) {
        logging.getLogger().error('No jupyter restart attempts remaining.');
        return;
    }
    remainingJupyterServerRestarts -= 1;
    var port = appSettings.nextJupyterPort;
    logging.getLogger().info('Launching Jupyter server at %d', port);
    var jupyterArgs = appSettings.jupyterArgs || [];
    function exitHandler(code, signal) {
        if (jupyterServer) {
            logging.getLogger().error('Jupyter process %d exited due to signal: %s', jupyterServer.childProcess.pid, signal);
        }
        else {
            logging.getLogger().error('Jupyter process exit before server creation finished due to signal: %s', signal);
        }
        // We want to restart jupyter whenever it terminates.
        createJupyterServer();
    }
    var contentDir = path.join(appSettings.datalabRoot, appSettings.contentDir);
    var processArgs = ['notebook'].concat(jupyterArgs || []).concat([
        "--port=".concat(port),
        "--FileContentsManager.root_dir=".concat(appSettings.datalabRoot, "/"),
        // TODO(b/136659627): Delete this line.
        "--MappingKernelManager.root_dir=".concat(contentDir),
    ]);
    var jupyterServerAddr = 'localhost';
    try {
        for (var jupyterArgs_1 = __values(jupyterArgs), jupyterArgs_1_1 = jupyterArgs_1.next(); !jupyterArgs_1_1.done; jupyterArgs_1_1 = jupyterArgs_1.next()) {
            var flag = jupyterArgs_1_1.value;
            // Extracts a string like '1.2.3.4' from the string '--ip=1.2.3.4'
            var match = flag.match(/--ip=([^ ]+)/);
            if (match) {
                jupyterServerAddr = match[1];
                break;
            }
        }
    }
    catch (e_2_1) { e_2 = { error: e_2_1 }; }
    finally {
        try {
            if (jupyterArgs_1_1 && !jupyterArgs_1_1.done && (_a = jupyterArgs_1.return)) _a.call(jupyterArgs_1);
        }
        finally { if (e_2) throw e_2.error; }
    }
    logging.getLogger().info('Using jupyter server address %s', jupyterServerAddr);
    var processOptions = {
        detached: false,
        env: process.env,
    };
    var serverProcess = childProcess.spawn('jupyter', processArgs, processOptions);
    serverProcess.on('exit', exitHandler);
    logging.getLogger().info('Jupyter process started with pid %d and args %j', serverProcess.pid, processArgs);
    // Capture the output, so it can be piped for logging.
    pipeOutput(serverProcess.stdout);
    pipeOutput(serverProcess.stderr);
    // Create the proxy.
    var proxyTargetHost = appSettings.kernelManagerProxyHost || jupyterServerAddr;
    var proxyTargetPort = appSettings.kernelManagerProxyPort || port;
    var proxy = httpProxy.createProxyServer({ target: "http://".concat(proxyTargetHost, ":").concat(proxyTargetPort) });
    proxy.on('error', errorHandler);
    jupyterServer = { port: port, proxy: proxy, childProcess: serverProcess };
}
/**
 * Initializes the Jupyter server manager.
 */
function init(settings) {
    appSettings = settings;
    createJupyterServer();
}
exports.init = init;
/**
 * Closes the Jupyter server manager.
 */
function close() {
    if (!jupyterServer) {
        return;
    }
    var pid = jupyterServer.childProcess.pid;
    logging.getLogger().info("jupyter close: PID: ".concat(pid));
    jupyterServer.childProcess.kill('SIGHUP');
}
exports.close = close;
/** Proxy this socket request to jupyter. */
function handleSocket(request, socket, head) {
    if (!jupyterServer) {
        logging.getLogger().error('Jupyter server is not running.');
        return;
    }
    jupyterServer.proxy.ws(request, socket, head);
}
exports.handleSocket = handleSocket;
/** Proxy this HTTP request to jupyter. */
function handleRequest(request, response) {
    if (!jupyterServer) {
        response.statusCode = 500;
        response.end();
        return;
    }
    jupyterServer.proxy.web(request, response, null);
}
exports.handleRequest = handleRequest;
function errorHandler(error, request, response) {
    logging.getLogger().error(error, 'Jupyter server returned error.');
    response.writeHead(500, 'Internal Server Error');
    response.end();
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jupyter.js","sourceRoot":"","sources":["../../../../../../third_party/colab/sources/jupyter.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\nimport * as childProcess from 'child_process';\nimport * as http from 'http';\nimport * as httpProxy from 'http-proxy';\nimport * as net from 'net';\nimport * as path from 'path';\n\nimport {AppSettings} from './appSettings';\nimport * as logging from './logging';\n\ninterface JupyterServer {\n  port: number;\n  childProcess: childProcess.ChildProcess;\n  proxy: httpProxy.ProxyServer;\n}\n\n/**\n * Singleton tracking the jupyter server instance we manage.\n */\nlet jupyterServer: JupyterServer|null = null;\n\n/**\n * The maximum number of times we'll restart jupyter; we set a limit to avoid\n * users being stuck with a slow-crash-looping server.\n */\nlet remainingJupyterServerRestarts: number = 20;\n\n/**\n * The application settings instance.\n */\nlet appSettings: AppSettings;\n\n/*\n * This list of levels should match the ones used by Python:\n *   https://docs.python.org/3/library/logging.html#logging-levels\n */\nenum LogLevels {\n  CRITICAL = 'CRITICAL',\n  ERROR = 'ERROR',\n  WARNING = 'WARNING',\n  INFO = 'INFO',\n  DEBUG = 'DEBUG',\n  NOTSET = 'NOTSET',\n}\n\nfunction pipeOutput(stream: NodeJS.ReadableStream) {\n  stream.setEncoding('utf8');\n\n  // The format we parse here corresponds to the log format we set in our\n  // jupyter configuration.\n  const logger = logging.getJupyterLogger();\n  stream.on('data', (data: string) => {\n    for (const line of data.split('\\n')) {\n      if (line.trim().length === 0) {\n        continue;\n      }\n      const parts = line.split('|', 3);\n      if (parts.length !== 3) {\n        // Non-logging messages (eg tracebacks) get logged as warnings.\n        logger.warn(line);\n        continue;\n      }\n      const level = parts[1];\n      const message = parts[2];\n      // We need to map Python's log levels to those used by bunyan.\n      if (level === LogLevels.CRITICAL || level === LogLevels.ERROR) {\n        logger.error(message);\n      } else if (level === LogLevels.WARNING) {\n        logger.warn(message);\n      } else if (level === LogLevels.INFO) {\n        logger.info(message);\n      } else {\n        // We map DEBUG, NOTSET, and any unknown log levels to debug.\n        logger.debug(message);\n      }\n    }\n  });\n}\n\nfunction createJupyterServer() {\n  if (!remainingJupyterServerRestarts) {\n    logging.getLogger().error('No jupyter restart attempts remaining.');\n    return;\n  }\n  remainingJupyterServerRestarts -= 1;\n  const port = appSettings.nextJupyterPort;\n  logging.getLogger().info('Launching Jupyter server at %d', port);\n  const jupyterArgs = appSettings.jupyterArgs || [];\n\n  function exitHandler(code: number, signal: string): void {\n    if (jupyterServer) {\n      logging.getLogger().error(\n          'Jupyter process %d exited due to signal: %s',\n          jupyterServer.childProcess.pid!, signal);\n    } else {\n      logging.getLogger().error(\n          'Jupyter process exit before server creation finished due to signal: %s',\n          signal);\n    }\n    // We want to restart jupyter whenever it terminates.\n    createJupyterServer();\n  }\n\n  const contentDir = path.join(appSettings.datalabRoot, appSettings.contentDir);\n  const processArgs = ['notebook'].concat(jupyterArgs || []).concat([\n    `--port=${port}`,\n    `--FileContentsManager.root_dir=${appSettings.datalabRoot}/`,\n    // TODO(b/136659627): Delete this line.\n    `--MappingKernelManager.root_dir=${contentDir}`,\n  ]);\n\n  let jupyterServerAddr = 'localhost';\n  for (const flag of jupyterArgs) {\n    // Extracts a string like '1.2.3.4' from the string '--ip=1.2.3.4'\n    const match = flag.match(/--ip=([^ ]+)/);\n    if (match) {\n      jupyterServerAddr = match[1];\n      break;\n    }\n  }\n  logging.getLogger().info(\n      'Using jupyter server address %s', jupyterServerAddr);\n\n  const processOptions = {\n    detached: false,\n    env: process.env,\n  };\n\n  const serverProcess =\n      childProcess.spawn('jupyter', processArgs, processOptions);\n  serverProcess.on('exit', exitHandler);\n  logging.getLogger().info(\n      'Jupyter process started with pid %d and args %j', serverProcess.pid!,\n      processArgs);\n\n  // Capture the output, so it can be piped for logging.\n  pipeOutput(serverProcess.stdout);\n  pipeOutput(serverProcess.stderr);\n\n  // Create the proxy.\n  const proxyTargetHost =\n      appSettings.kernelManagerProxyHost || jupyterServerAddr;\n  const proxyTargetPort = appSettings.kernelManagerProxyPort || port;\n\n  const proxy = httpProxy.createProxyServer(\n      {target: `http://${proxyTargetHost}:${proxyTargetPort}`});\n  proxy.on('error', errorHandler);\n\n  jupyterServer = {port, proxy, childProcess: serverProcess};\n}\n\n/**\n * Initializes the Jupyter server manager.\n */\nexport function init(settings: AppSettings): void {\n  appSettings = settings;\n  createJupyterServer();\n}\n\n/**\n * Closes the Jupyter server manager.\n */\nexport function close(): void {\n  if (!jupyterServer) {\n    return;\n  }\n\n  const pid = jupyterServer.childProcess.pid;\n  logging.getLogger().info(`jupyter close: PID: ${pid}`);\n  jupyterServer.childProcess.kill('SIGHUP');\n}\n\n/** Proxy this socket request to jupyter. */\nexport function handleSocket(\n    request: http.IncomingMessage, socket: net.Socket, head: Buffer) {\n  if (!jupyterServer) {\n    logging.getLogger().error('Jupyter server is not running.');\n    return;\n  }\n  jupyterServer.proxy.ws(request, socket, head);\n}\n\n/** Proxy this HTTP request to jupyter. */\nexport function handleRequest(\n    request: http.IncomingMessage, response: http.ServerResponse) {\n  if (!jupyterServer) {\n    response.statusCode = 500;\n    response.end();\n    return;\n  }\n\n  jupyterServer.proxy.web(request, response, null);\n}\n\nfunction errorHandler(\n    error: Error, request: http.IncomingMessage,\n    response: http.ServerResponse) {\n  logging.getLogger().error(error, 'Jupyter server returned error.');\n\n  response.writeHead(500, 'Internal Server Error');\n  response.end();\n}\n"]}