def join(message):
join_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit(SERVER_GEN_RESPONSE, {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']})
if message['room'] == ROOM_PGRC_PROD:
emit(PROD_RESPONSE, {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']})
show_client_status(CLIENT_STATUS_CODE['JOINED'], request.sid)
def close(message):
if message['room'] not in rooms():
return
emit('close',
{'user': message['user'], 'room': message['room']},
broadcast=True)
close_room(message['room'])
room_list = [room for room in rooms() if room != request.sid]
emit('my response',
{'data': 'In rooms: ' + ', '.join(room_list)})
def connect():
print('socektid # ', flask_socketio.rooms(), 'connecting in io: .... ')
# if they are connected,
socketId = flask_socketio.rooms()
print(socketId)
# how to send to just them?
print('emitting to connect so user can just rejoin the room')
print('user is in the rooms: ', flask_socketio.rooms())
def no_longer_typing(data):
typing_user_rooms = rooms()
typing_user_id = get_id_from_rooms(typing_user_rooms)
typing_user = DelhiveryUser.objects.get(id=typing_user_id)
friend = DelhiveryUser.objects.get(id=data['friend'])
if friend.is_online:
emit('sender_stopped_typing',{'typing_user': str(typing_user_id)},room=str(friend.id))
def leave(message):
print("leave")
leave_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response',
{'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']})
def on_disconnect():
if app.debug:
print('Received disconnect')
for room in rooms():
if room in module_listeners:
module_listeners[room] -= 1
def submitMove(data):
print("-------------------------------")
print(data)
print(flask_socketio.rooms())
room = flask.session['room']
print(room)
if game[flask.session['room']] :
if flask.session['sid'] in game[flask.session['room']]:
game[flask.session['room']].append(data)
if data['turn'] =='X':
print('############################### emitting to O')
io.emit('otherplayermademove', {"row":data['row'], "col":data['col'] }, room =game[room][0])
elif data['turn'] =='O':
print('############################### emitting to X')
io.emit('otherplayermademove', {"row":data['row'], "col":data['col'] }, room = game[room][1] )
else:
print('what the hell are you trying to pull? ')
io.emit('observing', {"row":data['row'], "col":data['col'], "turn": data['turn']}, room = "observing"+flask.session['room'] )
def disconnect():
for room in rooms():
if room in game_rooms:
try:
game_rooms[room].removeSnake(request.sid)
del user_snakes[request.sid]
except KeyError:
pass
def on_edit(ident, content):
my_rooms = rooms()
my_rooms.remove(request.sid)
edit_document(ident, content)
emit("edit", get_document(ident), room=my_rooms[-1], json=True)
def on_leave():
conn_rooms = rooms()
for room in conn_rooms:
if room != req.sid:
leave_room(room)
rc.client_leave_room(sid=req.sid, room=room)
emit("info", req.sid + ' left the room.', room=room)
emit("clients", rc.all_clients_in_room(room=room), room=room)
def on_disconnect():
conn_rooms = rooms()
for room in conn_rooms:
leave_room(room)
rc.client_leave_room(sid=req.sid, room=room)
# print('Client disconnected')
# emit("info", req.sid + ' left the room.', room=room)
emit("clients", rc.all_clients_in_room(room=room), room=room)
def on_leave(self, message):
leave_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit(
'reply', {
'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']
})
def handle_server(server):
session["room"] = server
print("Id: {} is now joining room {}".format(request.__getattr__("sid"), server))
joined_rooms = len(rooms())
if joined_rooms==1:
join_room(server)
bots[server].force_event()
def no_longer_typing(data):
typing_user_rooms = rooms()
typing_user_id = get_id_from_rooms(typing_user_rooms)
typing_user = DelhiveryUser.objects.get(id=typing_user_id)
friend = DelhiveryUser.objects.get(id=data['friend'])
if friend.is_online:
emit('sender_stopped_typing', {'typing_user': str(typing_user_id)},
room=str(friend.id))
def join(message):
join_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit(
'Server response', {
'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']
})
def leave(message):
leave_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit(
'my_response', {
'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']
})
def handle_message(message):
print(request.__dict__)
print(auth_ids)
print(rooms())
if session["room"] is not None and request.__getattr__("sid") in auth_ids:
bots[session["room"]].writeLine(message)
else:
print("user {} was not authenticated".format(request.__getattr__("sid")))
def join(message):
join_room(message['room'])
emit(
'ServerResponse', {
'data': 'In rooms: ' + ', '.join(rooms()),
'user': "******",
'date': message['date']
})
def on_leave(self, data):
room_id = data.pop('room', '')
if room_id not in rooms():
return
leave_room(room_id)
print('有人离开了？')
data = {'msg': data['name'] + '离开了房间', 'change': -1}
emit('response', data, broadcast=True, room=room_id)
def no_longer_typing(data):
typing_user_rooms = rooms()
typing_user_id = get_id_from_rooms(typing_user_rooms)
typing_user = FakeBookUser.objects.get(id=typing_user_id)
friend = FakeBookUser.objects.get(id=data['friend'])
if friend in typing_user.friends and typing_user in friend.friends and friend.is_online:
emit('sender_stopped_typing', {'typing_user': str(typing_user_id)},
room=str(friend.id))
def on_message(data):
if 'from' in data and 'text' in data:
if data['from'] in clients: # else received a message from fake client
sid = clients[data['from']]
if sid is rooms()[0]: # else client is faking his identity !'
distribute_message(data)
def join(message):
join_room(message['room'])
emit('join',
{'user': message['user'], 'room': message['room']},
broadcast=True)
room_list = [room for room in rooms() if room != request.sid]
emit('my response',
{'data': 'In rooms: ' + ', '.join(room_list)})
def join(json):
from flask import (current_app, session)
room = json['room']
join_room(room)
current_app.logger.info(
"Client (sid: {}) joined the room ({}).".format(session.sid, room))
data = {"status": "Joined room ({})".format(room), "rooms": rooms()}
emit("message", data)
def on_online_cnt(self, data):
room_id = data['room']
if room_id not in rooms():
emit('online_count', 0, room=room_id)
return
num = len(r_members['/chat'][room_id].keys())
print('是谁再问人数', num)
emit('online_count', num, room=room_id)
def leave(message):
room = int(message['room'])
if manager.operator_leave_room(room, request.sid):
leave_room(message['room'])
emit('my_response',
{'data': 'In rooms: ' + ', '.join(rooms())})
else:
emit('my_response',
{'data': 'Cannot delete operator from this room'})
def disconnect_handler():
"""
Received when the socket is removed or if the client closes the tab.
Remove the client from every game and room he's in.
"""
player_id = get_client_player_id()
for room in rooms()[1:]:
on_game_leave({"game_id": room, "player_id": player_id})
delete_player(player_id)
def join(message):
join_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response',
{'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']})
while(True):
emit('my response',{'data': 'In rooms: ','count': 1})
time.sleep(1)
def rate(data):
sid = rooms()[0]
col = reputationdb[getDomain(data['url']) + '_rating']
myquery = {'rater': sid}
result = col.find(myquery)
if result.count() == 0:
col.insert({'rater': sid, 'rate': data['rate']})
else:
col.update(myquery, {'$set': {'rate': data['rate']}})
def leave(json):
from flask import (current_app, session)
current_app.logger.info("Client (sid: {}) connected".format(session.sid))
room = json['room']
leave_room(room)
current_app.logger.info(
"Client (sid: {}) left the room ({}).".format(session.sid, room))
data = {"status": "Left room ({})".format(room), "rooms": rooms()}
emit("message", data)
def leave(message):
"""Listener for socket room leaving"""
leave_room(message[ec.MArgRoom])
session[ec.SArgReceivedCount] = session.get(ec.SArgReceivedCount, 0) + 1
emit(
ec.MOutPrefabResponse, {
ec.MOutArgData: "In rooms: " + ", ".join(rooms()),
ec.MOutArgCount: session[ec.SArgReceivedCount]
})
def join(message):
global clients
join_room(clients[message['room']])
session['receive_count'] = session.get('receive_count', 0) + 1
emit('qkd',
{'data': 'In rooms ' + ', '.join(rooms()),
'laser': message['laser'],
'count': session['receive_count']
}, room=clients[message['room']])
def socket_connect(js):
user = get_real_or_anonymous_user()
user_id = user.id
join_room('user-%s' % user.id)
rooms_list = rooms()
payload = {'user_id': user_id, 'datetime': str(get_utcnow()), 'rooms_list': rooms_list}
print('< SYN: ' + str(js))
print('> SYN/ACK: ' + str(payload))
emit('SYN/ACK', payload)
def join(message):
session['room'] = message['room']
join_room(message['room'])
emit('log_message_response',
{'data': 'In rooms: ' + ', '.join(rooms())})
emit('join_response_global',
{'username':session['username'], 'user_id':message['user_id']},
broadcast=True)
emit('join_response_local')
def join(message):
join_room(message['room'])
print(f'from join(), message[\'room\'] = {message["room"]}')
session['receive_count'] = session.get('receive_count', 0) + 1
emit(
'my_response', {
'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']
})
def join(message):
join_room(message['room'])
emit('join', {
'user': message['user'],
'room': message['room']
},
broadcast=True)
room_list = [room for room in rooms() if room != request.sid]
emit('my response', {'data': 'In rooms: ' + ', '.join(room_list)})
def on_disconnect(self):
whole = rooms()
room = private_chats.query.filter_by(name=whole[1]).first()
msg = private_messages(chat_id=room.id,
message=current_user.username + '_DISCONNECTED',
server_event='D',
user=current_user.username)
db.session.add(msg)
db.session.commit()
def emit_users_info(sid):
r = rooms(sid=sid)
logger.info("{} now is in: {}".format(current_user.username, r))
emit('users info', {
'amount': len(online_users),
'users': render_template('chat/_users.html', users=online_users),
'rooms_amount': len(r),
'rooms': render_template('chat/_rooms.html', rooms=r)
},
broadcast=True)
def leave(message):
leave_room(message["room"])
session["receive_count"] = session.get("receive_count", 0) + 1
emit(
"my_response",
{
"data": "In rooms: " + ", ".join(rooms()),
"count": session["receive_count"]
},
)
def on_join(self, message):
join_room(message["room"])
session["receive_count"] = session.get("receive_count", 0) + 1
emit(
"my_response",
{
"data": "In rooms: " + ", ".join(rooms()),
"count": session["receive_count"],
},
)
def on_disconnect():
global ACTIVE_CLIENTS
ACTIVE_CLIENTS -= 1
for room in rooms(sid=request.sid):
gm = get_game(room)
if gm:
join_room(room)
gm.players.remove(request.sid)
save_game(gm)
send(gm.to_json(), room=room)
def get_state(data):
session = data["session"]
if session not in rooms():
join_room(session)
gamestate = init.get_gamestate_from_data(data)
if "effects_timestamp" not in data or data["effects_timestamp"] != gamestate.effects_timestamp:
emit('neweffects', get_effects_state(gamestate))
if not "initiatives_timestamp" in data or data["initiatives_timestamp"] != gamestate.initiatives_timestamp:
emit('newstate', get_initiative_state(gamestate))
def leave(message):
leave_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my_response',
{'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']})
roomstats[message['room']] -= 1
if roomstats[message['room']] < 1:
close_room(message['room'])
emit('delete_room', message['room'])
def disconnect_socket():
import flask_socketio
for room in flask_socketio.rooms():
leave_room(room)
global num_sockets
print num_sockets
if num_sockets == 0:
raise Exception('Num sockets is already zero')
num_sockets -= 1
def enterchat(data):
print('entering chat')
# data:
# name, roomid, sid
sid = flask_socketio.rooms()
print('........ ',sid[0])
print('........ ',flask_socketio.rooms())
if flask.session['room'] not in flask_socketio.rooms():
flask_socketio.join_room(flask.session['room'])
print("............", rooms)
#get all the users in this room .
#for each user in this room,
print('sid: ',flask.session['sid'])
# for each in rooms[ flask.session['room']]:
#
# if each != flask.session['name']:
# io.emit("user-joined", { "name": each} , room=flask.session['sid'])
#
# # emit a user joined to only me.
io.emit("joined", { "name": data['name']} , room=flask.session['sid'])
# for eachuser in theRoom:
# io.emit("user-joined", { "name": data['name']} , room=flask.session['sid'] )
#send to everyone in the room
io.emit("user-joined", { "name": data['name']}, room=flask.session['room'] )
def leave(message):
leave_room(message['room'])
room_title = message['room']
user_id = session['user_id']
leaveRoom.leave(dc, user_id, room_title)
session['receive_count'] = session.get('receive_count', 0) + 1
emit('response',
{'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']})
def register_user(data):
"""
Register a user with username:sid.
"""
username = data['username']
sid = rooms()[0]
# add the user to the clients dictionary
clients[username] = sid
emit('user_registered', username, broadcast=True)
def do_msg(message):
"""
This will echo out a message sent here:
socket.send('SOME MESSAGE');
:param message:
:return:
"""
print(rooms())
emit('event', {'data': 'MESSAGE ECHO: ' + message})
def join(message):
join_room(message['room'])
emit('fight status', {'data': 'In rooms: ' + ', '.join(rooms())})
emit('fight status',
{'data': message['player'] + ' joined the battlefield.', 'player': message['player']},
room=message['room'])
front = Battlefront()
front.add_player(message['player'], message['player_room'])
player_list = front.get_player_list()
emit('fight players', {'player': player_list}, room=message['room'], broadcast=True)
def disconnect():
user_rooms = rooms()
for user_room in user_rooms:
leave_room(user_room)
user_id = get_id_from_rooms(user_rooms)
user = DelhiveryUser.objects.get(id=user_id)
user.become_offline()
active_users = get_active_user_ids()
online_friends = get_all_online_delhivery_boys(user)
for friend in online_friends:
emit('refresh_online_friends',room = str(friend.id))
emit('disconnected_offline',{'users':active_users},room='main')
def create_room(data):
user_id = data['user_id']
user = DelhiveryUser.objects.get(id=user_id)
user.become_online()
if user_id not in rooms():
join_room(data['user_id'])
join_room(user.role.role)
active_users = get_active_user_ids()
online_friends = get_all_online_delhivery_boys(user)
for friend in online_friends:
emit('refresh_online_friends',room = str(friend.id))
emit('connected_online',{'users':active_users},room='main')
def send_message(data):
sender_rooms = rooms()
sender_id = get_id_from_rooms(sender_rooms)
receiver = DelhiveryUser.objects.get(id=data['sent_to'])
sender = DelhiveryUser.objects.get(id=sender_id)
chat = DelhiveryChat.get_or_create_chat(sender,receiver)
message = DelhiveryMessages.new_message(data['message'],sender,receiver)
chat.messages.insert(0,message)
chat.save()
if receiver.is_online:
emit('new_message',room=str(receiver.id))
emit('refresh_sender',room=str(sender.id))
def on_disconnect():
sid = rooms()[0]
username = None
for client in clients:
if clients[client] is sid:
username = client
clients.pop(client, None)
break
if username is not None:
emit('user_disconnected', username, broadcast=True)
def on_leave(json):
"""
Sent by client to leave a room
:param json:
:return:
"""
LOG.debug('Received room leave: ' + str(json))
room_name = json.get('room_name')
parts = room_name.split('::')
cluster_name = parts[0]
metrics = parts[1]
leave_room(room_name)
print(rooms())
def joined(json):
"""
Sent by clients when they enter a room.
"""
LOG.debug('Received room join: ' + str(json))
room_name = json.get('room_name')
parts = room_name.split('::')
cluster_name = parts[0]
metric = parts[1]
join_room(room_name)
# sid = request.sid
print(rooms())
task_procesor(room_name, cluster_name=cluster_name, metric=metric)
def chat(data):
#print("lkasdf", flask.request.args)
print("chat data",data)
sender = flask.session['name']
room = flask.session['room']
message = data['message']
print('++++ ',room)
print('is it one of these?', flask_socketio.rooms())
io.emit("new-chat", { 'sender': sender, 'message': message } , room=room )
def disconnect():
print("someone in these rooms disconected", flask_socketio.rooms())
for room in flask_socketio.rooms():
io.emit('someoneleftaroom', room=room)
#flask_socketio.leave_room(room)
if room in rooms:
print("removing user from room")
print (rooms[room])
rooms[room].remove(flask.session['name'])
print (rooms[room])
if room in game:
if flask.session['sid'] in game[room]:
print('removing player from game.')
print(game[room])
game[room].remove(flask.session['sid'])
io.emit('playerleftgame', room=room)
print(game[room])
def join(message):
join_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit('Server response',
{'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']})
def join(message):
join_room(message['room'])
emit('my response',
{'data': 'In rooms: ' + ', '.join(rooms()),
'count': session['receive_count']})
def leave(message):
leave_room(message['room'])
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response',
{'data': 'In rooms: ' + ', '.join(rooms()),
'user': flask_login.current_user.username})
