Java Statistics类代码示例

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
public Statistics statsContainer(String id) throws IOException {
    this.readWriteLock.readLock().lock();

    try {
        StatsCmd statsCmd = this.dockerClient.statsCmd(id);
        CountDownLatch countDownLatch = new CountDownLatch(1);
        StatsLogsResultCallback statslogs = new StatsLogsResultCallback(countDownLatch);
        try {
            StatsLogsResultCallback statscallback = statsCmd.exec(statslogs);
            countDownLatch.await(5, TimeUnit.SECONDS);
            statscallback.close();
        } catch (InterruptedException e) {
            throw new IOException(e);
        }
        return statslogs.getStatistics();
    } finally {
        this.readWriteLock.readLock().unlock();
    }
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
public void onStats(Statistics statistics) {

    LOGGER.debug("Received Docker Statistics Event: " + statistics);

    final Exchange exchange = getEndpoint().createExchange();
    Message message = exchange.getIn();
    message.setBody(statistics);

    try {
        LOGGER.trace("Processing exchange [{}]...", exchange);
        getAsyncProcessor().process(exchange, new AsyncCallback() {
            @Override
            public void done(boolean doneSync) {
                LOGGER.trace("Done processing exchange [{}]...", exchange);
            }
        });
    } catch (Exception e) {
        exchange.setException(e);
    }
    if (exchange.getException() != null) {
        getExceptionHandler().handleException("Error processing exchange", exchange, exchange.getException());
    }

}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
protected NetInfo getNetInfo() {
  NetInfo netInfo = new NetInfo();
  Statistics stats = docker.getStatistics(containerId);
  Map<String, Object> networksStats = stats.getNetworks();

  for (String key : networksStats.keySet()) {
    Map<String, Object> iface = (Map<String, Object>) networksStats.get(key);
    int rxBytes = (Integer) iface.get("rx_bytes");
    int txBytes = (Integer) iface.get("tx_bytes");

    netInfo.putNetInfo(key, rxBytes, txBytes);
  }
  return netInfo;
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
public void onNext(Statistics stats) {
    if (stats != null) {
        this.stats = Optional.of(stats);
        completed.countDown();
        onComplete();
    }
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
public Statistics getStatistics(String containerId) {
  FirstObjectResultCallback<Statistics> resultCallback = new FirstObjectResultCallback<>();

  try {
    return getClient().statsCmd(containerId).exec(resultCallback).waitForObject();
  } catch (InterruptedException e) {
    throw new KurentoException("Interrupted while waiting for statistics");
  }
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
protected double getCpuUsage() {
  double cpuUsage = 0;
  Statistics stats = docker.getStatistics(containerId);
  Map<String, Object> cpuStats = stats.getCpuStats();

  if (cpuStats != null) {
    Map<String, Object> cpuUsageMap = (Map<String, Object>) cpuStats.get("cpu_usage");
    long systemUsage = Long.parseLong(cpuStats.get("system_cpu_usage").toString());
    long totalUsage = Long.parseLong(cpuUsageMap.get("total_usage").toString());

    List<Object> perCpuUsage = (List<Object>) cpuUsageMap.get("percpu_usage");

    if (previousCpu != -1 && previousSystem != -1) {
      // Using same formula than
      // https://github.com/docker/docker/blob/master/api/client/stats.go

      float cpuDelta = totalUsage - previousCpu;
      float systemDelta = systemUsage - previousSystem;

      if (cpuDelta > 0 && systemDelta > 0) {
        cpuUsage = cpuDelta / systemDelta * perCpuUsage.size() * 100;
      }
    }

    previousCpu = totalUsage;
    previousSystem = systemUsage;
  }

  return cpuUsage;
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
protected double[] getMem() {
  double[] out = { 0, 0 };

  Statistics stats = docker.getStatistics(containerId);
  Map<String, Object> memoryStats = stats.getMemoryStats();
  int usage = (Integer) memoryStats.get("usage");
  float limit = (Long) memoryStats.get("limit");
  double memPercent = usage / limit * 100;

  out[0] = usage;
  out[1] = memPercent;

  return out;
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
protected AbstractCallbackNotifier<Statistics> callbackNotifier(StatsCmd command,
        ResultCallback<Statistics> resultCallback) {

    WebTarget webTarget = getBaseResource().path("/containers/{id}/stats").resolveTemplate("id",
            command.getContainerId());

    LOGGER.trace("GET: {}", webTarget);

    return new GETCallbackNotifier<Statistics>(new JsonStreamProcessor<Statistics>(Statistics.class),
            resultCallback, webTarget.request());
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
public void onNext(Statistics stats) {
    LOG.info("Received stats #{}: {}", countDownLatch.getCount(), stats);
    if (stats != null) {
        gotStats = true;
    }
    countDownLatch.countDown();
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
public void onNext(Statistics statistics) {
    if (statistics != null) {
        this.statistics = statistics;
        this.onComplete();
    }
    this.countDownLatch.countDown();
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
public void onNext(Statistics stats) {
	listCommands.refresh();
	BoxContainer boxContainer = listCommands
			.getBoxContainerWithID(containerID);
	Container container = listCommands.getFromAllWithName(boxContainer
			.getName());
	
	NumberFormat formatter = new DecimalFormat("#0.00");

	double memoryUsage = Double.parseDouble(formatter
			.format((((Integer) stats.getMemoryStats().get("usage"))
					.doubleValue() / ((Integer) stats.getMemoryStats().get(
					"limit")).doubleValue()) * 100D));
	Object totalUsage = ((LinkedHashMap) stats.getCpuStats().get(
			"cpu_usage")).get("total_usage");
	double totalUsageDouble = 0D;
	if (totalUsage instanceof Integer) {
		totalUsageDouble = ((Integer) totalUsage).doubleValue();
	} else if (totalUsage instanceof Long) {
		totalUsageDouble = ((Long) totalUsage).doubleValue();
	}
	double cpuUsage = Double.parseDouble(formatter.format(totalUsageDouble
			/ ((Long) stats.getCpuStats().get("system_cpu_usage"))
					.doubleValue() * 100D));

	boxContainer.setMemoryUsage(memoryUsage);
	boxContainer.setCpuUsage(cpuUsage);

	if (sendMessages) {
		basicCommands.printContainerInfo(boxContainer, container);
		sendMessage(EnumChatFormatting.RED + "" + EnumChatFormatting.BOLD
				+ "Memory Usage: " + EnumChatFormatting.RESET + memoryUsage
				+ "%");
		sendMessage(EnumChatFormatting.GRAY + "" + EnumChatFormatting.BOLD
				+ "CPU Usage: " + EnumChatFormatting.RESET + cpuUsage + "%");
	}

	try {
		super.close();
	} catch (IOException exception) {
		throw new MobycraftException(exception);
	}
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
public Statistics getStats() {
	return stats;
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
@Override
public void onNext(Statistics stats) {
   	this.stats = stats;
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
public Statistics getStatistics() {
    return this.statistics;
}
 

import com.github.dockerjava.api.model.Statistics; //导入依赖的package包/类
public static CubeStatistics updateStats(Statistics statistics) {

        CubeStatistics stats = new CubeStatistics();

        Map<String, Long> blkio = extractIORW(statistics.getBlkioStats());
        Map<String, Long> memory = extractMemoryStats(statistics.getMemoryStats(), "usage", "max_usage", "limit");

        stats.setIoBytesRead(blkio.get("io_bytes_read"));
        stats.setIoBytesWrite(blkio.get("io_bytes_write"));
        stats.setMaxUsage(memory.get("max_usage"));
        stats.setUsage(memory.get("usage"));
        stats.setLimit(memory.get("limit"));

        stats.setNetworks(extractNetworksStats(statistics.getNetworks()));


        return stats;
    }