git-annex/Utility/CoProcess.hs

{- Interface for running a shell command as a coprocess,
 - sending it queries and getting back results.
 -
 - Copyright 2012 Joey Hess <joey@kitenet.net>
 -
 - Licensed under the GNU GPL version 3 or higher.
 -}

module Utility.CoProcess (
	CoProcessHandle,
	start,
	stop,
	query
) where

import Common

type CoProcessHandle = (ProcessHandle, Handle, Handle, CreateProcess)

start :: FilePath -> [String] -> Maybe [(String, String)] -> IO CoProcessHandle
start command params env = do
	(from, to, _err, pid) <- runInteractiveProcess command params Nothing env
	return (pid, to, from, proc command params)

stop :: CoProcessHandle -> IO ()
stop (pid, from, to, p) = do
	hClose to
	hClose from
	forceSuccessProcess p pid

query :: CoProcessHandle -> (Handle -> IO a) -> (Handle -> IO b) -> IO b
query (_, from, to, _) send receive = do
	_ <- send to
	hFlush to
	receive from
refactor 2012-02-20 19:20:36 +00:00			`{- Interface for running a shell command as a coprocess,`
			`- sending it queries and getting back results.`
			`-`
			`- Copyright 2012 Joey Hess <joey@kitenet.net>`
			`-`
			`- Licensed under the GNU GPL version 3 or higher.`
			`-}`

			`module Utility.CoProcess (`
			`CoProcessHandle,`
			`start,`
			`stop,`
			`query`
			`) where`

			`import Common`

add back debug logging Make Utility.Process wrap the parts of System.Process that I use, and add debug logging to them. Also wrote some higher-level code that allows running an action with handles to a processes stdin or stdout (or both), and checking its exit status, all in a single function call. As a bonus, the debug logging now indicates whether the process is being run to read from it, feed it data, chat with it (writing and reading), or just call it for its side effect. 2012-07-19 04:43:36 +00:00			`type CoProcessHandle = (ProcessHandle, Handle, Handle, CreateProcess)`
refactor 2012-02-20 19:20:36 +00:00
run git coprocesses with gitEnv 2012-09-15 21:25:05 +00:00			`start :: FilePath -> [String] -> Maybe [(String, String)] -> IO CoProcessHandle`
			`start command params env = do`
			`(from, to, _err, pid) <- runInteractiveProcess command params Nothing env`
add back debug logging Make Utility.Process wrap the parts of System.Process that I use, and add debug logging to them. Also wrote some higher-level code that allows running an action with handles to a processes stdin or stdout (or both), and checking its exit status, all in a single function call. As a bonus, the debug logging now indicates whether the process is being run to read from it, feed it data, chat with it (writing and reading), or just call it for its side effect. 2012-07-19 04:43:36 +00:00			`return (pid, to, from, proc command params)`
refactor 2012-02-20 19:20:36 +00:00
			`stop :: CoProcessHandle -> IO ()`
add back debug logging Make Utility.Process wrap the parts of System.Process that I use, and add debug logging to them. Also wrote some higher-level code that allows running an action with handles to a processes stdin or stdout (or both), and checking its exit status, all in a single function call. As a bonus, the debug logging now indicates whether the process is being run to read from it, feed it data, chat with it (writing and reading), or just call it for its side effect. 2012-07-19 04:43:36 +00:00			`stop (pid, from, to, p) = do`
refactor 2012-02-20 19:20:36 +00:00			`hClose to`
			`hClose from`
add back debug logging Make Utility.Process wrap the parts of System.Process that I use, and add debug logging to them. Also wrote some higher-level code that allows running an action with handles to a processes stdin or stdout (or both), and checking its exit status, all in a single function call. As a bonus, the debug logging now indicates whether the process is being run to read from it, feed it data, chat with it (writing and reading), or just call it for its side effect. 2012-07-19 04:43:36 +00:00			`forceSuccessProcess p pid`
refactor 2012-02-20 19:20:36 +00:00
			`query :: CoProcessHandle -> (Handle -> IO a) -> (Handle -> IO b) -> IO b`
add back debug logging Make Utility.Process wrap the parts of System.Process that I use, and add debug logging to them. Also wrote some higher-level code that allows running an action with handles to a processes stdin or stdout (or both), and checking its exit status, all in a single function call. As a bonus, the debug logging now indicates whether the process is being run to read from it, feed it data, chat with it (writing and reading), or just call it for its side effect. 2012-07-19 04:43:36 +00:00			`query (_, from, to, _) send receive = do`
refactor 2012-02-20 19:20:36 +00:00			`_ <- send to`
			`hFlush to`
			`receive from`