def update_score(score, username, gametype):
send_data = get_send_data()
send_data['type'] = 'update_score'
send_data['gametype'] = gametype
send_data['username'] = username
send_data['score'] = score
netstream.send(sock, send_data)
def notice(self, numOfRetries):
end = None
start = time.time()
for i in range(numOfRetries):
Robot.Mutex.acquire()
Robot.NoticeCnt += 1
Robot.Mutex.release()
sd = {'sid': self.sid, 'type': "notice"}
netstream.send(self.sock, sd)
rd = self.recv()
if rd == netstream.CLOSED:
break
elif rd == netstream.EMPTY or rd == netstream.TIMEOUT:
time.sleep(0.1)
continue
elif rd['type'] == 'notice' and rd[
'content'] == 'Sever is connected':
# end the timer
end = time.time()
break
if end is None:
# Robot.NoticeAbortCnt += 1
return 'NoticeError'
else:
delay = end - start
Robot.Mutex.acquire()
Robot.NoticeSuccessCnt += 1
Robot.NoticeDelaySum += delay
Robot.MinNoticeDelay = min(Robot.MinNoticeDelay, delay)
Robot.MaxNoticeDelay = max(Robot.MaxNoticeDelay, delay)
Robot.Mutex.release()
return True
def request_score(gametype):
recv_message = 0
send_data = get_send_data()
send_data['type'] = 'request_score'
send_data['gametype'] = gametype
print "send request_score"
netstream.send(sock, send_data)
def fix_game_result(recvData):
number = recvData['sid']
print 'receive game_result request from user id:', number
bestScore, bestTime, defeat, myRank = databaseOp.store_Result(recvData['game_result'])
#给客户端发送排名信息
information = str(bestScore) + '\t' + str(bestTime) + '\t' + str(defeat) + '\t' + str(myRank)
sendData = {"re_game_result": information}
netstream.send(onlineUser[number]['connection'], sendData)
def send_message(data, _type):
# possible value of _type:
# 0: registration
# 1: login
# 2: update score
data["type"] = _type
data["sid"] = serialID
netstream.send(sock, data)
def send_score(account, password, score, time, level):
send_data = get_send_data()
print 'send_score', score, account
send_data['account'] = account
send_data['password'] = password
send_data['score'] = score
send_data['time'] = time
send_data['level'] = level
netstream.send(sock, send_data)
def request_login(username, password):
recv_message = 0
send_data = get_send_data()
send_data['type'] = 'login'
send_data['username'] = username
send_data['password'] = password
print "send login"
print send_data['username']
print send_data['password']
netstream.send(sock, send_data)
def request_register(username, password):
recv_message = 0
send_data = get_send_data()
send_data['type'] = 'register'
send_data['username'] = username
send_data['password'] = password
print "send register"
print send_data['username']
print send_data['password']
netstream.send(sock, send_data)
def logout(self, token, usid):
uid = self._getUidCheckToken(token, usid)
if uid == None:
netstream.send(self.connections[usid]['connection'],
{"code": 5}) # code 5 for auth failed
self.logger.log("Trying to logout, but token invalid.", usid)
else:
self.connections[usid]['uid'] = -1
self._logout(uid)
netstream.send(self.connections[usid]['connection'],
{"code": 1}) # code 1 for success
self.logger.log("Logout successfully.", usid)
def fix_sign_up(recvData):
number = recvData['sid']
print 'receive sign_up request from user id:', number
result = databaseOp.Sign_up(recvData['sign_up'])
if result == databaseOp.UserHasExisted:
#如果用户已经存在
number = recvData['sid']
sendData = {"sign_up_result": "Failed"}
netstream.send(onlineUser[number]['connection'], sendData)
elif result == 0:
number = recvData['sid']
sendData = {"sign_up_result": "Success"}
netstream.send(onlineUser[number]['connection'], sendData)
def login(self, username, password, usid):
# check information correction
uid = -1
for _uid, profile in self.allUsers.iteritems():
if username == profile["username"]:
uid = _uid
# check if in black list
if self._checkBlackList(uid):
netstream.send(self.connections[usid]['connection'],
{"code": 6}) # code 6 for in black list
elif password == profile["password"]:
# generate a token
newToken = uuid.uuid4().hex
self.allUsers[_uid]["token"] = newToken
netstream.send(self.connections[usid]['connection'], {
"code": 1,
"token": newToken
}) # code 1 for success
self.logger.log("Username {} logined.".format(username),
usid)
else:
netstream.send(self.connections[usid]['connection'],
{"code": 4}) # code 4 for password error
self.logger.log(
"Username {} password error.".format(username), usid)
break
if uid == -1:
netstream.send(self.connections[usid]['connection'],
{"code": 3}) # code 3 for user not found
self.logger.log("Username {} not found.".format(username), usid)
def getLeaderboard(self, by, usid):
key = "best_score"
if by == 1:
key = "best_time"
elif by == 2:
key = "best_num"
# get list of user sorted by key
sortedUsers = sorted(self.allUsers.values(),
key=lambda x: x[key],
reverse=True)
# get top 10 user
sortedUsers = sortedUsers[0:10]
leaderboard = [{
'username': user['username'],
'data': user[key]
} for user in sortedUsers]
netstream.send(self.connections[usid]['connection'], {
"code": 1,
"leaderboard": leaderboard
}) # code 1 for success
self.logger.log("Get leaderboard successfully.", usid)
def updateData(self, token, score, time, num, usid):
# check for token
uid = self._getUidCheckToken(token, usid)
if uid == None:
netstream.send(self.connections[usid]['connection'],
{"code": 5}) # code 5 for auth failed
self.logger.log("Trying to update user data, but token invalid.",
usid)
# check if in black list
elif self._checkBlackList(uid):
netstream.send(self.connections[usid]['connection'],
{"code": 6}) # code 6 for in black list
else:
user = self.allUsers[uid]
changed = False
if user['best_score'] < score:
user['best_score'] = score
changed = True
if user['best_time'] < time:
user['best_time'] = time
changed = True
if user['best_num'] < num:
user['best_num'] = num
changed = True
netstream.send(self.connections[usid]['connection'],
{"code": 1}) # code 1 for success
if changed:
self.logger.log("Update user data successfully.", usid)
def signUp(self, numOfRetries):
end = None
# start the timer
start = time.time()
rd = None
for i in range(numOfRetries):
Robot.Mutex.acquire()
Robot.SignUpOrLoginCnt += 1
Robot.Mutex.release()
sd = {
'sid': self.sid,
'type': "signUp",
'username': self.username,
'password': self.password
}
netstream.send(self.sock, sd)
rd = self.recv()
if rd == netstream.CLOSED:
break
elif rd == netstream.EMPTY or rd == netstream.TIMEOUT:
time.sleep(0.1)
continue
elif rd['type'] == 'signUpResult' and rd['result'] == 'success':
# end the timer
end = time.time()
break
if end is None:
# Robot.SignUpAbortCnt += 1
return 'SignUpError'
else:
delay = end - start
Robot.Mutex.acquire()
Robot.SignUpOrLoginSuccessCnt += 1
Robot.SignUpOrLoginDelaySum += delay
Robot.MinSignUpOrLoginDelay = min(Robot.MinSignUpOrLoginDelay,
delay)
Robot.MaxSignUpOrLoginDelay = max(Robot.MaxSignUpOrLoginDelay,
delay)
Robot.Mutex.release()
return True
def process(self, timeout):
rList, wList, eList = select.select(self.inputs, [], [], timeout) # 如果不使用TimeScheduler，可以去掉timeout参数，这样会阻塞到inputs中有socket变成ready
for aSocket in rList:
if aSocket is self.welcomeSocket:
# accept
connectSocket, addr = self.welcomeSocket.accept()
self.inputs.append(connectSocket)
print 'FlappyBirdServer > get connection from: ' + str(connectSocket.getpeername())
# test client
sendData = {}
sendData['content'] = "send from server to client"
netstream.send(connectSocket, sendData)
else:
# receive data
recvData = netstream.read(aSocket)
# socket关闭
if recvData == netstream.CLOSED:
print 'FlappyBirdServer > disconnect: ' + str(aSocket.getpeername())
self.inputs.remove(aSocket)
# 收到request
else:
# test client
print "receive from client"
return
def initalSession(self, token, usid):
uid = self._getUidViaToken(token)
if uid == None:
netstream.send(self.connections[usid]['connection'],
{"code": 5}) # code 5 for token invalid
self.logger.log("Trying to initalize session, but token invalid.",
usid)
# check if in black list
elif self._checkBlackList(uid):
netstream.send(self.connections[usid]['connection'],
{"code": 6}) # code 6 for in black list
else:
self.connections[usid]['uid'] = uid
netstream.send(self.connections[usid]['connection'],
{"code": 1}) # code 1 for success
self.logger.log("Initalize session.", usid)
def fix_sign_in(recvData):
number = recvData['sid']
print 'receive sign_in request from user id:', number
#获取用户名
information = recvData['sign_in'].strip()
information = information.split('\t')
userName = information[0]
#与数据库中的数据对比
result = databaseOp.Sign_in(recvData['sign_in'])
if result == databaseOp.NotAUser:
#用户不存在
number = recvData['sid']
sendData = {"sign_in_result": "notAUser"}
netstream.send(onlineUser[number]['connection'], sendData)
elif result == databaseOp.PasswordError:
#密码错误
number = recvData['sid']
sendData = {"sign_in_result": "passwordError"}
netstream.send(onlineUser[number]['connection'], sendData)
elif result == 0:
#先判断用户是否已经登陆
if userName in userName_state and userName_state[userName] == True:
#用户在线
number = recvData['sid']
sendData = {"sign_in_result": "hasOnLine"}
netstream.send(onlineUser[number]['connection'], sendData)
else:
#用户成功登陆，服务器记录其地址与用户名的对应关系
addr_userName[onlineUser[number]['addr']] = userName
userName_state[userName] = True #记为在线状态
print 'address-map dict: ', addr_userName
print 'userName-State dict: ', userName_state, '\n'
#------------------------------------------------
number = recvData['sid']
sendData = {"sign_in_result": "success"}
netstream.send(onlineUser[number]['connection'], sendData)
def getUserInfo(self, token, usid):
uid = self._getUidViaToken(token)
if uid == None:
netstream.send(self.connections[usid]['connection'],
{"code": 5}) # code 5 for token invalid
self.logger.log(
"Trying to get user information, but token invalid.", usid)
# check if in black list
elif self._checkBlackList(uid):
netstream.send(self.connections[usid]['connection'],
{"code": 6}) # code 6 for in black list
else:
user = self.allUsers[uid]
netstream.send(
self.connections[usid]['connection'], {
"code": 1,
"username": user['username'],
"score": user['best_score'],
"time": user['best_time'],
"num": user['best_num']
}) # code 1 for success
self.logger.log("Get user information successfully.", usid)
pipeRandomHeight.append(random.randrange(0, 4))
pipeRandomHeight.append(random.randrange(0, 4))
# 准备sendData信息
sendData = {}
pipeData = {}
pipeData[0] = pipeRandomHeight[0]
pipeData[1] = pipeRandomHeight[1]
pipeData[2] = pipeRandomHeight[2]
sendData['pipe'] = pipeData
sendData['start'] = 1
sendData['size'] = battleSize
# 给user发送
for i in range(len(user)):
sendData['no'] = i
try:
netstream.send(user[i], sendData)
print 'send data to '+str(user[i].getpeername())+'\tdata is: '+str(sendData)
except Exception:
print 'Error: 游戏开始，给user'+i+'发送'
else:
# receive data
recvData = netstream.read(r)
print 'Read data from '+str(r.getpeername())+'\tdata is: '+str(recvData)
# socket关闭
if recvData == netstream.CLOSED:
print str(r.getpeername())+'disconnected'
inputs.remove(r)
user.remove(r)
else: # 根据收到的request发送response
# client请求pipeRandomHeight
if 'pipe' in recvData:
def requestHandle(self):
while self.runRequestHandle and self.inputs:
try:
rs, ws, es = select.select(self.inputs, [], [], 2)
for r in rs:
self.lock.acquire()
if self.runRequestHandle and r is self.sock:
# accept
connection, addr = self.sock.accept()
self.logger.log('Got connection from' + str(addr) +
" sid: {}".format(self.sid))
self.inputs.append(connection)
sendData = {}
sendData['sid'] = self.sid
netstream.send(connection, sendData)
cInfo = {}
cInfo['connection'] = connection
cInfo['addr'] = addr
cInfo['uid'] = -1 # -1 for not initalized
cInfo['startTime'] = time.time()
cInfo['timeStamp'] = time.time()
self.connections[str(self.sid)] = cInfo
# set timer to moniter session timeout
self._updateTimer(self.sid)
self.sid += 1
else:
# receive data
recvData = netstream.read(r)
if recvData == netstream.CLOSED or recvData == netstream.TIMEOUT: # socket关闭
pass
else: # 根据收到的request发送response
usid = recvData['sid']
usid = str(usid)
if usid not in self.connections: # invalid usid
netstream.send(r, {'code': 7}) # 7 for timeout
continue
# update timeout
self._updateTimer(usid)
self.connections[usid]['timeStamp'] = time.time()
# for registration
if recvData['type'] == 0:
self.registration(recvData['username'],
recvData['password'], usid)
# for login
elif recvData['type'] == 1:
self.login(recvData['username'],
recvData['password'], usid)
# for initialize session
elif recvData['type'] == 2:
self.initalSession(recvData['token'], usid)
# for request notice
elif recvData['type'] == 5:
self.sendNotice(usid)
# for update time stamp
elif recvData['type'] == 6:
self.updateTimeStamp(usid)
# for getting leaderboard
elif recvData['type'] == 8:
self.getLeaderboard(recvData['by'], usid)
# following request require session initalized
elif self.connections[usid][
'uid'] == -1: # not initialized session
netstream.send(
self.connections[usid]['connection'],
{"code": 0}) # 0 for not initialized
else: # session initialized
# for logout
if recvData['type'] == 3:
self.logout(recvData['token'], usid)
# for update states
elif recvData['type'] == 4:
self.updateData(recvData['token'],
recvData['score'],
recvData['time'],
recvData['num'], usid)
# for getting user information
elif recvData['type'] == 7:
self.getUserInfo(recvData['token'], usid)
self.lock.release()
except Exception:
self.lock.release()
self.logger.log(traceback.format_exc())
self.sock.close()
print("Server terminated.")
inputs.append(s)
print 'server start! listening host:', host, ' port:', port
while inputs:
try:
rs, ws, es = select.select(inputs, [], [])
for r in rs:
if r is s:
print 'sid:', sid
# accept
connection, addr = s.accept()
print 'Got connection from' + str(addr)
inputs.append(connection)
sendData = {}
sendData['sid'] = sid
netstream.send(connection, sendData)
cInfo = {}
cInfo['connection'] = connection
cInfo['addr'] = str(addr)
cInfo['ready'] = False
onlineUser[sid] = cInfo
print(str(onlineUser))
sid += 1
else:
# receive data
recvData = netstream.read(r)
# print 'Read data from ' + str(r.getpeername()) + '\tdata is: ' + str(recvData)
# socket关闭
if recvData == netstream.CLOSED or recvData == netstream.TIMEOUT:
if r.getpeername() not in disconnected_list:
def send_game_over_data(value):
send_data=get_send_data()
send_data['game_over_data']=value
netstream.send(sock,send_data)
def send_notice(notice_send, account):
send_data = get_send_data()
send_data['notice'] = notice_send
send_data['account'] = account
netstream.send(sock, send_data)
def sendNotice(self, usid):
netstream.send(self.connections[usid]['connection'], {
"code": 1,
"notice": self.notice
}) # code 1 for success
self.logger.log("Request notice successfully.", usid)
def send_log_out():
send_data = get_send_data()
send_data['log_out'] = True
netstream.send(sock, send_data)
1、当 参数1 序列中的句柄发生可读时（accetp和read），则获取发生变化的句柄并添加到 返回值1 序列中
2、当 参数2 序列中含有句柄时，则将该序列中所有的句柄添加到 返回值2 序列中
3、当 参数3 序列中的句柄发生错误时，则将该发生错误的句柄添加到 返回值3 序列中
4、当 超时时间 未设置，则select会一直阻塞，直到监听的句柄发生变化
5、当 超时时间 ＝ 1时，那么如果监听的句柄均无任何变化，则select会阻塞 1 秒，之后返回三个空列表，如果监听的句柄有变化，则直接执行。
'''
for r in rs: #对于收到的每个连接
if r is s: #目测是接收到发起的链接
print 'sid:', sid
# accept
connection, addr = s.accept() #获取到socket与IP
print 'Got connection from' + str(addr)
inputs.append(connection) #将socket加入监听列表中中
sendData = {}
sendData['sid'] = sid
netstream.send(connection, sendData)
# 记录每个连接的属性
cInfo = {}
cInfo['connection'] = connection
cInfo['addr'] = str(addr)
cInfo['ready'] = False
onlineUser[sid] = cInfo
print(str(onlineUser))
sid += 1
else: # 接收通讯数据
recvData = netstream.read(r)
# print 'Read data from ' + str(r.getpeername()) + '\tdata is: ' + str(recvData)
# 客户端socket关闭
if recvData == netstream.CLOSED or recvData == netstream.TIMEOUT:
def registration(self, username, password, usid):
code = self._registration(username, password)
netstream.send(self.connections[usid]['connection'], {"code": code})
self.logger.log("Username {} registered.".format(username), usid)
def _send(self, data):
data['sid'] = self.sid
netstream.send(self.sock, data)
return True
def request_champion(difficulty):
send_data = get_send_data()
send_data['requestChampion'] = 'requestChampion'
send_data['level'] = difficulty
netstream.send(sock, send_data)
def send_log_in_message(sendState, account, password):
send_data = get_send_data()
send_data['sendState'] = sendState
send_data['account'] = account
send_data['password'] = password
netstream.send(sock, send_data)
def updateTimeStamp(self, usid):
netstream.send(self.connections[usid]['connection'],
{'code': 1}) # code 1 for success
def request_notice():
send_data = get_send_data()
send_data['notice'] = 'request notice'
netstream.send(sock, send_data)
''' test client'''
import socket
import sys
sys.path.append("..");sys.path.append('.')
import netstream
s = socket.socket()
host = '127.0.0.1'
port = 1234
s.connect((host, port))
netstream.read(s)
sendData = {}
sendData['content'] = "send from client to server"
netstream.send(s, sendData)
s.close()
