support binary message from javascript

IPython/html/base/zmqhandlers.py

@@ -49,7 +49,6 b' def serialize_binary_message(msg):'
     bmsg = json.dumps(msg, default=date_default).encode('utf8')
     buffers.insert(0, bmsg)
     nbufs = len(buffers)
-    sizes = (len(buf) for buf in buffers)
     offsets = [4 * (nbufs + 1)]
     for buf in buffers[:-1]:
         offsets.append(offsets[-1] + len(buf))

IPython/html/services/kernels/handlers.py

@@ -12,7 +12,7 b' from IPython.utils.py3compat import string_types'
 from IPython.html.utils import url_path_join, url_escape
 
 from ...base.handlers import IPythonHandler, json_errors
-from ...base.zmqhandlers import AuthenticatedZMQStreamHandler
+from ...base.zmqhandlers import AuthenticatedZMQStreamHandler, deserialize_binary_message
 
 from IPython.core.release import kernel_protocol_version
 
@@ -150,7 +150,10 b' class ZMQChannelHandler(AuthenticatedZMQStreamHandler):'
             self.log.info("%s closed, closing websocket.", self)
             self.close()
             return
-        msg = json.loads(msg)
+        if isinstance(msg, bytes):
+            msg = deserialize_binary_message(msg)
+        else:
+            msg = json.loads(msg)
         self.session.send(self.zmq_stream, msg)
 
     def on_close(self):

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

@@ -129,12 +129,12 b' define(['
         return this.kernel.send_shell_message("comm_open", content, callbacks, metadata);
     };
     
-    Comm.prototype.send = function (data, 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);
+        return this.kernel.send_shell_message("comm_msg", content, callbacks, metadata, buffers);
     };
     
     Comm.prototype.close = function (data, callbacks, metadata) {

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

@@ -70,7 +70,7 b' define(['
     /**
      * @function _get_msg
      */
-    Kernel.prototype._get_msg = function (msg_type, content, metadata) {
+    Kernel.prototype._get_msg = function (msg_type, content, metadata, buffers) {
         var msg = {
             header : {
                 msg_id : utils.uuid(),
@@ -81,6 +81,7 b' define(['
             },
             metadata : metadata || {},
             content : content,
+            buffers : buffers || [],
             parent_header : {}
         };
         return msg;
@@ -597,12 +598,12 b' define(['
      *
      * @function send_shell_message
      */
-    Kernel.prototype.send_shell_message = function (msg_type, content, callbacks, metadata) {
+    Kernel.prototype.send_shell_message = function (msg_type, content, callbacks, metadata, buffers) {
         if (!this.is_connected()) {
             throw new Error("kernel is not connected");
         }
-        var msg = this._get_msg(msg_type, content, metadata);
-        this.channels.shell.send(JSON.stringify(msg));
+        var msg = this._get_msg(msg_type, content, metadata, buffers);
+        this.channels.shell.send(serialize.serialize(msg));
         this.set_callbacks_for_msg(msg.header.msg_id, callbacks);
         return msg.header.msg_id;
     };
@@ -753,7 +754,7 b' define(['
         };
         this.events.trigger('input_reply.Kernel', {kernel: this, content: content});
         var msg = this._get_msg("input_reply", content);
-        this.channels.stdin.send(JSON.stringify(msg));
+        this.channels.stdin.send(serialize.serialize(msg));
         return msg.header.msg_id;
     };
 

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

@@ -6,42 +6,53 b' define(['
     'components/utf8/utf8'
     ], function ($, utf8) {
     "use strict";
-
-    var _deserialize_binary = function(blob, callback) {
+    
+    var _deserialize_array_buffer = function (buf) {
+        var data = new DataView(buf);
+        // read the header: 1 + nbufs 32b integers
+        var nbufs = data.getInt32(0);
+        var offsets = [];
+        var i;
+        for (i = 1; i <= nbufs; i++) {
+            offsets.push(data.getInt32(i * 4));
+        }
+        // have to convert array to string for utf8.js
+        var bytestring = String.fromCharCode.apply(null,
+            new Uint8Array(buf.slice(offsets[0], offsets[1]))
+        );
+        var msg = $.parseJSON(
+            utf8.decode(
+                bytestring
+            )
+        );
+        // the remaining chunks are stored as DataViews in msg.buffers
+        msg.buffers = [];
+        var start, stop;
+        for (i = 1; i < nbufs; i++) {
+            start = offsets[i];
+            stop = offsets[i+1] || buf.byteLength;
+            msg.buffers.push(new DataView(buf.slice(start, stop)));
+        }
+        return msg;
+    };
+    
+    var _deserialize_binary = function(data, callback) {
         // deserialize the binary message format
         // callback will be called with a message whose buffers attribute
         // will be an array of DataViews.
-        var reader = new FileReader();
-        reader.onload  = function () {
-            var buf = this.result; // an ArrayBuffer
-            var data = new DataView(buf);
-            // read the header: 1 + nbufs 32b integers
-            var nbufs = data.getInt32(0);
-            var offsets = [];
-            var i;
-            for (i = 1; i <= nbufs; i++) {
-                offsets.push(data.getInt32(i * 4));
-            }
-            // have to convert array to string for utf8.js
-            var bytestring = String.fromCharCode.apply(null,
-                new Uint8Array(buf.slice(offsets[0], offsets[1]))
-            );
-            var msg = $.parseJSON(
-                utf8.decode(
-                    bytestring
-                )
-            );
-            // the remaining chunks are stored as DataViews in msg.buffers
-            msg.buffers = [];
-            var start, stop;
-            for (i = 1; i < nbufs; i++) {
-                start = offsets[i];
-                stop = offsets[i+1] || buf.byteLength;
-                msg.buffers.push(new DataView(buf.slice(start, stop)));
-            }
+        if (data instanceof Blob) {
+            // data is Blob, have to deserialize from ArrayBuffer in reader callback
+            var reader = new FileReader();
+            reader.onload = function () {
+                var msg = _deserialize_array_buffer(this.result);
+                callback(msg);
+            };
+            reader.readAsArrayBuffer(data);
+        } else {
+            // data is ArrayBuffer, can deserialize directly
+            var msg = _deserialize_array_buffer(data);
             callback(msg);
-        };
-        reader.readAsArrayBuffer(blob);
+        }
     };
 
     var deserialize = function (data, callback) {
@@ -55,7 +66,63 b' define(['
         }
     };
     
-    return {
-        deserialize : deserialize
+    var _bytes2buf = function (bytestring) {
+        // convert bytestring to UInt8Array
+        var nbytes = bytestring.length;
+        var buf = new Uint8Array(nbytes);
+        for (var i = 0; i < nbytes; i++) {
+            buf[i] = bytestring.charCodeAt(i);
+        }
+        return buf;
+    };
+    
+    var _serialize_binary = function (msg) {
+        // implement the binary serialization protocol
+        // serializes JSON message to ArrayBuffer
+        msg = $.extend({}, msg);
+        var offsets = [];
+        var buffers = msg.buffers;
+        delete msg.buffers;
+        var json_utf8 = _bytes2buf(utf8.encode(JSON.stringify(msg)));
+        buffers.unshift(json_utf8);
+        var nbufs = buffers.length;
+        offsets.push(4 * (nbufs + 1));
+        var i;
+        for (i = 0; i + 1 < buffers.length; i++) {
+            offsets.push(offsets[offsets.length-1] + buffers[i].byteLength);
+        }
+        var msg_buf = new Uint8Array(
+            offsets[offsets.length-1] + buffers[buffers.length-1].byteLength
+        );
+        // use DataView.setInt32 for network byte-order
+        var view = new DataView(msg_buf.buffer);
+        // write nbufs to first 4 bytes
+        view.setInt32(0, nbufs);
+        // write offsets to next 4 * nbufs bytes
+        for (i = 0; i < offsets.length; i++) {
+            view.setInt32(4 * (i+1), offsets[i]);
+        }
+        // write all the buffers at their respective offsets
+        for (i = 0; i < buffers.length; i++) {
+            msg_buf.set(new Uint8Array(buffers[i].buffer), offsets[i]);
+        }
+        
+        // return raw ArrayBuffer
+        return msg_buf.buffer;
+    };
+    
+    var serialize = function (msg) {
+        console.log(msg.buffers, msg.buffers.length);
+        if (msg.buffers && msg.buffers.length) {
+            return _serialize_binary(msg);
+        } else {
+            return JSON.stringify(msg);
+        }
+    };
+    
+    var exports = {
+        deserialize : deserialize,
+        serialize: serialize
     };
+    return exports;
 });
  No newline at end of file