会说话的狗

#coding=gbk
import time
import struct
import socket
import logging
import traceback
import threading
import binascii
 
import Object
import Config
import ClientEvent
import SocketServer
import MsgPackage
import Connection
import Game.M as M
import Game.I as I
 
class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
    '''线程请求管理'''
 
    def setup(self):
        self.request.settimeout(Config.CLIENT_OUTTIME)
 
    def send(self, command, info):
        _data = MsgPackage.pack(command, info)
        _len = len(_data)
        _data = struct.pack('>L', _len) + _data
        self.request.send(_data)
        logging.info('send[%s] data[%s]:%s', M.get(command), _len, info)
 
    def handle(self):
        try:
            while True:
                ctime = time.time()
                buf = self.request.recv(4)
                if not buf:
                    break
 
                cmd_len = struct.unpack('>L', buf)[0]
                data = ''
                while len(data) < cmd_len:
                    obuf = self.request.recv(cmd_len - len(data))
                    if not obuf:
                        raise Exception('not receive anything!')
                    data += obuf
 
                _data = MsgPackage.unpack(data)
                logging.info('get[%s] data[%s]:%s', M.get(_data['c']), cmd_len, data)
 
                ret = ClientEvent.deal(_data['c'], _data['i'], self)
 
                if ret: #有返回消息
                    self.send(*ret)
 
        except socket.timeout:#连接超时
            cur_thread = threading.currentThread()
            emsg = cur_thread.getName() + ' timeout connect!'
            logging.info(emsg)
 
        except:
            logging.error('error in ThreadedTCPRequestHandler :%s, res:', traceback.format_exc())
 
        self.request.close()
        Connection.unbind(self.request)
 
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass
 
class Server:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.server = None
        ThreadedTCPServer.allow_reuse_address = True
 
    def run(self):
        server_check = threading.Thread(target=self.check)
        server_check.setDaemon(True)
        server_check.start()
 
        self.server = ThreadedTCPServer((self.host, self.port), ThreadedTCPRequestHandler)
        self.server.serve_forever()
 
    def check(self):
        while not Object.END_EVENT.isSet():
            Object.END_EVENT.wait(2)
 
        self.shutdown()
 
    def stop(self):
        self.shutdown()
 
if __name__ == '__main__':
    Server('0.0.0.0', 25525).run()

#coding=gbk
import time
import traceback
import logging
import threading
 
import Config
import Queue
import Object
 
_INSTANCE_ = None
 
 
class GameServer:
 
    def __init__(self):
        self._table_conf = {}
        self._table_msgq = {}
 
    def join_table(self, table):
        if self._table_conf.has_key(table.table_id):
            return -1
 
        self._table_conf[table.table_id] = table
        self._table_msgq[table.table_id] = Queue.Queue()
        logging.info('table[%s] created!', table.table_id)
 
    def do_event(self, table_id, uid, command, info):
        '''处理一个事件'''
        t_queue = self._table_msgq.get(table_id, None)
        if not t_queue:
            return -1
        t_queue.put({'uid':uid, 'event':command, 'info':info})
        return True
 
    def get_event(self, table_id):
        '''获取一个事件'''
        t_queue = self._table_msgq.get(table_id, None)
        if not t_queue:
            return {}
        try:
            return t_queue.get_nowait()
        except:
            return {}
 
    def start(self):
        t = threading.Thread(target = self.run)
        t.setDaemon(True)
        t.start()
        return self
 
    def run(self):
        while not Object.END_EVENT.isSet():
            try:
                for tid, table in self._table_conf.items():
                    #logging.info('%s, %s, %s', table.status, table.wait_next_uid, table.wait_end_uid)
                    if table.status != Config.GAMEOVER_STATUS:
                        table.check(self.get_event(tid))
 
                time.sleep(1)
            except:
                logging.error('error in GameServer.run:%s', traceback.format_exc())
 
 
def getInstance():
    '''获取游戏服务进程'''
    global _INSTANCE_
    if not _INSTANCE_:
        _INSTANCE_ = GameServer()
    return _INSTANCE_