CODEWITHSUNDEEP
haskellprocessioipc
Damian Nadales
Damian Nadales

Reputation: 5037

Reading a couple of lines of a pipe obtained with createProcess and then closing it

I have a function that spawns a process as follows:

(_, Just outh, _, ph) <- createProcess $
    (proc "someproc" []) { std_out = CreatePipe }
line <- hGetLine outh
doSomeComputationOn line
-- ... 'outh' is not read anymore from here onwards

So "someproc" is created, and then the parent reads a line from it to obtain some information, and then it forgets about the pipe whose handle is outh.

Now the problem is that if the pipe is not read, "someproc" will block as soon as it is full. So this requires that the parent process reads outh even if it does not do anything with it. So my questions are:

  1. Is this this a good way to get the first line of a child process' output and then forget about additional output?
  2. Is there any way in Haskell in which I can automatically discard the input to the pipe (or even redirect it to a file)?.

So far the only way I can see to woraround this problem is spawning a new thread that constantly tries to read from outh (and just discards the output), which indicates that I'm doing something wrong ...

As additional background, this question is related to this one.

Upvotes: 1

Views: 340

Answers (2)

danidiaz
danidiaz

Reputation: 27766

Now the problem is that if the pipe is not read, "someproc" will block as soon as it is full. [...] Is there any way in Haskell in which I can automatically discard the input to the pipe (or even redirect it to a file)?

There is a helper library for process called process-streaming (written by the author of this answer) that tries to do just that: even if the user passes a stream-consuming function that doesn't exhaust a standard stream, it drains the stream automatically under the hood to avoid potential deadlocks.

The library doesn't work directly with handles, but accepts pipe-consuming functions and foldl folds through an adapter type.

An example of reading the first line:

import           Data.Text.Lazy
import qualified Pipes.Prelude
import           System.Process.Streaming      (CreateProcess,shell,
                                                piped,execute,foldOut,transduce1,withCont)
import           System.Process.Streaming.Text (utf8x,foldedLines)

program :: CreateProcess
program = piped $ shell "{ echo aaa ; echo bbbb ; }"

firstLine :: IO (Maybe Text)
firstLine = execute program streams
    where
    streams = foldOut
            . transduce1 utf8x
            . transduce1 foldedLines
            $ withCont Pipes.Prelude.head

The library has a much bigger dependency footprint than process though.

Upvotes: 1

chi
chi

Reputation: 116139

The alternative to use depends on the behavior of the external command.

If you simply want to interrupt that, you can hClose outh. This will close the pipe, and further writes to the pipe by the external command will fail with a "broken pipe" error. Most processes terminate upon receiving this.

If you instead want to read and discard the output, you can do that as well. Perhaps the easiest way is

do c <- hGetContents outh
   evaluate (length c)  -- force this to fetch all data
   doStuff              -- now we are sure that the remote end closed its output

which should run in constant space.

If you don't want to wait for the process to end before performing doStuff, wrap everything in forkIO.

Upvotes: 1

Related Questions