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')