Ensure DynamicClassLoader is the Context Class Loader (#604)

* Ensure DynamicClassLoader is the Context Class Loader

Author: arnaudgeiser

project.clj

@@ -32,7 +32,9 @@
                                    [criterium "0.4.6"]
                                    [cheshire "5.10.0"]
                                    [org.slf4j/slf4j-simple "1.7.30"]
-                                   [com.cognitect/transit-clj "1.0.324"]]}
+                                   [com.cognitect/transit-clj "1.0.324"]
+                                   [spootnik/signal "0.2.4"]
+                                   [me.mourjo/dynamic-redef "0.1.0"]]}
              ;; This is for self-generating certs for testing ONLY:
              :test {:dependencies [[org.bouncycastle/bcprov-jdk15on "1.69"]
                                    [org.bouncycastle/bcpkix-jdk15on "1.69"]]

src/aleph/netty.clj

@@ -10,6 +10,7 @@
     [clj-commons.primitive-math :as p]
     [potemkin :as potemkin :refer [doit doary]])
   (:import
+    [clojure.lang DynamicClassLoader]
     [java.io IOException]
     [io.netty.bootstrap Bootstrap ServerBootstrap]
     [io.netty.buffer ByteBuf Unpooled]
@@ -55,6 +56,7 @@
      FastThreadLocalThread GenericFutureListener Future]
     [java.io InputStream File]
     [java.nio ByteBuffer]
+    [java.nio.channels ClosedChannelException]
     [io.netty.util.internal SystemPropertyUtil]
     [java.util.concurrent
      ConcurrentHashMap
@@ -199,41 +201,51 @@
   (->> (bs/convert x (bs/stream-of ByteBuf) {:chunk-size chunk-size})
     (s/onto nil)))
 
+(defn ensure-dynamic-classloader
+  "Ensure the context class loader has a valid loader chain to
+   prevent `ClassNotFoundException`.
+   https://github.com/clj-commons/aleph/issues/603."
+  []
+  (let [thread (Thread/currentThread)
+        context-class-loader (.getContextClassLoader thread)
+        compiler-class-loader (.getClassLoader clojure.lang.Compiler)]
+    (when-not (instance? DynamicClassLoader context-class-loader)
+      (.setContextClassLoader
+        thread
+        (DynamicClassLoader. (or context-class-loader
+                                 compiler-class-loader))))))
+
+(defn- operation-complete [^Future f d]
+  (cond
+     (.isSuccess f)
+     (d/success! d (.getNow f))
+
+     (.isCancelled f)
+     (d/error! d (CancellationException. "future is cancelled."))
+
+     (some? (.cause f))
+     (if (instance? ClosedChannelException (.cause f))
+       (d/success! d false)
+       (d/error! d (.cause f)))
+
+     :else
+     (d/error! d (IllegalStateException. "future in unknown state"))))
+
 (defn wrap-future
   [^Future f]
   (when f
     (if (.isSuccess f)
       (d/success-deferred (.getNow f) nil)
       (let [d (d/deferred nil)
-            ;; workaround for the issue with executing RT.readString
-            ;; on a Netty thread that doesn't have appropriate class loader
-            ;; more information here:
-            ;; https://github.com/clj-commons/aleph/issues/365
-            class-loader (or (clojure.lang.RT/baseLoader)
-                             (clojure.lang.RT/makeClassLoader))]
+            ;; Ensure the same bindings are installed on the Netty thread (vars,
+            ;; classloader) than the thread registering the
+            ;; `operationComplete` callback.
+            bound-operation-complete (bound-fn* operation-complete)]
         (.addListener f
           (reify GenericFutureListener
             (operationComplete [_ _]
-              (try
-                (. clojure.lang.Var
-                   (pushThreadBindings {clojure.lang.Compiler/LOADER
-                                        class-loader}))
-                (cond
-                  (.isSuccess f)
-                  (d/success! d (.getNow f))
-
-                  (.isCancelled f)
-                  (d/error! d (CancellationException. "future is cancelled."))
-
-                  (some? (.cause f))
-                  (if (instance? java.nio.channels.ClosedChannelException (.cause f))
-                    (d/success! d false)
-                    (d/error! d (.cause f)))
-
-                  :else
-                  (d/error! d (IllegalStateException. "future in unknown state")))
-                (finally
-                  (. clojure.lang.Var (popThreadBindings)))))))
+              (ensure-dynamic-classloader)
+              (bound-operation-complete f d))))
         d))))
 
 (defn allocate [x]

test/aleph/classloader_test.clj

@@ -0,0 +1,49 @@
+(ns aleph.classloader-test
+  (:require  [clojure.test       :refer [deftest testing is]]
+             [aleph.http         :as http]
+             [aleph.netty        :as netty]
+             [manifold.deferred  :as d]
+             [manifold.utils     :refer [when-class]]
+             [signal.handler     :refer [on-signal]]
+             [dynamic-redef.core :refer [with-dynamic-redefs]])
+  (:import [io.netty.util.concurrent Future]
+           [java.lang.management ManagementFactory]
+           [java.util.concurrent CompletableFuture]))
+
+(defn- operation-complete
+  "Stubs for `GenericFutureListener/operationComplete` which
+  returns a completed `CompletableFuture` containing either
+  `true` or a Throwable."
+  [^CompletableFuture result ^Future f d]
+  (try
+    (d/success! d (.getNow f))
+    (.complete result true)
+    d
+    (catch Throwable e
+      (prn e)
+      (.completeExceptionally result e)
+      d)))
+
+(defn pid
+  "Gets this process' PID."
+  []
+  (if-let [pid (when-class java.lang.ProcessHandle
+                 (.pid (java.lang.ProcessHandle/current)))]
+    pid
+    (let [pid (.getName (ManagementFactory/getRuntimeMXBean))]
+      (->> pid
+           (re-seq #"[0-9]+")
+           (first)
+           (Integer/parseInt)))))
+
+(deftest test-classloader
+  (testing "classloader: ensure the class loader is always a DynamicClassLoader"
+    (let [result (CompletableFuture.)]
+      (with-dynamic-redefs [netty/operation-complete (partial operation-complete result)]
+        (let [server (http/start-server
+                      (constantly {:body "ok"})
+                      {:port 9999})]
+          (on-signal :int
+                     (bound-fn [_] (.close ^java.io.Closeable server)))
+          (.exec (Runtime/getRuntime) (format "kill -SIGINT %s" (pid)))
+          (is (= (deref result 10000 ::timeout) true)))))))