(ns clojure.java.process

"A process invocation API wrapping the Java process API.

(:require

[clojure.java.io :as jio])

(:import

[java.io File InputStream OutputStream]

[java.lang ProcessBuilder ProcessBuilder$Redirect Process]

[java.util List]

[clojure.lang IDeref IBlockingDeref]

[java.util.concurrent Executors ExecutorService ThreadFactory]))

(set! *warn-on-reflection* true)

(def ^:private ^File null-file

(delay

(jio/file

(if (.startsWith (System/getProperty "os.name") "Windows")

"NUL"

"/dev/null"))))

(defn to-file

"Coerce f to a file per clojure.java.io/file and return a ProcessBuilder.Redirect writing to the file.

{:added "1.12"}

^ProcessBuilder$Redirect [f & {:keys [append] :as opts}]

(let [fo (jio/file f)]

(if append

(ProcessBuilder$Redirect/appendTo fo)

(ProcessBuilder$Redirect/to fo))))

(defn from-file

"Coerce f to a file per clojure.java.io/file and return a ProcessBuilder.Redirect reading from the file.

{:added "1.12"}

^ProcessBuilder$Redirect [f]

(ProcessBuilder$Redirect/from (jio/file f)))

(defn start

"Start an external command, defined in args.

{:added "1.12"}

^Process [& opts+args]

(let [[opts command] (if (map? (first opts+args))

[(first opts+args) (rest opts+args)]

[{} opts+args])

{:keys [in out err dir env clear-env]

:or {in :pipe, out :pipe, err :pipe, dir "."}} opts

pb (ProcessBuilder. ^List command)

to-redirect (fn to-redirect

[x]

(case x

:pipe ProcessBuilder$Redirect/PIPE

:inherit ProcessBuilder$Redirect/INHERIT

:discard (ProcessBuilder$Redirect/to @null-file)

;; in Java 9+, just use ProcessBuilder$Redirect/DISCARD

x))]

(.directory pb (jio/file dir))

(.redirectInput pb ^ProcessBuilder$Redirect (to-redirect in))

(.redirectOutput pb ^ProcessBuilder$Redirect (to-redirect out))

(if

(= err :stdout) (.redirectErrorStream pb true)

(.redirectError pb ^ProcessBuilder$Redirect (to-redirect err)))

(when clear-env

(.clear (.environment pb)))

(when env

(let [pb-env (.environment pb)]

(run! (fn [[k v]] (.put pb-env k v)) env)))

(.start pb)))

(defn stdin

"Given a process, return the stdin of the external process (an OutputStream)"

{:added "1.12"}

^OutputStream [^Process process]

(.getOutputStream process))

(defn stdout

"Given a process, return the stdout of the external process (an InputStream)"

{:added "1.12"}

^InputStream [^Process process]

(.getInputStream process))

(defn stderr

"Given a process, return the stderr of the external process (an InputStream)"

{:added "1.12"}

^InputStream [^Process process]

(.getErrorStream process))

(defn exit-ref

"Given a Process (the output of 'start'), return a reference that can be

{:added "1.12"}

[^Process process]

(reify

IDeref

(deref [_] (long (.waitFor process)))

IBlockingDeref

(deref [_ timeout-ms timeout-val]

(if (.waitFor process timeout-ms java.util.concurrent.TimeUnit/MILLISECONDS)

(long (.exitValue process))

timeout-val))))

(defonce ^:private io-thread-factory

(let [counter (atom 0)]

(reify ThreadFactory

(newThread [_ r]

(doto (Thread. r)

(.setName (str "Clojure Process IO " (swap! counter inc)))

(.setDaemon true))))))

(defonce ^:private io-executor

(Executors/newCachedThreadPool ^ThreadFactory io-thread-factory))

(defn io-task

{:skip-wiki true}

[^Runnable f]

(let [f (bound-fn* f)

fut (.submit ^ExecutorService io-executor ^Callable f)]

(reify

clojure.lang.IDeref

(deref [_] (#'clojure.core/deref-future fut))

clojure.lang.IBlockingDeref

(deref

[_ timeout-ms timeout-val]

(#'clojure.core/deref-future fut timeout-ms timeout-val))

clojure.lang.IPending

(isRealized [_] (.isDone fut))

java.util.concurrent.Future

(get [_] (.get fut))

(get [_ timeout unit] (.get fut timeout unit))

(isCancelled [_] (.isCancelled fut))

(isDone [_] (.isDone fut))

(cancel [_ interrupt?] (.cancel fut interrupt?)))))

(defn exec

"Execute a command and on successful exit, return the captured output,

{:added "1.12"}

[& opts+args]

(let [[opts command] (if (map? (first opts+args))

[(first opts+args) (rest opts+args)]

[{} opts+args])

opts (merge {:err :inherit} opts)]

(let [proc (apply start opts command)

captured (io-task #(slurp (stdout proc)))

exit (deref (exit-ref proc))]

(if (zero? exit)

@captured

(throw (RuntimeException. (str "Process failed with exit=" exit)))))))

(comment

;; shell out and inherit the i/o

(start {:out :inherit, :err :stdout} "ls" "-l")

;; write out and err to files, wait for process to exit, return exit code

@(exit-ref (start {:out (to-file "out") :err (to-file "err")} "ls" "-l"))

;; capture output to string

(-> (start "ls" "-l") stdout slurp)

;; with exec

(exec "ls" "-l")

;; read input from file

(-> (exec {:in (from-file "deps.edn")} "wc" "-l") clojure.string/trim parse-long)

)