first commit

Author: Kyle Laplante

README.md

@@ -0,0 +1,42 @@
+A tornado RPC library.
+
+This RPC framework uses tornado
+so its very quick and asynchronous.
+
+This framework supports regular and
+asynchronous methods to be registered
+with the TornRPCServer. The below example
+shows both. The only difference in the
+framework is how you register it.
+Normal functions are registered using
+"server.register()". Async functions
+are registered using "server.register_async()".
+
+For more detailed info see the docstring
+for TornRPCClient and TornRPCServer.
+
+Example:
+### example server code ###
+
+from tornado import gen
+from tornrpc.server import TornRPCServer
+
+def test(arg):
+  return "You said %s" % arg
+
+@gen.coroutine
+def testasync(arg):
+  raise gen.Return("You said async %s" % arg)
+
+server = TornRPCServer()
+server.register(test)
+server.register_async(testasync)
+server.start(8080)
+
+### example client code ###
+
+from tornrpc.client import TornRPCClient
+
+client = TornRPCClient('localhost:8080')
+client.test('hi')
+client.testasync('hi')

setup.py

@@ -0,0 +1,58 @@
+from setuptools import setup
+
+description = """
+A tornado RPC library.
+
+This RPC framework uses tornado
+so its very quick and asynchronous.
+
+This framework supports regular and
+asynchronous methods to be registered
+with the TornRPCServer. The below example
+shows both. The only difference in the
+framework is how you register it.
+Normal functions are registered using
+"server.register()". Async functions
+are registered using "server.register_async()".
+
+For more detailed info see the docstring
+for TornRPCClient and TornRPCServer.
+
+Example:
+### example server code ###
+
+from tornado import gen
+from tornrpc.server import TornRPCServer
+
+def test(arg):
+  return "You said %s" % arg
+
+@gen.coroutine
+def testasync(arg):
+  raise gen.Return("You said async %s" % arg)
+
+server = TornRPCServer()
+server.register(test)
+server.register_async(testasync)
+server.start(8080)
+
+### example client code ###
+
+from tornrpc.client import TornRPCClient
+
+client = TornRPCClient('localhost:8080')
+client.test('hi')
+client.testasync('hi')
+"""
+
+setup(
+  name='TornRPC',
+  version='1.0.4',
+  description='A tornado RPC framework',
+  long_description=description,
+  author='Kyle Laplante',
+  author_email='[email protected]',
+  keywords='rpc tornado asynchronous web',
+  packages=['tornrpc', 'tornrpc/client', 'tornrpc/server'],
+  install_requires=['tornado'],
+)

tornrpc/README

@@ -0,0 +1,42 @@
+A tornado RPC library.
+
+This RPC framework uses tornado
+so its very quick and asynchronous.
+
+This framework supports regular and
+asynchronous methods to be registered
+with the TornRPCServer. The below example
+shows both. The only difference in the
+framework is how you register it.
+Normal functions are registered using
+"server.register()". Async functions
+are registered using "server.register_async()".
+
+For more detailed info see the docstring
+for TornRPCClient and TornRPCServer.
+
+Example:
+### example server code ###
+
+from tornado import gen
+from tornrpc.server import TornRPCServer
+
+def test(arg):
+  return "You said %s" % arg
+
+@gen.coroutine
+def testasync(arg):
+  raise gen.Return("You said async %s" % arg)
+
+server = TornRPCServer()
+server.register(test)
+server.register_async(testasync)
+server.start(8080)
+
+### example client code ###
+
+from tornrpc.client import TornRPCClient
+
+client = TornRPCClient('localhost:8080')
+client.test('hi')
+client.testasync('hi')

tornrpc/__init__.py

@@ -0,0 +1,90 @@
+import json
+import requests
+from urlparse import urljoin
+
+class _RPC(object):
+  __HEADERS__ = {'User-Agent': 'TornRPCClient'}
+
+  def __init__(self, server, name):
+    self._name = name
+    self._url = urljoin(server, name)
+
+  def __call__(self, *args, **kwargs):
+    if args:
+      # the server will turn this list into
+      # positional args
+      kwargs['__args'] = args
+
+    try:
+      resp = requests.get(self._url, data=kwargs, headers=self.__HEADERS__)
+    except Exception as e:
+      raise TornRPCClient.FailedCall(e)
+
+    if resp.status_code == 404:
+      raise TornRPCClient.MissingMethod(
+          'No remote method found for {0}'.format(self._name))
+
+    try:
+      ret = json.loads(resp.content)
+    except Exception as e:
+      raise TornRPCClient.InvalidSerializationError(e)
+
+    if 'error' in ret:
+      raise TornRPCClient.FailedCall(ret['error'])
+
+    return ret['response']
+
+class TornRPCClient(object):
+  """
+  Client for talking to TornRPCServer servers.
+
+  Example:
+    from tornrpc.client import TornRPCClient
+    client = TornRPCClient('http://myserver.com:9091')
+
+    # If you want to include some methods that are not allowed
+    # to be called include them in the unallowed_methods argument
+    # to the constructor. If you do not want auto-completion or dir
+    # fulfillment use load_remotes=False in the constructor.
+
+    # then just call any remote method on your client
+    client.remote_method_name(args)
+  """
+
+  class FailedCall(Exception): pass
+  class InvalidSerializationError(Exception): pass
+  class MissingMethod(Exception): pass
+
+  __UNALLOWED__ = [
+    # iPython calls these when using tab-complete.
+    # dont allow these methods to be sent to the
+    # server since _loadremotemethods() takes care
+    # of tab-completion.
+    'trait_names',
+    '_getAttributeNames',
+  ]
+
+  def __init__(self, server, unallowed_calls=[], load_remotes=True):
+    if server.startswith('http'):
+      self._server = server
+    else:
+      self._server = 'http://{0}'.format(server)
+    self._unallowed = unallowed_calls + self.__UNALLOWED__
+    if load_remotes:
+      self.__loadremoteroutes()
+
+  def __send(self, name):
+    return _RPC(self._server, name)
+
+  def __remoteroutes(self):
+    return self._getroutes()
+
+  def __loadremoteroutes(self):
+    for route in self.__remoteroutes():
+      setattr(self, route, self.__send(route))
+
+  def __getattr__(self, name):
+    return None if name in self._unallowed else self.__send(name)
+
+
+__all__ = ('TornRPCClient')

tornrpc/client/__init__.py

@@ -0,0 +1,105 @@
+from tornado import (
+    gen,
+    ioloop,
+    log,
+    web
+)
+
+from .handlers import _AsyncBase, _Base
+
+class TornRPCServer(object):
+  """
+  Server for TornRPC.
+
+  Example:
+    from tornrpc.server import TornRPCServer
+    server = TornRPCServer()
+
+    # create your functions and register them
+    # to the server.
+    # you dont need to use async funcs
+    # but it is recommended.
+    # Here is an example that uses both asycn
+    # and non-async
+
+    def not_async(arg=None):
+      return arg
+
+    @gen.coroutine
+    def is_async(arg=None):
+      raise gen.Return(arg)
+
+    server.register(not_async)
+    server.register_async(is_async)    
+
+    # start the server on the desired port
+    port = 8080
+    server.start(port)
+
+  Use the TornRPCClient to talk to this server
+  """
+
+  def __init__(self):
+    self._routes = []
+    self.log = log.logging.getLogger()
+    self.log.setLevel(log.logging.INFO)
+    log.enable_pretty_logging(logger=self.log)
+    self.register_async(self._getroutes)
+
+  @gen.coroutine
+  def _getroutes(self):
+    # this is support for the client to have a list
+    # of all the remote methods
+    raise gen.Return([v.__name__ for _, v in self._routes])
+
+  def _make(self, func, base):
+    name = func.__name__
+    # put func into a list as the only item because if
+    # we assign it as a method it will be required to have
+    # self as the first arg and we dont want that
+    handler = type(name, (base,), {'func': [func]})
+    self._routes.append((r'/{0}'.format(name), handler))
+    self.log.info('Registered {0} command {1}'.format(base.TYPE, name))
+
+  def register(self, func):
+    """
+    Register normal synchronous functions.
+    Use this to register functions
+    that do NOT return Futures.
+
+    Just pass the function name:
+      def test():
+        return True
+      register(test)
+    """
+
+    self._make(func, _Base)
+
+  def register_async(self, func):
+    """
+    Register an asynchronous function.
+    Use this to register functions that
+    DO return Futures. Generally these
+    functions will be wrapped in
+    @gen.coroutine.
+
+    Just pass the function name:
+      @gen.coroutine
+      def test():
+        raise gen.Return(True)
+    """
+
+    self._make(func, _AsyncBase)
+
+  def start(self, port):
+    """
+    Start a TornRPCServer on the defined port
+    """
+
+    self.log.info('Starting server on port {0}'.format(port))
+    app = web.Application(self._routes, debug=True)
+    app.listen(int(port))
+    ioloop.IOLoop.current().start()
+
+
+__all__ = ('TornRPCServer')