sample_client.py

import json
import requests

matlab_code = "a=magic(3);disp(a)"
python_code = "print 'Hello World!!'"

data = {}
data['matlab_code'] = matlab_code
data['python_code'] = python_code

r = requests.post('http://0.0.0.0:8888/execute', json.dumps(data))

tornado_sample_server.py

from zmq.eventloop.zmqstream import ZMQStream
from zmq.eventloop import ioloop
ioloop.install()


from functools import partial
from tornado import web, gen, escape
from tornado import options, httpserver
from tornado.concurrent import Future

settings = dict()
settings['autoreload'] = True 
settings['debug'] = True

from jupyter_client import MultiKernelManager


reply_futures = {}
kids = []

class MainHandler(web.RequestHandler):
	def get(self):
		self.write("Hello")

class ExecuteHandler(web.RequestHandler):
	def get(self):
		self.write("approaching execute")

	def post(self):
		data = escape.json_decode(self.request.body)
		print data
		self.application.execute_code(data)

class Application(web.Application):

	def __init__(self):

		handlers = []
		handlers.append((r"/", MainHandler))
		handlers.append((r"/execute", ExecuteHandler))
		web.Application.__init__(self, handlers, **settings)
		self.km = MultiKernelManager()
		self.setup_kernels()

	def setup_kernels(self):

		matlab_kernel_id = self.km.start_kernel(kernel_name="matlab")
		python_kernel_id = self.km.start_kernel(kernel_name="python")

		self.matlab_kernel_id = matlab_kernel_id
		self.python_kernel_id = python_kernel_id

		matkab_kernel_client = self.km.get_kernel(matlab_kernel_id).client()
		matkab_kernel_client.start_channels()

		python_kernel_client = self.km.get_kernel(python_kernel_id).client()
		python_kernel_client.start_channels()

		self.matkab_kernel_client = matkab_kernel_client
		self.python_kernel_client = python_kernel_client

		matlab_iopub_stream = ZMQStream(matkab_kernel_client.iopub_channel.socket)
		matlab_shell_stream = ZMQStream(matkab_kernel_client.shell_channel.socket)

		python_iopub_stream = ZMQStream(python_kernel_client.iopub_channel.socket)
		python_shell_stream = ZMQStream(python_kernel_client.shell_channel.socket)

		matlab_iopub_stream.on_recv_stream(partial(self.reply_callback, matkab_kernel_client.session))
		matlab_shell_stream.on_recv_stream(partial(self.reply_callback, matkab_kernel_client.session))

		python_iopub_stream.on_recv_stream(partial(self.reply_callback, python_kernel_client.session))
		python_shell_stream.on_recv_stream(partial(self.reply_callback, python_kernel_client.session))

		kids.append(self.matlab_kernel_id)
		kids.append(self.python_kernel_id)

	def reply_callback(self, session, stream, msg_list):
		idents, msg_parts = session.feed_identities(msg_list)
		reply = session.deserialize(msg_parts)

		if "stream" == reply["msg_type"]:
			print reply["content"]["text"]
		parent_id = reply['parent_header'].get('msg_id')
		reply_future = reply_futures.get(parent_id)
		if reply_future:
			reply_future.set_result(reply)

	def execute_code(self, data):

		matlab_code = data['matlab_code']
		python_code = data['python_code']

		self.execute_matlab_then_python(matlab_code, python_code)

	@gen.coroutine
	def execute_matlab_then_python(self, matlab_code, python_code):

		print "executing matlab code"
		parent_id1 = self.matkab_kernel_client.execute(matlab_code)
		reply_futures[parent_id1] = f1 = Future()
		yield f1

		print "executing python code"
		parent_id2 = self.python_kernel_client.execute(python_code)
		reply_futures[parent_id2] = f2 = Future()
		yield f2

	def shutdown_kernels(self):

		self.km.get_kernel(self.matlab_kernel_id).cleanup_connection_file()
		self.km.shutdown_kernel(self.matlab_kernel_id)

		self.km.get_kernel(self.python_kernel_id).cleanup_connection_file()
		self.km.shutdown_kernel(self.python_kernel_id	)

if __name__ == '__main__':

	options.parse_command_line()
	app = Application()
	server = httpserver.HTTPServer(app)
	server.listen(8888)

	try:
		ioloop.IOLoop.current().start()
	except KeyboardInterrupt:
		print 'going down'
	finally:	
		app.shutdown_kernels()