diff --git a/LICENSE-binary b/LICENSE-binary index aaa7a93867fc9..da4f2d420551b 100644 --- a/LICENSE-binary +++ b/LICENSE-binary @@ -281,6 +281,7 @@ MIT License ------------ org.slf4j:slf4j-api:2.0.9 com.bugsnag:bugsnag:3.7.2 +com.github.oshi:6.4.0 EPL 1.0 diff --git a/dependencies.json b/dependencies.json index 2859f95cfa32b..e6eb0b0301b89 100644 --- a/dependencies.json +++ b/dependencies.json @@ -17,6 +17,7 @@ "com.github.ben-manes.caffeine:caffeine", "com.github.luben:zstd-jni", "com.github.moquette-io.moquette:moquette-broker", + "com.github.oshi:oshi-core", "com.github.stephenc.jcip:jcip-annotations", "com.github.wendykierp:JTransforms", "com.google.code.findbugs:jsr305", diff --git a/iotdb-core/datanode/pom.xml b/iotdb-core/datanode/pom.xml index bbb8020537fc5..7ffd4b30e38de 100644 --- a/iotdb-core/datanode/pom.xml +++ b/iotdb-core/datanode/pom.xml @@ -371,6 +371,10 @@ 1.3.0 test + + com.github.oshi + oshi-core + diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/service/metrics/file/SystemRelatedFileMetrics.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/service/metrics/file/SystemRelatedFileMetrics.java index 3fac0d10a167c..a225dd63123ff 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/service/metrics/file/SystemRelatedFileMetrics.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/service/metrics/file/SystemRelatedFileMetrics.java @@ -31,6 +31,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import oshi.SystemInfo; import java.io.BufferedReader; import java.io.File; @@ -52,7 +53,9 @@ public SystemRelatedFileMetrics() { @Override public void bindTo(AbstractMetricService metricService) { - if ((CONFIG.getSystemType() == SystemType.LINUX || CONFIG.getSystemType() == SystemType.MAC) + if ((CONFIG.getSystemType() == SystemType.LINUX + || CONFIG.getSystemType() == SystemType.MAC + || CONFIG.getSystemType() == SystemType.WINDOWS) && !CONFIG.getPid().isEmpty()) { this.getOpenFileNumberCommand = new String[] {"/bin/sh", "-c", String.format("lsof -p %s | wc -l", CONFIG.getPid())}; @@ -88,6 +91,9 @@ private long getOpenFileHandlersNumber() { } } fdCount = Long.parseLong(result.toString().trim()); + } else if (CONFIG.getSystemType() == SystemType.WINDOWS) { + SystemInfo systemInfo = new SystemInfo(); + return systemInfo.getOperatingSystem().getCurrentProcess().getOpenFiles(); } } catch (IOException e) { LOGGER.warn("Failed to get open file number, because ", e); diff --git a/iotdb-core/metrics/interface/pom.xml b/iotdb-core/metrics/interface/pom.xml index f0709c62ff298..d2be9b8877de8 100644 --- a/iotdb-core/metrics/interface/pom.xml +++ b/iotdb-core/metrics/interface/pom.xml @@ -104,6 +104,10 @@ junit test + + com.github.oshi + oshi-core + diff --git a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/AbstractDiskMetricsManager.java b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/AbstractDiskMetricsManager.java new file mode 100644 index 0000000000000..0c769bafcd8f1 --- /dev/null +++ b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/AbstractDiskMetricsManager.java @@ -0,0 +1,130 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.iotdb.metrics.metricsets.disk; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +public abstract class AbstractDiskMetricsManager implements IDiskMetricsManager { + + public static final double BYTES_PER_KB = 1024.0; + // Disk IO status structure + protected Map lastReadOperationCountForDisk; + protected Map lastWriteOperationCountForDisk; + protected Map lastReadSizeForDisk; + protected Map lastWriteSizeForDisk; + protected Map lastReadTimeCostForDisk; + protected Map lastWriteTimeCostForDisk; + protected Map lastMergedReadCountForDisk; + protected Map lastMergedWriteCountForDisk; + protected Map lastReadSectorCountForDisk; + protected Map lastWriteSectorCountForDisk; + protected Map lastIoBusyTimeForDisk; + protected Map lastTimeInQueueForDisk; + protected Map incrementReadOperationCountForDisk; + protected Map incrementWriteOperationCountForDisk; + protected Map incrementReadSizeForDisk; + protected Map incrementWriteSizeForDisk; + protected Map incrementMergedReadOperationCountForDisk; + protected Map incrementMergedWriteOperationCountForDisk; + protected Map incrementReadTimeCostForDisk; + protected Map incrementWriteTimeCostForDisk; + protected Map incrementReadSectorCountForDisk; + protected Map incrementWriteSectorCountForDisk; + protected Map incrementIoBusyTimeForDisk; + protected Map incrementTimeInQueueForDisk; + protected long lastUpdateTime = 0L; + protected long updateInterval = 1L; + protected Set diskIdSet; + + public AbstractDiskMetricsManager() {} + + protected void init() { + collectDiskId(); + lastReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastReadSizeForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastWriteSizeForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastReadTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastWriteTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastMergedReadCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastMergedWriteCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastReadSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastWriteSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastIoBusyTimeForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + lastTimeInQueueForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementReadSizeForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementWriteSizeForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementMergedReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementMergedWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementReadTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementWriteTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementReadSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementWriteSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementIoBusyTimeForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + incrementTimeInQueueForDisk = new HashMap<>(diskIdSet.size() + 1, 1); + } + + protected void checkUpdate() { + if (System.currentTimeMillis() - lastUpdateTime + > IDiskMetricsManager.UPDATE_SMALLEST_INTERVAL) { + updateInfo(); + } + } + + @Override + public Map getIoUtilsPercentage() { + checkUpdate(); + Map utilsMap = new HashMap<>(incrementIoBusyTimeForDisk.size()); + for (Map.Entry entry : incrementIoBusyTimeForDisk.entrySet()) { + utilsMap.put(entry.getKey(), ((double) entry.getValue()) / updateInterval); + } + return utilsMap; + } + + protected void updateInfo() { + long currentTime = System.currentTimeMillis(); + updateInterval = currentTime - lastUpdateTime; + lastUpdateTime = currentTime; + } + + protected void updateSingleDiskInfo( + String diskId, long currentValue, Map lastMap, Map incrementMap) { + if (incrementMap != null) { + long lastValue = lastMap.getOrDefault(diskId, 0L); + if (lastValue != 0) { + incrementMap.put(diskId, currentValue - lastValue); + } else { + incrementMap.put(diskId, 0L); + } + } + lastMap.put(diskId, currentValue); + } + + @Override + public Set getDiskIds() { + return diskIdSet; + } + + protected abstract void collectDiskId(); +} diff --git a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/IDiskMetricsManager.java b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/IDiskMetricsManager.java index 67c2007965ea8..83a9f31122390 100644 --- a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/IDiskMetricsManager.java +++ b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/IDiskMetricsManager.java @@ -27,6 +27,9 @@ import java.util.Set; public interface IDiskMetricsManager { + + long UPDATE_SMALLEST_INTERVAL = 10000L; + default Map getReadDataSizeForDisk() { return Collections.emptyMap(); } diff --git a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/LinuxDiskMetricsManager.java b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/LinuxDiskMetricsManager.java index 730b3490d44e8..300dac9ecd8e9 100644 --- a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/LinuxDiskMetricsManager.java +++ b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/LinuxDiskMetricsManager.java @@ -33,7 +33,6 @@ import java.util.Map; import java.util.Objects; import java.util.Scanner; -import java.util.Set; import java.util.stream.Collectors; /** @@ -49,7 +48,7 @@ * system call count, write system call count, byte attempt to read, byte attempt to write, * cancelled write byte. */ -public class LinuxDiskMetricsManager implements IDiskMetricsManager { +public class LinuxDiskMetricsManager extends AbstractDiskMetricsManager { private static final Logger LOGGER = LoggerFactory.getLogger(LinuxDiskMetricsManager.class); @SuppressWarnings("squid:S1075") @@ -74,34 +73,7 @@ public class LinuxDiskMetricsManager implements IDiskMetricsManager { private static final int DISK_IO_TOTAL_TIME_OFFSET = 13; private static final int DISK_TIME_IN_QUEUE_OFFSET = 14; private static final int DEFAULT_SECTOR_SIZE = 512; - private static final double BYTES_PER_KB = 1024.0; - private static final long UPDATE_SMALLEST_INTERVAL = 10000L; - private Set diskIdSet; private final Map diskSectorSizeMap; - private long lastUpdateTime = 0L; - private long updateInterval = 1L; - - // Disk IO status structure - private final Map lastReadOperationCountForDisk; - private final Map lastWriteOperationCountForDisk; - private final Map lastReadTimeCostForDisk; - private final Map lastWriteTimeCostForDisk; - private final Map lastMergedReadCountForDisk; - private final Map lastMergedWriteCountForDisk; - private final Map lastReadSectorCountForDisk; - private final Map lastWriteSectorCountForDisk; - private final Map lastIoBusyTimeForDisk; - private final Map lastTimeInQueueForDisk; - private final Map incrementReadOperationCountForDisk; - private final Map incrementWriteOperationCountForDisk; - private final Map incrementMergedReadOperationCountForDisk; - private final Map incrementMergedWriteOperationCountForDisk; - private final Map incrementReadTimeCostForDisk; - private final Map incrementWriteTimeCostForDisk; - private final Map incrementReadSectorCountForDisk; - private final Map incrementWriteSectorCountForDisk; - private final Map incrementIoBusyTimeForDisk; - private final Map incrementTimeInQueueForDisk; // Process IO status structure private long lastReallyReadSizeForProcess = 0L; @@ -112,33 +84,13 @@ public class LinuxDiskMetricsManager implements IDiskMetricsManager { private long lastWriteOpsCountForProcess = 0L; public LinuxDiskMetricsManager() { + init(); processIoStatusPath = String.format( "/proc/%s/io", MetricConfigDescriptor.getInstance().getMetricConfig().getPid()); - collectDiskId(); // leave one entry to avoid hashmap resizing diskSectorSizeMap = new HashMap<>(diskIdSet.size() + 1, 1); collectDiskInfo(); - lastReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastReadTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastWriteTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastMergedReadCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastMergedWriteCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastReadSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastWriteSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastIoBusyTimeForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - lastTimeInQueueForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementMergedReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementMergedWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementReadTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementWriteTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementReadSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementWriteSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementIoBusyTimeForDisk = new HashMap<>(diskIdSet.size() + 1, 1); - incrementTimeInQueueForDisk = new HashMap<>(diskIdSet.size() + 1, 1); } @Override @@ -184,15 +136,6 @@ public Map getWriteCostTimeForDisk() { return lastWriteTimeCostForDisk; } - @Override - public Map getIoUtilsPercentage() { - Map utilsMap = new HashMap<>(diskIdSet.size()); - for (Map.Entry entry : incrementIoBusyTimeForDisk.entrySet()) { - utilsMap.put(entry.getKey(), ((double) entry.getValue()) / updateInterval); - } - return utilsMap; - } - @Override public Map getAvgReadCostTimeOfEachOpsForDisk() { Map avgReadTimeCostMap = new HashMap<>(diskIdSet.size()); @@ -318,11 +261,7 @@ public double getAttemptWriteSizeForProcess() { } @Override - public Set getDiskIds() { - return diskIdSet; - } - - private void collectDiskId() { + protected void collectDiskId() { File diskIdFolder = new File(DISK_ID_PATH); if (!diskIdFolder.exists()) { return; @@ -355,10 +294,9 @@ private void collectDiskInfo() { } } - private void updateInfo() { - long currentTime = System.currentTimeMillis(); - updateInterval = currentTime - lastUpdateTime; - lastUpdateTime = currentTime; + @Override + protected void updateInfo() { + super.updateInfo(); updateDiskInfo(); updateProcessInfo(); } @@ -430,15 +368,7 @@ private void updateSingleDiskInfo( Map lastMap, Map incrementMap) { long currentValue = Long.parseLong(diskInfo[offset]); - if (incrementMap != null) { - long lastValue = lastMap.getOrDefault(diskId, 0L); - if (lastValue != 0) { - incrementMap.put(diskId, currentValue - lastValue); - } else { - incrementMap.put(diskId, 0L); - } - } - lastMap.put(diskId, currentValue); + updateSingleDiskInfo(diskId, currentValue, lastMap, incrementMap); } private void updateProcessInfo() { @@ -469,10 +399,4 @@ private void updateProcessInfo() { LOGGER.error("Meets error while updating process io info", e); } } - - private void checkUpdate() { - if (System.currentTimeMillis() - lastUpdateTime > UPDATE_SMALLEST_INTERVAL) { - updateInfo(); - } - } } diff --git a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/WindowsDiskMetricsManager.java b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/WindowsDiskMetricsManager.java index 975576ac90439..b8961bd9b9ce4 100644 --- a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/WindowsDiskMetricsManager.java +++ b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/WindowsDiskMetricsManager.java @@ -19,5 +19,172 @@ package org.apache.iotdb.metrics.metricsets.disk; +import oshi.SystemInfo; +import oshi.hardware.HWDiskStore; +import oshi.software.os.OSProcess; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + /** Disk Metrics Manager for Windows system, not implemented yet. */ -public class WindowsDiskMetricsManager implements IDiskMetricsManager {} +@SuppressWarnings({"rawtypes", "unchecked"}) +public class WindowsDiskMetricsManager extends AbstractDiskMetricsManager { + + private final SystemInfo systemInfo = new SystemInfo(); + private final OSProcess thisProcess; + private List diskStores; + + public WindowsDiskMetricsManager() { + thisProcess = systemInfo.getOperatingSystem().getCurrentProcess(); + diskStores = systemInfo.getHardware().getDiskStores(); + init(); + } + + @Override + public Map getReadDataSizeForDisk() { + checkUpdate(); + Map result = new HashMap<>(); + diskStores.forEach( + disk -> { + result.put(this.getDisplayName(disk), (double) disk.getReadBytes() / BYTES_PER_KB); + }); + return result; + } + + @Override + public Map getWriteDataSizeForDisk() { + checkUpdate(); + Map result = new HashMap<>(); + diskStores.forEach( + disk -> { + result.put(this.getDisplayName(disk), (double) disk.getWriteBytes() / BYTES_PER_KB); + }); + return result; + } + + @Override + public Map getReadOperationCountForDisk() { + checkUpdate(); + Map result = new HashMap<>(); + diskStores.forEach( + disk -> { + result.put(this.getDisplayName(disk), disk.getReads()); + }); + return result; + } + + @Override + public Map getWriteOperationCountForDisk() { + checkUpdate(); + Map result = new HashMap<>(); + diskStores.forEach( + disk -> { + result.put(this.getDisplayName(disk), disk.getWrites()); + }); + return result; + } + + private Map getTransferTimesForDisk() { + checkUpdate(); + Map result = new HashMap<>(); + diskStores.forEach( + disk -> { + result.put(this.getDisplayName(disk), disk.getTransferTime()); + }); + return result; + } + + @Override + public Map getQueueSizeForDisk() { + checkUpdate(); + Map result = new HashMap<>(); + diskStores.forEach( + disk -> { + result.put(this.getDisplayName(disk), (double) disk.getCurrentQueueLength()); + }); + return result; + } + + @Override + public double getActualReadDataSizeForProcess() { + return thisProcess.getBytesRead() / BYTES_PER_KB; + } + + @Override + public double getActualWriteDataSizeForProcess() { + return thisProcess.getBytesWritten() / BYTES_PER_KB; + } + + @Override + public Map getAvgSizeOfEachReadForDisk() { + checkUpdate(); + Map result = new HashMap<>(incrementReadSizeForDisk.size()); + for (Map.Entry incrementReadSize : incrementReadSizeForDisk.entrySet()) { + // use Long.max to avoid NaN + long readOpsCount = + Long.max( + incrementReadOperationCountForDisk.getOrDefault(incrementReadSize.getKey(), 1L), 1L); + result.put( + incrementReadSize.getKey(), ((double) incrementReadSize.getValue()) / readOpsCount); + } + return result; + } + + @Override + public Map getAvgSizeOfEachWriteForDisk() { + checkUpdate(); + Map result = new HashMap<>(incrementWriteSizeForDisk.size()); + for (Map.Entry incrementReadSize : incrementWriteSizeForDisk.entrySet()) { + // use Long.max to avoid NaN + long readOpsCount = + Long.max( + incrementWriteOperationCountForDisk.getOrDefault(incrementReadSize.getKey(), 1L), 1L); + result.put( + incrementReadSize.getKey(), ((double) incrementReadSize.getValue()) / readOpsCount); + } + return result; + } + + protected void updateInfo() { + super.updateInfo(); + updateDiskInfo(); + } + + private void updateDiskInfo() { + diskStores = systemInfo.getHardware().getDiskStores(); + + Map[] currentMapArray = { + getTransferTimesForDisk(), getReadDataSizeForDisk(), getWriteDataSizeForDisk(), + }; + Map[] lastMapArray = { + lastIoBusyTimeForDisk, lastReadSizeForDisk, lastWriteSizeForDisk, + }; + Map[] incrementMapArray = { + incrementIoBusyTimeForDisk, incrementReadSizeForDisk, incrementWriteSizeForDisk, + }; + + for (int i = 0; i < currentMapArray.length; i++) { + Map map = currentMapArray[i]; + int finalI = i; + map.forEach( + (key, value) -> { + updateSingleDiskInfo( + (String) key, + ((Number) value).longValue(), + lastMapArray[finalI], + incrementMapArray[finalI]); + }); + } + } + + private String getDisplayName(HWDiskStore disk) { + return disk.getName() + "-" + disk.getModel(); + } + + @Override + protected void collectDiskId() { + diskIdSet = diskStores.stream().map(this::getDisplayName).collect(Collectors.toSet()); + } +} diff --git a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/net/WindowsNetMetricManager.java b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/net/WindowsNetMetricManager.java index c3ecb4b8d5028..b8497ec0c1681 100644 --- a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/net/WindowsNetMetricManager.java +++ b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/net/WindowsNetMetricManager.java @@ -19,4 +19,86 @@ package org.apache.iotdb.metrics.metricsets.net; -public class WindowsNetMetricManager implements INetMetricManager {} +import oshi.SystemInfo; +import oshi.hardware.NetworkIF; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +public class WindowsNetMetricManager implements INetMetricManager { + private final SystemInfo systemInfo = new SystemInfo(); + private final int pid; + + public WindowsNetMetricManager() { + this.pid = systemInfo.getOperatingSystem().getCurrentProcess().getProcessID(); + } + + @Override + public Map getReceivedByte() { + Map result = new HashMap<>(); + systemInfo + .getHardware() + .getNetworkIFs() + .forEach( + (networkIF) -> { + result.put(networkIF.getDisplayName(), networkIF.getBytesRecv()); + }); + return result; + } + + @Override + public Map getTransmittedBytes() { + Map result = new HashMap<>(); + systemInfo + .getHardware() + .getNetworkIFs() + .forEach( + (networkIF) -> { + result.put(networkIF.getDisplayName(), networkIF.getBytesSent()); + }); + return result; + } + + @Override + public Map getReceivedPackets() { + Map result = new HashMap<>(); + systemInfo + .getHardware() + .getNetworkIFs() + .forEach( + (networkIF) -> { + result.put(networkIF.getDisplayName(), networkIF.getPacketsRecv()); + }); + return result; + } + + @Override + public Map getTransmittedPackets() { + Map result = new HashMap<>(); + systemInfo + .getHardware() + .getNetworkIFs() + .forEach( + (networkIF) -> { + result.put(networkIF.getDisplayName(), networkIF.getPacketsSent()); + }); + return result; + } + + @Override + public Set getIfaceSet() { + return systemInfo.getHardware().getNetworkIFs().stream() + .map(NetworkIF::getDisplayName) + .collect(Collectors.toSet()); + } + + @Override + public int getConnectionNum() { + return (int) + systemInfo.getOperatingSystem().getInternetProtocolStats().getConnections().stream() + .filter(conn -> conn.getowningProcessId() == pid) + .count(); + } +} diff --git a/pom.xml b/pom.xml index b0e56f0308d7a..18896da00a50d 100644 --- a/pom.xml +++ b/pom.xml @@ -103,6 +103,7 @@ 1.0-1 2.40 + 6.4.0 9.4.57.v20241219 0.12.7 @@ -695,6 +696,11 @@ jersey-hk2 ${jersey.version} + + com.github.oshi + oshi-core + ${oshi.version} +