Fix clj-kondo warnings in ring-jetty-adapter

ring-jetty-adapter/src/ring/adapter/jetty.clj

@@ -6,7 +6,6 @@
             [ring.websocket :as ws]
             [ring.websocket.protocols :as wsp])
   (:import [java.nio ByteBuffer]
-           [java.util ArrayList]
            [org.eclipse.jetty.server
             Request
             Server
@@ -26,7 +25,6 @@
             JettyWebSocketServerContainer
             JettyWebSocketCreator]
            [org.eclipse.jetty.websocket.api
-            ExtensionConfig
             Session
             WebSocketConnectionListener
             WebSocketListener
@@ -87,8 +85,8 @@
       (onWebSocketPong [_ payload]
         (wsp/on-pong listener @socket payload)))))
 
-(defn- ^JettyWebSocketCreator websocket-creator
-  [{:keys [::ws/listener ::ws/protocol]}]
+(defn-  websocket-creator
+  ^JettyWebSocketCreator [{:keys [::ws/listener ::ws/protocol]}]
   (reify JettyWebSocketCreator
     (createWebSocket [_ ^JettyServerUpgradeRequest _req
                       ^JettyServerUpgradeResponse resp]
@@ -102,7 +100,7 @@
         creator   (websocket-creator response-map)]
     (.upgrade container creator request response)))
 
-(defn- ^ServletHandler proxy-handler [handler]
+(defn- proxy-handler ^ServletHandler [handler]
   (proxy [ServletHandler] []
     (doHandle [_ ^Request base-request request response]
       (let [request-map  (servlet/build-request-map request)
@@ -135,7 +133,7 @@
     (onError [^AsyncEvent _])
     (onStartAsync [^AsyncEvent _])))
 
-(defn- ^ServletHandler async-proxy-handler [handler timeout timeout-handler]
+(defn- async-proxy-handler ^ServletHandler [handler timeout timeout-handler]
   (proxy [ServletHandler] []
     (doHandle [_ ^Request base-request request response]
       (let [^AsyncContext context (.startAsync request)]
@@ -152,31 +150,32 @@
           (finally
             (.setHandled base-request true)))))))
 
-(defn- ^ServletContextHandler context-handler [proxy-handler]
+(defn- context-handler ^ServletContextHandler [proxy-handler]
   (doto (ServletContextHandler.)
     (.setServletHandler proxy-handler)
     (.setAllowNullPathInfo true)
     (JettyWebSocketServletContainerInitializer/configure nil)))
 
-(defn- ^ServerConnector server-connector [^Server server & factories]
-  (ServerConnector. server #^"[Lorg.eclipse.jetty.server.ConnectionFactory;" (into-array ConnectionFactory factories)))
+(defn- server-connector ^ServerConnector [^Server server & factories]
+  (ServerConnector. server #^"[Lorg.eclipse.jetty.server.ConnectionFactory;"
+                    (into-array ConnectionFactory factories)))
 
-(defn- ^HttpConfiguration http-config [options]
+(defn- http-config ^HttpConfiguration [options]
   (doto (HttpConfiguration.)
     (.setSendDateHeader (:send-date-header? options true))
     (.setOutputBufferSize (:output-buffer-size options 32768))
     (.setRequestHeaderSize (:request-header-size options 8192))
     (.setResponseHeaderSize (:response-header-size options 8192))
     (.setSendServerVersion (:send-server-version? options true))))
 
-(defn- ^ServerConnector http-connector [server options]
+(defn- http-connector ^ServerConnector [server options]
   (let [http-factory (HttpConnectionFactory. (http-config options))]
     (doto (server-connector server http-factory)
       (.setPort (options :port 80))
       (.setHost (options :host))
       (.setIdleTimeout (options :max-idle-time 200000)))))
 
-(defn- ^SslContextFactory$Server ssl-context-factory [options]
+(defn- ssl-context-factory ^SslContextFactory$Server [options]
   (let [context-server (SslContextFactory$Server.)]
     (if (string? (options :keystore))
       (.setKeyStorePath context-server (options :keystore))
@@ -210,7 +209,7 @@
     context-server))
 
 
-(defn- ^ServerConnector ssl-connector [^Server server options]
+(defn- ssl-connector ^ServerConnector [^Server server options]
   (let [ssl-port     (options :ssl-port 443)
         customizer   (doto (SecureRequestCustomizer.)
                        (.setSniHostCheck (options :sni-host-check? true)))
@@ -229,7 +228,7 @@
       (.setHost (options :host))
       (.setIdleTimeout (options :max-idle-time 200000)))))
 
-(defn- ^ThreadPool create-threadpool [options]
+(defn- create-threadpool ^ThreadPool [options]
   (let [min-threads         (options :min-threads 8)
         max-threads         (options :max-threads 50)
         queue-max-capacity  (-> (options :max-queued-requests Integer/MAX_VALUE) (max 8))
@@ -246,7 +245,7 @@
       (.setDaemon pool true))
     pool))
 
-(defn- ^Server create-server [options]
+(defn- create-server ^Server [options]
   (let [pool   (or (:thread-pool options) (create-threadpool options))
         server (Server. pool)]
     (when (:http? options true)
@@ -255,7 +254,7 @@
       (.addConnector server (ssl-connector server options)))
     server))
 
-(defn ^Server run-jetty
+(defn run-jetty
   "Start a Jetty webserver to serve the given handler according to the
   supplied options:
 
@@ -308,7 +307,7 @@
   :request-header-size    - the maximum size of a request header (default 8192)
   :response-header-size   - the maximum size of a response header (default 8192)
   :send-server-version?   - add Server header to HTTP response (default true)"
-  [handler options]
+  ^Server [handler options]
   (let [server (create-server (dissoc options :configurator))
         proxy  (if (:async? options)
                  (async-proxy-handler handler

ring-jetty-adapter/test/ring/adapter/test/jetty.clj

@@ -1,6 +1,6 @@
 (ns ring.adapter.test.jetty
-  (:require [clojure.test :refer :all]
-            [ring.adapter.jetty :refer :all]
+  (:require [clojure.test :refer [deftest is testing]]
+            [ring.adapter.jetty :refer [run-jetty]]
             [clj-http.client :as http]
             [clojure.java.io :as io]
             [hato.websocket :as hato]
@@ -10,7 +10,6 @@
             [ring.websocket.protocols :as wsp])
   (:import [java.nio ByteBuffer]
            [org.eclipse.jetty.util.thread QueuedThreadPool]
-           [org.eclipse.jetty.util BlockingArrayQueue]
            [org.eclipse.jetty.server Server Request SslConnectionFactory]
            [org.eclipse.jetty.server.handler AbstractHandler]
            [java.net ServerSocket ConnectException]
@@ -19,7 +18,7 @@
                     IOException]
            [org.apache.http MalformedChunkCodingException]))
 
-(defn- hello-world [request]
+(defn- hello-world [_request]
   {:status  200
    :headers {"Content-Type" "text/plain"}
    :body    "Hello World"})
@@ -55,10 +54,10 @@
        (finally (.stop server#)))))
 
 (defn- find-free-local-port []
-  (let [socket (ServerSocket. 0)]
-    (let [port (.getLocalPort socket)]
-      (.close socket)
-      port)))
+  (let [socket (ServerSocket. 0)
+        port   (.getLocalPort socket)]
+    (.close socket)
+    port))
 
 (defn- get-ssl-context-factory
   [^Server s]
@@ -327,7 +326,8 @@
 
   (testing "request translation"
     (with-server echo-handler {:port test-port}
-      (let [response (http/post (str test-url "/foo/bar/baz?surname=jones&age=123") {:body "hello"})]
+      (let [response (http/post (str test-url "/foo/bar/baz?surname=jones&age=123")
+                                {:body "hello"})]
         (is (= (:status response) 200))
         (is (= (:body response) "hello"))
         (let [request-map (read-string (get-in response [:headers "request-map"]))]
@@ -421,7 +421,7 @@
           (is (= thread-count (count (all-threads)))))))))
 
 (defn- chunked-stream-with-error
-  ([request]
+  ([_request]
    {:status  200
     :headers {"Transfer-Encoding" "chunked"}
     :body    (SequenceInputStream.
@@ -431,16 +431,16 @@
                    ([] (throw (IOException. "test error")))
                    ([^bytes _] (throw (IOException. "test error")))
                    ([^bytes _ _ _] (throw (IOException. "test error"))))))})
-  ([request response raise]
+  ([request response _raise]
    (response (chunked-stream-with-error request))))
 
 (defn- chunked-lazy-seq-with-error
-  ([request]
+  ([_request]
    {:status  200
     :headers {"Transfer-Encoding" "chunked"}
     :body    (lazy-cat (range 100000)
                        (throw (IOException. "test error")))})
-  ([request response raise]
+  ([request response _raise]
    (response (chunked-lazy-seq-with-error request))))
 
 (deftest streaming-with-error
@@ -462,20 +462,20 @@
 
 (def thread-exceptions (atom []))
 
-(defn- hello-world-cps [request respond raise]
+(defn- hello-world-cps [_request respond _raise]
   (respond {:status  200
             :headers {"Content-Type" "text/plain"}
             :body    "Hello World"}))
 
-(defn- hello-world-cps-future [request respond raise]
+(defn- hello-world-cps-future [_request respond _raise]
   (future
     (try (respond {:status  200
                    :headers {"Content-Type" "text/plain"}
                    :body    "Hello World"})
          (catch Exception ex
            (swap! thread-exceptions conj ex)))))
 
-(defn- hello-world-streaming [request respond raise]
+(defn- hello-world-streaming [_request respond _raise]
   (future
     (respond
      {:status  200
@@ -491,7 +491,7 @@
                        (.write w "data: world\n\n")
                        (.flush w)))))})))
 
-(defn- hello-world-streaming-long [request respond raise]
+(defn- hello-world-streaming-long [_request respond _raise]
   (respond
    {:status  200
     :headers {"Content-Type" "text/event-stream"}
@@ -504,15 +504,15 @@
                        (.write w (str "data: " i "\n\n"))
                        (.flush w))))))}))
 
-(defn- error-cps [request respond raise]
+(defn- error-cps [_request _respond raise]
   (raise (ex-info "test" {:foo "bar"})))
 
 (defn- sometimes-error-cps [request respond raise]
   (if (= (:uri request) "/error")
     (error-cps request respond raise)
     (hello-world-cps request respond raise)))
 
-(defn- hello-world-slow-cps [request respond raise]
+(defn- hello-world-slow-cps [_request respond _raise]
   (future (Thread/sleep 1000)
           (respond {:status  200
                     :headers {"Content-Type" "text/plain"}
@@ -583,7 +583,7 @@
         {:port test-port
          :async? true
          :async-timeout 200
-         :async-timeout-handler (fn [request respond raise]
+         :async-timeout-handler (fn [_request respond _raise]
                                   (respond
                                    {:status 503
                                     :headers {"Content-Type" "text/plain"}
@@ -598,7 +598,7 @@
         {:port test-port
          :async? true
          :async-timeout 200
-         :async-timeout-handler (fn [request respond raise]
+         :async-timeout-handler (fn [_request _respond raise]
                                   (raise
                                    (ex-info "An exception was thrown" {})))}
         (let [response (http/get (str test-url "/test-path/testing")
@@ -610,11 +610,11 @@
 
 (def call-count (atom 0))
 
-(defn- broken-handler [request]
+(defn- broken-handler [_request]
   (swap! call-count inc)
   (throw (ex-info "unhandled exception" {})))
 
-(defn- broken-handler-cps [request respond raise]
+(defn- broken-handler-cps [_request _respond raise]
   (swap! call-count inc)
   (raise (ex-info "unhandled exception" {})))
 
@@ -778,7 +778,7 @@
                       (on-message [_ _ _])
                       (on-pong [_ _ _])
                       (on-error [_ _ _])
-                      (on-close [_ _ code reason]
+                      (on-close [_ _ _ _]
                         (swap! log conj [:close])))})]
       (with-server handler {:port test-port}
         (hato/websocket test-websocket-url {})
@@ -787,8 +787,7 @@
              @log))))
 
   (testing "subprotocols"
-    (let [log     (atom [])
-          handler (constantly
+    (let [handler (constantly
                    {::ws/protocol "mqtt"
                     ::ws/listener
                     (reify wsp/Listener