def get(self):
send_welcome = False
user = self.get_secure_cookie("user")
room_id = redis.lobby_room_id
redis.UserManager.user_add(room_id, user, self)
# if user login into lobby first time, send welcome message
if redis.UserManager.user_welcome(user):
message = {
"id": str(uuid.uuid4()),
"user": user,
"time": time.strftime("%H:%M:%S"),
"type": "welcome_message",
}
message["body"] = user
message["html"] = self.render_string("message.html", message=message)
room_waiters = redis.WaiterManager.get_waiters_for_room_id(room_id)
for callback in room_waiters:
try:
# 增加消息类型，让客户端js舍弃此次消息的id，而使用上次的
callback([message], "welcome_message")
except Exception, e:
LOG.error("Error in waiter callback", exc_info=True)
LOG.exception(e)
redis.WaiterManager.empty_waiter(room_id)
multicast_sender(dict(user=user, message=[message]), "send_welcome")
send_welcome = True
def get(self):
send_welcome = False
user = self.get_secure_cookie("user")
room_id = redis.lobby_room_id
redis.UserManager.user_add(room_id, user, self)
# if user login into lobby first time, send welcome message
if redis.UserManager.user_welcome(user):
message = {
"id": str(uuid.uuid4()),
"user": user,
"time": time.strftime("%H:%M:%S"),
"type": "welcome_message",
}
message['body'] = user
message["html"] = self.render_string("message.html",
message=message)
room_waiters = redis.WaiterManager.get_waiters_for_room_id(room_id)
for callback in room_waiters:
try:
# 增加消息类型，让客户端js舍弃此次消息的id，而使用上次的
callback([message], "welcome_message")
except Exception, e:
LOG.error("Error in waiter callback", exc_info=True)
LOG.exception(e)
redis.WaiterManager.empty_waiter(room_id)
multicast_sender(dict(user=user, message=[message]),
"send_welcome")
send_welcome = True
def get(self):
room_name = self.get_argument("room_name")
room_max_user = self.get_argument("room_max_user")
# and chat room in local process and redis.
room_id = redis.ChatroomManager.add_chat_room(room_name, room_max_user)
# send "add_chatroom" to multicast channel.
if room_id:
ret = multicast_sender(redis.ChatroomManager.init_remote_chat_room(room_id), "command")
if ret:
self.write({"return": 0})
else:
self.send_error(500)
def get(self):
room_name = self.get_argument("room_name")
room_max_user = self.get_argument("room_max_user")
# and chat room in local process and redis.
room_id = redis.ChatroomManager.add_chat_room(room_name, room_max_user)
# send "add_chatroom" to multicast channel.
if room_id:
ret = multicast_sender(
redis.ChatroomManager.init_remote_chat_room(room_id),
"command")
if ret:
self.write({"return": 0})
else:
self.send_error(500)
def post(self):
room_id = self.get_argument("room_id")
body = self.get_argument("body")
msg_from = self.get_secure_cookie("user")
# 当server重启后，server接收到client的新消息ajax请求
# 发现用户不在线，则将用户加入到 userlist:room:x
# 可以做到当server重启后，client依然能够自动接收到消息
if not redis.UserManager.is_user_online(msg_from):
redis.UserManager.user_add(room_id, msg_from, self)
online_offline(room_id,
msg_from,
"online",
remote_ip=self.request.remote_ip)
if not msg_from:
self.finish({"status": "logout"})
return
msg_id = str(uuid.uuid4())
message = {
"id": msg_id,
"from": msg_from,
"body": body,
"room_id": room_id,
"time": time.strftime("%H:%M:%S"),
"type": "normal_chat"
}
########################## start command process ############################
commander = CommandManager(body)
if commander.is_command:
ret = commander.analyst()
# user to user chat
if ret[0] == manager.USER_TO_USER_CHAT:
user, user_message = ret[2], ret[3]
# user is not online in current
if not redis.UserManager.is_user_online(user):
message = {
"id": str(uuid.uuid4()),
"time": time.strftime("%H:%M:%S"),
}
message['type'] = "user_offline"
message["html"] = self.render_string("message.html",
message=message)
self.finish(message)
return
user_waiters = redis.UserManager.is_local_user(
user.encode('UTF-8'))
message['type'] = "private_chat"
message['body'] = user_message
message["html"] = self.render_string("message.html",
message=message)
# if user on local process
if user_waiters:
for waiter in user_waiters:
try:
waiter([message])
except Exception, e:
LOG.exception(e)
# send message to multicast channel
else:
multicast_sender(dict(message=[message], user=user),
"p2p_chat")
# send feedback to user
message.pop('body')
message['type'] = "private_chat_sent"
message["id"] = str(uuid.uuid4())
message["html"] = self.render_string("message.html",
message=message)
self.finish(message)
return
# broadcast message
elif ret[0] == manager.BROADCAST_CHAT:
broadcast_message = ret[2]
# send broadcast to local waiters
waiters = redis.WaiterManager.get_all_local_waiter()
message['type'] = "broadcast_chat"
message['body'] = broadcast_message
message["html"] = self.render_string("message.html",
message=message)
if waiters:
for waiter in waiters:
try:
waiter([message])
except Exception, e:
LOG.exception(e)
# send broadcast to multicast channel
multicast_sender(dict(message=[message]), "broadcast")
# send feedback to user
message.pop('body')
message["id"] = str(uuid.uuid4())
message['type'] = "broadcast_sent"
message["html"] = self.render_string("message.html",
message=message)
self.finish(message)
return
def new_messages(self, messages, room_id):
room_waiters = redis.WaiterManager.get_waiters_for_room_id(room_id)
LOG.warning("Server sending new message to %r listeners" %
len(room_waiters))
for callback in room_waiters:
try:
callback(messages)
except Exception, e:
LOG.error("Error in waiter callback", exc_info=True)
LOG.exception(e)
redis.WaiterManager.empty_waiter(room_id)
redis.MessageCacheManager.add_msg_cache(messages, room_id)
# send messages to multicast channel
multicast_sender(messages, "message")
class RoomList(WebHandler):
def get(self):
send_welcome = False
user = self.get_secure_cookie("user")
room_id = redis.lobby_room_id
redis.UserManager.user_add(room_id, user, self)
# if user login into lobby first time, send welcome message
if redis.UserManager.user_welcome(user):
message = {
"id": str(uuid.uuid4()),
"user": user,
"time": time.strftime("%H:%M:%S"),
def post(self):
room_id = self.get_argument("room_id")
body = self.get_argument("body")
msg_from = self.get_secure_cookie("user")
# 当server重启后，server接收到client的新消息ajax请求
# 发现用户不在线，则将用户加入到 userlist:room:x
# 可以做到当server重启后，client依然能够自动接收到消息
if not redis.UserManager.is_user_online(msg_from):
redis.UserManager.user_add(room_id, msg_from, self)
online_offline(room_id, msg_from, "online", remote_ip=self.request.remote_ip)
if not msg_from:
self.finish({"status": "logout"})
return
msg_id = str(uuid.uuid4())
message = {
"id": msg_id,
"from": msg_from,
"body": body,
"room_id": room_id,
"time": time.strftime("%H:%M:%S"),
"type": "normal_chat",
}
########################## start command process ############################
commander = CommandManager(body)
if commander.is_command:
ret = commander.analyst()
# user to user chat
if ret[0] == manager.USER_TO_USER_CHAT:
user, user_message = ret[2], ret[3]
# user is not online in current
if not redis.UserManager.is_user_online(user):
message = {"id": str(uuid.uuid4()), "time": time.strftime("%H:%M:%S")}
message["type"] = "user_offline"
message["html"] = self.render_string("message.html", message=message)
self.finish(message)
return
user_waiters = redis.UserManager.is_local_user(user.encode("UTF-8"))
message["type"] = "private_chat"
message["body"] = user_message
message["html"] = self.render_string("message.html", message=message)
# if user on local process
if user_waiters:
for waiter in user_waiters:
try:
waiter([message])
except Exception, e:
LOG.exception(e)
# send message to multicast channel
else:
multicast_sender(dict(message=[message], user=user), "p2p_chat")
# send feedback to user
message.pop("body")
message["type"] = "private_chat_sent"
message["id"] = str(uuid.uuid4())
message["html"] = self.render_string("message.html", message=message)
self.finish(message)
return
# broadcast message
elif ret[0] == manager.BROADCAST_CHAT:
broadcast_message = ret[2]
# send broadcast to local waiters
waiters = redis.WaiterManager.get_all_local_waiter()
message["type"] = "broadcast_chat"
message["body"] = broadcast_message
message["html"] = self.render_string("message.html", message=message)
if waiters:
for waiter in waiters:
try:
waiter([message])
except Exception, e:
LOG.exception(e)
# send broadcast to multicast channel
multicast_sender(dict(message=[message]), "broadcast")
# send feedback to user
message.pop("body")
message["id"] = str(uuid.uuid4())
message["type"] = "broadcast_sent"
message["html"] = self.render_string("message.html", message=message)
self.finish(message)
return
def new_messages(self, messages, room_id):
room_waiters = redis.WaiterManager.get_waiters_for_room_id(room_id)
LOG.warning("Server sending new message to %r listeners" % len(room_waiters))
for callback in room_waiters:
try:
callback(messages)
except Exception, e:
LOG.error("Error in waiter callback", exc_info=True)
LOG.exception(e)
redis.WaiterManager.empty_waiter(room_id)
redis.MessageCacheManager.add_msg_cache(messages, room_id)
# send messages to multicast channel
multicast_sender(messages, "message")
class RoomList(WebHandler):
def get(self):
send_welcome = False
user = self.get_secure_cookie("user")
room_id = redis.lobby_room_id
redis.UserManager.user_add(room_id, user, self)
# if user login into lobby first time, send welcome message
if redis.UserManager.user_welcome(user):
message = {
"id": str(uuid.uuid4()),
"user": user,
"time": time.strftime("%H:%M:%S"),
