HADOOP-19329. Remove direct usage of sun.misc.Signal

hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/service/launcher/IrqHandler.java

@@ -21,10 +21,9 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.apache.hadoop.util.Preconditions;
+import org.apache.hadoop.util.SignalUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import sun.misc.Signal;
-import sun.misc.SignalHandler;
 
 import org.apache.hadoop.classification.InterfaceAudience;
 import org.apache.hadoop.classification.InterfaceStability;
@@ -39,7 +38,7 @@
 @InterfaceAudience.Private
 @InterfaceStability.Unstable
 @SuppressWarnings("UseOfSunClasses")
-public final class IrqHandler implements SignalHandler {
+public final class IrqHandler implements SignalUtil.Handler {
   private static final Logger LOG = LoggerFactory.getLogger(IrqHandler.class);
 
   /**
@@ -68,7 +67,7 @@ public final class IrqHandler implements SignalHandler {
   /**
    * Stored signal.
    */
-  private Signal signal;
+  private SignalUtil.Signal signal;
 
   /**
    * Create an IRQ handler bound to the specific interrupt.
@@ -89,8 +88,8 @@ public IrqHandler(String name, Interrupted handler) {
   public void bind() {
     Preconditions.checkState(signal == null, "Handler already bound");
     try {
-      signal = new Signal(name);
-      Signal.handle(signal, this);
+      signal = new SignalUtil.Signal(name);
+      SignalUtil.handle(signal, this);
     } catch (IllegalArgumentException e) {
       throw new IllegalArgumentException(
           "Could not set handler for signal \"" + name + "\"."
@@ -110,7 +109,7 @@ public String getName() {
    * Raise the signal.
    */
   public void raise() {
-    Signal.raise(signal);
+    SignalUtil.raise(signal);
   }
 
   @Override
@@ -123,7 +122,7 @@ public String toString() {
    * @param s signal raised
    */
   @Override
-  public void handle(Signal s) {
+  public void handle(SignalUtil.Signal s) {
     signalCount.incrementAndGet();
     InterruptData data = new InterruptData(s.getName(), s.getNumber());
     LOG.info("Interrupted: {}", data);

hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/util/SignalLogger.java

@@ -19,8 +19,6 @@
 package org.apache.hadoop.util;
 
 import org.slf4j.Logger;
-import sun.misc.Signal;
-import sun.misc.SignalHandler;
 
 import org.apache.hadoop.classification.InterfaceAudience;
 import org.apache.hadoop.classification.InterfaceStability;
@@ -41,13 +39,13 @@ public enum SignalLogger {
   /**
    * Our signal handler.
    */
-  private static class Handler implements SignalHandler {
+  private static class Handler implements SignalUtil.Handler {
     final private Logger log;
-    final private SignalHandler prevHandler;
+    final private SignalUtil.Handler prevHandler;
 
     Handler(String name, Logger log) {
       this.log = log;
-      prevHandler = Signal.handle(new Signal(name), this);
+      prevHandler = SignalUtil.handle(new SignalUtil.Signal(name), this);
     }
 
     /**
@@ -56,9 +54,8 @@ private static class Handler implements SignalHandler {
      * @param signal    The incoming signal
      */
     @Override
-    public void handle(Signal signal) {
-      log.error("RECEIVED SIGNAL " + signal.getNumber() +
-          ": SIG" + signal.getName());
+    public void handle(SignalUtil.Signal signal) {
+      log.error("RECEIVED SIGNAL {}: SIG{}", signal.getNumber(), signal.getName());
       prevHandler.handle(signal);
     }
   }
@@ -75,7 +72,7 @@ public void register(final Logger log) {
     registered = true;
     StringBuilder bld = new StringBuilder();
     bld.append("registered UNIX signal handlers for [");
-    final String SIGNALS[] = { "TERM", "HUP", "INT" };
+    final String[] SIGNALS = { "TERM", "HUP", "INT" };
     String separator = "";
     for (String signalName : SIGNALS) {
       try {

hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/util/SignalUtil.java

@@ -0,0 +1,161 @@
+/*
+ * 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.util;
+
+import org.apache.hadoop.classification.InterfaceAudience;
+
+import org.apache.hadoop.util.dynamic.BindingUtils;
+import org.apache.hadoop.util.dynamic.DynConstructors;
+import org.apache.hadoop.util.dynamic.DynMethods;
+
+import java.lang.reflect.Proxy;
+
+@InterfaceAudience.Private
+public class SignalUtil {
+
+  static final Class<?> jdkSignalClazz =
+      BindingUtils.loadClassSafely("sun.misc.Signal");
+  static final Class<?> jdkSignalHandlerClazz =
+      BindingUtils.loadClassSafely("sun.misc.SignalHandler");
+
+  static DynConstructors.Ctor<?> jdkSignalCtor =
+      new DynConstructors.Builder()
+          .impl(jdkSignalClazz, String.class)
+          .build();
+
+  static DynMethods.StaticMethod jdkSignalHandleStaticMethod =
+      new DynMethods.Builder("handle")
+          .impl(jdkSignalClazz, jdkSignalClazz, jdkSignalHandlerClazz)
+          .buildStatic();
+
+  static DynMethods.StaticMethod jdkSignalRaiseStaticMethod =
+      new DynMethods.Builder("raise")
+          .impl(jdkSignalClazz, jdkSignalClazz)
+          .buildStatic();
+
+  static DynMethods.UnboundMethod jdkSignalHandlerHandleUnboundMethod =
+      new DynMethods.Builder("handle")
+          .impl(jdkSignalHandlerClazz, jdkSignalClazz)
+          .build();
+
+  @InterfaceAudience.Private
+  public static class Signal {
+    private final DynMethods.UnboundMethod getNumberUnboundMethod =
+        new DynMethods.Builder("getNumber").impl(jdkSignalClazz).build();
+
+    private final DynMethods.UnboundMethod getNameUnboundMethod =
+        new DynMethods.Builder("getName").impl(jdkSignalClazz).build();
+
+    private final Object delegate;
+    private final DynMethods.BoundMethod getNumberMethod;
+    private final DynMethods.BoundMethod getNameMethod;
+
+    public Signal(String name) {
+      Preconditions.checkNotNull(name);
+      this.delegate = jdkSignalCtor.newInstance(name);
+      this.getNumberMethod = getNumberUnboundMethod.bind(delegate);
+      this.getNameMethod = getNameUnboundMethod.bind(delegate);
+    }
+
+    public Signal(Object delegate) {
+      Preconditions.checkArgument(jdkSignalClazz.isInstance(delegate),
+          String.format("Expected class is '%s', but actual class is '%s'",
+              jdkSignalClazz.getName(), delegate.getClass().getName()));
+      this.delegate = delegate;
+      this.getNumberMethod = getNumberUnboundMethod.bind(delegate);
+      this.getNameMethod = getNameUnboundMethod.bind(delegate);
+    }
+
+    public int getNumber() {
+      return getNumberMethod.invoke();
+    }
+
+    public String getName() {
+      return getNameMethod.invoke();
+    }
+
+    public boolean equals(Object obj) {
+      if (this == obj) {
+        return true;
+      }
+      if (obj instanceof Signal) {
+        return delegate.equals(((Signal)obj).delegate);
+      }
+      return false;
+    }
+
+    public int hashCode() {
+      return delegate.hashCode();
+    }
+
+    public String toString() {
+      return delegate.toString();
+    }
+  }
+
+  @InterfaceAudience.Private
+  public interface Handler {
+    void handle(Signal sig);
+  }
+
+  static class JdkSignalHandlerImpl implements Handler {
+
+    private final Object delegate;
+    private final DynMethods.BoundMethod jdkSignalHandlerHandleMethod;
+
+    JdkSignalHandlerImpl(Handler handler) {
+      this.delegate = Proxy.newProxyInstance(
+          getClass().getClassLoader(),
+          new Class<?>[] { jdkSignalHandlerClazz },
+          (proxyObj, method, args) -> {
+            if ("handle".equals(method.getName()) && args.length == 1 && jdkSignalClazz.isInstance(args[0])) {
+              handler.handle(new Signal(args[0]));
+              return null;
+            } else {
+              return method.invoke(proxyObj, args);
+            }
+          }
+      );
+      this.jdkSignalHandlerHandleMethod = jdkSignalHandlerHandleUnboundMethod.bind(delegate);
+    }
+
+    JdkSignalHandlerImpl(Object delegate) {
+      Preconditions.checkArgument(jdkSignalHandlerClazz.isInstance(delegate),
+          String.format("Expected class is '%s', but actual class is '%s'",
+              jdkSignalHandlerClazz.getName(), delegate.getClass().getName()));
+      this.delegate = delegate;
+      this.jdkSignalHandlerHandleMethod = jdkSignalHandlerHandleUnboundMethod.bind(delegate);
+    }
+
+    @Override
+    public void handle(Signal sig) {
+      jdkSignalHandlerHandleMethod.invoke(sig.delegate);
+    }
+  }
+
+  public static Handler handle(Signal sig, Handler handler) {
+    Object preHandle = jdkSignalHandleStaticMethod.invoke(
+        sig.delegate, new JdkSignalHandlerImpl(handler).delegate);
+    return new JdkSignalHandlerImpl(preHandle);
+  }
+
+  public static void raise(Signal sig) throws IllegalArgumentException {
+    jdkSignalRaiseStaticMethod.invoke(sig.delegate);
+  }
+}