lib.dh

  λ(dataDir : Text)
→ λ(manifestDir : Text)
→ let values = ./resources/package.dh
  
  let types = ./resources/types.dh
  
  let argotypes = ./argo/types.dh
  
  let argo = ./argo/package.dh
  
  let assetDir = dataDir ++ "assets/"
  
  let openmcDir = assetDir ++ "openmc/"
  
  let lammpsDir = assetDir
  
  let qmcPackDir = assetDir
  
  let Powercap = < Cap : Text | NoCap : {} >
  
  let id = λ(a : Type) → λ(x : a) → x
  
  let idCmd = id types.Cmd
  
  let makeExtended =
          λ(daemonArg : argotypes.MkDaemon)
        → λ(daemonOverrides : types.Cmd → types.Cmd)
        → λ(runArg : argotypes.MkRun)
        → λ(runOverrides : types.Cmd → types.Cmd)
        → λ(extraCmds : List types.Cmd)
        →   { cmds =
                  [ daemonOverrides (argo.nrmd.mk daemonArg)
                  , runOverrides (argo.run.mk runArg)
                  ]
                # extraCmds
            , verbose =
                True
            , cleaning =
                True
            , workdir =
                "./_output"
            , pre =
                [] : List Text
            , post =
                [] : List Text
            }
          : types.Config
  
  let FilterTestArgs =
        { manifestname :
            Text
        , filter :
            Text
        , cmd :
            Text
        , args :
            List Text
        , vars :
            List types.EnvVar
        , passvars :
            List Text
        , cmdavoids :
            List Text
        , isTest :
            Bool
        , timeout :
            Optional Natural
        , powercap :
            Powercap
        }
  
  let emptyFilterTestArgs =
          λ(filter : Text)
        → λ(cmd : Text)
        →   { cmd =
                cmd
            , manifestname =
                "perfwrap.yml"
            , filter =
                filter
            , args =
                [] : List Text
            , vars =
                values.emptyVars
            , passvars =
                [] : List Text
            , cmdavoids =
                [] : List Text
            , isTest =
                False
            , timeout =
                [] : Optional Natural
            , powercap =
                < NoCap = {=} | Cap : Text >
            }
          : FilterTestArgs
  
  let appTest =
        let cn = "containerName"
        
        in    λ(args : FilterTestArgs)
            → makeExtended
              { powercap =
                  args.powercap
              , verbose =
                  True
              , singularity =
                  False
              , daemonavoids =
                  [ "Traceback", "ValueError" ]
              }
              idCmd
              { manifest =
                      manifestDir
                  ++  (       if args.isTest
                        
                        then  args.manifestname
                        
                        else  "parallel.yml"
                      )
              , containerName =
                  cn
              , cmd =
                  args.cmd
              , args =
                  args.args
              , cmdwants =
                  [] : List Text
              , cmdavoids =
                  args.cmdavoids
              , passvars =
                  args.passvars
              }
              (   λ(c : types.Cmd)
                → c ⫽ { timeout = args.timeout, vars = args.vars }
              )
              [ argo.listen.mk
                (argo.listen.defarg cn ⫽ { filter = args.filter })
              ]
  
  let ProgressAppTestArg =
        { cmd :
            Text
        , args :
            List Text
        , vars :
            List types.EnvVar
        , passvars :
            List Text
        , cmdavoids :
            List Text
        , isTest :
            Bool
        , timeout :
            Optional Natural
        , powercap :
            Powercap
        }
  
  let emptyProgressAppTestArg =
          λ(cmd : Text)
        → λ(args : List Text)
        →   { cmd =
                cmd
            , args =
                args
            , vars =
                [] : List types.EnvVar
            , passvars =
                [] : List Text
            , cmdavoids =
                [] : List Text
            , isTest =
                False
            , timeout =
                [] : Optional Natural
            , powercap =
                < NoCap = {=} | Cap : Text >
            }
          : ProgressAppTestArg
  
  let progressAppTest =
          λ(args : ProgressAppTestArg)
        → appTest
          (   emptyFilterTestArgs "progress" args.cmd
            ⫽ { args =
                  args.args
              , manifestname =
                  "basic.yml"
              , vars =
                  args.vars
              , passvars =
                  args.passvars
              , cmdavoids =
                  args.cmdavoids
              , isTest =
                  args.isTest
              , timeout =
                  args.timeout
              , powercap =
                  args.powercap
              }
          )
  
  let mkListen =
          λ(cn : Text)
        → λ(filter : Text)
        → let b =
                values.emptyCmd
                { name =
                    "nrm"
                , outfile =
                    filter ++ ".out"
                , errfile =
                    filter ++ ".err"
                }
          
          in  b ⫽ { args = [ "listen", "-u", cn, "--filter", filter ] }
  
  let powerexpeCmds =
        let cn = "containerName"
        
        in    [ argo.listen.mk (argo.listen.defarg cn ⫽ { filter = "power" })
              , argo.listen.mk
                (argo.listen.defarg cn ⫽ { filter = "performance" })
              , argo.listen.mk (argo.listen.defarg cn ⫽ { filter = "control" })
              ]
            : List types.Cmd
  
  let extendApp =
          λ(c : types.Config)
        → λ(isTest : Bool)
        → if isTest then c else c ⫽ { cmds = c.cmds # powerexpeCmds }
  
  in  { values =
          values
      , makeExtended =
          makeExtended
      , appTest =
          appTest
      , progressAppTest =
          progressAppTest
      , emptyFilterTestArgs =
          emptyFilterTestArgs
      , qmcPackDir =
          qmcPackDir
      , openmcDir =
          openmcDir
      , lammpsDir =
          lammpsDir
      , manifestDir =
          manifestDir
      , emptyProgressAppTestArg =
          emptyProgressAppTestArg
      , powerexpeCmds =
          powerexpeCmds
      , extendApp =
          extendApp
      , idCmd =
          id types.Cmd
      }