bb4f31a0ee
Baked into the code was an assumption that a repository's git directory could be determined by adding ".git" to its work tree (or nothing for bare repos). That fails when core.worktree, or GIT_DIR and GIT_WORK_TREE are used to separate the two. This was attacked at the type level, by storing the gitdir and worktree separately, so Nothing for the worktree means a bare repo. A complication arose because we don't learn where a repository is bare until its configuration is read. So another Location type handles repositories that have not had their config read yet. I am not entirely happy with this being a Location type, rather than representing them entirely separate from the Git type. The new code is not worse than the old, but better types could enforce more safety. Added support for core.worktree. Overriding it with -c isn't supported because it's not really clear what to do if a git repo's config is read, is not bare, and is then overridden to bare. What is the right git directory in this case? I will worry about this if/when someone has a use case for overriding core.worktree with -c. (See Git.Config.updateLocation) Also removed and renamed some functions like gitDir and workTree that misused git's terminology. One minor regression is known: git annex add in a bare repository does not print a nice error message, but runs git ls-files in a way that fails earlier with a less nice error message. This is because before --work-tree was always passed to git commands, even in a bare repo, while now it's not.
84 lines
2.8 KiB
Haskell
84 lines
2.8 KiB
Haskell
{- running git commands
|
|
-
|
|
- Copyright 2010-2012 Joey Hess <joey@kitenet.net>
|
|
-
|
|
- Licensed under the GNU GPL version 3 or higher.
|
|
-}
|
|
|
|
module Git.Command where
|
|
|
|
import qualified Data.Text.Lazy as L
|
|
import qualified Data.Text.Lazy.IO as L
|
|
import Control.Concurrent
|
|
import Control.Exception (finally)
|
|
|
|
import Common
|
|
import Git
|
|
import Git.Types
|
|
|
|
{- Constructs a git command line operating on the specified repo. -}
|
|
gitCommandLine :: [CommandParam] -> Repo -> [CommandParam]
|
|
gitCommandLine params Repo { location = l@(Local _ _ ) } = setdir : settree ++ params
|
|
where
|
|
setdir = Param $ "--git-dir=" ++ gitdir l
|
|
settree = case worktree l of
|
|
Nothing -> []
|
|
Just t -> [Param $ "--work-tree=" ++ t]
|
|
gitCommandLine _ repo = assertLocal repo $ error "internal"
|
|
|
|
{- Runs git in the specified repo. -}
|
|
runBool :: String -> [CommandParam] -> Repo -> IO Bool
|
|
runBool subcommand params repo = assertLocal repo $
|
|
boolSystem "git" $ gitCommandLine (Param subcommand : params) repo
|
|
|
|
{- Runs git in the specified repo, throwing an error if it fails. -}
|
|
run :: String -> [CommandParam] -> Repo -> IO ()
|
|
run subcommand params repo = assertLocal repo $
|
|
unlessM (runBool subcommand params repo) $
|
|
error $ "git " ++ subcommand ++ " " ++ show params ++ " failed"
|
|
|
|
{- Runs a git subcommand and returns its output, lazily.
|
|
-
|
|
- Note that this leaves the git process running, and so zombies will
|
|
- result unless reap is called.
|
|
-}
|
|
pipeRead :: [CommandParam] -> Repo -> IO String
|
|
pipeRead params repo = assertLocal repo $ do
|
|
(_, h) <- hPipeFrom "git" $ toCommand $ gitCommandLine params repo
|
|
fileEncoding h
|
|
hGetContents h
|
|
|
|
{- Runs a git subcommand, feeding it input.
|
|
- You should call either getProcessStatus or forceSuccess on the PipeHandle. -}
|
|
pipeWrite :: [CommandParam] -> L.Text -> Repo -> IO PipeHandle
|
|
pipeWrite params s repo = assertLocal repo $ do
|
|
(p, h) <- hPipeTo "git" (toCommand $ gitCommandLine params repo)
|
|
L.hPutStr h s
|
|
hClose h
|
|
return p
|
|
|
|
{- Runs a git subcommand, feeding it input, and returning its output.
|
|
- You should call either getProcessStatus or forceSuccess on the PipeHandle. -}
|
|
pipeWriteRead :: [CommandParam] -> String -> Repo -> IO (PipeHandle, String)
|
|
pipeWriteRead params s repo = assertLocal repo $ do
|
|
(p, from, to) <- hPipeBoth "git" (toCommand $ gitCommandLine params repo)
|
|
fileEncoding to
|
|
fileEncoding from
|
|
_ <- forkIO $ finally (hPutStr to s) (hClose to)
|
|
c <- hGetContents from
|
|
return (p, c)
|
|
|
|
{- Reads null terminated output of a git command (as enabled by the -z
|
|
- parameter), and splits it. -}
|
|
pipeNullSplit :: [CommandParam] -> Repo -> IO [String]
|
|
pipeNullSplit params repo =
|
|
filter (not . null) . split sep <$> pipeRead params repo
|
|
where
|
|
sep = "\0"
|
|
|
|
{- Reaps any zombie git processes. -}
|
|
reap :: IO ()
|
|
reap = do
|
|
-- throws an exception when there are no child processes
|
|
catchDefaultIO (getAnyProcessStatus False True) Nothing
|
|
>>= maybe noop (const reap)
|