Source: lib/kernel.spec.js

  1. /*
  2.  * BSD 3-Clause License
  3.  *
  4.  * Copyright (c) 2017, Nicolas Riesco and others as credited in the AUTHORS file
  5.  * All rights reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions are met:
  9.  *
  10.  * 1. Redistributions of source code must retain the above copyright notice,
  11.  * this list of conditions and the following disclaimer.
  12.  *
  13.  * 2. Redistributions in binary form must reproduce the above copyright notice,
  14.  * this list of conditions and the following disclaimer in the documentation
  15.  * and/or other materials provided with the distribution.
  16.  *
  17.  * 3. Neither the name of the copyright holder nor the names of its contributors
  18.  * may be used to endorse or promote products derived from this software without
  19.  * specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  22.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  25.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31.  * POSSIBILITY OF SUCH DAMAGE.
  32.  *
  33.  */
  35. var assert = require("assert");
  36. var console = require("console");
  37. var crypto = require("crypto");
  38. var fs = require("fs");
  39. var os = require("os");
  40. var path = require("path");
  41. var spawn = require("child_process").spawn;
  42. var uuid = require("uuid");
  44. var jmp = require("jmp");
  45. var zmq = jmp.zmq;
  47. // Setup logging helpers
  48. var LABEL = "JP-COFFEE-KERNEL: TEST";
  49. var log;
  50. var dontLog = function dontLog() {};
  51. var doLog = function doLog() {
  52.     process.stderr.write(LABEL);
  53.     console.error.apply(this, arguments);
  54. };
  56. if (process.env.DEBUG) {
  57.     global.DEBUG = true;
  59.     try {
  60.         doLog = require("debug")(LABEL);
  61.     } catch (err) {}
  62. }
  64. log = global.DEBUG ? doLog : dontLog;
  66. /**
  67.  * @typedef     {Object} Message
  68.  * @description IPython/Jupyter message
  69.  *
  70.  * @property    {Array}   [message.idents]        Identities
  71.  * @property    {Object}  [message.header]        Header
  72.  * @property    {Object}  [message.parent_header] Parent header
  73.  * @property    {Object}  [message.metadata]      Message metadata
  74.  * @property    {Object}  [message.content]       Message content
  75.  */
  77. /**
  78.  * Callback to handle kernel messages
  79.  *
  80.  * @callback  onMessageCallback
  81.  * @param    {string}  socketName Socket name
  82.  * @param    {Message} message    IPython/Jupyter message
  83.  */
  85. /* eslint-disable max-len */
  86. /**
  87.  * @class     Context
  88.  * @classdesc Context shared by tests
  89.  *            (adapted from MessagingTestEngine in IJavascript)
  90.  *            @see {@link https://github.com/n-riesco/ijavascript/tree/9c2cf6a94575b5016b4a6f3cbe380ab1fcfbcf76}
  91.  * @param {string} protocolVersion Messaging protocol version
  92.  */
  93. function Context(protocolVersion) {
  94. /* eslint-disable max-len */
  96.     /**
  97.      * @member          version
  98.      * @member {String} version.protocol Messaging protocol version
  99.      */
  100.     this.version = {
  101.         protocol: protocolVersion || "5.1",
  102.     };
  104.     /**
  105.      * @member          path
  106.      * @member {String} path.node           Path to node
  107.      * @member {String} path.root           Path to package folder
  108.      * @member {String} path.kernel         Path to kernel
  109.      * @member {String} path.connectionFile Path to kernel connection file
  110.      */
  111.     this.path = {};
  113.     /**
  114.      * @member           connection
  115.      * @member {String}  connection.transport    Transport protocol (e.g. "tcp")
  116.      * @member {String}  connection.ip           IP address (e.g. "127.0.0.1")
  117.      * @member {String}  connection.signature_scheme
  118.      *                                           Signature scheme
  119.      *                                           (e.g. "hmac-sha256")
  120.      * @member {String}  connection.key          Hashing key (e.g. uuid.v4())
  121.      * @member {Integer} connection.hb_port      HeartBeat port
  122.      * @member {Integer} connection.shell_port   Shell port
  123.      * @member {Integer} connection.stdin_port   Stdin port
  124.      * @member {Integer} connection.iopub_port   IOPub port
  125.      * @member {Integer} connection.control_port Control port
  126.      */
  127.     this.connection = {};
  129.     /**
  130.      * @member                     socket
  131.      * @member {module:jmp~Socket} socket.control Control socket
  132.      * @member {module:jmp~Socket} socket.hb      HearBeat socket
  133.      * @member {module:jmp~Socket} socket.iopub   IOPub socket
  134.      * @member {module:jmp~Socket} socket.shell   Shell socket
  135.      * @member {module:jmp~Socket} socket.stdin   Stdin socket
  136.      */
  137.     this.socket = {};
  139.     /**
  140.      * @member      {module:child_process~ChildProcess} kernel
  141.      * @description Kernel instance
  142.      */
  143.     this.kernel = null;
  145.     /**
  146.      * @member      {onMessageCallback} [onMessage]
  147.      * @description Callback to handle kernel messages
  148.      */
  149.     this.onMessage = null;
  150. }
  152. /**
  153.  * @method      init
  154.  * @param       {function} done
  155.  * @description Initialise the messaging test engine
  156.  */
  157. Context.prototype.init = function(done) {
  158.     this._setPaths();
  159.     this._initSockets();
  160.     this._createConnectionFile();
  161.     this._initKernel(done);
  162. };
  164. /**
  165.  * @method      dispose
  166.  * @description Dispose the messaging test engine
  167.  */
  168. Context.prototype.dispose = function() {
  169.     this._disposeKernel();
  170.     this._removeConnectionFile();
  171.     this._disposeSockets();
  172. };
  174. /**
  175.  * @method      _setPaths
  176.  * @description Set up paths
  177.  * @private
  178.  */
  179. Context.prototype._setPaths = function() {
  180.     log("Setting paths");
  182.     this.path.node = process.argv[0];
  183.     this.path.root = path.dirname(__dirname);
  184.     this.path.kernel = path.join(this.path.root, "lib", "kernel.js");
  186.     this.path.connectionFile = path.join(
  187.         os.tmpdir(),
  188.         "conn-" + uuid.v4() + ".json"
  189.     );
  190. };
  192. /**
  193.  * @method      _createConnectionFile
  194.  * @description Create connection file
  195.  * @private
  196.  */
  197. Context.prototype._createConnectionFile = function() {
  198.     log("Creating connection file");
  200.     fs.writeFileSync(
  201.         this.path.connectionFile,
  202.         JSON.stringify(this.connection)
  203.     );
  204. };
  206. /**
  207.  * @method      _removeConnectionFile
  208.  * @description Remove connection file
  209.  * @private
  210.  */
  211. Context.prototype._removeConnectionFile = function() {
  212.     log("Removing connection file");
  214.     try {
  215.         fs.unlinkSync(this.path.connectionFile);
  216.     } catch (e) {
  217.         console.error(e.message);
  218.     }
  219. };
  221. /**
  222.  * @method      _initSockets
  223.  * @description Setup ZMQ sockets and message listeners
  224.  * @private
  225.  */
  226. Context.prototype._initSockets = function() {
  227.     log("Setting up ZMQ sockets");
  229.     var transport = "tcp";
  230.     var ip = "127.0.0.1";
  231.     var address = transport + "://" + ip + ":";
  232.     var scheme = "sha256";
  233.     var key = crypto.randomBytes(256).toString("base64");
  235.     this.connection = {
  236.         transport: transport,
  237.         ip: ip,
  238.         signature_scheme: "hmac-" + scheme,
  239.         key: key,
  240.     };
  242.     var socketNames = ["hb", "shell", "stdin", "iopub", "control"];
  243.     var socketTypes = ["req", "dealer", "dealer", "sub", "dealer"];
  244.     for (var i = 0, attempts = 0; i < socketNames.length; attempts++) {
  245.         var socketName = socketNames[i];
  246.         var socketType = socketTypes[i];
  247.         var socket = (socketName === "hb") ?
  248.             new zmq.Socket(socketType) :
  249.             new jmp.Socket(socketType, scheme, key);
  250.         var port = Math.floor(1024 + Math.random() * (65536 - 1024));
  252.         try {
  253.             socket.connect(address + port);
  254.             this.connection[socketName + "_port"] = port;
  255.             this.socket[socketName] = socket;
  256.             i++;
  257.         } catch (e) {
  258.             log(e.stack);
  259.         }
  261.         if (attempts >= 100) {
  262.             throw new Error("can't bind to any local ports");
  263.         }
  264.     }
  266.     this.socket.iopub.subscribe("");
  268.     log("Setting up message listeners");
  270.     Object.getOwnPropertyNames(this.socket).forEach((function(socketName) {
  271.         this.socket[socketName]
  272.             .on("message", this._onMessage.bind(this, socketName));
  273.     }).bind(this));
  274. };
  276. /**
  277.  * @method      _disposeSockets
  278.  * @description Dispose ZMQ sockets
  279.  * @private
  280.  */
  281. Context.prototype._disposeSockets = function() {
  282.     log("Disposing ZMQ sockets");
  284.     this.socket.control.close();
  285.     this.socket.hb.close();
  286.     this.socket.iopub.close();
  287.     this.socket.shell.close();
  288.     this.socket.stdin.close();
  289. };
  291. /**
  292.  * @method      _initKernel
  293.  * @description Setup IJavascript kernel
  294.  * @param       {function} done
  295.  * @private
  296.  */
  297. Context.prototype._initKernel = function(done) {
  298.     log("Initialising a kernel");
  300.     var cmd = this.path.node;
  301.     var args = [
  302.         this.path.kernel,
  303.         "--protocol=" + this.version.protocol,
  304.         this.path.connectionFile,
  305.     ];
  306.     if (global.DEBUG) args.push("--debug");
  307.     var config = {
  308.         stdio: "inherit"
  309.     };
  310.     log("spawn", cmd, args, config);
  311.     this.kernel = spawn(cmd, args, config);
  313.     if (done) {
  314.         this._waitUntilConnect(function() {
  315.             this._waitUntilKernelIsIdle(done);
  316.         }.bind(this));
  317.     }
  318. };
  320. /**
  321.  * @method      _disposeKernel
  322.  * @description Dispose IJavascript kernel
  323.  * @private
  324.  */
  325. Context.prototype._disposeKernel = function() {
  326.     log("Disposing IJavascript kernel");
  328.     if (this.kernel) {
  329.         this.kernel.kill("SIGTERM");
  330.     }
  331. };
  333. /**
  334.  * @method      _waitUntilConnect
  335.  * @description Wait for ZMQ sockets to connect
  336.  * @param       {function} done
  337.  * @private
  338.  */
  339. Context.prototype._waitUntilConnect = function(done) {
  340.     log("Waiting for ZMQ sockets to connect");
  342.     var socketNames = ["hb", "shell", "iopub", "control"];
  344.     var waitGroup = socketNames.length;
  345.     function onConnect() {
  346.         waitGroup--;
  347.         if (waitGroup === 0) {
  348.             for (var i = 0; i < socketNames.length; i++) {
  349.                 this.socket[socketNames[i]].unmonitor();
  350.             }
  351.             if (done) done();
  352.         }
  353.     }
  355.     for (var j = 0; j < socketNames.length; j++) {
  356.         this.socket[socketNames[j]].on("connect", onConnect.bind(this));
  357.         this.socket[socketNames[j]].monitor();
  358.     }
  359. };
  361. /**
  362.  * @method      _waitUntilKernelIsIdle
  363.  * @description Wait until kernel is idle
  364.  * @param       {function} done
  365.  * @private
  366.  */
  367. Context.prototype._waitUntilKernelIsIdle = function(done) {
  368.     log("Waiting until kernel is idle");
  370.     var onMessage = this.onMessage;
  372.     var request = this.run("", function(socketName, response) {
  373.         if (response.parent_header.msg_id !== request.header.msg_id) {
  374.             return;
  375.         }
  377.         if (socketName === "iopub") {
  378.             if (response.header.msg_type === "status") {
  379.                 if (response.content.execution_state === "idle") {
  380.                     this.onMessage = onMessage;
  381.                     if (done) done();
  382.                 }
  383.             }
  384.         }
  385.     });
  386. };
  388. /**
  389.  * @method      _onMessage
  390.  * @description Handle kernel message
  391.  * @param       {string}  socketName Socket name
  392.  * @param       {Message} message    IPython/Jupyter message
  393.  * @private
  394.  */
  395. Context.prototype._onMessage = function(socketName, message) {
  396.     log("Received on " + socketName, message);
  398.     if (this.onMessage) this.onMessage(socketName, message);
  399. };
  401. /**
  402.  * @method      run
  403.  * @description Send kernel an execution request
  404.  *
  405.  * @param       {string}            code        Code to be run by kernel
  406.  * @param       {onMessageCallback} [onMessage] Kernel message handler
  407.  *
  408.  * @returns     {Message}           message     IPython/Jupyter message
  409.  */
  410. Context.prototype.run = function(code, onMessage) {
  411.     log("Running:", code);
  413.     var message = {
  414.         "header": {
  415.             "msg_type": "execute_request"
  416.         },
  417.         "content": {
  418.             "code": code
  419.         }
  420.     };
  422.     if (!(message instanceof jmp.Message)) {
  423.         message = new jmp.Message(message);
  424.     }
  426.     if (!message.header.msg_id) {
  427.         message.header.msg_id = uuid.v4();
  428.     }
  430.     if (!message.header.username) {
  431.         message.header.username = "user";
  432.     }
  434.     if (!message.header.session) {
  435.         message.header.session = uuid.v4();
  436.     }
  438.     if (!message.header.version) {
  439.         message.header.version = this.version.protocol;
  440.     }
  442.     this.onMessage = onMessage;
  443.     this.socket.shell.send(message);
  445.     return message;
  446. };
  448. describe("jp-coffee-kernel", function() {
  449.     var ctx = new Context();
  451.     before(function(done) {
  452.         this.timeout(5000);
  453.         ctx.init(done);
  454.     });
  456.     after(function() {
  457.         ctx.dispose();
  458.     });
  460.     it("can run: console.log 'Hello, World!'", function(done) {
  461.         test("console.log 'Hello, World!'", "Hello, World!\n", done);
  462.     });
  464.     it("uses coffeescript@2", function(done) {
  465.         var code = [
  466.             "outer = ->",
  467.             "  inner = => Array.prototype.slice.call arguments",
  468.             "  inner()",
  469.             "",
  470.             "console.log outer(1, 2)",
  471.         ].join("\n");
  473.         var stdout = "[ 1, 2 ]\n";
  475.         test(code, stdout, done);
  476.     });
  478.     function test(code, stdout, done) {
  479.         var receivedExecuteReply = false;
  480.         var receivedStdout = false;
  482.         var requestMessage = ctx.run(code, function(socketName, message) {
  483.             if (message.parent_header.msg_id !== requestMessage.header.msg_id) {
  484.                 return;
  485.             }
  487.             var msg_type = message && message.header && message.header.msg_type;
  489.             if (socketName === "shell") {
  490.                 if (msg_type === "execute_reply") {
  491.                     receivedExecuteReply = true;
  492.                 }
  493.             } else if (socketName === "iopub") {
  494.                 if (msg_type === "stream") {
  495.                     var name = message.content.name;
  496.                     if (name === "stdout") {
  497.                         var text = (message.content.hasOwnProperty("text")) ?
  498.                             message.content.text :
  499.                             message.content.data;
  500.                         assert.equal(text, stdout, "Unexpected stdout");
  501.                         receivedStdout = true;
  502.                     }
  503.                 }
  504.             }
  506.             if (receivedExecuteReply && receivedStdout) {
  507.                 ctx.onMessage = null;
  508.                 done();
  509.             }
  510.         });
  511.     }
  512. });