def run_test(self, test):
for i in range(self.streams):
cmd = self.driver.gen_cmd(test, i, self.limit, self.path)
cfg.dprint("Listing: " + cmd)
task.shell(cmd, nodes=','.join(self.nodes))
cfg.dprint("Running above commands.")
task.resume()
def run_test(self, test):
for i in range(self.streams):
cmd = self.driver.gen_cmd(test, i, self.limit, self.path)
cfg.dprint("Listing: " + cmd)
task.shell(cmd, nodes=','.join(self.nodes))
cfg.dprint("Running above commands.")
task.resume()
def doudizhuurl():
dprint(myIps["myLocalIp"])
dprint(myIps["myRemoteIp"])
redirecturl="http://"+myIps["myRemoteIp"]+":5000/mygame/doudizhu/index.html"
#return flask.redirect(redirecturl, code=302)
return "<html><head><title>斗地主</title><meta charset='UTF-8'></head>" \
+"<body leftmargin='0' topmargin='0'><iframe src='"+redirecturl+"' width='100%' height='100%' frameborder='0'></iframe></body></html>"
def gamestream():
dprint("gamestream sessions:",flask.session)
hallid=flask.session["hallid"]
#tableid=flask.session["tableid"]
playerid=flask.session["playerid"]
return flask.Response(mygame.getMessage(hallid,"",playerid), headers={"Access-Control-Allow-Origin": "*"},
mimetype="text/event-stream")
def query_api(term, location):
"""Queries the API by the input values from the user.
Args:
term (str): The search term to query.
location (str): The location of the business to query.
"""
response = search(term, location)
businesses = response.get('businesses')
if not businesses:
print u'No businesses for {0} in {1} found.'.format(term, location)
return
business_id = businesses[0]['id']
dprint(u'{0} businesses found, querying business info for the top result "{1}" ...'.format(
len(businesses),
business_id
))
response = get_business(business_id)
#print u'Result for business "{0}" found:'.format(business_id)
#pprint.pprint(response, indent=2)
return businesses
def gamelongpoll():
dprint("gamespoll sessions:",flask.session)
hallid=flask.session["hallid"]
#tableid=flask.session["tableid"]
playerid=flask.session["playerid"]
return flask.Response(mygame.getMessage2(hallid,"",playerid), headers={"Access-Control-Allow-Origin": "*"},
)
def getroom(self,roomid):
dprint(len(self.rooms))
for i in range(0,len(self.rooms)):
r=self.rooms[i]
if(r.roomid==roomid):
return(r)
return(0)
def run_test(self, test):
for node in self.nodes_paths:
for path in self.nodes_paths[node]:
cmd = self.driver.gen_cmd(test, self.streams, self.limit, path)
cfg.dprint("Listing: " + cmd)
csh.shell(cmd, nodes=node)
cfg.dprint("Running above commands.")
csh.resume()
def redis_post():
message = flask.request.form['message']
froomid=flask.request.form['roomid']
user = flask.session.get('user', 'anonymous')
flask.session['roomid']=froomid;
dprint(message,froomid);
red.publish(froomid,message);
return flask.Response(status=204,headers={"Access-Control-Allow-Origin": "*"})
def update_test_results(self, test):
for buf, nodes in csh.iter_buffers():
test_out = str(buf)
assert test_out != 'Permission denied (publickey,keyboard-interactive).'
cfg.dprint('Nodes {n} returned:'.format(n=','.join(nodes)))
cfg.dprint(test_out)
bw = self.driver.parse_bw(test_out)
test.results += [(n, bw) for n in nodes]
def getmessage(self,index=0):
if((len(self.messages))>0):
message=(self.messages[0])[:]
messageid=(self.messageids[0])[:]
dprint("getmessage 1")
dprint(message)
return(message,messageid)
return("","0")
def beat(self):
self.heartBeats-=10;
dprint(self.playerId+" second:",self.heartBeats)
if(self.heartBeats>0):
#self.hbtimer.cancel();
self.hbtimer=Timer(10,self.beat)
self.hbtimer.start()
else:
dprint(self.playerId+" timeout!")
self.hbtimer=None
def login():
if flask.request.method == 'POST':
froomid=flask.request.form['roomid']
fuser=flask.request.form['nickname']
flask.session['user'] = fuser
flask.session['roomid'] = froomid
dprint(flask.session)
myRooms.subscribe(roomid=froomid,user=fuser,peerid="1")
return flask.redirect('/')
return '<form action="/login" method="post">user: <input type=text name="nickname">room: <input type="text" name="roomid"><input type="submit" value="Submit"></form>'
def unsubscribe(self,user):
try:
index=self.users.index(user)
del self.usertimes[index]
del self.users[index]
self.setowner()
dprint(user[1],"leave room! ",self.getroominfo())
return True,"Success!"
except:
return False,"Failue:User not exist!"
def event_stream(roomid):
r=myRooms.getroom(roomid)
while(True):
message,index=r.getmessage()
if(len(message)>0):
dprint("event_stream #1")
yield 'data: %s\n\n' % message
#gevent.sleep(0.5)
dprint("event_stream #2 delete")
r.delmessage(index)
def subscribe(self,user):
try:
index=self.users.index(user)
self.usertimes[index]=heartbeattime
except:
self.users.append(user)
self.usertimes.append(heartbeattime)
dprint(user[1],"enter room! ",self.getroominfo())
self.setowner()
return True,"Success!"
def redismeesge(roomid):
pubsub = red.pubsub()
pubsub.subscribe(roomid)
dprint(roomid);
# TODO: handle client disconnection.
for msg in pubsub.listen():
dprint(msg)
if (msg["type"]=="message"):
yield 'data: %s\n\n' % (msg['data'].decode())
else:
continue;
def post():
fmessage = flask.request.form['message']
fuser = flask.session.get('user', 'anonymous')
froom= flask.session.get('roomid', 'chat')
now = datetime.datetime.now().strftime("%Y %m %d %H:%M:%S")
r=myRooms.getroom(froom)
message=""
message=message.join((now," ",fuser,":",fmessage))
r.publish(message)
dprint(r.getmessage())
return flask.Response(status=204)
def enterroom():
if flask.request.method == 'POST':
froomid=flask.request.form['roomid']
fnickname=flask.request.form['nickname']
fpeerid=flask.request.form['peerid']
flask.session['user'] = fnickname
flask.session['roomid'] = froomid
flask.session.permanent = True
r,message=myRooms.subscribe(roomid=froomid,user=fnickname,peerid=fpeerid)
roominfo= myRooms.getroominfo(froomid)
data={"result":r,"message":message,"roominfo":roominfo}
djson=json.dumps(data)
dprint(data)
return flask.Response(djson,headers={"Access-Control-Allow-Origin": "*"})
return '<form action="/enter" method="post">user: <input type=text name="nickname">room: <input type="text" name="roomid">peerid: <input type="text" name="peerid"><input type="submit" value="Submit"></form>'
def getMessage2(self,hallid,tableid,playerid):
hall=self.halls[hallid]
player=hall.getPlayer(playerid)
if(player == None):
#player=hall.getPlayer(playerid)
#time.sleep(1)
return "data:{message:player not ready!}\n\n"
msgbox=player.messageBox
while(True):
if(len(msgbox.messageBox)>0):
msg=msgbox.popMessage()
dprint("poll msg: ",msg)
return '%s' % msg
else:
time.sleep(0.1)
return
def request(host, path, url_params=None):
"""Prepares OAuth authentication and sends the request to the API.
Args:
host (str): The domain host of the API.
path (str): The path of the API after the domain.
url_params (dict): An optional set of query parameters in the request.
Returns:
dict: The JSON response from the request.
Raises:
urllib2.HTTPError: An error occurs from the HTTP request.
"""
url_params = url_params or {}
url = 'http://{0}{1}?'.format(host, urllib.quote(path.encode('utf8')))
consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET)
oauth_request = oauth2.Request(method="GET", url=url, parameters=url_params)
oauth_request.update(
{
'oauth_nonce': oauth2.generate_nonce(),
'oauth_timestamp': oauth2.generate_timestamp(),
'oauth_token': TOKEN,
'oauth_consumer_key': CONSUMER_KEY
}
)
token = oauth2.Token(TOKEN, TOKEN_SECRET)
oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token)
signed_url = oauth_request.to_url()
dprint(u'Querying {0} ...'.format(url))
conn = urllib2.urlopen(signed_url, None)
try:
response = json.loads(conn.read())
finally:
conn.close()
return response
def __init__(self,roomid="",users=[],messages=[],roomsize=2):
self.roomid=roomid[:]
self.roomsize=roomsize
self.users=users[:] #be(peerid,nickname)'s array
self.usertimes=[] #every 5s will check times,if 10s no beat,will remove user
self.roomtimer=None;
if(len(self.users)>0):
dprint(self.users[0][1],".. 创建房间",self.roomid);
for i in range(0,len(self.users)):
self.usertimes.append(heartbeattime)
self.messages=messages[:]
self.messageids=[]
self.currentid=0
self.setowner()
if(self.roomtimer==None):
self.roomtimer=Timer(5,self.timercheck)
self.roomtimer.start()
dprint("starttimer")
def game():
dprint("game sessions befor process:",flask.session)
rtn,session=mygame.process(flask.request,flask.session)
flask.session=session
dprint("game sessions after process:",flask.session)
djson=json.dumps(rtn)
dprint(djson)
return flask.Response(djson,headers={"Access-Control-Allow-Origin": "*"})
def postip():
if flask.request.method == 'POST':
myIps["myLocalIp"]=flask.request.form['wlanip']
myIps["myeth0Ip"]=flask.request.form['eth0ip']
myIps["myIp138"]=flask.request.form['138ip']
ip=""
try:
ip=flask.request.headers['X-Real-IP']; #pythonanywhere
dprint("X-Real-IP ",ip)
except:
try:
ip=flask.request.headers['x-forwarded-for']; #openshift
ip=ip.split(",")[0]
dprint("x-forwarded-for ",ip)
except:
ip=flask.request.remote_addr;
dprint('remote_addr ',ip)
myIps["myRemoteIp"]=ip
dprint("WlanIp = ",myIps["myLocalIp"]," eth0Ip = ",myIps["myeth0Ip"]," 138Ip = ",myIps["myIp138"]," RemoteIp = ",myIps["myRemoteIp"])
return flask.redirect('/getip')
return '<form action="/postip" method="post">localip: <input type=text name="wlanip">eth0ip: <input type=text name="eth0ip">138ip: <input type=text name="138ip"><input type="submit" value="Submit"></form>'
def timercheck(self):
#self.roomtimer.cancel()
dprint("5s timer")
for i in range(0,len(self.usertimes)):
dprint(i,self.usertimes[i])
self.usertimes[i]-=5
for i in range(len(self.usertimes)-1,-1,-1):
if(self.usertimes[i]<0):
username=self.users[i][1]
del self.users[i]
del self.usertimes[i]
dprint(username,"timeout! ",self.getroominfo())
self.roomtimer=Timer(5,self.timercheck)
self.roomtimer.start()
def update_test_results(self, test):
for buf, nodes in task.iter_buffers():
test_out = str(buf)
cfg.dprint(test_out)
bw = self.driver.parse_bw(test_out)
test.results += [(n, bw) for n in nodes]
def weixin1():
fullpath=flask.request.fullpath;
dprint("fullpath: ",fullpath)
r=requests.get("http://"+myIps["myRemoteIp"]+":5000/weixin2"+fullpath)
dprint("return: ",r.text)
return r.text;
def stream():
dprint(flask.session)
froom=flask.session.get('roomid','chat')
return flask.Response(event_stream(froom),
mimetype="text/event-stream")
def redis_stream():
dprint(flask.session)
froom=flask.session.get('roomid','904')
#froom=flask.request.form['room']
return flask.Response(redismeesge(froom), headers={"Access-Control-Allow-Origin": "*"},
mimetype="text/event-stream")
def update_test_results(self, test):
for buf, nodes in task.iter_buffers():
test_out = str(buf)
cfg.dprint(test_out)
bw = self.driver.parse_bw(test_out)
test.results += [(n, bw) for n in nodes]
def pushMessage(self,content,sender,sendtime):
dprint("message pushed! ",content,sender)
self.messageBox.append(Message(self.lastId,content,sender,sendtime).dump())
self.lastId+=1
return
def process(self,request,session):
action = request.args['action']
if(action=="regist"):
userdict=self.getDictFromDict(request.form, ["playerid","nickname","password","email"])
rtc,rtm=DBSqlite().putUser2DB(userdict)
return {"returncode":rtc,"errormessage":rtm,"playerid":userdict["playerid"]},session
elif(action=="login"):
userdict=self.getDictFromDict(request.form, ["playerid","password"])
dprint(userdict)
db=DBSqlite()
if(db.login(userdict)==0):
session["playerid"]=userdict["playerid"]
return {"returncode":0,"errormessage":"success!",
"player":db.getPlayerDict(userdict["playerid"])},session
else:
return {"returncode":-1,"errormessage":"something error!"},session
elif(action=="enterhall"):
hallid=request.args["hallid"]
playerid=session["playerid"]
if(hallid in self.halls):
hall=self.halls[hallid]
else:
hall=self.addHall(hallid, hallid)
player=hall.getPlayer(playerid);
if(player==None):
player=DBSqlite().getPlayer(playerid)
hall.addPlayer(player)
session["hallid"]=hallid
#session["playerid"]=playerid
return {"returncode":0,"errormessage":"success!","hallinfo":hall.getHallInfo()},session
elif(action=="intable"):
#hallid=request.form["hallid"]
tableid=request.form["tableid"]
#playerid=session["playerid"]
hallid=session["hallid"]
dprint(hallid,tableid,request.form)
hall=self.halls[hallid]
table=hall.getTable(tableid)
if(table==None):
return {"returncode":40001,"errormessage":"table not found!"},session
playerdict=request.form
#player=table.getPlayer(playerdict["playerid"]);
#if(player==None):
player=hall.getPlayer(playerdict["playerid"])
ok,rinfo=table.enter(player)
dprint("process intable ",ok,rinfo)
if(ok):
session["tableid"]=tableid
return {"returncode":0,"errormessage":"success!","tableinfo":rinfo},session;
else:
return rinfo,session;
elif(action=="tableinfo"):
hallid=session["hallid"]
tableid=session["tableid"]
playerid=session["playerid"]
dprint(hallid,tableid,playerid)
hall=self.halls[hallid]
table=hall.getTable(tableid)
if(table==None):
return {"returncode":40001,"errormessage":"table not found!"},session
rinfo=table.getTableInfo()
dprint("tableinfo ",rinfo)
return {"returncode":0,"errormessage":"success!","tableinfo":rinfo},session;
elif(action=="leavetable"):
hallid=session["hallid"]
tableid=session["tableid"]
playerid=session["playerid"]
dprint("leavetable:",hallid,tableid,playerid)
hall=self.halls[hallid]
table=hall.getTable(tableid)
if(table==None):
return {"returncode":40001,"errormessage":"table not found!"},session
playerdict=request.form
player=table.getPlayer(playerid);
if(player==None):
return {"returncode":50001,"errormessage":"player not found!"},session
ok,rinfo=table.leave(player)
return {"returncode":0,"errormessage":"success!"},session;
elif(action=="sendmessage"):
'''
* msgdict = { action:actiondata}
'''
msgdict=request.form
hallid=session["hallid"]
tableid=session["tableid"]
playerid=session["playerid"]
dprint("sendmessage:",hallid,tableid,playerid)
hall=self.halls[hallid]
table=hall.getTable(tableid)
player=table.getPlayer(playerid);
if(player==None):
return {"returncode":50001,"errormessage":"player not found!"},session
rtmdict=table.processMessage(msgdict,player)
return {"returncode":0,"errormessage":"success!"},session
elif(action=="getmessage"):
hallid=session["hallid"]
tableid=session["tableid"]
playerid=session["playerid"]
hall=self.halls[hallid]
table=hall.getTable(tableid)
if(table==None):
return {"returncode":40001,"errormessage":"table not found!"},session
player=hall.getPlayer(playerid)
ok,rinfo=table.enter(player)
msgdict=request.form
rtmdict=table.processMessage(msgdict,player)
#return {"returncode":0,"errormessage":"success!",
# "tableinfo":rinfo,"data":self.getMessage3(hallid, tableid, playerid)},session
return {"data":self.getMessage3(hallid, tableid, playerid)},session
elif(action=="synchronize"):
hallid=session["hallid"]
hall=self.halls[hallid]
tableid=session["tableid"]
table=hall.getTable(tableid)
playerid=session["playerid"]
playinfo=table.getPlayInfo()
return playinfo,session
return {"returncode":60001,"errormessage":"unknown action."},session
