                 ;; Q: Is there anything interesting about the deferred that it
                 ;; currently returns?
                 (let [eventually-started (clnt/start! client)
-                      clnt->srvr (::clnt/chan->server @client)]
+                      clnt->srvr (::clnt/chan->server @client)
+                      ;; Start with one that prefers direct buffers, even though it doesn't
+                      ;; make a lot of sense for this test.
+                      ;; I'm as certain as I can be (without actual metrics) that's the most
+                      ;; realistic picture I'll get of the way it needs to really work
+                      mem-pool (io.netty.buffer.PooledByteBufAllocator. true)]
                   (assert (= chan->server clnt->srvr)
                           (str "Client channels don't match.\n"
                                "Expected:" chan->server
                                "\nHave:" clnt->srvr))
                   (assert chan->server)
-                  (let [write-hello (partial retrieve-hello chan<-client)
+                  (let [write-hello (partial retrieve-hello mem-pool chan<-client)
                         build-cookie (partial wrote-hello chan->client)
                         write-cookie (partial forward-cookie chan<-server)
                         ;; This pulls the Initiate packet from the client
                         get-cookie (partial wrote-cookie chan->server)
-                        write-vouch (partial vouch->server chan<-client)
+                        write-vouch (partial vouch->server mem-pool chan<-client)
                         get-server-response (partial wrote-vouch chan->client)
                         write-server-response (partial finalize chan<-server)
                         _ (println "interaction-test: Starting the stream "

  ;; Shouldn't be trying to re-use buffers produced at client side on the server.
  ;; And vice-versa.
  ;; That's just adding needless complexity
  (throw (RuntimeException. "Start by isolating the ByteBuf"))
  (let [options (build-hand-shake-options)
        ;; Note that the channel names in here seem backward.
        ;; Remember that they're really a mirror image:


(defn retrieve-hello
  "This is really a server-side method"
  [mem-pool client-chan hello]
  (log/info "Pulled HELLO from client")
  (let [n (.readableBytes hello)]
    (println "Have" n "bytes to write to " client-chan)
    (if (= 224 n)
      (let [copy (.directBuffer mem-pool n)]
        (.readBytes hello copy)
        (.release hello)
        (strm/try-put! (:chan client-chan)
                       {:message copy
                        :host "test-client"
                        :port 65536}
                       500
                       ::timed-out))
      (throw (RuntimeException. "Bad Hello")))))

(defn wrote-hello
  [client-chan success]
  (log/info "Wrote HELLO to server")
  (is success "Failed to write hello to server")
  (is (not= success ::timed-out "Timed out waiting for server to read HELLO"))
  ;; This is timing out both here and in the server side.
