Use revTimestamp to only pick revisions in our index-state

Author: pranaysashank

modules/hackage-project.nix

@@ -1,6 +1,6 @@
 { lib, config, pkgs, haskellLib, ... }:
 let
-  inherit (config) name version revision;
+  inherit (config) name version revision index-state;
 in {
   _file = "haskell.nix/modules/hackage-project.nix";
   options = {
@@ -21,6 +21,19 @@ in {
       type = lib.types.str;
       default = "default";
       description = ''Hackage revision to use ("default", "r1", "r2", etc.)'';
+      apply = r: if r == "default"
+                 then (lib.attrsets.foldlAttrs
+                   (acc: name: value:
+                     if value.revTimestamp > acc.rTimestamp
+                     then { rName = name; rTimestamp = value.revTimestamp; }
+                     else acc
+                   )
+                   ({ rName = "default"; rTimestamp = "0"; })
+                   (
+                   lib.attrsets.filterAttrs (_: a: builtins.isAttrs a && a.revTimestamp <= index-state)
+                     (pkgs.haskell-nix.hackage.${config.name}.${version}.revisions)
+                   )).rName
+                 else r;
     };
   };
   config = {

modules/hackage.nix

@@ -1,4 +1,4 @@
-{ lib, config, pkgs, ... }:
+{ lib, config, pkgs, index-state, ... }:
 
 let
   # hackage looks like the following:
@@ -87,7 +87,21 @@ let
           revisions =
             lib.mapAttrs
               (_: rev2Config { inherit pname vnum; inherit (version) sha256; })
-              (makeContentAddressed version.revisions);
+              (makeContentAddressed
+                (
+                  let maxAllowedRev = (lib.attrsets.foldlAttrs
+                   (acc: name: value:
+                     if value.revTimestamp > acc.rTimestamp
+                     then { rName = name; rTimestamp = value.revTimestamp; }
+                     else acc
+                   )
+                   ({ rName = "default"; rTimestamp = "0"; })
+                   (
+                   lib.attrsets.filterAttrs (_: a: builtins.isAttrs a && a.revTimestamp <= index-state)
+                     version.revisions
+                   )).rName;
+                  in (version.revisions // {"default" = version.revisions."${maxAllowedRev}";}))
+              );
         }));
 
 in

nix-tools/cabal.project

@@ -27,5 +27,5 @@ allow-newer:
 source-repository-package
     type: git
     location: https://github.com/michaelpj/hackage-db.git
-    tag: f3b9240212b036391871e4ea09891e91efcea7a1
-    --sha256: sha256-n0ATmkwtR68E2FuZK3QIQgZirVmWbd21vIQmzhGKsRw=
+    tag: 83f819cb08742d3c86a83b407d45c1f6c1c7e299
+    --sha256: sha256-8NTfSb1fE/so843qG59XpvPE2HIYTa0D1UrpnHdJ44U=

nix-tools/nix-tools/hackage2nix/Main.hs

@@ -14,6 +14,7 @@ import qualified Data.ByteString.Char8         as BS
 import           Data.Foldable                            ( toList
                                                           , for_
                                                           )
+import           Data.Int
 import           Data.List                                ( intersperse )
 import           Data.Map                                 ( Map )
 import qualified Data.Map                      as Map
@@ -25,6 +26,8 @@ import           Data.String                              ( IsString(fromString)
 import           Data.Text                                ( Text )
 import qualified Data.Text                     as T       ( pack )
 import           Data.Text.Encoding                       ( decodeUtf8 )
+import           Data.Time.Format.ISO8601                 ( iso8601Show )
+import           Data.Time.Clock.POSIX                    ( posixSecondsToUTCTime )
 import           Distribution.Hackage.DB                  ( hackageTarball )
 import qualified Distribution.Hackage.DB.Parsed
                                                as P
@@ -136,22 +139,25 @@ version2nix pname vnum (U.VersionData { U.cabalFileRevisions, U.metaFile }) =
 revBindingJson
   :: PackageName
   -> Version
-  -> BS.ByteString
+  -> (Int64, BS.ByteString)
+  -- ^ (EpochTime, Cabal File)
   -> Integer
   -> GPDWriter (Text, NExpr)
-revBindingJson pname vnum cabalFile revNum = do
+revBindingJson pname vnum (epochTime, cabalFile) revNum = do
   let qualifiedName = mconcat $ intersperse
         "-"
         [prettyPname, fromPretty vnum, revName, BS.unpack cabalHash]
       revName :: (Semigroup a, IsString a) => a
       revName     = "r" <> fromString (show revNum)
       revPath     = "." </> "hackage" </> qualifiedName <.> "nix"
+      revTimestamp = iso8601Show (posixSecondsToUTCTime (fromIntegral epochTime))
       prettyPname = fromPretty pname
       cabalHash   = Base16.encode $ hash cabalFile
   modify' $ mappend $ Seq.singleton
     (cabalFile, prettyPname ++ ".cabal", revPath)
   return (revName, mkNonRecSet
     [ "nix" $= mkSym "import" @@ mkSym (T.pack ("../hackage/" <> qualifiedName <> ".nix"))
     , "revNum" $= mkInt revNum
+    , "revTimestamp" $= mkStr (T.pack revTimestamp)
     , "sha256" $= mkStr (decodeUtf8 cabalHash)
     ])

nix-tools/nix-tools/nix-tools.cabal

@@ -140,6 +140,7 @@ executable hackage-to-nix
                      , containers
                      , bytestring
                      , text
+                     , time
                      , cryptohash-sha256
                      , base16-bytestring
                      , base64-bytestring

overlays/haskell.nix

@@ -70,14 +70,15 @@ final: prev: {
             , pkg-def-extras ? [] # Additional packages to augment the Base package set `pkg-def` with.
             , modules ? []
             , extra-hackages ? [] # Extra Hackage repositories to use besides main one.
+            , index-state
             }@args:
 
             let
               hackageAll = builtins.foldl' final.lib.recursiveUpdate hackage extra-hackages;
             in
 
             import ../package-set.nix {
-                inherit (args) pkg-def pkg-def-extras;
+                inherit (args) pkg-def pkg-def-extras index-state;
                 modules = defaultModules ++ modules;
                 pkgs = final;
                 hackage = hackageAll;
@@ -141,6 +142,7 @@ final: prev: {
             , extra-hackages ? []
             , compiler-nix-name ? null
             , compilerSelection ? p: p.haskell-nix.compiler
+            , index-state
             }:
 
             let
@@ -163,7 +165,7 @@ final: prev: {
                        Make sure you didn't forget to update plan-sha256.''
               );
               mkPkgSet {
-                inherit pkg-def;
+                inherit pkg-def index-state;
                 pkg-def-extras = [ plan-pkgs.extras
                                    # Using the -unchecked version here to avoid infinite
                                    # recursion issues when checkMaterialization = true
@@ -652,7 +654,7 @@ final: prev: {
           projectModule: haskellLib.evalProjectModule ../modules/cabal-project.nix projectModule (
             { config, options, ... }:
             let
-              inherit (config) compiler-nix-name compilerSelection evalPackages;
+              inherit (config) compiler-nix-name compilerSelection evalPackages index-state;
 
               callProjectResults = callCabalProjectToNix config;
               plan-pkgs = importAndFilterProject {
@@ -671,7 +673,7 @@ final: prev: {
                   };
                 }
                 else mkCabalProjectPkgSet
-                { inherit compiler-nix-name compilerSelection plan-pkgs;
+                { inherit compiler-nix-name compilerSelection plan-pkgs index-state;
                   pkg-def-extras = config.pkg-def-extras or [];
                   modules = [ { _module.args.buildModules = final.lib.mkForce buildProject.pkg-set; } ]
                     ++ (config.modules or [])

package-set.nix

@@ -1,5 +1,5 @@
-let f = { hackage, pkgs, pkg-def, pkg-def-extras ? [], modules ? [] }: let
-  buildModules = f { inherit hackage pkg-def pkg-def-extras modules; pkgs = pkgs.buildPackages; };
+let f = { hackage, pkgs, pkg-def, pkg-def-extras ? [], modules ? [], index-state }: let
+  buildModules = f { inherit hackage pkg-def pkg-def-extras modules index-state; pkgs = pkgs.buildPackages; };
 in pkgs.lib.evalModules {
   modules = modules ++ [
     ({ config, lib, ... }: {
@@ -15,6 +15,8 @@ in pkgs.lib.evalModules {
         pkgs = import ./lib/system-pkgs.nix pkgs;
         pkgconfPkgs = import ./lib/pkgconf-nixpkgs-map.nix pkgs;
 
+        inherit index-state;
+
         inherit buildModules;
       };