tornado websockets supporting binary part 2

After looking though the source code of the websocket library, I found that by default it is formatting the packets as text. By changing the line:

ws.send('message')
# to:
   ws.send('message', opcode = websocket.ABNF.OPCODE_BINARY)
# or better yet:
   ws.send_binary('message')

Suggestion : 2

After looking though the source code of the websocket library, I found that by default it is formatting the packets as text. By changing the line:,Rspec selenium not finding data after returning from outside url without setting environment to development,I would like to change this code to display only OK and delete the cancel button,Changing an element in one list changes multiple lists

ws.send('message')
# to:
   ws.send('message', opcode = websocket.ABNF.OPCODE_BINARY)
# or better yet:
   ws.send_binary('message')

Suggestion : 3

The message may be either a string or a dict (which will be encoded as json). If the binary argument is false, the message will be sent as utf8; in binary mode any byte string is allowed.,WebSockets are supported in the current versions of all major browsers, although older versions that do not support WebSockets are still in use (refer to http://caniuse.com/websockets for details).,The data argument allows a small amount of data (up to 125 bytes) to be sent as a part of the ping message. Note that not all websocket implementations expose this data to applications.,Returns a future whose result is the message, or None if the connection is closed. If a callback argument is given it will be called with the future when it is ready.

class EchoWebSocket(tornado.websocket.WebSocketHandler):
   def open(self):
   print("WebSocket opened")

def on_message(self, message):
   self.write_message(u "You said: " + message)

def on_close(self):
   print("WebSocket closed")

var ws = new WebSocket("ws://localhost:8888/websocket");
ws.onopen = function() {
   ws.send("Hello, world");
};
ws.onmessage = function(evt) {
   alert(evt.data);
};

def check_origin(self, origin):
   return True

def check_origin(self, origin):
   parsed_origin = urllib.parse.urlparse(origin)
return parsed_origin.netloc.endswith(".mydomain.com")

conn = yield websocket_connect(url)
while True:
   msg = yield conn.read_message()
if msg is None: break
# Do something with msg

Suggestion : 4

In this article, we will take a look at how a simple WebSocket server can be built in Python using Tornado. The demo application will allow us to upload a tab-separated values (TSV) file, parse it and make its contents available at a unique URL.,Since our goal is to show uploaded TSV data in chunks of small pages, we need a means of requesting a particular page. To keep things simple, we will simply use the same WebSocket connection to send the page number to our server.,For front-end, we will use AngularJS. This framework and libraries will allow us to easily handle file uploads and pagination. For everything related to WebSockets, however, we will use standard JavaScript functions.,Tornado comes with its own implementation of WebSockets. For the purposes of this article, this is pretty much all we will need.

Installing Tornado is rather simple. It is listed in PyPI and can be installed using pip or easy_install:

pip install tornado

From the front-end, a WebSocket connection can be established by instantiating a WebSocket object:

new WebSocket(WEBSOCKET_URL);

open: fired when a connection is established
message: fired when a message is received from the server
close: fired when a connection is closed

$scope.init = function() {
   $scope.ws = new WebSocket('ws://' + location.host + '/parser/ws');
   $scope.ws.binaryType = 'arraybuffer';

   $scope.ws.onopen = function() {
      console.log('Connected.')
   };
   $scope.ws.onmessage = function(evt) {
      $scope.$apply(function() {
         message = JSON.parse(evt.data);
         $scope.currentPage = parseInt(message['page_no']);
         $scope.totalRows = parseInt(message['total_number']);
         $scope.rows = message['data'];
      });
   };
   $scope.ws.onclose = function() {
      console.log('Connection is closed...');
   };
}

$scope.init();

When you want to transfer binary data, you can choose among array buffer and blob. If it is just raw data like an image file, choose blob and handle it properly in server. Array buffer is for fixed-length binary buffer and a text file like TSV can be transferred in the format of byte string. This code snippet shows how to upload a file in array buffer format.

$scope.uploadFile = function(file, errFiles) {
   ws = $scope.ws;
   $scope.f = file;
   $scope.errFile = errFiles && errFiles[0];
   if (file) {
      reader = new FileReader();
      rawData = new ArrayBuffer();

      reader.onload = function(evt) {
         rawData = evt.target.result;
         ws.send(rawData);
      }

      reader.readAsArrayBuffer(file);
   }
}

Tornado determines the message type using the 4bit opcode, and returns str for binary data and unicode for text.

if opcode == 0x1:
   # UTF - 8 data
self._message_bytes_in += len(data)
try:
decoded = data.decode("utf-8")
except UnicodeDecodeError:
   self._abort()
return self._run_callback(self.handler.on_message, decoded)
elif opcode == 0x2:
   # Binary data
self._message_bytes_in += len(data)
self._run_callback(self.handler.on_message, data)

Suggestion : 5

To establish a WebSocket connection, the client and server upgrade from the HTTP protocol to the WebSocket protocol during their initial handshake, as shown in Figure and Listing 1. Note that this connection description represents the latest version of the protocol, as defined in IETF RFC 6455.,When you make a WebSocket connection, you have the option of listing the protocols your application can speak. The second argument to the WebSocket constructor can be a string or array of strings with the names of the subprotocols that your application understands and wishes to use to communicate.,What happens with WebSocket connectivity in the real world when you move away from localhost tests and proof of concepts? This section will cover what happens when a WebSocket connection traverses intermediaries on the network and what can be done to make WebSocket work in older browsers.,In the bottom half of the figure, you see the reduction in latency provided by the WebSocket solution. Once the connection is upgraded to WebSocket, messages can flow from server to browser the moment they arrive.

From client to server:

GET / chat HTTP / 1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec - WebSocket - Key: dGhlIHNhbXBsZSBub25jZQ ==
   Origin: http: //example.com
   Sec - WebSocket - Protocol: chat, superchat
Sec - WebSocket - Version: 13

From server to client:

HTTP / 1.1 HTTP / 1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec - WebSocket - Accept: s3pPLMBiTxaQ9kYGzza

Listing 2. HTTP request headers

GET / HTTP / 1.1
Host: example.com
User - Agent: Mozilla / 5.0(Macintosh; Intel Mac OS X 10.6; rv: 12.0 a2) Gecko / 20120218 Firefox / 12.0 a2
Accept: text / html, application / xhtml + xml, application / xml;
q = 0.9, *
/*;q=0.8
  Accept-Language: en-us,en;q=0.5
  Accept-Encoding: gzip, deflate
  Connection: keep-alive
  Cookie: __utma=23498jrt34mfjkeiwmfjif9o
  Cache-Control: max-age=0

Listing 4. Checking for browser support

if (window.WebSocket) {
   alert("WebSocket is supported");
} else {
   alert("WebSocket is not supported");
}

Using the WebSocket interface is quite straightforward. To connect to an endpoint, just create a new WebSocket instance, providing the new object with a URL that represents the endpoint to which you wish to connect. You can use the ws:// and wss:// prefixes to indicate a WebSocket and a WebSocket Secure connection, respectively.

url = "ws://localhost:8080/echo";
w = new WebSocket(url)

When you make a WebSocket connection, you have the option of listing the protocols your application can speak. The second argument to the WebSocket constructor can be a string or array of strings with the names of the subprotocols that your application understands and wishes to use to communicate.

w = new WebSocket(url, protocol);

Hypothetically, proto1 and proto2 are well defined protocol names that both the client and server can understand; they may even be registered and standardized. The server will select a prefered protocol from the list. When the socket opens, its protocol property will contain the protocol that the server chooses.

onopen = function(e) {
   // determine which protocol the server selected
   log(e.target.protocol)
}

A WebSocket object dispatches four events: open, message, close, and error. The open event fires when a connection is established, the message event when messages are received, the close event when the WebSocket connection is closed, and the error event when an error occurs. The error event fires in response to unexpected failure. As in most JavaScript APIs, there are corresponding callbacks (onopen, onmessage, onclose, and onerror) that are called when events are dispatched.

w.onopen = function() {
   console.log("open");
   w.send("Connection open");
}
w.onmessage = function(e) {
   console.log(e.data);
}
w.onclose = function(e) {
   console.log("closed");
}
w.onerror = function(e) {
   console.log("error");
}

If a browser is configured to use an explicit proxy server, it will first issue the HTTP CONNECT method to that proxy server while establishing the WebSocket connection. For example, to connect to the server example. com using the ws:// scheme (typically over port 80), the browser client sends the HTTP CONNECT method to the proxy server as follows:

CONNECT example.com: 80 HTTP / 1.1
Host: example.com