def insert_into_queue(self):
# 创建时间
created_time = from_now_to_datetime()
item.setdefault("created_time", created_time)
# 在waitting_t中加入请求
obj_id = waitting_t.insert(**self.item)
# 请求被排队
# 日志表里插入created_time，并增加waitting_id
# waitting_id是在waitting_t中获得的id
# 用于在RunningPutter线程中更新processed_time
# NOTICE: 目前使用uuid作为删除实例时更新deleted_time的条件
# user_id用于查询
created_time = time.time()
backup_t.insert(user_id=self.user_id, created_time=created_time, waitting_id=obj_id,
instance_data=self.instance_data)
# 将请求加入到等待队列
# 2013/02/20: 将db的_objectid也压入队列
# 在waitting_t中删除元素的时候，就根据_objectid删除
# 而不是user_id
item['_oid'] = obj_id
waitting_queue.put(self.item)
LOG.info("put data to waitting queue {0}: {1}".format(self.user_id, self.instance_data))
result = waitting_t.query(_id=obj_id)
# 返回排队的序号
for line in result:
auto_id = line['auto_id']
self.write(dict(status = auto_id))
self.finish()
def check_max_instance_for_user(user_id):
count = 1
for item in running_list:
if item['user_id'] == user_id:
count += 1
LOG.info("instances for %s is %s" % (user_id, count))
return count
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 check_max_instance_for_user(user_id):
count = 1
for item in running_list:
if item['user_id'] == user_id:
count += 1
LOG.info("instances for %s is %s" % (user_id, count))
return count
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 delete_vm(instance_id):
resp, body = api.deleteInstance(instance_id)
body = json.loads(body)
msg = body['msg']
LOG.info("%s vm deleted: %s" % (from_now_to_datetime(), instance_id))
LOG.info("Got return from cloudopen: %s" % msg)
return msg
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 add_nginx_host(instance_id=None, host=None, port=None):
msg_id = instance_id
msg_type = "add"
node_id = "client"
message = dict(msg_type=msg_type, msg_id=msg_id, dst_host=host, dst_port=port, node_id=node_id)
message = str(message)
sender(message)
LOG.info("Send to multicast: %s" % message)
def handler_signal(signum, frame):
# if process receive SIGNINT/SITTERM/SIGQUIT
# stop the server
if signum == 2 or signum == 3 or signum == 15:
LOG.error("Receive signal: %s" % signum)
LOG.error("Server quit.")
server_stop()
elif signum == 14: # ignore SIGALARM
pass
def handler_signal(signum, frame):
# if process receive SIGNINT/SITTERM/SIGQUIT
# stop the server
if signum == 2 or signum == 3 or signum == 15:
LOG.error("Receive signal: %s" % signum)
LOG.error("Server quit.")
server_stop()
elif signum == 14: # ignore SIGALARM
pass
def run(self):
if cond.acquire():
while 1:
if len(running_list) < options.running_dict_size \
and not waitting_queue.empty():
# 从等待队列中获取元素
item = waitting_queue.get()
try:
# 创建实例
uuid = nova_api.create_vm(item)
item['uuid'] = uuid
except Exception, e:
waitting_t.delete(_id=item['_oid'])
else:
# 为实例增加端口映射
os = item['instance_data']['os']
balancer = addNginxHost(uuid, os)
balancer.start()
# 实例加入到running_dict中
insert_vm_in_mem(item)
# 实例的到期时间
expired_time = from_now_to_datetime(seconds=seconds)
# 启动定时器
timer = Timer(uuid=uuid,
item=item,
seconds=cal_seconds_to(expired_time))
timer.start()
timer_list.append(timer)
# 在running_t中插入记录
obj_id = running_t.insert(
uuid=uuid,
user_id=item['user_id'],
expired_time=expired_time,
instance_data=item['instance_data'])
# 从等待的waitting_t中删除对应的记录
# 2013/02/20: 根据_id删除，而不是user_id
waitting_t.delete(_id=item['_oid'])
LOG.info("Get item from waitting_queue: %s" % item)
# 排队的请求被处理，根据waitting_id更新processed_time
# 并增加running_id，用于删除时例时更新deleted_time
# NOTICE: 目前使用uuid更新backup_t中deleted_time的条件
processed_time = time.time()
backup_t.update(dict(waitting_id=item['_oid']),
processed_time=processed_time,
uuid=uuid,
running_id=obj_id)
else:
cond.wait()
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 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 test_hhzui(self, value):
UItest = Baseway(value)
yqString = value['Expected']
LOG.info(
'inputdata> 执行步骤:%s,操作名称:%s，操作方法:%s ,元素:%s,参数:%s' %
(value['Testscenarios'], value['Functioname'], value['Opmethod'],
value['Pagelements'], value['inputparamete']))
ResultString = UItest.Uiaototest()
print(str(yqString), str(ResultString))
self.check(yqString, ResultString)
def create_vm(vm):
user_id = vm['user_id']
instance_data = vm['instance_data']
server_os = instance_data['os']
server_name = instance_data['name']
resp, body = api.createInstance(user_id, server_os, server_name)
LOG.info("Cloudopen create instance: %s %s %s" % (user_id, server_os, server_name))
LOG.info("Got return from cloudopen: %s" % body)
body = json.loads(body)
instance_id = body['instance_id']
return instance_id
def update_nginx_host(conn):
data, address = conn.recvfrom(2048)
data = eval(data)
node_id = data['node_id']
msg_type = data['msg_type']
if node_id != "client" and msg_type != "heartbeat":
LOG.info("Receive from multicast: %s" % data)
instance_id = data['msg_id']
host = data['target_host']
port = data['target_port']
running_t.update(dict(uuid=instance_id), host=host, port=port)
def update_nginx_host(conn):
data, address = conn.recvfrom(2048)
data = eval(data)
node_id = data["node_id"]
msg_type = data["msg_type"]
if node_id != "client" and msg_type != "heartbeat":
LOG.info("Receive from multicast: %s" % data)
instance_id = data["msg_id"]
host = data["target_host"]
port = data["target_port"]
running_t.update(dict(uuid=instance_id), host=host, port=port)
def add_nginx_host(instance_id=None, host=None, port=None):
msg_id = instance_id
msg_type = "add"
node_id = "client"
message = dict(msg_type=msg_type,
msg_id=msg_id,
dst_host=host,
dst_port=port,
node_id=node_id)
message = str(message)
sender(message)
LOG.info("Send to multicast: %s" % message)
def run(self):
if cond.acquire():
while 1:
if len(running_list) < options.running_dict_size \
and not waitting_queue.empty():
# 从等待队列中获取元素
item = waitting_queue.get()
try:
# 创建实例
uuid = nova_api.create_vm(item)
item['uuid'] = uuid
except Exception, e:
waitting_t.delete(_id=item['_oid'])
else:
# 为实例增加端口映射
os = item['instance_data']['os']
balancer = addNginxHost(uuid, os)
balancer.start()
# 实例加入到running_dict中
insert_vm_in_mem(item)
# 实例的到期时间
expired_time = from_now_to_datetime(seconds=seconds)
# 启动定时器
timer = Timer(uuid=uuid, item=item,
seconds=cal_seconds_to(expired_time))
timer.start()
timer_list.append(timer)
# 在running_t中插入记录
obj_id = running_t.insert(uuid=uuid, user_id=item['user_id'],
expired_time=expired_time,
instance_data=item['instance_data'])
# 从等待的waitting_t中删除对应的记录
# 2013/02/20: 根据_id删除，而不是user_id
waitting_t.delete(_id=item['_oid'])
LOG.info("Get item from waitting_queue: %s" % item)
# 排队的请求被处理，根据waitting_id更新processed_time
# 并增加running_id，用于删除时例时更新deleted_time
# NOTICE: 目前使用uuid更新backup_t中deleted_time的条件
processed_time = time.time()
backup_t.update(dict(waitting_id=item['_oid']),
processed_time=processed_time,
uuid=uuid, running_id=obj_id)
else:
cond.wait()
def is_local_user(user):
"""
当一个用户进入多个房间的时候
返回所有和这个用户相关的回调连接
(言下之意，连接不止一个, 虽然只有一个用户)
"""
user_waiters = list()
for room in room_list:
if user in room['room_waiter_list']:
user_waiters.append(room['room_waiter_list'][user])
if user_waiters:
LOG.info("got %s conn for user: %s" % (len(user_waiters), user))
return user_waiters
return False
def is_local_user(user):
"""
当一个用户进入多个房间的时候
返回所有和这个用户相关的回调连接
(言下之意，连接不止一个, 虽然只有一个用户)
"""
user_waiters = list()
for room in room_list:
if user in room['room_waiter_list']:
user_waiters.append(room['room_waiter_list'][user])
if user_waiters:
LOG.info("got %s conn for user: %s" % (len(user_waiters), user))
return user_waiters
return False
def add_chat_room(room_name, room_max_user, room_cache_size=50):
max_room_id = ChatroomManager.get_max_room_id()
if not max_room_id:
return False
room_key = room_prefix + str(max_room_id + 1)
if key_exists(room_key):
return False
try:
room_max_user = int(room_max_user)
except Exception, e:
LOG.info("the parameter 'room_max_user' is not a digest!")
room_max_user = default_room_max_user
def add_chat_room(room_name, room_max_user, room_cache_size=50):
max_room_id = ChatroomManager.get_max_room_id()
if not max_room_id:
return False
room_key = room_prefix + str(max_room_id + 1)
if key_exists(room_key):
return False
try:
room_max_user = int(room_max_user)
except Exception, e:
LOG.info("the parameter 'room_max_user' is not a digest!")
room_max_user = default_room_max_user
def del_nginx_host(instance_id=None):
msg_id = instance_id
msg_type = "del"
node_id = "client"
result = running_t.query_one(uuid=instance_id)
try:
port = result["port"]
except KeyError:
LOG.info("Error occured in get port.")
return
message = dict(msg_type=msg_type, msg_id=msg_id, server=port, node_id=node_id)
message = str(message)
sender(message)
LOG.info("Send to multicast: %s" % message)
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 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 del_nginx_host(instance_id=None):
msg_id = instance_id
msg_type = "del"
node_id = "client"
result = running_t.query_one(uuid=instance_id)
try:
port = result['port']
except KeyError:
LOG.info("Error occured in get port.")
return
message = dict(msg_type=msg_type,
msg_id=msg_id,
server=port,
node_id=node_id)
message = str(message)
sender(message)
LOG.info("Send to multicast: %s" % message)
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_sender(messages, msg_type, local_node_id=None):
"""
Send message to multicast channel.
messages: message need to send.
msg_type: type of message, can be "message" or "command".
"""
msg = dict(
node_id = local_node_id,
msg_type = msg_type,
body = messages
)
msg = str(msg)
msg = crypter.encrypt(msg)
try:
if sender(msg):
LOG.warning("Send %d to multicast channel." % len(messages))
except Exception, e:
return False
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 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 on_create_vm(self, response):
body = json.loads(response.body)
self.uuid = body['instance_id']
self.item['uuid'] = self.uuid
# 为实例增加端口映射
balancer = addNginxHost(self.uuid, self.os)
balancer.start()
# 实例加入到running_dict中
insert_vm_in_mem(self.item)
# 实例的到期时间
expired_time = from_now_to_datetime(seconds=seconds)
# 启动定时器
timer = Timer(uuid=self.uuid, item=self.item,
seconds=cal_seconds_to(expired_time))
timer.start()
timer_list.append(timer)
# 在running_t中插入一条记录
obj_id = running_t.insert(uuid=self.uuid, user_id=self.user_id,
expired_time=expired_time, instance_data=self.instance_data)
# 请求被立即处理
# 日志表里插入created_time和processed_time
# 并增加running_id，用于删除实例时更新deleted_time
# user_id用于查询用
processed_time = time.time()
backup_t.insert(user_id=self.user_id, created_time=processed_time, processed_time=processed_time,
instance_data=self.instance_data, running_id=obj_id, uuid=self.uuid)
LOG.info("Start timer for {0}: {1}".format(self.user_id, self.instance_data))
# 返回0
self.write(dict(status = 0))
self.finish()
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 rebuild_timer_and_queue():
'''
服务器重启时，从mongodb中读取记录并恢复定时器和队列
启动固定数量的timer
并将等待的请求放入到等待队列中
'''
LOG.info("Rebuild timer and waitting queue")
running_timer = running_t.query()
waitters = waitting_t.query()
for line in running_timer:
if line.has_key("instance_data"):
expired_time = line['expired_time']
seconds = cal_seconds_to(expired_time)
uuid = line['uuid']
user_id = line['user_id']
instance_data = line['instance_data']
_oid = line['_id']
# 定时器已经到期，立即删除运行的实例
if seconds < 0:
try:
nova_api.delete_vm(uuid)
except:
pass
running_t.delete(uuid=uuid)
# 更新backup_t中的deleted_time
deleted_time = time.time()
backup_t.update(dict(uuid=uuid), deleted_time=deleted_time)
else:
# 恢复running_dict和定时器
item = dict(user_id=user_id, instance_data=instance_data)
item['uuid'] = uuid
# 2013/03/01
# 增加_oid到元素，RunningPutter可以根据此_oid删除waitting_t中的元素
# 其实从mongodb中取得的记录已包含_id
# 此处为了加强重点，重复加入
item['_oid'] = _oid
insert_vm_in_mem(item)
timer = Timer(uuid=uuid, seconds=seconds, item=item)
timer.start()
timer_list.append(timer)
for line in waitters:
if line.has_key("instance_data"):
LOG.info("insert data to waitting queue: %s" % line)
user_id = line['user_id']
item = dict(_oid=line['_id'],
user_id=user_id,
instance_data=instance_data)
waitting_queue.put(item)
LOG.info("Rebuild end")
def rebuild_timer_and_queue():
'''
服务器重启时，从mongodb中读取记录并恢复定时器和队列
启动固定数量的timer
并将等待的请求放入到等待队列中
'''
LOG.info("Rebuild timer and waitting queue")
running_timer = running_t.query()
waitters = waitting_t.query()
for line in running_timer:
if line.has_key("instance_data"):
expired_time = line['expired_time']
seconds = cal_seconds_to(expired_time)
uuid = line['uuid']
user_id = line['user_id']
instance_data = line['instance_data']
_oid = line['_id']
# 定时器已经到期，立即删除运行的实例
if seconds < 0:
try:
nova_api.delete_vm(uuid)
except:
pass
running_t.delete(uuid=uuid)
# 更新backup_t中的deleted_time
deleted_time = time.time()
backup_t.update(dict(uuid=uuid), deleted_time=deleted_time)
else:
# 恢复running_dict和定时器
item = dict(user_id=user_id, instance_data=instance_data)
item['uuid'] = uuid
# 2013/03/01
# 增加_oid到元素，RunningPutter可以根据此_oid删除waitting_t中的元素
# 其实从mongodb中取得的记录已包含_id
# 此处为了加强重点，重复加入
item['_oid'] = _oid
insert_vm_in_mem(item)
timer = Timer(uuid=uuid, seconds=seconds, item=item)
timer.start()
timer_list.append(timer)
for line in waitters:
if line.has_key("instance_data"):
LOG.info("insert data to waitting queue: %s" % line)
user_id = line['user_id']
item = dict(_oid=line['_id'], user_id=user_id,
instance_data=instance_data)
waitting_queue.put(item)
LOG.info("Rebuild end")
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 __init__(self, uuid=None, item=None, seconds=None):
super(Timer, self).__init__()
self.uuid = uuid
self.seconds = float(seconds)
LOG.info("Timer remain: %s" % self.seconds)
LOG.info("Start timer at: %s" % from_now_to_datetime())
def install_lobby_room():
if not key_exists(lobby_room_key):
c_pipe.hset(lobby_room_key, "room_id", lobby_room_id)
c_pipe.hset(lobby_room_key, "room_magic_id", lobby_room_magic_id)
c_pipe.hset(lobby_room_key, "room_name", lobby_room_name)
c_pipe.hset(lobby_room_key, "room_max_user", lobby_room_max_user)
c_pipe.hset(lobby_room_key, "room_cache_size", lobby_room_msg_cache_size)
c_pipe.set(room_count_key, 2)
c_pipe.execute()
return True
return False
if not install_default_room():
LOG.info("This is just a WARNNING!\n" \
"Install default room failed!\n" \
"Maybe room was existed.\n")
if not install_lobby_room():
LOG.info("This is just a WARNNING!\n" \
"Install lobby room failed!\n" \
"Maybe room was existed.\n")
class UserManager(object):
def __init__(self):
pass
@staticmethod
def user_add(room_id, user, handler):
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_request(user_id, instance_data):
'''
处理用户的请求
如果运行队列未满，则创建虚拟机实例、启动定时器、在running_t中插入记录
否则将请求投入排队的队列中，并在waitting_t中插入记录
'''
item = dict(user_id=user_id, instance_data=instance_data)
os = instance_data['os']
# 如果运行队列未满
if len(running_list) < options.running_dict_size:
# 创建实例
uuid = nova_api.create_vm(item)
item['uuid'] = uuid
# 为实例增加端口映射
balancer = addNginxHost(uuid, os)
balancer.start()
# 实例加入到running_dict中
insert_vm_in_mem(item)
# 实例的到期时间
expired_time = from_now_to_datetime(seconds=seconds)
# 启动定时器
timer = Timer(uuid=uuid,
item=item,
seconds=cal_seconds_to(expired_time))
timer.start()
timer_list.append(timer)
# 在running_t中插入一条记录
obj_id = running_t.insert(uuid=uuid,
user_id=user_id,
expired_time=expired_time,
instance_data=instance_data)
# 请求被立即处理
# 日志表里插入created_time和processed_time
# 并增加running_id，用于删除实例时更新deleted_time
# user_id用于查询用
processed_time = time.time()
backup_t.insert(user_id=user_id,
created_time=processed_time,
processed_time=processed_time,
instance_data=instance_data,
running_id=obj_id,
uuid=uuid)
LOG.info("Start timer for {0}: {1}".format(user_id, instance_data))
# 返回0
return 0
else:
# 创建时间
created_time = from_now_to_datetime()
item.setdefault("created_time", created_time)
# 在waitting_t中加入请求
obj_id = waitting_t.insert(**item)
# 请求被排队
# 日志表里插入created_time，并增加waitting_id
# waitting_id是在waitting_t中获得的id
# 用于在RunningPutter线程中更新processed_time
# NOTICE: 目前使用uuid作为删除实例时更新deleted_time的条件
# user_id用于查询
created_time = time.time()
backup_t.insert(user_id=user_id,
created_time=created_time,
waitting_id=obj_id,
instance_data=instance_data)
# 将请求加入到等待队列
# 2013/02/20: 将db的_objectid也压入队列
# 在waitting_t中删除元素的时候，就根据_objectid删除
# 而不是user_id
item['_oid'] = obj_id
waitting_queue.put(item)
LOG.info("put data to waitting queue {0}: {1}".format(
user_id, instance_data))
result = waitting_t.query(_id=obj_id)
# 返回排队的序号
for line in result:
return line['auto_id']
def process_receive(self, data, node_id):
try:
data = eval(data)
except Exception, e:
LOG.exception(e)
raise
def __init__(self, uuid=None, item=None, seconds=None):
super(Timer, self).__init__()
self.uuid = uuid
self.seconds = float(seconds)
LOG.info("Timer remain: %s" % self.seconds)
LOG.info("Start timer at: %s" % from_now_to_datetime())
def process_receive(self, data, node_id):
try:
data = eval(data)
except Exception, e:
LOG.exception(e)
raise
def process_request(user_id, instance_data):
'''
处理用户的请求
如果运行队列未满，则创建虚拟机实例、启动定时器、在running_t中插入记录
否则将请求投入排队的队列中，并在waitting_t中插入记录
'''
item = dict(user_id=user_id, instance_data=instance_data)
os = instance_data['os']
# 如果运行队列未满
if len(running_list) < options.running_dict_size:
# 创建实例
uuid = nova_api.create_vm(item)
item['uuid'] = uuid
# 为实例增加端口映射
balancer = addNginxHost(uuid, os)
balancer.start()
# 实例加入到running_dict中
insert_vm_in_mem(item)
# 实例的到期时间
expired_time = from_now_to_datetime(seconds=seconds)
# 启动定时器
timer = Timer(uuid=uuid, item=item,
seconds=cal_seconds_to(expired_time))
timer.start()
timer_list.append(timer)
# 在running_t中插入一条记录
obj_id = running_t.insert(uuid=uuid, user_id=user_id,
expired_time=expired_time, instance_data=instance_data)
# 请求被立即处理
# 日志表里插入created_time和processed_time
# 并增加running_id，用于删除实例时更新deleted_time
# user_id用于查询用
processed_time = time.time()
backup_t.insert(user_id=user_id, created_time=processed_time, processed_time=processed_time,
instance_data=instance_data, running_id=obj_id, uuid=uuid)
LOG.info("Start timer for {0}: {1}".format(user_id, instance_data))
# 返回0
return 0
else:
# 创建时间
created_time = from_now_to_datetime()
item.setdefault("created_time", created_time)
# 在waitting_t中加入请求
obj_id = waitting_t.insert(**item)
# 请求被排队
# 日志表里插入created_time，并增加waitting_id
# waitting_id是在waitting_t中获得的id
# 用于在RunningPutter线程中更新processed_time
# NOTICE: 目前使用uuid作为删除实例时更新deleted_time的条件
# user_id用于查询
created_time = time.time()
backup_t.insert(user_id=user_id, created_time=created_time, waitting_id=obj_id,
instance_data=instance_data)
# 将请求加入到等待队列
# 2013/02/20: 将db的_objectid也压入队列
# 在waitting_t中删除元素的时候，就根据_objectid删除
# 而不是user_id
item['_oid'] = obj_id
waitting_queue.put(item)
LOG.info("put data to waitting queue {0}: {1}".format(user_id, instance_data))
result = waitting_t.query(_id=obj_id)
# 返回排队的序号
for line in result:
return line['auto_id']
