com.ery.ertc.estorm.util.JVM.java Source code

Java tutorial

Introduction

Here is the source code for com.ery.ertc.estorm.util.JVM.java

Source

/**
 * 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 com.ery.ertc.estorm.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.management.ManagementFactory;
import java.lang.management.OperatingSystemMXBean;
import java.lang.management.RuntimeMXBean;
import java.lang.reflect.Method;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * This class is a wrapper for the implementation of com.sun.management.UnixOperatingSystemMXBean It will decide to use the sun api or its
 * own implementation depending on the runtime (vendor) used.
 */

public class JVM {
    private static final Log LOG = LogFactory.getLog(JVM.class);
    private OperatingSystemMXBean osMbean;

    private static final boolean ibmvendor = System.getProperty("java.vendor").contains("IBM");
    private static final boolean windows = System.getProperty("os.name").startsWith("Windows");
    private static final boolean linux = System.getProperty("os.name").startsWith("Linux");
    private static final String JVMVersion = System.getProperty("java.version");

    /**
     * Constructor. Get the running Operating System instance
     */
    public JVM() {
        this.osMbean = ManagementFactory.getOperatingSystemMXBean();
    }

    /**
     * Check if the OS is unix.
     * 
     * @return whether this is unix or not.
     */
    public static boolean isUnix() {
        if (windows) {
            return false;
        }
        return (ibmvendor ? linux : true);
    }

    /**
     * Check if the finish() method of GZIPOutputStream is broken
     * 
     * @return whether GZIPOutputStream.finish() is broken.
     */
    public static boolean isGZIPOutputStreamFinishBroken() {
        return ibmvendor && JVMVersion.contains("1.6.0");
    }

    /**
     * Load the implementation of UnixOperatingSystemMXBean for Oracle jvm and runs the desired method.
     * 
     * @param mBeanMethodName
     *            : method to run from the interface UnixOperatingSystemMXBean
     * @return the method result
     */
    private Long runUnixMXBeanMethod(String mBeanMethodName) {
        Object unixos;
        Class<?> classRef;
        Method mBeanMethod;

        try {
            classRef = Class.forName("com.sun.management.UnixOperatingSystemMXBean");
            if (classRef.isInstance(osMbean)) {
                mBeanMethod = classRef.getMethod(mBeanMethodName, new Class[0]);
                unixos = classRef.cast(osMbean);
                return (Long) mBeanMethod.invoke(unixos);
            }
        } catch (Exception e) {
            LOG.warn("Not able to load class or method for" + " com.sun.management.UnixOperatingSystemMXBean.", e);
        }
        return null;
    }

    /**
     * Get the number of opened filed descriptor for the runtime jvm. If Oracle java, it will use the com.sun.management interfaces.
     * Otherwise, this methods implements it (linux only).
     * 
     * @return number of open file descriptors for the jvm
     */
    public long getOpenFileDescriptorCount() {

        Long ofdc;

        if (!ibmvendor) {
            ofdc = runUnixMXBeanMethod("getOpenFileDescriptorCount");
            return (ofdc != null ? ofdc.longValue() : -1);
        }
        InputStream in = null;
        BufferedReader output = null;
        try {
            // need to get the PID number of the process first
            RuntimeMXBean rtmbean = ManagementFactory.getRuntimeMXBean();
            String rtname = rtmbean.getName();
            String[] pidhost = rtname.split("@");

            // using linux bash commands to retrieve info
            Process p = Runtime.getRuntime()
                    .exec(new String[] { "bash", "-c", "ls /proc/" + pidhost[0] + "/fdinfo | wc -l" });
            in = p.getInputStream();
            output = new BufferedReader(new InputStreamReader(in));
            String openFileDesCount;
            if ((openFileDesCount = output.readLine()) != null)
                return Long.parseLong(openFileDesCount);
        } catch (IOException ie) {
            LOG.warn("Not able to get the number of open file descriptors", ie);
        } finally {
            if (output != null) {
                try {
                    output.close();
                } catch (IOException e) {
                    LOG.warn("Not able to close the InputStream", e);
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    LOG.warn("Not able to close the InputStream", e);
                }
            }
        }
        return -1;
    }

    /**
     * @see java.lang.management.OperatingSystemMXBean#getSystemLoadAverage
     */
    public double getSystemLoadAverage() {
        return osMbean.getSystemLoadAverage();
    }

    /**
     * @return the physical free memory (not the JVM one, as it's not very useful as it depends on the GC), but the one from the OS as it
     *         allows a little bit more to guess if the machine is overloaded or not).
     */
    public long getFreeMemory() {
        if (ibmvendor) {
            return 0;
        }

        Long r = runUnixMXBeanMethod("getFreePhysicalMemorySize");
        return (r != null ? r : -1);
    }

    /**
     * Workaround to get the current number of process running. Approach is the one described here:
     * http://stackoverflow.com/questions/54686/how-to-get-a-list-of-current-open-windows-process-with-java
     */
    public int getNumberOfRunningProcess() {
        if (!isUnix()) {
            return 0;
        }

        BufferedReader input = null;
        try {
            int count = 0;
            Process p = Runtime.getRuntime().exec("ps -e");
            input = new BufferedReader(new InputStreamReader(p.getInputStream()));
            while (input.readLine() != null) {
                count++;
            }
            return count - 1; // -1 because there is a headline
        } catch (IOException e) {
            return -1;
        } finally {
            if (input != null) {
                try {
                    input.close();
                } catch (IOException ignored) {
                }
            }
        }
    }

    /**
     * Get the number of the maximum file descriptors the system can use. If Oracle java, it will use the com.sun.management interfaces.
     * Otherwise, this methods implements it (linux only).
     * 
     * @return max number of file descriptors the operating system can use.
     */
    public long getMaxFileDescriptorCount() {
        Long mfdc;
        if (!ibmvendor) {
            mfdc = runUnixMXBeanMethod("getMaxFileDescriptorCount");
            return (mfdc != null ? mfdc.longValue() : -1);
        }
        InputStream in = null;
        BufferedReader output = null;
        try {
            // using linux bash commands to retrieve info
            Process p = Runtime.getRuntime().exec(new String[] { "bash", "-c", "ulimit -n" });
            in = p.getInputStream();
            output = new BufferedReader(new InputStreamReader(in));
            String maxFileDesCount;
            if ((maxFileDesCount = output.readLine()) != null)
                return Long.parseLong(maxFileDesCount);
        } catch (IOException ie) {
            LOG.warn("Not able to get the max number of file descriptors", ie);
        } finally {
            if (output != null) {
                try {
                    output.close();
                } catch (IOException e) {
                    LOG.warn("Not able to close the reader", e);
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    LOG.warn("Not able to close the InputStream", e);
                }
            }
        }
        return -1;
    }
}