Exemplo n.º 1
0
  @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);
    }
  }
Exemplo n.º 2
0
  @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;
  }
Exemplo n.º 3
0
  @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));
          }
        }
      }
    }
  }
Exemplo n.º 4
0
 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;
 }
Exemplo n.º 5
0
  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;
  }