def on_connect(): """Verifies that the user is logged in and that the app they want to monitor exists. Joins them to a "room" for that app. Emits an event containing a history of activity for the past 900 seconds. Starts polling for real time stats on the app's performance. """ print('connecting') app_id = request.args.get('app_id', None) if not app_id: print ('app_id is required') return disconnect() app = App.find_by_id(app_id) if not app: print ('app not found') return disconnect() print ('watching app', app_id) sockets.join_room(get_app_room_id(app_id)) interval = request.args.get('history_interval', 900) app_stats = AppStats.get_history(app_id, interval=interval) socketio.emit('history', util.to_dict(app_stats), room=request.sid, namespace=namespace) resume_stats()
def personal_connect(): if current_user.is_authenticated(): #emit('response', {'data': 'You are now connected.', 'user': '******'}) join_room(current_user.id) else: disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', { 'data': 'Disconnected!', 'count': session['receive_count'] }) disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 emit( 'my response', { 'data': "<i>déconnecté de la discussion</i>", 'count': session['receive_count'] }) disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 logging.debug("Client %s disconnects", request.remote_addr) emit('my response', { 'data': 'Disconnected!', 'count': session['receive_count'] }) disconnect()
def disconnect_anonymous(): if not current_user.is_authenticated and not app.config.get("LOGIN_DISABLED", False): disconnect() return for func in on_socketio_connect: func() return
def disconnect_anonymous(): if not current_user.is_authenticated and not app.config.get( "LOGIN_DISABLED", False): disconnect() return for func in on_socketio_connect: func() return
def test_disconnect(): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', {'data': 'Disconnected!', 'count': session['receive_count']}) global disconnected disconnected = False print('Client disconnected') disconnect()
def test_disconnect(): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', { 'data': 'Disconnected!', 'count': session['receive_count'] }) global disconnected disconnected = False print('Client disconnected') disconnect()
def TestConnectionItem(): # If the origin looks fishy... # Force a disconnect. if request.headers["Origin"] == request.headers["Origin"]: emit('connection status', {'data': 'Item: Connection Established!'}) print "Item: Connection Established!" else: # Currently on disconnection, a connection keeps trying to get established. # This can be stopped if you set the reconnect flag to false on the client side. print"Item: Disconnected!" disconnect()
def private_send_message(message): username = current_user.id room = message['room'] if current_user.is_authenticated() and username in room.split('|'): escaped_message = Markup.escape(message['data']) # escape the message before broadcasting it! emit('response',{'data': escaped_message, 'user': current_user.id},room=message['room'], broadcast=True) else: disconnect()
def handle_auth(message): # Authenticate a user tok = message try: something = session["username"] # is authed already? emit("error", "Already authenticated as "+something) return except: pass if use_tokens == True: try: # Will succeed is user token is valid user = tokens[tok] send("Welcome, {}. You are connected.".format(user)) users[str(user)] = "Online" session["username"] = user # store it in a session send(session['username']+" has come online.", room = "notify") return except: # User token invalid send("Sorry, but we could not establish your identity. \ Try logging in again") emit('skick', "Invalid Token") # tell the client to disconnect disconnect() else: tok = str(tok).translate(None, "!@#$%&*()/\<>~+;'") # filter symbols # no token nonsense try: if users[str(tok)] != "Offline": # If online, deny emit('skick', "Username in use.") disconnect(); return else: # Offline, allow use token = str(uuid4()) # generate a random token tokens[token] = str(tok) rtokens[str(tok)] = token users[str(tok)] = "Online" session["username"] = tok send("You are now known as "+tok) return except: token = str(uuid4()) # generate a random token tokens[token] = str(tok) rtokens[str(tok)] = token users[str(tok)] = "Online" session["username"] = tok send("You are now known as "+tok) return
def handle_drop_disc(json_data): game, player_id = authenticate(session) if not game: print('Invalid connection. Disconnecting!') return disconnect() # Play disc data = json.loads(json_data) column_index = data.get('column_index') game_id = game["game_id"] try: game = GameStore.play_turn(game_id, player_id, column_index) json_data = json_game_state(game) emit('game_state', json_data, room=game_id) except OutOfTurnError: print("Player %d out of turn" % game["player_positions"][player_id]) data = dict(message="It's not your turn!") emit("alert", json.dumps(data)) except GridColumnFullError: print("Column %d is full" % column_index) data = dict(message="This column is full. Please pick another column.") emit("alert", json.dumps(data)) except GameOverError: print("The game has ended") data = dict(message="The game is over!") emit("alert", json.dumps(data))
def handle_restart(): game, player_id = authenticate(session) if not game: print('Invalid connection. Disconnecting!') return disconnect() game_id = game["game_id"] game = GameStore.restart(game_id) json_data = json_game_state(game) emit('game_state', json_data, room=game_id)
def current(): current_app.logger.error('Socket.IO connect start') try: emit('change', {'msg': 'Connected'}) dburi = current_app.config['SQLALCHEMY_DATABASE_URI'] conn = psycopg2.connect(dburi) conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT) curs = conn.cursor() curs.execute('LISTEN queue;') while True: if select.select([conn], [], []) == ([], [], []): pass else: conn.poll() while conn.notifies: notify = conn.notifies.pop() emit('change', {'msg': 'Change'}) except Exception as e: current_app.logger.exception('Queue status error: ' + str(e)) disconnect()
def handle_connect(): game, player_id = authenticate(session) players = game["player_positions"] if not game: print('Invalid connection. Disconnecting!') return disconnect() game_id = game["game_id"] print("Player %d connected to game %s" % (players[player_id], game_id)) if game_id not in rooms(): join_room(game_id) json_data = json_game_state(game) emit('game_state', json_data, room=game_id)
def current(): current_app.logger.error('Socket.IO connect start') try: emit('change', {'msg': 'Connected'}) dburi = current_app.config['SQLALCHEMY_DATABASE_URI'] conn = psycopg2.connect(dburi) conn.set_isolation_level( psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT) curs = conn.cursor() curs.execute('LISTEN queue;') while True: if select.select([conn], [], []) == ([], [], []): pass else: conn.poll() while conn.notifies: notify = conn.notifies.pop() emit('change', {'msg': 'Change'}) except Exception as e: current_app.logger.exception('Queue status error: ' + str(e)) disconnect()
def handle_new_connection(data): if data is None \ or EventFields.TOKEN not in data \ or EventFields.CLIENT_TYPE not in data: disconnect() return token = data.get(EventFields.TOKEN, "") sid = request.sid user = User.get_user_by_auth_token(token) if user is None: disconnect() return if user.socket_id_as_source == sid or user.socket_id_as_explorer == sid: disconnect() return is_from_source = data.get(EventFields.CLIENT_TYPE) == EventFields.SOURCE user.attach_new_socket(sid, is_from_source) db_session.commit() emit(ClientEvents.CONNECTION_ESTABLISHED, {EventFields.RESULT: ResponseCode.SUCCESSFUL}, room=sid)
def wrapped(*args, **kwargs): if not current_user.is_authenticated: disconnect() else: return fn(*args, **kwargs)
def disconnect_request(): print 'Disconnecting client' emit('disconnected response', {'data': 'Disconnected'}) disconnect()
def disconnect_request(): emit('response',{'data': 'You have been disconnected.'}) disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 logging.debug("Client %s disconnects", request.remote_addr) emit('my response', {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect()
def disconnect_request(): session["receive_count"] = session.get("receive_count", 0) + 1 emit("my response", {"data": "Disconnected!", "count": session["receive_count"]}) disconnect()
def disconnect_request(): logger.debug("Client %s disconnects", request.remote_addr) emit('my response', {'data': 'Disconnected!'}) disconnect()
def disconnect_request(): emit('my response', {'data': 'Disconnected!'}) disconnect()
def wrapped(*args, **kwargs): if 'username' not in session: disconnect() else: return f(*args, **kwargs)
def wrapped_f(*args): sockets.connect_socket() if not helpers.is_logged_in(): return disconnect() return func(*args)
def disconnect_request(): """Disconnect thread""" disconnect()
def private_connect(): if current_user.is_authenticated(): emit('response', {'data': 'You are now connected.', 'user': '******'}) else: disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', {'data': "<i>déconnecté de la discussion</i>", 'count': session['receive_count']}) disconnect()
def disconnected(): """ Disconnects from Socket.IO """ disconnect()
def disconnect_request(): emit('status', {'status': 'Disconnected!'}) disconnect()
def disconnect_request(): session["receive_count"] = session.get("receive_count", 0) + 1 logging.debug("Client %s disconnects", request.remote_addr) emit("my response", {"data": "Disconnected!", "count": session["receive_count"]}) disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect()
def send_message(message): if current_user.is_authenticated(): escaped_message = Markup.escape(message['data']) # escape the message before broadcasting it! emit('response',{'data': escaped_message, 'user': current_user.id},broadcast=True) else: disconnect()