@Override
public void visitMachine(Machine machine) {
m_currentIp = machine.getIp();
if (StringUtils.isEmpty(m_domain)) {
incDistribute(m_currentIp, queryValue(m_attribute, machine));
} else {
super.visitMachine(machine);
}
}
@Override
public StateReport getReport(String domain) {
StateReport report = new StateReport(Constants.CAT);
report.setStartTime(new Date(m_startTime));
report.setEndTime(new Date(m_startTime + MINUTE * 60 - 1));
Machine machine = buildStateInfo(report.findOrCreateMachine(m_ip));
StateReport stateReport = m_reportManager.getHourlyReport(getStartTime(), Constants.CAT, true);
Map<String, ProcessDomain> processDomains =
stateReport.findOrCreateMachine(m_ip).getProcessDomains();
for (Map.Entry<String, ProcessDomain> entry : machine.getProcessDomains().entrySet()) {
ProcessDomain processDomain = processDomains.get(entry.getKey());
if (processDomain != null) {
entry.getValue().getIps().addAll(processDomain.getIps());
}
}
return report;
}
@Override
protected void process(MessageTree tree) {
StateReport report = m_reportManager.getHourlyReport(getStartTime(), Constants.CAT, true);
String domain = tree.getDomain();
String ip = tree.getIpAddress();
Machine machine =
report.findOrCreateMachine(NetworkInterfaceManager.INSTANCE.getLocalHostAddress());
machine.findOrCreateProcessDomain(domain).addIp(ip);
if (m_serverConfigManager.validateDomain(domain)) {
if (!m_domainManager.containsDomainInCat(domain)) {
boolean insert = m_domainManager.insertDomain(domain);
if (!insert) {
m_logger.warn(String.format("Error when insert domain %s info", domain));
}
}
Hostinfo info = m_domainManager.queryHostInfoByIp(ip);
if (info == null) {
m_domainManager.insert(domain, ip);
} else {
String oldDomain = info.getDomain();
if (!oldDomain.equals(domain) && !oldDomain.equals(Constants.CAT)) {
// only work on online environment
long current = System.currentTimeMillis();
Date lastModifiedDate = info.getLastModifiedDate();
if (lastModifiedDate != null && (current - lastModifiedDate.getTime()) > ONE_HOUR) {
m_domainManager.update(info.getId(), domain, ip);
m_logger.info(
String.format("old domain is %s , change ip %s to %s", oldDomain, ip, domain));
}
}
}
}
}
private double queryValue(String key, Machine machine) {
double value = 0;
if (key.equalsIgnoreCase("total")) {
value = machine.getTotal();
} else if (key.equalsIgnoreCase("totalLoss")) {
value = machine.getTotalLoss();
} else if (key.equalsIgnoreCase("avgTps")) {
value = machine.getAvgTps();
} else if (key.equalsIgnoreCase("maxTps")) {
value = machine.getMaxTps();
} else if (key.equalsIgnoreCase("dump")) {
value = machine.getDump();
} else if (key.equalsIgnoreCase("dumpLoss")) {
value = machine.getDumpLoss();
} else if (key.equalsIgnoreCase("eagleTimeError")) {
value = machine.getEagleTimeError();
} else if (key.equalsIgnoreCase("networkTimeError")) {
value = machine.getNetworkTimeError();
} else if (key.equalsIgnoreCase("blockTotal")) {
value = machine.getBlockTotal();
} else if (key.equalsIgnoreCase("blockLoss")) {
value = machine.getBlockLoss();
} else if (key.equalsIgnoreCase("blockTime")) {
value = machine.getBlockTime() * 1.0 / 60 / 1000;
} else if (key.equalsIgnoreCase("size")) {
value = machine.getSize() / 1024 / 1024;
} else if (key.equalsIgnoreCase("delayAvg")) {
if (machine.getDelayCount() > 0) {
value = machine.getDelaySum() / machine.getDelayCount();
}
}
return value;
}
private Machine buildStateInfo(Machine machine) {
long minute = 1000 * 60;
long start = m_startTime;
long end = m_startTime + minute * 60;
double maxTps = 0;
long current = System.currentTimeMillis();
int size = 0;
if (end > current) {
end = current;
}
for (; start < end; start += minute) {
Statistic state = m_serverStateManager.findOrCreateState(start);
Message temp = machine.findOrCreateMessage(start);
Map<String, AtomicLong> totals = state.getMessageTotals();
Map<String, AtomicLong> totalLosses = state.getMessageTotalLosses();
Map<String, AtomicLong> sizes = state.getMessageSizes();
for (Entry<String, AtomicLong> entry : totals.entrySet()) {
String domain = entry.getKey();
long value = entry.getValue().get();
ProcessDomain processDomain = machine.findOrCreateProcessDomain(domain);
Detail detail = processDomain.findOrCreateDetail(start);
processDomain.setTotal(value + processDomain.getTotal());
detail.setTotal(value + detail.getTotal());
}
for (Entry<String, AtomicLong> entry : totalLosses.entrySet()) {
String domain = entry.getKey();
long value = entry.getValue().get();
ProcessDomain processDomain = machine.findOrCreateProcessDomain(domain);
Detail detail = processDomain.findOrCreateDetail(start);
processDomain.setTotalLoss(value + processDomain.getTotalLoss());
detail.setTotalLoss(value + detail.getTotalLoss());
}
for (Entry<String, AtomicLong> entry : sizes.entrySet()) {
String domain = entry.getKey();
long value = entry.getValue().get();
ProcessDomain processDomain = machine.findOrCreateProcessDomain(domain);
Detail detail = processDomain.findOrCreateDetail(start);
processDomain.setSize(value + processDomain.getSize());
detail.setSize(value + detail.getSize());
}
long messageTotal = state.getMessageTotal();
long messageTotalLoss = state.getMessageTotalLoss();
long messageSize = state.getMessageSize();
long blockTotal = state.getBlockTotal();
long blockLoss = state.getBlockLoss();
long blockTime = state.getBlockTime();
long pigeonTimeError = state.getPigeonTimeError();
long networkTimeError = state.getNetworkTimeError();
long messageDump = state.getMessageDump();
long messageDumpLoss = state.getMessageDumpLoss();
int processDelayCount = state.getProcessDelayCount();
double processDelaySum = state.getProcessDelaySum();
temp.setTotal(messageTotal).setTotalLoss(messageTotalLoss).setSize(messageSize);
temp.setBlockTotal(blockTotal).setBlockLoss(blockLoss).setBlockTime(blockTime);
temp.setPigeonTimeError(pigeonTimeError)
.setNetworkTimeError(networkTimeError)
.setDump(messageDump);
temp.setDumpLoss(messageDumpLoss)
.setDelayCount(processDelayCount)
.setDelaySum(processDelaySum);
machine
.setTotal(messageTotal + machine.getTotal())
.setTotalLoss(messageTotalLoss + machine.getTotalLoss())
.setSize(messageSize + machine.getSize());
machine
.setBlockTotal(machine.getBlockTotal() + blockTotal)
.setBlockLoss(machine.getBlockLoss() + blockLoss)
.setBlockTime(machine.getBlockTime() + blockTime);
machine
.setPigeonTimeError(machine.getPigeonTimeError() + pigeonTimeError)
.setNetworkTimeError(machine.getNetworkTimeError() + networkTimeError)
.setDump(machine.getDump() + messageDump);
machine
.setDumpLoss(machine.getDumpLoss() + messageDumpLoss)
.setDelayCount(machine.getDelayCount() + processDelayCount)
.setDelaySum(machine.getDelaySum() + processDelaySum);
double avg = 0;
long count = machine.getDelayCount();
if (count > 0) {
avg = machine.getDelaySum() / count;
machine.setDelayAvg(avg);
}
if (messageTotal > maxTps) {
maxTps = messageTotal;
}
temp.setTime(new Date(start));
size++;
}
double avgTps = 0;
if (size > 0) {
avgTps = machine.getTotal() / (double) size;
}
machine.setAvgTps(avgTps);
machine.setMaxTps(maxTps);
return machine;
}
