HBASE-6965 Generic MXBean Utility class to support all JDK vendors (Kumar Ravi)

git-svn-id: https://svn.apache.org/repos/asf/hbase/trunk@1399734 13f79535-47bb-0310-9956-ffa450edef68

hbase-common/pom.xml

@@ -70,6 +70,14 @@
       <groupId>commons-logging</groupId>
       <artifactId>commons-logging</artifactId>
     </dependency>
+     <dependency>
+       <groupId>org.slf4j</groupId>
+       <artifactId>slf4j-api</artifactId>
+     </dependency>
+     <dependency>
+       <groupId>org.slf4j</groupId>
+       <artifactId>slf4j-log4j12</artifactId>
+     </dependency>                                         
   </dependencies>
 
   <profiles>

hbase-common/src/main/java/org/apache/hadoop/hbase/util/OSMXBean.java

@@ -0,0 +1,175 @@
+/**
+ * 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.hadoop.hbase.util;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.OperatingSystemMXBean;
+import java.lang.management.RuntimeMXBean;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.lang.reflect.Method;
+
+import org.apache.hadoop.classification.InterfaceAudience;
+import org.apache.hadoop.classification.InterfaceStability;
+
+/**
+ * This class is a wrapper for the implementation of
+ * com.sun.management.UnixOperatingSystemMXBean
+ * It will decide to use Oracle Java api or its own implementation
+ * depending on the runtime (vendor) used.
+ */
+
+@InterfaceAudience.Public
+@InterfaceStability.Evolving
+public class OSMXBean {
+  static final Logger LOG = LoggerFactory.getLogger(OSMXBean.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");
+
+  /**
+   * Constructor. Get the running Operating System instance
+   */
+  public OSMXBean () {
+    this.osMbean = ManagementFactory.getOperatingSystemMXBean();
+  }
+ 
+  /**
+   * Check if the OS is unix. 
+   * 
+   * @return whether this is unix or not.
+   */
+  public boolean isUnix() {
+    if (windows) {
+      return false;
+    }
+    return (ibmvendor ? linux : true);
+  }
+
+  /**
+   * 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.getDeclaredMethod(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.managment.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);
+    }
+    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" });
+      InputStream in = p.getInputStream();
+      BufferedReader 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);
+    }
+    return -1;
+  }
+
+  /**
+   * 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);
+    }
+    try {
+      
+      //using linux bash commands to retrieve info
+      Process p = Runtime.getRuntime().exec(
+        new String[] { "bash", "-c",
+        "ulimit -n" });
+      InputStream in = p.getInputStream();
+      BufferedReader 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);
+    }
+    return -1;
+  }  
+}