1037 lines
30 KiB
Java
1037 lines
30 KiB
Java
/*
|
|
* Copyright (c) 2006-2009 Hyperic, Inc.
|
|
* Copyright (c) 2010 VMware, Inc.
|
|
*
|
|
* Licensed 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.hyperic.sigar;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.StringTokenizer;
|
|
|
|
import org.hyperic.jni.ArchLoaderException;
|
|
import org.hyperic.jni.ArchNotSupportedException;
|
|
|
|
import org.hyperic.sigar.ptql.ProcessFinder;
|
|
|
|
/**
|
|
* The Sigar class provides access to the sigar objects containing
|
|
* system information. The Sigar object itself maintains internal
|
|
* state specific to each platform. It also implements the SigarProxy
|
|
* interface which provides caching at the Java level.
|
|
*/
|
|
public class Sigar implements SigarProxy {
|
|
|
|
private static String loadError = null;
|
|
|
|
public static final long FIELD_NOTIMPL = -1;
|
|
public static final int PID_PROC_CPU_CACHE = 1;
|
|
public static final int PID_PROC_IO_CACHE = 2;
|
|
|
|
/**
|
|
* The Sigar java version.
|
|
*/
|
|
public static final String VERSION_STRING =
|
|
Version.VERSION_STRING;
|
|
|
|
/**
|
|
* The Sigar native version.
|
|
*/
|
|
public static final String NATIVE_VERSION_STRING;
|
|
|
|
/**
|
|
* The scm (svn) revision from which sigar.jar was built.
|
|
*/
|
|
public static final String SCM_REVISION =
|
|
Version.SCM_REVISION;
|
|
|
|
/**
|
|
* The scm (svn) revision from which the sigar native binary was built.
|
|
*/
|
|
public static final String NATIVE_SCM_REVISION;
|
|
|
|
/**
|
|
* The date on which sigar.jar was built.
|
|
*/
|
|
public static final String BUILD_DATE =
|
|
Version.BUILD_DATE;
|
|
|
|
/**
|
|
* The date on which the sigar native binary was built.
|
|
*/
|
|
public static final String NATIVE_BUILD_DATE;
|
|
|
|
private static boolean enableLogging =
|
|
"true".equals(System.getProperty("sigar.nativeLogging"));
|
|
|
|
private static SigarLoader loader = new SigarLoader(Sigar.class);
|
|
private FileSystemMap mounts = null;
|
|
|
|
private boolean open = false;
|
|
int sigarWrapper = 0; //holds the sigar_t *
|
|
long longSigarWrapper = 0; //same, but where sizeof(void*) > sizeof(int)
|
|
|
|
// lastCpu is used to calculate the cpuPerc;
|
|
private Cpu lastCpu;
|
|
private Cpu[] lastCpuList;
|
|
|
|
private ProcessFinder processFinder = null;
|
|
|
|
static {
|
|
String nativeVersion = "unknown";
|
|
String nativeBuildDate = "unknown";
|
|
String nativeScmRevision = "unknown";
|
|
|
|
try {
|
|
loadLibrary();
|
|
nativeVersion = getNativeVersion();
|
|
nativeBuildDate = getNativeBuildDate();
|
|
nativeScmRevision = getNativeScmRevision();
|
|
checkVersion(nativeVersion);
|
|
} catch (SigarException e) {
|
|
loadError = e.getMessage();
|
|
try {
|
|
SigarLog.debug(loadError, e);
|
|
} catch (NoClassDefFoundError ne) {
|
|
//no log4j.jar
|
|
System.err.println(loadError);
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
NATIVE_VERSION_STRING = nativeVersion;
|
|
NATIVE_BUILD_DATE = nativeBuildDate;
|
|
NATIVE_SCM_REVISION = nativeScmRevision;
|
|
}
|
|
|
|
private static void checkVersion(String nativeVersionString)
|
|
throws SigarException {
|
|
|
|
StringTokenizer javaVersion =
|
|
new StringTokenizer(VERSION_STRING, ".");
|
|
StringTokenizer nativeVersion =
|
|
new StringTokenizer(nativeVersionString, ".");
|
|
|
|
String[] desc = { "major", "minor" };
|
|
|
|
for (int i=0; i<desc.length; i++) {
|
|
String jv =
|
|
javaVersion.hasMoreTokens() ?
|
|
javaVersion.nextToken() : "0";
|
|
String nv =
|
|
nativeVersion.hasMoreTokens() ?
|
|
nativeVersion.nextToken() : "0";
|
|
|
|
if (!jv.equals(nv)) {
|
|
String msg =
|
|
desc[i] + " version mismatch: (" +
|
|
jv + "!=" + nv + ") " +
|
|
"java=" + VERSION_STRING +
|
|
", native=" + nativeVersionString;
|
|
throw new SigarException(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void load() throws SigarException {
|
|
if (loadError != null) {
|
|
throw new SigarException(loadError);
|
|
}
|
|
}
|
|
|
|
private static void loadLibrary() throws SigarException {
|
|
if (SigarLoader.IS_WIN32 &&
|
|
System.getProperty("os.version").equals("4.0"))
|
|
{
|
|
try {
|
|
//NT 4.0 only
|
|
String lib =
|
|
loader.findJarPath("pdh.dll") +
|
|
File.separator + "pdh.dll";
|
|
loader.systemLoad(lib);
|
|
} catch (Exception e) {}
|
|
}
|
|
|
|
try {
|
|
loader.load();
|
|
} catch (ArchNotSupportedException e) {
|
|
throw new SigarException(e.getMessage());
|
|
} catch (ArchLoaderException e) {
|
|
throw new SigarException(e.getMessage());
|
|
} catch (UnsatisfiedLinkError e) {
|
|
throw new SigarException(e.getMessage());
|
|
}
|
|
}
|
|
|
|
public File getNativeLibrary() {
|
|
return loader.getNativeLibrary();
|
|
}
|
|
|
|
/**
|
|
* Format size in bytes to a human readable string.
|
|
*
|
|
* @param size The size to format.
|
|
* @return The formatted string.
|
|
*/
|
|
public static native String formatSize(long size);
|
|
|
|
private static native String getNativeVersion();
|
|
private static native String getNativeBuildDate();
|
|
private static native String getNativeScmRevision();
|
|
|
|
/**
|
|
* Allocate and initialize the native Sigar object.
|
|
*/
|
|
public Sigar() {
|
|
try {
|
|
open();
|
|
this.open = true;
|
|
} catch (SigarException e) {
|
|
if (enableLogging) {
|
|
e.printStackTrace();
|
|
}
|
|
} catch (UnsatisfiedLinkError e) {
|
|
if (enableLogging) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
if (enableLogging) {
|
|
enableLogging(true);
|
|
}
|
|
}
|
|
|
|
protected void finalize() {
|
|
close();
|
|
}
|
|
|
|
private native void open() throws SigarException;
|
|
|
|
/**
|
|
* Release any native resources associated with this sigar instance.
|
|
* The sigar object is no longer usable after it has been closed.
|
|
* If the close method is not called directly, the finalize method will
|
|
* call it if the Sigar object is garbage collected.
|
|
*/
|
|
public synchronized void close() {
|
|
if (this.open) {
|
|
nativeClose();
|
|
this.open = false;
|
|
}
|
|
}
|
|
|
|
private native int nativeClose();
|
|
|
|
/**
|
|
* Get pid of the current process.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native long getPid();
|
|
|
|
|
|
/**
|
|
* Get pid for the Windows service with the given name.
|
|
* This method is implemented on Windows only as a helper
|
|
* for PTQL.
|
|
*/
|
|
public native long getServicePid(String name) throws SigarException;
|
|
|
|
/**
|
|
* Send a signal to a process.
|
|
*
|
|
* @param pid The process id.
|
|
* @param signum The signal number.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native void kill(long pid, int signum) throws SigarException;
|
|
|
|
/**
|
|
* Send a signal to a process.
|
|
*
|
|
* @param pid The process id.
|
|
* @param signame The signal name.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public void kill(long pid, String signame) throws SigarException {
|
|
int signum;
|
|
|
|
if (Character.isDigit(signame.charAt(0))) {
|
|
try {
|
|
signum = Integer.parseInt(signame);
|
|
} catch (NumberFormatException e) {
|
|
signum = -1;
|
|
}
|
|
}
|
|
else {
|
|
signum = getSigNum(signame);
|
|
}
|
|
|
|
if (signum < 0) {
|
|
throw new SigarException(signame +
|
|
": invalid signal specification");
|
|
}
|
|
|
|
kill(pid, signum);
|
|
}
|
|
|
|
public static native int getSigNum(String name);
|
|
|
|
/**
|
|
* Send a signal to a process.
|
|
*
|
|
* @param pid The process id or query.
|
|
* @param signum The signal number.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public void kill(String pid, int signum) throws SigarException {
|
|
kill(convertPid(pid), signum);
|
|
}
|
|
|
|
/**
|
|
* Get system memory info.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public Mem getMem() throws SigarException {
|
|
return Mem.fetch(this);
|
|
}
|
|
|
|
/**
|
|
* Get system swap info.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public Swap getSwap() throws SigarException {
|
|
return Swap.fetch(this);
|
|
}
|
|
|
|
/**
|
|
* Get system cpu info.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public Cpu getCpu() throws SigarException {
|
|
return Cpu.fetch(this);
|
|
}
|
|
|
|
static void pause(int millis) {
|
|
try {
|
|
Thread.sleep(millis);
|
|
} catch(InterruptedException e) { }
|
|
}
|
|
|
|
static void pause() {
|
|
pause(500);
|
|
}
|
|
|
|
/**
|
|
* Get system CPU info in percentage format. (i.e. fraction of 1)
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public CpuPerc getCpuPerc() throws SigarException {
|
|
Cpu oldCpu;
|
|
|
|
if (this.lastCpu == null){
|
|
oldCpu = getCpu();
|
|
pause();
|
|
}
|
|
else {
|
|
oldCpu = this.lastCpu;
|
|
}
|
|
|
|
this.lastCpu = getCpu();
|
|
|
|
return CpuPerc.fetch(this, oldCpu, this.lastCpu);
|
|
}
|
|
|
|
/**
|
|
* Get system per-CPU info in percentage format. (i.e. fraction of 1)
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public CpuPerc[] getCpuPercList() throws SigarException {
|
|
Cpu[] oldCpuList;
|
|
|
|
if (this.lastCpuList == null){
|
|
oldCpuList = getCpuList();
|
|
pause();
|
|
}
|
|
else {
|
|
oldCpuList = this.lastCpuList;
|
|
}
|
|
|
|
this.lastCpuList = getCpuList();
|
|
|
|
int curLen = this.lastCpuList.length;
|
|
int oldLen = oldCpuList.length;
|
|
|
|
CpuPerc[] perc =
|
|
new CpuPerc[curLen < oldLen ? curLen : oldLen];
|
|
|
|
for (int i=0; i<perc.length; i++) {
|
|
perc[i] =
|
|
CpuPerc.fetch(this, oldCpuList[i],
|
|
this.lastCpuList[i]);
|
|
}
|
|
|
|
return perc;
|
|
}
|
|
|
|
/**
|
|
* Get system resource limits.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ResourceLimit getResourceLimit() throws SigarException {
|
|
return ResourceLimit.fetch(this);
|
|
}
|
|
|
|
/**
|
|
* Get system uptime info.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public Uptime getUptime() throws SigarException {
|
|
return Uptime.fetch(this);
|
|
}
|
|
|
|
/**
|
|
* Get system load average.
|
|
* @exception SigarException on failure.
|
|
* @return The system load averages for the past 1, 5, and 15 minutes.
|
|
*/
|
|
public native double[] getLoadAverage() throws SigarException;
|
|
|
|
/**
|
|
* Get system process list.
|
|
* @exception SigarException on failure.
|
|
* @return Array of process ids.
|
|
*/
|
|
public native long[] getProcList() throws SigarException;
|
|
|
|
/**
|
|
* Get system process stats.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcStat getProcStat() throws SigarException {
|
|
return ProcStat.fetch(this);
|
|
}
|
|
|
|
private long convertPid(String pid) throws SigarException {
|
|
if (pid.equals("$$")) {
|
|
return getPid();
|
|
}
|
|
else if (Character.isDigit(pid.charAt(0))) {
|
|
return Long.parseLong(pid);
|
|
}
|
|
else {
|
|
if (this.processFinder == null) {
|
|
this.processFinder = new ProcessFinder(this);
|
|
}
|
|
|
|
return this.processFinder.findSingleProcess(pid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get process memory info.
|
|
* @param pid The process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcMem getProcMem(long pid) throws SigarException {
|
|
return ProcMem.fetch(this, pid);
|
|
}
|
|
|
|
public ProcMem getProcMem(String pid) throws SigarException {
|
|
return getProcMem(convertPid(pid));
|
|
}
|
|
|
|
public ProcMem getMultiProcMem(String query) throws SigarException {
|
|
return MultiProcMem.get(this, query);
|
|
}
|
|
|
|
/**
|
|
* Get process state info.
|
|
* @param pid The process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcState getProcState(long pid) throws SigarException {
|
|
return ProcState.fetch(this, pid);
|
|
}
|
|
|
|
public ProcState getProcState(String pid) throws SigarException {
|
|
return getProcState(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process time info.
|
|
* @param pid The process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcTime getProcTime(long pid) throws SigarException {
|
|
return ProcTime.fetch(this, pid);
|
|
}
|
|
|
|
public ProcTime getProcTime(String pid) throws SigarException {
|
|
return getProcTime(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process cpu info.
|
|
* @param pid The process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcCpu getProcCpu(long pid) throws SigarException {
|
|
return ProcCpu.fetch(this, pid);
|
|
}
|
|
|
|
public ProcCpu getProcCpu(String pid) throws SigarException {
|
|
return getProcCpu(convertPid(pid));
|
|
}
|
|
|
|
public MultiProcCpu getMultiProcCpu(String query) throws SigarException {
|
|
return MultiProcCpu.get(this, query);
|
|
}
|
|
|
|
/**
|
|
* Get process credential info.
|
|
* @param pid The process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcCred getProcCred(long pid) throws SigarException {
|
|
return ProcCred.fetch(this, pid);
|
|
}
|
|
|
|
public ProcCred getProcCred(String pid) throws SigarException {
|
|
return getProcCred(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process credential names.
|
|
* @param pid The process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcCredName getProcCredName(long pid) throws SigarException {
|
|
return ProcCredName.fetch(this, pid);
|
|
}
|
|
|
|
public ProcCredName getProcCredName(String pid) throws SigarException {
|
|
return getProcCredName(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process file descriptor info.
|
|
* @param pid The process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcFd getProcFd(long pid) throws SigarException {
|
|
return ProcFd.fetch(this, pid);
|
|
}
|
|
|
|
public ProcFd getProcFd(String pid) throws SigarException {
|
|
return getProcFd(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process current working directory.
|
|
* @param pid The process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcExe getProcExe(long pid) throws SigarException {
|
|
return ProcExe.fetch(this, pid);
|
|
}
|
|
|
|
public ProcExe getProcExe(String pid) throws SigarException {
|
|
return getProcExe(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process arguments.
|
|
* @param pid The process id.
|
|
* @return Array of argument strings.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native String[] getProcArgs(long pid) throws SigarException;
|
|
|
|
public String[] getProcArgs(String pid) throws SigarException {
|
|
return getProcArgs(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process environment.
|
|
* @param pid The process id.
|
|
* @return Map of environment strings.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public Map getProcEnv(long pid) throws SigarException {
|
|
return ProcEnv.getAll(this, pid);
|
|
}
|
|
|
|
public Map getProcEnv(String pid) throws SigarException {
|
|
return getProcEnv(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process environment variable value.
|
|
* This method is intended to avoid the overhead
|
|
* of creating a Map with all variables if only
|
|
* a single variable is needed.
|
|
* @param pid The process id.
|
|
* @param key Environment variable name.
|
|
* @return Environment variable value.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public String getProcEnv(long pid, String key) throws SigarException {
|
|
return ProcEnv.getValue(this, pid, key);
|
|
}
|
|
|
|
public String getProcEnv(String pid, String key) throws SigarException {
|
|
return getProcEnv(convertPid(pid), key);
|
|
}
|
|
|
|
/**
|
|
* Get process loaded modules.<p>
|
|
* Supported Platforms: Linux, Solaris and Windows.
|
|
* @param pid The process id.
|
|
* @return List of loaded modules.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
private native List getProcModulesNative(long pid) throws SigarException;
|
|
|
|
public List getProcModules(long pid) throws SigarException {
|
|
return getProcModulesNative(pid);
|
|
}
|
|
|
|
public List getProcModules(String pid) throws SigarException {
|
|
return getProcModules(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Find the pid of the process which is listening on the given port.<p>
|
|
* Supported Platforms: Linux, Windows 2003, Windows XP, AIX.
|
|
* @param protocol NetFlags.CONN_TCP or NetFlags.CONN_UDP.
|
|
* @param port The port number.
|
|
* @return pid of the process.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native long getProcPort(int protocol, long port)
|
|
throws SigarException;
|
|
|
|
/**
|
|
* @param protocol "tcp" or "udp".
|
|
* @param port The port number.
|
|
* @return pid of the process.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public long getProcPort(String protocol, String port)
|
|
throws SigarException {
|
|
|
|
return getProcPort(NetFlags.getConnectionProtocol(protocol),
|
|
Integer.parseInt(port));
|
|
}
|
|
|
|
/**
|
|
* Get process disk IO info.
|
|
* @param pid THe process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcDiskIO getProcDiskIO(long pid) throws SigarException {
|
|
try {
|
|
return ProcDiskIO.fetch(this, pid);
|
|
} catch (UnsatisfiedLinkError linkErrorException) {
|
|
// We want to handle exceptions gracefully even if the linked
|
|
// shared library is older and isn't compiled with the ProcDiskIO APIs.
|
|
// The downside of this is that we throw SigarNotImplemented exception
|
|
// also when the shared library can't be loaded.
|
|
SigarException sigarException = new SigarNotImplementedException();
|
|
sigarException.initCause(linkErrorException);
|
|
throw sigarException;
|
|
}
|
|
}
|
|
|
|
public ProcDiskIO getProcDiskIO(String pid) throws SigarException {
|
|
return getProcDiskIO(convertPid(pid));
|
|
}
|
|
|
|
/**
|
|
* Get process cumulative disk IO info.
|
|
* @param pid THe process id.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public ProcCumulativeDiskIO getProcCumulativeDiskIO(long pid) throws SigarException {
|
|
try {
|
|
return ProcCumulativeDiskIO.fetch(this, pid);
|
|
} catch (UnsatisfiedLinkError linkErrorException) {
|
|
// We want to handle exceptions gracefully even if the linked
|
|
// shared library is older and isn't compiled with the ProcDiskIO APIs.
|
|
// The downside of this is that we throw SigarNotImplemented exception
|
|
// also when the shared library can't be loaded.
|
|
SigarException sigarException = new SigarNotImplementedException();
|
|
sigarException.initCause(linkErrorException);
|
|
throw sigarException;
|
|
}
|
|
}
|
|
|
|
public ProcCumulativeDiskIO getProcCumulativeDiskIO(String pid) throws SigarException {
|
|
return getProcCumulativeDiskIO(convertPid(pid));
|
|
}
|
|
|
|
public DumpPidCache dumpPidCache() throws SigarException {
|
|
return DumpPidCache.fetch(this);
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the cumulative cpu time for the calling thread.
|
|
*/
|
|
public ThreadCpu getThreadCpu() throws SigarException {
|
|
return ThreadCpu.fetch(this, 0);
|
|
}
|
|
|
|
private native FileSystem[] getFileSystemListNative() throws SigarException;
|
|
|
|
/**
|
|
* Get list of file systems.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public FileSystem[] getFileSystemList() throws SigarException {
|
|
FileSystem[] fslist = getFileSystemListNative();
|
|
if (this.mounts != null) {
|
|
this.mounts.init(fslist);
|
|
}
|
|
return fslist;
|
|
}
|
|
|
|
/**
|
|
* Get file system usage.
|
|
* @param name Name of the directory on which filesystem is mounted.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public FileSystemUsage getFileSystemUsage(String name)
|
|
throws SigarException {
|
|
if (name == null) {
|
|
throw new SigarException("name cannot be null");
|
|
}
|
|
return FileSystemUsage.fetch(this, name);
|
|
}
|
|
|
|
/**
|
|
* Get disk usage.
|
|
* @param name Name of disk
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public DiskUsage getDiskUsage(String name)
|
|
throws SigarException {
|
|
if (name == null) {
|
|
throw new SigarException("name cannot be null");
|
|
}
|
|
return DiskUsage.fetch(this, name);
|
|
}
|
|
|
|
/**
|
|
* Get file system usage of a mounted directory.
|
|
* This method checks that the given directory is mounted.
|
|
* Unlike getFileSystemUsage() which only requires that the
|
|
* directory exists within a mounted file system.
|
|
* This method will also check that NFS servers are reachable via RPC
|
|
* before attempting to get the file system stats to prevent application
|
|
* hang when an NFS server is down.
|
|
* @param name Name of the directory on which filesystem is mounted.
|
|
* @exception SigarException If given directory is not mounted.
|
|
* @exception NfsUnreachableException If NFS server is unreachable.
|
|
* @see org.hyperic.sigar.Sigar#getFileSystemUsage
|
|
*/
|
|
public FileSystemUsage getMountedFileSystemUsage(String name)
|
|
throws SigarException, NfsUnreachableException {
|
|
|
|
FileSystem fs = getFileSystemMap().getFileSystem(name);
|
|
|
|
if (fs == null) {
|
|
throw new SigarException(name + " is not a mounted filesystem");
|
|
}
|
|
|
|
if (fs instanceof NfsFileSystem) {
|
|
NfsFileSystem nfs = (NfsFileSystem)fs;
|
|
if (!nfs.ping()) {
|
|
throw nfs.getUnreachableException();
|
|
}
|
|
}
|
|
|
|
return FileSystemUsage.fetch(this, name);
|
|
}
|
|
|
|
public FileSystemMap getFileSystemMap()
|
|
throws SigarException {
|
|
|
|
if (this.mounts == null) {
|
|
this.mounts = new FileSystemMap();
|
|
}
|
|
|
|
getFileSystemList(); //this.mounts.init()
|
|
|
|
return this.mounts;
|
|
}
|
|
|
|
public FileInfo getFileInfo(String name)
|
|
throws SigarException {
|
|
return FileInfo.fetchFileInfo(this, name);
|
|
}
|
|
|
|
public FileInfo getLinkInfo(String name)
|
|
throws SigarException {
|
|
return FileInfo.fetchLinkInfo(this, name);
|
|
}
|
|
|
|
public DirStat getDirStat(String name)
|
|
throws SigarException {
|
|
return DirStat.fetch(this, name);
|
|
}
|
|
|
|
public DirUsage getDirUsage(String name)
|
|
throws SigarException {
|
|
return DirUsage.fetch(this, name);
|
|
}
|
|
|
|
/**
|
|
* Get list of cpu infomation.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native CpuInfo[] getCpuInfoList() throws SigarException;
|
|
|
|
private native Cpu[] getCpuListNative() throws SigarException;
|
|
|
|
/**
|
|
* Get list of per-cpu metrics.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public Cpu[] getCpuList() throws SigarException {
|
|
return getCpuListNative();
|
|
}
|
|
|
|
/**
|
|
* Get list of network routes.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native NetRoute[] getNetRouteList() throws SigarException;
|
|
|
|
/**
|
|
* Get list of network connections.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native NetConnection[] getNetConnectionList(int flags)
|
|
throws SigarException;
|
|
|
|
/**
|
|
* Get the TCP listen address for the given port.
|
|
* If there is not a listener on the given port, null will be returned.
|
|
*/
|
|
public native String getNetListenAddress(long port)
|
|
throws SigarException;
|
|
|
|
public String getNetListenAddress(String port)
|
|
throws SigarException {
|
|
|
|
return getNetListenAddress(Long.parseLong(port));
|
|
}
|
|
|
|
public native String getNetServicesName(int protocol, long port);
|
|
|
|
public NetStat getNetStat()
|
|
throws SigarException {
|
|
NetStat netstat = new NetStat();
|
|
netstat.stat(this);
|
|
return netstat;
|
|
}
|
|
|
|
public NetStat getNetStat(byte[] address, long port)
|
|
throws SigarException {
|
|
NetStat netstat = new NetStat();
|
|
netstat.stat(this, address, port);
|
|
return netstat;
|
|
}
|
|
|
|
public native Arp[] getArpList()
|
|
throws SigarException;
|
|
|
|
public native Who[] getWhoList()
|
|
throws SigarException;
|
|
|
|
/**
|
|
* TCP-MIB stats
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public Tcp getTcp()
|
|
throws SigarException {
|
|
return Tcp.fetch(this);
|
|
}
|
|
|
|
public NfsClientV2 getNfsClientV2()
|
|
throws SigarException {
|
|
return NfsClientV2.fetch(this);
|
|
}
|
|
|
|
public NfsServerV2 getNfsServerV2()
|
|
throws SigarException {
|
|
return NfsServerV2.fetch(this);
|
|
}
|
|
|
|
public NfsClientV3 getNfsClientV3()
|
|
throws SigarException {
|
|
return NfsClientV3.fetch(this);
|
|
}
|
|
|
|
public NfsServerV3 getNfsServerV3()
|
|
throws SigarException {
|
|
return NfsServerV3.fetch(this);
|
|
}
|
|
|
|
/**
|
|
* Get general network info.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public NetInfo getNetInfo()
|
|
throws SigarException {
|
|
return NetInfo.fetch(this);
|
|
}
|
|
|
|
/**
|
|
* Get network interface configuration info.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public NetInterfaceConfig getNetInterfaceConfig(String name)
|
|
throws SigarException {
|
|
return NetInterfaceConfig.fetch(this, name);
|
|
}
|
|
|
|
/**
|
|
* Get default network interface configuration info.
|
|
* Iterates getNetInterfaceList(), returning the first
|
|
* available ethernet interface.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public NetInterfaceConfig getNetInterfaceConfig()
|
|
throws SigarException {
|
|
|
|
String[] interfaces = getNetInterfaceList();
|
|
|
|
for (int i=0; i<interfaces.length; i++) {
|
|
String name = interfaces[i];
|
|
NetInterfaceConfig ifconfig;
|
|
|
|
try {
|
|
ifconfig = getNetInterfaceConfig(name);
|
|
} catch (SigarException e) {
|
|
continue;
|
|
}
|
|
|
|
long flags = ifconfig.getFlags();
|
|
if ((flags & NetFlags.IFF_UP) <= 0) {
|
|
continue;
|
|
}
|
|
if ((flags & NetFlags.IFF_POINTOPOINT) > 0) {
|
|
continue;
|
|
}
|
|
if ((flags & NetFlags.IFF_LOOPBACK) > 0) {
|
|
continue;
|
|
}
|
|
|
|
return ifconfig;
|
|
}
|
|
|
|
String msg =
|
|
"No ethernet interface available";
|
|
throw new SigarException(msg);
|
|
}
|
|
|
|
/**
|
|
* Get network interface stats.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public NetInterfaceStat getNetInterfaceStat(String name)
|
|
throws SigarException {
|
|
return NetInterfaceStat.fetch(this, name);
|
|
}
|
|
|
|
/**
|
|
* Get the list of configured network interface names.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native String[] getNetInterfaceList() throws SigarException;
|
|
|
|
/**
|
|
* Prompt for a password, disabling terminal echo
|
|
* during user input.
|
|
* @param prompt Text printed before disabling echo
|
|
* @return Text entered by the user.
|
|
* @throws IOException If input could not be read.
|
|
* @throws SigarNotImplementedException If the native method
|
|
* is not implemented on the current platform.
|
|
*/
|
|
|
|
native static String getPasswordNative(String prompt)
|
|
throws IOException, SigarNotImplementedException;
|
|
|
|
/**
|
|
* Prompt for a password, disabling terminal echo
|
|
* during user input if possible.
|
|
* @param prompt Text printed before disabling echo
|
|
* @return Text entered by the user.
|
|
* @throws IOException If input could not be read.
|
|
*/
|
|
public static String getPassword(String prompt)
|
|
throws IOException
|
|
{
|
|
try {
|
|
return getPasswordNative(prompt);
|
|
} catch (IOException e) {
|
|
throw e;
|
|
} catch (SigarNotImplementedException e) {
|
|
//fallthrough
|
|
}
|
|
|
|
//fallback if native .so was not loaded or not supported
|
|
System.out.print(prompt);
|
|
|
|
return (new BufferedReader(new InputStreamReader(System.in))).
|
|
readLine();
|
|
}
|
|
|
|
/**
|
|
* Reliably retrieve the FQDN for a machine
|
|
*
|
|
* @return The fully qualified domain name of the machine.
|
|
* @exception SigarException on failure.
|
|
*/
|
|
public native String getFQDN() throws SigarException;
|
|
|
|
public SigarVersion getSigarVersion() {
|
|
return new SigarVersion();
|
|
}
|
|
|
|
/**
|
|
* Enabling logging in the native Sigar code.
|
|
* This method will hook log4j into the Sigar
|
|
* native logging methods. Note that the majority
|
|
* of logging in the native code is only at the DEBUG
|
|
* level.
|
|
*/
|
|
public void enableLogging(boolean value) {
|
|
if (value) {
|
|
SigarLog.enable(this);
|
|
}
|
|
else {
|
|
SigarLog.disable(this);
|
|
}
|
|
}
|
|
}
|