Question

I’m trying to procedurally generate images in python to send to a node.js instance, so I can then deliver those images real-time to a browser through a websocket.

My first test iteration was simply opening a jpeg file in my node.js server, encoding it into base64, and sending it to the browser using socket.io (on port 81). This worked fine every time data was sent.

I then tried opening the same file in python, connecting to a raw TCP node.js server (on port 9090), and sending the file to the node server for it to forward to the browser (on port 81). About half the time, the data node receives seems to be broken, yet the data python reads from the file is fine every time.

What surprises me is that the data channel between node and the browser is fine, yet that between python and node isn’t. Is it the case that websockets provides some error-correction that is not present in a raw TCP socket. If not, what might be causing this error?

Thanks.

JS Code

var io = require('socket.io').listen(81);
var fs = require('fs');
var path = require('path');
var net = require('net');

var mousex = 0;
var mousey = 0;
var imgdata = "";
var oldimgdata = "";
var imagehaschanged = true;

//Serving python
var server = net.createServer(function (stream) {
  stream.setEncoding("base64");
  stream.on("connect", function () {
    console.log("rendering client connected");
  });
  stream.on("data", function (data) {

    //parsed = JSON.parse(data);
    imgdata = data;
    preview = imgdata.substr(0,50);
    console.log(preview);
    if (imgdata!=oldimgdata) {
        imagehaschanged=true;
    }

    console.log("rendering client sent data:");
    posdata = JSON.stringify({'x':mousex ,'y':mousey});
    stream.write(posdata, "ascii", function() {
        console.log("Sent response");
    });

  });
  stream.on("end", function () {
    stream.end();
    console.log("rendering client closed connection");
  });
});
server.listen(9090);

//Serving web
io.sockets.on('connection', function (socket) {
  socket.emit('ready');
  socket.on('position', function(data){
      mousex = data.x;
      mousey = data.y;

      if (imagehaschanged) {
        socket.emit('image', {data: imgdata});
        oldimgdata = imgdata;
        imagehaschanged = false;
      }


      //fs.readFile("1.jpg", processRead);
      //console.log(data.x + ", " + data.y)
  });
});

Python Code

import socket, json,# base64
from time import sleep, time

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('localhost', 9090))

while 1:
    t0 = time()
    f = open("1.jpg")
    data = f.read()
    f.close()
    imgdata = data # base64.b64encode(data)
    print imgdata[:50]
    len = s.send(imgdata)
    response = json.loads(s.recv(4096))
    print "Response is:", response
    sleep(2)
    print "Time taken is: ", time()-t0

Answer 1

regardless on how many writes was on client side of tcp socket and what were sizes of messages you generally don’t have control on sizes of data chunks you’ll get on serever’s ‘data’ handler (tcp only guarantees they are in order). You need to frame your data manually (simplest way is to prefix with frame size and buffer incoming data)

see also this question