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]})
