root / tabled.tac

"""
"""
from games.holdem.holdemtable import holdemtable
import protocol
import simplejson
from twisted.internet.protocol import Factory
from twisted.protocols.basic import NetstringReceiver
from twisted.internet import defer
from twisted.application import internet, service
from twisted.web2 import http, resource, channel, server, static
from path import path
import ucomet
from ucomet import encodejson,decodejson


tables = {}
class BasePokerTableHandler:
    def __init__(self):
        self.table = None
        self.__id = None
    
    def sendData(self, data):
        self.sendMessageViaTransport( data )
        d = defer.Deferred()
        d.addCallback(self.sendData)
        self.table.addDeferred(self.__id, d)

    def sendMessageViaTransport(self,data):
        """This needs to be overidden"""
        pass

    def dataReceived(self,data):

        if data == None or "method" not in data:
            self.sendMessageViaTransport( 
                protocol.MakeError(101,"Messages must contain methods"))
            return
        else: method = data["method"]
        if method == "connect":
            if self.table or self.__id:
                self.sendMessageViaTransport( 
                    protocol.MakeError(103,"Already connected"))
                return
            table_name = data["table_name"]

            if not table_name in tables:
                tables[table_name]=holdemtable(table_name)

            self.table = tables[table_name]
            if self.table.isFull():
                self.sendMessageViaTransport(
                        protocol.MakeError(104,"Table is full"))
                return
            else:
                self.__id = data['client_id']
                d = defer.Deferred()
                d.addCallback(self.sendData)
                self.table.addPlayer(data, d)
        elif method == "action":
            value =  data["value"]
            if value == "null": value = None
            if value != None: value = float(value)
            self.table.action(self.__id, data["action"],value)
        else:
            self.sendMessageViaTransport( protocol.MakeError(102,"Unknown Method")) 

class PokerTableProtocol(NetstringReceiver,BasePokerTableHandler):

    def sendMessageViaTransport(self,data):
        NetstringReceiver.sendString(self, encodejson(data))
        

    def stringReceived(self, data):
        self.dataReceived(decodejson(data))
        
    def connectionLost(self, reason):
        pass

clientChannels = [ r"\/poker" ]

class PokerSubscription(ucomet.ClientSubscription, BasePokerTableHandler):
    def __init__(self, channel, sendMessageCallback):
        BasePokerTableHandler.__init__(self)
        ucomet.ClientSubscription.__init__(self, channel, sendMessageCallback)

    def messageReceived(self,message):
        self.dataReceived(message)

    def sendMessageViaTransport(self,data):
        self.sendMessage(data)





"""
def makeToken( id, table ):
    #TODO make this a bit more secure
    return id + "$$$" + table

class PokerTableWebHandler(BasePokerTableHandler):
    def __init__(self):
        BasePokerTableHandler.__init__(self)
        #request consists of (jsoncallback,deferred)
        self.__waitingRequest=[]
        self.__messageQueue=[]

    def sendMessageViaTransport(self, data):
        self.__messageQueue.append(data)
        #for json callbacks
        #else: self.__messageQueue.append(str("%s(%s)" % (self.jsoncallback, data)))

    def sendMessage(self, data):
        #Add your token name to the data
        data["token"] = makeToken( self.id, self.table.name )
        BasePokerTableHandler.sendMessage(self,data)
        self.checkWaiting()

    def checkWaiting(self):
        if len(self.__waitingRequest) > 0 and len(self.__messageQueue) > 0:
            print "SENDING RESPONSE TO HTTP"
            d = self.__waitingRequest.pop(0)
            d[1].callback((self.__messageQueue, d[0]))
            self.__messageQueue = []

    def __doResponse(self,dat):
        resp,jsoncallback = dat
        return str("%s(%s)" % (jsoncallback,encodejson(resp)))

    def doRenderStuff(self,nargs):
        if "jsoncallback" in nargs:
            jsoncallback = nargs["jsoncallback"]

        d = defer.Deferred()
        #yeah, i know we're going to unparse
        d.addCallback( self.__doResponse )
        print "ADDING REQUEST"
        self.__waitingRequest.append( (jsoncallback, d) )

        if "method" in nargs and not nargs["method"] == "get_update":
            self.dataReceived(encodejson(nargs))

        self.checkWaiting()


        return d


class PokerTableWebProtocoll(rend.Page):
    addSlash = True
    
    def __init__(self):
        self.__webHandlers = {}

    def renderHTTP(self, ctx):
        nargs = {}
        print "---------------"
        request = IRequest(ctx)
        args = request.args
        request.setHeader("Content-type", "text/javascript")
        for k,v in args.items(): nargs[k] = v[0]
        handler = None
        print nargs



        if "token" in nargs: handler =  self.__webHandlers[nargs["token"]]
        elif "method" in nargs and nargs["method"] == "connect":
            token = makeToken(nargs["client_id"], nargs["table_name"])
            handler = PokerTableWebHandler()
            self.__webHandlers[token] = handler
        else: return http.Response(stream=encodejson(protocol.error(200,"Require either token or connect")))

        return handler.doRenderStuff(nargs)

"""
class CometdRunner(resource.Resource):
    addSlash = True
    child_web = static.File(path("web").abspath())
    child_cometd = ucomet.ucomet()
#    child_cometd.ClientType = WebClient
    child_cometd.ClientSubscriptionType = PokerSubscription
    def render(self, ctx):
        return http.Response( stream="hi")


port = 8007#int(sys.argv[1])
port2 = 8080#int(sys.argv[1])

factory = Factory()
factory.protocol = PokerTableProtocol


site = server.Site(CometdRunner())
application = service.Application("cometd")

myService = service.MultiService()
internet.TCPServer(port, factory).setServiceParent(myService)
internet.TCPServer(port2, channel.HTTPFactory(site)).setServiceParent(myService)

application = service.Application( "dpoker" )


myService.setServiceParent(application)

print "Listening on localhost:%d(tcp) %d(http)" % (port, port2)