def redis_init(client):
sqls_user = """select `ep_id`, `level_id`, `vsp_id` from adjacency"""
res_user = db.execFetch(sqls_user)
for ep, ep_level, ep_vsp in res_user:
client.hmset("user:%s" % ep, {"level_id": ep_level, "vsp_id": ep_vsp})
sqls_sys = """select `lr_id`, `level_id`, `sysload`, `ip`, `port`, `lr_type` from lr_node"""
res_sys = db.execFetch(sqls_sys)
for lr, level, sysload, ip, port, lr_type in res_sys:
# client.set("lrid:%s:%s"%(level,lr), sysload)
client.hmset("lrid:%s:%s" % (level, lr), {
"sysload": sysload,
"ip": ip,
"port": port,
"lr_type": lr_type
})
sqls_qos = """select `level_src`,`level_dst`,`weight`,`layer_distance`,`path` from net_qos"""
res_qos = db.execFetch(sqls_qos)
for src, dst, weight, layer_distance, path in res_qos:
client.hmset("qos:%s:%s" % (src, dst), {
"weight": weight,
"layer_distance": layer_distance,
"path": path
})
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 setMembership(level_id, plevel_id):
sqls = """select count(*) from `level_node` where `level_id`='%s'""" % level_id
sqli = """insert into level_node (`level_id`, `plevel_id`) values ('%s', '%s')""" % (
level_id, plevel_id)
count = db.execFetch(sqls)[0][0]
# print level_id, plevel_id, type(count)
if count == 0:
db.execFetch(sqli)
return True
else:
return False
def delLrnode(self):
# sql_1 = """select `lr_id`,`plr_id` from `lr_node` where `plr_id` REGEXP '%s'"""%self.lr_id
# sql_3 = """select `plr_id` from `lr_node` where `lr_id`='%s'"""%self.lr_id
# # 更新以本身为父层的LR记录
# res = db.execFetch(sql_1)
# if len(res) > 0:
# for node in res:
# lrid = node[0]
# plrid = eval(node[1])
# plrid.remove(self.lr_id)
# if len(plrid) == 0:
# ret = db.execFetch(sql_3)[0][0]
# new_plr = ret
# else: new_plr = str(plrid)
# self.logger.info("update lr_node -> lrid : %s, parent_lr: %s"%(lrid, new_plr))
# sql_2 = """update `lr_node` set `plr_id`="%s" where `lr_id`='%s'"""%(new_plr, lrid)
# db.execOnly(sql_2)
# # 更新以本身为LR的用户记录
# sql_4 = """select `ep_id`,`lr_id` from `adjacency` where lr_id REGEXP '%s'"""%self.lr_id
# res = db.execFetch(sql_4)
# if len(res) > 0:
# for user in res:
# userid = user[0]
# userlr = eval(user[1])
# userlr.remove(self.lr_id)
# if len(userlr) == 0:
# new_userlr = db.execFetch(sql_3)[0][0]
# else: new_userlr = str(userlr)
# self.logger.info("update user table -> ep_id: %s, lr_id: %s"%(userid, new_userlr))
# sql_5 = """update `adjacency` set `lr_id`="%s" where `ep_id`='%s'"""%(new_userlr, userid)
# db.execOnly(sql_5)
# 删除LR记录
sql_6 = """delete from lr_node where lr_id='%s'""" % self.lr_id
sql_s = """select `level_id` from lr_node where `lr_id`='%s'""" % self.lr_id
level_id_res = db.execFetch(sql_s)
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][0]
# res = db.execFetch(sql_6)
# if res > 0:
if level_id:
sql_check = """select lr_id from lr_node where level_id='%s'""" % level_id
result = db.execFetch(sql_check)
if len(result) <= 1:
sql_delete = """delete from `level_node` where `level_id`='%s'""" % level_id
db.execOnly(sql_delete)
netqos = netQos(level_id)
netqos.lrDel()
db.execFetch(sql_6)
self.logger.info("Del lr_node with lrid=%s success." % level_id)
return {"code": 200, "status": "success"}
def redis_save(client):
logger = logging.getLogger("nc")
lr_sysload_list = client.keys("lrid:*")
sqlu_sys = """update lr_node set `sysload` = CASE `lr_id` """
sqlu_time = """update lr_node set `last_subtime` = CASE `lr_id` """
sqlu_active = """update lr_node set `active` = CASE `lr_id` """
for lr in lr_sysload_list:
sysload, last_subtime, active = client.hmget(lr, "sysload",
"last_subtime", "active")
sqlu_sys += "WHEN '%s' THEN '%s' " % (lr.split(":")[2], sysload)
sqlu_time += "WHEN '%s' THEN '%s'" % (lr.split(":")[2], last_subtime)
sqlu_active += "WHEN '%s' THEN '%s'" % (lr.split(":")[2], active)
sqlu_sys += "END"
sqlu_time += "END"
sqlu_active += "END"
db.execFetch(sqlu_sys)
db.execFetch(sqlu_time)
db.execFetch(sqlu_active)
qos_list = client.keys("qos:*")
sqlu_qos = """update net_qos set `path` = CASE """
for qos in qos_list:
qos_src = qos.split(":")[1]
qos_dst = qos.split(":")[2]
path = float(client.hget(qos, "path"))
sqlu_qos += """WHEN `level_src`='%s' AND `level_dst`='%s' THEN %f """ % (
qos_src, qos_dst, path)
sqlu_qos += "END"
db.execFetch(sqlu_qos)
# print sqlu_qos
logger.info("Successfully save the redis data to mysql.")
def getPlevel(level):
sql = """select plevel_id from level_node where level_id='%s'""" % level
res = db.execFetch(sql)
if res:
return res[0][0]
else:
return None
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 getAlllevel():
sqls = """select `level_id` from `level_node`"""
level_list = []
res = db.execFetch(sqls)
for level in res:
level_list.append(level[0])
return level_list
def getRootlevel():
''' 获取根LR列表 '''
sqls = """select distinct level_id from level_node where plevel_id='0'"""
res = db.execFetch(sqls)
reslist = []
for level in res:
reslist.append(level[0])
return reslist
def getCluster(self):
sqls = """select `lrc_id`, `lrg_ids` from lr_cluster """
lrc_list = []
res = db.execFetch(sqls)
for lrc in res:
lrg_ids = eval(lrc[1])
if self.lrgid in lrg_ids: lrc_list.append(lrc[0])
return lrc_list
def check_lrg(lrgid, lrgname, vspid):
sqls = """select * from `lr_grid` where `lrg_id`='%s'""" % lrgid
res = db.execFetch(sqls)
if len(res) == 0:
sqli = """insert into `lr_grid` (`lrg_id`, `lrg_name`, `vsp_id`) values ('%s', '%s', '%s')""" % (
lrgid, lrgname, vspid)
db.execOnly(sqli)
return True
return False
def getDescendant(level_id, reslist=[]):
''' 递归获取指定LR的子层LR '''
sqls = """select distinct level_id from lr_node where plevel_id='%s'""" % level_id
res = db.execFetch(sqls)
if len(res) == 0: return reslist
for i in range(len(res)):
lr = res[i][0]
if lr not in reslist: reslist.append(lr)
if i == len(res) - 1: return getDescendant(lr, reslist)
else: reslist = getDescendant(lr, reslist)
def detectForce(account):
""" 检测帐号是否有指定LR """
sqls = """select `lr_id` from `force_route` where `account`='%s'""" % account
# sql_id = """select `lr_id` from `lr_node` where `ip`='%s' and port='%s'"""
rows = db.execFetch(sqls)
if len(rows) > 0:
lrid = rows[0][0]
return {"statu": True, "lrid": lrid}
else:
return {"statu": False}
def getAlllr(self):
sqls = """ select `lr_id` from `lr_node` where `level_id`='%s'""" % self.lrcid
res = db.execFetch(sqls)
if len(res) == 0:
return None
lr_list = []
count = len(res)
for lr in res:
lr_list.append(lr[0])
return {"count": count, "lr_list": lr_list}
def getDstlist(self):
sqls = """select lr_id from lr_node"""
lr_dst_list = []
res = db.execFetch(sqls)
if len(res) == 0:
self.logger.error("lr_node table empty.")
sys.exit(0)
for record in res:
lr_dst_list.append(record[0])
lr_dst_list.remove(self.lr_id)
return lr_dst_list
def addLrnode(self, sql_data):
sqli = """insert into lr_node (`lr_id`, `name`, `plevel_id`, `ip`, `port`, `operator`, `cloud`, `price`, `lr_type`, `sysload`, `lrc_ids`, `level_id`, `last_subtime`) values ( "%s", "%s", "%s", "%s", "%s", "%s", "%s", "%s", "%s", %s, "%s", "%s", %s)""" % sql_data
try:
res = db.execOnly(sqli)
except:
res = 0
plevel_id = sql_data[2]
level_id = sql_data[-2]
if res > 0:
sql_select = """select `level_id` from `level_node`"""
level_list = [x[0] for x in db.execFetch(sql_select)]
if level_id not in level_list:
sql_1 = """insert into level_node (`level_id`, `plevel_id`) values ('%s', '%s')""" % (
level_id, plevel_id)
db.execOnly(sql_1)
netqos = netQos(level_id)
ret = netqos.lrAddall()
if ret > 0:
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 fail, on update table netqos."
% self.lr_id)
return {
"code":
400,
"status":
"failed",
"msg":
"Add lr_node with lrid=%s fail, on update table netqos."
% self.lr_id
}
else:
self.logger.info("Add lr_node success, level_id exists.")
return {
"code": 200,
"status": "success",
"msg": "Add lr_node success, level_id exists."
}
else:
self.logger.error("Add lr_node with lrid=%s failed." % self.lr_id)
return {
"code": 400,
"status": "exist",
"msg": "Add lr_node with lrid=%s failed." % self.lr_id
}
def getAncestor(level_id, reslist=[]):
''' 递归获取指定LR的父层LR '''
sqls = """select `plevel_id`,`lr_type` from lr_node where `level_id`='%s' """ % level_id
while True:
sql_result = db.execFetch(sqls)
# print sql_result
if len(
sql_result
) == 0: # or sql_result[0][1] == 'lr': # or sql_result[0][0] == '0':
if reslist: return reslist[:-1]
else: return reslist
else:
reslist.append(sql_result[0][0])
return getAncestor(sql_result[0][0], reslist)
def redis_init(client):
# 初始化用户信息，string 格式：userid:xxxxxx "level_id"
sqls_user = """select `ep_id`, `level_id` from adjacency"""
res_user = db.execFetch(sqls_user)
for user in res_user:
user_id, user_level = user
client.set("user:%s"%user_id, user_level)
# 初始化lr信息，hash 格式：lrid:level_id:xxxxxx {"lr_type": "dlr", "ip": "10.x.x.x", "port": "900x", "sysload": 0, "last_subtime": "1509840xxx", "active": 1}
sqls_lr = """select `lr_id`, `level_id`, `lr_type`, `ip`, `port`, `cluster`, `sysload`, `last_subtime`, `active` from lr_node"""
res_lr = db.execFetch(sqls_lr)
for lr in res_lr:
lr_id, level_id, lr_type, ip, port, cluster, sysload, last_subtime, active = lr
client.hmset("lr:%s:%s"%(level_id, lr_id), {"sysload": sysload, "ip": ip, "port": port, "cluster": cluster, "lr_type": lr_type, "last_subtime": last_subtime, "active": active})
# 初始化level信息，hash 格式：level:xxxxxx {"plevel_id": "xxx", "level_cluster": "xxx", "level_type": "xxx"}
sqls_level = """select `level_id`,`level_cluster`,`plevel_id`,`level_type` from level_node"""
res_level = db.execFetch(sqls_level)
for level in res_level:
level_id, level_cluster, plevel_id, level_type = level
client.hmset("level:%s"%level_id, {"level_cluster": level_cluster, "plevel_id": plevel_id, "level_type": level_type})
# 初始化每个level的递归父层，list 格式：ancestors:xxx ['xxx', 'xxxxx', 'xxxxx']
reset_ancestors()
def delCluster(self):
sqld = """delete from `lr_cluster` where `lrc_id`='%s'""" % self.lrcid
ret = db.execOnly(sqld)
if ret:
self.logger.info("Delete lr_cluster [%s] success." % self.lrcid)
else:
self.logger.error("Delete lr_cluster[%s] failed." % self.lrcid)
sqls = """ select `lr_id`,`lrc_ids` from `lr_node` where `lrc_ids`!='[]'"""
res = db.execFetch(sqls)
sqlu = """update `lr_node` set `lrc_ids`="%s" where `lr_id`='%s'"""
for lr in res:
lrc_ids = eval(lr[1])
if self.lrcid in lrc_ids:
lrc_ids.remove(self.lrcid)
db.execOnly(sqlu % (str(lrc_ids), lr[0]))
return True
def delGrid(self):
sqld = """delete from lr_grid where `lrg_id`='%s'""" % self.lrgid
ret = db.execOnly(sqld)
if ret:
self.logger.info("Delete lr_grid [%s] success." % self.lrgid)
else:
self.logger.error("Delete lr_grid [%s] failed." % self.lrgid)
sqls = """select `lrc_id`,`lrg_ids` from lr_cluster"""
res = db.execFetch(sqls)
sqlu = """update `lr_cluster` set `lrg_ids`='%s' where `lrg_ids`='%s'"""
for lrc in res:
lrgs = eval(lrc[1])
if self.lrgid in lrgs:
lrgs.remove(self.lrgid)
db.execOnly(sqlu % (str(lrgs), lrc[0]))
return True
def modLrnode(self, sql_data, level_id, plevel_id, old_level, lrid):
sqlu = """update lr_node set `name`="%s", `plevel_id`="%s", `ip`="%s", `port`="%s", `operator`="%s", `cloud`="%s", `price`="%s", `lr_type`="%s", `sysload`=%s, `lrc_ids`="%s", `level_id`='%s', `last_subtime`=%s where `lr_id`='%s' """ % sql_data
sqlu_1 = """update level_node set `plevel_id`='%s' where `level_id`='%s'""" % (
plevel_id, level_id)
sql_select = """select `level_id` from `level_node`"""
level_list = [x[0] for x in db.execFetch(sql_select)]
# sql_parent = """select `plevel_id` from level_node where `level_id`='%s'"""%old_level
# old_parent_level = db.execFetch(sql_parent)[0][0]
if level_id not in level_list:
sql_1 = """insert into level_node (`level_id`, `plevel_id`) values ('%s', '%s')""" % (
level_id, plevel_id)
if old_level:
sql_check = """select lr_id from lr_node where level_id='%s'""" % old_level
result = db.execFetch(sql_check)
if len(result) <= 1:
sql_s_old = """select `plevel_id` from level_node where `level_id`='%s'""" % old_level
sql_u_old = """update level_node set `plevel_id`='%s' where `plevel_id`='%s'"""
need_r = db.execFetch(sql_s_old)
if need_r:
db.execFetch(sql_u_old % (need_r[0][0], old_level))
sql_delete = """delete from `level_node` where `level_id`='%s'""" % old_level
db.execOnly(sql_delete)
netqos = netQos(old_level)
netqos.lrDel()
db.execOnly(sql_1)
netqos = netQos(level_id)
ret = netqos.lrAddall()
if ret > 0:
self.logger.info("Add new level and qos for lrid=%s done." %
self.lr_id)
# return {"code": 200, "status": "success", "msg": "Add new level and qos for lrid=%s done."%self.lr_id}
else:
self.logger.error(
"Add new level for lrid=%s fail, on update table netqos." %
self.lr_id)
# return {"code": 400, "status": "failed", "msg": "Add new level for lrid=%s fail, on update table netqos."%self.lr_id}
else:
if level_id != old_level:
sql_check = """select lr_id from lr_node where level_id='%s'""" % old_level
result = db.execFetch(sql_check)
if len(result) <= 1:
sql_delete = """delete from `level_node` where `level_id`='%s'""" % old_level
db.execOnly(sql_delete)
netqos = netQos(old_level)
netqos.lrDel()
# print sqlu
try:
db.execOnly(sqlu_1)
res = db.execOnly(sqlu)
except Exception, e:
# print "**************",e
res = 0
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 redis_save(client):
# logger = logging.getLogger("nc")
lr_sysload_list = client.keys("lr:*")
sqlu_sys = """update lr_node set `sysload` = CASE `lr_id` """
sqlu_time = """update lr_node set `last_subtime` = CASE `lr_id` """
sqlu_active = """update lr_node set `active` = CASE `lr_id` """
for lr in lr_sysload_list:
sysload, last_subtime, active = client.hmget(lr, "sysload", "last_subtime", "active")
sqlu_sys += "WHEN '%s' THEN '%s' "% (lr.split(":")[2], sysload)
sqlu_time += "WHEN '%s' THEN '%s'"%(lr.split(":")[2], last_subtime)
sqlu_active += "WHEN '%s' THEN '%s'"%(lr.split(":")[2], active)
sqlu_sys += "END"
sqlu_time += "END"
sqlu_active += "END"
db.execFetch(sqlu_sys)
db.execFetch(sqlu_time)
db.execFetch(sqlu_active)
def modLrnode(self, sql_data, level_id, plevel_id, old_level, lrid):
sqlu = """update lr_node set `name`="%s", `plevel_id`="%s", `ip`="%s", `port`="%s", `cluster`="%s", `cloud`="%s", `price`="%s", `lr_type`="%s", `sysload`=%s, `level_id`='%s', `last_subtime`=%s where `lr_id`='%s' """ % sql_data
sqlu_1 = """update level_node set `plevel_id`='%s' where `level_id`='%s'""" % (
plevel_id, level_id)
sql_select = """select `level_id` from `level_node`"""
level_list = [x[0] for x in db.execFetch(sql_select)]
# sql_parent = """select `plevel_id` from level_node where `level_id`='%s'"""%old_level
# old_parent_level = db.execFetch(sql_parent)[0][0]
if level_id not in level_list:
if old_level:
sql_check = """select lr_id from lr_node where level_id='%s'""" % old_level
result = db.execFetch(sql_check)
if len(result) <= 1:
sql_s_old = """select `level_id`, `plevel_id` from level_node where `level_id`='%s'""" % old_level
sql_u_old = """update level_node set `plevel_id`='%s' where `plevel_id`='%s'"""
need_r = db.execFetch(sql_s_old)
if need_r:
db.execFetch(sql_u_old % (need_r[0][1], old_level))
for l in need_r:
redis_client.hset("level:%s" % l[0], "plevel_id",
l[1])
sql_delete = """delete from `level_node` where `level_id`='%s'""" % old_level
db.execOnly(sql_delete)
redis_client.delete("level:%s" % old_level)
db.execOnly(sqlu)
res = write_level(level_id)
redis_client.hmset(
"level:%s" % level_id, {
"plevel_id": plevel_id,
"level_cluster": res[0],
"level_type": res[1]
})
reset_ancestors()
self.logger.info("Add new level and qos for lrid=%s done." %
self.lr_id)
# return {"code": 200, "status": "success", "msg": "Add new level and qos for lrid=%s done."%self.lr_id}
else:
if level_id != old_level:
sql_check = """select lr_id from lr_node where level_id='%s'""" % old_level
result = db.execFetch(sql_check)
if len(result) <= 1:
sql_delete = """delete from `level_node` where `level_id`='%s'""" % old_level
db.execOnly(sql_delete)
redis_client.delete("level:%s" % old_level)
reset_ancestors()
# print sqlu
try:
db.execOnly(sqlu_1)
result = db.execOnly(sqlu)
write_level(old_level)
res = write_level(level_id)
redis_client.hmset(
"level:%s" % level_id, {
"plevel_id": plevel_id,
"level_cluster": res[0],
"level_type": res[1]
})
redis_client.delete("ancestors:%s" % level_id)
redis_client.rpush("ancestors:%s" % level_id, level_id)
for l in getAncestor(level_id, []):
redis_client.rpush("ancestors:%s" % level_id, l)
except Exception, e:
# print "**************",e
result = 0
def getGrid(self):
sqls = """select `lrg_id` from `lr_grid` where `vsp_id`='%s'""" % self.vspid
res = db.execFetch(sqls)
if len(res) == 0: lrg = None
else: lrg = res[0][0]
return lrg
for user_lr in api_data:
if user_lr["user_id"] == '' or user_lr[
"node_level"] == '' or user_lr["vsp_id"] == '':
continue
ep_user = "******" % (user_lr["user_id"], user_lr["account"])
query_data.append(
(user_lr["account"], ep_user, str(user_lr["node_level"]),
user_lr["vsp_id"]))
# redis_client.hmset("user:%s"%ep_user, {"level_id": str(user_lr["node_level"]), "vsp_id": user_lr["vsp_id"]})
sqli = """insert into `adjacency` (`account`, `ep_id`, `level_id`, `vsp_id`) values (%s, %s, %s, %s)"""
else:
lr_all_list = []
for lr_info in api_data:
lr_all_list.append(lr_info["id"])
query_data.append(
(lr_info["id"], lr_info["name"], lr_info["p_node_level"],
lr_info["ip"], lr_info["port"], lr_info["op_name"],
lr_info["net_type"], lr_info["price"], lr_info["lr_type"],
lr_info["level_id"], cur_time)) # -------------------
sqli = """insert into `lr_node` (`lr_id`, `name`, `plevel_id`, `ip`, `port`, `cluster`, `cloud`, `price`, `lr_type`, `level_id`, `last_subtime`, `sysload`, `active`) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 0, '1')"""
logger.info("%s query_data: %s" % (db_table, query_data))
db.execOnly(sqli, query_data)
logger.info("Fill table %s success." % db_table)
# 自lr_node表中提取所有的level（去重），并初始化生成level_node表
sqls_level = """select distinct `level_id` from lr_node"""
level_res = db.execFetch(sqls_level)
for level_temp in level_res:
level = level_temp[0]
result = write_level(level)
if not result: logger.error("Error inserting level/%s" % level)
def write_level(level_id):
sqls = """select * from level_node where `level_id`='%s'""" % level_id
res = db.execFetch(sqls)
sqls_c = """select distinct `cluster` from lr_node where `level_id`='%s'""" % level_id
level_c_list = db.execFetch(sqls_c)
level_c_by_lr = ''
for c in level_c_list:
level_c_by_lr += c[0]
level_c_by_lr += ":"
level_c_by_lr = level_c_by_lr.strip(":")
sqls_t = """select distinct `lr_type` from lr_node where `level_id`='%s'""" % level_id
level_type_by_lr = db.execFetch(sqls_t)[0][0]
if len(res) == 0:
sqls_p = """select distinct `plevel_id` from lr_node where `level_id`='%s'""" % level_id
plevel_id = db.execFetch(sqls_p)[0][0]
sqli = """insert into level_node (`level_id`, `level_cluster`, `level_type`, `plevel_id`) values ('%s', '%s', '%s', '%s')""" % (
level_id, level_c_by_lr, level_type_by_lr, plevel_id)
db.execFetch(sqli)
return (level_c_by_lr, level_type_by_lr)
else:
sqls_c_f_level = """select `level_cluster` from level_node where `level_id`='%s'""" % level_id
level_c_by_levelnode = db.execFetch(sqls_c_f_level)[0][0]
if level_c_by_lr != level_c_by_levelnode:
sqlu = """update level_node set `level_cluster`='%s' where `level_id`='%s'""" % (
level_c_by_lr, level_id)
db.execFetch(sqlu)
sqls_t_f_level = """select `level_type` from level_node where `level_id`='%s'""" % level_id
level_t_by_levelnode = db.execFetch(sqls_t_f_level)[0][0]
if level_type_by_lr != level_t_by_levelnode:
sqlu = """update level_node set `level_type`='%s' where `level_id`='%s'""" % (
level_type_by_lr, level_id)
db.execFetch(sqlu)
return (level_c_by_lr, level_type_by_lr)
def getProperty(self, attr):
sqls = """select %s from lr_node where lr_id='%s'""" % (attr,
self.lr_id)
res = db.execFetch(sqls)
return res[0][0]
def getLrProperty(lrid, attr):
sqls = """select %s from `lr_node` where `lr_id`='%s'""" % (attr, lrid)
res = db.execFetch(sqls)
return res[0][0]
