def components_run(request):
"""
运行组件
"""
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
context = {}
POST = request.POST
if POST.get("run", ""):
componentType = int(POST.get("componentType", "0"))
targetMachine = POST.get("targetMachine", "").strip()
runNumber = int(POST.get("runNumber", "0"))
kbe_root = request.session["kbe_root"]
kbe_res_path = request.session["kbe_res_path"]
kbe_bin_path = request.session["kbe_bin_path"]
if componentType not in Define.VALID_COMPONENT_TYPE_FOR_RUN or \
not machinesmgr.hasMachine( targetMachine ) or \
runNumber <= 0:
context = {"error": "invalid data!"}
else:
for e in range(runNumber):
cid = machinesmgr.makeCID(componentType)
gus = machinesmgr.makeGUS(componentType)
print("cid: %s, gus: %s" % (cid, gus))
components.startServer(componentType, cid, gus, targetMachine,
kbe_root, kbe_res_path, kbe_bin_path)
time.sleep(2)
return HttpResponseRedirect("/wc/components/manage")
context["machines"] = machinesmgr.machines
return render(request, "WebConsole/components_run.html", context)
def show_components(request):
"""
控制台可连接的组件显示页面
"""
VALID_CT = set([
Define.DBMGR_TYPE,
Define.LOGINAPP_TYPE,
Define.CELLAPP_TYPE,
Define.BASEAPP_TYPE,
Define.INTERFACES_TYPE,
Define.LOGGER_TYPE,
])
html_template = "WebConsole/console_show_components.html"
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.queryAllInterfaces(timeout=0.5)
# [(machine, [components, ...]), ...]
kbeComps = []
for mID, comps in components.interfaces_groups.items():
for comp in comps:
if comp.componentType in VALID_CT:
kbeComps.append(comp)
context = {
"KBEComps": kbeComps,
}
return render(request, html_template, context)
def components_run(request):
"""
运行组件
"""
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.queryAllInterfaces(timeout=0.5)
context = {}
POST = request.POST
if POST.get("run", ""):
componentType = int(POST.get("componentType", "0"))
targetMachine = POST.get("targetMachine", "").strip()
runNumber = int(POST.get("runNumber", "0"))
if componentType not in Define.VALID_COMPONENT_TYPE_FOR_RUN or \
not components.hasMachine( targetMachine ) or \
runNumber <= 0:
context = {"error": "invalid data!"}
else:
for e in range(runNumber):
cid = components.makeCID(componentType)
gus = components.makeGUS(componentType)
components.startServer(componentType, cid, gus, targetMachine)
time.sleep(2)
return HttpResponseRedirect("/wc/components/manage")
context["machines"] = components.machines
return render(request, "WebConsole/components_run.html", context)
def components_save_layout(request):
"""
保存当前服务器运行状态
"""
layoutName = request.GET.get("name")
if not layoutName:
result = {"state": "fault", "message": "invalid layout name!!!"}
return HttpResponse(json.dumps(result),
content_type="application/json")
VALIDATE_CT = set([
Define.DBMGR_TYPE,
Define.LOGINAPP_TYPE,
Define.BASEAPPMGR_TYPE,
Define.CELLAPPMGR_TYPE,
Define.CELLAPP_TYPE,
Define.BASEAPP_TYPE,
Define.INTERFACES_TYPE,
Define.LOGGER_TYPE,
])
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.queryAllInterfaces(timeout=0.5)
conf = {}
for machineID, infos in components.interfaces_groups.items():
for info in infos:
if info.componentType not in VALIDATE_CT:
continue
compnentName = Define.COMPONENT_NAME[info.componentType]
if compnentName not in conf:
conf[compnentName] = []
d = {
"ip": info.intaddr,
"cid": info.componentID,
"gus": 0
} # 当前取不到gus参数，所以只是先写0
conf[compnentName].append(d)
if len(conf) == 0:
result = {"state": "fault", "message": "当前没有服务器在运行!!!"}
return HttpResponse(json.dumps(result),
content_type="application/json")
try:
m = ServerLayout.objects.get(name=layoutName)
except ObjectDoesNotExist:
m = ServerLayout()
m.name = layoutName
m.sys_user = request.session["sys_user"]
m.config = json.dumps(conf)
m.save()
result = {"state": "success", "message": ""}
return HttpResponse(json.dumps(result), content_type="application/json")
def components_stop( request ):
"""
停止一个组件
"""
components = Machines.Machines( request.session["sys_uid"], request.session["sys_user"] )
components.queryAllInterfaces(timeout = 0.5)
context = {}
POST = request.POST
def components_load_layout(request):
"""
加载某个保存的服务器运行配置，并启动服务器
"""
VALIDATE_CT = set([
Define.DBMGR_TYPE,
Define.LOGINAPP_TYPE,
Define.BASEAPPMGR_TYPE,
Define.CELLAPPMGR_TYPE,
Define.CELLAPP_TYPE,
Define.BASEAPP_TYPE,
Define.INTERFACES_TYPE,
Define.LOGGER_TYPE,
])
try:
id = int(request.GET["id"])
except:
id = 0
if not id:
return render(request, "WebConsole/components_load_layout.html",
{"error": "无效的参数"})
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.queryAllInterfaces(timeout=0.5)
for mID, comps in components.interfaces_groups.items():
if len(comps) > 1:
return render(request, "WebConsole/components_load_layout.html",
{"error": "服务器正在运行，不允许加载"})
# 计数器
t2c = [
0,
] * len(Define.COMPONENT_NAME)
ly = ServerLayout.objects.get(pk=id)
layoutData = json.loads(ly.config)
for ct in VALIDATE_CT:
compnentName = Define.COMPONENT_NAME[ct]
for comp in layoutData.get(compnentName, []):
cid = comp["cid"]
if cid <= 0:
cid = components.makeCID(ct)
gus = comp["gus"]
if gus <= 0:
gus = components.makeGUS(ct)
t2c[ct] += 1
components.startServer(ct, cid, gus, comp["ip"], 0)
context = {"run_counter": str(t2c)}
return render(request, "WebConsole/components_load_layout.html", context)
def components_group_shutdown(request, ct):
"""
停止一组服务器组件
"""
ct = int(ct)
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.stopServer(ct, trycount=0)
context = {"shutType": "group_ct", "ct": ct}
return render(request, "WebConsole/components_shutdown.html", context)
def components_kill(request, ct, cid):
"""
杀死一个组件进程
"""
ct = int(ct)
cid = int(cid)
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.killServer(ct, componentID=cid, trycount=0)
context = {"shutType": "kill_cid", "ct": ct, "cid": cid}
return render(request, "WebConsole/components_kill.html", context)
def components_stop(request, ct, cid):
"""
停止一个组件
"""
ct = int(ct)
cid = int(cid)
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.stopServer(ct, componentID=cid, trycount=0)
context = {"shutType": "stop_cid", "ct": ct, "cid": cid}
return render(request, "WebConsole/components_shutdown.html", context)
def components_query_machines(request):
"""
请求获取所有的machines
"""
components = Machines.Machines(0, "WebConsole")
components.queryMachines()
# [ machine, ...]
kbeComps = []
for machine in components.machines:
d = {
"ip": machine.intaddr,
"uid": machine.uid,
"pid": machine.pid,
}
kbeComps.append(d)
return HttpResponse(json.dumps(kbeComps), content_type="application/json")
def machines_show_all(request):
"""
忽略用户，显示所有的machine
"""
components = Machines.Machines(0, "WebConsole")
components.queryAllInterfaces(timeout=0.5)
targetIP = request.GET.get("target", None)
kbeComps = []
for mID, comps in components.interfaces_groups.items():
if len(comps) > 1 and comps[0].intaddr == targetIP:
kbeComps = comps[1:]
break
context = {
"KBEMachines": components.machines,
"KBEComps": kbeComps,
}
return render(request, "WebConsole/machines_show_all.html", context)
def components_manage( request ):
"""
组件管理主页面
"""
html_template = "WebConsole/components_manage.html"
components = Machines.Machines( request.session["sys_uid"], request.session["sys_user"] )
components.queryAllInterfaces(timeout = 0.5)
# [(machine, [components, ...]), ...]
kbeComps = []
for mID, comps in components.interfaces_groups.items():
if len( comps ) > 1:
kbeComps.extend( comps[1:] )
context = {
"KBEComps" : kbeComps,
"hasComponents" : len( kbeComps ) > 0,
"hasMachines" : len( components.interfaces_groups ) > 0,
}
return render( request, html_template, context )
def __init__(self):
"""
"""
print("MachinesMgr::__init__(), USE_MACHINES_BUFFER = %s" %
settings.USE_MACHINES_BUFFER)
if self.instance is not None:
assert False
self.instance = weakref.proxy(self)
self.machineInst = Machines.Machines(0, "WebConsole")
self.interfaces_groups = {} # { machineID : [ComponentInfo, ...], ...}
self.machines = []
# 是否已经初始化过缓冲区
# 用于当 settings.USE_MACHINES_BUFFER == True 时
self.inited = False
# 最后一次查询的时间
# 在settings.USE_MACHINES_BUFFER == False时，用于避免外部代码在同一时间多次query all interfaces；
# 在settings.USE_MACHINES_BUFFER == True时，用于子线程判断停止query all interfaces的时机。
self.lastQueryTime = 0.0
def components_shutdown( request ):
"""
停止服务器
"""
COMPS_FOR_SHUTDOWN = [
Define.BOTS_TYPE,
Define.LOGINAPP_TYPE,
Define.CELLAPP_TYPE,
Define.BASEAPP_TYPE,
Define.CELLAPPMGR_TYPE,
Define.BASEAPPMGR_TYPE,
Define.DBMGR_TYPE,
Define.INTERFACES_TYPE,
Define.LOGGER_TYPE,
]
components = Machines.Machines( request.session["sys_uid"], request.session["sys_user"] )
for ctid in COMPS_FOR_SHUTDOWN:
components.stopServer( ctid, trycount = 0 )
return render( request, "WebConsole/components_shutdown.html", {} )
def components_group_query(request, ct):
"""
请求获取一组组件数据
"""
ct = int(ct)
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.queryAllInterfaces(timeout=0.5)
# [ [machine, other-components, ...], ...]
kbeComps = []
for mID, comps in components.interfaces_groups.items():
if len(comps) <= 1:
continue
dl = []
kbeComps.append(dl)
for comp in comps:
if comp.componentType == ct or comp.componentType == 8:
d = {
"ip": comp.intaddr,
"componentType": comp.componentType,
"componentName": comp.componentName,
"fullname": comp.fullname,
"uid": comp.uid,
"pid": comp.pid,
"componentID": comp.componentID,
"globalOrderID": comp.globalOrderID,
"cpu": comp.cpu,
"mem": comp.mem,
"usedmem": comp.usedmem,
"entities": comp.entities,
"proxies": comp.proxies,
"clients": comp.clients,
"consolePort": comp.consolePort,
}
dl.append(d)
return HttpResponse(json.dumps(kbeComps), content_type="application/json")
def components_load_layout(request):
"""
加载某个保存的服务器运行配置，并启动服务器
"""
VALID_CT = set([
Define.DBMGR_TYPE,
Define.LOGINAPP_TYPE,
Define.BASEAPPMGR_TYPE,
Define.CELLAPPMGR_TYPE,
Define.CELLAPP_TYPE,
Define.BASEAPP_TYPE,
Define.INTERFACES_TYPE,
Define.LOGGER_TYPE,
])
kbe_root = request.session["kbe_root"]
kbe_res_path = request.session["kbe_res_path"]
kbe_bin_path = request.session["kbe_bin_path"]
try:
id = int(request.GET["id"])
except:
id = 0
if not id:
return render(request, "WebConsole/components_load_layout.html",
{"error": "无效的参数"})
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
interfaces_groups = machinesmgr.queryAllInterfaces(
request.session["sys_uid"], request.session["sys_user"])
for mID, comps in interfaces_groups.items():
if len(comps) > 1:
return render(request, "WebConsole/components_load_layout.html",
{"error": "服务器正在运行，不允许加载"})
# 计数器
t2c = [
0,
] * len(Define.COMPONENT_NAME)
components_ct = [
0,
] * len(Define.COMPONENT_NAME)
components_cid = [
0,
] * len(Define.COMPONENT_NAME)
components_gus = [
0,
] * len(Define.COMPONENT_NAME)
ly = ServerLayout.objects.get(pk=id)
layoutData = json.loads(ly.config)
for ct in VALID_CT:
compnentName = Define.COMPONENT_NAME[ct]
components_ct[ct] = ct
for comp in layoutData.get(compnentName, []):
print("components_load_layout(), component data: %s" % comp)
cid = comp["cid"]
if cid <= 0:
cid = machinesmgr.makeCID(ct)
components_cid[ct] = cid
gus = comp["gus"]
if gus <= 0:
gus = machinesmgr.makeGUS(ct)
components_gus[ct] = gus
t2c[ct] += 1
components.startServer(ct, cid, gus, comp["ip"], kbe_root,
kbe_res_path, kbe_bin_path, 0)
context = {
"run_counter": str(t2c),
"components_ct": json.dumps(components_ct),
"components_cid": json.dumps(components_cid),
"components_gus": json.dumps(components_gus),
"components_ip": comp["ip"]
}
return render(request, "WebConsole/components_load_layout.html", context)
def pull_log(request):
VALID_CT = set([
Define.LOGGER_TYPE,
])
components = Machines.Machines(request.session["sys_uid"],
request.session["sys_user"])
components.queryAllInterfaces(timeout=0.5)
# [(machine, [components, ...]), ...]
kbeComps = []
for mID, comps in components.interfaces_groups.items():
for comp in comps:
if comp.componentType in VALID_CT:
kbeComps.append(comp)
POST = request.POST
try:
intaddr = kbeComps[0].intaddr
intport = kbeComps[0].intport
extaddr = kbeComps[0].extaddr
extport = kbeComps[0].extport
# host = kbeComps[0].extaddr
# port = kbeComps[0].consolePort
uid = request.session["sys_uid"]
except:
message = {"unlogger": "logger进程未运行"}
return HttpResponse(json.dumps(message))
# return render(request, html_template, context)
#获取进程选中状态
components_checks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
components_checks2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
baseapp_check = POST.get("baseapp_check")
baseappmgr_check = POST.get("baseappmgr_check")
cellapp_check = POST.get("cellapp_check")
dbmgr_check = POST.get("dbmgr_check")
loginapp_check = POST.get("loginapp_check")
pull_state = POST.get("pull_state")
if pull_state == 0:
pull_state = 1
if baseapp_check: components_checks[6] = Define.BASEAPP_TYPE
if baseappmgr_check: components_checks[3] = Define.BASEAPPMGR_TYPE
if cellapp_check: components_checks[5] = Define.CELLAPP_TYPE
if dbmgr_check: components_checks[1] = Define.DBMGR_TYPE
if loginapp_check: components_checks[2] = Define.LOGINAPP_TYPE
if components_checks[6] == 0 \
and components_checks[3] == 0 \
and components_checks[5] == 0 \
and components_checks[1] == 0 \
and components_checks[2] == 0 :
components_checks[6] = Define.BASEAPP_TYPE
components_checks[3] = Define.BASEAPPMGR_TYPE
components_checks[5] = Define.CELLAPP_TYPE
components_checks[1] = Define.DBMGR_TYPE
components_checks[2] = Define.LOGINAPP_TYPE
baseapp_check = 1
baseappmgr_check = 1
cellapp_check = 1
dbmgr_check = 1
loginapp_check = 1
# if len(components_checks)<=1:components_checks[].append(Define.COMPONENT_END_TYPE)
#获取log类型
CRITICAL_check = 0
DEBUG_check = 0
ERROR_check = 0
INFO_check = 0
PRINT_check = 0
S_DBG_check = 0
S_ERR_check = 0
S_INFO_check = 0
S_NORM_check = 0
S_WARN_check = 0
WARNING_check = 0
logtype = 0x00000000
CRITICAL = POST.get("CRITICAL")
DEBUG = POST.get("DEBUG")
ERROR = POST.get("ERROR")
INFO = POST.get("INFO")
PRINT = POST.get("PRINT")
S_DBG = POST.get("S_DBG")
S_ERR = POST.get("S_ERR")
S_INFO = POST.get("S_INFO")
S_NORM = POST.get("S_NORM")
S_WARN = POST.get("S_WARN")
WARNING = POST.get("WARNING")
if CRITICAL:
logtype |= logName2type["CRITICAL"]
CRITICAL_check = 1
if DEBUG:
logtype |= logName2type["DEBUG"]
DEBUG_check = 1
if ERROR:
logtype |= logName2type["ERROR"]
ERROR_check = 1
if INFO:
logtype |= logName2type["INFO"]
INFO_check = 1
if PRINT:
logtype |= logName2type["PRINT"]
PRINT_check = 1
if S_DBG:
logtype |= logName2type["S_DBG"]
S_DBG_check = 1
if S_ERR:
logtype |= logName2type["S_ERR"]
S_ERR_check = 1
if S_INFO:
logtype |= logName2type["S_INFO"]
S_INFO_check = 1
if S_NORM:
logtype |= logName2type["S_NORM"]
S_NORM_check = 1
if S_WARN:
logtype |= logName2type["S_WARN"]
S_WARN_check = 1
if WARNING:
logtype |= logName2type["S_WARN"]
WARNING_check = 1
if logtype == 0x00000000:
logtype = 0xffffffff
CRITICAL_check = 1
DEBUG_check = 1
ERROR_check = 1
INFO_check = 1
PRINT_check = 1
S_DBG_check = 1
S_ERR_check = 1
S_INFO_check = 1
S_NORM_check = 1
S_WARN_check = 1
WARNING_check = 1
#自定义搜索
globalOrder = POST.get("globalOrder")
groupOrder = POST.get("groupOrder")
searchDate = POST.get("searchDate")
keystr = POST.get("keystr")
if globalOrder == None: globalOrder = ""
if groupOrder == None: groupOrder = ""
if searchDate == None: searchDate = ""
if keystr == None: keystr = ""
message = {
"ws_url": ws_url,
"baseapp_check": components_checks[6],
"baseappmgr_check": components_checks[3],
"cellapp_check": components_checks[5],
"dbmgr_check": components_checks[1],
"loginapp_check": components_checks[2],
"CRITICAL_check": CRITICAL_check,
"DEBUG_check": DEBUG_check,
"ERROR_check": ERROR_check,
"INFO_check": INFO_check,
"PRINT_check": PRINT_check,
"S_DBG_check": S_DBG_check,
"S_ERR_check": S_ERR_check,
"S_INFO_check": S_ERR_check,
"S_NORM_check": S_NORM_check,
"S_WARN_check": S_WARN_check,
"WARNING_check": WARNING_check,
"globalOrder": globalOrder,
"groupOrder": groupOrder,
"searchDate": searchDate,
"keystr": keystr,
"components_checks": components_checks,
}
return HttpResponse(json.dumps(message), content_type='application/json')