private void checkCompatibility() {
OperatingSystemMXBean osmx = ManagementFactory.getOperatingSystemMXBean();
if (osmx == null) {
throw new UnsupportedOperationException("Failed to get OperatingSystemMXBean");
}
Class[] interfaces = osmx.getClass().getInterfaces();
boolean hasInterface = false;
if (interfaces != null) {
for (Class i : interfaces) {
if ("com.sun.management.OperatingSystemMXBean".equals(i.getName())
|| "com.sun.management.UnixOperatingSystemMXBean".equals(i.getName())) {
hasInterface = true;
break;
}
}
}
if (!hasInterface) {
throw new UnsupportedOperationException(
"Incompatible OperatingSystemMXBean class: " + osmx.getClass().getName());
}
RuntimeMXBean rtmx = ManagementFactory.getRuntimeMXBean();
if (rtmx == null) {
throw new UnsupportedOperationException("Failed to get RuntimeMXBean");
}
}
private long getCpuTime() {
OperatingSystemMXBean osmx = ManagementFactory.getOperatingSystemMXBean();
try {
Method getProcessCpuTime = osmx.getClass().getDeclaredMethod("getProcessCpuTime");
getProcessCpuTime.setAccessible(true);
Object o = getProcessCpuTime.invoke(osmx);
if (o instanceof Long) {
return (Long) o;
}
} catch (Throwable e) {
}
return 0L;
}
private Object invokeMethod(String methodName)
throws NoSuchMethodException, SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
final Method method = mxBean.getClass().getDeclaredMethod(methodName);
method.setAccessible(true);
return method.invoke(mxBean);
}
private void jvmSummary() {
OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean();
stdout.format(
"JVM: %s %s %s\n",
runtimeBean.getVmVendor(), runtimeBean.getVmName(), runtimeBean.getVmVersion());
stdout.format(" on %s %s %s\n", "", osBean.getName(), osBean.getVersion(), osBean.getArch());
try {
stdout.format(
" running as %s on %s\n",
System.getProperty("user.name"), InetAddress.getLocalHost().getHostName());
} catch (UnknownHostException e) {
}
stdout.format(" cwd %s\n", path(new File(".").getAbsoluteFile().getParentFile()));
stdout.format(" site %s\n", path(sitePath));
}
/* (non-Javadoc)
* @see org.epics.pvaccess.server.plugins.BeaconServerStatusProvider#getServerStatusData()
*/
public PVField getServerStatusData() {
status
.getIntField("connections")
.put(context.getTransportRegistry().numberOfActiveTransports());
status.getLongField("allocatedMemory").put(Runtime.getRuntime().totalMemory());
status.getLongField("freeMemory").put(Runtime.getRuntime().freeMemory());
ThreadMXBean threadMBean = ManagementFactory.getThreadMXBean();
status.getIntField("threads").put(threadMBean.getThreadCount());
final long[] deadlocks =
threadMBean.isSynchronizerUsageSupported()
? threadMBean.findDeadlockedThreads()
: threadMBean.findMonitorDeadlockedThreads();
status.getIntField("deadlocks").put((deadlocks != null) ? deadlocks.length : 0);
OperatingSystemMXBean osMBean = ManagementFactory.getOperatingSystemMXBean();
status.getDoubleField("averageSystemLoad").put(osMBean.getSystemLoadAverage());
return status;
}
@Override
public Map<String, Metric> getMetrics() {
final Map<String, Metric> gauges = new HashMap<String, Metric>();
double loadAverage = mxBean.getSystemLoadAverage();
if (Double.compare(loadAverage, 0.0d) >= 0) {
gauges.put(
"system.load.average",
new Gauge<Double>() {
@Override
public Double getValue() {
return mxBean.getSystemLoadAverage();
}
});
} else {
if (logger.isDebugEnabled()) {
logger.debug("System Load Average is not available as an Operating System Metric");
}
}
Gauge<Long> openFileDescriptorCountGauge = getLongGauge("getOpenFileDescriptorCount");
if (openFileDescriptorCountGauge != null) {
gauges.put("file.descriptor.open.count", openFileDescriptorCountGauge);
}
Gauge<Long> maxFileDescriptorCountGauge = getLongGauge("getMaxFileDescriptorCount");
if (maxFileDescriptorCountGauge != null) {
gauges.put("file.descriptor.max.count", maxFileDescriptorCountGauge);
}
Gauge<Double> processCpuLoadGauge = getDoubleGauge("getProcessCpuLoad");
if (processCpuLoadGauge != null) {
gauges.put("cpu.load.process", processCpuLoadGauge);
}
Gauge<Double> systemCpuLoadGauge = getDoubleGauge("getSystemCpuLoad");
if (systemCpuLoadGauge != null) {
gauges.put("cpu.load.system", systemCpuLoadGauge);
}
Gauge<Long> freePhysicalMemorySizeGauge = getLongGauge("getFreePhysicalMemorySize");
if (freePhysicalMemorySizeGauge != null) {
gauges.put("physical.memory.free.size", freePhysicalMemorySizeGauge);
}
Gauge<Long> totalPhysicalMemorySizeGauge = getLongGauge("getTotalPhysicalMemorySize");
if (totalPhysicalMemorySizeGauge != null) {
gauges.put("physical.memory.total.size", totalPhysicalMemorySizeGauge);
}
Gauge<Long> freeSwapSpaceSizeGauge = getLongGauge("getFreeSwapSpaceSize");
if (freeSwapSpaceSizeGauge != null) {
gauges.put("swap.space.free.size", freeSwapSpaceSizeGauge);
}
Gauge<Long> totalSwapSpaceSizeGauge = getLongGauge("getTotalSwapSpaceSize");
if (totalSwapSpaceSizeGauge != null) {
gauges.put("swap.space.total.size", totalSwapSpaceSizeGauge);
}
Gauge<Long> committedVirtualMemorySizeGauge = getLongGauge("getCommittedVirtualMemorySize");
if (committedVirtualMemorySizeGauge != null) {
gauges.put("virtual.memory.committed.size", committedVirtualMemorySizeGauge);
}
return Collections.unmodifiableMap(gauges);
}
// Get the current load on this machine
private double getLoad() {
OperatingSystemMXBean mxBean = ManagementFactory.getOperatingSystemMXBean();
return mxBean.getSystemLoadAverage();
}
/** {@inheritDoc} */
@Override
public double getSystemLoadAverage() {
return OS_MXBEAN.getSystemLoadAverage();
}
public static void getData() {
java.lang.management.OperatingSystemMXBean data =
java.lang.management.ManagementFactory.getOperatingSystemMXBean();
d = data.getSystemLoadAverage();
System.out.println(d);
}
public OptionsPane() {
this.setBorder(new EmptyBorder(5, 5, 5, 5));
currentRam = new JLabel();
currentRam.setBounds(427, 114, 85, 23);
long ram = 0;
OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
Method m;
try {
m = operatingSystemMXBean.getClass().getDeclaredMethod("getTotalPhysicalMemorySize");
m.setAccessible(true);
Object value = m.invoke(operatingSystemMXBean);
if (value != null) {
ram = Long.valueOf(value.toString()) / 1024 / 1024;
} else {
Logger.logWarn("Could not get RAM Value");
ram = 8192;
}
} catch (Exception e) {
Logger.logError(e.getMessage(), e);
}
ramMaximum = new JSlider();
ramMaximum.setBounds(190, 114, 222, 23);
ramMaximum.setSnapToTicks(true);
ramMaximum.setMajorTickSpacing(256);
ramMaximum.setMinorTickSpacing(256);
ramMaximum.setMinimum(256);
String vmType = System.getProperty("sun.arch.data.model");
if (vmType != null) {
if (vmType.equals("64")) {
ramMaximum.setMaximum((int) ram);
} else if (vmType.equals("32")) {
if (ram < 1024) {
ramMaximum.setMaximum((int) ram);
} else {
ramMaximum.setMaximum(1024);
}
}
}
int ramMax =
(Integer.parseInt(Settings.getSettings().getRamMax()) > ramMaximum.getMaximum())
? ramMaximum.getMaximum()
: Integer.parseInt(Settings.getSettings().getRamMax());
ramMaximum.setValue(ramMax);
currentRam.setText(getAmount());
ramMaximum.addChangeListener(
new ChangeListener() {
@Override
public void stateChanged(ChangeEvent arg0) {
currentRam.setText(getAmount());
}
});
ramMaximum.addFocusListener(settingsChangeListener);
JButton installBrowseBtn = new JButton("...");
installBrowseBtn.setBounds(786, 11, 49, 23);
installBrowseBtn.addActionListener(new ChooseDir(this));
setLayout(null);
add(installBrowseBtn);
lblInstallFolder = new JLabel(I18N.getLocaleString("INSTALL_FOLDER"));
lblInstallFolder.setBounds(10, 11, 127, 23);
add(lblInstallFolder);
installFolderTextField = new JTextField();
installFolderTextField.setBounds(147, 11, 629, 23);
installFolderTextField.addFocusListener(settingsChangeListener);
installFolderTextField.setColumns(10);
installFolderTextField.setText(Settings.getSettings().getInstallPath());
add(installFolderTextField);
tglbtnForceUpdate = new JToggleButton(I18N.getLocaleString("FORCE_UPDATE"));
tglbtnForceUpdate.setBounds(147, 45, 629, 29);
tglbtnForceUpdate.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
tglbtnForceUpdate.setEnabled(false);
saveSettingsInto(Settings.getSettings());
}
});
tglbtnForceUpdate.getModel().setPressed(Settings.getSettings().getForceUpdate());
add(tglbtnForceUpdate);
lblRamMaximum = new JLabel(I18N.getLocaleString("RAM_MAX"));
lblRamMaximum.setBounds(10, 114, 195, 23);
add(lblRamMaximum);
add(ramMaximum);
add(currentRam);
ArrayList<String> locales = new ArrayList<String>();
for (Map.Entry<Integer, String> entry : I18N.localeIndices.entrySet()) {
Logger.logInfo(
"[i18n] Added "
+ entry.getKey().toString()
+ " "
+ entry.getValue()
+ " to options pane");
locales.add(entry.getKey(), I18N.localeFiles.get(entry.getValue()));
}
locale = new JComboBox(locales.toArray());
locale.setBounds(190, 148, 222, 23);
locale.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
I18N.setLocale(I18N.localeIndices.get(locale.getSelectedIndex()));
if (LaunchFrame.getInstance() != null) {
LaunchFrame.getInstance().updateLocale();
}
}
});
locale.addFocusListener(settingsChangeListener);
locale.setSelectedItem(I18N.localeFiles.get(Settings.getSettings().getLocale()));
lblLocale = new JLabel(I18N.getLocaleString("LANGUAGE"));
lblLocale.setBounds(10, 148, 195, 23);
add(lblLocale);
add(locale);
minecraftSize = new JLabel("Size for Minecraft Window");
minecraftSize.setBounds(10, 182, 195, 23);
add(minecraftSize);
minecraftX = new JTextField();
minecraftX.setBounds(190, 182, 85, 22);
minecraftX.setDocument(new documentFilter("\\D++"));
minecraftX.setText(Settings.getSettings().getMinecraftX());
minecraftX.addFocusListener(settingsChangeListener);
add(minecraftX);
lblX = new JLabel("x");
lblX.setBounds(297, 182, 6, 20);
add(lblX);
minecraftY = new JTextField();
minecraftY.setBounds(327, 182, 85, 23);
minecraftY.setDocument(new documentFilter("\\D++"));
minecraftY.setText(Settings.getSettings().getMinecraftY());
minecraftY.addFocusListener(settingsChangeListener);
add(minecraftY);
minecraftY.setColumns(5);
JLabel minecraftPos = new JLabel("Position of Minecraft Window");
minecraftPos.setBounds(10, 216, 195, 23);
add(minecraftPos);
xPosField = new JTextField();
xPosField.setBounds(190, 217, 85, 22);
xPosField.setDocument(new documentFilter("\\D++"));
xPosField.setText(Settings.getSettings().getMinecraftXPos());
xPosField.addFocusListener(settingsChangeListener);
add(xPosField);
xPosField.setColumns(10);
JLabel lblX_1 = new JLabel("x");
lblX_1.setBounds(297, 216, 6, 23);
add(lblX_1);
yPosField = new JTextField();
yPosField.setBounds(327, 216, 85, 23);
yPosField.setDocument(new documentFilter("\\D++"));
yPosField.setText(Settings.getSettings().getMinecraftYPos());
yPosField.addFocusListener(settingsChangeListener);
add(yPosField);
yPosField.setColumns(10);
tglbtnCenterScreen = new JToggleButton("Center Window on Screen");
tglbtnCenterScreen.setBounds(190, 252, 222, 23);
tglbtnCenterScreen.setSelected(Boolean.parseBoolean(Settings.getSettings().getCenterWindow()));
tglbtnCenterScreen.addFocusListener(settingsChangeListener);
add(tglbtnCenterScreen);
downloadServers = new JComboBox(getDownloadServerNames());
downloadServers.setBounds(613, 115, 222, 23);
downloadServers.addFocusListener(settingsChangeListener);
if (DownloadUtils.serversLoaded) {
if (DownloadUtils.downloadServers.containsKey(Settings.getSettings().getDownloadServer())) {
downloadServers.setSelectedItem(Settings.getSettings().getDownloadServer());
}
}
add(downloadServers);
JLabel downloadLocation = new JLabel("Download Location");
downloadLocation.setBounds(490, 118, 110, 14);
add(downloadLocation);
chckbxShowConsole = new JCheckBox("Show Console?");
chckbxShowConsole.addFocusListener(settingsChangeListener);
chckbxShowConsole.setSelected(Boolean.parseBoolean(Settings.getSettings().getConsoleActive()));
chckbxShowConsole.setBounds(613, 148, 183, 23);
add(chckbxShowConsole);
autoMaxCheck = new JCheckBox("Automatically Maximize?");
autoMaxCheck.addFocusListener(settingsChangeListener);
autoMaxCheck.setSelected(Boolean.parseBoolean(Settings.getSettings().getAutoMaximize()));
autoMaxCheck.setBounds(613, 184, 183, 23);
add(autoMaxCheck);
JLabel javaLocLabel = new JLabel("Java Location");
javaLocLabel.setBounds(490, 220, 110, 14);
add(javaLocLabel);
javaInstallDir = new JTextField();
javaInstallDir.setEditable(false);
String javaInstall = Settings.getSettings().getJavaInstall();
javaInstallDir.setText(javaInstall);
javaInstallDir.setToolTipText(javaInstall);
javaInstallDir.setBounds(613, 220, 230, 23);
add(javaInstallDir);
JButton dirChooserButton = new JButton("Change");
dirChooserButton.setBounds(763, 240, 80, 23);
dirChooserButton.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JFileChooser chooser = new JFileChooser(Settings.getSettings().getJavaInstall());
chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int option = chooser.showOpenDialog(OptionsPane.this);
if (JFileChooser.APPROVE_OPTION == option) {
File selectedDir = chooser.getSelectedFile();
String javaExecutableName = "java";
if (OS.WINDOWS.equals(OSUtils.getCurrentOS())) {
javaExecutableName += ".exe";
}
File javaExecutable =
new File(
selectedDir
+ System.getProperty("file.separator")
+ "bin"
+ System.getProperty("file.separator")
+ javaExecutableName);
if (javaExecutable.exists()) {
javaInstallDir.setText(selectedDir.getAbsolutePath());
saveSettingsInto(Settings.getSettings());
} else {
JOptionPane.showMessageDialog(
OptionsPane.this,
"The selected directoy is not a proper Java installation.",
"Error",
JOptionPane.ERROR_MESSAGE);
}
}
}
});
add(dirChooserButton);
}
synchronized Result formatSummary() {
Result result = new Result();
ProxyClient proxyClient = vmPanel.getProxyClient();
if (proxyClient.isDead()) {
return null;
}
buf = new StringBuilder();
append("<table cellpadding=1>");
try {
RuntimeMXBean rmBean = proxyClient.getRuntimeMXBean();
CompilationMXBean cmpMBean = proxyClient.getCompilationMXBean();
ThreadMXBean tmBean = proxyClient.getThreadMXBean();
MemoryMXBean memoryBean = proxyClient.getMemoryMXBean();
ClassLoadingMXBean clMBean = proxyClient.getClassLoadingMXBean();
OperatingSystemMXBean osMBean = proxyClient.getOperatingSystemMXBean();
com.sun.management.OperatingSystemMXBean sunOSMBean =
proxyClient.getSunOperatingSystemMXBean();
append("<tr><td colspan=4>");
append("<center><b>" + Messages.SUMMARY_TAB_TAB_NAME + "</b></center>");
String dateTime = headerDateTimeFormat.format(System.currentTimeMillis());
append("<center>" + dateTime + "</center>");
append(newDivider);
{ // VM info
append(newLeftTable);
append(Messages.CONNECTION_NAME, vmPanel.getDisplayName());
append(
Messages.VIRTUAL_MACHINE,
Resources.format(
Messages.SUMMARY_TAB_VM_VERSION, rmBean.getVmName(), rmBean.getVmVersion()));
append(Messages.VENDOR, rmBean.getVmVendor());
append(Messages.NAME, rmBean.getName());
append(endTable);
append(newRightTable);
result.upTime = rmBean.getUptime();
append(Messages.UPTIME, formatTime(result.upTime));
if (sunOSMBean != null) {
result.processCpuTime = sunOSMBean.getProcessCpuTime();
append(Messages.PROCESS_CPU_TIME, formatNanoTime(result.processCpuTime));
}
if (cmpMBean != null) {
append(Messages.JIT_COMPILER, cmpMBean.getName());
append(
Messages.TOTAL_COMPILE_TIME,
cmpMBean.isCompilationTimeMonitoringSupported()
? formatTime(cmpMBean.getTotalCompilationTime())
: Messages.UNAVAILABLE);
} else {
append(Messages.JIT_COMPILER, Messages.UNAVAILABLE);
}
append(endTable);
}
append(newDivider);
{ // Threads and Classes
append(newLeftTable);
int tlCount = tmBean.getThreadCount();
int tdCount = tmBean.getDaemonThreadCount();
int tpCount = tmBean.getPeakThreadCount();
long ttCount = tmBean.getTotalStartedThreadCount();
String[] strings1 =
formatLongs(
tlCount, tpCount,
tdCount, ttCount);
append(Messages.LIVE_THREADS, strings1[0]);
append(Messages.PEAK, strings1[1]);
append(Messages.DAEMON_THREADS, strings1[2]);
append(Messages.TOTAL_THREADS_STARTED, strings1[3]);
append(endTable);
append(newRightTable);
long clCount = clMBean.getLoadedClassCount();
long cuCount = clMBean.getUnloadedClassCount();
long ctCount = clMBean.getTotalLoadedClassCount();
String[] strings2 = formatLongs(clCount, cuCount, ctCount);
append(Messages.CURRENT_CLASSES_LOADED, strings2[0]);
append(Messages.TOTAL_CLASSES_LOADED, strings2[2]);
append(Messages.TOTAL_CLASSES_UNLOADED, strings2[1]);
append(null, "");
append(endTable);
}
append(newDivider);
{ // Memory
MemoryUsage u = memoryBean.getHeapMemoryUsage();
append(newLeftTable);
String[] strings1 = formatKByteStrings(u.getUsed(), u.getMax());
append(Messages.CURRENT_HEAP_SIZE, strings1[0]);
append(Messages.MAXIMUM_HEAP_SIZE, strings1[1]);
append(endTable);
append(newRightTable);
String[] strings2 = formatKByteStrings(u.getCommitted());
append(Messages.COMMITTED_MEMORY, strings2[0]);
append(
Messages.SUMMARY_TAB_PENDING_FINALIZATION_LABEL,
Messages.SUMMARY_TAB_PENDING_FINALIZATION_VALUE,
memoryBean.getObjectPendingFinalizationCount());
append(endTable);
append(newTable);
Collection<GarbageCollectorMXBean> garbageCollectors =
proxyClient.getGarbageCollectorMXBeans();
for (GarbageCollectorMXBean garbageCollectorMBean : garbageCollectors) {
String gcName = garbageCollectorMBean.getName();
long gcCount = garbageCollectorMBean.getCollectionCount();
long gcTime = garbageCollectorMBean.getCollectionTime();
append(
Messages.GARBAGE_COLLECTOR,
Resources.format(
Messages.GC_INFO,
gcName,
gcCount,
(gcTime >= 0) ? formatTime(gcTime) : Messages.UNAVAILABLE),
4);
}
append(endTable);
}
append(newDivider);
{ // Operating System info
append(newLeftTable);
String osName = osMBean.getName();
String osVersion = osMBean.getVersion();
String osArch = osMBean.getArch();
result.nCPUs = osMBean.getAvailableProcessors();
append(Messages.OPERATING_SYSTEM, osName + " " + osVersion);
append(Messages.ARCHITECTURE, osArch);
append(Messages.NUMBER_OF_PROCESSORS, result.nCPUs + "");
if (pathSeparator == null) {
// Must use separator of remote OS, not File.pathSeparator
// from this local VM. In the future, consider using
// RuntimeMXBean to get the remote system property.
pathSeparator = osName.startsWith("Windows ") ? ";" : ":";
}
if (sunOSMBean != null) {
String[] kbStrings1 = formatKByteStrings(sunOSMBean.getCommittedVirtualMemorySize());
String[] kbStrings2 =
formatKByteStrings(
sunOSMBean.getTotalPhysicalMemorySize(),
sunOSMBean.getFreePhysicalMemorySize(),
sunOSMBean.getTotalSwapSpaceSize(),
sunOSMBean.getFreeSwapSpaceSize());
append(Messages.COMMITTED_VIRTUAL_MEMORY, kbStrings1[0]);
append(endTable);
append(newRightTable);
append(Messages.TOTAL_PHYSICAL_MEMORY, kbStrings2[0]);
append(Messages.FREE_PHYSICAL_MEMORY, kbStrings2[1]);
append(Messages.TOTAL_SWAP_SPACE, kbStrings2[2]);
append(Messages.FREE_SWAP_SPACE, kbStrings2[3]);
}
append(endTable);
}
append(newDivider);
{ // VM arguments and paths
append(newTable);
String args = "";
java.util.List<String> inputArguments = rmBean.getInputArguments();
for (String arg : inputArguments) {
args += arg + " ";
}
append(Messages.VM_ARGUMENTS, args, 4);
append(Messages.CLASS_PATH, rmBean.getClassPath(), 4);
append(Messages.LIBRARY_PATH, rmBean.getLibraryPath(), 4);
append(
Messages.BOOT_CLASS_PATH,
rmBean.isBootClassPathSupported() ? rmBean.getBootClassPath() : Messages.UNAVAILABLE,
4);
append(endTable);
}
} catch (IOException e) {
if (JConsole.isDebug()) {
e.printStackTrace();
}
proxyClient.markAsDead();
return null;
} catch (UndeclaredThrowableException e) {
if (JConsole.isDebug()) {
e.printStackTrace();
}
proxyClient.markAsDead();
return null;
}
append("</table>");
result.timeStamp = System.currentTimeMillis();
result.summary = buf.toString();
return result;
}
/**
* Retrieve a JVM information text formatted using the given StringManager.
*
* @param requestedSm the StringManager to use
* @return the formatted JVM information text
*/
private static String getVMInfo(StringManager requestedSm) {
StringBuilder sb = new StringBuilder();
synchronized (timeformat) {
sb.append(timeformat.format(new Date()));
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoRuntime"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "vmName: " + runtimeMXBean.getVmName() + CRLF);
sb.append(INDENT1 + "vmVersion: " + runtimeMXBean.getVmVersion() + CRLF);
sb.append(INDENT1 + "vmVendor: " + runtimeMXBean.getVmVendor() + CRLF);
sb.append(INDENT1 + "specName: " + runtimeMXBean.getSpecName() + CRLF);
sb.append(INDENT1 + "specVersion: " + runtimeMXBean.getSpecVersion() + CRLF);
sb.append(INDENT1 + "specVendor: " + runtimeMXBean.getSpecVendor() + CRLF);
sb.append(
INDENT1 + "managementSpecVersion: " + runtimeMXBean.getManagementSpecVersion() + CRLF);
sb.append(INDENT1 + "name: " + runtimeMXBean.getName() + CRLF);
sb.append(INDENT1 + "startTime: " + runtimeMXBean.getStartTime() + CRLF);
sb.append(INDENT1 + "uptime: " + runtimeMXBean.getUptime() + CRLF);
sb.append(
INDENT1 + "isBootClassPathSupported: " + runtimeMXBean.isBootClassPathSupported() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoOs"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "name: " + operatingSystemMXBean.getName() + CRLF);
sb.append(INDENT1 + "version: " + operatingSystemMXBean.getVersion() + CRLF);
sb.append(INDENT1 + "architecture: " + operatingSystemMXBean.getArch() + CRLF);
sb.append(
INDENT1 + "availableProcessors: " + operatingSystemMXBean.getAvailableProcessors() + CRLF);
sb.append(
INDENT1 + "systemLoadAverage: " + operatingSystemMXBean.getSystemLoadAverage() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoThreadMxBean"));
sb.append(":" + CRLF);
sb.append(
INDENT1
+ "isCurrentThreadCpuTimeSupported: "
+ threadMXBean.isCurrentThreadCpuTimeSupported()
+ CRLF);
sb.append(
INDENT1 + "isThreadCpuTimeSupported: " + threadMXBean.isThreadCpuTimeSupported() + CRLF);
sb.append(INDENT1 + "isThreadCpuTimeEnabled: " + threadMXBean.isThreadCpuTimeEnabled() + CRLF);
sb.append(
INDENT1
+ "isObjectMonitorUsageSupported: "
+ threadMXBean.isObjectMonitorUsageSupported()
+ CRLF);
sb.append(
INDENT1
+ "isSynchronizerUsageSupported: "
+ threadMXBean.isSynchronizerUsageSupported()
+ CRLF);
sb.append(
INDENT1
+ "isThreadContentionMonitoringSupported: "
+ threadMXBean.isThreadContentionMonitoringSupported()
+ CRLF);
sb.append(
INDENT1
+ "isThreadContentionMonitoringEnabled: "
+ threadMXBean.isThreadContentionMonitoringEnabled()
+ CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoThreadCounts"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "daemon: " + threadMXBean.getDaemonThreadCount() + CRLF);
sb.append(INDENT1 + "total: " + threadMXBean.getThreadCount() + CRLF);
sb.append(INDENT1 + "peak: " + threadMXBean.getPeakThreadCount() + CRLF);
sb.append(INDENT1 + "totalStarted: " + threadMXBean.getTotalStartedThreadCount() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoStartup"));
sb.append(":" + CRLF);
for (String arg : runtimeMXBean.getInputArguments()) {
sb.append(INDENT1 + arg + CRLF);
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoPath"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "bootClassPath: " + runtimeMXBean.getBootClassPath() + CRLF);
sb.append(INDENT1 + "classPath: " + runtimeMXBean.getClassPath() + CRLF);
sb.append(INDENT1 + "libraryPath: " + runtimeMXBean.getLibraryPath() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoClassLoading"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "loaded: " + classLoadingMXBean.getLoadedClassCount() + CRLF);
sb.append(INDENT1 + "unloaded: " + classLoadingMXBean.getUnloadedClassCount() + CRLF);
sb.append(INDENT1 + "totalLoaded: " + classLoadingMXBean.getTotalLoadedClassCount() + CRLF);
sb.append(INDENT1 + "isVerbose: " + classLoadingMXBean.isVerbose() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoClassCompilation"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "name: " + compilationMXBean.getName() + CRLF);
sb.append(
INDENT1 + "totalCompilationTime: " + compilationMXBean.getTotalCompilationTime() + CRLF);
sb.append(
INDENT1
+ "isCompilationTimeMonitoringSupported: "
+ compilationMXBean.isCompilationTimeMonitoringSupported()
+ CRLF);
sb.append(CRLF);
for (MemoryManagerMXBean mbean : memoryManagerMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoMemoryManagers", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryPoolNames: " + CRLF);
String[] names = mbean.getMemoryPoolNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(CRLF);
}
for (GarbageCollectorMXBean mbean : garbageCollectorMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoGarbageCollectors", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryPoolNames: " + CRLF);
String[] names = mbean.getMemoryPoolNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(INDENT1 + "getCollectionCount: " + mbean.getCollectionCount() + CRLF);
sb.append(INDENT1 + "getCollectionTime: " + mbean.getCollectionTime() + CRLF);
sb.append(CRLF);
}
sb.append(requestedSm.getString("diagnostics.vmInfoMemory"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isVerbose: " + memoryMXBean.isVerbose() + CRLF);
sb.append(
INDENT1
+ "getObjectPendingFinalizationCount: "
+ memoryMXBean.getObjectPendingFinalizationCount()
+ CRLF);
sb.append(formatMemoryUsage("heap", memoryMXBean.getHeapMemoryUsage()));
sb.append(formatMemoryUsage("non-heap", memoryMXBean.getNonHeapMemoryUsage()));
sb.append(CRLF);
for (MemoryPoolMXBean mbean : memoryPoolMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoMemoryPools", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "getType: " + mbean.getType() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryManagerNames: " + CRLF);
String[] names = mbean.getMemoryManagerNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(INDENT1 + "isUsageThresholdSupported: " + mbean.isUsageThresholdSupported() + CRLF);
try {
sb.append(INDENT1 + "isUsageThresholdExceeded: " + mbean.isUsageThresholdExceeded() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
sb.append(
INDENT1
+ "isCollectionUsageThresholdSupported: "
+ mbean.isCollectionUsageThresholdSupported()
+ CRLF);
try {
sb.append(
INDENT1
+ "isCollectionUsageThresholdExceeded: "
+ mbean.isCollectionUsageThresholdExceeded()
+ CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(INDENT1 + "getUsageThreshold: " + mbean.getUsageThreshold() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(INDENT1 + "getUsageThresholdCount: " + mbean.getUsageThresholdCount() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(
INDENT1 + "getCollectionUsageThreshold: " + mbean.getCollectionUsageThreshold() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(
INDENT1
+ "getCollectionUsageThresholdCount: "
+ mbean.getCollectionUsageThresholdCount()
+ CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
sb.append(formatMemoryUsage("current", mbean.getUsage()));
sb.append(formatMemoryUsage("collection", mbean.getCollectionUsage()));
sb.append(formatMemoryUsage("peak", mbean.getPeakUsage()));
sb.append(CRLF);
}
sb.append(requestedSm.getString("diagnostics.vmInfoSystem"));
sb.append(":" + CRLF);
Map<String, String> props = runtimeMXBean.getSystemProperties();
ArrayList<String> keys = new ArrayList<String>(props.keySet());
Collections.sort(keys);
for (String prop : keys) {
sb.append(INDENT1 + prop + ": " + props.get(prop) + CRLF);
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoLogger"));
sb.append(":" + CRLF);
List<String> loggers = loggingMXBean.getLoggerNames();
Collections.sort(loggers);
for (String logger : loggers) {
sb.append(
INDENT1
+ logger
+ ": level="
+ loggingMXBean.getLoggerLevel(logger)
+ ", parent="
+ loggingMXBean.getParentLoggerName(logger)
+ CRLF);
}
sb.append(CRLF);
return sb.toString();
}
