def join(message):
"""joins and adds clients to global var rooms"""
global rooms
if rooms.get(message["room"]) == None:
rooms[message["room"]] = []
if len(rooms.get(message['room'], [])) < 2:
if message['start'] == 1:
join_room(message['room'])
rooms[message['room']].append(session['login'])
emit('invite_to_join',
{'room_name': message['room']},
broadcast=True)
elif message['start']==2:
join_room(message['room'])
rooms[message['room']].append(session['login'])
starter = rooms[message['room']][0]
joiner = rooms[message['room']][1]
emit('start_game', {'room_name': message['room'], 'starter': starter, 'joiner': joiner})
# emit('full_room', {}, broadcast=True)
else:
print "full room"
def send_unique_usr_data(message):
"""sends message regarding who's in which room to both clientsw"""
emit("room_message", {'starter':message['starter'],
'joiner':message['joiner'],
'room':message['room']},
room=message['room'])
def pin_write(data):
result = PIN_MANAGER.update_value(data.num, data.value)
if not result:
emit('pin:write', {'message': 'Pin not found'})
else:
response = PIN_MANAGER.read_one(data.num)
emit('pin:write', response)
def update_graph(app_state):
print(app_state)
ticker = app_state['ticker']
if ticker not in tickers:
print(ticker, 'not in tickers')
return
else:
try:
df = web.DataReader(ticker, 'yahoo', dt.datetime(2014, 1, 1),
dt.datetime(2015, 4, 15))
except:
print(traceback.format_exc())
return
messages = [
{
'id': 'line-chart',
'task': 'newPlot',
'data': [{
'x': df.index,
'y': df['Close']
}]
}
]
emit('postMessage', json.dumps(messages,
cls=plotly.utils.PlotlyJSONEncoder))
def get_rooms(data):
rooms_d = socketio.rooms.get("/chatapp", {})
room_l = []
for room_t in rooms_d.iteritems():
room_name = room_t[0]
room_l.append(room_name)
emit("rooms", {"rooms": room_l})
def ws_city(message):
print message['disp']
print "jouned new"
fina = check(message['disp'])
room = session.get('room')
print room
emit('disp', {'nam': session.get('name')+': ','disp' :fina},room = room,namespace='/chat')
def handle_message(message):
cols = list(message['data'].keys())
x = message['data']
df_cos = df_sub[cols].append(x, ignore_index = True)
X = df_cos.values
user_array = X[-1]
hood_matrix = X[:-1]
max_array = hood_matrix.max(axis = 1)
min_array = hood_matrix.min(axis = 1)
def translate(user_value, col_min, col_max):
NewRange = col_max - col_min
return (((user_value - (-1)) * NewRange) / 2) + col_min
user_array = [translate(x,y,z) for x,y,z in zip(user_array,min_array, max_array)]
if len(cols) == 1:
cs_array = np.apply_along_axis(lambda x: abs(x[0] - user_array[0]), 1, hood_matrix)
else:
cs_array = np.apply_along_axis(lambda x: euclidean(x, user_array), 1, hood_matrix)
print cs_array
max_val, min_val = max(cs_array), min(cs_array)
color_values = np.linspace(min_val, max_val, 10)
map_data = dict(zip(ids, cs_array))
emit('new clusters', map_data, color_values.tolist())
def getinstructions(forknum, clnum, clstart, clend):
trace = program.traces[forknum]
slce = qira_analysis.slice(trace, clnum)
ret = []
for i in range(clstart, clend):
rret = trace.db.fetch_changes_by_clnum(i, 1)
if len(rret) == 0:
continue
else:
rret = rret[0]
if rret['address'] in program.instructions:
# fetch the instruction from the qemu dump
rret['instruction'] = program.instructions[rret['address']]
else:
# otherwise use the memory
rawins = trace.fetch_memory(i, rret['address'], rret['data'])
if len(rawins) == rret['data']:
raw = ''.join(map(lambda x: chr(x[1]), sorted(rawins.items())))
rret['instruction'] = program.disasm(raw, rret['address'])
if rret['address'] in program.dwarves:
rret['comment'] = program.dwarves[rret['address']][2]
if i in slce:
rret['slice'] = True
else:
rret['slice'] = False
# for numberless javascript
rret['address'] = ghex(rret['address'])
try:
rret['depth'] = trace.dmap[i]
except:
rret['depth'] = 0
ret.append(rret)
emit('instructions', ret)
def search(searchItem):
print("I am here")
db = connect_to_db()
cur = db.cursor(cursor_factory=psycopg2.extras.DictCursor)
searchQuery = ""
results = []
queryResults = []
searchTerm = '%{0}%'.format(searchItem)
#print(searchItem)
cur.execute(movieSearchQuery, (searchTerm,));
results = cur.fetchall();
print(results)
for i in range(len(results)):
resultsDict = {'text' : results[i]['movie_title']}
queryResults.append(resultsDict)
emit('searchResults', queryResults)
cur.close()
db.close()
def hpc_user_disk_usage(message_string):
print 'hpc_user_disk_usage'
message = message_string
query_user = message['data']['query_user']
query_password = message['data']['query_password']
hostname = '10.20.49.124'
port = 22
username = query_user
password = query_password
user_disk_usage = hpcquota.get_cmquota_by_user(hostname, port, username, password)
if 'error' in user_disk_usage:
result = {
'app': 'nwpc_operation_monitor_broker',
'error': user_disk_usage['error'],
'error_msg': user_disk_usage['error_msg']
}
emit('user_disk_usage', result, namespace='/hpc')
return
result = {
'app': 'nwpc_operation_monitor_broker',
'data': {
'query_user': query_user,
'user_disk_usage': user_disk_usage
}
}
response = result
emit('user_disk_usage', response, namespace='/hpc')
def makeConnection():
session['uuid'] = uuid.uuid1()
print('connected')
print(usersOnline)
for user in usersOnline:
print(user)
emit('users', usersOnline[user])
def pause_experiment(message):
# TODO - Need to create additional logic to maintain experiment pause state
experiment_paused = experiment.pause_experiment()
if experiment_paused:
emit('pause_experiment', {'data': 'pause'}, namespace='/subject_space', broadcast=True)
else:
emit('pause_experiment', {'data': 'continue'}, namespace='/subject_space', broadcast=True)
def create_game(data):
"""Sent by clients when they attempt to create a game in the lobby.
A game object is passed in with relevant properties such as name, max. players."""
room = session.get('room')
errors = [];
#error checking
if len(data['name']) < 1: errors.append("Name too short")
if len(data['maxPlayers']) < 1 or not str(data['maxPlayers']).isdigit() or int(data['maxPlayers']) > 99: errors.append("Invalid max. number of players")
if len(games) >= 10: errors.append("Lobby is full")
#for g in games:
# if data['name'] == g.name:
# errors.append("Name already taken")
emit('game creation errors', errors)
if len(errors) > 0: return
game = Game(data['name'], int(data['maxPlayers']))
add_game(game)
update_lobby_list()
def leave_the_room(message):
"""removes user from room, from rooms dictionary, alerts other client in room"""
leave_room(message['room'])
rooms[message['room']].remove(session['login'])
emit('display_disconnect_alert', {'leaving_usr':session['login']},
room=message['room'])
def find_room(message):
room_list=Chat_list.query.all()
list_of_rooms=[]
for i in room_list:
if message['data'] in i.name:
list_of_rooms.append(i)
emit('find room result',{'data': json_find_room(list_of_rooms)})
def getchanges(forknum, address, typ, cview, cscale, clnum):
if forknum != -1 and forknum not in program.traces:
return
address = fhex(address)
if forknum == -1:
forknums = program.traces.keys()
else:
forknums = [forknum]
ret = {}
for forknum in forknums:
db = program.traces[forknum].db.fetch_clnums_by_address_and_type(address, chr(ord(typ[0])), cview[0], cview[1], LIMIT)
# send the clnum and the bunch closest on each side
if len(db) > 50:
send = set()
bisect = 0
last = None
cnt = 0
for cl in db:
if cl <= clnum:
bisect = cnt
cnt += 1
if last != None and (cl - last) < cscale:
continue
send.add(cl)
last = cl
add = db[max(0,bisect-4):min(len(db), bisect+5)]
#print bisect, add, clnum
for tmp in add:
send.add(tmp)
ret[forknum] = list(send)
else:
ret[forknum] = db
emit('changes', {'type': typ, 'clnums': ret})
def answer_student(data):
"""
Needs to make a socket call to shift student and TA to a specific room. There will be an another function which
catches a signal that is emitted back (Python code will add both users to a room on this signal) and will return
a href to redirect the users {unique roomID} and will be redirected using window's href in the javascript code
:param data: data from socketio call
"""
join_room(data['ta']) # Joined ta's room
new_data = {'room' : data['net_id'], 'student': data['net_id'], 'ta': data['ta']}
path = os.path.abspath("VOH/codeshare.py")
print path
link = subprocess.check_output(["python", path])
# emit('answer_info', new_data, namespace='/queue', broadcast=True)
# Adding a new collection for particular student, ta pair. Collection name is the ta's netID
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
client, db = open_db_connection()
db['chat_log'][data['ta']].insert(
dict(room=data['ta'].encode("utf-8"), message="Started Conversation", time=st.encode("utf-8")))
close_db_connection(client)
emit('student_join_emit', {"student" : data['net_id'], "ta" : data['ta'], "link":link}, broadcast = True )
def getregisters(forknum, clnum):
trace = program.traces[forknum]
# register names shouldn't be here
# though i'm not really sure where a better place is, qemu has this information
ret = []
REGS = program.tregs[0]
REGSIZE = program.tregs[1]
cls = trace.db.fetch_changes_by_clnum(clnum+1, LIMIT)
regs = trace.db.fetch_registers(clnum)
for i in range(0, len(REGS)):
if REGS[i] == None:
continue
rret = {"name": REGS[i], "address": i*REGSIZE, "value": ghex(regs[i]), "size": REGSIZE, "regactions": ""}
act = set()
for c in cls:
if c['address'] == i*REGSIZE:
act.add(c['type'])
# this +1 is an ugly hack
if 'R' in act:
rret['regactions'] = "regread"
if 'W' in act:
if "regread" == rret['regactions']:
rret['regactions'] = "regreadwrite"
else:
rret['regactions'] = "regwrite"
rret['num'] = i
ret.append(rret)
emit('registers', ret)
def joined(message):
'''A new user has entered the room, status message sent to everybody in the room.
Also, the list of active users is updated and setn to everybody in the room'''
room = session.get('room')
join_room(room)
emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room)
emit('active', {'msg': '\n'.join(list(active_users[room])) }, room=room)
def run_end(msg):
users_obj = Room.query.filter_by(name=msg['room']).first().users
emit('run response',
{'result': msg['result'], 'user': msg['user'],
'users': [u.name for u in users_obj],
'points': [u.point for u in users_obj]},
room = msg['room'])
def handle_move(message):
game_id = message["gameId"]
user_move = [int(i) for i in message["move"]]
board = get_board(red, game_id)
data = Game(board).handle_move(user_move)
update_board(red, game_id, board)
emit("move:server", data)
def update_grid(json):
room = json['room']
if room not in room_puzzles:
return
puzzle, fill = room_puzzles[room]
if not puzzle:
return
if json['uid'] != puzzle['uid']:
emit('error', {'code': 'REFR'})
print 'ERROR!', 'json', json['uid'], 'flask', puzzle['uid']
return
cell = json['cell']
event = (json['value'], time.time())
if event[1] > fill[cell][1]:
fill[cell] = event
emit('update', {'cell': cell,
'value': fill[cell][0],
'solved': puz_util.check_solution(puzzle, fill),
'uid': puzzle['uid']},
room=room)
def io_get_directions(query):
url = 'http://maps.googleapis.com/maps/api/directions/json?origin={},{}&destination={},{}&sensor=true&mode={}'.format(
query['origin']['latitude'],
query['origin']['longitude'],
query['destination']['latitude'],
query['destination']['longitude'],
query['travel_mode']
)
r = requests.get(url)
if 200 <= r.status_code < 300:
result = r.json()
if result.get('status') == 'OK':
LOG.info('Sending directions to client. {}'.format(result.get('routes')))
emit('directions', {
'status': StatusChoices.Ok,
'routes': result.get('routes'),
})
return
else:
LOG.error(u'Failed GET request to {}'.format(url))
emit('directions', {
'status': StatusChoices.Error,
'error_message': result.get('error_message', 'An unknown error occurred.'),
})
else:
LOG.error(u'Failed GET request to {} - status_code = {}'.format(url, r.status_code))
pass
def handle_realtime_connect(keyword):
print ("received keyword: " + keyword)
pubsub = redis.pubsub()
pubsub.subscribe("sentiment-tweet")
tweets = pubsub.listen()
while True:
try:
message = tweets.next()
raw_tweet = message.get("data")
if not raw_tweet:
continue
tweet = None
if str(raw_tweet)[0] == '"' or str(raw_tweet)[0] == '"': # sns message has backslash in it
tweet = json.loads(str(raw_tweet.decode("string_escape"))[1:-1])
else:
tweet = json.loads(str(raw_tweet))
if not isinstance(tweet, dict):
continue
text = tweet.get("text")
lon = tweet.get("lon")
lat = tweet.get("lat")
sentiment_score = tweet.get("sentiment_score")
data = {"text": text, "lon": lon, "lat": lat, "sentiment_score": sentiment_score}
if text and lon and lat and data:
if keyword in text:
emit("data_transfer", json.dumps(data))
except Exception, e:
emit("die", e, broadcast=True)
pubsub.unsubscribe("twitter_raw")
print e
return
def event(self, data):
state = data["state"]
if state=="on":
print self.ID + " ON"
else:
print self.ID + " OFF"
emit(self.ID + "_status", {"state": state}, broadcast=True)
def handleLightChange(data):
roomId = data['roomId']
state = data['state']
pinNumber = pins['light'][roomId][0][0]['pinNumber']
if state == 1:
GPIO.output(pinNumber, GPIO.HIGH)
if state == 0:
GPIO.output(pinNumber, GPIO.LOW)
for states in pins['light'].itervalues():
for pinState in states[0]:
pinState['state'] = GPIO.input(pinState['pinNumber'])
states[1]['overallState'] = GPIO.input(states[0][0]['pinNumber'])
emit('serverResponse', {
'type': 'light',
'roomId': roomId,
'state': pins['light'][roomId][1]['overallState']
},
broadcast=True)
print "Light change!"
return
def joined(message):
"""Sent by clients when they enter a room.
A status message is broadcast to all people in the room."""
room = session.get('room')
join_room(room)
print "session1", session
emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room)
def get_media_from_all_clients():
clients = get_clients_in_room()
for socket in clients:
if socket != request.namespace:
print("Sending get media to other clients")
socket.emit('get media')
emit('dashlog', 'Accessing media from other player')
def new_search(search):
if search!='':
conn = connectToDB()
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
try:
search = '%'+search+'%'
if subList.find("Movies") >= 1 and subList.find("Sports") < 1 and subList.find("TV Shows") < 1:
query = "SELECT message, username FROM movies WHERE message LIKE '%s' " % (search)
elif subList.find("Movies") >= 1 and subList.find("Sports") >= 1 and subList.find("TV Shows") < 1:
query = "SELECT message, username FROM sports WHERE message LIKE '%s' UNION SELECT message, username FROM movies WHERE message LIKE '%s' " % (search, search)
elif subList.find("Movies") >= 1 and subList.find("Sports") >= 1 and subList.find("TV Shows") >= 1:
query = "SELECT message, username FROM sports WHERE message LIKE '%s' UNION SELECT message, username FROM movies WHERE message LIKE '%s' UNION SELECT message, username FROM tvshows WHERE message LIKE '%s'" % (search, search, search)
cur.execute(query)
rows = cur.fetchall()
conn.commit()
cur.close()
conn.close()
del searchMsg[:]
for row in rows:
str = '***'
row = str.join(row)
t = row.partition("***")
tmp = {'text':t[0], 'name':t[2]}
searchMsg.append(tmp)
for message in searchMsg:
emit('search', message)
except:
print("SEARCH MESSAGE FAIL")
def create_db_reports(message):
#if the user is playing with computer
if message['two_players'] == False:
usr1 = session['user']
usr2 = "Computer"
results = dbsession.query(Game).filter_by(usr1=usr1).filter_by(usr2=usr2).all()
display_results = create_results_dict(results)
# display_results from the db, report how many times a user has won a game
# if the user did not win a single game, the result is "0"
# similarly, for no draw between the two, the result is "0"
adjust_dbresults(usr1, usr2, display_results)
#if user is playing with another person
else:
dbuser1 = dbuser1_get_first_socket()
dbuser2 = dbuser2_get_second_socket()
results = dbsession.query(Game).filter(((Game.usr1==dbuser1.username) | (Game.usr1==dbuser2.username)) & ((Game.usr2==dbuser1.username) | (Game.usr2==dbuser2.username))).all()
display_results = create_results_dict(results)
# display_results from the db, report how many times a user has won a game
# if the user did not win a single game, the result is "0"
# similarly, for no draw between the two, the result is "0"
adjust_dbresults(dbuser1.username, dbuser2.username, display_results)
emit('display results', display_results, broadcast=True)
def heart_gyro_receiver(message):
r = redis.Redis(connection_pool=p)
# Publish data on Redis PUB-SUB Channel
r.publish('model::ACCEL_STREAM', message)
# Broadcast data to all connected clients
emit('model::ACCEL_STREAM', message, broadcast=True)
def relate_Organizations():
emit('getInfo nodeInfo', getGranEstructura())
def join(data):
session["group"] = data["groupName"]
session["userUuid"] = data["userUuid"]
join_room(session["group"])
emit("who is there", room=session["group"])
def getSuggestion(message):
print "La busqueda es: "
print message
emit('suggestion response', pyWiki.search(message))
def test_connect():
emit('my response', {'data': 'Connected'})
print('Client Connected')
def room_chat(message):
room = message['room']
data = message['data']
print(room)
emit('test Only', {'data': 'sds'}, room=room)
def subscribe(message):
join_room(message['channel'])
emit('confirm', message, room=message['channel'])
def client_message(message):
servers = [':'.join(s.split(':')[:2]) for s in REDIS_SERVER]
emit('servers', {'data': servers})
def disconnect():
emit("user disconnected", session["userUuid"], room=session["group"])
def update(data):
emit("update", data, room=session["group"])
def on_custom_event_broadcast(data):
emit('my custom response', data, broadcast=True)
def publish(message):
emit('slidechanged', message, room=message['channel'])
emit('confirm', message, room=message['channel'])
def test_message(message):
room = message['data']
join_room(room)
emit('join confirm', {'data': 'success'})
print('request join')
def connect():
emit('confirm', {'conn': 'conn'})
def test_message(message):
emit('my response', {'data': message['data']}, broadcast=True)
def getStructure(message):
emit('get structure', cleanStructure(create_structure(message)))
def on_join(data):
room = data['room']
msg = data['data']
emit('my response', {'data': msg}, room=room)
def relateFamily(message):
emit('create family', relatedFamily(message))
def getDataSuggestion(message):
print message
emit('suggestion dataResponse', pyWiki.getPageData(message))
def on_custom_event_broadcast_test(data):
emit('my custom namespace response',
data,
namespace='/test',
broadcast=True)
def createPerson(message):
emit('create person', savePerson(message))
def test_connect():
emit('my response', {'data': 'Connected', 'count': 0})
def relate_Organizations(message):
emit(
'create organization',
relateOrganizationsAcademic(message) + relateParty(message) +
relateOrganizationsLaboral(message))
def test_message(message):
session['receive_count'] = session.get('receive_count', 0) + 1
response = {}
response['endofinnings'] = False
isNoBall = message['noball']
isWideBall = message['wide']
isValid = not message['invalid']
isBye = message['bye']
isLegBye = message['legbye']
isWicket = message['wicket']
global match
mtch = match[session['mid']]
try:
run = int(message['data'])
session['mtotal'] = session.get('mtotal', 0) + run
striker = mtch.get_player(session['striker'], session['playing'])
if isNoBall:
if message['nbe']:
update_striker(run - 1)
else:
striker.update_runs(run - 1)
update_striker(run - 1)
elif isWideBall:
update_striker(run - 1)
elif isLegBye:
update_striker(run)
elif isBye:
update_striker(run)
elif isWicket:
session['currentwickets'] += 1
if session['currentwickets'] == session['wickets']:
response['endofinnings'] = True
session['mtotalone'] = session['mtotal']
if not response['endofinnings']:
if message['stikerout']:
session['striker'] = mtch.get_next_player(
session['currentwickets'] + 2, session['playing'])
session['playerone'] = session['striker']
else:
session['nonstriker'] = mtch.get_next_player(
session['currentwickets'] + 2, session['playing'])
session['playertwo'] = session['nonstriker']
else:
striker.update_runs(run)
update_striker(run)
if isValid:
session['validdeliveries'] += 1
scorecard_dict = []
for p in mtch.get_all_players(session['playing']):
temp = mtch.get_player(p, session['playing'])
scorecard_dict.append(temp.return_runs())
response['scorecard'] = scorecard_dict
response['playerone'] = session['playerone']
player_1 = mtch.get_player(session['playerone'], session['playing'])
response['playeroneruns'] = player_1.total()
response['playertwo'] = session['playertwo']
player_2 = mtch.get_player(session['playertwo'], session['playing'])
response['playertworuns'] = player_2.total()
response['endofover'] = False
if session['validdeliveries'] == 6:
response['endofover'] = True
session['validdeliveries'] = 0
update_striker(1)
session['currentovers'] += 1
if session['currentovers'] == session['overs']:
response['endofinnings'] = True
session['mtotalone'] = session['mtotal']
except Exception as e:
print(str(e))
response['data'] = message['data']
response['count'] = session['receive_count']
response['mtotal'] = session['mtotal']
response['wickets'] = session['currentwickets']
response['overs'] = session['currentovers']
response['deliveries'] = session['validdeliveries']
response['playing'] = session['playing']
response['mtotalone'] = session['mtotalone']
global replay
replay[session['mid']] = response
print replay[session['mid']]
emit('my response', response, room=session['mid'])
def heart_commands_receiver(message):
r = redis.Redis(connection_pool=p)
# Publish data on Redis PUB-SUB Channel
r.publish('model::COMMANDS', message)
# Broadcast data to all connected clients
emit('model::COMMANDS', message, broadcast=True)
def join(message):
join_room(message['room'])
emit('my response',
{'data': 'In rooms: ' + ', '.join(str(request.namespace.rooms))})
def test_message(message):
emit('rome', {'data': 'romeeeee'}, broadcast=True)
def test_message(message):
room = str(randint(1, 1000))
emit('host confirm', {'data': room})
join_room(room)
print('request host')
def new_round():
emit("new round", room=session["group"])
def on_custom_event_test(data):
emit('my custom namespace response', data, namespace='/test')
