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():
print 'Disconnecting client'
emit('disconnected response', {'data': 'Disconnected'})
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 wrapped(*args, **kwargs):
if 'username' not in session:
disconnect()
else:
return f(*args, **kwargs)
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()
