System.Unix.Process

functions for killing processes, running processes, etc

Strict process running

simpleProcess :: FilePath -> [String] -> IO (String, String, ExitCode)

simpleProcess - run a process returning (stdout, stderr, exitcode)

Warning - stdout and stderr will be read strictly so that we do not deadlock when trying to check the exitcode. Do not try doing something like, simpleProcess ["yes"]

NOTE: this may still dead-lock because we first strictly read outStr and then errStr. Perhaps we should use forkIO or something?

processResult :: FilePath -> [String] -> IO (Either Int (String, String))

processOutput :: FilePath -> [String] -> IO (Either Int String)

simpleCommand :: String -> IO (String, String, ExitCode)

commandResult :: String -> IO (Either Int (String, String))

commandOutput :: String -> IO (Either Int String)

Lazy process running

type Process = (Handle, Handle, Handle, ProcessHandle)

This is the type returned by runInteractiveProcess et. al.

data Output

The process returns a list of objects of type Output. There will be one Result object at the end of the list (if the list has an end.)

Constructors

Stdout ByteString

Stderr ByteString

Result ExitCode

Instances

Show Output

lazyRun :: ByteString -> Process -> IO [Output]

Take the tuple like that returned by runInteractiveProcess, create a process, send the list of inputs to its stdin and return the lazy list of Output objects.

lazyCommand :: String -> ByteString -> IO [Output]

Current verbosity level.

Create a process with runInteractiveCommand and run it with lazyRun.

lazyProcess :: FilePath -> [String] -> Maybe FilePath -> Maybe [(String, String)] -> ByteString -> IO [Output]

Create a process with runInteractiveProcess and run it with lazyRun.

stdoutOnly :: [Output] -> ByteString

Filter everything except stdout from the output list.

stderrOnly :: [Output] -> ByteString

Filter everything except stderr from the output list.

outputOnly :: [Output] -> ByteString

Filter the exit codes output list and merge the two output streams in the order they appear.

checkResult :: (Int -> a) -> a -> [Output] -> a

discardStdout :: [Output] -> [Output]

discardStderr :: [Output] -> [Output]

discardOutput :: [Output] -> [Output]

mergeToStderr :: [Output] -> [Output]

Turn all the Stdout text into Stderr, preserving the order.

mergeToStdout :: [Output] -> [Output]

Turn all the Stderr text into Stdout, preserving the order.

collectStdout :: [Output] -> (ByteString, [Output])

Split out and concatenate Stdout

collectStderr :: [Output] -> (ByteString, [Output])

Split out and concatenate Stderr

collectOutput :: [Output] -> (ByteString, ByteString, [ExitCode])

Split out and concatenate both Stdout and Stderr, leaving only the exit code.

collectOutputUnpacked :: [Output] -> (String, String, [ExitCode])

Collect all output, unpack and concatenate.

data ExitCode

Constructors

ExitSuccess

indicates successful termination;

ExitFailure Int

indicates program failure with an exit code. The exact interpretation of the code is operating-system dependent. In particular, some values may be prohibited (e.g. 0 on a POSIX-compliant system).

Instances

Eq ExitCode

Ord ExitCode

Read ExitCode

Show ExitCode

Typeable ExitCode

Exception ExitCode

exitCodeOnly :: [Output] -> [ExitCode]

Filter everything except the exit code from the output list.

hPutNonBlocking :: Handle -> ByteString -> IO Int64

This belongs in Data.ByteString. See ticket 1070, http://hackage.haskell.org/trac/ghc/ticket/1070.

Process killing

killByCwd :: FilePath -> IO [(String, Maybe String)]

Kill the processes whose working directory is in or under the given directory.