system-posix-redirect-1.1.0.1: A toy module to temporarily redirect a program's stdout.

Copyright | Galois Inc. 2010
Maintainer | ezyang@galois.com
Stability | experimental
Portability | non-portable (POSIX, GHC)
Safe Haskell | Safe-Inferred
Language | Haskell98

System.Posix.Redirect

Contents

- Low-level operations

Description

Misbehaved third-party libraries (usually not written in Haskell) may print error messages directly to stdout or stderr when we would actually like to capture them and propagate them as a normal exception. In such cases, it would be useful to temporarily override those file descriptors to point to a pipe that we control.

This module is not portable and not thread safe. However, it can safely manage arbitrarily large amounts of data, as it spins off another thread to read from the pipe created; therefore, you must use -threaded to compile a program with this. If you are making a foreign call, you must ensure that the foreign call is marked safe or there is a possibility of deadlock.

While this module is an interesting novelty, it is the module author's opinion that it is not a sustainable method for making C libraries behave properly, primarily due to its unportability (this trick does not appear to be possible on Windows). Use at your own risk.

Synopsis

- redirectStdout :: IO a -> IO (ByteString, a)
- redirectStderr :: IO a -> IO (ByteString, a)
- redirectWriteHandle :: Fd -> Handle -> Ptr FILE -> IO a -> IO (ByteString, a)
- unsafeRedirectWriteFd :: Fd -> IO a -> IO (ByteString, a)

# Documentation

redirectStdout :: IO a -> IO (ByteString, a) Source #

``redirectStdout` f` redirects standard output during the execution of `f` into a pipe passed as the first argument to `f`.

redirectStderr :: IO a -> IO (ByteString, a) Source #

``redirectStderr` f` redirects standard error during the execution of `f` into a pipe passed as the first argument to `f`.

# Low-level operations

redirectWriteHandle :: Fd -> Handle -> Ptr FILE -> IO a -> IO (ByteString, a) Source #

``redirectWriteHandle` oldFd oldHandle oldCHandle f` executes the computation `f`, passing as an argument a handle which is the read end of a pipe that `fd` now points to. This function appropriately flushes the Haskell `oldHandle` and the C `oldCHandle` before and after `f`'s execution.

unsafeRedirectWriteFd :: Fd -> IO a -> IO (ByteString, a) Source #

``unsafeRedirectFd` fd f` executes the computation `f`, passing as an argument a handle which is the read end of a pipe that `fd` now points to. When the computation is done, the original file descriptor is restored. Use with care: if there are any file handles with this descriptor that have unflushed buffers, they will not flush to the old file descriptor, but the new file descriptor.