Reflex.Process

Documentation

createProcess

Arguments

:: (MonadIO m, TriggerEvent t m, PerformEvent t m, MonadIO (Performable m))

=> CreateProcess

Specification of process to create

-> ProcessConfig t (SendPipe ByteString)

Reflex-level configuration for the process

-> m (Process t ByteString ByteString)

Create a process feeding it input using an Event and exposing its output Events representing the process exit code, stdout, and stderr.

The stdout and stderr Handles are line-buffered.

N.B. The process input is buffered with an unbounded channel! For more control of this, use createProcessBufferingInput directly.

N.B.: The std_in, std_out, and std_err parameters of the provided CreateProcess are replaced with new pipes and all output is redirected to those pipes.

createProcessBufferingInput

Arguments

:: (MonadIO m, TriggerEvent t m, PerformEvent t m, MonadIO (Performable m))

=> IO (SendPipe ByteString)

An action that reads a value from the input stream buffer. This must block when the buffer is empty or not ready.

-> (SendPipe ByteString -> IO ())

An action that writes a value to the input stream buffer.

-> CreateProcess

Specification of process to create

-> ProcessConfig t (SendPipe ByteString)

Reflex-level configuration for the process

-> m (Process t ByteString ByteString)

Create a process feeding it input using an Event and exposing its output with Events for its exit code, stdout, and stderr. The input is fed via a buffer represented by a reading action and a writing action.

The stdout and stderr Handles are line-buffered.

For example, you may use Chan for an unbounded buffer (like createProcess does) like this: > channel <- liftIO newChan > createProcessBufferingInput (readChan channel) (writeChan channel) myConfig

Similarly you could use TChan.

Bounded buffers may cause the Reflex network to block when you trigger an Event that would cause more data to be sent to a process whose stdin is blocked.

If an unbounded channel would lead to too much memory usage you will want to consider * speeding up the consuming process. * buffering with the file system or another persistent storage to reduce memory usage. * if your usa case allows, dropping Events or messages that aren't important.

N.B.: The std_in, std_out, and std_err parameters of the provided CreateProcess are replaced with new pipes and all output is redirected to those pipes.

defProcessConfig :: Reflex t => ProcessConfig t i

A default ProcessConfig where stdin and signals are never sent.

You can also use def.

unsafeCreateProcessWithHandles

Arguments

:: forall t m i o e. (MonadIO m, TriggerEvent t m, PerformEvent t m, MonadIO (Performable m))

=> (Handle -> IO (i -> IO ()))

Builder for the standard input handler. The Handle is the write end of the process' stdin and the resulting i -> IO () is a function that writes each input 'Event t i' to into Handle. This functios must not block or the entire Reflex network will block.

-> (Handle -> (o -> IO ()) -> IO (IO ()))

Builder for the standard output handler. The Handle is the read end of the process' stdout and the o -> IO () is a function that will trigger the output Event t o when called. The resulting IO () will be run in a separate thread and must block until there is no more data in the Handle to process.

-> (Handle -> (e -> IO ()) -> IO (IO ()))

Builder for the standard error handler. The Handle is the read end of the process' stderr and the e -> IO () is a function that will trigger the output Event t e when called. The resulting IO () will be run in a separate thread and must block until there is no more data in the Handle to process.

-> CreateProcess

Specification of process to create

-> ProcessConfig t i

Reflex-level configuration for the process

-> m (Process t o e)

Runs a process and uses the given input and output handler functions to interact with the process via the standard streams. Used to implement createProcess.

N.B.: The std_in, std_out, and std_err parameters of the provided CreateProcess are replaced with new pipes and all output is redirected to those pipes.

data Process t o e

The output of a process

Constructors

Process

Fields

• _process_handle :: ProcessHandle
• _process_stdout :: Event t o

  Fires whenever there's some new stdout output. Depending on the buffering strategy of the implementation, this could be anything from whole lines to individual characters.

• _process_stderr :: Event t e

  Fires whenever there's some new stderr output. See note on _process_stdout.

• _process_exit :: Event t ExitCode

  Fires when the process is over and no stdout or stderr data is left. Once this fires, no other Events for the process will fire again.

• _process_signal :: Event t Signal

  Fires when a signal has actually been sent to the process (via _processConfig_signal).

data ProcessConfig t i

The inputs to a process

Constructors

ProcessConfig

Fields

• _processConfig_stdin :: Event t i

  stdin input to be fed to the process

• _processConfig_signal :: Event t Signal

  Signals to send to the process

Instances

Reflex t => Default (ProcessConfig t i)

Defined in Reflex.Process

Methods

def :: ProcessConfig t i

data SendPipe i

Constructors

SendPipe_Message i

A message that's sent to the underlying process

SendPipe_EOF

Send an EOF to the underlying process

SendPipe_LastMessage i

Send the last message (an EOF will be added). This option is offered for convenience, because it has the same effect of sending a Message and then the EOF signal

createRedirectedProcess :: forall t m i o e. (MonadIO m, TriggerEvent t m, PerformEvent t m, MonadIO (Performable m)) => (Handle -> IO (i -> IO ())) -> (Handle -> (o -> IO ()) -> IO (IO ())) -> (Handle -> (e -> IO ()) -> IO (IO ())) -> CreateProcess -> ProcessConfig t i -> m (Process t o e)

Deprecated: Use unsafeCreateProcessWithHandles instead.