def delLrnode(self): # 删除LR记录 sql_6 = """delete from lr_node where lr_id='%s'""" % self.lr_id db.execFetch(sql_6) level_id_res = redis_client.keys("lr:*:%s" % self.lr_id) if len(level_id_res) == 0: level_id = None self.logger.warn("Not found level_id by lr_id [%s]" % self.lr_id) else: level_id = level_id_res[0].split(":")[1] if level_id: # sql_check = """select lr_id from lr_node where level_id='%s'""" % level_id # result = db.execFetch(sql_check) result = redis_client.keys("lr:%s:*" % level_id) # print "*"*20 level_cluster, _ = write_level(level_id) redis_client.hset("level:%s" % level_id, "level_cluster", level_cluster) if len(result) <= 1: sql_delete = """delete from `level_node` where `level_id`='%s'""" % level_id db.execOnly(sql_delete) redis_client.delete("level:%s" % level_id) reset_ancestors() self.logger.info("Del lr_node with lrid=%s success." % level_id) return {"code": 200, "status": "success"}
def lrDel(self): del_list = redis_client.keys("qos:*:%s" % self.src_level) del_list += redis_client.keys("qos:%s:*" % self.src_level) for k in del_list: redis_client.delete(k) sqld = """delete from net_qos where `level_src`='%s' or `level_dst`='%s'""" % ( self.src_level, self.src_level) self.logger.info("delete record with level_id -> %s" % self.src_level) return db.execOnly(sqld)
def randomLr(self, name="level"): """ 返回当前lrcluster内sysload最低的lr """ # if name == "level": # sqls = """select `lr_id` from `lr_node` where `level_id`='%s' order by `sysload` limit 1""" % self.lrcid # res = db.execFetch(sqls) # if len(res) == 0: return None # lrid = res[0][0] # # for redis if name == "level": lr_list = redis_client.keys("lrid:%s:*" % self.lrcid) if not lr_list: return None best_lr = lr_list[0] for lr in lr_list: sysload = redis_client.hget(lr, "sysload") active = redis_client.hget(lr, "active") if sysload < redis_client.hget(best_lr, "sysload") and active == '1': best_lr = lr lrid = best_lr.split(":")[2] else: lr_list = [] sqls = """ select `lr_id`,`lrc_ids`, `sysload` from `lr_node` where `lrc_id`!='[]'""" # order by `sysload` limit 1""" % self.lrcid res = db.execFetch(sqls) if len(res) == 0: return None for lr in res: lrc_ids = eval(lr[1]) if self.lrcid in lrc_ids: lr_list.append({"lrid": lr[0], "sysload": lr[2]}) lr_list.sort(key=lambda x: (x["sysload"])) lrid = lr_list[0]["lrid"] return lrid
def choose_result(level_id): level_cluster = redis_client.hget("level:%s" % level_id, "level_cluster") level_cluster_list = level_cluster.split(":") lr_list = redis_client.keys("lr:%s:*" % level_id) if len(level_cluster_list) == 1: lr = best_lr(level_id, lr_list) if lr: res = {"status": True, "type": "lrc", "data": lr} else: res = {"status": False, "type": "lrc", "data": None} return res else: lrc_dict = {} lr_res = [] for cluster_type in level_cluster_list: lrc_dict[cluster_type] = [] for lr in lr_list: lr_cluster = redis_client.hget(lr, "cluster") lrc_dict[lr_cluster].append(lr) for k in lrc_dict.keys(): lr = best_lr(level_id, lrc_dict[k]) if not lr: res = {"status": False, "type": "lrg", "data": None} return res lr_res.append(lr) res = {"status": True, "type": "lrg", "data": lr_res} return res
def getDlrRoot(level_id): p_level_list = getAncestor(level_id, []) p_level_list.insert(0, level_id) p_level_list.reverse() print p_level_list while True: now_level = p_level_list[-1] lr_level = redis_client.keys("lrid:%s:*" % now_level)[0] lr_type = redis_client.hget(lr_level, "lr_type") if lr_type == "lr": return lr_level.split(":")[1] else: plevel = getPlevel(lr_level.split(":")[1]) p_level_lr = redis_client.keys("lrid:%s:*" % plevel)[0] p_lr_type = redis_client.hget(p_level_lr, "lr_type") if p_lr_type == "lr": return lr_level.split(":")[1] p_level_list.pop()
def getValidlevel(self): qos_list = redis_client.keys("qos:%s:*" % self.src_level) level_list = [] for qos in qos_list: weight = redis_client.hget(qos, "weight") if float(weight) != 0.0: level_list.append(qos.split(":")[2]) # sqls = """select `level_dst` from `net_qos` where `level_src`='%s' and weight!=0"""%self.src_level # res = db.execFetch(sqls) # level_list = [] # for level in res: # level_list.append(level[0]) return level_list
def post(self): logger = logging.getLogger("nc") req = self.request reqbody = json.loads(self.request.body) # reqbody = eval(self.request.body) logger.info(' -- %s -- "%s %s %s" - "%s" -- MSM request data: %s --' % (req.remote_ip, req.method, req.version, req.uri, req.headers["User-Agent"], reqbody)) caller = reqbody["callerId"] addcallee = reqbody["addCallee"] curmeeting = reqbody["curMeeting"] star = False existing_lr = dict() for lr in curmeeting: if lr["star"]: star = lr lrid = lr["lrid"] lr_list = redis_client.keys("lr:*:%s" % lrid) if lr_list: lr_level = lr_list[0].split(":")[1] existing_lr["lr:%s:%s" % (lr_level, lrid)] = lr add_num = len(addcallee) if add_num < 1: logging.warning("Missing parameters, the calleeList was empty.") self.write({"code": 400, "mark": "undecided", "data": data}) else: my_meet = meeting(caller, curmeeting, logger) for user in addcallee: my_meet.addcallee(user) response_data = my_meet.get_data() epids_set = set() for i in response_data: epids = frozenset(i["epids"]) epids_set.add(epids) if len(epids_set) == len(response_data): response = { "code": 200, "mark": "fixed", "data": response_data } else: response = { "code": 200, "mark": "undecided", "data": response_data } logger.info("Response: %s" % response) self.write(response)
def level_cluster_lr(level_id, cluster): lr_list = redis_client.keys("lr:%s:*" % level_id) lr = '' sysload = 10000 # uncertain for lr_obj in lr_list: lr_cluster, lr_active, lr_sysload = redis_client.hmget( lr_obj, "cluster", "active", "sysload") if lr_cluster == cluster: if lr_active == '1': if int(lr_sysload) <= sysload: lr = lr_obj.split(":")[2] sysload = int(lr_sysload) else: continue if lr: return lr # lr => lr92385aebbf2d97cf320180504100221 else: return None
def getLrnode(self, all=False): if all: sqls = """select `lr_id`,`name`,`ip`,`port`,`plevel_id`,`operator`,`cloud`,`price`, `lr_type`,`sysload`, `level_id`, `lrc_ids` from `lr_node`""" res = db.execFetch(sqls) all_lr_list = [] for record in res: all_lr_list.append({ "lrid": record[0], "name": record[1], "ip": record[2], "port": record[3], "plevel_id": record[4], "operator": record[5], "cloud": record[6], "price": record[7], "lr_type": record[8], "sysload": record[9], "level_id": record[10], "lrc_id": record[11] }) data = all_lr_list else: lr_list = redis_client.keys("lrid:*:%s" % self.lr_id) if not lr_list: return None lr = lr_list.pop() lr_ip, lr_port, lr_type = redis_client.hmget( lr, "ip", "port", "lr_type") data = { "lrid": self.lr_id, "ip": lr_ip, "port": lr_port, "lr_type": lr_type, "level_id": lr.split(":")[1] } # sqls = """select `lr_id`,`name`,`ip`,`port`,`operator`,`cloud`,`price`,`lr_type`, `plevel_id`, `sysload`, `level_id`, `lrc_ids` from lr_node where lr_id='%s'""" % self.lr_id # res = db.execFetch(sqls) # if len(res) != 0: data = {"lrid": res[0][0], "name": res[0][1], "ip": res[0][2], "port": res[0][3], "operator": res[0][4], "cloud": res[0][5], "price": res[0][6], "lr_type": res[0][7], "plevel_id": res[0][8], "sysload": res[0][9], "level_id": res[0][10], "lrc_id": res[0][11]} # else: data = nc_config.DEFAULT_LR return data
def getLrnode(self, all=False): if all: sqls = """select `lr_id`,`name`,`ip`,`port`,`plevel_id`,`cluster`,`cloud`,`price`, `lr_type`,`sysload`, `level_id`, `last_subtime`, `active` from `lr_node`""" res = db.execFetch(sqls) all_lr_list = [] for record in res: all_lr_list.append({ "lrid": record[0], "name": record[1], "ip": record[2], "port": record[3], "plevel_id": record[4], "cluster": record[5], "cloud": record[6], "price": record[7], "lr_type": record[8], "sysload": record[9], "level_id": record[10], "last_subtime": record[11], "active": record[12] }) data = all_lr_list else: lr_list = redis_client.keys("lr:*:%s" % self.lr_id) if not lr_list: return None lr = lr_list.pop() lr_ip, lr_port, lr_type, cluster, last_subtime, active = redis_client.hmget( lr, "ip", "port", "lr_type", "cluster", "last_subtime", "active") data = { "lrid": self.lr_id, "ip": lr_ip, "port": lr_port, "lr_type": lr_type, "level_id": lr.split(":")[1], "cluster": cluster, "last_subtime": last_subtime, "active": active } return data
def _set_attr(self): for lr in self.curmeeting: lrid = lr["lrid"] lr_level_list = redis_client.keys("lr:*:%s" % lrid) if lr_level_list: lr_level = lr_level_list[0].split(":")[1] if lr["star"]: self.star = lr else: if lr_level not in self.existing_level: self.existing_level[lr_level] = [lrid] else: self.existing_level[lr_level].append(lrid) self.existing_lr.append({lrid: lr}) caller_level = redis_client.get("user:%s" % self.caller) caller_level_type, caller_level_cluster = redis_client.hmget( "level:%s" % caller_level, {"level_type", "level_cluster"}) if caller_level_type == "lr" and (len(caller_level_cluster.split(":")) > 1): if caller_level in self.existing_level: self.is_lrg = True self.logger.info("Meeting type: LRG.")
def addLrnode(self, sql_data, level_id, plevel_id): sqli = """insert into lr_node (`lr_id`, `name`, `plevel_id`, `ip`, `port`, `cluster`, `cloud`, `price`, `lr_type`, `sysload`, `level_id`, `last_subtime`, `active`) values ( "%s", "%s", "%s", "%s", "%s", "%s", "%s", "%s", "%s", %s, "%s", %s, '1')""" % sql_data try: res = db.execOnly(sqli) except: res = 0 if res > 0: level_cluster, level_type = write_level(level_id) redis_client.hmset( "level:%s" % level_id, { "plevel_id": plevel_id, "level_cluster": level_cluster, "level_type": level_type }) # 生成 ancestors/level 的redis记录 l_list = redis_client.keys("level:%s" % level_id) if not l_list: redis_client.rpush("ancestors:%s" % level_id, level_id) for l in getAncestor(level_id, []): redis_client.rpush("ancestors:%s" % level_id, l) self.logger.info("Add lr_node with lrid=%s done." % self.lr_id) return { "code": 200, "status": "success", "msg": "Add lr_node with lrid=%s done." % self.lr_id } else: self.logger.error( "Add lr_node with lrid=%s failed, insert statement failed to execute." % self.lr_id) return { "code": 400, "status": "exist", "msg": "Add lr_node with lrid=%s failed." % self.lr_id }
def post(self): logger = logging.getLogger("nc") req = self.request reqbody = json.loads(self.request.body) # reqbody = eval(self.request.body) caller = reqbody["callerId"] logger.info(' -- %s -- "%s %s %s" - "%s" -- MSM request data: %s --' % (req.remote_ip, req.method, req.version, req.uri, req.headers["User-Agent"], reqbody)) user_list = redis_client.keys("user:%s" % caller) if not user_list: logger.error("The caller was not found, use default LR.") self.write({ "code": 404, "mark": "fixed", "data": [nc_config.DEFAULT_LR] }) # 判断该账号是否设置了强制使用的LR caller_account = caller.split("_")[2] force_res = detectForce(caller_account) if force_res["statu"]: lrid = force_res["lrid"] lr_obj = redis_client.keys("lr:*:%s" % lrid) ip, port, lr_type = redis_client.hmget(lr_obj[0], "ip", "port", "lr_type") lr_res = { "lrid": lrid, "ip": ip, "port": port, "lr_type": lr_type, "epids": [], "star": False } logger.info("The account [%s] has a specified LR [%s]" % (caller_account, force_res["lrid"])) self.write({ "code": 200, "mark": "fixed", "data": [lr_res] }) # mark: fixed/undecided # return # 含calleeList,通讯录会议 if reqbody.has_key("calleeList"): personlist = reqbody["calleeList"] personlist.append(caller) logger.info("Contacts style meeting starting, members -> [%s]" % personlist) near_level_list = [] all_person_level = {} for ep in personlist: adjacency_level = redis_client.get("user:%s" % ep) if not adjacency_level: logger.warning( "No matching level target found, please check the user_id [%s] exists." % ep) continue if adjacency_level not in near_level_list: near_level_list.append(adjacency_level) all_person_level[adjacency_level] = [ep] else: all_person_level[adjacency_level].append(ep) if len(near_level_list) < 1: nc_config.DEFAULT_LR["epids"] = personlist logger.error( "Contacts style meeting, did not find an adjacency, use default LR." ) self.write({ "code": 404, "mark": "fixed", "data": [nc_config.DEFAULT_LR] }) # return 404 elif len(near_level_list) == 1: level_id = near_level_list[0] parents_list = redis_client.lrange("ancestors:%s" % level_id, 0, -1) result = loop_choose(parents_list, logger) # result: "" || {"status": True, "type": "lrg"|"lrc", "data": lr_res|None} lr_res: [ lr:39:lr78920180518155843, lr:39:lr78945afe87b30 ] if result: data = set_data(caller, result) if len(data) == 1: response = {"code": 200, "mark": "fixed", "data": data} else: # level_type = redis_client.hget("level:%s"%level_id, "level_type") # if level_type == "lr": # star = nc_config.DEFAULT_STAR_LR # else: # star = set_star(caller, logger) star = set_star(caller, logger) for x in data: x["epids"] = personlist data.append(star) response = { "code": 200, "mark": "undecided", "data": data } logger.info( "Contacts style meeting, personlist has the same adjacency. Response: %s" % data) self.write(response) # return 200 else: nc_config.DEFAULT_LR["epids"] = personlist nc_config.DEFAULT_LR["star"] = False logger.error( "Contacts style meeting, personlist has the same adjacency, but didn't choose a valid LR. Use default LR." ) self.write({ "code": 404, "mark": "fixed", "data": [nc_config.DEFAULT_LR] }) # return 404 else: response_data = elect_func(caller, near_level_list, all_person_level, logger) epids_set = set() for i in response_data: epids = frozenset(i["epids"]) epids_set.add(epids) if len(epids_set) == len(response_data): response = { "code": 200, "mark": "fixed", "data": response_data } else: response = { "code": 200, "mark": "undecided", "data": response_data } logger.info("Contacts style meeting, effective return: %s" % response) self.write(response) # return 200 else: caller_level = redis_client.get("user:%s" % caller) caller_dlr_parents_list, caller_lr_parents_list = split_level( caller_level) if caller_dlr_parents_list: caller_lr_parents_list.insert(0, caller_dlr_parents_list[-1]) # print "$"*10, caller_meeting_level res = loop_choose(caller_lr_parents_list, logger) if not res: nc_config.DEFAULT_LR["epids"] = personlist nc_config.DEFAULT_LR["star"] = False logger.error( "Caller meeting, didn't choose a valid LR. Use default LR." ) self.write({ "code": 404, "mark": "fixed", "data": [nc_config.DEFAULT_LR] }) else: data = set_data(caller, res) for d in data: d["epids"] = [caller] if len(data) > 1: mark = "undecided" else: mark = "fixed" logger.info("Caller meeting, response: %s" % data) self.write({"code": 200, "mark": mark, "data": data})
def post(self): logger = logging.getLogger("nc") req = self.request reqbody = eval(self.request.body) caller = reqbody["callerId"] logger.info("%s %s %s %s -MSM request data: %s-" % (req.remote_ip, req.method, req.uri, req.headers["User-Agent"], reqbody)) caller_account = caller.split("_")[2] force_res = detectForce(caller_account) if force_res["statu"]: lr_node = lrNode(force_res["lrid"]) lr_res = lr_node.getLrnode() logger.info("The account [%s] has a specified LR [%s]" % (caller_account, force_res["lrid"])) self.write({"code": 200, "status": "success", "data": [lr_res]}) return ''' 判断多点会议 ''' if reqbody.has_key("mt_type"): if reqbody["mt_type"] == "multi": logger.info("Multipoint meeting start..") caller_vsp = getAdjacency(caller, item="vsp_id") caller_vsp_obj = vspObj(caller_vsp) caller_lrg = caller_vsp_obj.getGrid() logger.info("Found user vsp id: %s, lr grid id: %s" % (caller_vsp, caller_lrg)) if not caller_lrg: res = { "code": 200, "status": "success", "data": nc_config.DEFAULT_LR } logger.warn( "Multipoint meeting. Not found caller's adjacency LR, or this VSP has no LRG, return default lr" ) self.write(res) return else: lr_list = [] caller_lrg_obj = lrGrid(caller_lrg) caller_lrc_list = caller_lrg_obj.getCluster() logger.info("Found lr cluster ids: %s:" % caller_lrc_list) for member in caller_lrc_list: lr_cluster = lrCluster(member) lr_list.append(lr_cluster.randomLr(name="cluster")) response_list = [] for lr_id in lr_list: lr_node = lrNode(lr_id) response_list.append(lr_node.getLrnode()) logger.info("Found lr_list in lrc_list: %s" % response_list) self.write({ "code": 200, "status": "success", "data": response_list }) return ''' 判断公开课 ''' if reqbody.has_key("scope"): public_mt_type = reqbody["scope"] if public_mt_type == "inner": level_id = getAdjacency(caller) if not level_id: res = { "code": 404, "status": "warning", "data": nc_config.DEFAULT_LR } logger.info( "Stranger meeting. Not found caller's adjacency LR, return default lr" ) self.write(res) return lr_level = redis_client.keys("lrid:%s:*" % level_id)[0] lr_type = redis_client.hget(lr_level, "lr_type") if lr_type == "lr": level_res = lr_level.split(":")[1] else: level_res = getDlrRoot(lr_level.split(":")[1]) lr_cluster = lrCluster(level_res) lr_id = lr_cluster.randomLr() lr_node = lrNode(lr_id) lr_res = lr_node.getLrnode() logger.info( "Stranger meeting, type [%s], caller [%s], dlr [%s]" % (public_mt_type, caller, lr_res)) self.write({ "code": 200, "status": "success", "data": [lr_res] }) return else: level_list = getRootlevel() if not level_list: res = { "code": 404, "status": "warning", "data": nc_config.DEFAULT_LR } logger.info( "Stranger meeting. Not found root level, return default lr" ) self.write(res) return lr_cluster = lrCluster(level_list[0]) lr_id = lr_cluster.randomLr() lr_node = lrNode(lr_id) lr_res = lr_node.getLrnode() logger.info( "Stranger meeting, type [%s], caller [%s], SO lr [%s]" % (public_mt_type, caller, lr_res)) self.write({ "code": 200, "status": "success", "data": [lr_res] }) return # else: # level_id = getAdjacency(caller) # level_list = redis_client.keys("qos:%s:*"%level_id) # best_level = level_list[0] # for level in level_list: # layer_count = redis_client.hget(level, "layer_distance") # if layer_count > redis_client.hget(best_level, "layer_distance"): best_level = level # lr_cluster = lrCluster(best_level.split(":")[2]) # lr_id = lr_cluster.randomLr() # lr_node = lrNode(lr_id) # lr_res = lr_node.getLrnode() # logger.info("Stranger meeting, type [%s], caller [%s], lr [%s]"%(public_mt_type, caller, lr_res)) # self.write({"code": 200, "status": "success", "data": [lr_res]}) # return # 非公开会议 personlist = reqbody["calleeList"] personlist.append(caller) logger.info("Standard meeting starting, members -> [%s]" % personlist) near_level_set = set() for user in personlist: res_level = getAdjacency(user) if not res_level: logger.info( "No matching level target found, please check if the user_id [%s] exists." % user) break if res_level not in near_level_set: near_level_set.add(res_level) if len(near_level_set) < 1: res = { "code": 404, "msg": "Find the near_level_set failure for the personlist [%s], use default LR." % personlist, "data": nc_config.DEFAULT_LR } self.write(res) elif len(near_level_set) == 1: res_lrc = lrCluster(near_level_set.pop()) meeting_lr = res_lrc.randomLr() if meeting_lr: lr_node = lrNode(meeting_lr) lr_res = lr_node.getLrnode() logger.info("The meeting has the same LR=>[%s]" % lr_res) self.write({ "code": 200, "status": "success", "data": [lr_res] }) else: logger.info( "The members of the meeting are at the same level, but the LR fails at this level." ) self.write({ "code": 404, "status": "success", "data": nc_config.DEFAULT_LR }) else: # for level_id in near_level_set: # netqos = netQos(level_id) # valid_level_list = netqos.getValidlevel() # valid_level_list.append(level_id) # all_valid_level.append(valid_level_list) # logger.info("near_lr: %s, find the level_list: %s"%(level_id, valid_level_list)) # result = set(all_valid_level[0]) # for i in range(len(all_valid_level)): # result = result & set(all_valid_level[i]) # level_list = list(result) all_valid_level = [] near_level_list = list(near_level_set) for i in range(len(near_level_list)): netqos = netQos(near_level_list[i]) valid_level_list = netqos.getValidlevel() # valid_level_list.append(near_level_set[i]) if i == 0: all_valid_level = valid_level_list all_valid_level = [ val for val in all_valid_level if val in valid_level_list ] if len(all_valid_level) == 0: data = nc_config.DEFAULT_LR logger.warning( "Failure to calculate the result, return default lr") res = { "code": 404, "status": "Find the level_list error, use default lr", "data": data } self.write(res) return # sqls_2 = """select `path` from `net_qos` where `level_src`='%s' and `level_dst`='%s'""" result_list = [] for x in all_valid_level: flag = False sum = 0 for y in near_level_list: if y != x: # value = db.execFetch(sqls_2%(y, x))[0][0] value = float( redis_client.hget("qos:%s:%s" % (y, x), "path")) if value == 0: flag = True else: value = 0 sum = sum + value if flag: continue result_list.append({"level": x, "path": sum}) if not result_list: res = { "code": 404, "msg": "Check the result_list failure for the personlist [%s], use default LR." % personlist, "data": nc_config.DEFAULT_LR } self.write(res) return result_list.sort(key=lambda x: (x["path"])) lr_cluster = lrCluster(result_list[0]["level"]) lr_id = lr_cluster.randomLr() lr_node = lrNode(lr_id) res = lr_node.getLrnode() logger.info("Selected list %s, final choice %s" % (result_list, res)) self.write({"code": 200, "status": "success", "data": [res]})