Ticket #334: server.py

import twisted
from twisted.internet import reactor, defer
from twisted.web import server, static, resource
from twisted.python import versions

import pyamf
from pyamf.remoting.gateway.twisted import TwistedGateway
from pyamf.remoting.gateway import expose_request
from pyamf import register_class

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy.orm import mapper, sessionmaker

import logging
        
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s %(levelname)-5.5s [%(name)s] %(message)s'
)

# We define our tables within a catalog called MetaData, using the
# Table construct, which is used in a manner similar to SQL's CREATE
# TABLE syntax:
metadata = MetaData()

users_table = Table('users', metadata,
                    Column('id', Integer, primary_key=True),
                    Column('name', String(50)),
                    Column('fullname', String),
                    Column('password', String),
                    Column('ip', String(50))
                    )


# Create a rudimentary User class to correspond to our users table.
# It only need subclass Python's built-in object class (i.e. it's a
# new style class):
class User(object):
    def __init__(self, name, fullname, password, ip):
        self.name = name
        self.fullname = fullname
        self.password = password
        self.ip = ip
        
    def __repr__(self):
        return "<User('%s','%s', '%s')>" % (self.name, self.fullname,
                                            self.ip)
    
# Use the mapper function to create a mapping between users_table and
# User. The mapper() function creates a new Mapper object and stores
# it away for future reference, associated with our class.
mapper(User, users_table)
register_class(User, 'org.pyamf.User')

class example:
    """
    An example class that can be used as a PyAMF service
    """
    def __init__(self):
        self.logger = pyamf.logging.instance_logger(self)
        self.pyamf_version = versions.getVersionString(
            versions.Version('PyAMF', *pyamf.__version__))
        self.sqlalchemy_version = 'SQLAlchemy %s' % sqlalchemy.__version__
        self.twisted_version = 'Twisted %s' % twisted.version.base()

        # Use an in-memory-only SQLite database.
        self.engine = create_engine('sqlite:///:memory:', echo=True)

        # Define a Session class which will serve as a factory for new
        # Session objects
        Session = sessionmaker(bind=self.engine)

        # This will create new Session objects which are bound to the
        # database
        self.session = Session()
        
        # Next, we can issue CREATE TABLE statements derived from our table
        # metadata, by calling create_all() and passing it the engine instance
        # which points to our database. This will check for the presence of a
        # table first before creating, so it's safe to call multiple times:
        metadata.create_all(self.engine)

        self.logger.debug(self.twisted_version)
        self.logger.debug(self.pyamf_version)
        self.logger.debug(self.sqlalchemy_version)
        
    def test1(self, request):
        return "Test 1 Success!"
    
    def testn(self, request, n):
        ip = exposedRequest(request)
        
        return "%s said %s!" % (ip, n)

    def add(self, request, username, fullname, password):
        """
        """
        ip = exposedRequest(request)
        new_user = User(username, fullname, password, ip)

        self.session.add(new_user)
        self.session.commit()
        
        return new_user

# This function is decorated to expose the underlying HTTP request
# This allows for accessing things such as the requesting client's IP
@expose_request
def exposedRequest(request):
    return request.getClientIP()

if __name__ == '__main__':
    # Create a dictionary mapping the service namespaces to a function
    # or class instance
    service = {
        'example': example(),
    }

    # Place the namespace mapping into a TwistedGateway
    gateway = TwistedGateway(service)

    # A base root resource for the twisted.web server
    root = resource.Resource()

    # Publish the PyAMF gateway at the root URL
    root.putChild('', gateway)

    # Start the twisted reactor and listen on HTTP port 8080
    print 'Running AMF gateway on http://localhost:8080'

    reactor.listenTCP(8080, server.Site(root))
    reactor.run()