Drop wrap-future's "success" treatment of ClosedChannelException

Treating channel closes as successful in the deferred returned by
`wrap-future` is a bit of a footgun. For example, when used on an
`SSLHandler#handshakeFuture`, one would not just have to listen for
the operation to succeed but *also* check that the value returned from
the deferred isn't `false`. Instead, we now propagate
`ClosedChannelException` as an error just like any other to make the
API a bit less surprising. This allows us to remove said check from
the handshake future again.

Further note that other existing uses of `wrap-future` where this
could happen wrap the operation in a `.closeFuture` anyway which makes
this special-case unnecessary to begin with.

Also included is a test for showing that putting to a closed channel
sink still returns a successful deferred with a `false` value as per
`manifold.stream`'s API convention.

Author: DerGuteMoritz

src/aleph/netty.clj

@@ -232,9 +232,7 @@
      (d/error! d (CancellationException. "future is cancelled."))
 
      (some? (.cause f))
-     (if (instance? ClosedChannelException (.cause f))
-       (d/success! d false)
-       (d/error! d (.cause f)))
+     (d/error! d (.cause f))
 
      :else
      (d/error! d (IllegalStateException. "future in unknown state"))))

src/aleph/tcp.clj

@@ -62,12 +62,8 @@
          (-> ssl-handler
              .handshakeFuture
              netty/wrap-future
-             (d/on-realized (fn [ok?]
-                              ;; See
-                              ;; https://github.com/clj-commons/aleph/issues/618
-                              ;; for why this conditional is necessary
-                              (when ok?
-                                (call-handler ctx)))
+             (d/on-realized (fn [_]
+                              (call-handler ctx))
                             ;; No need to handle errors here since
                             ;; the SSL handler will terminate the
                             ;; whole pipeline by throwing a

test/aleph/netty_test.clj

@@ -0,0 +1,14 @@
+(ns aleph.netty-test
+  (:require
+   [aleph.netty :as netty]
+   [clojure.test :refer [deftest is]]
+   [manifold.stream :as s])
+  (:import
+   (io.netty.channel.embedded EmbeddedChannel)))
+
+(deftest closing-a-channel-sink
+  (let [ch (EmbeddedChannel.)
+        s (netty/sink ch)]
+    (is (= true @(s/put! s "foo")))
+    (is (nil? @(netty/wrap-future (netty/close ch))))
+    (is (= false @(s/put! s "foo")))))