wsrpc-aiohttp 2.1.0

WSRPC is the RPC over WebSocket for aiohttp

Remote Procedure call through WebSocket between browser and tornado.

Features

• Initiating call client function from server side.
• Calling the server method from the client.
• Transferring any exceptions from a client side to the server side and vise versa.
• The frontend-library are well done for usage without any modification.
• Fully asynchronous server-side functions.
• Thread-based websocket handler for writing fully-synchronous code (for synchronous database drivers etc.)
• Protected server-side methods (starts with underline never will be call from clients-side directly)
• Asynchronous connection protocol. Server or client can call multiple methods with unpredictable ordering of answers.
• If ujson is installed messages will be serialize/deserialize with it.

Installation

Install via pip:

pip install wsrpc-aiohttp

Install ujson if you want:

pip install ujson

Simple usage

Add the backend side

from time import time
## If you want write async tornado code import it
# from from wsrpc import WebSocketRoute, WebSocket, wsrpc_static
## else you should use thread-base handler
from wsrpc import WebSocketRoute, WebSocketThreaded as WebSocket, wsrpc_static

tornado.web.Application((
    # js static files will available as "/js/wsrpc.min.js".
    wsrpc_static(r'/js/(.*)'),
    # WebSocket handler. Client will connect here.
    (r"/ws/", WebSocket),
    # Serve other static files
    (r'/(.*)', tornado.web.StaticFileHandler, {
         'path': os.path.join(project_root, 'static'),
         'default_filename': 'index.html'
    }),
))

# This class should be call by client.
# Connection object will be have the instance of this class when will call route-alias.
class TestRoute(WebSocketRoute):
    # This method will be executed when client will call route-alias first time.
    def init(self, **kwargs):
        # the python __init__ must be return "self". This method might return anything.
        return kwargs

    def getEpoch(self):
        # this method named by camelCase because the client can call it.
        return time()

# stateful request
# this is the route alias TestRoute as "test1"
WebSocket.ROUTES['test1'] = TestRoute

# stateless request
WebSocket.ROUTES['test2'] = lambda *a, **kw: True

# initialize ThreadPool. Needed when using WebSocketThreaded.
WebSocket.init_pool()

Add the frontend side

<script type="text/javascript" src="/js/q.min.js"></script>
<script type="text/javascript" src="/js/wsrpc.min.js"></script>
<script>
    var url = ((window.location.protocol==="https):"?"wss://":"ws://") + window.location.host + '/ws/';
    RPC = WSRPC(url, 5000);
    RPC.addRoute('test', function (data) { return "Test called"; });
    RPC.connect();

    RPC.call('test1.getEpoch').then(function (data) {
        console.log(data);
    }, function (error) {
        alert(error);
    }).done();

    RPC.call('test2').then(function (data) { console.log(data); }).done();
</script>

Reverse call from Server to Client

backend:

def do_notify(self):
    awesome = 'Notification for you!'
    yield self.socket.call('notify', result=awesome)

frontend:

<script>
    var url = (window.location.protocol==="https:"?"wss://":"ws://") + window.location.host + '/ws/';
    RPC = WSRPC(url, 5000);
    RPC.addRoute('notify', function (data) { return data.result; });
    RPC.connect();
</script>

Documentation

All available documentation here.

Example

Example running there demo.