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 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 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 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 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 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 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 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 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 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']