kernel.js
616 lines
| 20.8 KiB
| application/javascript
|
JavascriptLexer
|
r16359 | // Copyright (c) IPython Development Team. | ||
// Distributed under the terms of the Modified BSD License. | ||||
|
r4349 | |||
|
r17198 | define([ | ||
'base/js/namespace', | ||||
|
r17200 | 'jquery', | ||
|
r17198 | 'base/js/utils', | ||
'services/kernels/js/comm', | ||||
'widgets/js/init', | ||||
|
r17202 | ], function(IPython, $, utils, comm, widgetmanager) { | ||
|
r13187 | "use strict"; | ||
|
r4352 | |||
|
r7168 | // Initialization and connection. | ||
|
r8768 | /** | ||
* A Kernel Class to communicate with the Python kernel | ||||
* @Class Kernel | ||||
*/ | ||||
|
r17308 | var Kernel = function (kernel_service_url, ws_url, notebook, name) { | ||
|
r17200 | this.events = notebook.events; | ||
|
r4352 | this.kernel_id = null; | ||
|
r4545 | this.shell_channel = null; | ||
this.iopub_channel = null; | ||||
|
r10366 | this.stdin_channel = null; | ||
|
r15242 | this.kernel_service_url = kernel_service_url; | ||
|
r17223 | this.name = name; | ||
|
r17308 | this.ws_url = ws_url || IPython.utils.get_body_data("wsUrl"); | ||
|
r17303 | if (!this.ws_url) { | ||
// trailing 's' in https will become wss for secure web sockets | ||||
this.ws_url = location.protocol.replace('http', 'ws') + "//" + location.host; | ||||
} | ||||
|
r4545 | this.running = false; | ||
|
r13102 | this.username = "username"; | ||
|
r13035 | this.session_id = utils.uuid(); | ||
|
r7168 | this._msg_callbacks = {}; | ||
|
r16277 | this.post = $.post; | ||
|
r7168 | |||
|
r4612 | if (typeof(WebSocket) !== 'undefined') { | ||
|
r5479 | this.WebSocket = WebSocket; | ||
|
r4612 | } else if (typeof(MozWebSocket) !== 'undefined') { | ||
|
r5479 | this.WebSocket = MozWebSocket; | ||
|
r4611 | } else { | ||
|
r5253 | alert('Your browser does not have WebSocket support, please try Chrome, Safari or Firefox ≥ 6. Firefox 4 and 5 are also supported by you have to enable WebSockets in about:config.'); | ||
|
r13187 | } | ||
|
r11611 | this.bind_events(); | ||
|
r13187 | this.init_iopub_handlers(); | ||
|
r17198 | this.comm_manager = new comm.CommManager(this); | ||
|
r17202 | this.widget_manager = new widgetmanager.WidgetManager(this.comm_manager, notebook); | ||
|
r16359 | |||
this.last_msg_id = null; | ||||
this.last_msg_callbacks = {}; | ||||
|
r4352 | }; | ||
|
r13217 | Kernel.prototype._get_msg = function (msg_type, content, metadata) { | ||
|
r4352 | var msg = { | ||
header : { | ||||
msg_id : utils.uuid(), | ||||
|
r4694 | username : this.username, | ||
|
r13035 | session : this.session_id, | ||
|
r16666 | msg_type : msg_type, | ||
version : "5.0" | ||||
|
r4352 | }, | ||
|
r13217 | metadata : metadata || {}, | ||
|
r4352 | content : content, | ||
parent_header : {} | ||||
}; | ||||
return msg; | ||||
|
r5479 | }; | ||
|
r11611 | |||
|
r13187 | Kernel.prototype.bind_events = function () { | ||
|
r11611 | var that = this; | ||
|
r17198 | this.events.on('send_input_reply.Kernel', function(evt, data) { | ||
|
r11611 | that.send_input_reply(data); | ||
}); | ||||
|
r13187 | }; | ||
// Initialize the iopub handlers | ||||
Kernel.prototype.init_iopub_handlers = function () { | ||||
|
r16569 | var output_msg_types = ['stream', 'display_data', 'execute_result', 'error']; | ||
|
r13187 | this._iopub_handlers = {}; | ||
this.register_iopub_handler('status', $.proxy(this._handle_status_message, this)); | ||||
this.register_iopub_handler('clear_output', $.proxy(this._handle_clear_output, this)); | ||||
|
r16569 | for (var i=0; i < output_msg_types.length; i++) { | ||
this.register_iopub_handler(output_msg_types[i], $.proxy(this._handle_output_message, this)); | ||||
|
r13187 | } | ||
}; | ||||
|
r4352 | |||
|
r8768 | /** | ||
* Start the Python kernel | ||||
* @method start | ||||
*/ | ||||
|
r13103 | Kernel.prototype.start = function (params) { | ||
params = params || {}; | ||||
if (!this.running) { | ||||
var qs = $.param(params); | ||||
|
r16277 | this.post(utils.url_join_encode(this.kernel_service_url) + '?' + qs, | ||
|
r13103 | $.proxy(this._kernel_started, this), | ||
'json' | ||||
); | ||||
|
r13187 | } | ||
|
r13103 | }; | ||
|
r4545 | |||
|
r8768 | /** | ||
* Restart the python kernel. | ||||
* | ||||
* Emit a 'status_restarting.Kernel' event with | ||||
* the current object as parameter | ||||
* | ||||
* @method restart | ||||
*/ | ||||
|
r7168 | Kernel.prototype.restart = function () { | ||
|
r17198 | this.events.trigger('status_restarting.Kernel', {kernel: this}); | ||
|
r4545 | if (this.running) { | ||
this.stop_channels(); | ||||
|
r16277 | this.post(utils.url_join_encode(this.kernel_url, "restart"), | ||
|
r13103 | $.proxy(this._kernel_started, this), | ||
|
r4545 | 'json' | ||
); | ||||
|
r13187 | } | ||
|
r4352 | }; | ||
|
r7168 | Kernel.prototype._kernel_started = function (json) { | ||
|
r13015 | console.log("Kernel started: ", json.id); | ||
|
r4545 | this.running = true; | ||
|
r13015 | this.kernel_id = json.id; | ||
|
r15242 | this.kernel_url = utils.url_path_join(this.kernel_service_url, this.kernel_id); | ||
|
r4545 | this.start_channels(); | ||
|
r4352 | }; | ||
|
r7168 | |||
|
r9222 | Kernel.prototype._websocket_closed = function(ws_url, early) { | ||
this.stop_channels(); | ||||
|
r17198 | this.events.trigger('websocket_closed.Kernel', | ||
|
r9222 | {ws_url: ws_url, kernel: this, early: early} | ||
); | ||||
|
r5479 | }; | ||
|
r4352 | |||
|
r8768 | /** | ||
* Start the `shell`and `iopub` channels. | ||||
* Will stop and restart them if they already exist. | ||||
* | ||||
* @method start_channels | ||||
*/ | ||||
|
r4545 | Kernel.prototype.start_channels = function () { | ||
|
r5253 | var that = this; | ||
|
r4545 | this.stop_channels(); | ||
|
r17303 | var ws_host_url = this.ws_url + this.kernel_url; | ||
|
r15400 | console.log("Starting WebSockets:", ws_host_url); | ||
|
r15242 | this.shell_channel = new this.WebSocket( | ||
|
r17303 | this.ws_url + utils.url_join_encode(this.kernel_url, "shell") | ||
|
r15242 | ); | ||
this.stdin_channel = new this.WebSocket( | ||||
|
r17303 | this.ws_url + utils.url_join_encode(this.kernel_url, "stdin") | ||
|
r15242 | ); | ||
this.iopub_channel = new this.WebSocket( | ||||
|
r17303 | this.ws_url + utils.url_join_encode(this.kernel_url, "iopub") | ||
|
r15242 | ); | ||
|
r12254 | |||
|
r5253 | var already_called_onclose = false; // only alert once | ||
|
r8839 | var ws_closed_early = function(evt){ | ||
|
r5253 | if (already_called_onclose){ | ||
return; | ||||
} | ||||
already_called_onclose = true; | ||||
if ( ! evt.wasClean ){ | ||||
|
r15242 | that._websocket_closed(ws_host_url, true); | ||
|
r5253 | } | ||
|
r5479 | }; | ||
|
r8839 | var ws_closed_late = function(evt){ | ||
|
r5253 | if (already_called_onclose){ | ||
return; | ||||
} | ||||
already_called_onclose = true; | ||||
if ( ! evt.wasClean ){ | ||||
|
r15242 | that._websocket_closed(ws_host_url, false); | ||
|
r5253 | } | ||
|
r5479 | }; | ||
|
r10366 | var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel]; | ||
for (var i=0; i < channels.length; i++) { | ||||
|
r12254 | channels[i].onopen = $.proxy(this._ws_opened, this); | ||
|
r10366 | channels[i].onclose = ws_closed_early; | ||
} | ||||
|
r5253 | // switch from early-close to late-close message after 1s | ||
|
r9222 | setTimeout(function() { | ||
|
r10366 | for (var i=0; i < channels.length; i++) { | ||
if (channels[i] !== null) { | ||||
channels[i].onclose = ws_closed_late; | ||||
} | ||||
|
r9222 | } | ||
|
r5253 | }, 1000); | ||
|
r10366 | this.shell_channel.onmessage = $.proxy(this._handle_shell_reply, this); | ||
|
r13187 | this.iopub_channel.onmessage = $.proxy(this._handle_iopub_message, this); | ||
|
r10366 | this.stdin_channel.onmessage = $.proxy(this._handle_input_request, this); | ||
|
r4545 | }; | ||
|
r4352 | |||
|
r8768 | /** | ||
|
r12254 | * Handle a websocket entering the open state | ||
* sends session and cookie authentication info as first message. | ||||
* Once all sockets are open, signal the Kernel.status_started event. | ||||
* @method _ws_opened | ||||
*/ | ||||
Kernel.prototype._ws_opened = function (evt) { | ||||
// send the session id so the Session object Python-side | ||||
// has the same identity | ||||
evt.target.send(this.session_id + ':' + document.cookie); | ||||
var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel]; | ||||
for (var i=0; i < channels.length; i++) { | ||||
// if any channel is not ready, don't trigger event. | ||||
if ( !channels[i].readyState ) return; | ||||
} | ||||
// all events ready, trigger started event. | ||||
|
r17198 | this.events.trigger('status_started.Kernel', {kernel: this}); | ||
|
r12254 | }; | ||
/** | ||||
* Stop the websocket channels. | ||||
|
r8768 | * @method stop_channels | ||
*/ | ||||
|
r4545 | Kernel.prototype.stop_channels = function () { | ||
|
r10366 | var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel]; | ||
for (var i=0; i < channels.length; i++) { | ||||
if ( channels[i] !== null ) { | ||||
|
r13187 | channels[i].onclose = null; | ||
|
r10366 | channels[i].close(); | ||
} | ||||
|
r13187 | } | ||
|
r10366 | this.shell_channel = this.iopub_channel = this.stdin_channel = null; | ||
|
r4545 | }; | ||
|
r7168 | // Main public methods. | ||
|
r13187 | |||
// send a message on the Kernel's shell channel | ||||
|
r13217 | Kernel.prototype.send_shell_message = function (msg_type, content, callbacks, metadata) { | ||
var msg = this._get_msg(msg_type, content, metadata); | ||||
|
r13187 | this.shell_channel.send(JSON.stringify(msg)); | ||
this.set_callbacks_for_msg(msg.header.msg_id, callbacks); | ||||
return msg.header.msg_id; | ||||
|
r13207 | }; | ||
|
r7168 | |||
|
r8768 | /** | ||
|
r14681 | * Get kernel info | ||
* | ||||
* @param callback {function} | ||||
|
r16587 | * @method kernel_info | ||
|
r14681 | * | ||
* When calling this method, pass a callback function that expects one argument. | ||||
* The callback will be passed the complete `kernel_info_reply` message documented | ||||
* [here](http://ipython.org/ipython-doc/dev/development/messaging.html#kernel-info) | ||||
*/ | ||||
Kernel.prototype.kernel_info = function (callback) { | ||||
var callbacks; | ||||
if (callback) { | ||||
callbacks = { shell : { reply : callback } }; | ||||
} | ||||
return this.send_shell_message("kernel_info_request", {}, callbacks); | ||||
}; | ||||
/** | ||||
|
r13208 | * Get info on an object | ||
|
r8768 | * | ||
|
r16580 | * @param code {string} | ||
* @param cursor_pos {integer} | ||||
|
r13208 | * @param callback {function} | ||
|
r16587 | * @method inspect | ||
|
r8768 | * | ||
|
r13212 | * When calling this method, pass a callback function that expects one argument. | ||
|
r16587 | * The callback will be passed the complete `inspect_reply` message documented | ||
|
r13212 | * [here](http://ipython.org/ipython-doc/dev/development/messaging.html#object-information) | ||
|
r8768 | */ | ||
|
r16587 | Kernel.prototype.inspect = function (code, cursor_pos, callback) { | ||
|
r13208 | var callbacks; | ||
if (callback) { | ||||
callbacks = { shell : { reply : callback } }; | ||||
} | ||||
|
r16580 | var content = { | ||
code : code, | ||||
cursor_pos : cursor_pos, | ||||
detail_level : 0, | ||||
}; | ||||
|
r16587 | return this.send_shell_message("inspect_request", content, callbacks); | ||
|
r13187 | }; | ||
|
r5397 | |||
|
r8768 | /** | ||
* Execute given code into kernel, and pass result to callback. | ||||
* | ||||
* @async | ||||
* @method execute | ||||
* @param {string} code | ||||
|
r13212 | * @param [callbacks] {Object} With the following keys (all optional) | ||
* @param callbacks.shell.reply {function} | ||||
* @param callbacks.shell.payload.[payload_name] {function} | ||||
* @param callbacks.iopub.output {function} | ||||
* @param callbacks.iopub.clear_output {function} | ||||
* @param callbacks.input {function} | ||||
|
r8768 | * @param {object} [options] | ||
* @param [options.silent=false] {Boolean} | ||||
* @param [options.user_expressions=empty_dict] {Dict} | ||||
* @param [options.allow_stdin=false] {Boolean} true|false | ||||
* | ||||
* @example | ||||
* | ||||
* The options object should contain the options for the execute call. Its default | ||||
* values are: | ||||
* | ||||
* options = { | ||||
* silent : true, | ||||
* user_expressions : {}, | ||||
* allow_stdin : false | ||||
* } | ||||
* | ||||
* When calling this method pass a callbacks structure of the form: | ||||
* | ||||
* callbacks = { | ||||
|
r13212 | * shell : { | ||
* reply : execute_reply_callback, | ||||
* payload : { | ||||
* set_next_input : set_next_input_callback, | ||||
* } | ||||
* }, | ||||
* iopub : { | ||||
* output : output_callback, | ||||
* clear_output : clear_output_callback, | ||||
* }, | ||||
* input : raw_input_callback | ||||
|
r8768 | * } | ||
* | ||||
|
r13212 | * Each callback will be passed the entire message as a single arugment. | ||
* Payload handlers will be passed the corresponding payload and the execute_reply message. | ||||
|
r8768 | */ | ||
|
r7176 | Kernel.prototype.execute = function (code, callbacks, options) { | ||
|
r4352 | var content = { | ||
code : code, | ||||
|
r7176 | silent : true, | ||
|
r11857 | store_history : false, | ||
|
r4975 | user_expressions : {}, | ||
|
r10368 | allow_stdin : false | ||
|
r4352 | }; | ||
|
r10594 | callbacks = callbacks || {}; | ||
|
r13207 | if (callbacks.input !== undefined) { | ||
|
r10368 | content.allow_stdin = true; | ||
} | ||||
|
r13187 | $.extend(true, content, options); | ||
|
r17198 | this.events.trigger('execution_request.Kernel', {kernel: this, content:content}); | ||
|
r13187 | return this.send_shell_message("execute_request", content, callbacks); | ||
|
r5479 | }; | ||
|
r4352 | |||
|
r8768 | /** | ||
|
r13212 | * When calling this method, pass a function to be called with the `complete_reply` message | ||
|
r13208 | * as its only argument when it arrives. | ||
|
r8768 | * | ||
|
r13208 | * `complete_reply` is documented | ||
|
r8768 | * [here](http://ipython.org/ipython-doc/dev/development/messaging.html#complete) | ||
* | ||||
* @method complete | ||||
|
r16580 | * @param code {string} | ||
|
r8768 | * @param cursor_pos {integer} | ||
|
r13208 | * @param callback {function} | ||
|
r8768 | * | ||
*/ | ||||
|
r16580 | Kernel.prototype.complete = function (code, cursor_pos, callback) { | ||
|
r13208 | var callbacks; | ||
if (callback) { | ||||
callbacks = { shell : { reply : callback } }; | ||||
} | ||||
|
r4388 | var content = { | ||
|
r16580 | code : code, | ||
cursor_pos : cursor_pos, | ||||
|
r4388 | }; | ||
|
r13187 | return this.send_shell_message("complete_request", content, callbacks); | ||
|
r5479 | }; | ||
|
r4388 | |||
|
r4352 | Kernel.prototype.interrupt = function () { | ||
|
r4545 | if (this.running) { | ||
|
r17198 | this.events.trigger('status_interrupting.Kernel', {kernel: this}); | ||
|
r16277 | this.post(utils.url_join_encode(this.kernel_url, "interrupt")); | ||
|
r13187 | } | ||
|
r4349 | }; | ||
|
r4496 | Kernel.prototype.kill = function () { | ||
|
r4545 | if (this.running) { | ||
this.running = false; | ||||
var settings = { | ||||
cache : false, | ||||
|
r16445 | type : "DELETE", | ||
error : utils.log_ajax_error, | ||||
|
r4545 | }; | ||
|
r15242 | $.ajax(utils.url_join_encode(this.kernel_url), settings); | ||
|
r13187 | } | ||
|
r4496 | }; | ||
|
r10368 | Kernel.prototype.send_input_reply = function (input) { | ||
|
r10366 | var content = { | ||
value : input, | ||||
}; | ||||
|
r17198 | this.events.trigger('input_reply.Kernel', {kernel: this, content:content}); | ||
|
r10366 | var msg = this._get_msg("input_reply", content); | ||
this.stdin_channel.send(JSON.stringify(msg)); | ||||
return msg.header.msg_id; | ||||
}; | ||||
// Reply handlers | ||||
|
r7168 | |||
|
r13187 | Kernel.prototype.register_iopub_handler = function (msg_type, callback) { | ||
this._iopub_handlers[msg_type] = callback; | ||||
}; | ||||
Kernel.prototype.get_iopub_handler = function (msg_type) { | ||||
// get iopub handler for a specific message type | ||||
return this._iopub_handlers[msg_type]; | ||||
}; | ||||
|
r7168 | Kernel.prototype.get_callbacks_for_msg = function (msg_id) { | ||
|
r13187 | // get callbacks for a specific message | ||
|
r16359 | if (msg_id == this.last_msg_id) { | ||
return this.last_msg_callbacks; | ||||
} else { | ||||
return this._msg_callbacks[msg_id]; | ||||
} | ||||
|
r7168 | }; | ||
|
r12555 | Kernel.prototype.clear_callbacks_for_msg = function (msg_id) { | ||
if (this._msg_callbacks[msg_id] !== undefined ) { | ||||
delete this._msg_callbacks[msg_id]; | ||||
} | ||||
}; | ||||
|
r13207 | |||
|
r16359 | Kernel.prototype._finish_shell = function (msg_id) { | ||
var callbacks = this._msg_callbacks[msg_id]; | ||||
if (callbacks !== undefined) { | ||||
callbacks.shell_done = true; | ||||
if (callbacks.iopub_done) { | ||||
this.clear_callbacks_for_msg(msg_id); | ||||
} | ||||
} | ||||
}; | ||||
Kernel.prototype._finish_iopub = function (msg_id) { | ||||
var callbacks = this._msg_callbacks[msg_id]; | ||||
if (callbacks !== undefined) { | ||||
callbacks.iopub_done = true; | ||||
|
r16599 | if (callbacks.shell_done) { | ||
|
r16359 | this.clear_callbacks_for_msg(msg_id); | ||
} | ||||
} | ||||
}; | ||||
|
r13207 | /* Set callbacks for a particular message. | ||
* Callbacks should be a struct of the following form: | ||||
* shell : { | ||||
* | ||||
* } | ||||
*/ | ||||
|
r7168 | Kernel.prototype.set_callbacks_for_msg = function (msg_id, callbacks) { | ||
|
r16359 | this.last_msg_id = msg_id; | ||
|
r13187 | if (callbacks) { | ||
|
r13207 | // shallow-copy mapping, because we will modify it at the top level | ||
|
r16359 | var cbcopy = this._msg_callbacks[msg_id] = this.last_msg_callbacks = {}; | ||
|
r13207 | cbcopy.shell = callbacks.shell; | ||
cbcopy.iopub = callbacks.iopub; | ||||
cbcopy.input = callbacks.input; | ||||
|
r16359 | cbcopy.shell_done = (!callbacks.shell); | ||
cbcopy.iopub_done = (!callbacks.iopub); | ||||
} else { | ||||
this.last_msg_callbacks = {}; | ||||
|
r13187 | } | ||
|
r12555 | }; | ||
|
r7168 | |||
Kernel.prototype._handle_shell_reply = function (e) { | ||||
|
r8839 | var reply = $.parseJSON(e.data); | ||
|
r17198 | this.events.trigger('shell_reply.Kernel', {kernel: this, reply:reply}); | ||
|
r7168 | var content = reply.content; | ||
|
r7952 | var metadata = reply.metadata; | ||
|
r13207 | var parent_id = reply.parent_header.msg_id; | ||
var callbacks = this.get_callbacks_for_msg(parent_id); | ||||
if (!callbacks || !callbacks.shell) { | ||||
return; | ||||
|
r13187 | } | ||
|
r13207 | var shell_callbacks = callbacks.shell; | ||
|
r16359 | // signal that shell callbacks are done | ||
this._finish_shell(parent_id); | ||||
|
r13207 | |||
if (shell_callbacks.reply !== undefined) { | ||||
shell_callbacks.reply(reply); | ||||
} | ||||
if (content.payload && shell_callbacks.payload) { | ||||
this._handle_payloads(content.payload, shell_callbacks.payload, reply); | ||||
|
r7168 | } | ||
}; | ||||
|
r13207 | Kernel.prototype._handle_payloads = function (payloads, payload_callbacks, msg) { | ||
var l = payloads.length; | ||||
|
r7168 | // Payloads are handled by triggering events because we don't want the Kernel | ||
// to depend on the Notebook or Pager classes. | ||||
for (var i=0; i<l; i++) { | ||||
|
r13207 | var payload = payloads[i]; | ||
var callback = payload_callbacks[payload.source]; | ||||
if (callback) { | ||||
callback(payload, msg); | ||||
|
r7168 | } | ||
|
r13187 | } | ||
|
r7168 | }; | ||
|
r13187 | Kernel.prototype._handle_status_message = function (msg) { | ||
var execution_state = msg.content.execution_state; | ||||
|
r13231 | var parent_id = msg.parent_header.msg_id; | ||
// dispatch status msg callbacks, if any | ||||
var callbacks = this.get_callbacks_for_msg(parent_id); | ||||
if (callbacks && callbacks.iopub && callbacks.iopub.status) { | ||||
try { | ||||
callbacks.iopub.status(msg); | ||||
} catch (e) { | ||||
|
r14499 | console.log("Exception in status msg handler", e, e.stack); | ||
|
r13231 | } | ||
} | ||||
|
r13187 | if (execution_state === 'busy') { | ||
|
r17198 | this.events.trigger('status_busy.Kernel', {kernel: this}); | ||
|
r13187 | } else if (execution_state === 'idle') { | ||
|
r16359 | // signal that iopub callbacks are (probably) done | ||
// async output may still arrive, | ||||
// but only for the most recent request | ||||
this._finish_iopub(parent_id); | ||||
|
r13231 | // trigger status_idle event | ||
|
r17198 | this.events.trigger('status_idle.Kernel', {kernel: this}); | ||
|
r13187 | } else if (execution_state === 'restarting') { | ||
// autorestarting is distinct from restarting, | ||||
// in that it means the kernel died and the server is restarting it. | ||||
// status_restarting sets the notification widget, | ||||
// autorestart shows the more prominent dialog. | ||||
|
r17198 | this.events.trigger('status_autorestarting.Kernel', {kernel: this}); | ||
this.events.trigger('status_restarting.Kernel', {kernel: this}); | ||||
|
r13187 | } else if (execution_state === 'dead') { | ||
this.stop_channels(); | ||||
|
r17198 | this.events.trigger('status_dead.Kernel', {kernel: this}); | ||
|
r13187 | } | ||
}; | ||||
// handle clear_output message | ||||
Kernel.prototype._handle_clear_output = function (msg) { | ||||
var callbacks = this.get_callbacks_for_msg(msg.parent_header.msg_id); | ||||
|
r13207 | if (!callbacks || !callbacks.iopub) { | ||
|
r13187 | return; | ||
} | ||||
|
r13214 | var callback = callbacks.iopub.clear_output; | ||
|
r13207 | if (callback) { | ||
callback(msg); | ||||
|
r13187 | } | ||
}; | ||||
|
r7168 | |||
|
r13187 | |||
|
r16568 | // handle an output message (execute_result, display_data, etc.) | ||
|
r13187 | Kernel.prototype._handle_output_message = function (msg) { | ||
var callbacks = this.get_callbacks_for_msg(msg.parent_header.msg_id); | ||||
|
r13207 | if (!callbacks || !callbacks.iopub) { | ||
|
r7168 | return; | ||
} | ||||
|
r13207 | var callback = callbacks.iopub.output; | ||
if (callback) { | ||||
callback(msg); | ||||
|
r13187 | } | ||
}; | ||||
// dispatch IOPub messages to respective handlers. | ||||
// each message type should have a handler. | ||||
Kernel.prototype._handle_iopub_message = function (e) { | ||||
var msg = $.parseJSON(e.data); | ||||
var handler = this.get_iopub_handler(msg.header.msg_type); | ||||
if (handler !== undefined) { | ||||
handler(msg); | ||||
} | ||||
|
r7168 | }; | ||
|
r10366 | Kernel.prototype._handle_input_request = function (e) { | ||
var request = $.parseJSON(e.data); | ||||
var header = request.header; | ||||
var content = request.content; | ||||
var metadata = request.metadata; | ||||
var msg_type = header.msg_type; | ||||
if (msg_type !== 'input_request') { | ||||
console.log("Invalid input request!", request); | ||||
return; | ||||
} | ||||
|
r10368 | var callbacks = this.get_callbacks_for_msg(request.parent_header.msg_id); | ||
|
r13207 | if (callbacks) { | ||
if (callbacks.input) { | ||||
callbacks.input(request); | ||||
|
r10368 | } | ||
|
r13187 | } | ||
|
r10366 | }; | ||
|
r17200 | // Backwards compatability. | ||
|
r4352 | IPython.Kernel = Kernel; | ||
|
r17201 | return {'Kernel': Kernel}; | ||
|
r17198 | }); | ||