package com.wgcloud.service;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.json.JSONUtil;
|
import com.github.pagehelper.PageInfo;
|
import com.wgcloud.config.CommonConfig;
|
import com.wgcloud.config.MailConfig;
|
import com.wgcloud.dto.ChartInfo;
|
import com.wgcloud.dto.MessageDto;
|
import com.wgcloud.entity.*;
|
import com.wgcloud.util.DateUtil;
|
import com.wgcloud.util.FormatUtil;
|
import com.wgcloud.util.HostUtil;
|
import com.wgcloud.util.staticvar.StaticKeys;
|
import org.apache.commons.lang3.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.ui.Model;
|
|
import javax.annotation.Resource;
|
import javax.servlet.http.HttpServletRequest;
|
import java.util.*;
|
|
/**
|
* @version v3.3
|
* @ClassName:DashboardService.java
|
* @author: http://www.wgstart.com
|
* @date: 2021年1月16日
|
* @Description: 监控概要页面信息管理
|
* @Copyright: 2019-2021 wgcloud. All rights reserved.
|
*/
|
@Service
|
public class DashboardService {
|
|
private static final Logger logger = LoggerFactory.getLogger(DashboardService.class);
|
|
@Resource
|
DbTableService dbTableService;
|
@Resource
|
SnmpInfoService snmpInfoService;
|
@Resource
|
FileSafeService fileSafeService;
|
@Resource
|
DceInfoService dceInfoService;
|
@Resource
|
DbInfoService dbInfoService;
|
@Resource
|
SystemInfoService systemInfoService;
|
@Resource
|
AppInfoService appInfoService;
|
@Resource
|
FileWarnInfoService fileWarnInfoService;
|
@Resource
|
FileWarnStateService fileWarnStateService;
|
@Resource
|
DockerInfoService dockerInfoService;
|
@Resource
|
LogInfoService logInfoService;
|
@Autowired
|
HeathMonitorService heathMonitorService;
|
@Autowired
|
HostGroupService hostInfoService;
|
@Autowired
|
CpuStateService cpuStateService;
|
@Autowired
|
MemStateService memStateService;
|
@Autowired
|
SysLoadStateService sysLoadStateService;
|
@Autowired
|
NetIoStateService netIoStateService;
|
@Autowired
|
DeskIoService deskIoService;
|
@Autowired
|
DiskStateService diskStateService;
|
@Autowired
|
DiskSmartService diskSmartService;
|
@Resource
|
CpuTemperaturesService cpuTemperaturesService;
|
@Resource
|
private CustomInfoService customInfoService;
|
@Resource
|
private PortInfoService portInfoService;
|
@Autowired
|
CommonConfig commonConfig;
|
@Autowired
|
MailConfig mailConfig;
|
|
|
/**
|
* 获取从今天开始，往前倒数天数的日期集合
|
*
|
* @param days
|
* @return
|
*/
|
public List<String> getDateList() {
|
int days = 30;
|
List<String> dateList = new ArrayList<String>();
|
String sevenDayBefore = DateUtil.getDateBefore(days);
|
for (int i = 0; i < days; i++) {
|
sevenDayBefore = DateUtil.getDateBefore(i);
|
dateList.add(sevenDayBefore.substring(0, 10));
|
}
|
return dateList;
|
}
|
|
/**
|
* 获取四个时间段
|
*
|
* @param days
|
* @return
|
*/
|
public List<MessageDto> getAmList() {
|
MessageDto dto1 = new MessageDto();
|
dto1.setCode("am1");
|
dto1.setMsg("最近1小时");
|
MessageDto dto2 = new MessageDto();
|
dto2.setCode("am2");
|
dto2.setMsg("最近2小时");
|
MessageDto dto3 = new MessageDto();
|
dto3.setCode("am3");
|
dto3.setMsg("最近6小时");
|
MessageDto dto4 = new MessageDto();
|
dto4.setCode("am4");
|
dto4.setMsg("最近12小时");
|
MessageDto dto5 = new MessageDto();
|
dto5.setCode("am5");
|
dto5.setMsg("最近24小时");
|
List<MessageDto> timeList = new ArrayList<MessageDto>();
|
timeList.add(dto1);
|
timeList.add(dto2);
|
timeList.add(dto3);
|
timeList.add(dto4);
|
timeList.add(dto5);
|
return timeList;
|
}
|
|
|
/**
|
* 查看图表时候，组装日期查询条件
|
*
|
* @param am 最近1小时，2小时，6小时，12小时，24小时
|
* @param startTime 开始时间
|
* @param endTime 结束时间
|
* @param params 查询map
|
* @param model 回显页面存贮
|
*/
|
public void setDateParam(String am, String startTime, String endTime, Map<String, Object> params, Model model) {
|
if ("null".equals(am)) {
|
am = "";
|
}
|
try {
|
String nowTime = DateUtil.getCurrentDateTime();
|
if (!StringUtils.isEmpty(am) && (StringUtils.isEmpty(startTime) || StringUtils.isEmpty(endTime))) {
|
if ("am1".equals(am)) {
|
params.put(StaticKeys.SEARCH_START_TIME, DateUtil.beforeHourToNowDate(1));
|
params.put(StaticKeys.SEARCH_END_TIME, nowTime);
|
}
|
if ("am2".equals(am)) {
|
params.put(StaticKeys.SEARCH_START_TIME, DateUtil.beforeHourToNowDate(2));
|
params.put(StaticKeys.SEARCH_END_TIME, nowTime);
|
}
|
if ("am3".equals(am)) {
|
params.put(StaticKeys.SEARCH_START_TIME, DateUtil.beforeHourToNowDate(6));
|
params.put(StaticKeys.SEARCH_END_TIME, nowTime);
|
}
|
if ("am4".equals(am)) {
|
params.put(StaticKeys.SEARCH_START_TIME, DateUtil.beforeHourToNowDate(12));
|
params.put(StaticKeys.SEARCH_END_TIME, nowTime);
|
}
|
if ("am5".equals(am)) {
|
params.put(StaticKeys.SEARCH_START_TIME, DateUtil.beforeHourToNowDate(24));
|
params.put(StaticKeys.SEARCH_END_TIME, nowTime);
|
}
|
model.addAttribute("am", am);
|
return;
|
}
|
if (StringUtils.isEmpty(am) && !StringUtils.isEmpty(startTime) && !StringUtils.isEmpty(endTime)) {
|
params.put(StaticKeys.SEARCH_START_TIME, startTime + ":00");
|
|
params.put(StaticKeys.SEARCH_END_TIME, endTime + ":59");
|
model.addAttribute("startTime", startTime);
|
model.addAttribute("endTime", endTime);
|
return;
|
}
|
params.put(StaticKeys.SEARCH_START_TIME, DateUtil.beforeHourToNowDate(1));
|
params.put(StaticKeys.SEARCH_END_TIME, nowTime);
|
model.addAttribute("am", "am1");
|
} catch (Exception e) {
|
logger.error("查看图表组装日期查询条件错误", e);
|
}
|
}
|
|
/**
|
* 查看详细信息监控时候，组装日期查询条件
|
*
|
* @param params
|
* @param date
|
*/
|
public void setDateParam(String date, Map<String, Object> params) {
|
params.put(StaticKeys.SEARCH_START_TIME, date + " 00:00:00");
|
params.put(StaticKeys.SEARCH_END_TIME, date + " 23:59:59");
|
}
|
|
/**
|
* 设置监控概要页面环图
|
*
|
* @param model
|
* @param totalSystemInfoSize
|
*/
|
public void setHuantu(Model model, int totalSystemInfoSize, int totalSizeApp, int dockerSize, int portSize, int dceSize, int fileWarnSize,
|
int dbInfoSize, int heathSize, HttpServletRequest request) throws Exception {
|
//校验是否添加过滤用户查询条件
|
Map<String, Object> params = new HashMap<String, Object>();
|
HostUtil.addAccountquery(request, params);
|
int dbTableSize = dbTableService.countByParams(params);
|
int snmpInfoSize = snmpInfoService.countByParams(params);
|
|
|
int huantuTotalSize = totalSystemInfoSize + totalSizeApp + dockerSize + portSize + dceSize + fileWarnSize + dbInfoSize + heathSize + dbTableSize + snmpInfoSize;
|
//防止除以0的bug，所以新增一个total变量
|
double total = huantuTotalSize;
|
if (0 == total) {
|
total = 1d;
|
}
|
List<ChartInfo> chartInfos = new ArrayList<>();
|
double totalSystemInfoSizePercent = totalSystemInfoSize / total;
|
ChartInfo totalSystemInfoChart = new ChartInfo();
|
totalSystemInfoChart.setCount(totalSystemInfoSize);
|
totalSystemInfoChart.setItem("主机");
|
totalSystemInfoChart.setPercent(FormatUtil.formatDouble(totalSystemInfoSizePercent, 2));
|
if (totalSystemInfoSize > 0) {
|
chartInfos.add(totalSystemInfoChart);
|
}
|
|
double totalSizeAppPercent = totalSizeApp / total;
|
ChartInfo totalSizeAppChart = new ChartInfo();
|
totalSizeAppChart.setCount(totalSizeApp);
|
totalSizeAppChart.setItem("进程");
|
totalSizeAppChart.setPercent(FormatUtil.formatDouble(totalSizeAppPercent, 2));
|
if (totalSizeApp > 0) {
|
chartInfos.add(totalSizeAppChart);
|
}
|
|
double dockerSizePercent = dockerSize / total;
|
ChartInfo dockerSizeChart = new ChartInfo();
|
dockerSizeChart.setCount(dockerSize);
|
dockerSizeChart.setItem("DOCKER");
|
dockerSizeChart.setPercent(FormatUtil.formatDouble(dockerSizePercent, 2));
|
if (dockerSize > 0) {
|
chartInfos.add(dockerSizeChart);
|
}
|
|
double portSizePercent = portSize / total;
|
ChartInfo portSizeChart = new ChartInfo();
|
portSizeChart.setCount(portSize);
|
portSizeChart.setItem("端口");
|
portSizeChart.setPercent(FormatUtil.formatDouble(portSizePercent, 2));
|
if (portSize > 0) {
|
chartInfos.add(portSizeChart);
|
}
|
|
double dceSizePercent = dceSize / total;
|
ChartInfo dceSizeChart = new ChartInfo();
|
dceSizeChart.setCount(dceSize);
|
dceSizeChart.setItem("数通PING");
|
dceSizeChart.setPercent(FormatUtil.formatDouble(dceSizePercent, 2));
|
if (dceSize > 0) {
|
chartInfos.add(dceSizeChart);
|
}
|
|
double snmpInfoPercent = snmpInfoSize / total;
|
ChartInfo snmpInfoChart = new ChartInfo();
|
snmpInfoChart.setCount(snmpInfoSize);
|
snmpInfoChart.setItem("数通SNMP");
|
snmpInfoChart.setPercent(FormatUtil.formatDouble(snmpInfoPercent, 2));
|
if (snmpInfoSize > 0) {
|
chartInfos.add(snmpInfoChart);
|
}
|
|
double fileWarnSizePercent = fileWarnSize / total;
|
ChartInfo fileWarnSizeChart = new ChartInfo();
|
fileWarnSizeChart.setCount(fileWarnSize);
|
fileWarnSizeChart.setItem("日志");
|
fileWarnSizeChart.setPercent(FormatUtil.formatDouble(fileWarnSizePercent, 2));
|
if (fileWarnSize > 0) {
|
chartInfos.add(fileWarnSizeChart);
|
}
|
|
double dbInfoSizePercent = dbInfoSize / total;
|
ChartInfo dbInfoSizeChart = new ChartInfo();
|
dbInfoSizeChart.setCount(dbInfoSize);
|
dbInfoSizeChart.setItem("数据源");
|
dbInfoSizeChart.setPercent(FormatUtil.formatDouble(dbInfoSizePercent, 2));
|
if (dbInfoSize > 0) {
|
chartInfos.add(dbInfoSizeChart);
|
}
|
|
double heathSizePercent = heathSize / total;
|
ChartInfo heathSizeChart = new ChartInfo();
|
heathSizeChart.setCount(heathSize);
|
heathSizeChart.setItem("服务接口");
|
heathSizeChart.setPercent(FormatUtil.formatDouble(heathSizePercent, 2));
|
if (heathSize > 0) {
|
chartInfos.add(heathSizeChart);
|
}
|
|
double dbTableSizePercent = dbTableSize / total;
|
ChartInfo dbTableSizeChart = new ChartInfo();
|
dbTableSizeChart.setCount(dbTableSize);
|
dbTableSizeChart.setItem("数据表");
|
dbTableSizeChart.setPercent(FormatUtil.formatDouble(dbTableSizePercent, 2));
|
if (dbTableSize > 0) {
|
chartInfos.add(dbTableSizeChart);
|
}
|
|
model.addAttribute("huantuChartInfos", JSONUtil.parseArray(chartInfos));
|
model.addAttribute("huantuTotalSize", huantuTotalSize);
|
}
|
|
/**
|
* 设置监控概要页面腰线和波浪图
|
*
|
* @param model
|
* @param totalSystemInfoSize
|
*/
|
public void setMiddleData(Model model, HttpServletRequest request) throws Exception {
|
Map<String, Object> params = new HashMap<String, Object>();
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
List<SystemInfo> list = systemInfoService.selectAllByParams(params);
|
//cpu使用率最高
|
Double maxCpu = 0d;
|
//cpu使用率平均
|
Double avgCpu = 0d;
|
//cpu使用率最低
|
Double minCpu = 1000d;
|
Double sumCpu = 0d;
|
|
//内存使用率最高
|
Double maxMem = 0d;
|
//内存使用率最低
|
Double minMem = 1000d;
|
//内存使用率平均
|
Double avgMem = 0d;
|
Double sumMem = 0d;
|
|
//下行传输速率最高
|
Double maxRxbyt = 0d;
|
//下行传输速率平均
|
Double avgRxbyt = 0d;
|
//下行传输速率最低
|
Double minRxbyt = 1000d;
|
Double sumRxbyt = 0d;
|
|
//上行传输速率最高
|
Double maxTxbyt = 0d;
|
//上行传输速率最低
|
Double minTxbyt = 1000d;
|
//上行传输速率平均
|
Double avgTxbyt = 0d;
|
Double sumTxbyt = 0d;
|
|
//5分钟负载最高
|
Double maxFiveLoad = 0d;
|
//5分钟负载平均
|
Double avgFiveLoad = 0d;
|
//5分钟负载最低
|
Double minFiveLoad = 1000d;
|
Double sumFiveLoad = 0d;
|
|
//15分钟负载最高
|
Double maxFifteenLoad = 0d;
|
//15分钟负载最低
|
Double minFifteenLoad = 1000d;
|
//15分钟负载平均
|
Double avgFifteenLoad = 0d;
|
Double sumFifteenLoad = 0d;
|
|
//主机数量
|
int systemSize = 0;
|
|
//cpu总核数
|
int cpuCoresSum = 0;
|
//内存总和
|
double memSum = 0;
|
//上报时间总和
|
int submitSecondsSum = 0;
|
//主机平均上报频率
|
double avgSubmitSeconds = 120;
|
|
for (SystemInfo systemInfo : list) {
|
// if(StaticKeys.DOWN_STATE.equals(systemInfo.getState())){
|
// continue;
|
// }
|
systemSize += 1;
|
//组装cpu使用率 begin
|
if (null != systemInfo.getCpuPer()) {
|
if (systemInfo.getCpuPer() > maxCpu) {
|
maxCpu = systemInfo.getCpuPer();
|
}
|
if (systemInfo.getCpuPer() < minCpu) {
|
minCpu = systemInfo.getCpuPer();
|
}
|
sumCpu += systemInfo.getCpuPer();
|
}
|
//组装cpu使用率 end
|
|
//组装内存使用率 begin
|
if (null != systemInfo.getMemPer()) {
|
if (systemInfo.getMemPer() > maxMem) {
|
maxMem = systemInfo.getMemPer();
|
}
|
if (systemInfo.getMemPer() < minMem) {
|
minMem = systemInfo.getMemPer();
|
}
|
sumMem += systemInfo.getMemPer();
|
}
|
//组装内存使用率 end
|
|
//组装下行传输速率 begin
|
if (null != systemInfo.getRxbyt()) {
|
if (Double.valueOf(systemInfo.getRxbyt()) > maxRxbyt) {
|
maxRxbyt = Double.valueOf(systemInfo.getRxbyt());
|
}
|
if (Double.valueOf(systemInfo.getRxbyt()) < minRxbyt) {
|
minRxbyt = Double.valueOf(systemInfo.getRxbyt());
|
}
|
sumRxbyt += Double.valueOf(systemInfo.getRxbyt());
|
}
|
//组装下行传输速率 end
|
|
//组装上行传输速率 begin
|
if (null != systemInfo.getTxbyt()) {
|
if (Double.valueOf(systemInfo.getTxbyt()) > maxTxbyt) {
|
maxTxbyt = Double.valueOf(systemInfo.getTxbyt());
|
}
|
if (Double.valueOf(systemInfo.getTxbyt()) < minTxbyt) {
|
minTxbyt = Double.valueOf(systemInfo.getTxbyt());
|
}
|
sumTxbyt += Double.valueOf(systemInfo.getTxbyt());
|
}
|
//组装上行传输速率 end
|
|
//组装5分钟负载 begin
|
if (null != systemInfo.getFiveLoad()) {
|
if (Double.valueOf(systemInfo.getFiveLoad()) > maxFiveLoad) {
|
maxFiveLoad = Double.valueOf(systemInfo.getFiveLoad());
|
}
|
if (Double.valueOf(systemInfo.getFiveLoad()) < minFiveLoad) {
|
minFiveLoad = Double.valueOf(systemInfo.getFiveLoad());
|
}
|
sumFiveLoad += Double.valueOf(systemInfo.getFiveLoad());
|
}
|
//组装5分钟负载 end
|
|
//组装15分钟负载 begin
|
if (null != systemInfo.getFifteenLoad()) {
|
if (Double.valueOf(systemInfo.getFifteenLoad()) > maxFifteenLoad) {
|
maxFifteenLoad = Double.valueOf(systemInfo.getFifteenLoad());
|
}
|
if (Double.valueOf(systemInfo.getFifteenLoad()) < minFifteenLoad) {
|
minFifteenLoad = Double.valueOf(systemInfo.getFifteenLoad());
|
}
|
sumFifteenLoad += Double.valueOf(systemInfo.getFifteenLoad());
|
}
|
//组装15分钟负载 end
|
|
//组装cpu总核数 begin
|
try {
|
cpuCoresSum += Integer.valueOf(systemInfo.getCpuCoreNum());
|
} catch (Exception e) {
|
logger.error("统计所有主机总核数错误", e);
|
}
|
//组装cpu总核数 end
|
|
//组装总内存 begin
|
try {
|
memSum += Double.valueOf(systemInfo.getTotalMem().replace("G", ""));
|
} catch (Exception e) {
|
logger.error("统计所有主机总内存错误", e);
|
}
|
//组装总内存 end
|
|
//组装上报数据频率总和 begin
|
try {
|
submitSecondsSum += Integer.valueOf(systemInfo.getSubmitSeconds());
|
} catch (Exception e) {
|
logger.error("统计所有主机组装上报数据频率总和错误", e);
|
}
|
//组装上报数据频率总和 end
|
|
}
|
|
if (systemSize > 0) {
|
avgCpu = sumCpu / list.size();
|
avgMem = sumMem / list.size();
|
avgRxbyt = sumRxbyt / list.size();
|
avgTxbyt = sumTxbyt / list.size();
|
avgFifteenLoad = sumFifteenLoad / list.size();
|
avgFiveLoad = sumFiveLoad / list.size();
|
avgSubmitSeconds = submitSecondsSum / (double) list.size();
|
} else {
|
minCpu = 0d;
|
minMem = 0d;
|
minRxbyt = 0d;
|
minTxbyt = 0d;
|
avgFifteenLoad = 0d;
|
avgFiveLoad = 0d;
|
}
|
|
model.addAttribute("cpuCoresSum", cpuCoresSum);
|
model.addAttribute("memSum", FormatUtil.formatDouble(memSum, 2));
|
model.addAttribute("avgSubmitSeconds", FormatUtil.formatDouble(avgSubmitSeconds, 2));
|
|
//最近5分钟所有主机cpu状态 begin
|
List cpuInfoList = new ArrayList();
|
ChartInfo maxCpuInfo = new ChartInfo();
|
maxCpuInfo.setValue(maxCpu);
|
maxCpuInfo.setItem("CPU%最高");
|
cpuInfoList.add(maxCpuInfo);
|
ChartInfo avgCpuInfo = new ChartInfo();
|
avgCpuInfo.setValue(FormatUtil.formatDouble(avgCpu, 2));
|
avgCpuInfo.setItem("CPU%平均");
|
cpuInfoList.add(avgCpuInfo);
|
ChartInfo minCpuInfo = new ChartInfo();
|
minCpuInfo.setValue(minCpu);
|
minCpuInfo.setItem("CPU%最低");
|
cpuInfoList.add(minCpuInfo);
|
model.addAttribute("cpuInfoList", cpuInfoList);
|
//最近5分钟所有主机cpu状态 end
|
|
//最近5分钟所有主机内存状态 begin
|
List memInfoList = new ArrayList();
|
ChartInfo maxMemInfo = new ChartInfo();
|
maxMemInfo.setValue(maxMem);
|
maxMemInfo.setItem("内存%最高");
|
memInfoList.add(maxMemInfo);
|
ChartInfo avgMemInfo = new ChartInfo();
|
avgMemInfo.setValue(FormatUtil.formatDouble(avgMem, 2));
|
avgMemInfo.setItem("内存%平均");
|
memInfoList.add(avgMemInfo);
|
ChartInfo minMemInfo = new ChartInfo();
|
minMemInfo.setValue(minMem);
|
minMemInfo.setItem("内存%最低");
|
memInfoList.add(minMemInfo);
|
model.addAttribute("memInfoList", memInfoList);
|
//最近5分钟所有主机内存状态 end
|
|
model.addAttribute("maxRxbyt", FormatUtil.kbToM(maxRxbyt + "") + "/s");
|
model.addAttribute("minRxbyt", FormatUtil.kbToM(minRxbyt + "") + "/s");
|
model.addAttribute("avgRxbyt", FormatUtil.kbToM(FormatUtil.formatDouble(avgRxbyt, 2) + "") + "/s");
|
model.addAttribute("maxTxbyt", FormatUtil.kbToM(maxTxbyt + "") + "/s");
|
model.addAttribute("minTxbyt", FormatUtil.kbToM(minTxbyt + "") + "/s");
|
model.addAttribute("avgTxbyt", FormatUtil.kbToM(FormatUtil.formatDouble(avgTxbyt, 2) + "") + "/s");
|
|
model.addAttribute("maxFiveLoad", maxFiveLoad);
|
model.addAttribute("minFiveLoad", minFiveLoad);
|
model.addAttribute("avgFiveLoad", FormatUtil.formatDouble(avgFiveLoad, 2));
|
model.addAttribute("maxFifteenLoad", maxFifteenLoad);
|
model.addAttribute("minFifteenLoad", minFifteenLoad);
|
model.addAttribute("avgFifteenLoad", FormatUtil.formatDouble(avgFifteenLoad, 2));
|
|
}
|
|
/**
|
* 设置监控概要页面的内存和cpu饼图
|
*
|
* @param model
|
* @param totalSystemInfoSize
|
*/
|
public void setPieChart(Model model, int totalSystemInfoSize, HttpServletRequest request) throws Exception {
|
Map<String, Object> params = new HashMap<String, Object>();
|
List<ChartInfo> chartInfoList1 = new ArrayList<ChartInfo>();
|
List<ChartInfo> chartInfoList2 = new ArrayList<ChartInfo>();
|
|
//内存>=95% begin
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
params.put("memPer", 95);
|
int memPerSize_95 = systemInfoService.countByParams(params);
|
double a = 0;
|
if (totalSystemInfoSize != 0) {
|
a = (double) memPerSize_95 / totalSystemInfoSize;
|
}
|
ChartInfo memPerSize_95_chart = new ChartInfo();
|
memPerSize_95_chart.setItem("内存>=95%");
|
memPerSize_95_chart.setCount(memPerSize_95);
|
memPerSize_95_chart.setPercent(FormatUtil.formatDouble(a, 2));
|
chartInfoList1.add(memPerSize_95_chart);
|
params.clear();
|
//内存>=95% begin
|
|
|
//内存>=90%且<95% begin
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
params.put("memPer", 90);
|
params.put("memPerLe", 95);
|
int memPerSize_90_95 = systemInfoService.countByParams(params);
|
double a_90_95 = 0;
|
if (totalSystemInfoSize != 0) {
|
a_90_95 = (double) memPerSize_90_95 / totalSystemInfoSize;
|
}
|
ChartInfo memPerSize_90_95_chart = new ChartInfo();
|
memPerSize_90_95_chart.setItem("内存>=90%且<95%");
|
memPerSize_90_95_chart.setCount(memPerSize_90_95);
|
memPerSize_90_95_chart.setPercent(FormatUtil.formatDouble(a_90_95, 2));
|
chartInfoList1.add(memPerSize_90_95_chart);
|
params.clear();
|
//内存>=90%且<95% begin
|
|
//内存>=50%且<90% begin
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
params.put("memPer", 50);
|
params.put("memPerLe", 90);
|
int memPerSize_50_90 = systemInfoService.countByParams(params);
|
double b = 0;
|
if (totalSystemInfoSize != 0) {
|
b = (double) memPerSize_50_90 / totalSystemInfoSize;
|
}
|
ChartInfo memPerSize_50_90_chart = new ChartInfo();
|
memPerSize_50_90_chart.setItem("内存>=50%且<90%");
|
memPerSize_50_90_chart.setCount(memPerSize_50_90);
|
memPerSize_50_90_chart.setPercent(FormatUtil.formatDouble(b, 2));
|
chartInfoList1.add(memPerSize_50_90_chart);
|
params.clear();
|
//内存>=50%且<90% end
|
|
|
//内存<50% begin
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
params.put("memPerLe", 50);
|
int memPerSize_50 = systemInfoService.countByParams(params);
|
double bb = 0;
|
if (totalSystemInfoSize != 0) {
|
bb = (double) memPerSize_50 / totalSystemInfoSize;
|
}
|
ChartInfo memPerSize_50_chart = new ChartInfo();
|
memPerSize_50_chart.setItem("内存<50%");
|
memPerSize_50_chart.setCount(memPerSize_50);
|
memPerSize_50_chart.setPercent(FormatUtil.formatDouble(bb, 2));
|
chartInfoList1.add(memPerSize_50_chart);
|
params.clear();
|
//内存<50% end
|
|
model.addAttribute("chartInfoList1", JSONUtil.parseArray(chartInfoList1));
|
|
|
//CPU>=95%" begin
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
params.put("cpuPer", 95);
|
int cpuPerSize_95 = systemInfoService.countByParams(params);
|
double c_95 = 0;
|
if (totalSystemInfoSize != 0) {
|
c_95 = (double) cpuPerSize_95 / totalSystemInfoSize;
|
}
|
ChartInfo cpuPerSize_95_chart = new ChartInfo();
|
cpuPerSize_95_chart.setItem("CPU>=95%");
|
cpuPerSize_95_chart.setCount(cpuPerSize_95);
|
cpuPerSize_95_chart.setPercent(FormatUtil.formatDouble(c_95, 2));
|
chartInfoList2.add(cpuPerSize_95_chart);
|
params.clear();
|
//CPU>=95%" end
|
|
//CPU>=90%且<95% begin
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
params.put("cpuPer", 90);
|
params.put("cpuPerLe", 95);
|
int cpuPerSize_90_95 = systemInfoService.countByParams(params);
|
double c_90_95 = 0;
|
if (totalSystemInfoSize != 0) {
|
c_90_95 = (double) cpuPerSize_90_95 / totalSystemInfoSize;
|
}
|
ChartInfo cpuPerSize_90_95_chart = new ChartInfo();
|
cpuPerSize_90_95_chart.setItem("CPU>=90%且<95%");
|
cpuPerSize_90_95_chart.setCount(cpuPerSize_90_95);
|
cpuPerSize_90_95_chart.setPercent(FormatUtil.formatDouble(c_90_95, 2));
|
chartInfoList2.add(cpuPerSize_90_95_chart);
|
params.clear();
|
//CPU>=90%且<95% end
|
|
|
//CPU>=50%且<90% begin
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
params.put("cpuPerLe", 90);
|
params.put("cpuPer", 50);
|
int perSize_50_90 = systemInfoService.countByParams(params);
|
double e = 0;
|
if (totalSystemInfoSize != 0) {
|
e = (double) perSize_50_90 / totalSystemInfoSize;
|
}
|
ChartInfo perSize_50_90_chart = new ChartInfo();
|
perSize_50_90_chart.setItem("CPU>=50%且<90%");
|
perSize_50_90_chart.setCount(perSize_50_90);
|
perSize_50_90_chart.setPercent(FormatUtil.formatDouble(e, 2));
|
chartInfoList2.add(perSize_50_90_chart);
|
params.clear();
|
//CPU>=50%且<90% end
|
|
//CPU<50% begin
|
//校验是否添加过滤用户查询条件
|
HostUtil.addAccountquery(request, params);
|
params.put("cpuPerLe", 50);
|
int perSize_50 = systemInfoService.countByParams(params);
|
double f = 0;
|
if (totalSystemInfoSize != 0) {
|
f = (double) perSize_50 / totalSystemInfoSize;
|
}
|
ChartInfo perSize_50_chart = new ChartInfo();
|
perSize_50_chart.setItem("CPU<50%");
|
perSize_50_chart.setCount(perSize_50);
|
perSize_50_chart.setPercent(FormatUtil.formatDouble(f, 2));
|
chartInfoList2.add(perSize_50_chart);
|
params.clear();
|
//CPU<50% end
|
|
model.addAttribute("chartInfoList2", JSONUtil.parseArray(chartInfoList2));
|
params.clear();
|
|
}
|
|
|
/**
|
* 设置监控概要页面，系统核心参数信息
|
*
|
* @param model
|
* @param model
|
*/
|
public void setMiddleApplicationData(Model model) throws Exception {
|
Map<String, Object> params = new HashMap<String, Object>();
|
//告警日志数量
|
params.put("hostname", "告警");
|
model.addAttribute("warnCount", logInfoService.countByParams(params));
|
|
//历史趋势图数据保留天数
|
model.addAttribute("historyDataOut", commonConfig.getHistoryDataOut());
|
|
//告警方式
|
String warnType = "未设置";
|
if (StaticKeys.mailSet != null && !StringUtils.isEmpty(mailConfig.getWarnScript())) {
|
warnType = "邮件+脚本";
|
}
|
if (StaticKeys.mailSet == null && !StringUtils.isEmpty(mailConfig.getWarnScript())) {
|
warnType = "脚本";
|
}
|
if (StaticKeys.mailSet != null && StringUtils.isEmpty(mailConfig.getWarnScript())) {
|
warnType = "邮件";
|
}
|
model.addAttribute("warnType", warnType);
|
|
//公众看板服务是否开启
|
String dapingView = "已关闭";
|
if (StaticKeys.TRUE_VAL.equals(commonConfig.getDashView())) {
|
dapingView = "已开启";
|
}
|
model.addAttribute("dapingView", dapingView);
|
|
//管理员默认密码是否已修改
|
String adminPwd = "默认";
|
if (!"111111".equals(commonConfig.getAccountPwd())) {
|
adminPwd = "已修改";
|
}
|
model.addAttribute("adminPwd", adminPwd);
|
|
//只读账号默认密码是否已修改
|
String guestAccountPwd = "默认";
|
if (!"111111".equals(commonConfig.getGuestAccountPwd())) {
|
guestAccountPwd = "已修改";
|
}
|
model.addAttribute("guestAccountPwd", guestAccountPwd);
|
|
//通信token是否已修改
|
String wgToken = "默认";
|
if (!"wgcloud".equals(commonConfig.getWgToken())) {
|
wgToken = "已修改";
|
}
|
model.addAttribute("wgToken", wgToken);
|
|
//webSSH是否开启
|
String webSSH = "已关闭";
|
if (StaticKeys.TRUE_VAL.equals(commonConfig.getWebSsh())) {
|
webSSH = "已开启";
|
}
|
model.addAttribute("webSSH", webSSH);
|
}
|
|
/**
|
* 给主机画像
|
*
|
* @param model
|
* @param systemInfoId
|
*/
|
public void hostDraw(Model model, String systemInfoId) {
|
try {
|
SystemInfo systemInfo = systemInfoService.selectById(systemInfoId);
|
String hostname = systemInfo.getHostname();
|
Map<String, Object> params = new HashMap<String, Object>();
|
params.put("hostname", hostname);
|
model.addAttribute("systemInfo", systemInfo);
|
//监控进程总数量
|
int totalAppSize = appInfoService.countByParams(params);
|
model.addAttribute("totalAppSize", totalAppSize);
|
//监控端口总数量
|
int totalPortSize = portInfoService.countByParams(params);
|
model.addAttribute("totalPortSize", totalPortSize);
|
|
//监控进程下线数量
|
params.put("state", StaticKeys.DOWN_STATE);
|
int downAppSize = appInfoService.countByParams(params);
|
model.addAttribute("downAppSize", downAppSize);
|
//监控端口下线数量
|
int downPortSize = portInfoService.countByParams(params);
|
model.addAttribute("downPortSize", downPortSize);
|
|
//最近监控周期天cpu使用率最大
|
Double maxCpuState = cpuStateService.selectMaxByHostname(hostname);
|
model.addAttribute("maxCpuState", maxCpuState);
|
//最近监控周期天mem使用率最大
|
Double maxMemState = memStateService.selectMaxByHostname(hostname);
|
model.addAttribute("maxMemState", maxMemState);
|
|
//多少天清空一次历史数据
|
model.addAttribute("historyDataOut", commonConfig.getHistoryDataOut());
|
|
params.clear();
|
params.put("hostname", hostname);
|
PageInfo pageInfoLoad = sysLoadStateService.selectByParams(params, 1, 1);
|
if (!CollectionUtil.isEmpty(pageInfoLoad.getList())) {
|
//最新一条系统负载
|
model.addAttribute("sysLoadState", pageInfoLoad.getList().get(0));
|
} else {
|
//最新一条系统负载
|
model.addAttribute("sysLoadState", new SysLoadState());
|
}
|
SysLoadState sysLoadStateMax = sysLoadStateService.selectMaxByHostname(hostname);
|
if (null == sysLoadStateMax) {
|
sysLoadStateMax = new SysLoadState();
|
}
|
//1分钟负载历史最高
|
model.addAttribute("maxOneLoad", sysLoadStateMax.getOneLoad());
|
//5分钟负载历史最高
|
model.addAttribute("maxFiveLoad", sysLoadStateMax.getFiveLoad());
|
//15分钟负载历史最高
|
model.addAttribute("maxFifteenLoad", sysLoadStateMax.getFifteenLoad());
|
|
//最新一条网络流量数据
|
PageInfo pageInfoNetIo = netIoStateService.selectByParams(params, 1, 1);
|
NetIoState netIoStateNew = new NetIoState();
|
if (!CollectionUtil.isEmpty(pageInfoNetIo.getList())) {
|
netIoStateNew = (NetIoState) pageInfoNetIo.getList().get(0);
|
netIoStateNew.setRxbyt(FormatUtil.kbToM(netIoStateNew.getRxbyt()) + "/s");
|
netIoStateNew.setTxbyt(FormatUtil.kbToM(netIoStateNew.getTxbyt()) + "/s");
|
model.addAttribute("netIoState", netIoStateNew);
|
} else {
|
//最新一条网络流量
|
model.addAttribute("netIoState", netIoStateNew);
|
}
|
|
|
NetIoState netIoStateMax = netIoStateService.selectMaxByHostname(hostname);
|
if (null == netIoStateMax) {
|
netIoStateMax = new NetIoState();
|
}
|
//接受字节历史最高
|
model.addAttribute("maxRxbyt", FormatUtil.kbToM(netIoStateMax.getRxbyt()) + "/s");
|
//发送字节历史最高
|
model.addAttribute("maxTxbyt", FormatUtil.kbToM(netIoStateMax.getTxbyt()) + "/s");
|
//接受包历史最高
|
model.addAttribute("maxRxpck", netIoStateMax.getRxpck());
|
//发送包历史最高
|
model.addAttribute("maxTxpck", netIoStateMax.getTxpck());
|
|
//主机下线次数
|
params.clear();
|
params.put("hostname", "主机下线告警：" + hostname);
|
int hostDownSize = logInfoService.countByParams(params);
|
model.addAttribute("hostDownSize", hostDownSize);
|
|
//所有监控进程
|
params.clear();
|
params.put("hostname", hostname);
|
List<AppInfo> appInfoList = appInfoService.selectAllByParams(params);
|
for (AppInfo appInfo1 : appInfoList) {
|
appInfo1.setWritesBytes(FormatUtil.mToG(appInfo1.getWritesBytes()));
|
appInfo1.setReadBytes(FormatUtil.mToG(appInfo1.getReadBytes()));
|
}
|
//设置分组
|
appInfoService.setGroupInList(appInfoList);
|
model.addAttribute("appInfoList", appInfoList);
|
|
//所有监控端口
|
List<PortInfo> portInfoList = portInfoService.selectAllByParams(params);
|
portInfoService.setGroupInList(portInfoList);
|
model.addAttribute("portInfoList", portInfoList);
|
|
//所有监控防篡改文件
|
List<FileSafe> fileSafeInfoList = fileSafeService.selectAllByParams(params);
|
model.addAttribute("fileSafeInfoList", fileSafeInfoList);
|
|
//所有日志文件监控
|
List<FileWarnInfo> fileWarnInfoList = fileWarnInfoService.selectAllByParams(params);
|
for (FileWarnInfo info : fileWarnInfoList) {
|
params.put("fileWarnId", info.getId());
|
Integer count = fileWarnStateService.countByParams(params);
|
info.setWarnDatas(count + "");
|
}
|
model.addAttribute("fileWarnInfoList", fileWarnInfoList);
|
|
params.clear();
|
params.put("hostname", hostname);
|
//所有监控docker
|
List<DockerInfo> dockerInfoList = dockerInfoService.selectAllByParams(params);
|
dockerInfoService.setGroupInList(dockerInfoList);
|
model.addAttribute("dockerInfoList", dockerInfoList);
|
|
|
//磁盘容量信息
|
List<DiskState> diskStateList = diskStateService.selectAllByParams(params);
|
model.addAttribute("deskStateList", diskStateList);
|
|
//磁盘IO信息
|
List<DeskIo> deskIoList = deskIoService.selectAllByParams(params);
|
model.addAttribute("deskIoList", deskIoList);
|
|
//磁盘smart信息
|
List<DiskSmart> diskSmartList = diskSmartService.selectAllByParams(params);
|
model.addAttribute("diskSmartList", diskSmartList);
|
|
//cpu温度
|
List<CpuTemperatures> cpuTemperaturesList = cpuTemperaturesService.selectAllByParams(params);
|
model.addAttribute("cpuTemperaturesList", cpuTemperaturesList);
|
|
//自定义监控项列表
|
List<CustomInfo> customInfoList = customInfoService.selectAllByParams(params);
|
model.addAttribute("customInfoList", customInfoList);
|
|
|
} catch (Exception e) {
|
logger.error("主机画像错误", e);
|
logInfoService.save("主机画像错误", e.toString(), StaticKeys.LOG_XTCZ);
|
}
|
}
|
|
}
|
