hix 0.7.1 → 0.7.2

raw patch · 51 files changed

+1021/−266 lines, 51 filesdep ~aesonPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: aeson

API changes (from Hackage documentation)

Files

• hix.cabal +7/−3
• lib/Hix/Class/Map.hs +8/−0
• lib/Hix/Data/Json.hs +11/−0
• lib/Hix/Data/PackageId.hs +1/−1
• lib/Hix/Error.hs +4/−4
• lib/Hix/Managed/Build.hs +50/−32
• lib/Hix/Managed/Build/Mutation.hs +3/−3
• lib/Hix/Managed/Build/NixOutput.hs +226/−0
• lib/Hix/Managed/Build/NixOutput/Analysis.hs +16/−0
• lib/Hix/Managed/Build/Single.hs +4/−2
• lib/Hix/Managed/Build/Solve.hs +38/−9
• lib/Hix/Managed/Bump/App.hs +1/−3
• lib/Hix/Managed/Bump/Optimize.hs +1/−1
• lib/Hix/Managed/Cabal/Data/SolverState.hs +3/−2
• lib/Hix/Managed/Cabal/Data/SourcePackage.hs +19/−8
• lib/Hix/Managed/Cabal/Mock/SourcePackage.hs +18/−13
• lib/Hix/Managed/Cabal/Solve.hs +11/−4
• lib/Hix/Managed/Cabal/Source.hs +20/−0
• lib/Hix/Managed/Data/BuildConfig.hs +4/−2
• lib/Hix/Managed/Data/Mutation.hs +8/−1
• lib/Hix/Managed/Data/StageState.hs +23/−8
• lib/Hix/Managed/Handlers/Build.hs +9/−6
• lib/Hix/Managed/Handlers/Build/Prod.hs +178/−46
• lib/Hix/Managed/Handlers/Build/Test.hs +8/−8
• lib/Hix/Managed/Handlers/Cabal.hs +4/−0
• lib/Hix/Managed/Handlers/Cabal/Prod.hs +6/−2
• lib/Hix/Managed/Handlers/Hackage/Prod.hs +10/−3
• lib/Hix/Managed/Handlers/Mutation.hs +2/−1
• lib/Hix/Managed/Handlers/Mutation/Bump.hs +3/−3
• lib/Hix/Managed/Handlers/Mutation/Lower.hs +3/−3
• lib/Hix/Managed/Handlers/StateFile/Test.hs +1/−1
• lib/Hix/Managed/Lower/App.hs +2/−3
• lib/Hix/Managed/Lower/Auto.hs +1/−1
• lib/Hix/Managed/StageState.hs +3/−1
• lib/Hix/Managed/StateFile.hs +1/−1
• lib/Hix/Monad.hs +6/−2
• lib/Hix/Options.hs +1/−0
• test/Hix/Test/Hedgehog.hs +17/−5
• test/Hix/Test/Managed/Bump/MutationTest.hs +100/−48
• test/Hix/Test/Managed/BumpNativeTest.hs +135/−0
• test/Hix/Test/Managed/LowerAuto/MutationOptimizeTest.hs +4/−4
• test/Hix/Test/Managed/LowerAuto/MutationStabilizeTest.hs +4/−4
• test/Hix/Test/Managed/LowerInit/MutationTest.hs +5/−5
• test/Hix/Test/Managed/LowerNativeTest.hs +3/−2
• test/Hix/Test/Managed/LowerOptimize/CandidatesTest.hs +7/−4
• test/Hix/Test/Managed/LowerOptimize/MutationTest.hs +3/−3
• test/Hix/Test/Managed/LowerOptimize/OrderTest.hs +3/−3
• test/Hix/Test/Managed/LowerStabilize/MutationTest.hs +3/−3
• test/Hix/Test/Managed/Run.hs +3/−2
• test/Hix/Test/Managed/SolveTest.hs +12/−6
• test/Hix/Test/Managed/UnsafeIsString.hs +8/−0

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hix-version:        0.7.1+version:        0.7.2 synopsis:       Haskell/Nix development build tools description:    See https://hackage.haskell.org/package/hix/docs/Hix.html category:       Build@@ -65,6 +65,8 @@       Hix.Log       Hix.Managed.Build       Hix.Managed.Build.Mutation+      Hix.Managed.Build.NixOutput+      Hix.Managed.Build.NixOutput.Analysis       Hix.Managed.Build.Single       Hix.Managed.Build.Solve       Hix.Managed.BuildOutput@@ -91,6 +93,7 @@       Hix.Managed.Cabal.Resources       Hix.Managed.Cabal.Solve       Hix.Managed.Cabal.Sort+      Hix.Managed.Cabal.Source       Hix.Managed.Cabal.Targets       Hix.Managed.Constraints       Hix.Managed.Data.BuildConfig@@ -231,7 +234,7 @@   ghc-options: -Wall -Widentities -Wincomplete-uni-patterns -Wmissing-deriving-strategies -Wredundant-constraints -Wunused-type-patterns -Wunused-packages   build-depends:       Cabal-    , aeson >=2.0 && <2.2+    , aeson >=2.0 && <2.3     , base ==4.*     , bytestring     , cabal-install@@ -331,6 +334,7 @@       Hix.Test.Managed.BuildOutputTest       Hix.Test.Managed.Bump.CandidatesTest       Hix.Test.Managed.Bump.MutationTest+      Hix.Test.Managed.BumpNativeTest       Hix.Test.Managed.DiffTest       Hix.Test.Managed.LowerAuto.MutationOptimizeTest       Hix.Test.Managed.LowerAuto.MutationStabilizeTest@@ -391,7 +395,7 @@   ghc-options: -threaded -rtsopts -with-rtsopts=-N -Wall -Widentities -Wincomplete-uni-patterns -Wmissing-deriving-strategies -Wredundant-constraints -Wunused-type-patterns -Wunused-packages   build-depends:       Cabal-    , aeson >=2.0 && <2.2+    , aeson >=2.0 && <2.3     , base ==4.*     , exon >=1.4 && <1.7     , extra ==1.7.*

@@ -713,3 +713,11 @@   map nWithoutKeys keys =   nVia (`Map.withoutKeys` keys)++nMember ::+  NMap map k v sort =>+  k ->+  map ->+  Bool+nMember k =+  Map.member k . nGet

@@ -31,3 +31,14 @@   Parser a foldMissing o k =   fold <$> o .:? k++newtype JsonEither a b =+  JsonEither (Either a b)+  deriving stock (Eq, Show)++jsonEither :: JsonEither a b -> Either a b+jsonEither = coerce++instance (FromJSON a, FromJSON b) => FromJSON (JsonEither a b) where+  parseJSON v =+    JsonEither <$> ((Right <$> parseJSON v) <|> (Left <$> parseJSON v))

@@ -14,7 +14,7 @@     name :: PackageName,     version :: Version   }-  deriving stock (Eq, Show, Generic)+  deriving stock (Eq, Show, Ord, Generic)  renderPackage :: PackageId -> Text renderPackage PackageId {..} =

@@ -71,18 +71,18 @@   [exon|#{reason} the source file '#{pathText source}'|]  catchIO ::-  (Text -> ExceptT Error IO a) ->+  (Text -> ExceptT e IO a) ->   IO a ->-  ExceptT Error IO a+  ExceptT e IO a catchIO handleError ma =   liftIO (tryIOError ma) >>= \case     Right a -> pure a     Left err -> handleError (show err)  tryIOWith ::-  (Text -> Error) ->+  (Text -> e) ->   IO a ->-  ExceptT Error IO a+  ExceptT e IO a tryIOWith mkErr ma =   liftIO (tryIOError ma) >>= \case     Right a -> pure a

@@ -2,17 +2,22 @@  import Control.Monad (foldM) import qualified Data.Map.Strict as Map+import qualified Data.Text as Text import Distribution.Pretty (Pretty) import Exon (exon) import Text.PrettyPrint (vcat) -import Hix.Data.EnvName (EnvName)+import qualified Hix.Console+import Hix.Console (color, colors)+import Hix.Data.EnvName (EnvName (EnvName)) import Hix.Data.Monad (M) import Hix.Data.Overrides (Overrides)+import qualified Hix.Data.PackageId import Hix.Data.PackageId (PackageId) import Hix.Data.Version (Version, Versions) import Hix.Data.VersionBounds (VersionBounds) import qualified Hix.Log as Log+import Hix.Managed.Build.NixOutput (PackageDerivation (..)) import Hix.Managed.Build.Solve (solveMutation) import qualified Hix.Managed.Cabal.Changes import Hix.Managed.Cabal.Config (isNonReinstallableDep, isReinstallableId)@@ -33,13 +38,12 @@ import Hix.Managed.Data.StageContext (StageContext (StageContext)) import qualified Hix.Managed.Data.StageState import Hix.Managed.Data.StageState (-  BuildResult (Finished, TimedOut),-  BuildStatus (Failure, Success),-  StageState,+  BuildFailure (PackageFailure, TimeoutFailure),+  BuildResult (BuildFailure, BuildSuccess),+  BuildStatus,+  StageState (failed, iterations),   buildStatus,-  failed,   initStageState,-  iterations,   justSuccess,   ) import qualified Hix.Managed.Handlers.Build@@ -57,18 +61,28 @@   [PackageId] ->   M () logBuildInputs env description overrides = do-  Log.info [exon|Building targets in '##{env}' with #{description}...|]+  Log.info [exon|Building targets in #{color colors.yellow (coerce env)} with #{description}...|]   Log.debugP (vcat ["Overrides:", prettyL overrides])  logBuildResult :: Text -> BuildResult -> M () logBuildResult description result =-  Log.info [exon|Build with ##{description} #{describeResult result}|]+  Log.info [exon|Build with ##{description} #{describeResult result}#{describePackages result}|]   where     describeResult = \case-      Finished Success -> "succeeded"-      Finished Failure -> "failed"-      TimedOut -> "timed out"+      BuildSuccess -> "succeeded"+      BuildFailure (TimeoutFailure _) -> "timed out"+      BuildFailure _ -> "failed" +    describePackages = \case+      BuildFailure (TimeoutFailure pkgs) | not (null pkgs) -> packageFragment pkgs+      BuildFailure (PackageFailure pkgs) -> packageFragment ((.package) <$> toList pkgs)+      _ -> ""++    packageFragment pkgs =+      [exon| in #{names}|]+      where+        names = Text.intercalate ", " (color colors.blue . showP . (.name) <$> pkgs)+ updateMutationState ::   (Version -> VersionBounds -> VersionBounds) ->   Versions ->@@ -84,20 +98,19 @@   }  -- | /Note/: This quietly discards non-reinstallable packages.------ TODO Discard installed versions, for builds with initial versions. buildVersions ::   EnvBuilder ->   EnvContext ->   Text ->+  Bool ->   Versions ->   [PackageId] ->-  M (Overrides, BuildStatus)-buildVersions builder context description versions overrideVersions = do+  M (Overrides, Set PackageId, BuildStatus)+buildVersions builder context description allowRevisions versions overrideVersions = do   logBuildInputs context.env description reinstallable-  (overrides, status) <- builder.buildWithState versions reinstallable-  logBuildResult description status-  pure (overrides, buildStatus status)+  (result, (overrides, revisions)) <- builder.buildWithState allowRevisions versions reinstallable+  logBuildResult description result+  pure (overrides, revisions, buildStatus result)   where     reinstallable = filter isReinstallableId overrideVersions @@ -105,25 +118,30 @@   EnvBuilder ->   EnvContext ->   Text ->+  Bool ->+  Set PackageId ->   SolverState ->-  M (Maybe (Versions, Overrides, BuildStatus))-buildConstraints builder context description state =-  solveMutation builder.cabal context.deps state >>= traverse \ changes -> do-    (overrides, status) <- buildVersions builder context description changes.versions changes.overrides-    pure (changes.versions, overrides, status)+  M (Maybe (Versions, Overrides, Set PackageId, BuildStatus))+buildConstraints builder context description allowRevisions prevRevisions state =+  solveMutation builder.cabal context.deps prevRevisions state >>= traverse \ changes -> do+    (overrides, revisions, status) <-+      buildVersions builder context description allowRevisions changes.versions changes.overrides+    pure (changes.versions, overrides, prevRevisions <> revisions, status)  buildMutation ::   EnvBuilder ->   EnvContext ->   MutationState ->+  Set PackageId ->   BuildMutation ->-  M (Maybe MutationState)-buildMutation builder context state BuildMutation {description, solverState, updateBound} =-  result <$> buildConstraints builder context description solverState+  M (Maybe (MutationState, Set PackageId))+buildMutation builder context state prevRevisions BuildMutation {description, solverState, updateBound} =+  result <$> buildConstraints builder context description True prevRevisions solverState   where     result = \case-      Just (versions, overrides, status) ->-        justSuccess (updateMutationState updateBound versions overrides state) status+      Just (versions, overrides, revisions, status) -> do+        new <- justSuccess (updateMutationState updateBound versions overrides state) status+        pure (new, revisions)       Nothing -> Nothing  logMutationResult ::@@ -131,14 +149,14 @@   MutationResult s ->   M () logMutationResult package = \case-  MutationSuccess candidate True _ _ ->+  MutationSuccess {candidate, changed = True} ->     Log.verbose [exon|Build succeeded for #{showP candidate}|]-  MutationSuccess _ False _ _ ->+  MutationSuccess {changed = False} ->     Log.verbose [exon|Build is up to date for '##{package}'|]   MutationKeep ->     Log.verbose [exon|No better version found for '##{package}'|]   MutationFailed ->-    Log.verbose [exon|Could not find a buildable version of '##{package}'|]+    Log.verbose [exon|Could not find a buildable version of #{color colors.blue (showP package)}|]  validateMutation ::   EnvBuilder ->@@ -157,7 +175,7 @@       = pure MutationKeep       | otherwise       = handlers.process stageState.ext mutation build-    build = buildMutation envBuilder context stageState.state+    build = buildMutation envBuilder context stageState.state stageState.revisions  convergeMutations ::   Pretty a =>

@@ -56,18 +56,18 @@ -- TODO If we'd use the @retract@ field from @DepMutation@ and the target bound here, we could probably use a universal -- bounds updater without leaking implementation...investigate. buildCandidate ::-  (BuildMutation -> M (Maybe MutationState)) ->+  (BuildMutation -> M (Maybe (MutationState, Set PackageId))) ->   (Version -> VersionBounds -> VersionBounds) ->   (MutableId -> PackageId -> MutationConstraints -> MutationConstraints) ->   SolverState ->   MutableDep ->   Version ->-  M (Maybe (MutableId, SolverState, MutationState))+  M (Maybe (MutableId, SolverState, MutationState, Set PackageId)) buildCandidate build updateStateBound updateConstraintBound solverState package version = do   Log.debug [exon|Mutation constraints for #{showP candidate}: #{showP mutationSolverState.constraints}|]   fmap result <$> build (candidateMutation mutationSolverState candidate updateStateBound)   where-    result newState = (candidate, newSolverState newState, newState)+    result (newState, revisions) = (candidate, newSolverState newState, newState, revisions)      candidate = MutableId {name = package, version} 

@@ -0,0 +1,226 @@+module Hix.Managed.Build.NixOutput where++import Control.Monad.Trans.Class (lift)+import Control.Monad.Trans.State.Strict (StateT (runStateT), modify', state)+import qualified Data.Aeson as Aeson+import Data.Aeson (FromJSON, Value (String), withObject, (.:), (.:?))+import qualified Data.ByteString.Char8 as ByteString+import qualified Data.Map.Strict as Map+import Data.Map.Strict ((!?))+import qualified Data.Sequence as Seq+import Data.Sequence ((|>))+import Distribution.Compat.CharParsing (+  CharParsing (char, notChar, string),+  Parsing (notFollowedBy, try),+  digit,+  letter,+  lower,+  )+import Distribution.Parsec (Parsec, eitherParsec, parsec)+import Exon (exon)++import Hix.Data.Json (jsonEither)+import Hix.Data.Monad (M)+import qualified Hix.Data.PackageId as PackageId+import Hix.Data.PackageId (PackageId (..))+import qualified Hix.Log as Log+import Hix.Pretty (showP)++data Derivation =+  Derivation {+    path :: Text,+    log :: (Seq Text, Seq Text)+  }+  deriving stock (Eq, Show, Generic)++data PackageDerivation =+  PackageDerivation {+    package :: PackageId,+    success :: Bool,+    log :: [Text]+  }+  deriving stock (Eq, Show, Generic)++data BuildsState =+  BuildsState {+    id :: Integer,+    done :: Int,+    failed :: Int,+    unassigned :: [Bool]+  }+  deriving stock (Eq, Show, Generic)++data OutputState =+  OutputState {+    builds :: Maybe BuildsState,+    running :: Map Integer Derivation,+    finished :: [PackageDerivation]+  }+  deriving stock (Eq, Show, Generic)+  deriving anyclass (Default)++data OutputResult =+  OutputResult {+    failedPackages :: Maybe (NonEmpty PackageDerivation)+  }+  deriving stock (Eq, Show, Generic)++outputResult :: OutputState -> OutputResult+outputResult OutputState {finished} =+  OutputResult {failedPackages = nonEmpty (filter (not . (.success)) finished)}++runOutputState ::+  Monad m =>+  StateT OutputState m a ->+  m (a, OutputResult)+runOutputState ma =+  second outputResult <$> runStateT ma def++data NixAction =+  NixResult { aid :: Integer, rtype :: Int, fields :: [Either Text Int] }+  |+  NixStartBuilds Integer+  |+  NixStart Integer Text+  |+  NixStop Integer+  |+  NixStartOther Integer+  |+  NixMessage+  deriving stock (Eq, Show, Generic)++instance FromJSON NixAction where+  parseJSON =+    withObject "NixOutput" \ o ->+      o .: "action" >>= \case+        "result" -> do+          aid <- o .: "id"+          rtype <- o .: "type"+          fields <- fmap jsonEither <$> o .: "fields"+          pure NixResult {..}+        "start" -> do+          i <- o .: "id"+          o .:? "type" >>= \case+            Just (105 :: Int) ->+              o .: "fields" >>= \case+                String path : _ -> pure (NixStart i path)+                _ -> pure (NixStartOther i)+            Just 104 ->+              pure (NixStartBuilds i)+            _ -> pure (NixStartOther i)+        "stop" -> do+          i <- o .: "id"+          pure (NixStop i)+        "msg" -> pure NixMessage+        (act :: Text) -> fail [exon|Unknown action: #{toString act}|]++parseError :: String -> StateT s M ()+parseError err =+  lift $ Log.debug [exon|Nix output message parse error: #{toText err}|]++newtype StorePathName =+  StorePathName String+  deriving stock (Eq, Show, Generic)++instance Parsec StorePathName where+  parsec = do+    string "/nix/store/"+    some (lower <|> digit)+    char '-'+    pid0 <- some (notChar '.')+    pid <- some (notChar '.' <|> (try (char '.' <* notFollowedBy letter)))+    string ".drv"+    pure (StorePathName (pid0 <> pid))++addLogMessage :: Text -> Derivation -> Derivation+addLogMessage message Derivation {log = (current, prev), ..} =+  Derivation {log = updated, ..}+  where+    updated | Seq.length current > 100 = (pure message, current)+            | otherwise = (current |> message, prev)++finish :: Bool -> Derivation -> Either String PackageDerivation+finish success Derivation {path, log = (current, prev)} = do+  StorePathName name <- eitherParsec (toString path)+  package <- PackageId.fromCabal <$> eitherParsec name+  pure PackageDerivation {package, success, log = toList (prev <> current)}++tryFinish ::+  Maybe BuildsState ->+  Maybe Derivation ->+  (Maybe (Either Derivation PackageDerivation), [PackageDerivation], Maybe BuildsState)+tryFinish builds = \case+  Nothing -> (Nothing, [], builds)+  Just drv ->+    case finish success drv of+      Right pkg -> (Just (Right pkg), [pkg], newBuilds)+      Left _ -> (Just (Left drv), [], newBuilds)+  where+    (success, newBuilds) = case builds of+      Just s@BuildsState {unassigned = h : t} ->+        (h, Just s {unassigned = t})+      _ ->+        (False, builds)++reportFinished :: Either Derivation PackageDerivation -> StateT OutputState M ()+reportFinished result =+  lift $ Log.debug [exon|Nix build of #{desc} #{status}|]+  where+    (desc, status) = case result of+      Right PackageDerivation {package, success} -> (showP package, if success then "succeeded" else "failed")+      Left Derivation {path} -> (path, "finished with unknown status")++updateBuilds :: [Either Text Int] -> OutputState -> OutputState+updateBuilds [Right updatedDone, _, _, Right updatedFailed] s@OutputState {builds = Just bs@BuildsState {done, failed, unassigned}}+  | newDone > 0+  , newFailed == 0+  = s {builds = Just newBs {unassigned = unassigned ++ replicate newDone True}}+  | newFailed > 0+  , newDone == 0+  = s {builds = Just newBs {unassigned = unassigned ++ replicate newFailed False}}+  where+    newBs = bs {done = updatedDone, failed = updatedFailed}+    newDone = updatedDone - done+    newFailed = updatedFailed - failed+updateBuilds _ s = s++processResult :: Integer -> Int -> [Either Text Int] -> OutputState -> OutputState+processResult aid rtype fields s+  | rtype == 105+  , Just BuildsState {id = buildsId} <- s.builds+  , aid == buildsId+  = updateBuilds fields s+  | rtype == 101+  , Left message : _ <- fields+  = s {running = Map.adjust (addLogMessage message) aid s.running}+  | otherwise+  = s++processMessage ::+  ByteString ->+  NixAction ->+  StateT OutputState M ()+processMessage _ = \case+  NixResult {aid, rtype, fields} -> do+    -- lift (Log.debug (decodeUtf8 payload))+    modify' (processResult aid rtype fields)+  NixStartBuilds i -> modify' \ s -> s {builds = Just BuildsState {id = i, done = 0, failed = 0, unassigned = []}}+  NixStart i path -> do+    lift $ Log.debug [exon|Started build of #{path} (#{show i})|]+    modify' \ OutputState {running, ..} ->+      OutputState {running = Map.insert i (Derivation path mempty) running, ..}+  NixStop i -> do+    result <- state \ OutputState {running, ..} -> do+      let (result, package, newBuilds) = tryFinish builds (running !? i)+      (result, OutputState {running = Map.delete i running, finished = finished ++ package, builds = newBuilds, ..})+    traverse_ reportFinished result+  NixStartOther _ -> unit+  NixMessage -> unit++outputParse :: ByteString -> StateT OutputState M ()+outputParse outputLine+  | Just payload <- ByteString.stripPrefix "@nix " outputLine+  = either parseError (processMessage payload) (Aeson.eitherDecodeStrict' payload)+  | otherwise+  = lift (Log.debug (decodeUtf8 outputLine))

@@ -0,0 +1,16 @@+module Hix.Managed.Build.NixOutput.Analysis where++import Distribution.Parsec (simpleParsec)+import Distribution.Simple (Dependency)++import qualified Hix.Data.Dep as Dep+import Hix.Data.Dep (Dep)++analyzeLog :: [Text] -> Maybe (NonEmpty Dep)+analyzeLog log =+  nonEmpty bounds+  where+    bounds = catMaybes (takeWhile isJust (parseDep <$> afterBoundsMarker))+    afterBoundsMarker = drop 1 (dropWhile (boundsMarker /=) log)+    boundsMarker = "Error: Setup: Encountered missing or private dependencies:"+    parseDep = fmap Dep.fromCabal . simpleParsec @Dependency . toString

@@ -11,6 +11,8 @@ import Hix.Managed.Data.StageState (BuildStatus (Failure)) import Hix.Managed.Handlers.Build (EnvBuilder) +-- | Passes 'False' to 'buildConstraints' to disable revisions, since this function is used to check whether the current+-- configuration builds successful, and revisions modify the set of overrides on failure. buildVersions ::   EnvBuilder ->   EnvContext ->@@ -18,8 +20,8 @@   MutableVersions ->   M BuildStatus buildVersions builder context description versions =-  buildConstraints builder context description solver <&> \case-    Just (_, _, status) -> status+  buildConstraints builder context description False [] solver <&> \case+    Just (_, _, _, status) -> status     Nothing -> Failure   where     solver = solverState context.solverBounds context.deps (fromVersions exactVersion versions) def

@@ -1,9 +1,11 @@ module Hix.Managed.Build.Solve where +import Data.List (partition) import qualified Data.Set as Set+import Distribution.PackageDescription (customFieldsPD) import Distribution.Pretty (pretty) import Exon (exon)-import Text.PrettyPrint (hang)+import Text.PrettyPrint (hang, ($$), (<+>))  import Hix.Class.Map (nRestrictKeys) import Hix.Data.Monad (M)@@ -14,38 +16,65 @@ import qualified Hix.Log as Log import qualified Hix.Managed.Cabal.Changes import Hix.Managed.Cabal.Changes (SolverChanges (SolverChanges), SolverPlan (SolverPlan))+import qualified Hix.Managed.Cabal.Data.SolverState import Hix.Managed.Cabal.Data.SolverState (SolverState) import qualified Hix.Managed.Data.EnvContext import Hix.Managed.Data.EnvContext (EnvDeps) import Hix.Managed.Data.Mutable (depName) import qualified Hix.Managed.Handlers.Cabal import Hix.Managed.Handlers.Cabal (CabalHandlers)-import Hix.Pretty (showPL)+import Hix.Pretty (prettyL, showPL)  logNonReinstallable :: NonEmpty PackageId -> M () logNonReinstallable ids =   Log.verbose [exon|NOTE: Cabal solver suggested new versions for non-reinstallable packages: #{showPL ids}|] --- TODO Do we need to filter locals out of @matching@ or can those not be in there?+checkRevision ::+  Bool ->+  CabalHandlers ->+  PackageId ->+  Either PackageId PackageId+checkRevision forceRevisions cabal package+  | forceRevisions+  , Just packageDesc <- cabal.sourcePackage package+  , any isRevision packageDesc.customFieldsPD+  = Right package+  | otherwise+  = Left package+  where+    isRevision = \case+      ("x-revision", rev) | rev /= "0" -> True+      _ -> False+ processSolverPlan ::+  Bool ->+  CabalHandlers ->   EnvDeps ->+  Set PackageId ->   SolverPlan ->   M SolverChanges-processSolverPlan deps SolverPlan {..} = do-  Log.debugP (hang "New project deps from solver:" 2 (pretty projectDeps))+processSolverPlan forceRevisions cabal deps prevRevisions SolverPlan {..} = do+  Log.debugP $+    hang "New project deps from solver:" 2 (pretty projectDeps) $$+    "Forced revisions:" <+> prettyL forcedRevisions $$+    "Reused revisions:" <+> prettyL reusedRevisions   traverse_ logNonReinstallable nonReinstallable   pure SolverChanges {versions, overrides, projectDeps}   where     projectDeps = nRestrictKeys mutablePIds versions-    versions = packageIdVersions (overrides ++ matching)-    overrides = filter notLocal changes+    versions = packageIdVersions (overrides ++ installed)+    overrides = filter notLocal (changes ++ forcedRevisions ++ reusedRevisions)+    (reusedRevisions, installed) = partition (flip Set.member prevRevisions) noForcedRevisions+    (noForcedRevisions, forcedRevisions) = partitionEithers (checkRevision forceRevisions cabal <$> matching)     notLocal PackageId {name} = not (isLocalPackage deps.local name)     mutablePIds = Set.fromList (depName <$> Set.toList deps.mutable) +-- TODO probably best to store the revisions in the SolverState solveMutation ::   CabalHandlers ->   EnvDeps ->+  Set PackageId ->   SolverState ->   M (Maybe SolverChanges)-solveMutation cabal deps state =-  traverse (processSolverPlan deps) =<< cabal.solveForVersion state+solveMutation cabal deps prevRevisions state =+  traverse (processSolverPlan state.flags.forceRevisions cabal deps prevRevisions) =<< cabal.solveForVersion state

@@ -6,7 +6,6 @@ import Hix.Data.Options (BumpOptions (BumpOptions)) import Hix.Json (jsonConfigE) import Hix.Managed.Bump.Optimize (bumpOptimizeMain)-import qualified Hix.Managed.Data.BuildConfig import qualified Hix.Managed.Data.ProjectContextProto import Hix.Managed.Handlers.Build.Test (chooseHandlers) import Hix.Managed.ProjectContext (withProjectContext)@@ -15,6 +14,5 @@ bumpCli BumpOptions {common = opts} = do   context <- jsonConfigE Client opts.context   handlers <- liftIO $-    chooseHandlers opts.stateFile context.envs context.buildOutputsPrefix opts.project.build.timeout opts.cabal-      opts.handlers+    chooseHandlers opts.stateFile context.envs context.buildOutputsPrefix opts.project.build opts.cabal opts.handlers   withProjectContext handlers opts.project context (bumpOptimizeMain handlers)

@@ -83,7 +83,7 @@   pure (stageResult success failure result)   where     ext = solverState env.solverBounds env.deps (bumpSolverParams env.deps builder.cabal state) flags-    flags = SolverFlags {allowNewer = True}+    flags = SolverFlags {allowNewer = True, forceRevisions = False}  bumpBuildStage ::   BuildHandlers ->

@@ -22,12 +22,13 @@  data SolverFlags =   SolverFlags {-    allowNewer :: Bool+    allowNewer :: Bool,+    forceRevisions :: Bool   }   deriving stock (Eq, Show, Generic)  instance Default SolverFlags where-  def = SolverFlags {allowNewer = False}+  def = SolverFlags {allowNewer = False, forceRevisions = False}  flagAllowNewer :: DepResolverParams -> DepResolverParams flagAllowNewer =

@@ -1,30 +1,41 @@ module Hix.Managed.Cabal.Data.SourcePackage where +import Distribution.PackageDescription (PackageDescription) import Distribution.Pretty (Pretty (pretty)) import Distribution.Simple (Version) import GHC.Exts (IsList) -import Hix.Class.Map (LookupMaybe, LookupMonoid, NMap, nPretty1, nPrettyWith)+import Hix.Class.Map (LookupMaybe, LookupMonoid, NMap, nPretty, nPretty1, nPrettyWith) import Hix.Data.Dep (Dep) import Hix.Data.PackageName (PackageName) import Hix.Pretty (prettyL) -newtype SourcePackageDeps =-  SourcePackageDeps (Map Version [Dep])+data SourcePackageId =+  SourcePackageId {+    deps :: [Dep],+    description :: Maybe PackageDescription+  }   deriving stock (Eq, Show, Generic)++instance Pretty SourcePackageId where+  pretty SourcePackageId {deps} = prettyL deps++newtype SourcePackage =+  SourcePackage (Map Version SourcePackageId)+  deriving stock (Eq, Show, Generic)   deriving newtype (Semigroup, Monoid, IsList) -instance NMap SourcePackageDeps Version [Dep] LookupMonoid where+instance NMap SourcePackage Version SourcePackageId LookupMonoid where -instance Pretty SourcePackageDeps where-  pretty = nPrettyWith prettyL+instance Pretty SourcePackage where+  pretty = nPretty  newtype SourcePackages =-  SourcePackages (Map PackageName SourcePackageDeps)+  SourcePackages (Map PackageName SourcePackage)   deriving stock (Eq, Show, Generic)   deriving newtype (Semigroup, Monoid, IsList) -instance NMap SourcePackages PackageName SourcePackageDeps LookupMaybe where+instance NMap SourcePackages PackageName SourcePackage LookupMaybe where  instance Pretty SourcePackages where   pretty = nPretty1

@@ -3,39 +3,42 @@ import qualified Data.Map.Strict as Map import Distribution.Client.Types (PackageLocation (LocalTarballPackage), SourcePackageDb (..), UnresolvedSourcePackage) import Distribution.PackageDescription (+  BuildInfo (targetBuildDepends),   CondTree (..),   Library (libBuildInfo),   LibraryVisibility (LibraryVisibilityPublic),   PackageDescription (..),   emptyLibrary,-  emptyPackageDescription, BuildInfo (targetBuildDepends),+  emptyPackageDescription,   ) import Distribution.Simple (Version) import qualified Distribution.Solver.Types.PackageIndex as PackageIndex import Distribution.Solver.Types.PackageIndex (PackageIndex)-import Distribution.Solver.Types.SourcePackage (SourcePackage (..))+import qualified Distribution.Solver.Types.SourcePackage as Cabal import Distribution.Types.GenericPackageDescription (GenericPackageDescription (..), emptyGenericPackageDescription) import Distribution.Types.Library (libVisibility) import Exon (exon) -import Hix.Class.Map (nGet, nKeys, nMap, nTo1, nTransform, nVia, (!!))+import Hix.Class.Map (nGet, nKeys, nMap, nTo1, nTransform, (!!)) import qualified Hix.Data.Dep as Dep import Hix.Data.Dep (Dep) import Hix.Data.Monad (M) import qualified Hix.Data.PackageId as PackageId import Hix.Data.PackageId (PackageId (PackageId)) import Hix.Data.PackageName (LocalPackage (LocalPackage), PackageName, localPackageName)-import Hix.Managed.Cabal.Data.SourcePackage (SourcePackageDeps, SourcePackageVersions, SourcePackages)+import Hix.Managed.Cabal.Data.SourcePackage (SourcePackage, SourcePackageId (..), SourcePackageVersions, SourcePackages) import qualified Hix.Managed.Data.ManagedPackage as ManagedPackage import Hix.Managed.Data.ManagedPackage (ManagedPackage) import Hix.Managed.Data.Packages (Packages) import Hix.Monad (noteClient) -allDeps :: [Dep] -> SourcePackageDeps -> SourcePackageDeps-allDeps deps = nVia (fmap (deps ++))+allDeps :: [Dep] -> SourcePackage -> SourcePackage+allDeps deps =+  nMap \ p -> p {deps = deps ++ p.deps}+  where -allDep :: Dep -> SourcePackageDeps -> SourcePackageDeps-allDep dep = nVia (fmap (dep :))+allDep :: Dep -> SourcePackage -> SourcePackage+allDep = allDeps . pure  sourcePackageVersions :: SourcePackages -> SourcePackageVersions sourcePackageVersions = nMap (sort . nKeys)@@ -59,12 +62,12 @@ -- | This _must_ have the dependencies in both 'targetBuildDepends' and 'condTreeConstraints', otherwise they will be -- ignored or deleted depending on what resolver params are used. -- This is also evidenced by looking at a parsed Cabal file, see @CabalTest@.-mockSourcePackage :: PackageName -> Version -> [Dep] -> UnresolvedSourcePackage-mockSourcePackage name version deps =-  SourcePackage {+mockSourcePackage :: PackageName -> Version -> SourcePackageId -> UnresolvedSourcePackage+mockSourcePackage name version SourcePackageId {description, deps} =+  Cabal.SourcePackage {     srcpkgPackageId = cabalId,     srcpkgDescription = emptyGenericPackageDescription {-      packageDescription = emptyPackageDescription {+      packageDescription = (fromMaybe emptyPackageDescription description) {         package = cabalId       },       condLibrary = Just library@@ -97,7 +100,9 @@  managedSourcePackage :: ManagedPackage -> UnresolvedSourcePackage managedSourcePackage package =-  mockSourcePackage (localPackageName package.package) package.version (ManagedPackage.deps package)+  mockSourcePackage (localPackageName package.package) package.version pid+  where+    pid = SourcePackageId {deps = ManagedPackage.deps package, description = Nothing}  managedPackageIndex :: Packages ManagedPackage -> PackageIndex UnresolvedSourcePackage managedPackageIndex packages =

@@ -68,16 +68,23 @@     pkgSpecifiers = (.dep) <$> targets     prefs = (.prefs) =<< targets -solveWithCabal ::+solveWithCabal' ::   SolveResources ->   SolverState ->-  M (Maybe SolverPlan)-solveWithCabal solveResources SolverState {constraints, flags} = do+  M (Maybe SolverInstallPlan)+solveWithCabal' solveResources SolverState {constraints, flags} = do   solveForTargets solveResources (compileSolverFlags flags) targets >>= \case     Right plan ->-      pure (Just (solverPlan plan))+      pure (Just plan)     Left err -> do       Log.debug [exon|Solver found no plan: ##{err}|]       pure Nothing   where     targets = solveTargets constraints++solveWithCabal ::+  SolveResources ->+  SolverState ->+  M (Maybe SolverPlan)+solveWithCabal solveResources solverState =+  fmap solverPlan <$> solveWithCabal' solveResources solverState

@@ -0,0 +1,20 @@+module Hix.Managed.Cabal.Source where++import Distribution.Client.Types (SourcePackageDb (SourcePackageDb, packageIndex))+import Distribution.PackageDescription (+  GenericPackageDescription (GenericPackageDescription, packageDescription),+  PackageDescription,+  )+import Distribution.Solver.Types.PackageIndex (lookupPackageId)+import Distribution.Solver.Types.SourcePackage (SourcePackage (SourcePackage, srcpkgDescription))++import qualified Hix.Data.PackageId as PackageId+import Hix.Data.PackageId (PackageId)++sourcePackage ::+  SourcePackageDb ->+  PackageId ->+  Maybe PackageDescription+sourcePackage SourcePackageDb {packageIndex} package =+  lookupPackageId packageIndex (PackageId.toCabal package) <&> \case+    SourcePackage {srcpkgDescription = GenericPackageDescription {packageDescription}} -> packageDescription

@@ -11,7 +11,8 @@     validate :: Bool,     buildOutput :: Bool,     toposortMutations :: Bool,-    timeout :: Maybe BuildTimeout+    timeout :: Maybe BuildTimeout,+    disableNixMonitor :: Bool   }   deriving stock (Eq, Show, Generic) @@ -24,5 +25,6 @@     validate = False,     buildOutput = False,     toposortMutations = True,-    timeout = Nothing+    timeout = Nothing,+    disableNixMonitor = False   }

@@ -4,6 +4,7 @@ import qualified Text.PrettyPrint as PrettyPrint import Text.PrettyPrint (parens, (<+>)) +import Hix.Data.PackageId (PackageId) import Hix.Data.Version (Version) import Hix.Data.VersionBounds (VersionBounds) import Hix.Managed.Cabal.Data.SolverState (SolverState)@@ -36,7 +37,13 @@   deriving stock (Generic)  data MutationResult s =-  MutationSuccess { candidate :: MutableId, changed :: Bool, state :: MutationState, ext :: s }+  MutationSuccess {+    candidate :: MutableId,+    changed :: Bool,+    state :: MutationState,+    revisions :: Set PackageId,+    ext :: s+  }   |   MutationKeep   |

@@ -1,5 +1,7 @@ module Hix.Managed.Data.StageState where +import Hix.Data.PackageId (PackageId)+import Hix.Managed.Build.NixOutput (PackageDerivation) import Hix.Managed.Data.Initial (Initial (Initial)) import Hix.Managed.Data.Mutable (MutableDep) import qualified Hix.Managed.Data.MutableId@@ -18,23 +20,35 @@   Success -> Just a   Failure -> Nothing +data BuildFailure =+  UnknownFailure+  |+  PackageFailure (NonEmpty PackageDerivation)+  |+  TimeoutFailure [PackageId]+  deriving stock (Eq, Show, Generic)+ data BuildResult =-  Finished BuildStatus+  BuildSuccess   |-  TimedOut+  BuildFailure BuildFailure   deriving stock (Eq, Show, Generic)  buildUnsuccessful :: BuildResult -> Bool buildUnsuccessful = \case-  Finished Success -> False-  Finished Failure -> True-  TimedOut -> True+  BuildSuccess -> False+  BuildFailure _ -> True  buildStatus :: BuildResult -> BuildStatus buildStatus = \case-  Finished s -> s-  TimedOut -> Failure+  BuildSuccess -> Success+  BuildFailure _ -> Failure +resultFromStatus :: BuildStatus -> BuildResult+resultFromStatus = \case+  Success -> BuildSuccess+  Failure -> BuildFailure UnknownFailure+ data BuildSuccess =   CandidateBuilt MutableId   |@@ -57,6 +71,7 @@     success :: Map MutableDep BuildSuccess,     failed :: [DepMutation a],     state :: MutationState,+    revisions :: Set PackageId,     iterations :: Natural,     ext :: s   }@@ -64,4 +79,4 @@  initStageState :: Initial MutationState -> s -> StageState a s initStageState (Initial state) ext =-  StageState {success = [], failed = [], iterations = 0, ..}+  StageState {success = [], failed = [], revisions = [], iterations = 0, ..}

@@ -16,7 +16,7 @@ import Hix.Managed.Data.Initial (Initial) import Hix.Managed.Data.ManagedPackage (ManagedPackage) import Hix.Managed.Data.Packages (Packages)-import Hix.Managed.Data.StageState (BuildResult (Finished), BuildStatus (Failure))+import Hix.Managed.Data.StageState (BuildFailure (UnknownFailure), BuildResult (BuildFailure)) import qualified Hix.Managed.Handlers.Cabal as Solve import qualified Hix.Managed.Handlers.Cabal as Cabal import Hix.Managed.Handlers.Cabal (CabalHandlers)@@ -40,7 +40,7 @@ data EnvBuilder =   EnvBuilder {     cabal :: CabalHandlers,-    buildWithState :: Versions -> [PackageId] -> M (Overrides, BuildResult)+    buildWithState :: Bool -> Versions -> [PackageId] -> M (BuildResult, (Overrides, Set PackageId))   }  data Builder =@@ -61,16 +61,19 @@     latestVersion :: PackageName -> M (Maybe Version)   } -testBuilder :: (Versions -> [PackageId] -> M (Overrides, BuildResult)) -> (Builder -> M a) -> M a+testBuilder ::+  (Bool -> Versions -> [PackageId] -> M (BuildResult, (Overrides, Set PackageId))) ->+  (Builder -> M a) ->+  M a testBuilder buildWithState use =   use Builder {withEnvBuilder = \ cabal _ _ useE -> useE EnvBuilder {cabal, buildWithState}}  versionsBuilder :: HackageHandlers -> (Versions -> M BuildResult) -> (Builder -> M a) -> M a versionsBuilder hackage build =-  testBuilder \ versions overrideVersions -> do+  testBuilder \ _ versions overrideVersions -> do     overrides <- packageOverrides hackage overrideVersions     status <- build versions-    pure (overrides, status)+    pure (status, (overrides, mempty))  handlersNull :: BuildHandlers handlersNull =@@ -78,7 +81,7 @@     stateFile = StateFileHandlers.handlersNull,     report = Report.handlersNull,     cabal = \ _ _ -> pure Solve.handlersNull,-    withBuilder = testBuilder \ _ _ -> pure (mempty, Finished Failure),+    withBuilder = testBuilder \ _ _ _ -> pure (BuildFailure UnknownFailure, mempty),     versions = \ _ -> pure [],     latestVersion = \ _ -> pure Nothing   }

@@ -1,16 +1,24 @@ module Hix.Managed.Handlers.Build.Prod where  import Control.Monad.Catch (catch)-import Control.Monad.Trans.Reader (asks)+import Control.Monad.Trans.Class (lift)+import Control.Monad.Trans.Reader (ask, asks)+import Control.Monad.Trans.State.Strict (StateT (runStateT), gets, modify')+import qualified Data.ByteString.Char8 as ByteString+import Data.List.Extra (firstJust)+import qualified Data.Set as Set import Exon (exon) import Network.HTTP.Client (newManager) import Network.HTTP.Client.TLS (tlsManagerSettings) import Path (Abs, Dir, Path, toFilePath) import Path.IO (copyDirRecur')-import System.IO.Error (IOError)+import System.IO (BufferMode (LineBuffering), Handle, hSetBuffering)+import System.IO.Error (IOError, tryIOError) import System.Process.Typed (   ExitCode (ExitFailure, ExitSuccess),   ProcessConfig,+  createPipe,+  getStderr,   inherit,   nullStream,   proc,@@ -22,36 +30,36 @@   ) import System.Timeout (timeout) +import Hix.Class.Map (nInsert, nMember) import Hix.Data.EnvName (EnvName) import Hix.Data.Error (Error (Fatal)) import qualified Hix.Data.Monad import Hix.Data.Monad (M (M)) import Hix.Data.Overrides (Overrides)+import qualified Hix.Data.PackageId import Hix.Data.PackageId (PackageId) import Hix.Data.PackageName (LocalPackage) import Hix.Data.Version (Versions) import Hix.Error (pathText) import Hix.Hackage (latestVersionHackage, versionsHackage) import qualified Hix.Log as Log+import Hix.Managed.Build.NixOutput (OutputResult (OutputResult), PackageDerivation (..), outputParse, runOutputState)+import Hix.Managed.Build.NixOutput.Analysis (analyzeLog) import Hix.Managed.Cabal.Data.Config (CabalConfig)+import qualified Hix.Managed.Data.BuildConfig+import Hix.Managed.Data.BuildConfig (BuildConfig) import Hix.Managed.Data.EnvConfig (EnvConfig) import qualified Hix.Managed.Data.EnvContext-import Hix.Managed.Data.EnvContext (EnvContext (EnvContext))+import Hix.Managed.Data.EnvContext (EnvContext) import Hix.Managed.Data.EnvState (EnvState) import Hix.Managed.Data.Envs (Envs) import Hix.Managed.Data.Initial (Initial)-import Hix.Managed.Data.StageState (BuildResult (Finished, TimedOut), BuildStatus (Failure, Success), buildUnsuccessful)+import Hix.Managed.Data.StageState (BuildFailure (..), BuildResult (..), buildUnsuccessful) import qualified Hix.Managed.Data.StateFileConfig import Hix.Managed.Data.StateFileConfig (StateFileConfig) import Hix.Managed.Data.Targets (firstMTargets) import qualified Hix.Managed.Handlers.Build-import Hix.Managed.Handlers.Build (-  BuildHandlers (..),-  BuildOutputsPrefix,-  BuildTimeout,-  Builder (Builder),-  EnvBuilder (EnvBuilder),-  )+import Hix.Managed.Handlers.Build (BuildHandlers (..), BuildOutputsPrefix, Builder (Builder), EnvBuilder (EnvBuilder)) import Hix.Managed.Handlers.Cabal (CabalHandlers) import qualified Hix.Managed.Handlers.Cabal.Prod as CabalHandlers import Hix.Managed.Handlers.Hackage (HackageHandlers)@@ -59,10 +67,11 @@ import qualified Hix.Managed.Handlers.Report.Prod as ReportHandlers import Hix.Managed.Handlers.StateFile (StateFileHandlers) import qualified Hix.Managed.Handlers.StateFile.Prod as StateFileHandlers-import Hix.Managed.Overrides (packageOverrides)+import Hix.Managed.Overrides (packageOverride, packageOverrides) import Hix.Managed.Path (rootOrCwd) import Hix.Managed.StateFile (writeBuildStateFor, writeInitialEnvState)-import Hix.Monad (throwM, tryIOM, withTempDir)+import Hix.Monad (runMUsing, throwM, tryIOM, withTempDir)+import Hix.Pretty (showP)  data BuilderResources =   BuilderResources {@@ -71,7 +80,7 @@     envsConf :: Envs EnvConfig,     buildOutputsPrefix :: Maybe BuildOutputsPrefix,     root :: Path Abs Dir,-    buildTimeout :: Maybe BuildTimeout+    buildConfig :: BuildConfig   }  data EnvBuilderResources =@@ -93,55 +102,178 @@         use tmpRoot     \ (err :: IOError) -> throwM (Fatal (show err)) +data OutputConfig =+  OutputDebug+  |+  OutputParse+  |+  OutputIgnore++data NixProcResult =+  NixProcSuccess [Text]+  |+  NixProcFailure Text+  deriving stock (Eq, Show, Generic)++outputLines ::+  MonadIO m =>+  (ByteString -> m ()) ->+  Handle ->+  m (Maybe Text)+outputLines parse handle = do+  liftIO (hSetBuffering handle LineBuffering)+  spin mempty+  where+    spin buf = do+      liftIO (tryIOError (ByteString.hGet handle 4096)) >>= \case+        Left err -> pure (Just (show err))+        Right new ->+          join <$> for (completeLines buf new) \ (lns, newBuf) -> do+            for_ lns parse+            spin newBuf++    completeLines = \cases+      -- Empty output means the handle was closed, empty buffer means we can terminate+      "" "" ->+        Nothing+      -- First iteration after handle was closed, need to emit the last line+      buf "" ->+        Just ([buf], "")+      buf new ->+        Just (breakNl [] (buf <> new))++    breakNl acc s =+      case ByteString.break (== '\n') s of+        (rest, "") -> (reverse acc, rest)+        (ln, rest) -> breakNl (ln : acc) (ByteString.drop 1 rest)+ nixProc ::+  OutputConfig ->   Path Abs Dir ->   [Text] ->   Text ->   [Text] ->-  M (ProcessConfig () () ())-nixProc root cmd installable extra = do+  M (ProcessConfig () () (Maybe Handle))+nixProc output root cmd installable extra = do   Log.debug [exon|Running nix at '#{pathText root}' with args #{show args}|]-  conf <$> M (asks (.debug))+  pure conf   where-    conf debug = err debug (setWorkingDir (toFilePath root) (proc "nix" args))+    conf = err (setWorkingDir (toFilePath root) (proc "nix" args)) -    err = \case-      True -> setStderr inherit-      False -> setStderr nullStream+    err = case output of+      OutputParse -> setStderr (Just <$> createPipe)+      OutputDebug -> setStdout inherit . setStderr (Nothing <$ inherit)+      OutputIgnore -> setStderr (Nothing <$ nullStream) -    args = toString <$> cmd ++ [exon|path:#{".#"}#{installable}|] : extra+    args = toString <$> cmd ++ [exon|path:#{".#"}#{installable}|] : extra ++ logArgs -buildPackage ::-  Maybe BuildTimeout ->+    logArgs = case output of+      OutputParse -> ["--log-format", "internal-json"]+      OutputDebug -> ["-L"]+      OutputIgnore -> []++runProc ::+  BuildConfig ->+  (Handle -> IO a) ->+  ProcessConfig () () (Maybe Handle) ->+  M (Maybe (Maybe a, ExitCode))+runProc buildConf pipeHandler conf =+  tryIOM (withProcessTerm conf interact)+  where+    interact prc =+      limit do+        output <- traverse pipeHandler (getStderr prc)+        res <- waitExitCode prc+        pure (output, res)++    limit | Just t <- buildConf.timeout+          , t > 0+          = timeout (coerce t * 1_000_000)+          | otherwise = fmap Just++outputResult ::+  Maybe (Either Error (Maybe Text, OutputResult)) ->+  ExitCode ->+  M BuildResult+outputResult result = \case+  ExitSuccess -> pure BuildSuccess+  ExitFailure _ -> pure (BuildFailure (maybe UnknownFailure PackageFailure failedPackage))+  where+    failedPackage =+      result >>= \case+        Right (_, OutputResult pkg) -> pkg+        Left _ -> Nothing++buildTarget ::+  BuildConfig ->   Path Abs Dir ->   EnvName ->   LocalPackage ->   M BuildResult-buildPackage processTimeout root env target = do+buildTarget buildConf root env target = do+  appRes <- M ask   debug <- M (asks (.debug))-  conf <- nixProc root ["-L", "build"] [exon|env.##{env}.##{target}|] []-  tryIOM (withProcessTerm (err debug conf) (limit . waitExitCode)) <&> \case-    Just ExitSuccess -> Finished Success-    Just (ExitFailure _) -> Finished Failure-    Nothing -> TimedOut+  conf <- nixProc (outputHandler debug) root ["build"] [exon|env.##{env}.##{target}|] []+  runProc buildConf (runOutput appRes) conf >>= \case+    Just (output, code) ->+      outputResult output code+    Nothing -> pure (BuildFailure (TimeoutFailure []))   where-    limit | Just t <- processTimeout = timeout (coerce t * 1_000_000)-          | otherwise = fmap Just+    runOutput appRes handle =+      runMUsing appRes (runOutputState (outputLines outputParse handle)) -    err = \case-      True -> setStdout inherit-      False -> id+    outputHandler debug+      | buildConf.buildOutput || (buildConf.disableNixMonitor && debug)+      = OutputDebug+      | buildConf.disableNixMonitor+      = OutputIgnore+      | otherwise+      = OutputParse +buildAdaptive ::+  EnvBuilderResources ->+  Bool ->+  LocalPackage ->+  StateT (Overrides, Set PackageId) M BuildResult+buildAdaptive EnvBuilderResources {global, context} allowRevisions target = do+  build+  where+    build = do+      overrides <- gets fst+      result <- lift do+        writeBuildStateFor "current build" global.stateFileHandlers global.root context overrides+        buildTarget global.buildConfig global.root context.env target+      checkResult overrides result++    checkResult overrides result+      | allowRevisions+      , BuildFailure (PackageFailure pkgs) <- result+      , Just package <- firstJust logFailure (toList pkgs)+      , not (nMember package.name overrides)+      = retry package+      | otherwise+      = pure result++    logFailure PackageDerivation {package, log} =+      package <$ analyzeLog log++    retry broken = do+      lift $ Log.verbose [exon|Installed package failed with bounds error, retrying with override: #{showP broken}|]+      (package, newOverride) <- lift $ packageOverride global.hackage broken+      modify' \ (overrides, revisions) -> (nInsert package newOverride overrides, Set.insert broken revisions)+      build+ buildWithState ::   EnvBuilderResources ->+  Bool ->   Versions ->   [PackageId] ->-  M (Overrides, BuildResult)-buildWithState EnvBuilderResources {global, context = context@EnvContext {env, targets}} _ overrideVersions = do-  overrides <- packageOverrides global.hackage overrideVersions-  writeBuildStateFor "current build" global.stateFileHandlers global.root context overrides-  status <- firstMTargets (Finished Success) buildUnsuccessful (buildPackage global.buildTimeout global.root env) targets-  pure (overrides, status)+  M (BuildResult, (Overrides, Set PackageId))+buildWithState builder allowRevisions _ overrideVersions = do+  overrides <- packageOverrides builder.global.hackage overrideVersions+  let build = buildAdaptive builder allowRevisions+      s0 = (overrides, Set.empty)+  runStateT (firstMTargets BuildSuccess buildUnsuccessful build builder.context.targets) s0  -- | This used to have the purpose of reading an updated GHC package db using the current managed state, but this has -- become obsolete.@@ -173,10 +305,10 @@   StateFileConfig ->   Envs EnvConfig ->   Maybe BuildOutputsPrefix ->-  Maybe BuildTimeout ->+  BuildConfig ->   (Builder -> M a) ->   M a-withBuilder hackage stateFileHandlers stateFileConf envsConf buildOutputsPrefix buildTimeout use =+withBuilder hackage stateFileHandlers stateFileConf envsConf buildOutputsPrefix buildConfig use =   withTempProject stateFileConf.projectRoot \ root -> do     let resources = BuilderResources {..}     use Builder {withEnvBuilder = withEnvBuilder resources}@@ -186,11 +318,11 @@   StateFileConfig ->   Envs EnvConfig ->   Maybe BuildOutputsPrefix ->-  Maybe BuildTimeout ->+  BuildConfig ->   CabalConfig ->   Bool ->   m BuildHandlers-handlersProd stateFileConf envsConf buildOutputsPrefix buildTimeout cabalConf oldest = do+handlersProd stateFileConf envsConf buildOutputsPrefix buildConfig cabalConf oldest = do   manager <- liftIO (newManager tlsManagerSettings)   hackage <- HackageHandlers.handlersProd   let stateFile = StateFileHandlers.handlersProd stateFileConf@@ -198,7 +330,7 @@     stateFile,     report = ReportHandlers.handlersProd,     cabal = CabalHandlers.handlersProd cabalConf oldest,-    withBuilder = withBuilder hackage stateFile stateFileConf envsConf buildOutputsPrefix buildTimeout,+    withBuilder = withBuilder hackage stateFile stateFileConf envsConf buildOutputsPrefix buildConfig,     versions = versionsHackage manager,     latestVersion = latestVersionHackage manager   }

@@ -13,6 +13,7 @@ import qualified Hix.Managed.Cabal.Data.Packages import Hix.Managed.Cabal.Data.Packages (GhcPackages) import Hix.Managed.Cabal.Mock.SourcePackage (queryVersions, queryVersionsLatest, sourcePackageVersions)+import Hix.Managed.Data.BuildConfig (BuildConfig) import Hix.Managed.Data.EnvConfig (EnvConfig) import Hix.Managed.Data.Envs (Envs) import Hix.Managed.Data.Mutation (FailedMutation)@@ -21,7 +22,6 @@ import Hix.Managed.Handlers.Build (   BuildHandlers (..),   BuildOutputsPrefix,-  BuildTimeout,   SpecialBuildHandlers (TestBumpHandlers),   versionsBuilder,   )@@ -68,12 +68,12 @@   StateFileConfig ->   Envs EnvConfig ->   Maybe BuildOutputsPrefix ->-  Maybe BuildTimeout ->+  BuildConfig ->   CabalConfig ->   Bool ->   m BuildHandlers-handlersBumpTest stateFileConf envsConf buildOutputsPrefix buildTimeout cabalConf oldest = do-  handlers <- handlersProd stateFileConf envsConf buildOutputsPrefix buildTimeout cabalConf oldest+handlersBumpTest stateFileConf envsConf buildOutputsPrefix buildConf cabalConf oldest = do+  handlers <- handlersProd stateFileConf envsConf buildOutputsPrefix buildConf cabalConf oldest   pure handlers {     cabal = CabalHandlers.handlersTest cabalConf oldest,     latestVersion = latestVersionNixTestBump@@ -84,12 +84,12 @@   StateFileConfig ->   Envs EnvConfig ->   Maybe BuildOutputsPrefix ->-  Maybe BuildTimeout ->+  BuildConfig ->   CabalConfig ->   Maybe SpecialBuildHandlers ->   m BuildHandlers-chooseHandlers stateFileConf envsConf buildOutputsPrefix buildTimeout cabalConf = \case-  Just TestBumpHandlers -> handlersBumpTest stateFileConf envsConf buildOutputsPrefix buildTimeout cabalConf oldest-  Nothing -> handlersProd stateFileConf envsConf buildOutputsPrefix buildTimeout cabalConf oldest+chooseHandlers stateFileConf envsConf buildOutputsPrefix buildConf cabalConf = \case+  Just TestBumpHandlers -> handlersBumpTest stateFileConf envsConf buildOutputsPrefix buildConf cabalConf oldest+  Nothing -> handlersProd stateFileConf envsConf buildOutputsPrefix buildConf cabalConf oldest   where     oldest = False

@@ -1,9 +1,11 @@ module Hix.Managed.Handlers.Cabal where  import Data.IORef (IORef, modifyIORef')+import Distribution.PackageDescription (PackageDescription)  import Hix.Class.Map (nFromKeys) import Hix.Data.Monad (M)+import Hix.Data.PackageId (PackageId) import Hix.Data.PackageName (PackageName) import Hix.Data.Version (Version) import Hix.Managed.Cabal.Changes (SolverPlan)@@ -16,6 +18,7 @@   CabalHandlers {     solveForVersion :: SolverState -> M (Maybe SolverPlan),     installedVersion :: PackageName -> Maybe Version,+    sourcePackage :: PackageId -> Maybe PackageDescription,     sortMutations :: ∀ a . [DepMutation a] -> M [DepMutation a]   } @@ -24,6 +27,7 @@   CabalHandlers {     solveForVersion = \ _ -> pure Nothing,     installedVersion = const Nothing,+    sourcePackage = const Nothing,     sortMutations = pure   } 

@@ -15,11 +15,12 @@ import Hix.Data.PackageName (PackageName) import Hix.Managed.Cabal.Data.Config (CabalConfig, GhcDb) import qualified Hix.Managed.Cabal.Data.SolveResources as SolveResources-import Hix.Managed.Cabal.Data.SolveResources (SolveResources (SolveResources), solverParams)+import Hix.Managed.Cabal.Data.SolveResources (SolveResources (SolveResources, solverParams)) import Hix.Managed.Cabal.Installed (installedVersion) import qualified Hix.Managed.Cabal.Resources as SolveResources import Hix.Managed.Cabal.Solve (solveWithCabal) import Hix.Managed.Cabal.Sort (sortMutations)+import Hix.Managed.Cabal.Source (sourcePackage) import Hix.Managed.Data.ManagedPackage (ManagedPackage) import Hix.Managed.Data.Packages (Packages) import Hix.Managed.Handlers.Cabal (CabalHandlers (..))@@ -37,6 +38,7 @@   pure CabalHandlers {     solveForVersion = solveWithCabal solveResources {solverParams},     installedVersion = installedVersion solveResources.installedPkgIndex,+    sourcePackage = sourcePackage solveResources.sourcePkgDb,     sortMutations = sortMutations solveResources   }   where@@ -59,7 +61,9 @@     PackageId {name = "base", version = [4, 17, 2, 0]},     PackageId {name = "extra", version = [1, 7, 14]},     PackageId {name = "th-abstraction", version = [0, 5, 0, 0]},-    PackageId {name = "path", version = [0, 9, 5]}+    PackageId {name = "path", version = [0, 9, 5]},+    PackageId {name = "multi-fail1", version = [0, 1, 0]},+    PackageId {name = "multi-fail2", version = [0, 1, 0]}   ]  removeLaterVersions ::

@@ -2,15 +2,22 @@  import Data.IORef (newIORef) +import Hix.Data.Version (SourceHash) import Hix.Hackage (fetchHashHackageCached) import qualified Hix.Managed.Handlers.Hackage import Hix.Managed.Handlers.Hackage (HackageHandlers (HackageHandlers)) -handlersProd ::+handlersProdWith ::   MonadIO m =>+  Map Text SourceHash ->   m HackageHandlers-handlersProd = do-  hashCache <- liftIO (newIORef mempty)+handlersProdWith initial = do+  hashCache <- liftIO (newIORef initial)   pure HackageHandlers {     fetchHash = fetchHashHackageCached hashCache   }++handlersProd ::+  MonadIO m =>+  m HackageHandlers+handlersProd = handlersProdWith mempty

@@ -1,6 +1,7 @@ module Hix.Managed.Handlers.Mutation where  import Hix.Data.Monad (M)+import Hix.Data.PackageId (PackageId) import Hix.Managed.Data.Mutation (BuildMutation, DepMutation, MutationResult) import Hix.Managed.Data.MutationState (MutationState) @@ -9,6 +10,6 @@     process ::       s ->       DepMutation a ->-      (BuildMutation -> M (Maybe MutationState)) ->+      (BuildMutation -> M (Maybe (MutationState, Set PackageId))) ->       M (MutationResult s)   }

@@ -35,12 +35,12 @@ processMutationBump ::   SolverState ->   DepMutation Bump ->-  (BuildMutation -> M (Maybe MutationState)) ->+  (BuildMutation -> M (Maybe (MutationState, Set PackageId))) ->   M (MutationResult SolverState) processMutationBump solver DepMutation {package, mutation = Bump {version, changed}} build =   builder version <&> \case-    Just (candidate, ext, state) ->-      MutationSuccess {candidate, changed, state, ext}+    Just (candidate, ext, state, revisions) ->+      MutationSuccess {candidate, changed, state, revisions, ext}     Nothing ->       MutationFailed   where

@@ -38,12 +38,12 @@   (Bool -> MutableId -> PackageId -> MutationConstraints -> MutationConstraints) ->   SolverState ->   DepMutation Lower ->-  (BuildMutation -> M (Maybe MutationState)) ->+  (BuildMutation -> M (Maybe (MutationState, Set PackageId))) ->   M (MutationResult SolverState) processMutationLower conf mode update solver DepMutation {package, retract, mutation = Lower {majors}} build = do   foldM buildMajor (Right 0, Nothing) majors <&> \case-    (_, Just (candidate, ext, state)) ->-      MutationSuccess {candidate, changed = True, state, ext}+    (_, Just (candidate, ext, state, revisions)) ->+      MutationSuccess {candidate, changed = True, state, revisions, ext}     (_, Nothing) ->       mode.noSuccess   where

@@ -4,7 +4,7 @@  import Hix.Data.Monad (M) import Hix.Data.NixExpr (Expr)-import Hix.Managed.Handlers.StateFile (StateFileHandlers (StateFileHandlers), writeFile)+import Hix.Managed.Handlers.StateFile (StateFileHandlers (StateFileHandlers, writeFile))  writeFileIORef ::   IORef [Expr] ->

@@ -5,7 +5,6 @@ import qualified Hix.Data.Options import Hix.Data.Options (LowerOptions (LowerOptions)) import Hix.Json (jsonConfigE)-import qualified Hix.Managed.Data.BuildConfig import Hix.Managed.Data.LowerConfig (LowerConfig, lowerConfig) import Hix.Managed.Data.ProjectContext (ProjectContext) import qualified Hix.Managed.Data.ProjectContextProto@@ -24,8 +23,8 @@   M () lowerCli main opts@LowerOptions {common} = do   context <- jsonConfigE Client common.context-  handlers <- chooseHandlers common.stateFile context.envs context.buildOutputsPrefix common.project.build.timeout-    common.cabal common.handlers+  handlers <- chooseHandlers common.stateFile context.envs context.buildOutputsPrefix common.project.build common.cabal+    common.handlers   withProjectContext handlers common.project context (main conf handlers)   where     conf = lowerConfig opts

@@ -15,7 +15,7 @@ import Hix.Managed.Data.ProjectResult (ProjectResult) import Hix.Managed.Data.Query (Query (Query)) import qualified Hix.Managed.Data.QueryDep-import Hix.Managed.Data.StageContext (StageContext (StageContext), query)+import Hix.Managed.Data.StageContext (StageContext (StageContext, query)) import Hix.Managed.Data.StageState (BuildStatus (Failure, Success)) import Hix.Managed.Diff (reifyVersionChanges) import Hix.Managed.Flow (Flow, evalStageState, runStage_, stageError)

@@ -1,6 +1,7 @@ module Hix.Managed.StageState where  import qualified Data.Map.Strict as Map+import qualified Data.Set as Set  import qualified Hix.Managed.Data.MutableId import qualified Hix.Managed.Data.Mutation@@ -13,10 +14,11 @@   MutationResult s ->   StageState a s updateStageState old mutation = \case-  MutationSuccess candidate changed state ext ->+  MutationSuccess {..} ->     old {       success = Map.insert candidate.name buildSuccess old.success,       state,+      revisions = Set.union revisions old.revisions,       ext     }     where

@@ -38,7 +38,7 @@   ProjectState ->   M () writeStateFile purpose handlers tmpRoot state = do-  Log.debug [exon|writing managed stated file for #{purpose}: #{renderRootExpr expr}|]+  Log.debug [exon|writing managed state file for #{purpose}: #{renderRootExpr expr}|]   handlers.writeFile tmpRoot expr   where     expr = encodeNix state

@@ -96,10 +96,14 @@   log <- readIORef logRef   pure (log, result) +runMUsing :: AppResources -> M a -> IO (Either Error a)+runMUsing res (M ma) =+  runExceptT (runReaderT ma res)+ runMLoggerWith :: (LogLevel -> Text -> IO ()) -> GlobalOptions -> M a -> IO (Either Error a)-runMLoggerWith logger GlobalOptions {..} (M ma) =+runMLoggerWith logger GlobalOptions {..} ma =   withSystemTempDir "hix-cli" \ tmp ->-    runExceptT (runReaderT ma AppResources {logger = logWith logger, ..})+    runMUsing AppResources {logger = logWith logger, ..} ma  runMLogWith :: GlobalOptions -> M a -> IO ([Text], Either Error a) runMLogWith opts ma =

@@ -258,6 +258,7 @@   validate <- switch (long "validate" <> help "Validate new versions, but don't update the project state")   buildOutput <- switch (long "build-output" <> help "Show output from Nix builds")   timeout <- fmap BuildTimeout <$> optional (option auto (long "build-timeout" <> help buildTimeoutHelp))+  disableNixMonitor <- switch (long "disable-nix-monitor" <> help "Don't parse Nix build output")   pure BuildConfig {..}   where     maxIterationsHelp = "Number of restarts when some dependencies fail"

@@ -1,6 +1,6 @@ module Hix.Test.Hedgehog where -import Data.List.Extra (zipWithLongest)+import Data.List.Extra (takeEnd, zipWithLongest) import qualified Data.Text as Text import Hedgehog (TestT, evalEither, (===)) @@ -50,8 +50,20 @@   [a] ->   [a] ->   TestT m ()-listEqZip target log =-  for_ (zip [0 :: Natural ..] (zipWithLongest (,) target log)) \case+listEqZip target actual =+  for_ (zip [0 :: Natural ..] (zipWithLongest (,) target actual)) \case     (i, (Just t, Just l)) -> (i, t) === (i, l)-    _ | [] <- log -> fail "Result list is empty."-    _ -> target === log+    _ | [] <- actual -> fail "Result list is empty."+    _ -> target === actual++listEqTail ::+  ∀ m a .+  Monad m =>+  HasCallStack =>+  Eq a =>+  Show a =>+  [a] ->+  [a] ->+  TestT m ()+listEqTail target actual =+  target === takeEnd (length target) actual

@@ -1,8 +1,8 @@ module Hix.Test.Managed.Bump.MutationTest where  import qualified Data.Text as Text+import Distribution.Types.PackageDescription (customFieldsPD, emptyPackageDescription) import Exon (exon)-import Hedgehog ((===)) import Test.Tasty (TestTree, testGroup)  import Hix.Data.Error (Error (Fatal))@@ -10,7 +10,7 @@ import Hix.Managed.Bump.Optimize (bumpOptimizeMain) import qualified Hix.Managed.Cabal.Data.Packages import Hix.Managed.Cabal.Data.Packages (GhcPackages (GhcPackages), InstalledPackages)-import Hix.Managed.Cabal.Data.SourcePackage (SourcePackages)+import Hix.Managed.Cabal.Data.SourcePackage (SourcePackageId (description), SourcePackages) import Hix.Managed.Data.ManagedPackageProto (ManagedPackageProto, managedPackages) import Hix.Managed.Data.Packages (Packages) import qualified Hix.Managed.Data.ProjectStateProto@@ -19,7 +19,7 @@ import Hix.Monad (M, throwM) import Hix.NixExpr (renderRootExpr) import Hix.Pretty (showP)-import Hix.Test.Hedgehog (eqLines)+import Hix.Test.Hedgehog (eqLines, listEqTail) import qualified Hix.Test.Managed.Run import Hix.Test.Managed.Run (Result (Result), TestParams (..), bumpTest, testParams) import Hix.Test.Utils (UnitTest, unitTest)@@ -32,7 +32,9 @@     "direct2",     "direct3",     "direct4",-    "direct5"+    "direct5",+    "direct6",+    "direct7"   ])]  installed :: InstalledPackages@@ -43,55 +45,80 @@     ("direct2-1.0.1", []),     ("direct3-1.0.1", []),     ("direct4-1.0.1", []),-    ("direct5-1.0.1", [])+    ("direct5-1.0.1", []),+    ("direct6-1.0.1", []),+    ("direct7-1.0.1", ["transitive1-1.0.1"]),+    ("transitive1-1.0.1", ["direct6-1.0.1"])   ] -packageDb :: SourcePackages-packageDb =-  [-    ("base", [-      ([4, 11, 0, 0], []),-      ([4, 12, 0, 0], []),-      ([4, 13, 0, 0], [])-    ]),-    ("direct1", [-      ([1, 0, 1], []),-      ([1, 1, 1], []),-      ([1, 2, 1], ["direct2 ==1.2.1"])-    ]),-    ("direct2", [-      ([1, 0, 1], []),-      ([1, 1, 1], []),-      ([1, 2, 1], [])-    ]),-    ("direct3", [-      ([1, 0, 1], []),-      ([1, 1, 1], []),-      ([1, 2, 1], [])-    ]),-    ("direct4", [-      ([1, 0, 1], []),-      ([1, 1, 1], []),-      ([1, 2, 1], [])-    ]),-    ("direct5", [-      ([1, 0, 1], []),-      ([1, 1, 1], []),-      ([1, 2, 1], ["direct4 <1.2"])-    ])-  ]+available :: SourcePackages+available =+  pkgs+  where+    pkgs =+      [+        ("base", [+          ([4, 11, 0, 0], []),+          ([4, 12, 0, 0], []),+          ([4, 13, 0, 0], [])+        ]),+        ("direct1", [+          ([1, 0, 1], []),+          ([1, 1, 1], []),+          ([1, 2, 1], ["direct2 ==1.2.1"])+        ]),+        ("direct2", [+          ([1, 0, 1], []),+          ([1, 1, 1], []),+          ([1, 2, 1], [])+        ]),+        ("direct3", [+          ([1, 0, 1], []),+          ([1, 1, 1], []),+          ([1, 2, 1], [])+        ]),+        ("direct4", [+          ([1, 0, 1], []),+          ([1, 1, 1], []),+          ([1, 2, 1], [])+        ]),+        ("direct5", [+          ([1, 0, 1], []),+          ([1, 1, 1], []),+          ([1, 2, 1], ["direct4 <1.2"])+        ]),+        ("direct6", [+          ([1, 0, 1], []),+          ([1, 1, 1], [])+        ]),+        ("direct7", [+          ([1, 0, 1], ["transitive1 <1.1"])+        ]),+        ("transitive1", [+          ([1, 0, 1], ["direct6 <1.2"] {+            description = Just (emptyPackageDescription {customFieldsPD = [("x-revision", "2")]})+          })+        ])+      ]  ghcPackages :: GhcPackages-ghcPackages = GhcPackages {installed, available = packageDb}+ghcPackages = GhcPackages {installed, available}  build :: Versions -> M BuildStatus build = \case-  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 0, 1]), ("direct4", [1, 0, 1]), ("direct5", [1, 1, 1])] -> pure Success-  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 2, 1]), ("direct4", [1, 0, 1]), ("direct5", [1, 1, 1])] -> pure Failure-  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 0, 1]), ("direct4", [1, 2, 1]), ("direct5", [1, 1, 1])] -> pure Success-  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 0, 1]), ("direct4", [1, 2, 1]), ("direct5", [1, 2, 1])] -> pure Success-  -- second iteration-  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 2, 1]), ("direct4", [1, 2, 1]), ("direct5", [1, 2, 1])] -> pure Failure+  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 0, 1]), ("direct4", [1, 0, 1]), ("direct5", [1, 1, 1]), ("direct6", [1, 0, 1]), ("direct7", [1, 0, 1]), ("transitive1", [1, 0, 1])] -> pure Success++  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 2, 1]), ("direct4", [1, 0, 1]), ("direct5", [1, 1, 1]), ("direct6", [1, 0, 1]), ("direct7", [1, 0, 1]), ("transitive1", [1, 0, 1])] -> pure Failure++  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 0, 1]), ("direct4", [1, 2, 1]), ("direct5", [1, 1, 1]), ("direct6", [1, 0, 1]), ("direct7", [1, 0, 1]), ("transitive1", [1, 0, 1])] -> pure Success++  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 0, 1]), ("direct4", [1, 2, 1]), ("direct5", [1, 2, 1]), ("direct6", [1, 0, 1]), ("direct7", [1, 0, 1]), ("transitive1", [1, 0, 1])] -> pure Success++  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 0, 1]), ("direct4", [1, 2, 1]), ("direct5", [1, 2, 1]), ("direct6", [1, 1, 1]), ("direct7", [1, 0, 1]), ("transitive1", [1, 0, 1])] -> pure Success++--   -- second iteration+  [("base", [4, 12, 0, 0]), ("direct1", [1, 2, 1]), ("direct2", [1, 2, 1]), ("direct3", [1, 2, 1]), ("direct4", [1, 2, 1]), ("direct5", [1, 2, 1]), ("direct6", [1, 1, 1]), ("direct7", [1, 0, 1]), ("transitive1", [1, 0, 1])] -> pure Failure+   versions -> throwM (Fatal [exon|Unexpected build plan: #{showP versions}|])  state :: ProjectStateProto@@ -101,7 +128,8 @@       ("local1", [         ("direct1", ">=0.1"),         ("direct2", ">=0.1"),-        ("direct4", "^>=1.0")+        ("direct4", "^>=1.0"),+        ("direct6", "<1.1")       ])     ],     versions = [("fancy", [("direct4", "1.0.1")])],@@ -141,6 +169,14 @@         lower = null;         upper = "1.3";       };+      direct6 = {+        lower = null;+        upper = "1.2";+      };+      direct7 = {+        lower = null;+        upper = "1.1";+      };     };   };   versions = {@@ -151,6 +187,8 @@       direct3 = "1.0.1";       direct4 = "1.2.1";       direct5 = "1.2.1";+      direct6 = "1.1.1";+      direct7 = "1.0.1";     };   };   initial = {@@ -174,6 +212,18 @@         version = "1.2.1";         hash = "direct5-1.2.1";       };+      direct6 = {+        version = "1.1.1";+        hash = "direct6-1.1.1";+      };+      direct7 = {+        version = "1.0.1";+        hash = "direct7-1.0.1";+      };+      transitive1 = {+        version = "1.0.1";+        hash = "transitive1-1.0.1";+      };     };   };   resolving = false;@@ -192,6 +242,8 @@     📦 [34mdirect2[0m   1.2.1      ↕ >=0.1 -> [0.1, [32m1.3[0m]     📦 [34mdirect3[0m   1.0.1      ↕ [no bounds] -> <[32m1.1[0m     📦 [34mdirect5[0m   1.2.1      ↕ [no bounds] -> <[32m1.3[0m+    📦 [34mdirect6[0m   1.1.1      ↕ <[31m1.1[0m -> <[32m1.2[0m+    📦 [34mdirect7[0m   1.0.1      ↕ [no bounds] -> <[32m1.1[0m [35m[1m>>>[0m Updated versions:     📦 [34mdirect4[0m   [31m1.0.1[0m -> [32m1.2.1[0m   ↕ [1.0, [31m1.1[0m] -> [1.0, [32m1.3[0m] |]@@ -231,7 +283,7 @@ test_bumpMutationBasic = do   Result {stateFile, log} <- bumpTest params bumpOptimizeMain   eqLines stateFileTarget (renderRootExpr stateFile)-  logTarget === drop 12 (reverse log)+  listEqTail logTarget (reverse log)   where     params = (testParams False packages) {       log = True,

@@ -0,0 +1,135 @@+module Hix.Test.Managed.BumpNativeTest where++import Control.Monad.Trans.Reader (ask)+import qualified Data.Text.IO as Text+import Exon (exon)+import Hedgehog (evalEither)+import Path (Abs, Dir, File, Path, Rel, parent, reldir, relfile, toFilePath, (</>))+import Path.IO (createDirIfMissing, getCurrentDir)++import qualified Hix.Data.Monad+import Hix.Data.Monad (AppResources (AppResources), M (M))+import Hix.Data.Options (ProjectOptions (query), projectOptions)+import Hix.Error (pathText)+import Hix.Managed.Bump.Optimize (bumpOptimizeMain)+import Hix.Managed.Cabal.Data.Config (GhcDb (GhcDbSystem))+import qualified Hix.Managed.Data.EnvConfig+import Hix.Managed.Data.EnvConfig (EnvConfig (EnvConfig))+import Hix.Managed.Data.ManagedPackageProto (ManagedPackageProto, managedPackages)+import Hix.Managed.Data.Packages (Packages)+import qualified Hix.Managed.Data.ProjectContext+import qualified Hix.Managed.Data.ProjectContextProto+import Hix.Managed.Data.ProjectContextProto (ProjectContextProto (ProjectContextProto))+import qualified Hix.Managed.Data.ProjectResult+import Hix.Managed.Data.ProjectStateProto (ProjectStateProto (ProjectStateProto))+import qualified Hix.Managed.Data.StateFileConfig+import Hix.Managed.Data.StateFileConfig (StateFileConfig (StateFileConfig))+import qualified Hix.Managed.Handlers.Build.Prod as Build+import Hix.Managed.ProjectContext (updateProject)+import qualified Hix.Managed.ProjectContextProto as ProjectContextProto+import Hix.Test.Hedgehog (eqLines)+import Hix.Test.Utils (UnitTest, runMTest)++packages :: Packages ManagedPackageProto+packages =+  managedPackages [+    (("root", "1.0"), ["tasty <1.5", "criterion <1.7"])+  ]++flake :: Path Abs Dir -> Text+flake hixRoot =+  [exon|{+  description = "hix test project";+  inputs.hix.url = "path:#{pathText hixRoot}";+  outputs = {self, hix, ...}: hix.lib.flake ({config, lib, ...}: {+    managed = {+      enable = true;+      latest.compiler = "ghc98";+    };+    compat.enable = false;+    ghcVersions = [];+    packages = {+      root = {+        src = ./.;+        library = {+          enable = true;+          dependencies = ["tasty" "criterion"];+        };+      };+    };+    envs.latest.localPackage = api: api.minimal;+  });+}|]++libMod :: Text+libMod =+  [exon|module Root where+-- import Test.Tasty (blarkh)+string :: String+string = "hello"+|]++addFile :: Path Abs Dir -> Path Rel File -> Text -> M ()+addFile root path content = do+  createDirIfMissing True (parent file)+  liftIO (Text.writeFile (toFilePath file) content)+  where+    file = root </> path++setupProject :: M (Path Abs Dir)+setupProject = do+  AppResources {tmp} <- M ask+  cwd <- getCurrentDir+  let projectRoot = tmp </> [reldir|project|]+  let hixRoot = parent (parent cwd)+  createDirIfMissing True projectRoot+  addFile projectRoot [relfile|flake.nix|] (flake hixRoot)+  addFile projectRoot [relfile|lib/Root.hs|] libMod+  pure projectRoot++targetStateFile :: Text+targetStateFile =+  [exon|{+  resolving = false;+}+|]++bumpNativeTest :: M Text+bumpNativeTest = do+  root <- setupProject+  let+    stateFileConf = StateFileConfig {+      file = [relfile|ops/managed.nix|],+      projectRoot = Just root+    }+    envsConfig = [("latest", EnvConfig {targets = ["root"], ghc = GhcDbSystem Nothing})]+    buildConfig = def+  handlers <- Build.handlersProd stateFileConf envsConfig Nothing buildConfig def False+  let+    opts = (projectOptions ["latest"]) {query = ["tasty"]}++    proto0 =+      ProjectContextProto {+        packages,+        state = ProjectStateProto [] [] mempty mempty False,+        envs = envsConfig,+        buildOutputsPrefix = Nothing+      }++    stateFile = root </> [relfile|ops/managed.nix|]++    run context process = do+      result <- process handlers context+      updateProject handlers context.build result+      stateFileContent <- liftIO (Text.readFile (toFilePath stateFile))+      pure (result.state, stateFileContent)++  context0 <- ProjectContextProto.validate opts proto0+  (_, stateFileContent) <- run context0 bumpOptimizeMain+  pure stateFileContent++test_bumpNative :: UnitTest+test_bumpNative = do+  stateFileContent <- evalEither =<< liftIO do+    runMTest True bumpNativeTest+  eqLines targetStateFile stateFileContent

@@ -11,7 +11,7 @@ import qualified Hix.Managed.Cabal.Data.Packages import Hix.Managed.Cabal.Data.Packages (GhcPackages (GhcPackages), InstalledPackages) import Hix.Managed.Cabal.Data.SourcePackage (SourcePackages)-import Hix.Managed.Data.LowerConfig (reset)+import Hix.Managed.Data.LowerConfig (LowerConfig (reset)) import Hix.Managed.Data.ManagedPackageProto (ManagedPackageProto, managedPackages) import Hix.Managed.Data.Packages (Packages) import qualified Hix.Managed.Data.ProjectStateProto@@ -76,8 +76,8 @@     ("direct3-1.2", [])   ] -packageDb :: SourcePackages-packageDb =+available :: SourcePackages+available =   [     ("direct1", versions),     ("direct2", versions),@@ -94,7 +94,7 @@       ]  ghcPackages :: GhcPackages-ghcPackages = GhcPackages {installed, available = packageDb}+ghcPackages = GhcPackages {installed, available}  buildVersionsBasic :: Versions -> M BuildStatus buildVersionsBasic = \case

@@ -10,7 +10,7 @@ import qualified Hix.Managed.Cabal.Data.Packages import Hix.Managed.Cabal.Data.Packages (GhcPackages (GhcPackages), InstalledPackages) import Hix.Managed.Cabal.Data.SourcePackage (SourcePackages)-import Hix.Managed.Data.LowerConfig (stabilize)+import Hix.Managed.Data.LowerConfig (LowerConfig (stabilize)) import Hix.Managed.Data.ManagedPackageProto (ManagedPackageProto, managedPackages) import Hix.Managed.Data.Packages (Packages) import qualified Hix.Managed.Data.ProjectStateProto@@ -42,8 +42,8 @@     ("direct3-1.2", [])   ] -packageDb :: SourcePackages-packageDb =+available :: SourcePackages+available =   [     ("direct1", versions),     ("direct2", versions),@@ -60,7 +60,7 @@       ]  ghcPackages :: GhcPackages-ghcPackages = GhcPackages {installed, available = packageDb}+ghcPackages = GhcPackages {installed, available}  state :: ProjectStateProto state =

@@ -6,7 +6,7 @@  import Hix.Class.Map ((!!)) import Hix.Data.Error (Error (Fatal))-import Hix.Data.Options (envs, readUpperBounds)+import Hix.Data.Options (ProjectOptions (envs, readUpperBounds)) import qualified Hix.Data.Overrides import Hix.Data.Overrides (Override (Override)) import Hix.Data.Version (SourceHash (SourceHash), Versions)@@ -27,7 +27,7 @@ import Hix.NixExpr (renderRootExpr) import Hix.Pretty (showP) import Hix.Test.Hedgehog (eqLines, listEqZip)-import Hix.Test.Managed.Run (Result (..), TestParams (..), lowerTest, testParams, nosortOptions)+import Hix.Test.Managed.Run (Result (..), TestParams (..), lowerTest, nosortOptions, testParams) import Hix.Test.Utils (UnitTest)  packages :: Packages ManagedPackageProto@@ -48,8 +48,8 @@     (("local8", "1.0"), ["direct1", "direct6"])   ] -packageDb :: SourcePackages-packageDb =+available :: SourcePackages+available =   [     ("direct1", [       ([1, 0, 3], ["transitive1 >=1"]),@@ -86,7 +86,7 @@   ]  ghcPackages :: GhcPackages-ghcPackages = GhcPackages {installed = [], available = packageDb}+ghcPackages = GhcPackages {installed = [], available}  state :: ProjectStateProto state =

@@ -233,7 +233,8 @@       projectRoot = Just root     }     envsConfig = [("lower", EnvConfig {targets = ["root"], ghc = GhcDbSystem Nothing})]-  handlers <- Build.handlersProd stateFileConf envsConfig Nothing Nothing def False+    buildConfig = def+  handlers <- Build.handlersProd stateFileConf envsConfig Nothing buildConfig def False   let     opts = projectOptions ["lower"] @@ -256,7 +257,7 @@   context0 <- ProjectContextProto.validate opts proto0   (state1, stateFileContentInit) <- run context0 (lowerInitMain def)   -- TODO the packages here aren't updated with the result from the first run-  let context1 = projectContext def state1 context0.packages context0.envs+  let context1 = projectContext buildConfig state1 context0.packages context0.envs   (_, stateFileContentOptimize) <- run context1 lowerOptimizeMain   pure (stateFileContentInit, stateFileContentOptimize) 

@@ -4,12 +4,13 @@ import Distribution.Version (Version) import Hedgehog (evalEither, (===)) +import Hix.Data.PackageId (PackageId) import Hix.Data.PackageName (PackageName) import qualified Hix.Data.VersionBounds import Hix.Data.VersionBounds (fromLower, fromUpper) import qualified Hix.Managed.Cabal.Data.SolverState import Hix.Managed.Cabal.Data.SolverState (SolverState (SolverState), solverState, updateSolverState)-import Hix.Managed.Data.Constraints (MutationConstraints (MutationConstraints), mutation)+import Hix.Managed.Data.Constraints (MutationConstraints (MutationConstraints, mutation)) import Hix.Managed.Data.Mutable (MutableDep) import qualified Hix.Managed.Data.MutableId import Hix.Managed.Data.MutableId (MutableId (MutableId))@@ -45,10 +46,12 @@ candidateVersion :: Version candidateVersion = [1, 9, 2] -build :: IORef [Maybe Version] -> BuildMutation -> M (Maybe MutationState)+build :: IORef [Maybe Version] -> BuildMutation -> M (Maybe (MutationState, Set PackageId)) build buildRef BuildMutation {solverState = SolverState {constraints = [("dep", MutationConstraints {mutation})]}} = do   liftIO (modifyIORef' buildRef (mutation.lower :))-  pure (result =<< mutation.lower)+  pure do+    s <- result =<< mutation.lower+    pure (s, [])   where     result version       | candidateVersion == version@@ -71,7 +74,7 @@     for majors \ mut ->       processMutationLower def lowerOptimizeMode lowerOptimizeUpdate initialState mut (build buildRef)   mutationResults <- evalEither result-  Just (MutationSuccess candidate True mstate (updateSolverState (const newConstraints) initialState)) === mutationResults+  Just (MutationSuccess candidate True mstate [] (updateSolverState (const newConstraints) initialState)) === mutationResults   triedVersions <- liftIO (readIORef buildRef)   (Just <$> targets) === triedVersions   where

@@ -25,8 +25,8 @@ packages =   managedPackages [(("local1", "1.0"), ["direct1", "direct2"])] -packageDb :: SourcePackages-packageDb =+available :: SourcePackages+available =   [     ("direct1", allDep "transitive1 >=1.0" [       ([1, 8, 1], []),@@ -46,7 +46,7 @@   ]  ghcPackages :: GhcPackages-ghcPackages = GhcPackages {installed = [], available = packageDb}+ghcPackages = GhcPackages {installed = [], available}  state :: ProjectStateProto state =

@@ -21,8 +21,8 @@ packages =   managedPackages [(("local1", "1.0"), ["dep1", "dep2", "dep3"])] -packageDb :: SourcePackages-packageDb =+available :: SourcePackages+available =   [     ("dep1", [       ([1, 8], []),@@ -43,7 +43,7 @@   ]  ghcPackages :: GhcPackages-ghcPackages = GhcPackages {installed = [], available = packageDb}+ghcPackages = GhcPackages {installed = [], available}  state :: ProjectStateProto state =

@@ -22,8 +22,8 @@ import Hix.Test.Managed.Run (TestParams (..), Result (..), testParams, lowerTest) import Hix.Test.Utils (UnitTest) -packageDb :: SourcePackages-packageDb =+available :: SourcePackages+available =   [     ("direct1", [       ([1, 8, 1], []),@@ -38,7 +38,7 @@   ]  ghcPackages :: GhcPackages-ghcPackages = GhcPackages {installed = [], available = packageDb}+ghcPackages = GhcPackages {installed = [], available}  packages :: Packages ManagedPackageProto packages =

@@ -26,7 +26,7 @@ import Hix.Managed.Data.ProjectContextProto (ProjectContextProto (..)) import Hix.Managed.Data.ProjectResult (ProjectResult) import Hix.Managed.Data.ProjectStateProto (ProjectStateProto)-import Hix.Managed.Data.StageState (BuildResult (Finished), BuildStatus (Failure))+import Hix.Managed.Data.StageState (BuildStatus (Failure), resultFromStatus) import qualified Hix.Managed.Handlers.Build as BuildHandlers import Hix.Managed.Handlers.Build (BuildHandlers (..)) import qualified Hix.Managed.Handlers.Build.Test as BuildHandlers@@ -98,7 +98,8 @@   TestT IO (Result a) managedTest' defaultEnvName params main =   withFrozenCallStack do-    (handlers0, stateFileRef, _) <- BuildHandlers.handlersUnitTest params.ghcPackages (fmap Finished . params.build)+    (handlers0, stateFileRef, _) <-+      BuildHandlers.handlersUnitTest params.ghcPackages (fmap resultFromStatus . params.build)     (cabalRef, handlers1) <-       if params.cabalLog       then first Just <$> BuildHandlers.logCabal handlers0

@@ -5,10 +5,11 @@  import Hix.Class.Map (nKeys) import qualified Hix.Managed.Cabal.Changes+import Hix.Managed.Cabal.Changes (solverPlan) import Hix.Managed.Cabal.Data.Config (GhcDb (GhcDbSystem)) import Hix.Managed.Cabal.Data.SolverState (solverState) import qualified Hix.Managed.Cabal.Resources as SolveResources-import Hix.Managed.Cabal.Solve (solveWithCabal)+import Hix.Managed.Cabal.Solve (solveWithCabal') import Hix.Managed.Cabal.Sort (sortDeps) import Hix.Managed.Data.EnvContext (EnvDeps (EnvDeps)) import Hix.Managed.Data.Mutable (unsafeMutableDep)@@ -21,16 +22,21 @@   evalEither =<< liftIO do     runMTest True do       res <- SolveResources.acquire mempty def (GhcDbSystem Nothing)-      result <- solveWithCabal res state+      mb_sip <- solveWithCabal' res state       sorted <- sortDeps res id (nKeys constraints)       liftIO do         putStrLn ""         putStrLn "Constraints:"         putStrLn (showP constraints)-        putStrLn ""-        putStrLn "Changes:"-        putStrLn (maybe "no plan" (show . prettyL . (.changes)) result)-        putStrLn ""+        for_ mb_sip \ sip -> do+          let plan = solverPlan sip+          putStrLn ""+          putStrLn "Changes:"+          putStrLn (show (prettyL plan.changes))+          putStrLn ""+          putStrLn "Matching DB:"+          putStrLn (show (prettyL plan.matching))+          putStrLn ""         putStrLn "Sorted:"         putStrLn (showPL sorted)   where

@@ -18,6 +18,7 @@ import Hix.Data.Version (SourceHash (SourceHash), Version) import qualified Hix.Data.VersionBounds import Hix.Data.VersionBounds (VersionBounds (VersionBounds), fromLower, unsafeVersionBoundsFromRange, versionBounds)+import Hix.Managed.Cabal.Data.SourcePackage (SourcePackageId (..)) import Hix.Managed.Data.Constraints (MutationConstraints (mutation)) import Hix.Managed.Data.Mutable (MutableDep, unsafeMutableDep) import qualified Hix.Managed.Data.MutableId@@ -71,3 +72,10 @@     (package, mempty {mutation = unsafeVersionBoundsFromRange version})     where       Dep {package, version} = fromString s++instance IsList SourcePackageId where+  type Item SourcePackageId = Dep++  fromList s = SourcePackageId {deps = fromList s, description = Nothing}++  toList = (.deps)