def on_unready(data):
room_id = data['room_id']
room = active_rooms[room_id]
player_id = UUID(request.sid)
player = room.players[player_id]
if room.session is not None:
room.session.eliminate_player_by_id(player_id)
else:
player.status = PlayerStatus.joined
socketio.emit("game_update", build_game_update_payload(room), room=str(room_id))
python类sid()的实例源码
def handle_connected():
# clients.append(request.namespace)
sockets.append(request.sid)
def handle_disconnected():
# clients.remove(request.namespace)
sockets.remove(request.sid)
def handle_connected():
"""
connect: ????
"""
sockets.append(request.sid)
def handle_disconnected():
"""
disconnect: ??????
"""
sockets.remove(request.sid)
def watchdog_connect():
if sentrygund.config.debug:
print '[debug][views] %s connected' % (request.sid)
clients.append(request.sid)
def watchdog_disconnect_request():
if sentrygund.config.debug:
print '[debug][views] %s connected' % (request.sid)
clients.remove(request.sid)
disconnect()
# VIEWS -----------------------------------------------------------------------
def handle_disconnect():
"""
Disconnect handler that removes the client from the room list
:return:
"""
app.logger.debug("Client disconnected: " + str(request.sid))
with lock:
sid = str(request.sid)
try:
client_dict.pop(sid)
except KeyError:
pass
# @socketio.on('client-message')
# def handle_client_message(msg):
# """
# Custom event name example
# :param msg:
# :return:
# """
# # emit message on server-message channel and set a callback for handling delivery
# emit('server-message', ('lele', 'theeke'), callback=ack)
# app.logger.debug('Client message received: ' + msg)
# # return acknowledgement: can be processed as args i client callback
# return 'got it', 'carry on'
# def ack():
# """
# Callback for acknowledging whether
# client received the message or not
# :return:
# """
# print "ack"
# def messenger():
# """
# Simple stupid test
# :return:
# """
# for i in range(0,100):
# if len(client_dict) > 0:
# idx = i % len(client_dict)
# app.logger.info('Sending message to client in room: ')
# socketio.emit('server-message', {'data': 'Message sent at time: ' + str(i)})
# app.logger.info('Messenger in iteration: ' + str(i))
# sleep(5)
#
def uber_oauth_response():
params = parse_req_data(request)
event = params.get('event_type')
if event != 'requests.status_changed':
logger.error('Unsure how to handle event from Uber: {}'.format(event))
return rh.json_response()
metadata = params.get('meta') or {}
external_ride_id = metadata.get('resource_id')
if not external_ride_id:
logger.error('Couldn\'t find meta.resource_id in params body...: {}'.format(params))
return rh.json_response()
pending_ride = find(PendingRide, {'external_ride_id': external_ride_id})
if not pending_ride:
logger.error('No Pending Ride for external_ride_id: {}'.format(external_ride_id))
return rh.json_response()
user = find(User, {'id': pending_ride.user_id})
if not user:
logger.error('No User for id: {}'.format(pending_ride.user_id))
return rh.json_response()
# Get all socket ids associated with user from cache
user_sids = cache.hget(config('USER_CONNECTIONS'), user.uid) or []
if not user_sids:
logger.error('No open sockets registered for user with uid: {}'.format(user.uid))
return rh.json_response()
status = metadata.get('status')
status_update = uber_status_update(status)
if not status_update:
logger.error('No status update could be found for ride status: {}'.format(status))
return rh.json_response()
# Update the ride even if no need to reach out to user
logger.info('Updating pending ride with uid {} to status of {}'.format(pending_ride.uid, status))
update(pending_ride, {'status', status_update['status']})
if status_update.get('destroy_ride'):
destroy_instance(pending_ride)
response_msg = status_update.get('response')
if response_msg:
[socket.emit('job:update', {'text': response_msg}, namespace=namespace, room=sid) for sid in user_sids]
return rh.json_response()
# ---- Socket Listeners ----
