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 run(self):
'''
暂停指定的时间，到时间后执行一些列动作
'''
time.sleep(self.seconds)
result = running_t.query_one(uuid=self.uuid)
if result:
if cond.acquire():
# 从running_dict中删除用户
try:
del_vm_in_mem(self.uuid)
# nginx负载均衡中删除主机
del_nginx_host(self.uuid)
except Exception, e:
LOG.exception(e)
# 从running_t中删除用户
running_t.delete(uuid=self.uuid)
# 调用openstack删除主机
nova_api.delete_vm(self.uuid)
# 更新backup_t中的deleted_time
deleted_time = time.time()
backup_t.update(dict(uuid=self.uuid), deleted_time=deleted_time)
# 通知排队线程
cond.notify()
cond.release()
return
def run(self):
'''
暂停指定的时间，到时间后执行一些列动作
'''
time.sleep(self.seconds)
result = running_t.query_one(uuid=self.uuid)
if result:
if cond.acquire():
# 从running_dict中删除用户
try:
del_vm_in_mem(self.uuid)
# nginx负载均衡中删除主机
del_nginx_host(self.uuid)
except Exception, e:
LOG.exception(e)
# 从running_t中删除用户
running_t.delete(uuid=self.uuid)
# 调用openstack删除主机
nova_api.delete_vm(self.uuid)
# 更新backup_t中的deleted_time
deleted_time = time.time()
backup_t.update(dict(uuid=self.uuid),
deleted_time=deleted_time)
# 通知排队线程
cond.notify()
cond.release()
return
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 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)
def run(self):
while 1:
try:
ip_addr = nova_api.query_vm(self.uuid)
except Exception, e:
LOG.exception(e)
return
if ip_addr:
break
time.sleep(1)
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)
def run(self):
while 1:
try:
ip_addr = nova_api.query_vm(self.uuid)
except Exception, e:
LOG.exception(e)
return
if ip_addr:
break
time.sleep(1)
def wait_for_messages(self, callback, room_id, user, cursor=None):
if cursor:
index = 0
msg_cache = redis.MessageCacheManager.get_msg_for_room_id(room_id)
for i in xrange(len(msg_cache)):
index = len(msg_cache) - i - 1
if msg_cache[index]["id"] == cursor:
break
recent = msg_cache[index + 1:]
if recent:
try:
callback(recent)
except Exception, e:
LOG.error("Error in waiter callback", exc_info=True)
LOG.exception(e)
def wait_for_messages(self, callback, room_id, user, cursor=None):
if cursor:
index = 0
msg_cache = redis.MessageCacheManager.get_msg_for_room_id(room_id)
for i in xrange(len(msg_cache)):
index = len(msg_cache) - i - 1
if msg_cache[index]["id"] == cursor:
break
recent = msg_cache[index + 1 :]
if recent:
try:
callback(recent)
except Exception, e:
LOG.error("Error in waiter callback", exc_info=True)
LOG.exception(e)
def _get_host_amount(self, conf_path):
# on error callback function, just raise the error
def listdir_onerror(error):
raise error
host_amount = 0
host_list = []
# the dirs will be an empty list, because the depth is 1
try:
for root, dirs, files in os.walk(conf_path, onerror=listdir_onerror):
for file in files:
if os.path.isfile(os.path.join(root, file)):
host_amount += 1
host_list.append(file.split(settings.conf_suffix)[0])
except Exception, e:
LOG.exception(e)
return None
def _get_host_amount(self, conf_path):
# on error callback function, just raise the error
def listdir_onerror(error):
raise error
host_amount = 0
host_list = []
# the dirs will be an empty list, because the depth is 1
try:
for root, dirs, files in os.walk(conf_path,
onerror=listdir_onerror):
for file in files:
if os.path.isfile(os.path.join(root, file)):
host_amount += 1
host_list.append(file.split(settings.conf_suffix)[0])
except Exception, e:
LOG.exception(e)
return None
def multicast_processor(conn, local_node_id=None):
data, address = conn.recvfrom(1024)
data = crypter.decrypt(data)
data = eval(data)
remote_node_id = data['node_id']
msg_type = data['msg_type']
body = data['body']
if remote_node_id != local_node_id:
if msg_type == "message":
room_id = body[0]['room_id']
waiters = redis.WaiterManager.get_waiters_for_room_id(room_id)
if waiters:
for waiter in waiters:
try:
waiter(body)
except Exception, e:
LOG.exception(e)
redis.WaiterManager.empty_waiter(room_id)
LOG.warning("Receive [normal chat] message and send to %r listeners." % len(waiters))
elif msg_type == "command":
cmd = body['cmd']
if "add_chatroom" == cmd:
room_id = body['room_id']
if redis.ChatroomManager.add_local_chat_room(room_id):
LOG.warning("Receive command add chat room %d." % room_id)
elif "del_chatroom" == cmd:
pass
elif msg_type == "p2p_chat":
user = body['user']
message = body['message']
user_waiters = redis.UserManager.is_local_user(user.encode('utf-8'))
if user_waiters:
for waiter in user_waiters:
try:
waiter(message)
except Exception, e:
LOG.exception(e)
LOG.warning("Receive [p2p] message and send to %s listeners." % user)
def online_offline(room_id, user, on_off, **kwargs):
"""
当用户上下线的时候，通知对应房间内的用户
当/post_new, /poll_message, /chat/xxxxx
这三个URL被访问时，并判断用户是否已在线，发送online
当关闭浏览器/标签的时候
会导致关闭/poll_message连接，发送offline
"""
message = dict(user=user, on_off=on_off)
if on_off == "online":
message["remote_ip"] = kwargs.pop("remote_ip")
room_waiters = redis.WaiterManager.get_waiters_for_room_id(room_id)
try:
for waiter in room_waiters:
waiter(message, "online_offline")
except Exception, e:
LOG.exception(e)
def online_offline(room_id, user, on_off, **kwargs):
'''
当用户上下线的时候，通知对应房间内的用户
当/post_new, /poll_message, /chat/xxxxx
这三个URL被访问时，并判断用户是否已在线，发送online
当关闭浏览器/标签的时候
会导致关闭/poll_message连接，发送offline
'''
message = dict(user=user, on_off=on_off)
if on_off == "online":
message["remote_ip"] = kwargs.pop("remote_ip")
room_waiters = redis.WaiterManager.get_waiters_for_room_id(room_id)
try:
for waiter in room_waiters:
waiter(message, "online_offline")
except Exception, e:
LOG.exception(e)
def run(self):
if cond.acquire():
del_vm_in_mem(self.uuid)
# 当调用cloudopen接口处理失败时，调用tornado返回500
try:
nova_api.delete_vm(self.uuid)
except Exception, e:
LOG.exception(e)
running_t.delete(uuid=self.uuid)
# 更新backup_t中的deleted_time
deleted_time = time.time()
backup_t.update(dict(uuid=self.uuid), deleted_time=deleted_time)
self.obj.send_error(500)
return
else:
try:
del_nginx_host(self.uuid)
except Exception, e:
LOG.exception(e)
def run(self):
if cond.acquire():
del_vm_in_mem(self.uuid)
# 当调用cloudopen接口处理失败时，调用tornado返回404
try:
del_nginx_host(self.uuid)
nova_api.delete_vm(self.uuid)
except Exception, e:
LOG.exception(e)
self.obj.send_error(500)
running_t.delete(uuid=self.uuid)
# 更新backup_t中的deleted_time
deleted_time = time.time()
backup_t.update(dict(uuid=self.uuid), deleted_time=deleted_time)
# 当全部处理成功后，调用tornado返回成功状态
self.obj.write({"status": 0})
tornado.ioloop.IOLoop.instance().add_callback(self.obj.on_write)
cond.notify()
cond.release()
return
def run(self):
if cond.acquire():
del_vm_in_mem(self.uuid)
# 当调用cloudopen接口处理失败时，调用tornado返回404
try:
del_nginx_host(self.uuid)
nova_api.delete_vm(self.uuid)
except Exception, e:
LOG.exception(e)
self.obj.send_error(500)
running_t.delete(uuid=self.uuid)
# 更新backup_t中的deleted_time
deleted_time = time.time()
backup_t.update(dict(uuid=self.uuid), deleted_time=deleted_time)
# 当全部处理成功后，调用tornado返回成功状态
self.obj.write({"status": 0})
tornado.ioloop.IOLoop.instance().add_callback(self.obj.on_write)
cond.notify()
cond.release()
return
def process_receive(self, data, node_id):
try:
data = eval(data)
except Exception, e:
LOG.exception(e)
raise
if user_waiters:
for waiter in user_waiters:
try:
waiter(message)
except Exception, e:
LOG.exception(e)
LOG.warning("Receive [p2p] message and send to %s listeners." % user)
elif msg_type == "broadcast":
message = body['message']
waiters = redis.WaiterManager.get_all_local_waiter()
for waiter in waiters:
try:
waiter(message)
except Exception, e:
LOG.exception(e)
LOG.warning("Receive [broadcast] message and send to %s listeners." % len(waiters))
elif msg_type == "send_welcome":
message = body['message']
waiters = redis.WaiterManager.get_all_local_waiter()
for waiter in waiters:
try:
waiter(message)
except Exception, e:
LOG.exception(e)
LOG.warning("Receive [welcome] message and send to %s listeners." % len(waiters))
def multicast_sender(messages, msg_type, local_node_id=None):
"""
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 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 process_receive(self, data, node_id):
try:
data = eval(data)
except Exception, e:
LOG.exception(e)
raise
