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 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 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 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 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 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 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 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 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 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 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 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):
cls = UserManager
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_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_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 __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):
