mirrors/git-annex
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

recompute closer to working properly

Browse source 
Proper behavior without --others implemented.

And eliminated most of the code duplication through refactoring.

Also, changed it to not stage recomputed files. This way, git diff will
show files that have differences.
This commit is contained in:
Joey Hess 2025-02-26 15:51:31 -04:00
parent 53d107ca47
commit d6a010a615
No known key found for this signature in database
GPG key ID: DB12DB0FF05F8F38
3 changed files with 81 additions and 113 deletions
Download patch file Download diff file Expand all files Collapse all files

78
Command/Recompute.hs
View file

@ -15,14 +15,9 @@ import qualified Remote.Compute
import qualified Remote
import qualified Types.Remote as Remote
import Annex.CatFile
import Annex.Ingest
import Git.FilePath
import Types.KeySource
import Messages.Progress
import Logs.Location
import Utility.Metered
import Backend.URL (fromUrl)
import Command.AddComputed (Reproducible(..), parseReproducible, getInputContent)
import Command.AddComputed (Reproducible(..), parseReproducible, getInputContent, getInputContent', addComputed)
import qualified Data.Map as M
@ -111,81 +106,28 @@ start' o r si file key =
-- recompute. This way, the user will see the
-- computation fail, with an error message that
-- explains the problem.
-- XXX check that this works well
Nothing -> True
perform :: RecomputeOptions -> Remote -> OsPath -> Key -> Remote.Compute.ComputeState -> CommandPerform
perform o r file key oldstate = do
program <- Remote.Compute.getComputeProgram r
let recomputestate = oldstate
{ Remote.Compute.computeInputs = mempty
, Remote.Compute.computeOutputs = mempty
}
fast <- Annex.getRead Annex.fast
showOutput
Remote.Compute.runComputeProgram program recomputestate
(Remote.Compute.ImmutableState False)
Remote.Compute.runComputeProgram program oldstate
(Remote.Compute.ImmutableState True)
(getinputcontent program fast)
(go fast)
(addComputed "processing" False r (reproducible o) wantfile fast)
next $ return True
where
getinputcontent program fast p
| originalOption o =
| originalOption o =
case M.lookup p (Remote.Compute.computeInputs oldstate) of
Just inputkey -> return (inputkey, Nothing)
Just inputkey -> getInputContent' fast inputkey
(fromOsPath p ++ "(key " ++ serializeKey inputkey ++ ")")
Nothing -> Remote.Compute.computationBehaviorChangeError program
"requesting a new input file" p
| otherwise = getInputContent fast p
go fast state tmpdir ts = do
let outputs = Remote.Compute.computeOutputs state
when (M.null outputs) $
giveup "The computation succeeded, but it did not generate any files."
oks <- forM (M.keys outputs) $ \outputfile -> do
showAction $ "adding " <> QuotedPath outputfile
k <- catchNonAsync (addfile fast state tmpdir outputfile)
(\err -> giveup $ "Failed to ingest output file " ++ fromOsPath outputfile ++ ": " ++ show err)
return (outputfile, Just k)
let state' = state
{ Remote.Compute.computeOutputs = M.fromList oks
}
forM_ (mapMaybe snd oks) $ \k -> do
Remote.Compute.setComputeState
(Remote.remoteStateHandle r)
k ts state'
logChange NoLiveUpdate k (Remote.uuid r) InfoPresent
addfile fast state tmpdir outputfile
| fast = do
addSymlink outputfile stateurlk Nothing
return stateurlk
| isreproducible state = do
sz <- liftIO $ getFileSize outputfile'
metered Nothing sz Nothing $ \_ p ->
ingestwith $ ingestAdd p (Just ld)
| otherwise = ingestwith $
ingestAdd' nullMeterUpdate (Just ld) (Just stateurlk)
where
stateurl = Remote.Compute.computeStateUrl r state outputfile
stateurlk = fromUrl stateurl Nothing True
outputfile' = tmpdir </> outputfile
ld = LockedDown ldc $ KeySource
{ keyFilename = outputfile
, contentLocation = outputfile'
, inodeCache = Nothing
}
ingestwith a = a >>= \case
Nothing -> giveup "key generation failed"
Just k -> do
logStatus NoLiveUpdate k InfoPresent
return k
ldc = LockDownConfig
{ lockingFile = True
, hardlinkFileTmpDir = Nothing
, checkWritePerms = True
}
isreproducible state = case reproducible o of
Just v -> isReproducible v
Nothing -> Remote.Compute.computeReproducible state
wantfile outputfile
| othersOption o = True
| otherwise = outputfile == file