more OsPath conversion

Sponsored-by: Brock Spratlen

Annex/Ssh.hs

@@ -40,14 +40,14 @@ import Types.Concurrency
 import Git.Env
 import Git.Ssh
 import qualified Utility.RawFilePath as R
+import qualified Utility.OsString as OS
 import Annex.Perms
 #ifndef mingw32_HOST_OS
 import Annex.LockPool
 #endif
 
 import Control.Concurrent.STM
-import qualified Data.ByteString as S
-import qualified System.FilePath.ByteString as P
+import qualified Data.ByteString.Short as SBS
 
 {- Some ssh commands are fed stdin on a pipe and so should be allowed to
  - consume it. But ssh commands that are not piped stdin should generally
@@ -101,15 +101,15 @@ consumeStdinParams NoConsumeStdin = [Param "-n"]
 
 {- Returns a filename to use for a ssh connection caching socket, and
  - parameters to enable ssh connection caching. -}
-sshCachingInfo :: (SshHost, Maybe Integer) -> Annex (Maybe RawFilePath, [CommandParam])
+sshCachingInfo :: (SshHost, Maybe Integer) -> Annex (Maybe OsPath, [CommandParam])
 sshCachingInfo (host, port) = go =<< sshCacheDir'
   where
 	go (Right dir) =
-		liftIO (bestSocketPath $ dir P.</> hostport2socket host port) >>= return . \case
+		liftIO (bestSocketPath $ dir </> hostport2socket host port) >>= return . \case
 			Nothing -> (Nothing, [])
 			Just socketfile -> 
 				(Just socketfile
-				, sshConnectionCachingParams (fromRawFilePath socketfile)
+				, sshConnectionCachingParams (fromOsPath socketfile)
 				)
 	-- No connection caching with concurrency is not a good
 	-- combination, so warn the user.
@@ -137,10 +137,10 @@ sshCachingInfo (host, port) = go =<< sshCacheDir'
  - file.
  -
  - If no path can be constructed that is a valid socket, returns Nothing. -}
-bestSocketPath :: RawFilePath -> IO (Maybe RawFilePath)
+bestSocketPath :: OsPath -> IO (Maybe OsPath)
 bestSocketPath abssocketfile = do
 	relsocketfile <- liftIO $ relPathCwdToFile abssocketfile
-	let socketfile = if S.length abssocketfile <= S.length relsocketfile
+	let socketfile = if OS.length abssocketfile <= OS.length relsocketfile
 		then abssocketfile
 		else relsocketfile
 	return $ if valid_unix_socket_path socketfile sshgarbagelen
@@ -167,10 +167,10 @@ sshSocketDirEnv = "GIT_ANNEX_SSH_SOCKET_DIR"
  - 
  - The directory will be created if it does not exist.
  -}
-sshCacheDir :: Annex (Maybe RawFilePath)
+sshCacheDir :: Annex (Maybe OsPath)
 sshCacheDir = eitherToMaybe <$> sshCacheDir'
 
-sshCacheDir' :: Annex (Either String RawFilePath)
+sshCacheDir' :: Annex (Either String OsPath)
 sshCacheDir' = 
 	ifM (fromMaybe BuildInfo.sshconnectioncaching . annexSshCaching <$> Annex.getGitConfig)
 		( ifM crippledFileSystem
@@ -191,9 +191,9 @@ sshCacheDir' =
 	gettmpdir = liftIO $ getEnv sshSocketDirEnv
 
 	usetmpdir tmpdir = do
-		let socktmp = tmpdir </> "ssh"
+		let socktmp = toOsPath tmpdir </> literalOsPath "ssh"
 		createDirectoryIfMissing True socktmp
-		return (toRawFilePath socktmp)
+		return socktmp
 	
 	crippledfswarning = unwords
 		[ "This repository is on a crippled filesystem, so unix named"
@@ -216,7 +216,7 @@ portParams (Just port) = [Param "-p", Param $ show port]
  - Locks the socket lock file to prevent other git-annex processes from
  - stopping the ssh multiplexer on this socket.
  -}
-prepSocket :: RawFilePath -> SshHost -> [CommandParam] -> Annex ()
+prepSocket :: OsPath -> SshHost -> [CommandParam] -> Annex ()
 prepSocket socketfile sshhost sshparams = do
 	-- There could be stale ssh connections hanging around
 	-- from a previous git-annex run that was interrupted.
@@ -288,11 +288,11 @@ prepSocket socketfile sshhost sshparams = do
  - and this check makes such files be skipped since the corresponding lock
  - file won't exist.
  -}
-enumSocketFiles :: Annex [RawFilePath]
+enumSocketFiles :: Annex [OsPath]
 enumSocketFiles = liftIO . go =<< sshCacheDir
   where
 	go Nothing = return []
-	go (Just dir) = filterM (R.doesPathExist . socket2lock)
+	go (Just dir) = filterM (R.doesPathExist . fromOsPath . socket2lock)
 		=<< filter (not . isLock)
 		<$> catchDefaultIO [] (dirContents dir)
 
@@ -326,45 +326,45 @@ sshCleanup = mapM_ cleanup =<< enumSocketFiles
 forceSshCleanup :: Annex ()
 forceSshCleanup = mapM_ forceStopSsh =<< enumSocketFiles
 
-forceStopSsh :: RawFilePath -> Annex ()
+forceStopSsh :: OsPath -> Annex ()
 forceStopSsh socketfile = withNullHandle $ \nullh -> do
-	let (dir, base) = splitFileName (fromRawFilePath socketfile)
+	let (dir, base) = splitFileName socketfile
 	let p = (proc "ssh" $ toCommand $
 		[ Param "-O", Param "stop" ] ++ 
-		sshConnectionCachingParams base ++ 
+		sshConnectionCachingParams (fromOsPath base) ++ 
 		[Param "localhost"])
-		{ cwd = Just dir
+		{ cwd = Just (fromOsPath dir)
 		-- "ssh -O stop" is noisy on stderr even with -q
 		, std_out = UseHandle nullh
 		, std_err = UseHandle nullh
 		}
 	void $ liftIO $ catchMaybeIO $ withCreateProcess p $ \_ _ _ pid ->
 		forceSuccessProcess p pid
-	liftIO $ removeWhenExistsWith R.removeLink socketfile
+	liftIO $ removeWhenExistsWith R.removeLink (fromOsPath socketfile)
 
 {- This needs to be as short as possible, due to limitations on the length
  - of the path to a socket file. At the same time, it needs to be unique
  - for each host.
  -}
-hostport2socket :: SshHost -> Maybe Integer -> RawFilePath
+hostport2socket :: SshHost -> Maybe Integer -> OsPath
 hostport2socket host Nothing = hostport2socket' $ fromSshHost host
 hostport2socket host (Just port) = hostport2socket' $
 	fromSshHost host ++ "!" ++ show port
-hostport2socket' :: String -> RawFilePath
+hostport2socket' :: String -> OsPath
 hostport2socket' s
-	| length s > lengthofmd5s = toRawFilePath $ show $ md5 $ encodeBL s
-	| otherwise = toRawFilePath s
+	| length s > lengthofmd5s = toOsPath $ show $ md5 $ encodeBL s
+	| otherwise = toOsPath s
   where
 	lengthofmd5s = 32
 
-socket2lock :: RawFilePath -> RawFilePath
+socket2lock :: OsPath -> OsPath
 socket2lock socket = socket <> lockExt
 
-isLock :: RawFilePath -> Bool
-isLock f = lockExt `S.isSuffixOf` f
+isLock :: OsPath -> Bool
+isLock f = lockExt `OS.isSuffixOf` f
 
-lockExt :: S.ByteString
-lockExt = ".lock"
+lockExt :: OsPath
+lockExt = literalOsPath ".lock"
 
 {- This is the size of the sun_path component of sockaddr_un, which
  - is the limit to the total length of the filename of a unix socket.
@@ -376,8 +376,9 @@ sizeof_sockaddr_un_sun_path = 100
 
 {- Note that this looks at the true length of the path in bytes, as it will
  - appear on disk. -}
-valid_unix_socket_path :: RawFilePath -> Int -> Bool
-valid_unix_socket_path f n = S.length f + n < sizeof_sockaddr_un_sun_path
+valid_unix_socket_path :: OsPath -> Int -> Bool
+valid_unix_socket_path f n = 
+	SBS.length (fromOsPath f) + n < sizeof_sockaddr_un_sun_path
 
 {- Parses the SSH port, and returns the other OpenSSH options. If
  - several ports are found, the last one takes precedence. -}
@@ -463,7 +464,7 @@ sshOptionsTo remote gc localr
 				liftIO $ do
 					localr' <- addGitEnv localr sshOptionsEnv
 						(toSshOptionsEnv sshopts)
-					addGitEnv localr' gitSshEnv command
+					addGitEnv localr' gitSshEnv (fromOsPath command)
 
 runSshOptions :: [String] -> String -> IO ()
 runSshOptions args s = do