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] -> IO CoProcessHandle
start command params = do
	(from, to, _err, pid) <- runInteractiveProcess command params Nothing Nothing
	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
			`start :: FilePath -> [String] -> IO CoProcessHandle`
switch from System.Cmd.Utils to System.Process Test suite now passes with -threaded! I traced back all the hangs with -threaded to System.Cmd.Utils. It seems it's just crappy/unsafe/outdated, and should not be used. System.Process seems to be the cool new thing, so converted all the code to use it instead. In the process, --debug stopped printing commands it runs. I may try to bring that back later. Note that even SafeSystem was switched to use System.Process. Since that was a modified version of code from System.Cmd.Utils, it needed to be converted too. I also got rid of nearly all calls to forkProcess, and all calls to executeFile, which I'm also doubtful about working well with -threaded. 2012-07-18 19:30:26 +00:00			`start command params = do`
			`(from, to, _err, pid) <- runInteractiveProcess command params Nothing Nothing`
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`