Support specifying requirejs modules for comm targets

IPython/html/static/services/kernels/comm.js

@@ -1,190 +1,210 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
 ], function(IPython, $, utils) {
     "use strict";
 
     //-----------------------------------------------------------------------
     // CommManager class
     //-----------------------------------------------------------------------
     
     var CommManager = function (kernel) {
         this.comms = {};
         this.targets = {};
         if (kernel !== undefined) {
             this.init_kernel(kernel);
         }
     };
     
     CommManager.prototype.init_kernel = function (kernel) {
         // connect the kernel, and register message handlers
         this.kernel = kernel;
         var msg_types = ['comm_open', 'comm_msg', 'comm_close'];
         for (var i = 0; i < msg_types.length; i++) {
             var msg_type = msg_types[i];
             kernel.register_iopub_handler(msg_type, $.proxy(this[msg_type], this));
         }
     };
     
     CommManager.prototype.new_comm = function (target_name, data, callbacks, metadata) {
         // Create a new Comm, register it, and open its Kernel-side counterpart
         // Mimics the auto-registration in `Comm.__init__` in the IPython Comm
         var comm = new Comm(target_name);
         this.register_comm(comm);
         comm.open(data, callbacks, metadata);
         return comm;
     };
     
     CommManager.prototype.register_target = function (target_name, f) {
         // Register a target function for a given target name
         this.targets[target_name] = f;
     };
     
     CommManager.prototype.unregister_target = function (target_name, f) {
         // Unregister a target function for a given target name
         delete this.targets[target_name];
     };
     
     CommManager.prototype.register_comm = function (comm) {
         // Register a comm in the mapping
         this.comms[comm.comm_id] = comm;
         comm.kernel = this.kernel;
         return comm.comm_id;
     };
     
     CommManager.prototype.unregister_comm = function (comm) {
         // Remove a comm from the mapping
         delete this.comms[comm.comm_id];
     };
     
     // comm message handlers
     
     CommManager.prototype.comm_open = function (msg) {
         var content = msg.content;
-        var f = this.targets[content.target_name];
-        if (f === undefined) {
-            console.log("No such target registered: ", content.target_name);
-            console.log("Available targets are: ", this.targets);
-            return;
-        }
-        var comm = new Comm(content.target_name, content.comm_id);
-        this.register_comm(comm);
-        try {
-            f(comm, msg);
-        } catch (e) {
-            console.log("Exception opening new comm:", e, e.stack, msg);
-            comm.close();
-            this.unregister_comm(comm);
+        var that = this;
+        
+        var instantiate_comm = function(target) {
+            var comm = new Comm(content.target_name, content.comm_id);
+            that.register_comm(comm);
+            try {
+                target(comm, msg);
+            } catch (e) {
+                console.log("Exception opening new comm:", e, e.stack, msg);
+                comm.close();
+                that.unregister_comm(comm);
+            }
+        };
+
+        if (content.target_module) {
+            // Load requirejs module for comm target
+            require([content.target_module], function(mod) {
+                var target = mod[content.target_name];
+                if (target !== undefined) {
+                    instantiate_comm(target)
+                } else {
+                    console.log("Comm target " + content.target_name + 
+                        " not found in module " + content.target_module);
+                }
+            }, function(err) { console.log(err); });
+        } else {
+            // No requirejs module specified: look for target in registry
+            var f = this.targets[content.target_name];
+            if (f === undefined) {
+                console.log("No such target registered: ", content.target_name);
+                console.log("Available targets are: ", this.targets);
+                return;
+            }
+            instantiate_comm(f)
         }
     };
     
     CommManager.prototype.comm_close = function (msg) {
         var content = msg.content;
         var comm = this.comms[content.comm_id];
         if (comm === undefined) {
             return;
         }
         this.unregister_comm(comm);
         try {
             comm.handle_close(msg);
         } catch (e) {
             console.log("Exception closing comm: ", e, e.stack, msg);
         }
     };
     
     CommManager.prototype.comm_msg = function (msg) {
         var content = msg.content;
         var comm = this.comms[content.comm_id];
         if (comm === undefined) {
             return;
         }
         try {
             comm.handle_msg(msg);
         } catch (e) {
             console.log("Exception handling comm msg: ", e, e.stack, msg);
         }
     };
     
     //-----------------------------------------------------------------------
     // Comm base class
     //-----------------------------------------------------------------------
     
     var Comm = function (target_name, comm_id) {
         this.target_name = target_name;
         this.comm_id = comm_id || utils.uuid();
         this._msg_callback = this._close_callback = null;
     };
     
     // methods for sending messages
     Comm.prototype.open = function (data, callbacks, metadata) {
         var content = {
             comm_id : this.comm_id,
             target_name : this.target_name,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_open", content, callbacks, metadata);
     };
     
     Comm.prototype.send = function (data, callbacks, metadata, buffers) {
         var content = {
             comm_id : this.comm_id,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_msg", content, callbacks, metadata, buffers);
     };
     
     Comm.prototype.close = function (data, callbacks, metadata) {
         var content = {
             comm_id : this.comm_id,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_close", content, callbacks, metadata);
     };
     
     // methods for registering callbacks for incoming messages
     Comm.prototype._register_callback = function (key, callback) {
         this['_' + key + '_callback'] = callback;
     };
     
     Comm.prototype.on_msg = function (callback) {
         this._register_callback('msg', callback);
     };
     
     Comm.prototype.on_close = function (callback) {
         this._register_callback('close', callback);
     };
     
     // methods for handling incoming messages
     
     Comm.prototype._maybe_callback = function (key, msg) {
         var callback = this['_' + key + '_callback'];
         if (callback) {
             try {
                 callback(msg);
             } catch (e) {
                 console.log("Exception in Comm callback", e, e.stack, msg);
             }
         }
     };
     
     Comm.prototype.handle_msg = function (msg) {
         this._maybe_callback('msg', msg);
     };
     
     Comm.prototype.handle_close = function (msg) {
         this._maybe_callback('close', msg);
     };
     
     // For backwards compatability.
     IPython.CommManager = CommManager;
     IPython.Comm = Comm;
 
     return {
         'CommManager': CommManager,
         'Comm': Comm
     };
 });

IPython/kernel/comm/comm.py

@@ -1,158 +1,162 b''
 """Base class for a Comm"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import uuid
 
 from IPython.config import LoggingConfigurable
 from IPython.kernel.zmq.kernelbase import Kernel
 
 from IPython.utils.jsonutil import json_clean
 from IPython.utils.traitlets import Instance, Unicode, Bytes, Bool, Dict, Any
 
 
 class Comm(LoggingConfigurable):
     
     # If this is instantiated by a non-IPython kernel, shell will be None
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                      allow_none=True)
     kernel = Instance('IPython.kernel.zmq.kernelbase.Kernel')
     def _kernel_default(self):
         if Kernel.initialized():
             return Kernel.instance()
     
     iopub_socket = Any()
     def _iopub_socket_default(self):
         return self.kernel.iopub_socket
     session = Instance('IPython.kernel.zmq.session.Session')
     def _session_default(self):
         if self.kernel is not None:
             return self.kernel.session
     
     target_name = Unicode('comm')
+    target_module = Unicode(None, allow_none=True, help="""requirejs module from
+        which to load comm target.""")
     
     topic = Bytes()
     def _topic_default(self):
         return ('comm-%s' % self.comm_id).encode('ascii')
     
     _open_data = Dict(help="data dict, if any, to be included in comm_open")
     _close_data = Dict(help="data dict, if any, to be included in comm_close")
     
     _msg_callback = Any()
     _close_callback = Any()
     
     _closed = Bool(True)
     comm_id = Unicode()
     def _comm_id_default(self):
         return uuid.uuid4().hex
     
     primary = Bool(True, help="Am I the primary or secondary Comm?")
     
     def __init__(self, target_name='', data=None, **kwargs):
         if target_name:
             kwargs['target_name'] = target_name
         super(Comm, self).__init__(**kwargs)
         if self.primary:
             # I am primary, open my peer.
             self.open(data)
         else:
             self._closed = False
     
     def _publish_msg(self, msg_type, data=None, metadata=None, buffers=None, **keys):
         """Helper for sending a comm message on IOPub"""
         data = {} if data is None else data
         metadata = {} if metadata is None else metadata
         content = json_clean(dict(data=data, comm_id=self.comm_id, **keys))
         self.session.send(self.iopub_socket, msg_type,
             content,
             metadata=json_clean(metadata),
             parent=self.kernel._parent_header,
             ident=self.topic,
             buffers=buffers,
         )
     
     def __del__(self):
         """trigger close on gc"""
         self.close()
     
     # publishing messages
     
     def open(self, data=None, metadata=None, buffers=None):
         """Open the frontend-side version of this comm"""
         if data is None:
             data = self._open_data
         comm_manager = getattr(self.kernel, 'comm_manager', None)
         if comm_manager is None:
             raise RuntimeError("Comms cannot be opened without a kernel "
                         "and a comm_manager attached to that kernel.")
 
         comm_manager.register_comm(self)
         try:
             self._publish_msg('comm_open',
                               data=data, metadata=metadata, buffers=buffers,
-                              target_name=self.target_name)
+                              target_name=self.target_name,
+                              target_module=self.target_module,
+                              )
             self._closed = False
         except:
             comm_manager.unregister_comm(self)
             raise
     
     def close(self, data=None, metadata=None, buffers=None):
         """Close the frontend-side version of this comm"""
         if self._closed:
             # only close once
             return
         self._closed = True
         if data is None:
             data = self._close_data
         self._publish_msg('comm_close',
             data=data, metadata=metadata, buffers=buffers,
         )
         self.kernel.comm_manager.unregister_comm(self)
     
     def send(self, data=None, metadata=None, buffers=None):
         """Send a message to the frontend-side version of this comm"""
         self._publish_msg('comm_msg',
             data=data, metadata=metadata, buffers=buffers,
         )
     
     # registering callbacks
     
     def on_close(self, callback):
         """Register a callback for comm_close
         
         Will be called with the `data` of the close message.
         
         Call `on_close(None)` to disable an existing callback.
         """
         self._close_callback = callback
     
     def on_msg(self, callback):
         """Register a callback for comm_msg
         
         Will be called with the `data` of any comm_msg messages.
         
         Call `on_msg(None)` to disable an existing callback.
         """
         self._msg_callback = callback
     
     # handling of incoming messages
     
     def handle_close(self, msg):
         """Handle a comm_close message"""
         self.log.debug("handle_close[%s](%s)", self.comm_id, msg)
         if self._close_callback:
             self._close_callback(msg)
     
     def handle_msg(self, msg):
         """Handle a comm_msg message"""
         self.log.debug("handle_msg[%s](%s)", self.comm_id, msg)
         if self._msg_callback:
             if self.shell:
                 self.shell.events.trigger('pre_execute')
             self._msg_callback(msg)
             if self.shell:
                 self.shell.events.trigger('post_execute')
 
 
 __all__ = ['Comm']