Clojure Q&A - Recent questions tagged prepl

When using remote prepl server, repl is false, preventing use of add-lib and related functions

Thu, 06 Feb 2025 13:54:48 +0000

To reproduce:

clojure -J-Dclojure.server.jvm="{:port 5555 :accept clojure.core.server/io-prepl}"

Clojure 1.12.0
user=>

then

nc localhost 5555
*repl*
{:tag :ret, :val "false", :ns "user", :ms 0, :form "*repl*"}

prepl could have IDs for requests/responses

Sun, 02 Jun 2024 10:33:07 +0000

Given a pREPL client that evaluates this expr:

(do
    (-> (bound-fn []
          (dotimes [_ 4]
            (Thread/sleep 100)
            (println 1)))
        Thread.
        (doto .start))

    1)

Output will be, correctly:

{:tag :ret, :val 1, :ns user, :ms 4, :form (do
        (-> (bound-fn []
              (dotimes [_ 4]
                (Thread/sleep 100)
                (println 1)))
            Thread.
            (doto .start))

        1)}
{:tag :out, :val 1
}
{:tag :out, :val 1
}
{:tag :out, :val 1
}
{:tag :out, :val 1
}

Now, the problem is, that output that came from a thread may be printed anytime, maybe 1 minute from now.

During that time, many other pREPL requests may have been processed.

So in absence of an ID, a message like {:tag :out, :val 1} lacks sufficient context to be able to track where it's coming from.

Would adding IDs be a good idea?

How to create a short-lived remote-prepl such that it can be gracefully shutdown?

Tue, 27 Feb 2024 17:04:50 +0000

TLDR: How can I start a "one time use" remote-prepl connection that runs a single command, gets the return value, and then releases all resources used?

I asked this in slack but didn't receive a response. It's probably not usually a big deal in practice but it's been bothering me, so I figured I would more formally log it here.

I was under the impression that short lived remote-prepl clients is an intended usage. That it should enable one to connect to the remote, eval something, get the return value and disconnect.

Some example code I found to this effect is here:
https://github.com/Olical/how-to-be-a-repl-sorcerer/blob/b6bd530f3d0c6b165248d980d7ce6cd28e8da51f/src/sorcery/main.clj#L20

Modified slightly:

(ns prepl-question
  (:require [clojure.core.server :as server])
  (:import [java.io PipedReader PipedWriter]))

(def srv
  (server/start-server {:accept 'clojure.core.server/io-prepl
                        :port   0
                        :name   "srv"}))

(defn remote-eval [code]
  (with-open [reader (PipedReader.)
              writer (PipedWriter.)]
    (.connect reader writer)
    (let [result! (promise)]
      (future
        (server/remote-prepl
          "localhost" (.getLocalPort srv)
          reader
          (fn [msg]
            (deliver result! msg)))
        (println "DONE"))
      (.write writer code)
      (.flush writer)
      @result!

      ;; doesn't print "DONE"
      (let [r @result!]
        (.close reader)
        (.close writer)

        ;;(.write writer ":repl/quit\n") ;; also tried this
        ;;(.flush writer)

        r))))

(remote-eval "(+ 1 2 3)")

I've found no way to get "DONE" to print, signifying the stopping of the prepl thread loop, with any combination of closing the streams used.

Looking at the remote-prepl source code a bit, it seems like this line here will call close on the reader, but it will be called when the reader is already closed. But at least in the example above, I've found that this causes things to hang forever when close is called the second time. I'm guessing this is related to the issue described here: https://stackoverflow.com/a/45703662, related to the PipedReader/Writer setup.

But I'm not sure if this could be considered a bug in the prepl code or if I'm using it wrong.

prepl only issues referral warnings once - is that right?

Mon, 25 Apr 2022 22:51:24 +0000

When testing I noticed that my tests for certain warnings when evaluating code in the prepl pass once and then fail. The warnings are only issued once per session:

$ clojure -X clojure.core.server/start-server :name prepl :port 7777 :accept clojure.core.server/io-prepl :server-daemon false &
$ nc localhost 7777
(defn identity [x] x)
{:tag :ret, :val "#'user/identity", :ns "user", :ms 1, :form "(defn identity [x] x)"}
(binding [*out* *err*] (flush))
{:tag :err, :val "WARNING: identity already refers to: #'clojure.core/identity in namespace: user, being replaced by: #'user/identity\n"}
{:tag :ret, :val "nil", :ns "user", :ms 1, :form "(binding [*out* *err*] (flush))"}
(defn identity [x] x)
{:tag :ret, :val "#'user/identity", :ns "user", :ms 1, :form "(defn identity [x] x)"}
(binding [*out* *err*] (flush))
{:tag :ret, :val "nil", :ns "user", :ms 1, :form "(binding [*out* *err*] (flush))"}

Is this expected behavior?

clojure.core.server/io-prepl doesn't support read-line

Thu, 27 Jan 2022 21:42:53 +0000

Repro:

λ clj -Srepro -M -r
Clojure 1.10.3
user=> (read-line)
Hello, world!
"Hello, world!"
user=> (clojure.core.server/io-prepl)
(read-line)
{:tag :ret, :val "\"\"", :ns "user", :ms 2, :form "(read-line)"}

Notice how with io-prepl, (read-line) returns immediately without awaiting for user input and returns an empty string.

Calling either clojure.main/skip-if-eol or clojure.main/skip-whitespace after read+string in clojure.core.server/prepl appears to fix the issue, but it is admittedly unclear to me why that is.

prepl warnings remain buffered until explicit flushing from the client

Fri, 25 Jun 2021 13:56:30 +0000

In a prepl session, Clojure warnings remain buffered and won't be sent to the client without flushing explicitly from the client side.

Here is an example prepl session using netcat (the lines starting with ;; indicate responses from the prepl server):

$ clojure -X clojure.core.server/start-server :name prepl :port 5555 :accept clojure.core.server/io-prepl :server-daemon false &
$ nc localhost 5555

(set! *warn-on-reflection* true)
;; {:tag :ret, :val "true", :ns "user", :ms 2, :form "(set! *warn-on-reflection* true)"}

(.toString (identity "foo"))
;; {:tag :ret, :val "\"foo\"", :ns "user", :ms 4, :form "(.toString (identity \"foo\"))"}
(binding [*out* *err*] (flush))
;; {:tag :err, :val "Reflection warning, NO_SOURCE_PATH:2:1 - reference to field toString can't be resolved.\n"}
;; {:tag :ret, :val "nil", :ns "user", :ms 4, :form "(binding [*out* *err*] (flush))"}

(defn identity [x] x)
;; {:tag :ret, :val "#'user/identity", :ns "user", :ms 3, :form "(defn identity [x] x)"}
(binding [*out* *err*] (flush))
;; {:tag :err, :val "WARNING: identity already refers to: #'clojure.core/identity in namespace: user, being replaced by: #'user/identity\n"}
;; {:tag :ret, :val "nil", :ns "user", :ms 2, :form "(binding [*out* *err*] (flush))"}

This seems to be caused by the fact that prepl's *err* PrintWriter is not autoFlush-enabled and that most of the Clojure warnings are not flushed explicitly.

Is this an issue to be addressed? Or is it an intended behavior and it's the client's responsibility to flush the error stream on a timely basis?