@mitchellwrosen: add int-supply, add park-bench, move unix-compat to abandoned

.dir-locals.el

@@ -0,0 +1,3 @@
+((haskell-mode . ((haskell-process-type . cabal-repl)
+                  (haskell-indent-spaces . 4)
+                  (hindent-style . "johan-tibell"))))

.dockerignore

@@ -0,0 +1,10 @@
+dist
+builds
+logs
+.cabal-sandbox
+cabal.sandbox.config
+tarballs
+*.yaml
+.git
+automated
+.github

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,13 @@
+Checklist:
+- [ ] Meaningful commit message, eg `add my-cool-package` (please don't mention `build-constraints.yml`)
+- [ ] At least 30 minutes have passed since uploading to Hackage
+- [ ] If applicable, required system libraries are added to [02-apt-get-install.sh](https://github.com/commercialhaskell/stackage/blob/master/docker/02-apt-get-install.sh) or [03-custom-install.sh](https://github.com/commercialhaskell/stackage/blob/master/docker/03-custom-install.sh)
+- [ ] (optional) Package is compatible with the latest version of all dependencies (Run `cabal update && cabal outdated`)
+- [ ] (optional) Package have been verified to work with the latest nightly snapshot, e.g by running the [verify-package script](https://github.com/commercialhaskell/stackage/blob/master/verify-package)
+
+The script runs virtually the following commands in a clean directory:
+
+      stack unpack $package-$version # `-$version` is optional
+      cd $package-$version
+      rm -f stack.yaml && stack init --resolver nightly --ignore-subdirs
+      stack build --resolver nightly --haddock --test --bench --no-run-benchmarks

.github/workflows/check.yml

@@ -0,0 +1,24 @@
+name: check
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    name: Stackage check
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.stack
+            ~/.stackage/curator/cache
+          key: ${{ runner.os }}-stackage-nightly-${{ hashFiles('**/build-constraints.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-
+      - run: etc/check.sh

.github/workflows/image.yml

@@ -0,0 +1,26 @@
+name: image
+
+on:
+  push:
+    branches:
+      - nightly
+      - lts21
+
+jobs:
+  push:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push'
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Log into Github registry
+        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login docker.pkg.github.com -u ${{ github.actor }} --password-stdin
+
+      - name: Build image
+        run: |
+          IMAGE_ID=docker.pkg.github.com/${{ github.repository }}/build:${GITHUB_REF#refs/heads/}
+          #IMAGE_ID=${{ github.repository }}:${GITHUB_REF#refs/heads/}
+          docker build . -f Dockerfile --tag $IMAGE_ID
+          docker push $IMAGE_ID
+          echo Pushed new build image $IMAGE_ID

.gitignore

@@ -0,0 +1,11 @@
+/builds/
+/logs/
+/tmp.*/
+nightly-*.yaml
+lts-*.yaml
+*.swp
+check-plan.yaml
+*~
+/constraints.yaml
+/snapshot.yaml
+/snapshot-incomplete.yaml

.project-settings.yml

@@ -0,0 +1,10 @@
+module-template: ! 'module MODULE_NAME where
+
+'
+extensions: {}
+environment: default
+cabal-file: project.cabal
+version: 1
+ghc-args: []
+excluded-modules:
+- Setup.hs

CODE_OF_CONDUCT.md

@@ -0,0 +1,3 @@
+We use the [Haskell Foundation's Guidelines For Respectful
+Communication](https://haskell.foundation/guidelines-for-respectful-communication/)
+as our Code of Conduct.

CURATORS.md

@@ -0,0 +1,614 @@
+This is a collection of instructions covering the processes that the Stackage curators - the
+team who maintain the Stackage project itself - should be doing on a regular basis.
+Curation activities are mostly automated, and do not take up a significant amount of time.
+The following is the current list of curators, in alphabetical order:
+
+* Adam Bergmark (@bergmark)
+* Alexey Zabelin (@alexeyzab)
+* Andreas Ländle (@alaendle)
+* Chris Dornan (@cdornan)
+* Dan Burton (@danburton)
+* Jens Petersen (@juhp)
+* Joe Kachmar (@jkachmar)
+* Mihai Maruseac (@mihaimaruseac)
+
+## Workflow overview
+
+This section sketches out at a high level how the entire Stackage build/curation
+process works:
+
+* [build-constraints.yaml](https://github.com/commercialhaskell/stackage/blob/master/build-constraints.yaml) specifies packages to be included in Stackage
+* [curator](https://github.com/commercialhaskell/curator) combines build-constraints.yaml with the current state of Hackage to create a build plan for a Stackage Nightly
+* `curator` can check that build plan to ensure all version bounds are consistent
+    * The [Travis job](https://github.com/commercialhaskell/stackage/blob/master/.travis.yml) performs these two steps to provide immediate feedback on pull requests
+* Docker builds [builds](https://github.com/commercialhaskell/stackage/actions/workflows/image.yml)
+* The stackage-build server (described below) is able to run automated builds using the [build.sh script](https://github.com/commercialhaskell/stackage/blob/master/automated/build.sh)
+* When a new (nightly or LTS) build is completed, it is uploaded to [stackage-snapshots](https://github.com/commercialhaskell/stackage-snapshots)
+* Once a week, we run an LTS minor bump. Instead of using build-constraints.yaml, that job takes the previous LTS release, turns it into `^>=` constraints, and then bumps the version numbers to the latest on Hackage, in accordance with the generated constraint.
+* Cutting a new LTS major release is essentially just a Stackage Nightly that gets rebuilt and uploaded as an LTS
+
+## Pull requests
+
+The typical story on pull requests is: If Travis accepts it and the
+author only added packages under his/her own name, merge it.  If the
+build later fails (see [Adding Debian packages]), then block the
+package until it's fixed.
+
+[Adding Debian packages]: https://github.com/commercialhaskell/stackage/blob/master/CURATORS.md#adding-debian-packages-for-required-system-tools-or-libraries
+
+If benchmarks, haddocks, or test suites fails at this point we
+typically also block the package until these issues are fixed. This in
+order to add packages with a clean slate.
+
+Optionally we can check if packdeps says the package is up to date.
+Visit http://packdeps.haskellers.com/feed?needle=<package-name>
+
+Builds may fail because of unrelated bounds changes. If this happens,
+first add any version bounds to get master into a passing state (see
+"Fixing bounds issues"), then re-run the travis build.
+
+A common issue is that authors submit newly uploaded packages, it can
+take up to an hour before this has synced across the stack
+infrastructure. You can usually compare the versions of the package in
+https://github.com/commercialhaskell/all-cabal-metadata/tree/master/packages/
+to what's on hackage to see if this is the case. Wait an hour and
+re-run the pull request.
+
+Tests also commonly fail due to missing test files, and sometimes due
+to doctest limitations. You can point the maintainer to
+https://github.com/bergmark/blog/blob/master/2016/package-faq.md
+
+## Fixing bounds issues
+
+The most common activity you'll deal with in Stackage curation is a version
+bound issue, usually a restrictive upper bound. You fix this by opening an
+issue on the Stackage repo about the problem, and modifying the
+build-constraints.yaml file to work around it in one of the ways below. Be sure
+to refer to the issue for workarounds added to that file.
+
+### Temporary upper bounds
+
+Most common technique, just prevent a new version of a library from
+being included immediately. This also applies to when only benchmarks
+and tests are affected.
+
+* Copy the `curator` output and create a new issue, see e.g
+https://github.com/commercialhaskell/stackage/issues/2108
+
+* Add a new entry under the "stackage upper bounds" section of `build-constraints.yaml`. For the above example it would be
+
+```yaml
+    "Stackage upper bounds":
+        # https://github.com/commercialhaskell/stackage/issues/2108
+        - pipes < 4.3.0
+```
+
+* Commit (message e.g. "Upper bound for #2108")
+* Optionally: Verify with `./check` locally
+* Push
+* Verify that everything works on the build server (you can restart the build or wait for it to to run again)
+
+Sometimes releases for different packages are tightly coupled. Then it
+can make sense to combine them into one issue, as in
+https://github.com/commercialhaskell/stackage/issues/2143.
+
+If a dependency that is not explicitly in stackage is causing test or
+benchmark failures you can skip or expect them to fail (see "Skipping
+tests and benchmarks" and "Expecting test/benchmark/haddock
+failures"). Bonus points for reporting this upstream to that packages'
+maintainer.
+
+### Lifting upper bounds
+
+You can try this when you notice that a package has been updated. You
+can also periodically try to lift bounds (I think it's good to do this
+at the start of your week /@bergmark)
+
+If not all packages have been updated check if any of them are missing
+from the original issue and if so add a new comment mentioning them. A
+new package may appear if its dependencies were part of this issue but
+have been updated since the last time we checked. We want to give
+these new packages ample time to be upgraded.
+
+If `curator` is happy commit the change ("Remove upper bounds
+and close #X"). After doing this the next nightly build may fail
+because some packages didn't have an upper bound in place, but
+compilation failed. In this case revert the previous commit so any
+disabled packages are enabled again, re-open the issue, and add a new
+comment with the failing packages. This is to give all maintainers
+enough time to upgrade for this case as well.
+
+### Amending upper bounds
+
+With the `pipes` example above there was later a new release of
+`pipes-safe` that required the **newer** version of `pipes`. You can
+add that package to the same upper bounds section,
+(e.g. https://github.com/commercialhaskell/stackage/commit/6429b1eb14db3f2a0779813ef2927085fa4ad673)
+as we want to lift them simultaneously.
+
+### Skipping tests and benchmarks
+
+Sometimes tests and benchmark dependencies are forgotten or not cared
+for. To disable compilation for them add them to `skipped-tests` or
+`skipped-benchmarks`. If a package is added to these sections they
+won't be compiled, and their dependencies won't be taken into account.
+
+There are sub sections under these headers that is used to group types
+of failures together, and also to document what type of failures
+exist.
+
+### Expecting test/benchmark/haddock failures
+
+The difference from the `skipped` sections is that items listed here
+are compiled and their dependencies are taken into account
+(but they are allowed to fail to build).
+These sections also have subsections with groups and descriptions.
+
+One big category of test suites in this section are those requiring
+running services. We don't want to run those, but we do want to check
+dependencies and compile them.
+
+If there are no version bounds that would fix the issue or if you
+can't figure it out, file it
+(e.g. https://github.com/commercialhaskell/stackage/issues/2133) to ask the
+maintainer for help.
+
+### Waiting for new releases
+
+Sometimes there is a failure reported on a (now possibly closed) issue
+on an external tracker. If an issue gets resolved but there is no
+hackage release yet we'd like to get notified when it's uploaded.
+
+Add the package with its current version to the
+`tell-me-when-its-released` section. This will cause the build to stop
+when the new version is out.
+
+### Excluding packages
+
+In an extreme case of a non-responsive maintainer, you can remove the
+package entirely from Stackage. We try to avoid that whenever
+possible.
+
+This typically happens when we move to a new major GHC release or when
+there are only a few packages waiting for updates on an upper bounds
+issue.
+
+If a package needs to be disabled due to build failures: Add a `< 0`
+bound to the package to exclude it, and add a comment stating why it
+was disabled: `- swagger < 0 # compile failure againts aeson 1.0`
+
+If a package needs to be disabled due to bounds issues, see the "Large
+scale enabling/disabling of packages" section below.
+
+If this causes reverse dependencies to be disabled we should notify
+the maintainers of those packages.
+
+
+## Updating the content of the Docker image used for building
+
+### Adding Debian packages for required system tools or libraries
+Additional (non-Haskell) system libraries or tools should be added to `docker/02-apt-get-install.sh` or `docker/03-custom-install.sh`.
+After you've committed those changes, merging them into the `nightly` branch should
+trigger an image build. Simply run:
+
+```bash
+    $ git checkout nightly
+    $ git merge master
+    $ git push
+```
+
+This will [trigger a build](https://github.com/commercialhaskell/stackage/actions/workflows/image.yml).
+
+Use [Ubuntu Package content search](http://packages.ubuntu.com/) to determine which package provides particular dev files (it defaults to xenial which is the version used to build Nightly).
+
+Note that we generally don't install/run services needed for testsuites in the docker images - packages with tests requiring some system service can be added to `expected-test-failures`.
+It's good to inform the maintainer of any disabled tests (commenting in the PR is sufficient).
+
+If a new package fails to build because of missing system libraries we often ask the maintainer to help figure out what to install.
+
+
+### Upgrading GHC version
+The nightly branch is used for nightlies. For LTSes, we use the ltsX branch,
+where X is the major version number (e.g., lts20 for lts-20.\*).)
+
+Note that when starting a new LTS major release, you'll need to modify `.github/workflows/image.yml` to add a new lts branch.
+
+Ensure that the [global-hints.yaml
+file](https://github.com/fpco/stackage-content/blob/master/stack/global-hints.yaml)
+is updated with information on the latest GHC release by cloning that
+repo and running `./update-global-hints.hs ghc-X.Y.Z`.
+
+If enountering an error like the following, this means that the [Stack metadata](https://github.com/commercialhaskell/stackage-content)
+has not yet been updated, so wait some time until this happens:
+
+```
+This probably means a GHC bindist has not yet been added for OS key 'linux64', 'linux64-ncurses6', 'linux64-tinfo6'.
+Supported versions: ...
+update-global-hints.hs: Received ExitFailure 1 when running
+```
+
+Also required to build an LTS minor bump with a ghc version change: On the build server, modify `/var/stackage/stackage/automated/work/lts-$THIS_LTS_MAJOR_VER/constraints.yaml` and update the ghc-version. (You may need to update sibling files as well.) Then run `NOPLAN=1 /var/stackage/stackage/automated/build.sh lts-$THIS_LTS_MINOR_BUMP` to build the LTS.
+
+### Getting the new image to the build server
+Once a new Docker image is available, you'll need to pull it onto the stackage-build server (see
+below). Instead of pulling an unbounded number of images, I typically just
+delete all of the old images and let the new ones get downloaded:
+
+```
+docker rm $(docker ps -a -q)
+docker rmi $(docker images -q)
+```
+
+but `docker pull ghcr.io/commercialhaskell/stackage/build:nightly` can also be run instead just to update the nightly image say.
+
+For a new GHC version you should also delete the ~~cache~~ .stack-work snapshot install directories on the stackage-build server to
+~~force all packages to be rebuilt~~ clear up some space. See: [issue#746](https://github.com/commercialhaskell/stackage/issues/746). Eg:
+
+```
+# for example
+SNAP_SERIES=nightly # or lts16
+OLD_GHCVER=8.10.1
+rm -r work/$SNAP_SERIES/unpack-dir/.stack-work/install/x86_64-linux/*/$OLD_GHCVER/
+```
+This should also be done when moving the Nightly docker image to a new version of Ubuntu.
+
+If you're impatient and would like to build the Docker image on the
+build server instead of waiting for Docker Hub, you can run the
+following command (replacing `BRANCH=nightly` if the image for a different branch is desired):
+
+```
+BRANCH=nightly
+DIR=$(mktemp -d)
+(cd $DIR \
+  && git clone https://github.com/commercialhaskell/stackage \
+  && cd stackage \
+  && git checkout $BRANCH \
+  && docker build --tag commercialhaskell/stackage:$BRANCH .)
+rm -rf $DIR
+```
+
+Note that we do a clean clone of the `stackage` repo instead of using
+the existing checkout because of how `docker build` works: it will
+send the entire local directory contents as context to the Docker
+daemon, which in the case of the build tree is a _lot_ of content. (We
+can discuss the wisdom&mdash;or lack thereof&mdash;of Docker's
+approach separately.)
+
+## stackage-build server
+
+You'll need to get your SSH public key added to the machine. ~/.ssh/config info:
+
+```
+Host stackage-build
+    User curators
+    Hostname stackage-builder.haskell.org
+```
+
+### Running the build script
+
+We currently run the builds manually so make it easy to see when there are
+bounds issues that need to be corrected. Automated this would be even better,
+we're just not there yet.
+
+```
+# Run a nightly build
+/var/stackage/stackage/automated/run-nightly.sh
+
+# Run an LTS minor bump
+/var/stackage/stackage/automated/build.sh lts-15.1
+
+# Run an LTS major bump
+/var/stackage/stackage/automated/build.sh lts-16.0
+```
+
+Recommended: run these from inside a `tmux` session. If you get version bound
+problems on nightly or LTS major, you need to fix build-constraints.yaml (see
+info above).
+
+### Building LTS minor releases
+Before running the build, please make sure that the Dockerfile in `automated/dockerfiles/lts-X.Y` is up to date, where X is the major version that you're building and Y is the latest minor version of X for which a Dockerfile exists.
+  * If any changes need to be made, (eg, new GHC version), copy `automated/lts-X.Y/Dockerfile` to `automated/lts-X.Z/Dockerfile`, where Z is the minor version you're building, and include the new changes.
+  * If you are building the first release of a new LTS major version, create a new `lts-X.0/Dockerfile` based on the previous LTS's, and adjust the variables at the top to match the requirements of the snapshot.  Ensure that `STACK_VERSION` is the latest release of Stack, and `BOOTSTRAP_COMMIT` is the commit ID of this repo containing the version of the `bootstrap-commit.sh` used to build the snapshot.  Also ensure the FROM image's Ubuntu version matches that used in the [root Dockerfile](Dockerfile) used to build this snapshot.
+
+First run `build.sh` to regenerate updated `ltsXX/work/constraints.yaml` and `ltsXX/work/snapshot-incomplete.yaml` files.
+
+For an LTS minor bump, you'll typically want to:
+
+* Add constraints to package `range:` fields _under_ the `source:` field in that `constraints.yaml` (should not be necessary normally to edit `snapshot-incomplete.yaml` to change the version used for that package).
+* Add new packages to the `constraints.yaml` file
+* Test, benchmark, haddock failures can also be added to package fields in the `constraints.yaml` if necessary, though it should be avoided if possible for LTS.
+
+Then run `NOPLAN=1 build.sh` to build the generate an updated snapshot.
+
+If a build fails for bounds reasons, see all of the advice above. If the code
+itself doesn't build, or tests fail, open up an issue and then either put in a
+version bound to avoid that version or something else. It's difficult to give
+universal advice on how to solve things, since each situation is unique. Let's
+develop this advice over time. For now: if you're not sure, ask for guidance.
+
+__`NOPLAN=1`__ If you wish to rerun a build without recalculating a
+build plan, you can set the environment variable `NOPLAN=1`. This is
+useful for such cases as an intermittent test failure, out of memory
+condition, or manually tweaking the plan file. (When using `NOPLAN=1`,
+if one needs to revert one package, say due to a build or test regression,
+one can edit `snapshot-incomplete.yaml`
+(the SHA256 hash of the .cabal file will get updated),
+to avoid having to rebuild everything again.)
+
+Note LTS builds without NOPLAN will use the latest Hackage data.
+
+If you need to make further modifications beyond what `constraints.yaml` allows, you can directly edit the `snapshot-incomplete.yaml` file. Then, instead of `NOPLAN=1 build.sh`, you need to use `NOPLAN=2 build.sh`. Note that from this point on, further changes to `constraints.yaml` will not impact the build plan.
+
+### Timing
+
+A looping script on the build server keeps trying to build nightly
+with `sleep 30m` interleaved. It only publishes the nightly once per
+day. This way new package versions or build failures can be caught
+early and hopefully the nightlies will be timely.
+
+LTS minor bumps are typically run on weekends. It can be a good idea
+to start the build on friday or saturday to have enough time to
+resolve any issues before the next curator shift the coming monday.
+
+### Diskspace errors (and website sync debugging)
+
+* You can detect the problem by running `df`. If you see that `/` is out of space, we have a problem.
+* If you see that `/var/stackage/` is out of space, you can:
+  * run `./etc/diskspace/remove-old-stack-work-libs.hs [nightly|lts-XX]`
+  * If that is insufficient then remove all the old builds under the previous ghc/Cabal version:
+    * `rm -r /var/stackage/stackage/automated/work/[nightly|lts-XX]/unpack-dir/unpacked/*/.stack-work/dist/x86_64-linux/Cabal-X.Y.0.0/`
+
+  optionally:
+  * `rm -r /var/stackage/stackage/automated/work/lts*/unpack-dir/unpacked/`
+  * `rm -r /var/stackage/stackage/automated/work/nightly/unpack-dir/unpacked/`
+
+### Wiping the cache
+
+Sometimes the cache can get corrupted which might manifest as `can't load .so/.DLL`.
+You can wipe the nightly cache and rebuild everything by doing
+`rm -rf /var/stackage/stackage/automated/nightly`.
+Replace nightly with `lts7` to wipe the LTS 7 cache.
+
+### Force a single package rebuild
+
+You can force a single package to rebuild by deleting its "previous result"
+file, e.g.:
+
+```
+$ rm /var/stackage/stackage/automated/nightly/work/builds/nightly/prevres/Build/cryptohash-0.11.9
+```
+
+### Restarting docker
+
+If docker hangs with e.g. `docker: Error response from daemon:
+connection error: desc = "transport: dial unix
+/var/run/docker/containerd/docker-containerd .sock: connect:
+connection refused".` you can restart it with `sudo systemctl restart
+docker.service`.
+
+## Local curator setup
+
+We do not run the full stackage build locally as that might take too
+much time. However, some steps on the other hand are much faster to do
+yourself, e.g. verifying constraints without building anything.
+
+To get started, install `curator` via Git:
+
+```
+$ git clone git@github.com:commercialhaskell/curator.git
+$ cd curator && stack install curator
+```
+
+It is a good idea to upgrade `curator` at the start of your week.
+Then, clone the stackage repo, get the latest packages and run dependency
+resolution:
+
+```
+$ git clone git@github.com:commercialhaskell/stackage.git
+$ cd stackage
+$ ./check
+```
+
+This can be used to make sure all version bounds are in place, including for
+test suites and benchmarks, to check whether bounds can be lifted, and to get
+[tell-me-when-its-released] notifications.
+
+`curator` does not build anything, so you wont see any compilation
+errors for builds, tests and benchmarks.
+
+[tell-me-when-its-released]: https://github.com/commercialhaskell/stackage/blob/master/CURATORS.md#waiting-for-new-releases
+
+### Large scale enabling/disabling of packages
+
+`etc/commenter` is a binary that automates `build-constraints.yaml` workflows.
+
+#### Setup
+This is currently a rust program, You can install the rust toolchain
+by using [rustup](https://rustup.rs/).
+
+#### Example usage
+
+After disabling a few packages you get this curator output:
+
+```
+ConfigFile (GHC 9 bounds issues, @maintainer) (not present) depended on by:
+- [ ] xdg-desktop-entry-0.1.1.1 (-any). @maintainer. Used by: library
+
+
+pipes-misc (GHC 9 bounds issues, @maintainer) (not present) depended on by:
+- [ ] pipes-fluid-0.6.0.1 (>=0.5). @handles. Used by: test-suite
+
+
+testing-feat (GHC 9 bounds issues, Grandfathered dependencies) (not present) depended on by:
+- [ ] dual-tree-0.2.3.0 (-any). Grandfathered dependencies. @handles. Used by: test-suite
+```
+
+Now run:
+```
+./check 2>&1 >/dev/null | ./commenter add
+```
+
+You will get this output:
+```
+[INFO] ...
+LIBS + EXES
+
+        - xdg-desktop-entry < 0 # tried xdg-desktop-entry-0.1.1.1, but its *library* requires the disabled package: ConfigFile
+
+TESTS
+
+    - dual-tree # tried dual-tree-0.2.3.0, but its *test-suite* requires the disabled package: testing-feat
+    - pipes-fluid # tried pipes-fluid-0.6.0.1, but its *test-suite* requires the disabled package: pipes-misc
+
+Adding 1 libs, 2 tests, 0 benches to build-constraints.yaml
+```
+
+These bounds are added to build-constraints.yaml automatically.
+
+Re-run this command until no more packages are disabled.
+
+#### Re-enabling
+
+We can periodically remove all packages under the bounds sections and then re-run the disabling flow above until we get a clean plan. This will automatically pick up packages that have been fixed.
+
+```
+./commenter clear
+./check 2>&1 >/dev/null | ./commenter add
+```
+
+Repeat the second command until no updates are made to build-constraints.yaml (or use `commenter add-loop` instead).
+
+#### Checking for new releases
+
+Run `stack update` before doing this.
+
+`./commenter outdated` looks through all bounds issues and library
+compilation failures and compares the marked version with the latest hackage release. Example output is
+
+```
+Fin mismatch, manual: 0.2.8.0, hackage: 0.2.9.0
+aeson mismatch, auto: 1.5.6.0, hackage: 2.0.2.0
+```
+
+where "manual" means the bound was added manually by a curator,
+perhaps due to a compilation failure so we could try re-enabling the
+package. "auto" means it's part of the sections generated by
+`./commenter`, to update that run the `Re-enabling` step as documented
+above.
+
+`outdated` only finds packages that are in the auto generated
+sections, or that are of the form `- package < 0 # $version`.
+
+#### Notes
+
+* Please make sure to separate bounds issues from compilation failures/test run failures, as we cannot verify that a package builds or that tests pass without running the build!
+
+#### Diffing snapshots / Inspecting changes
+
+To diff existing snapshots, or to evaluate changes before they end up
+in a snapshot you can run:
+
+```
+./commenter diff-snapshot <old-snapshot.yaml> <new-snapshot.yaml>
+```
+
+Existing snapshots can be retrieved from https://github.com/commercialhaskell/stackage-snapshots. Preliminary snapshots can be generated by running relevant parts of `automated/build.sh`, at the time of writing:
+
+```
+TARGET=nightly-2021-01-14 \ # the date doesn't matter
+  curator update && \
+  curator constraints --target $TARGET && \
+  curator snapshot-incomplete --target $TARGET && \
+  curator snapshot
+```
+
+#### Pinging maintainers after disabling packages
+
+After lifting a bound We often have to disable additional packages due
+to compilation failures. `affected` figures out which packages have
+been disabled and which maintainers are affected. Note that this does
+not handle disabled test suites and benchmarks as the snapshots don't
+contain this information.
+
+```
+./commenter affected <old-snapshot.yaml> <new-snapshot.yaml>
+```
+
+E.g.:
+```
+$ commenter affected ../stackage-snapshots/nightly/2022/1/2.yaml ../stackage-snapshots/nightly/2022/2/7.yaml
+```
+```
+alg-0.2.13.1: Matthew Farkas-Dyck <strake888@gmail.com> @strake
+butter-0.1.0.6: Matthew Ahrens <matt.p.ahrens@gmail.com> @mpahrens
+category-0.2.5.0: Matthew Farkas-Dyck <strake888@gmail.com> @strake
+constraint-0.1.4.0: Matthew Farkas-Dyck <strake888@gmail.com> @strake
+dl-fedora-0.9.2: Jens Petersen <juhpetersen@gmail.com> @juhp
+foldable1-0.1.0.0: Matthew Farkas-Dyck <strake888@gmail.com> @strake
+gitlab-haskell-0.3.2.0: Rob Stewart <robstewart57@gmail.com> @robstewart57
+hslua-module-doclayout-1.0.0: Albert Krewinkel <albert+stackage@zeitkraut.de> @tarleb
+util-0.1.17.1: Matthew Farkas-Dyck <strake888@gmail.com> @strake
+wai-middleware-auth-0.2.5.1: Alexey Kuleshevich <lehins@yandex.ru> @lehins
+yesod-csp-0.2.5.0: Bob Long <robertjflong@gmail.com> @bobjflong
+```
+
+#### Finding disabled packages with lots of dependents
+
+`./commenter disabled` prints the number of transitive dependents a disabled package has. Low hanging fruit to get a lot of packages included again.
+
+Example output:
+```
+[...]
+stringable is disabled with 10 dependents
+llvm-hs is disabled with 12 dependents
+th-data-compat is disabled with 12 dependents
+amazonka-core is disabled with 96 dependents
+gogol-core is disabled with 96 dependents
+```
+
+## Adding new curators
+
+1. Add public ssh key to `~/.ssh/authorized_keys` on build server
+2. Add to commercialhaskell/stackage project.
+
+## Dealing with a new GHC major release
+
+As mentioned in the [GHC upgrade note], the major impact of a new GHC release
+is on the packages that are causing upper bounds to be put in place. In order
+to minimise out-of-date breakage and allow maintainers to have a solid chance
+of getting their packages into the newest LTS, we try to do the following:
+
+Make an early announcement (in the form of a blog post, typically) of the new
+GHC release on the nightly build and the planned deadline for the new LTS release.
+Make it clear, that in the time coming up to this, we hope package maintainers
+will upgrade their packages to allow for the new GHC release.
+
+We prefer to prune packages causing upper bounds constraints **after** the LTS
+release to allow the maximum amount of packages to get into the newest LTS.
+
+After the first LTS release, the package pruning process may begin in the
+nightly build in order to move forward with getting the latest versions of
+packages compatible with the new GHC release.
+
+[GHC upgrade note]: https://github.com/commercialhaskell/stackage/blob/master/MAINTAINERS.md#upgrading-to-a-new-ghc-version
+
+## New LTS major bump
+
+Every 3-6 months, we make a new major release of LTS. The procedure we follow for this is:
+
+1. Write a blog post on stackage.org announcing the intent to cut a major
+   release. Give an estimated date two weeks in the future from the publication
+   date of the post.
+2. Spread the blog post on social media and mailing lists as much as possible.
+3. Expect maintainers to send significant requests for added packages and
+   relaxed upper bounds. There will likely be some hard decisions to be made
+   regarding relaxing a bound versus keeping more packages. All of these changes
+   occur on master and affect nightly.
+4. Once the estimated date hits, push a new `ltsXX` and wait for the docker image build.
+5. Run the build procedure for the new LTS release.
+6. After the LTS build completes, more aggressively prune upper bounds from
+   `build-constraints.yaml`.
+7. Once both (5) and (6) are done, publish a new blog post on stackage.org
+   announcing the new LTS and Nightly, with links to the change pages on
+   stackage.org. Include a reminder that requests for packages to be added to LTS
+   may be made on commercialhaskell/lts-haskell.

DATA-FLOW.md

@@ -0,0 +1,129 @@
+# The Stackage data flow
+
+The Stackage project is really built on top of a number of different
+subcomponents. This page covers how they fit together. The Stackage data flow
+diagram gives a good bird's-eye view:
+
+![Stackage data flow diagram](https://cloud.githubusercontent.com/assets/49415/14490986/cad5274e-017e-11e6-85cc-a4d815175c61.png)
+
+## Inputs
+
+There are three inputs into the data flow:
+
+* [Hackage](http://hackage.haskell.org/) is the upstream repository of all
+  available open source Haskell packages that are part of our ecosystem.
+  Hackage provides both cabal file metadata (via the 00-index.tar file) and
+  tarballs of the individual packages.
+
+* [build-constraints.yaml](https://github.com/commercialhaskell/stackage/blob/master/build-constraints.yaml)
+  is the primary Stackage input file. This is where package maintainers can add
+  packages to the Stackage package set. This also defines upper bounds, skipped
+  tests, and a few other pieces of metadata.
+
+* [stackage-content](https://github.com/fpco/stackage-content) is a Github
+  repository containing static file content served from stackage.org
+
+## Travis
+
+For [various
+reasons](https://tech.fpcomplete.com/blog/2015/05/distributing-packages-without-sysadmin),
+we leverage Travis CI for running some processes. In particular:
+
+* [all-cabal-files](https://github.com/commercialhaskell/all-cabal-files/blob/hackage/.travis.yml)
+  clones all cabal files from Hackage's 00-index.tar file into a Git repository
+  without any modification
+
+* [all-cabal-hashes](https://github.com/commercialhaskell/all-cabal-hashes/blob/hackage/.travis.yml)
+  is mostly the same, but also includes cryptographic hashes of the package
+  tarballs for more secure download (as leveraged by
+  [Stack](http://haskellstack.com). It is powered by [all-cabal-hashes-tool](https://github.com/commercialhaskell/all-cabal-hashes-tool)
+
+* [all-cabal-packages](https://github.com/commercialhaskell/all-cabal-packages)
+  uses [hackage-mirror](http://github.com/fpco/hackage-mirror) to populate the
+  hackage.fpcomplete.com mirror of Hackage, which provides S3-backed high
+  availability hosting of all package tarballs
+
+* [all-cabal-metadata](https://github.com/commercialhaskell/all-cabal-metadata)
+  uses
+  [all-cabal-metadata-tool](https://github.com/commercialhaskell/all-cabal-metadata-tool)
+  to query extra metadata from Hackage about packages and put them into YAML
+  files. As we'll see later, this avoids the need to make a lot of costly calls
+  to Hackage APIs
+
+Travis does not currently provide a means of running jobs on a regular basis.
+Therefore, we have a simple cron job on the Stackage build server that triggers
+each of the above builds every 30 minutes.
+
+## stackage-curator
+
+The heart of running Stackage builds is the
+[stackage-curator](https://github.com/fpco/stackage-curator) tool. We run this
+on a daily basis on the Stackage build server for Stackage Nightly, and on a
+weekly basis for LTS Haskell. The build process is [highly
+automated](https://github.com/commercialhaskell/stackage/blob/master/automated/build.sh) and
+leverages Docker quite a bit.
+
+stackage-curator needs to know about the most recent versions of all packages,
+their tarball contents, and some metadata, all of which it gets from the
+Travis-generated sources mentioned in the previous section. In addition, it
+needs to know about build constraints, which can come from one of two places:
+
+* When doing an LTS Haskell minor version bump (e.g., building lts-5.13), it
+  grabs the previous version (e.g., lts-5.12) and converts the previous package
+  set into constraints. For example, if lts-5.12 contains the package foo-5.6.7,
+  this will be converted into the constraint `foo >= 5.6.7 && < 5.7`.
+* When doing a Stackage Nightly build or LTS Haskell major version bump (e.g.,
+  building lts-6.0), it grabs the latest version of the build-constraints.yaml
+  file.
+
+By combining these constraints with the current package data, stackage-curator
+can generate a build plan and check it. (As an aside, this build plan
+generation and checking also occurs every time you make a pull request to the
+stackage repo.) If there are version bounds problems, one of the [Stackage
+curators](https://github.com/commercialhaskell/stackage/blob/master/CURATORS.md) will open
+up a Github issue and will add upper bounds, temporarily block a package, or
+some other corrective action.
+
+Once a valid build plan is found, stackage-curator will build all packages,
+build docs, and run test suites. Assuming that all succeeds, it generates some
+artifacts:
+
+* Uploads the build plan as a YAML file to either
+  [stackage-nightly](https://github.com/fpco/stackage-nightly) or
+  [lts-haskell](https://github.com/fpco/lts-haskell)
+* Uploads the generated Haddock docs and a package index (containing all used
+  .cabal files) to haddock.stackage.org.
+
+## stackage-server-cron
+
+On the Stackage build server, we run the [stackage-server-cron
+executable](https://github.com/fpco/stackage-server/blob/master/app/stackage-server-cron.hs)
+regularly, which generates:
+
+* A [SQLite
+  database](https://github.com/fpco/stackage-server/blob/master/Stackage/Database.hs)
+  containing information on snapshots, the packages they contain, Hackage
+  metadata about packages, and a bit more. This database is uploaded to S3.
+* A Hoogle database for each snapshot, which is also uploaded to S3
+
+## stackage-server
+
+The [software running stackage.org](https://github.com/fpco/stackage-server) is
+a relatively simple Yesod web application. It pulls data from the
+stackage-content repo, the SQLite database, the Hoogle databases, and the build
+plans for Stackage Nightly and LTS Haskell. It doesn't generate anything
+important of its own except for a user interface.
+
+## Stack
+
+[Stack](http://haskellstack.com) takes advantage of many of the pieces listed above as well:
+
+* It by default uses the all-cabal-hashes repo for getting package metadata,
+  and downloads package contents from the hackage.fpcomplete.com mirror (using
+  the hashes in the repo for verification)
+* There are some metadata files in stackage-content which contain information
+  on, for example, where to download GHC tarballs from to make `stack setup`
+  work
+* Stack downloads the raw build plans for Stackage Nightly and LTS Haskell from
+  the Github repo and uses them when deciding which packages to build for a
+  given stack.yaml file

Dockerfile

@@ -0,0 +1,19 @@
+FROM fpco/pid1:22.04
+
+ENV HOME /home/stackage
+ENV LANG en_US.UTF-8
+
+ADD docker/01-build-server.sh /tmp/01-build-server.sh
+RUN /tmp/01-build-server.sh && rm /tmp/01-build-server.sh
+
+ADD docker/02-apt-get-install.sh /tmp/02-apt-get-install.sh
+RUN /tmp/02-apt-get-install.sh && rm /tmp/02-apt-get-install.sh
+
+ADD docker/03-custom-install.sh /tmp/03-custom-install.sh
+RUN /tmp/03-custom-install.sh && rm /tmp/03-custom-install.sh
+
+ADD docker/04-cleanup.sh /tmp/04-cleanup.sh
+RUN /tmp/04-cleanup.sh && rm /tmp/04-cleanup.sh
+
+# Include file path
+ENV CPATH /usr/lib/jvm/java-8-openjdk-amd64/include:/usr/lib/jvm/java-8-openjdk-amd64/include/linux:/usr/lib/llvm-3.7/include

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 FP Complete, http://www.fpcomplete.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

MAINTAINERS.md

@@ -0,0 +1,268 @@
+This project is built around the concept of maintainers taking responsibility for making their packages work with the rest of the stable ecosystem, usually meaning the newest version of all dependencies. This is a social contract, and is not reflected in the codebase in any way.
+
+The idea behind Stackage is that, if all packages work with the newest versions of dependencies, we avoid dependency hell. Specifically, we aim for:
+
+* All packages are buildable and testable from Hackage. We recommend [the Stack Travis script](https://docs.haskellstack.org/en/stable/travis_ci/), which ensures a package is not accidentally incomplete.
+* All packages are compatible with the newest versions of all dependencies (You can find restrictive upper bounds by visiting http://packdeps.haskellers.com/feed?needle=PACKAGENAME).
+* All packages in a snapshot are compatible with the versions of libraries that ship with the GHC used in the snapshot ([more information on lenient lower bounds](https://tech.fpcomplete.com/blog/2014/05/lenient-lower-bounds)).
+
+Packages in Stackage are not patched: all package changes occur upstream in Hackage.
+
+## Adding a package
+
+Anyone can add any package to Stackage but you should talk to the upstream maintainer before putting another person's package under your own name.
+It's generally better the actual package maintainer is also the Stackage maintainer, if that is not the case you should write the package maintainer a note first, eg by opening an upstream issue or sending them an email.
+
+To add your package you can edit [`build-constraints.yaml`](https://github.com/fpco/stackage/blob/master/build-constraints.yaml) directly on github or fork the project. There's a section called `packages` where you would add yourself and your packages:
+
+    "My Name <myemail@example.com> @mygithubuser":
+        - package1
+        - package2
+        - package3
+
+(If you are adding yourself for the first time, you can yourself anywhere under the `packages:` section, it does not have to be at the end: this actually helps to avoid merge conflicts between new contributions.)
+
+Any dependencies of your packages that are not already part of
+stackage also need to be added explicitly (When this happens you will
+see `not present` errors in the CI log). As mentioned above: If you
+don't maintain this package yourself it is preferable that the actual
+maintainer is also the stackage maintainer, but you are allowed to add
+it under your own name.
+
+If your package depends on a C library, please add it to `docker/02-apt-get-install.sh` or `docker/03-custom-install.sh`.
+
+After doing that, commit with a message like "add foo-bar" and send a pull request.
+
+The continuous integration job will do some checks to see if your package's dependencies are up-to-date.
+
+The CI job notably doesn't compile packages, run tests, build documentation, or find missing C libraries.
+If you want to be proactive or if CI fails, you can make sure that your package builds against the latest nightly.
+See the [verify-package](https://github.com/commercialhaskell/stackage/blob/master/verify-package) script in this repository.
+
+This approach works well, but has two limitations you should be aware
+of:
+
+* It won't notify you of restrictive upper bounds in your package if
+  Stackage has the same upper bounds. For that reason, we recommend
+  using [Packdeps](http://packdeps.haskellers.com/) (see "Following
+  dependency upgrades" below). You can also run `cabal outdated`.
+* If the latest Stackage Nightly is missing some of the latest
+  packages, your build above may succeed whereas the Travis job may
+  fail. Again: Packdeps will help you detect this situation.
+
+## Github and Notifications
+
+Stackage uses Github notifications to reduce overhead of contacting individual
+package maintainers through various channels. As a package maintainer, you will
+receive notifications for a number of reasons, package build failures of
+different sorts, blockages and bounds issues, etc.
+
+Please note, Github does some throttling on the number people that can be
+notified within one issue. This means that on issues created with a large
+number of packages affected, maintainers may not receive a notification. This
+is not ideal, but Stackage is largely a manual process and done on a best
+effort basis.
+
+## Uploading a new package version
+
+When a new version of a package in Stackage is uploaded to Hackage, we automatically try to include it in Stackage. That can result in a number of possible failures. If there is a failure we temporarily introduce an upper bound, and open a GitHub issue ticket to resolve the issue.
+
+If the new version doesn't compile then the package author should upload a fixed version.
+
+If a package's test suite is failing, the first job is to investigate why. If this is due to a bad interaction with versions of other packages in Stackage, then it is the responsibility of the maintainer to fix the test suite. In some situations, it is acceptable to not run the test suite.
+
+## Moving or retiring maintainership of a Stackage package
+
+If you no longer wish to be listed as maintainer of a package in Stackage,
+you can open a pull request to move it to a new maintainer or
+to either the "Grandfathered dependencies" or the "Abandoned packages" sections in `build-constraints.yaml`.
+Unless there is a compelling technical reason to remove the package,
+this is better than just dropping it from the distribution.
+
+## Following dependency upgrades
+
+If a new version of a dependency is released your package may fail to
+build or tests may fail. In most cases we will add an upper bound on
+the dependency so that your package remains in nightly. We'll also
+create a github issue pinging you with the bounds issues or give build
+logs showing failures. It's then up to you to modify your package.
+
+We recommend that you also follow the dependencies of your packages on
+[Packdeps](http://packdeps.haskellers.com/) (typically using the RSS
+feeds) as well as that often gives you notice ahead of stackage
+issues. There are cases where we will not notice a new release of a
+package because of other upper bounds that are in place.
+
+If a package is not updated in time, it may be temporarily removed
+from Stackage by the curator team. We strive to notify you when this
+happens. If it does you are always welcome to file another pull
+request to add it back.
+
+We typically use fairly long windows before disabling packages, but it
+is decided on a case-by-case basis.
+
+* If restrictive version bounds are the only problem, we will give
+  maintainers at least a week to respond.
+* If there are real breaking changes, the curator team will retain
+  more discretion on how long a window to give before dropping
+  packages.
+* We typically drop upper bounds and disable conflicting packages in Nightly after we create
+  a new Long Term Support (LTS) major version.
+* There are rare cases where an upper bound or build failure are hard
+  to deal with so then we may disable
+
+**NOTE** Previously we had stricter time limits, but we decided to
+remove that: Anyone is free to add a package to Stackage regardless of
+responsiveness guarantees. However, as stated above, we may elect to
+temporarily remove a package if it is not updated in a timely manner.
+
+## Understanding stackage issues
+
+### Bounds issues
+
+These are the most common.
+
+Using https://github.com/commercialhaskell/stackage/issues/6217 as an example.
+
+Our convention is to title a PR after the package that is being held
+back from the nightly snapshot (here: aeson).
+
+The issue body is templated and looks like this:
+
+```
+aeson-2.0.0.0 ([changelog](http://hackage.haskell.org/package/aeson-2.0.0.0/changelog)) (MAINTAINER) is out of bounds for:
+- [ ] Agda-2.6.2 (>=1.1.2.0 && < 1.6). MAINTAINER. Used by: library
+- [ ] HsYAML-aeson-0.2.0.0 (>=1.4.0.0 && < 1.6). MAINTAINER. Used by: library
+- [ ] IPv6Addr-2.0.2 (>=0.8.0.2 && < 1.6). MAINTAINER. Used by: library
+[...]
+```
+
+This (usually - see "Other issues") means that there was a new release of the package in the
+header (aeson). This is expected and the aeson maintainer is
+not expected to act. They are pinged to notify them that the
+latest version of their package will not be part of the nightly
+snapshots until the issue closed.
+
+The list of packages with checkboxes denote the packages that prevent
+us from using the latest version of aeson, the first version number is
+the current version of that package in nightly (e.g. Agda 2.6.2). The
+constraint in parenthesis `(>=1.1.2.0 && < 1.6)` is Agda's current
+bound on `aeson`. To check this box we expect there to be an update
+of Agda to support aeson 2.0.0.0.
+
+Once all boxes are checked we should be able to close the issue and
+upgrade aeson.
+
+### Other issues
+
+Other common types of issues are
+* Packages with failing tests, haddocks, or benchmarks (note that we only *compile* benchmarks)
+  + Maintainers may choose to update these parts of their package, or
+    to exclude them from the stackage build (e.g. adding a package to
+    `skipped-tests`)
+* New releases of packages that depend on packages that are not a part
+  of stackage. This is denoted as `not present`
+  + Maintainers are encouraged to ask the maintainer of these packages
+    to join stackage, or to be the stackage contact person themselves.
+* A new release of a package with stricter upper bounds than its previous version
+  + This will look like a normal bounds issue, and should be treated
+    the same way by maintainers. Curators usually resolve this by
+    adding an upper bound to that package instead of its dependency.
+
+## Delays
+
+Maintainers are humans, humans get sick/have babies/go on
+holiday. Sometimes a dependency upgrade is extra time consuming.
+
+Consider finding a co-maintainer with access to SCM and Hackage to
+help you out.
+
+We appreciate if you notify us of any expected delays in the Github
+issues, some kind soul might decide to help out.
+
+## Upgrading to a new GHC version
+
+The Stackage curation team tries to move Stackage Nightly to new
+versions of GHC quickly as they become available, while keeping LTS
+Haskell on a regular release schedule. For package maintainers, the
+most important impacts of a new GHC release are:
+
+* We will typically do a sweep through the Stackage upper bounds and
+  remove blocking packages. We prefer to do it this way rather than
+  ask other maintainers to backport fixes.
+    * We will definitely do this at a GHC major version release, and
+      may do so at a minor version release
+* Packages that are incompatible with the newest GHC version will be
+  temporarily disabled
+
+If your package ends up being temporarily disabled from Stackage
+Nightly, please simply send a pull request to add it back once it and
+its dependencies are compatible with the newest GHC version.
+
+Note that it is _not_ a goal of LTS Haskell to track the latest
+version of GHC. If you want the latest and greatest, Stackage Nightly
+is your best bet. In particular, LTS Haskell will often&mdash;but not
+always&mdash;avoid upgrading to the first point release of GHC
+releases (e.g., 8.x.1) to allow further testing and to get the
+benefits of the first bugfix release (e.g., 8.x.2).
+
+## Adding a package to an LTS snapshot
+
+The steps above affect the Stackage Nightly builds, but do not directly affect
+LTS Haskell builds. When we build a new LTS Haskell major version (anything
+ending in `.0`), the package set is taken from Stackage Nightly. Therefore, by
+following the above steps, you can get your package into the next major LTS
+Haskell release.
+
+If you would like to get your package added to the current LTS Haskell
+major release, please do the following in addition to the steps for Nightly described earlier:
+
+* Check that your package can be built with the current LTS version (e.g. `stack build --test --bench --haddock --resolver lts`)
+* Open up a new issue on the [lts-haskell repo](https://github.com/fpco/lts-haskell/issues/new)
+  * Provide a list of packages you would like added
+    * If relevant, mention any upper bounds that are needed on those packages
+* Be patient! The LTS releases are less frequent than Nightly. The
+  Stackage curators will try to get to your issue as soon as possible,
+  but it may take some time.
+
+## LTS package guarantees and exceptions
+
+In general, we try to stick to some rules when it comes to the
+packages included in LTS minor bumps. In particular:
+
+* If a package exists in LTS-X.Y, it should also exist in LTS-X.(Y+1)
+* We should not include a major version bump of a package between
+  LTS-X.Y and LTS-X.(Y+1)
+
+However, there are some cases where exceptions may be made, based
+purely on Stackage Curator discretion. The most common examples are:
+
+*   If a package does not follow the PVP in its version number policy,
+    applying the standard version bump rules would not necessarily
+    makes sense. As an example, suppose package `foo` decides to
+    follow SemVer instead of the PVP. By our standard rules of version
+    bumps, a change from `foo-1.2.0` to `foo-1.3.0` would be
+    considered a major version bump, and disallowed in an LTS minor
+    version bump. However, if a package is following SemVer, this
+    would not be a breaking change, and curators may elect to include
+    it. Note though that curators and their tooling will not know your
+    package is following SemVer, so in this case you would have to open
+    an issue on the [lts-haskell repo](https://github.com/fpco/lts-haskell/issues/new).
+
+*   If a package has overly restrictive version bounds on a
+    dependency, in particular constraining a minor version
+    unnecessarily, we may drop that package instead of artificially
+    holding back the dependency. As an example: suppose `LTS-20.1`
+    includes `foo-1.2.0` and `bar-1`. `bar-1` has a dependency `foo >=
+    1.2.0 && < 1.2.1`, which is overly constrained on the minor
+    version number according to the PVP. Then `foo-1.2.1` is
+    released. The Stackage Curator team would have two choices:
+
+    * Reject `foo-1.2.1` from `LTS-20.2`, since that is what `bar-1`
+      requires.
+    * Drop `bar-1` from `LTS-20.2`, and allow `foo-1.2.1`.
+
+    Decisions will need to be taken on a case-by-case basis, and may
+    depend on such issues as whether an important bugfix or security
+    update in included. The curator team may also try to notify the
+    author of `bar` to try and get a patched version released.

README.md

@@ -0,0 +1,142 @@
+stackage
+========
+[![check](https://github.com/commercialhaskell/stackage/actions/workflows/check.yml/badge.svg)](https://github.com/commercialhaskell/stackage/actions/workflows/check.yml)
+
+Stable sets of Haskell Packages from Hackage
+
+_This repository is for package authors and maintainers to get their packages into Stackage._
+
+If you simply want to use Stackage as an end user, please follow the instructions on [https://www.stackage.org/](https://www.stackage.org).
+
+We strongly recommend using the Haskell [stack](https://github.com/commercialhaskell/stack) tool for doing builds, which
+includes built-in Stackage support.
+
+Add your package
+----------------
+
+We welcome all packages, provided:
+
+* The package author/maintainer agrees to the [maintainers agreement](https://github.com/commercialhaskell/stackage/blob/master/MAINTAINERS.md).
+* The package is buildable and testable from Hackage. We recommend [the Stack Travis script](https://docs.haskellstack.org/en/stable/travis_ci/), which ensures a package is not accidentally incomplete.
+* The package is compatible with the newest versions of all dependencies (You can find restrictive upper bounds by visiting http://packdeps.haskellers.com/feed?needle=PACKAGENAME).
+* The package is compatible with the versions of libraries that ship with GHC ([more information on lenient lower bounds](https://tech.fpcomplete.com/blog/2014/05/lenient-lower-bounds)).
+
+Full details on how to add and test a package can be found in the [maintainers agreement](https://github.com/commercialhaskell/stackage/blob/master/MAINTAINERS.md#adding-a-package).
+
+__NOTE__: There is an approximate 30 minute delay between a package uploading
+to Hackage and being available to the Github workflow action to check upper
+bounds. If a pull request is marked as failed due to using an older version,
+please close and reopen the PR to retrigger a Travis build.
+
+Other repos
+-----------
+
+The Stackage project consists of multiple repositories. This repository
+contains the metadata on packages to be included in future builds and some
+project information. In addition, we have the following repositories:
+
+* [stackage-server](https://github.com/fpco/stackage-server) [![Base image](https://github.com/fpco/stackage-server/actions/workflows/base.yml/badge.svg)](https://github.com/fpco/stackage-server/actions/workflows/base.yml)
+* [curator](https://github.com/commercialhaskell/curator) ![Build Status](https://github.com/commercialhaskell/curator/workflows/Runtime%20image/badge.svg)
+* [lts-haskell](https://github.com/commercialhaskell/lts-haskell)
+* [stackage-snapshots](https://github.com/commercialhaskell/stackage-snapshots/)
+
+Curious how it all fits together? See the [Stackage data
+flow](https://github.com/commercialhaskell/stackage/blob/master/DATA-FLOW.md).
+
+Build the package set
+---------------------
+
+Generally only the stackage build server run by the stackage curator
+team and people interested in incorporating stackage snapshots into an
+OS distribution need to build the entire package set. If you're
+interested in trying this yourself, please check out
+[the curator guide](https://github.com/commercialhaskell/stackage/blob/master/CURATORS.md),
+though be aware that this is not a recommended practice and there
+likely will be problems you will need to debug yourself.
+
+## Processing
+
+The following describes at a high level the series of steps for processing
+
+### Nightlies
+
+1. Get list of core packages
+2. Get build constraints from list of maintained packages
+3. Load up package index
+4. Calculate build plan using newest versions of packages
+5. Write out a YAML file with complete build plan
+6. Verify that the build plan can be compiled
+7. Perform the build
+
+### LTS
+
+1. Load up most recent build plan
+2. Convert build plan into constraints for next build
+3. Continue from step (3) above
+
+Frequently Asked Questions
+--------------------------
+
+__Why is Stackage LTS still on an older version of GHC?__
+
+Typically it takes some months from a new major ghc release before
+the Haskell ecosystem supports it fully enough that we can push it
+to a new stable Stackage major version release. There can also be
+ghc regressions that hold up a LTS major release.
+
+The lag for minor ghc releases should be less
+but it still requires extra work and there is usually some delay - this also
+allows for some community testing before updating LTS.
+
+__Why does Stackage have an older version of a package than Hackage?__
+
+There are a number of answers to this question:
+
+* Simplest reason: how old of a Stackage snapshot are you using? Once a
+  snapshot is created, it's frozen for all time. So if you use
+  nightly-2016-01-01, by the time you get to 2018, it will be pretty dated.
+* If you're using an LTS snapshot: we lock down major versions when
+  first creating an LTS run, so subsequent minor versions will not get
+  new versions necessary. For example, if LTS 6.0 has `foo` version
+  1.2.3, and the author immediately thereafter releases a version
+  1.3.0 and never releases another 1.2.\* version, you'll never get
+  another update in the LTS 6 line
+* Sometimes we have upper bounds in place because other packages have
+  problems with newer versions of dependencies. Open up the
+  [build-constraints file](https://github.com/commercialhaskell/stackage/blob/master/build-constraints.yaml)
+  and search for "Stackage upper bounds"
+* Wired-in packages - those that ship with GHC and cannot be upgraded,
+  and packages depending on them - are fixed to GHC versions. Common
+  examples of this are containers and transformers. There's a lot more
+  information on this in
+  [an FP Complete blog post](https://tech.fpcomplete.com/blog/2014/05/lenient-lower-bounds)
+
+__How long do you maintain an LTS build?__
+
+We only guarantee that we will maintain a single LTS major version at
+a time, and that it will be maintained for at least three months. This
+is the
+[originally proposed support window](https://tech.fpcomplete.com/blog/2014/12/backporting-bug-fixes),
+and hasn't changed since then.
+
+That said, we do maintain the capability to keep multiple LTS runs
+operational in parallel, and with LTS 6 and 7 in fact did so. We
+aren't changing our guarantees yet on longevity of a release, but are
+trying to push out the bounds a bit farther.
+
+__What time are Stackage snapshots published?__
+
+Stackage Nightly and LTS are not released at a fixed time of day, they get
+pushed to stackage.org (and the metadata to the stackage-snapshots github repo)
+when their builds finish on the Stackage build server and
+the latest built haddocks have been synced over. This time varies
+greatly depending on build times for package updates, bounds breakage,
+problems with new packages being added and other build issues, etc. There are
+days when a release does not happen. LTS releases tend to happen over the
+weekend or early in the week.
+
+__Where to get help regarding uploading packages?__
+
+Please ask on the #stackage channel on the
+[Haskell Foundation Slack](https://join.slack.com/t/haskell-foundation/shared_invite/zt-mjh76fw0-CEjg2NbyVE8rVQDvR~0F4A)
+or open an issue or comment on the PR which uploads the package.

automated/.gitignore

@@ -0,0 +1,2 @@
+/work/
+/*-build.log

automated/build.sh

@@ -0,0 +1,166 @@
+#!/usr/bin/env bash
+
+set -eu +x -o pipefail
+
+ROOT=$(cd $(dirname $0) ; pwd)
+TARGET=$1
+
+source work/aws.sh
+
+# For nightly-YYYY-MM-DD, tag should be nightly
+# For lts-X.Y, tag should be ltsX
+SHORTNAME=$(echo $TARGET | cut -d- -f 1)
+if [ $SHORTNAME = "lts" ]
+then
+    TAG=$(echo $TARGET | sed 's@^lts-\([0-9]*\)\.[0-9]*@lts\1@')
+    WORKDIR=$ROOT/work/$(echo $TARGET | sed 's@^lts-\([0-9]*\)\.[0-9]*@lts-\1@')
+else
+    TAG=$SHORTNAME
+    WORKDIR=$ROOT/work/$TAG
+fi
+
+#IMAGE=commercialhaskell/stackage:$TAG
+IMAGE=ghcr.io/commercialhaskell/stackage/build:$TAG
+
+PANTRY_DIR=$ROOT/work/stack/pantry
+STACK_DIR=$ROOT/work/stack
+DOT_STACKAGE_DIR=$ROOT/work/dot-stackage
+# ssh key is used for committing snapshots (and their constraints) to Github
+SSH_DIR=$ROOT/work/ssh
+USERID=$(id -u)
+
+mkdir -p \
+	"$PANTRY_DIR" \
+	"$STACK_DIR" \
+	"$DOT_STACKAGE_DIR" \
+	"$WORKDIR" \
+	"$SSH_DIR"
+
+GITCONFIG=$ROOT/work/gitconfig
+cat >$GITCONFIG <<EOF
+[user]
+	email = michael+stackage-build@fpcomplete.com
+	name = Stackage Build host
+EOF
+
+HACKAGE_CREDS=$ROOT/work/hackage-creds
+
+function require_400_file {
+    if [ ! -f "$1" ]
+    then
+        echo File not found: "$1"
+        exit 1
+    fi
+
+    chmod 400 "$1"
+}
+
+require_400_file "$SSH_DIR/id_rsa"
+require_400_file "$HACKAGE_CREDS"
+
+mkdir -p $ROOT/work/bin
+BINDIR=$(cd $ROOT/work/bin ; pwd)
+(
+cd $BINDIR
+rm -f curator stack *.bz2
+
+curl -L "https://github.com/commercialhaskell/curator/releases/download/commit-558215d639561301a0069dc749896ad3e71b5c24/curator.bz2" | bunzip2 > curator
+chmod +x curator
+echo -n "curator version: "
+docker run --rm -v $(pwd)/curator:/exe $IMAGE /exe --version
+
+STACK_VERSION=2.13.1
+# rc url
+#curl -L https://github.com/commercialhaskell/stack/releases/download/rc%2Fv${STACK_VERSION}/stack-${STACK_VERSION}-linux-x86_64-bin > stack
+curl -L https://github.com/commercialhaskell/stack/releases/download/v${STACK_VERSION}/stack-${STACK_VERSION}-linux-x86_64-bin > stack
+chmod +x stack
+echo -n "stack version: "
+docker run --rm -v $(pwd)/stack:/exe $IMAGE /exe --version
+)
+
+# We share pantry directory between snapshots while the other content in .stack
+# is stored separately (because e.g. Ubuntu releases between LTS and nightly
+# could differ). Also the order of binds is important.
+ARGS_COMMON="--rm -v $WORKDIR:$HOME/work -w $HOME/work -v $BINDIR/curator:/usr/bin/curator:ro -v /etc/passwd:/etc/passwd:ro -v /etc/group:/etc/group:ro -v $BINDIR/stack:/usr/bin/stack:ro -v $STACK_DIR:$HOME/.stack -v $PANTRY_DIR:$HOME/.stack/pantry"
+ARGS_PREBUILD="$ARGS_COMMON -u $USERID -e HOME=$HOME -v $DOT_STACKAGE_DIR:$HOME/.stackage"
+ARGS_BUILD="$ARGS_COMMON"
+# instance-data is an undocumented feature of S3 used by amazonka,
+# see https://github.com/brendanhay/amazonka/issues/271
+ARGS_UPLOAD="$ARGS_COMMON -u $USERID -e HOME=$HOME -v $HACKAGE_CREDS:/hackage-creds:ro -v $DOT_STACKAGE_DIR:$HOME/.stackage -v $SSH_DIR:$HOME/.ssh:ro -v $GITCONFIG:$HOME/.gitconfig:ro -e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID -e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY -v $DOT_STACKAGE_DIR:/dot-stackage"
+
+# Make sure we actually need this snapshot. We only check this for LTS releases
+# since, for nightlies, we'd like to run builds even if they are unnecessary to
+# get early warning information of upcoming failures. (See the duplicate check
+# below for why this is safe.)
+if [ $SHORTNAME = "lts" ]
+then
+  docker run $ARGS_UPLOAD $IMAGE /bin/bash -c "exec curator check-target-available --target $TARGET"
+fi
+
+
+# Determine the new build plan unless NOPLAN is set
+#
+# * Update the package index (unless LTS)
+# * Create a new plan
+if [ "${NOPLAN:-}x" = "1x" ]
+then
+    docker run $ARGS_PREBUILD $IMAGE /bin/bash -c "curator snapshot-incomplete --target $TARGET && curator snapshot"
+elif [ "${NOPLAN:-}x" = "2x" ]
+then
+    docker run $ARGS_PREBUILD $IMAGE curator snapshot
+elif [ $SHORTNAME = "lts" ]
+then
+    docker run $ARGS_PREBUILD $IMAGE /bin/bash -c "curator constraints --target $TARGET && curator snapshot-incomplete --target $TARGET && curator snapshot"
+else
+    docker run $ARGS_PREBUILD $IMAGE /bin/bash -c "curator update && curator constraints --target $TARGET && curator snapshot-incomplete --target $TARGET && curator snapshot"
+fi
+
+
+# Do the rest of the pre-build actions:
+#
+# * Check that the snapshot is valid
+# * Fetch and unpack all needed tarballs (the build step does not have write access to the tarball directory)
+docker run $ARGS_PREBUILD $IMAGE /bin/bash -c 'GHCVER=$(sed -n "s/^ghc-version: \(.*\)/\1/p" constraints.yaml) && stack setup ghc-$GHCVER --verbosity=error && stack exec --resolver=ghc-$GHCVER curator check-snapshot && curator unpack'
+
+case $SHORTNAME in
+    lts) JOBS=16 ;;
+    nightly) JOBS=16 ;;
+esac
+
+if [ -e "$SHORTNAME-build.log" ]
+then
+    cp -p $SHORTNAME-build.log $SHORTNAME-build.log-previous
+fi
+
+# Now do the actual build. We need to first set the owner of the home directory
+# correctly, so we run the command as root, change owner, and then use sudo to
+# switch back to the current user
+docker run $ARGS_BUILD $IMAGE nice -n 15 /bin/bash -c "chown $USER $HOME && exec sudo -E -u $USER env \"HOME=$HOME\" \"PATH=\$PATH\" curator build --jobs $JOBS" 2>&1 | tee "$SHORTNAME-build.log"
+
+# Make sure we actually need this snapshot. We used to perform this check
+# exclusively before building. Now we perform it after as well for the case of
+# nightly, where we don't perform this check beforehand. This is also slightly
+# safer, in case someone else already uploaded a specific snapshot while we
+# were building.
+docker run $ARGS_UPLOAD $IMAGE /bin/bash -c "exec curator check-target-available --target $TARGET"
+
+# Successful build, so we need to:
+#
+# * Upload the docs to S3
+# * Upload the new snapshot .yaml file to the appropriate Github repo, also upload its constraints
+docker run $ARGS_UPLOAD $IMAGE /bin/bash -c "curator upload-docs --target $TARGET && curator upload-github --target $TARGET"
+
+# fixed in https://github.com/commercialhaskell/curator/pull/24
+docker run $ARGS_UPLOAD $IMAGE /bin/bash -c "exec curator hackage-distro --target $TARGET"
+
+# Build and push docker image fpco/stack-build & fpco/stack-build-small for current release
+
+if [ $SHORTNAME = "lts" ]
+then
+    $ROOT/dockerfiles/build.sh $TARGET
+    $ROOT/dockerfiles/build.sh --push $TARGET
+    $ROOT/dockerfiles/build.sh --push --small $TARGET
+fi
+
+echo -n "Completed at "
+date

automated/dockerfiles/README.md

@@ -0,0 +1,33 @@
+dockerfiles/stack-build
+=======================
+
+Build [fpco/stack-build](https://hub.docker.com/r/fpco/stack-build/) Docker
+images. This script and its Dockerfiles are used for building images for LTS >=
+8.0.
+
+Usage
+-----
+
+    ./build.sh [--push] [--dry-run] [--small] lts-X.Y"
+
+Options
+-------
+
+`--help`: show this help
+
+`--push`: push the image after building/tagging it
+
+`--dry-run`: print the important commands that will be run, but don't actually
+    run them
+
+`--small`: build the small variant of the image
+
+Argument
+---------
+
+The image for the selected LTS version will be built.
+
+This searches for a Dockerfile for the selected snapshot in
+`lts-X.Y/Dockerfile`, and if one isn't found reuses the same image as built the
+most recent `lts-X.Y/Dockerfile` found for earlier minor versions of the same
+major version.

automated/dockerfiles/build.sh

@@ -0,0 +1,177 @@
+#!/usr/bin/env bash
+
+set -eu
+cd "$(dirname "$0")"
+
+#
+# Constants and defaults
+#
+
+DOCKER_REPO=fpco/stack-build
+PUSH=false
+DRY=false
+VARIANT=build
+
+#
+# Functions
+#
+
+# Print usage information and exit with failure status. First argument is an
+# error message.
+usage() {
+    echo "$0: $1" >&2
+    echo
+    echo "Usage: $0 [--push] [--dry-run] [--small] lts-X.Y]"
+    echo "See README.md for more information."
+    echo
+    exit 1
+}
+
+# Print a command, and if --dry-run disabled also run it
+dry() {
+    echo ">>> $*"
+    [[ $DRY = true ]] || "$@"
+}
+
+# Push an image if --push is enabled (otherwise do nothing)
+push() {
+    [[ $PUSH = false ]] || dry docker push "$1"
+}
+
+# Tag an image, and then push it if --push is enabled
+tagpush() {
+    dry docker tag "$1" "$2"
+    push "$2"
+}
+
+#
+# Parse command-line
+#
+
+LTS_SLUG_ARG=
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --push)
+            PUSH=true
+            shift
+            ;;
+        --dry-run)
+            DRY=true
+            shift
+            ;;
+        --small)
+            VARIANT=small
+            DOCKER_REPO=fpco/stack-build-small
+            shift
+            ;;
+        -*)
+            usage "Unknown option: $1"
+            ;;
+        *)
+            if [[ -n "$LTS_SLUG_ARG" ]]; then
+                usage "Cannot specify multiple snaphots: $1"
+            fi
+            LTS_SLUG_ARG="$1"
+            shift
+            ;;
+    esac
+done
+
+case "$LTS_SLUG_ARG" in
+    "")
+        usage "Missing argument: snapshot"
+        ;;
+    lts-*.*)
+        LTS_SLUG="$LTS_SLUG_ARG"
+        ;;
+    *)
+        echo "$0: Wrong snapshot format: $LTS_SLUG_ARG" >&2
+        exit 1
+        ;;
+esac
+
+#
+# Determine if lts slug is latest
+#
+
+SNAPSHOTS="$(mktemp "lts-snapshots.json.XXXXXX")"
+trap "rm -f \"$SNAPSHOTS\"" EXIT
+wget -qO- https://www.stackage.org/download/lts-snapshots.json >"$SNAPSHOTS"
+
+LTS_VERSION="${LTS_SLUG#lts-}"
+LTS_MAJOR="${LTS_VERSION%.*}"
+LTS_MINOR="${LTS_VERSION#*.}"
+
+#
+# Determine latest LTS version
+#
+
+if [[ ! -x "$HOME/.local/bin/jq" ]]; then
+    mkdir -p $HOME/.local/bin
+    if [[ "$(uname)" = "Darwin" ]]; then
+        curl -o $HOME/.local/bin/jq -L https://github.com/stedolan/jq/releases/download/jq-1.6/jq-osx-amd64
+    else
+        curl -o $HOME/.local/bin/jq -L https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64
+    fi
+    chmod +x $HOME/.local/bin/jq
+fi
+
+LATEST_LTS_SLUG=$($HOME/.local/bin/jq -r ".[\"lts\"]" $SNAPSHOTS)
+LATEST_LTS_VERSION="${LATEST_LTS_SLUG#lts-}"
+LATEST_LTS_MAJOR="${LATEST_LTS_VERSION%.*}"
+LATEST_LTS_MINOR="${LATEST_LTS_VERSION#*.}"
+
+#
+# Determine latest minor version of the selected major version
+#
+
+MAJOR_LATEST_LTS_SLUG=$(jq -r ".[\"lts-$LTS_MAJOR\"]" $SNAPSHOTS)
+MAJOR_LATEST_LTS_VERSION="${MAJOR_LATEST_LTS_SLUG#lts-}"
+MAJOR_LATEST_LTS_MAJOR="${MAJOR_LATEST_LTS_VERSION%.*}"
+MAJOR_LATEST_LTS_MINOR="${MAJOR_LATEST_LTS_VERSION#*.}"
+
+#
+# Find the Dockerfile for the selected snapshot
+#
+
+if [[ -s "$LTS_SLUG/Dockerfile" ]]; then
+
+    # If there is an exact match, build and push that image
+
+    sed "s/\\\$DOCKER_REPO/$(echo $DOCKER_REPO|sed 's/\//\\\//')/g" "$LTS_SLUG/Dockerfile" >"$LTS_SLUG/Dockerfile.sub"
+    dry docker build -t "$DOCKER_REPO:$LTS_SLUG" --build-arg "DOCKER_REPO=$DOCKER_REPO" --build-arg "LTS_SLUG=$LTS_SLUG" --build-arg "VARIANT=$VARIANT" -f "$LTS_SLUG/Dockerfile.sub" "$LTS_SLUG"
+    rm -f "$LTS_SLUG/Dockerfile.sub"
+    push "$DOCKER_REPO:$LTS_SLUG"
+else
+
+    # If no exact match, find a dockerfile for any earlier minor version of the
+    # selected major version, and just create a new tag from version's image with the selected
+    # minor version (assuming that nothing needs to change), and push it.
+
+    minor=$(( LTS_MINOR - 1 ))
+    while [[ ! -s "lts-$LTS_MAJOR.$minor/Dockerfile" && $minor -ge 0 ]]; do
+        minor=$(( minor - 1 ))
+    done
+    if [[ $minor -lt 0 ]]; then
+        echo "$0: Cannot find any Dockerfile for LTS major version" >&2
+        exit 1
+    fi
+    dry docker pull "$DOCKER_REPO:lts-$LTS_MAJOR.$minor" || true
+    tagpush "$DOCKER_REPO:lts-$LTS_MAJOR.$minor" "$DOCKER_REPO:$LTS_SLUG"
+fi
+
+#
+# Create and push additional tags
+#
+
+# If we select the latest minor version for the selected major version, then
+# also create and push an 'lts-X' tag.
+if [[ $LTS_MINOR -ge $MAJOR_LATEST_LTS_MINOR ]]; then
+    tagpush "$DOCKER_REPO:$LTS_SLUG" "$DOCKER_REPO:lts-$LTS_MAJOR"
+fi
+
+# If we selected the latest LTS snapshot, also create and push the 'lts' and 'latest' tags.
+if [[ "$LTS_MAJOR" = "$LATEST_LTS_MAJOR" ]] && [[ $LTS_MINOR -ge $LATEST_LTS_MINOR ]]; then
+    tagpush "$DOCKER_REPO:$LTS_SLUG" "$DOCKER_REPO:lts"
+    tagpush "$DOCKER_REPO:$LTS_SLUG" "$DOCKER_REPO:latest"
+fi

automated/dockerfiles/lts-10.0/Dockerfile

@@ -0,0 +1,67 @@
+FROM ubuntu:16.04
+
+MAINTAINER Emanuel Borsboom <manny@fpcomplete.com>
+
+ARG GHC_VERSION=8.2.2
+ARG LTS_SLUG=lts-10.0
+ARG PID1_VERSION=0.1.0.1
+ARG STACK_VERSION=1.6.3
+ARG BOOTSTRAP_COMMIT=a8234cb586c3022099a3b0155275ed067df00f72
+ARG DEBIAN_FRONTEND=noninteractive
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.cabal/bin:/root/.local/bin:/opt/ghc/$GHC_VERSION/bin:$PATH
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+#
+
+RUN apt-get update && \
+    apt-get install -y wget && \
+    wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | bash && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Create symlink to help tools find GHC documentation
+#
+
+RUN ln -s ghc /opt/ghc/$GHC_VERSION/share/doc/ghc-$GHC_VERSION
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --system-ghc --resolver=$LTS_SLUG --local-bin-path=/usr/local/bin install \
+        cabal-install happy alex cpphs gtk2hs-buildtools hscolour && \
+    cd $HOME/.stack && \
+    find . -type f -not -path './snapshots/*/share/*' -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/pid1%2F$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Install Stack
+#
+
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-10.1/Dockerfile

@@ -0,0 +1,3 @@
+FROM fpco/stack-build:lts-10.0
+ARG STACK_VERSION=1.6.3
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-10.5/Dockerfile

@@ -0,0 +1,3 @@
+FROM fpco/stack-build:lts-10.0
+ARG STACK_VERSION=1.6.5
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-11.0/Dockerfile

@@ -0,0 +1,67 @@
+FROM ubuntu:16.04
+
+MAINTAINER Emanuel Borsboom <manny@fpcomplete.com>
+
+ARG GHC_VERSION=8.2.2
+ARG LTS_SLUG=lts-11.0
+ARG PID1_VERSION=0.1.0.1
+ARG STACK_VERSION=1.6.5
+ARG BOOTSTRAP_COMMIT=13ab2b86779c98598e96af7f4c4b9653ba280be5
+ARG DEBIAN_FRONTEND=noninteractive
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.cabal/bin:/root/.local/bin:/opt/ghc/$GHC_VERSION/bin:$PATH
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+#
+
+RUN apt-get update && \
+    apt-get install -y wget && \
+    wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | bash && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Create symlink to help tools find GHC documentation
+#
+
+RUN ln -s ghc /opt/ghc/$GHC_VERSION/share/doc/ghc-$GHC_VERSION
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --system-ghc --resolver=$LTS_SLUG --local-bin-path=/usr/local/bin install \
+        cabal-install happy alex cpphs gtk2hs-buildtools hscolour && \
+    cd $HOME/.stack && \
+    find . -type f -not -path './snapshots/*/share/*' -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/pid1%2F$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Install Stack
+#
+
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-11.22/Dockerfile

@@ -0,0 +1,3 @@
+FROM fpco/stack-build:lts-11.6
+ARG STACK_VERSION=1.9.3
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-11.6/Dockerfile

@@ -0,0 +1,3 @@
+FROM fpco/stack-build:lts-11.5
+ARG STACK_VERSION=1.7.1
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-12.0/Dockerfile

@@ -0,0 +1,69 @@
+FROM ubuntu:16.04
+
+MAINTAINER Emanuel Borsboom <manny@fpcomplete.com>
+
+ARG GHC_VERSION=8.4.3
+ARG LTS_SLUG=lts-12.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=1.7.1
+ARG CUDA_VERSION=8.0
+ARG BOOTSTRAP_COMMIT=56c62ccbf31229ee2b09d3a0b4cd2ad94e7406a8
+ARG DEBIAN_FRONTEND=noninteractive
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.cabal/bin:/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:/opt/ghc/$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    LD_LIBRARY_PATH=/usr/local/cuda-$CUDA_VERSION/lib64:/usr/local/cuda-$CUDA_VERSION/nvvm/lib64
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+#
+
+RUN apt-get update && \
+    apt-get install -y wget && \
+    wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | bash && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Create symlink to help tools find GHC documentation
+#
+
+RUN ln -s ghc /opt/ghc/$GHC_VERSION/share/doc/ghc-$GHC_VERSION
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --system-ghc --resolver=$LTS_SLUG --local-bin-path=/usr/local/bin install \
+        cabal-install happy alex cpphs gtk2hs-buildtools hscolour && \
+    cd $HOME/.stack && \
+    find . -type f -not -path './snapshots/*/share/*' -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Install Stack
+#
+
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-12.13/Dockerfile

@@ -0,0 +1,3 @@
+FROM fpco/stack-build:lts-12.0
+ARG STACK_VERSION=1.9.1
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-12.15/Dockerfile

@@ -0,0 +1,14 @@
+FROM fpco/stack-build:lts-12.0
+ARG STACK_VERSION=1.9.1
+ARG GHC_VERSION=8.4.4
+RUN apt-get update && \
+    apt-get install -y \
+        ghc-$GHC_VERSION \
+        ghc-$GHC_VERSION-dyn \
+        ghc-$GHC_VERSION-htmldocs \
+        ghc-$GHC_VERSION-prof && \
+    rm -rf /var/lib/apt/lists/*
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'
+RUN ln -s ghc-$GHC_VERSION /opt/ghc/$GHC_VERSION/share/doc/ghc
+ARG CUDA_VERSION=8.0
+ENV PATH=/root/.cabal/bin:/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:/opt/ghc/$GHC_VERSION/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

automated/dockerfiles/lts-12.21/Dockerfile

@@ -0,0 +1,3 @@
+FROM fpco/stack-build:lts-12.15
+ARG STACK_VERSION=1.9.3
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-12.26/Dockerfile

@@ -0,0 +1,89 @@
+FROM ubuntu:16.04
+
+MAINTAINER Emanuel Borsboom <manny@fpcomplete.com>
+
+ARG GHC_VERSION=8.4.4
+ARG LTS_SLUG=lts-12.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=1.9.3
+ARG CUDA_VERSION=8.0
+ARG BOOTSTRAP_COMMIT=7f982f63a3734ddb2a7cbbc52b8cec983c496efa
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.cabal/bin:/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:/opt/ghc/$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    LD_LIBRARY_PATH=/usr/local/cuda-$CUDA_VERSION/lib64:/usr/local/cuda-$CUDA_VERSION/nvvm/lib64
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends wget netbase ca-certificates && \
+    if [ "$VARIANT" = "small" ]; then \
+        echo "deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main" >>/etc/apt/sources.list && \
+        echo "deb-src http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main" >>/etc/apt/sources.list && \
+        apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 063DAB2BDC0B3F9FCEBC378BFF3AEACEF6F88286 && \
+        apt-get update && \
+	    apt-get install -y --no-install-recommends \
+	    	ghc-$GHC_VERSION ghc-$GHC_VERSION-htmldocs \
+			g++ gcc libc6-dev libffi-dev libgmp-dev make xz-utils zlib1g-dev git gnupg \
+            libtinfo-dev; \
+    else \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | bash; \
+    fi && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Create symlink to help tools find GHC documentation
+#
+
+RUN ln -s ghc /opt/ghc/$GHC_VERSION/share/doc/ghc-$GHC_VERSION
+
+#
+# Install Stack
+#
+
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN export STACK_ROOT=/usr/local/lib/stack && \
+    stack --resolver=$LTS_SLUG --local-bin-path=/usr/local/bin install \
+        cabal-install happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-13.0/Dockerfile

@@ -0,0 +1,69 @@
+FROM ubuntu:16.04
+
+MAINTAINER Emanuel Borsboom <manny@fpcomplete.com>
+
+ARG GHC_VERSION=8.6.3
+ARG LTS_SLUG=lts-13.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=1.9.3
+ARG CUDA_VERSION=10.0
+ARG BOOTSTRAP_COMMIT=26b29f2862462afd47fb916ed0a2c2a6844ebca9
+ARG DEBIAN_FRONTEND=noninteractive
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.cabal/bin:/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:/opt/ghc/$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    LD_LIBRARY_PATH=/usr/local/cuda-$CUDA_VERSION/lib64:/usr/local/cuda-$CUDA_VERSION/nvvm/lib64
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+#
+
+RUN apt-get update && \
+    apt-get install -y wget && \
+    wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | bash && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Create symlink to help tools find GHC documentation
+#
+
+RUN ln -s ghc /opt/ghc/$GHC_VERSION/share/doc/ghc-$GHC_VERSION
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --system-ghc --resolver=$LTS_SLUG --local-bin-path=/usr/local/bin install \
+        cabal-install happy alex cpphs gtk2hs-buildtools hscolour && \
+    cd $HOME/.stack && \
+    find . -type f -not -path './snapshots/*/share/*' -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Install Stack
+#
+
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-13.12/Dockerfile

@@ -0,0 +1,93 @@
+FROM ubuntu:16.04
+
+MAINTAINER Emanuel Borsboom <manny@fpcomplete.com>
+
+ARG GHC_VERSION=8.6.4
+ARG LTS_SLUG=lts-13.11
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=1.9.3
+ARG CUDA_VERSION=10.0
+ARG BOOTSTRAP_COMMIT=9f2b7ab95c711794257b059604e80ab9ad3c0c45
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.cabal/bin:/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:/opt/ghc/$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    LD_LIBRARY_PATH=/usr/local/cuda-$CUDA_VERSION/lib64:/usr/local/cuda-$CUDA_VERSION/nvvm/lib64
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends wget netbase ca-certificates && \
+    if [ "$VARIANT" = "small" ]; then \
+        echo "deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main" >>/etc/apt/sources.list && \
+        echo "deb-src http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main" >>/etc/apt/sources.list && \
+        apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 063DAB2BDC0B3F9FCEBC378BFF3AEACEF6F88286 && \
+        apt-get update && \
+	    apt-get install -y --no-install-recommends \
+	    	ghc-$GHC_VERSION ghc-$GHC_VERSION-htmldocs \
+			g++ gcc libc6-dev libffi-dev libgmp-dev make xz-utils zlib1g-dev git gnupg \
+            libtinfo-dev; \
+    else \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.3$/GHCVER=$GHC_VERSION/" | bash && \
+        # Add g++ version required for building 'double-conversion' \
+        # (see https://github.com/commercialhaskell/stack/issues/4470) \
+        apt-get install -y g++-7; \
+    fi && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Create symlink to help tools find GHC documentation
+#
+
+RUN ln -s ghc /opt/ghc/$GHC_VERSION/share/doc/ghc-$GHC_VERSION
+
+#
+# Install Stack
+#
+
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN export STACK_ROOT=/usr/local/lib/stack && \
+    stack --resolver=$LTS_SLUG --local-bin-path=/usr/local/bin install \
+        cabal-install happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-13.20/Dockerfile

@@ -0,0 +1,93 @@
+FROM ubuntu:16.04
+
+MAINTAINER Emanuel Borsboom <manny@fpcomplete.com>
+
+ARG GHC_VERSION=8.6.5
+ARG LTS_SLUG=lts-13.20
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=1.9.3
+ARG CUDA_VERSION=10.0
+ARG BOOTSTRAP_COMMIT=9f2b7ab95c711794257b059604e80ab9ad3c0c45
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.cabal/bin:/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:/opt/ghc/$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    LD_LIBRARY_PATH=/usr/local/cuda-$CUDA_VERSION/lib64:/usr/local/cuda-$CUDA_VERSION/nvvm/lib64
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends wget netbase ca-certificates && \
+    if [ "$VARIANT" = "small" ]; then \
+        echo "deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main" >>/etc/apt/sources.list && \
+        echo "deb-src http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main" >>/etc/apt/sources.list && \
+        apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 063DAB2BDC0B3F9FCEBC378BFF3AEACEF6F88286 && \
+        apt-get update && \
+	    apt-get install -y --no-install-recommends \
+	    	ghc-$GHC_VERSION ghc-$GHC_VERSION-htmldocs \
+			g++ gcc libc6-dev libffi-dev libgmp-dev make xz-utils zlib1g-dev git gnupg \
+            libtinfo-dev; \
+    else \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.3$/GHCVER=$GHC_VERSION/" | bash && \
+        # Add g++ version required for building 'double-conversion' \
+        # (see https://github.com/commercialhaskell/stack/issues/4470) \
+        apt-get install -y g++-7; \
+    fi && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Create symlink to help tools find GHC documentation
+#
+
+RUN ln -s ghc /opt/ghc/$GHC_VERSION/share/doc/ghc-$GHC_VERSION
+
+#
+# Install Stack
+#
+
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN export STACK_ROOT=/usr/local/lib/stack && \
+    stack --resolver=$LTS_SLUG --local-bin-path=/usr/local/bin install \
+        cabal-install happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-13.25/Dockerfile

@@ -0,0 +1,3 @@
+FROM $DOCKER_REPO:lts-13.24
+ARG STACK_VERSION=2.1.1
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-13.27/Dockerfile

@@ -0,0 +1,9 @@
+FROM $DOCKER_REPO:lts-13.26
+ARG VARIANT
+RUN if [ "$VARIANT" = "small" ]; then \
+        apt-get update && \
+        apt-get install -y --no-install-recommends sudo && \
+        rm -rf /var/lib/apt/lists/*; \
+    fi
+ARG STACK_VERSION=2.1.3
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64-static.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-13.3/Dockerfile

@@ -0,0 +1,10 @@
+FROM fpco/stack-build:lts-13.0
+
+#
+# Add g++ version required for building 'double-conversion'
+# (see https://github.com/commercialhaskell/stack/issues/4470)
+#
+
+RUN apt-get update && \
+    apt-get install -y g++-7 && \
+    rm -rf /var/lib/apt/lists/*

automated/dockerfiles/lts-14.0/Dockerfile

@@ -0,0 +1,89 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.6.5
+ARG LTS_SLUG=lts-14.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.1.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_VERSION=3.9
+ARG BOOTSTRAP_COMMIT=d4143f1845f26e8e99d0a1a8134d6ff535ab98b2
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:/usr/lib/llvm-$LLVM_VERSION/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.5$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-14.0/Dockerfile.sub

@@ -0,0 +1,89 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.6.5
+ARG LTS_SLUG=lts-14.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.1.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_VERSION=3.9
+ARG BOOTSTRAP_COMMIT=d4143f1845f26e8e99d0a1a8134d6ff535ab98b2
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:/usr/lib/llvm-$LLVM_VERSION/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.5$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-15.0/Dockerfile

@@ -0,0 +1,89 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.8.2
+ARG LTS_SLUG=lts-15.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.1.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=77790c7bcb21fd8875871245df5c5c39a55ec0c1
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.5$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-15.10/Dockerfile

@@ -0,0 +1,3 @@
+FROM $DOCKER_REPO:lts-15.5
+ARG STACK_VERSION=2.3.1
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-15.5/Dockerfile

@@ -0,0 +1,89 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.8.3
+ARG LTS_SLUG=lts-15.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.1.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=77790c7bcb21fd8875871245df5c5c39a55ec0c1
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.5$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-16.0/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.8.3
+ARG LTS_SLUG=lts-16.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.3.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=1afd08ff0a3c3627f17eb1b928d35f337db40e08
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.5$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-16.12/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.8.4
+ARG LTS_SLUG=lts-16.12
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.3.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=1afd08ff0a3c3627f17eb1b928d35f337db40e08
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.5$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-16.8/Dockerfile

@@ -0,0 +1,3 @@
+FROM $DOCKER_REPO:lts-16.0
+ARG STACK_VERSION=2.3.3
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-17.0/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.8.3
+ARG LTS_SLUG=lts-17.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.5.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=1afd08ff0a3c3627f17eb1b928d35f337db40e08
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.5$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-17.10/Dockerfile

@@ -0,0 +1,3 @@
+FROM $DOCKER_REPO:lts-17.9
+ARG STACK_VERSION=2.7.1
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-17.3/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.8.4
+ARG LTS_SLUG=lts-17.3
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.5.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=1afd08ff0a3c3627f17eb1b928d35f337db40e08
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=8.6.5$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-18.0/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.10.4
+ARG LTS_SLUG=lts-18.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.7.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=b91382f2ff1f2775f4aa9d42c9a6b06b33e5904d
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-18.27/Dockerfile

@@ -0,0 +1,3 @@
+FROM $DOCKER_REPO:lts-18.26
+ARG STACK_VERSION=2.7.5
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-18.7/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.10.6
+ARG LTS_SLUG=lts-18.6
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.7.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=b1d40e112040a7f44eff47a9fafb6937f5d02dff
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-18.9/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=8.10.7
+ARG LTS_SLUG=lts-18.9
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.7.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-7
+ARG BOOTSTRAP_COMMIT=b1d40e112040a7f44eff47a9fafb6937f5d02dff
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-19.0/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=9.0.2
+ARG LTS_SLUG=lts-19.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.7.3
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-9
+ARG BOOTSTRAP_COMMIT=70317ea1c42e6caae625059980575157cf9525ed
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-20.0/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:18.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=9.2.5
+ARG LTS_SLUG=lts-20.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.9.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-9
+ARG BOOTSTRAP_COMMIT=80f68bd733963b71c09b1e8ef6c19bf5b3347245
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-21.0/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:22.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=9.4.5
+ARG LTS_SLUG=lts-21.0
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.11.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-9
+ARG BOOTSTRAP_COMMIT=56d27e1cfead1a37ff55942a9d2f14c0733459c9
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running debian-bootstrap.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-21.12/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:22.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=9.4.7
+ARG LTS_SLUG=lts-21.12
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.11.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-9
+ARG BOOTSTRAP_COMMIT=56d27e1cfead1a37ff55942a9d2f14c0733459c9
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's docker/*.sh scripts to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running docker/*.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/01-build-server.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/02-apt-get-install.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/03-custom-install.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/04-cleanup.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-21.22/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:22.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=9.4.8
+ARG LTS_SLUG=lts-21.22
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.11.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-9
+ARG BOOTSTRAP_COMMIT=56d27e1cfead1a37ff55942a9d2f14c0733459c9
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's docker/*.sh scripts to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running docker/*.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/01-build-server.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/02-apt-get-install.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/03-custom-install.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/04-cleanup.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-21.6/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:22.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=9.4.5
+ARG LTS_SLUG=lts-21.6
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.11.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-9
+ARG BOOTSTRAP_COMMIT=56d27e1cfead1a37ff55942a9d2f14c0733459c9
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's docker/*.sh scripts to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running docker/*.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/01-build-server.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/02-apt-get-install.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/03-custom-install.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/04-cleanup.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-21.7/Dockerfile

@@ -0,0 +1,90 @@
+FROM ubuntu:22.04
+
+LABEL maintainer="manny@fpcomplete.com"
+
+ARG GHC_VERSION=9.4.6
+ARG LTS_SLUG=lts-21.7
+ARG PID1_VERSION=0.1.2.0
+ARG STACK_VERSION=2.11.1
+ARG CUDA_VERSION=10.0
+ARG JVM_PATH=/usr/lib/jvm/java-8-openjdk-amd64
+ARG LLVM_PATH=/usr/lib/llvm-9
+ARG BOOTSTRAP_COMMIT=56d27e1cfead1a37ff55942a9d2f14c0733459c9
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG VARIANT=build
+ARG STACK_ROOT=/home/stackage/.stack
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.local/bin:/usr/local/cuda-$CUDA_VERSION/bin:$STACK_ROOT/programs/x86_64-linux/ghc-$GHC_VERSION/bin:$PATH \
+    CUDA_PATH=/usr/local/cuda-$CUDA_VERSION \
+    CPATH=$JVM_PATH/include:$JVM_PATH/include/linux:$LLVM_PATH/include
+
+#
+# Install pre-requisites
+#
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget netbase ca-certificates g++ gcc libc6-dev libffi-dev libgmp-dev \
+        make xz-utils zlib1g-dev git gnupg libtinfo-dev jq && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use Stackage's docker/*.sh scripts to install system libraries and
+# tools required to build any Stackage package.
+# Re-installs 'stack' *after* running docker/*.sh since that may have
+# installed a different version.
+# In the case of 'small' image, just install Stack and GHC.
+#
+
+RUN if [ "$VARIANT" != "small" ]; then \
+        wget -qO- https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/01-build-server.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/02-apt-get-install.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/03-custom-install.sh https://raw.githubusercontent.com/commercialhaskell/stackage/$BOOTSTRAP_COMMIT/docker/04-cleanup.sh | sed "s/^GHCVER=9.0.1$/GHCVER=$GHC_VERSION/" | GHCVER=$GHC_VERSION bash; \
+    fi && \
+    wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/bin '*/stack' && \
+    if [ "$VARIANT" = "small" ]; then \
+        stack setup --resolver ghc-$GHC_VERSION; \
+    fi && \
+    rm -rf /var/lib/apt/lists/* && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Configure Stack to use the GHC installed in the Docker image rather than installing its own
+#
+
+RUN mkdir /etc/stack/ && \
+    echo "system-ghc: true" >/etc/stack/config.yaml
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --resolver=$LTS_SLUG --local-bin-path=/usr/bin install \
+        happy alex cpphs gtk2hs-buildtools hscolour hlint hindent && \
+    cd $STACK_ROOT && \
+    find . -type f -not -path './snapshots/*/share/*' -and -not -path "./programs/x86_64-linux/ghc-$GHC_VERSION/*" -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/v$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-9.0/Dockerfile

@@ -0,0 +1,55 @@
+FROM ubuntu:16.04
+
+MAINTAINER Emanuel Borsboom <manny@fpcomplete.com>
+
+ARG GHC_VERSION=8.0.2
+ARG LTS_SLUG=lts-9.0
+ARG PID1_VERSION=0.1.0.1
+ARG BOOTSTRAP_COMMIT=1bc67bb54eda08c90d8421bc11d257354a379d11
+ARG DEBIAN_FRONTEND=noninteractive
+
+#
+# Set encoding to UTF-8 and PATH to find GHC and cabal/stack-installed binaries.
+#
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    PATH=/root/.cabal/bin:/root/.local/bin:/opt/ghc/$GHC_VERSION/bin:$PATH
+
+#
+# Use Stackage's debian-bootstrap.sh script to install system libraries and
+# tools required to build any Stackage package.
+#
+
+RUN apt-get update && \
+    apt-get install -y wget && \
+    wget -qO- https://raw.githubusercontent.com/fpco/stackage/$BOOTSTRAP_COMMIT/debian-bootstrap.sh | bash && \
+    ln -s ghc /opt/ghc/$GHC_VERSION/share/doc/ghc-$GHC_VERSION && \
+    rm -rf /var/lib/apt/lists/*
+
+#
+# Use 'stack' to install basic Haskell tools like alex, happy, and cpphs. We
+# remove most of the STACK_ROOT afterward to save space, but keep the 'share'
+# files that some of these tools require.
+#
+
+RUN stack --system-ghc --resolver=$LTS_SLUG --local-bin-path=/usr/local/bin install \
+        cabal-install happy alex cpphs gtk2hs-buildtools hscolour && \
+    cd $HOME/.stack && \
+    find . -type f -not -path './snapshots/*/share/*' -exec rm '{}' \; && \
+    find . -type d -print0 |sort -rz |xargs -0 rmdir 2>/dev/null || true
+
+#
+# Install proper 'pid1' init daemon
+#
+
+RUN wget -O- "https://github.com/fpco/pid1/releases/download/pid1%2F$PID1_VERSION/pid1-$PID1_VERSION-linux-x86_64.tar.gz" | tar xzf - -C /usr/local && \
+    chown root:root /usr/local/sbin && \
+    chown root:root /usr/local/sbin/pid1
+
+#
+# Set up pid1 entrypoint and default command
+#
+
+ENTRYPOINT ["/usr/local/sbin/pid1"]
+CMD ["bash"]

automated/dockerfiles/lts-9.20/Dockerfile

@@ -0,0 +1,3 @@
+FROM fpco/stack-build:lts-9.0
+ARG STACK_VERSION=1.6.1
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/dockerfiles/lts-9.21/Dockerfile

@@ -0,0 +1,3 @@
+FROM fpco/stack-build:lts-9.0
+ARG STACK_VERSION=1.6.5
+RUN wget -qO- https://github.com/commercialhaskell/stack/releases/download/v$STACK_VERSION/stack-$STACK_VERSION-linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C /usr/local/bin '*/stack'

automated/run-nightly.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+while true; do
+    git pull
+    ./build.sh nightly-$(date -u +%F)
+    date
+
+    sleep 30m
+    echo
+done

become-a-curator.md

@@ -0,0 +1,44 @@
+## We are no longer accepting applications, please wait until next time
+
+We are looking to expand the stackage curator team!
+
+As a stackage curator you will help the community by curating and
+publishing the widely used nightly and LTS snapshots: Collections of
+packages that are guaranteed to play well together. All curators are
+volunteers.
+
+This is a great opportunity to contribute to the haskell community and get
+familiar with the tools of the trade! You will also be in regular
+contact with experienced community members.
+
+We don't have any prerequisites, but familiarity with any of Haskell,
+Cabal, Stack, Linux, Git, and Docker is a plus.
+
+We work in shifts of one week, which means you will be on duty every
+6th week. Our suggestion is to pair you up with another curator to
+help out in the beginning.
+
+The workload is usually about 30 minutes per day, whenever you have
+time. The work consists of keeping the builds running on the build
+server, filing issues for packages needing updates when new releases
+occur, and closing resolved issues. The LTS snapshots are prepared
+once a week. All communication with package maintainers happen on
+github.
+
+We also have a curator slack channel where we help each other out.
+
+The current curator team consists of:
+* Adam Bergmark
+* Dan Burton
+* Jens Petersen
+* Luke Murphy
+* Michael Snoyman
+
+We onboarded Luke as the newest member a few months ago and this
+helped us iron out and document the process further.
+
+You can read the curator documentation here: https://github.com/commercialhaskell/stackage/blob/master/CURATORS.md
+
+To apply, please fill in this form: [REDACTED]
+
+If you applied last time, we encourage you to do so again!

check

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# Convenience script for checking constraints locally
+
+cd `dirname $0`
+
+export GHCVER=$(sed -n "s/^ghc-version: \"\(.*\)\"/\1/p" "build-constraints.yaml")
+
+NIGHTLY="nightly-$(date +%Y-%m-%d)"
+curator update &&
+  curator constraints --target=$NIGHTLY &&
+  curator snapshot-incomplete --target=$NIGHTLY &&
+  curator snapshot &&
+  stack --resolver ghc-$GHCVER exec curator check-snapshot

commenter

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+if ! command -v commenter &> /dev/null
+then
+    echo "commenter is not installed, get it from https://github.com/bergmark/commenter"
+    exit 1
+fi
+
+commenter $@

docker/01-build-server.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+# This file contains setup needed for the build server to function at all.
+
+set -exuo pipefail
+
+mkdir -p /home/stackage
+
+export LANG=C.UTF-8
+export DEBIAN_FRONTEND=noninteractive
+
+apt-get update
+apt-get install -y curl unzip
+
+# Install AWS CLI
+mkdir -p /tmp/awscli
+(
+cd /tmp/awscli
+curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
+unzip -q awscliv2.zip
+./aws/install --bin-dir /usr/bin
+)
+rm -rf /tmp/awscli

docker/02-apt-get-install.sh

@@ -0,0 +1,161 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+export LANG=C.UTF-8
+export DEBIAN_FRONTEND=noninteractive
+
+# List of ubuntu packages needed to build stackage's haskell packages.
+#
+# If new packages are added here, please document why they are needed
+# e.g. "# for my-package"
+
+apt-get update
+
+apt-get install -y \
+    apt-transport-https \
+    build-essential \
+    cmake \
+    coinor-libclp-dev \
+    curl \
+    dvipng \
+    freeglut3-dev \
+    freetds-dev \
+    fsharp \
+    g++ \
+    gawk \
+    git \
+    gnupg \
+    gradle \
+    hscolour \
+    libadns1-dev \
+    libaio1 \
+    libalut-dev \
+    libasound2-dev \
+    libblas-dev \
+    libbrotli-dev \
+    libbz2-dev \
+    libcairo2-dev \
+    libclang-12-dev \
+    libcurl4-openssl-dev \
+    libcwiid-dev \
+    libdbusmenu-glib-dev \
+    libdbusmenu-gtk3-dev \
+    libdevil-dev \
+    libedit-dev \
+    libedit2 \
+    libfftw3-dev \
+    libflac-dev \
+    libfreenect-dev \
+    libgd-dev \
+    libgeoip-dev \
+    libgirepository1.0-dev \
+    libglew-dev \
+    libglfw3-dev \
+    libglib2.0-dev \
+    libglpk-dev \
+    libglu1-mesa-dev \
+    libgmp3-dev \
+    libgnutls28-dev \
+    libgraphene-1.0-dev \
+    libgsasl7-dev \
+    libgsl-dev \
+    libgtk-3-dev \
+    libgtk-4-dev \
+    libgtk2.0-dev \
+    libgtksourceview-3.0-dev \
+    libhidapi-dev \
+    libi2c-dev \
+    libicu-dev \
+    libimlib2-dev \
+    libjack-jackd2-dev \
+    libjansson-dev \
+    libjavascriptcoregtk-4.0-dev \
+    libjudy-dev \
+    liblapack-dev \
+    libleveldb-dev \
+    liblmdb-dev \
+    liblz4-tool \
+    liblzma-dev \
+    libmagic-dev \
+    libmagickcore-dev \
+    libmagickwand-dev \
+    libmarkdown2-dev \
+    libmono-2.0-dev \
+    libmp3lame-dev \
+    libmpfr-dev \
+    libmpich-dev \
+    libmysqlclient-dev \
+    libncurses5-dev \
+    libnfc-dev \
+    libnotify-dev \
+    liboath-dev \
+    libopenal-dev \
+    libpango1.0-dev \
+    libpcap0.8-dev \
+    libpcre2-dev \
+    libpq-dev \
+    libprimecount-dev \
+    libprotobuf-dev \
+    libre2-dev \
+    librocksdb-dev \
+    libsdl1.2-dev \
+    libsdl2-dev \
+    libsdl2-gfx-dev \
+    libsdl2-image-dev \
+    libsdl2-mixer-dev \
+    libsdl2-ttf-dev \
+    libsecp256k1-dev \
+    libsnappy-dev \
+    libsndfile1-dev \
+    libsodium-dev \
+    libsoup2.4-dev \
+    libsox-dev \
+    libsqlite3-dev \
+    libssl-dev \
+    libsystemd-dev \
+    libtagc0-dev \
+    libtre-dev \
+    libudev-dev \
+    libusb-1.0-0-dev \
+    libvte-2.91-dev \
+    libwebkit2gtk-4.0-dev \
+    libxau-dev \
+    libxml2-dev \
+    libxrandr-dev \
+    libxss-dev \
+    libyaml-dev \
+    libz3-dev \
+    libzip-dev \
+    libzmq3-dev \
+    libzstd-dev \
+    llvm-11 \
+    llvm-12 \
+    llvm-13 \
+    locales \
+    m4 \
+    minisat \
+    mono-mcs \
+    nettle-dev \
+    ninja-build \
+    nodejs \
+    openjdk-8-jdk \
+    python-mpltoolkits.basemap \
+    python3-matplotlib \
+    python3-numpy \
+    python3-pip \
+    python3-scipy \
+    r-base \
+    r-base-dev \
+    rpm \
+    ruby-dev \
+    software-properties-common \
+    sudo \
+    texlive \
+    unixodbc-dev \
+    unzip \
+    wget \
+    xclip \
+    zip \
+    zlib1g-dev \
+    zsh

docker/03-custom-install.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+export LANG=C.UTF-8
+export DEBIAN_FRONTEND=noninteractive
+
+# Add system dependencies not present in the ubuntu package registry here.
+# Please add a comment stating which haskell packages needs it.
+
+locale-gen en_US.UTF-8
+
+# Buggy versions of ld.bfd fail to link some Haskell packages:
+# https://sourceware.org/bugzilla/show_bug.cgi?id=17689. Gold is
+# faster anyways and uses less RAM.
+update-alternatives --install "/usr/bin/ld" "ld" "/usr/bin/ld.gold" 20
+update-alternatives --install "/usr/bin/ld" "ld" "/usr/bin/ld.bfd" 10
+
+# install ocilib dependencies then build and install ocilib
+cd /tmp \
+    && wget https://storage.googleapis.com/oracle.fpinsight.com/instantClient/oracle-instantclient12.1-basiclite_12.1.0.2.0-2_amd64.deb \
+    && dpkg -i oracle-instantclient12.1-basiclite_12.1.0.2.0-2_amd64.deb \
+    && rm -f oracle-instantclient12.1-basiclite_12.1.0.2.0-2_amd64.deb \
+    && wget https://storage.googleapis.com/oracle.fpinsight.com/instantClient/oracle-instantclient12.1-devel_12.1.0.2.0-2_amd64.deb \
+    && dpkg -i oracle-instantclient12.1-devel_12.1.0.2.0-2_amd64.deb \
+    && rm -f oracle-instantclient12.1-devel_12.1.0.2.0-2_amd64.deb \
+    && wget https://github.com/vrogier/ocilib/archive/v4.3.2.tar.gz \
+    && tar xvf v4.3.2.tar.gz \
+    && cd /tmp/ocilib-4.3.2 \
+    && ./configure --with-oracle-import=linkage \
+                   --with-oracle-charset=ansi \
+                   --with-oracle-headers-path=/usr/include/oracle/12.1/client64 \
+                   --with-oracle-lib-path=/usr/lib/oracle/12.1/client64/lib \
+    && make \
+    && make install \
+    && cd \
+    && rm -rf /tmp/ocilib-4.3.2 \
+    && echo "/usr/local/lib" > /etc/ld.so.conf.d/usr-local.conf \
+    && echo "/usr/lib/oracle/12.1/client64/lib" > /etc/ld.so.conf.d/oracle-client.conf \
+    && ldconfig
+
+# Add JDK to system paths.
+echo "/usr/lib/jvm/java-8-openjdk-amd64/jre/lib/amd64/server/" > /etc/ld.so.conf.d/openjdk.conf \
+    && ldconfig
+
+# Install erlang/otp platform and its dependencies
+ERLANG_DEB_FILE="esl-erlang_21.1-1~ubuntu~bionic_amd64.deb"
+pushd /tmp \
+    && wget https://packages.erlang-solutions.com/erlang/debian/pool/${ERLANG_DEB_FILE} \
+    && (dpkg -i ${ERLANG_DEB_FILE}; apt-get install -yf) \
+    && rm ${ERLANG_DEB_FILE} \
+    && popd
+
+# Install the TensorFlow C API.
+curl https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-linux-x86_64-1.1.0.tar.gz > libtensorflow.tar.gz \
+    && sudo tar zxf libtensorflow.tar.gz -C /usr \
+    && rm libtensorflow.tar.gz \
+    && ldconfig
+
+export CLANG_PURE_LLVM_LIB_DIR=/usr/lib/llvm-9/lib;
+export CLANG_PURE_LLVM_INCLUDE_DIR=/usr/lib/llvm-9/include;
+
+# protoc, for proto-lens-combinators test suite
+# Instructions from: https://google.github.io/proto-lens/installing-protoc.html
+PROTOC_ZIP=protoc-3.3.0-linux-x86_64.zip
+curl -OL https://github.com/google/protobuf/releases/download/v3.3.0/$PROTOC_ZIP
+sudo unzip -o $PROTOC_ZIP -d /usr bin/protoc
+rm -f $PROTOC_ZIP
+
+
+echo /usr/lib/jvm/java-8-openjdk-amd64/jre/lib/amd64/server > /etc/ld.so.conf.d/java.conf
+
+# Install librdkafka (Apache Kafka C/C++ library)
+wget -qO - https://packages.confluent.io/deb/5.2/archive.key | apt-key add -
+add-apt-repository "deb https://packages.confluent.io/deb/5.2 stable main"
+apt-get update && apt install -y librdkafka-dev
+
+LIBJWT_VER=1.12.1
+(
+pushd /tmp \
+    && wget https://github.com/benmcollins/libjwt/archive/v${LIBJWT_VER}.zip \
+    && unzip v${LIBJWT_VER}.zip \
+    && pushd libjwt-${LIBJWT_VER} \
+       && autoreconf -fiv \
+       && ./configure --disable-valgrind --disable-doxygen-doc --prefix /usr \
+       && make \
+       && sudo make install \
+       && popd \
+    && popd
+)

docker/04-cleanup.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+export LANG=C.UTF-8
+export DEBIAN_FRONTEND=noninteractive
+
+# Cleanup
+apt-get clean
+rm -rf /var/lib/apt/lists/*

etc/check.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+set -euxo pipefail
+
+ETC=$(cd $(dirname $0) ; pwd)
+export GHCVER=$(sed -n "s/^ghc-version: \"\(.*\)\"/\1/p" "$ETC/../build-constraints.yaml")
+
+# Download and unpack the stack executable
+mkdir -p ~/.local/bin
+export PATH=$HOME/.local/bin:$PATH
+curl -L https://www.stackage.org/stack/linux-x86_64 | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack'
+
+# Get new Stackage curator
+curl -L "https://github.com/commercialhaskell/curator/releases/download/commit-62d4bce549af5fccb5089b8aa319891dbe032ccb/curator.bz2" | bunzip2 > curator
+chmod +x curator
+
+# Install GHC
+stack setup $GHCVER
+
+# curator's constraint command has target as a required parameter
+# because of a different constraints handling in minor LTS version bumps
+NIGHTLY="nightly-$(date +%Y-%m-%d)"
+# New curator check
+./curator update &&
+  ./curator constraints --target=$NIGHTLY &&
+  ./curator snapshot-incomplete --target=$NIGHTLY &&
+  ./curator snapshot &&
+  stack --resolver ghc-$GHCVER exec ./curator check-snapshot

etc/curator-exes/.gitignore

@@ -0,0 +1 @@
+/bin/

etc/curator-exes/Dockerfile

@@ -0,0 +1,13 @@
+FROM fpco/stack-build:lts-14
+
+# Prime the snapshot so rebuilds are faster
+RUN mkdir -p /artifacts
+RUN stack update
+RUN stack build --no-install-ghc --resolver lts-13.28 --only-dependencies stack amazonka-s3
+
+RUN git clone --depth 1 https://github.com/commercialhaskell/stack && \
+    git clone --depth 1 https://github.com/commercialhaskell/curator
+
+COPY stack.yaml .
+
+RUN stack --no-install-ghc install --local-bin-path /artifacts

etc/curator-exes/README.md

@@ -0,0 +1,5 @@
+Scripts to create and upload the curator-exes.tar.bz2 files. Make sure to
+update the hash in automated/build-next.sh.
+
+NOTE: Depending on what's exactly on the master branches when running the
+`./run.sh` script, the `stack.yaml` file may need some tweaks.

etc/curator-exes/run.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -eux
+
+rm -rf bin
+mkdir -p bin
+
+docker build . --tag curator-exes
+
+docker run --rm -v $(pwd)/bin:/output curator-exes cp /artifacts/* output
+aws s3 cp curators-exes/* s3://download.fpcomplete.com/curator-exes/

etc/curator-exes/stack.yaml

@@ -0,0 +1,22 @@
+resolver: lts-13.28
+
+packages:
+- stack
+- curator
+
+extra-deps:
+- hi-file-parser-0.1.0.0@sha256:3fc95852035c8e0fa6d5f9d22e5108067c8f4816ac84675bddc971b20144a9ae,2317
+- http-download-0.1.0.0@sha256:b02d76d28364b74fb90d3ec3c46fd81f9d77bcf71fa40c1d341a7251a0fc40e8,2023
+- pantry-0.1.1.2@sha256:6f06556f8e934afd517559d6f3dae947db91ef3801ee4e5cee9916c83a0c4d52,4628
+- rio-prettyprint-0.1.0.0@sha256:764e1a357275c3c62d57c494d038feae01cf745788e7d0e97367ba793c9670c3,1359
+- ansi-terminal-0.9.1@sha256:48f53532d0f365ffa568c8cf0adc84c66f800a7d80d3329e4f04fa75392f4af1,3225
+- rio-0.1.12.0@sha256:a0b42682a455ffde6a4d894b135117e379aea7ed1810c2cfed471b8f5879968c,3633
+- unliftio-0.2.12@sha256:b089fbc2ff2628a963c2c4b12143f2020874e3e5144ffd6c62b25639a0ca1483,3325
+
+- github: fpco/casa
+  commit: a0cd05c1a9ce33acbb1bdfb9324370f884916e88
+  # sha256: 812e05de8f9abdbd1101fc94895dcfd5c35962c4d67a43cc20cbc06eb59ea1f0
+  # size: 9508
+  subdirs:
+     - casa-client
+     - casa-types

etc/diskspace/remove-old-stack-work-libs.hs

@@ -0,0 +1,123 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-19.33 script
+
+-- Utility to remove old libs installed under .stack-work/ to save diskspace
+
+import Control.Monad
+import Data.List
+import System.Directory
+import System.FilePath
+import System.Environment
+import Text.Regex.TDFA
+
+-- keep 2 latest builds
+keepBuilds :: Int
+keepBuilds = 2
+
+main :: IO ()
+main = do
+  args <- getArgs
+  case args of
+    [stream] -> do
+      home <- getHomeDirectory
+      withCurrentDirectory (home </> "stackage/automated/work" </> stream </> "unpack-dir") $ do
+        cleanStackWorkInstall
+        putStrLn ""
+        cleanStackWorkPackages
+    _ -> error "arg should be 'lts-XX' or 'nightly'"
+
+  -- navigates to: .stack-work/install/x86_64-linux*/*/*/lib/x86_64-linux-ghc-*
+cleanStackWorkInstall :: IO ()
+cleanStackWorkInstall =
+  withCurrentDirectory ".stack-work/install"
+  $ withOneDirectory_ -- "x86_64-linux*"
+  $ withOneDirectory_ -- hash
+  $ withOneDirectory $ \ghcver ->
+  withCurrentDirectory ("lib" </> "x86_64-linux-ghc-" ++ ghcver) $ do
+  getCurrentDirectory >>= putStrLn
+  files <- sort <$> listDirectory "."
+  let (dynlibs,libdirs) = partition (".so" `isExtensionOf`) files
+      pkglibdirs = groupBy samePkgLibDir libdirs
+      pkgdynlibs = groupBy samePkgDynLib dynlibs
+  mapM_ (removeOlder removeDirectoryRecursive) pkglibdirs
+  mapM_ (removeOlder removeFile) pkgdynlibs
+  where
+    samePkgLibDir l1 l2 = pkgDirName l1 == pkgDirName l2
+      where
+        pkgDirName p =
+          if length p < 25
+          then error $ p ++ " too short to be in correct name-version-hash format"
+          else extractNameInternal p
+
+    extractNameInternal :: String -> String
+    extractNameInternal p =
+      let (name,match',internal) = p =~ "-[0-9.]+-[0-9A-Za-z]{19,22}" :: (String, String, String)
+      in if null match' || null name then error $ p ++ " not in correct name-version-hash format"
+         else name ++ internal
+
+    samePkgDynLib d1 d2 = pkgDynName d1 == pkgDynName d2
+      where
+        pkgDynName p =
+          if length p < 42
+          then error $ p ++ " too short to be libHSname-version-hash-ghc*.so format"
+          else (extractNameInternal . removeDashSegment) p
+
+    removeDashSegment = dropWhileEnd (/= '-')
+
+
+removeOlder :: (FilePath -> IO ()) -> [FilePath] -> IO ()
+removeOlder remover files = do
+  oldfiles <- drop keepBuilds . reverse <$> sortByAge files
+  mapM_ remover oldfiles
+
+sortByAge :: [FilePath] -> IO [FilePath]
+sortByAge files = do
+  timestamps <- mapM getModificationTime files
+  let fileTimes = zip files timestamps
+  return $ map fst $ sortBy compareSnd fileTimes
+  where
+    compareSnd (_,t1) (_,t2) = compare t1 t2
+
+-- navigates to:
+-- unpacked/*/.stack-work/dist/x86_64-linux-tinfo6/Cabal-3.8.1.0/build/
+cleanStackWorkPackages :: IO ()
+cleanStackWorkPackages =
+  withCurrentDirectory "unpacked" $ do
+  getCurrentDirectory >>= putStrLn
+  pkgs <- listDirectory "."
+  forM_ pkgs $ \pkg ->
+    withCurrentDirectory (pkg </> ".stack-work/dist") $ do
+    -- [(dyn,stat)]
+    libs <- do
+      platforms <- listDirectory "." -- "x86_64-linux-tinfo6*"
+      forM platforms $ \pl ->
+        withCurrentDirectory pl $
+        withOneDirectory -- "Cabal-*"
+        $ \cbl ->
+        withCurrentDirectory "build" $ do
+        ls <- sort <$> listDirectory "."
+        files <- filterM doesFileExist ls
+        let (dynlibs,others) = partition (".so" `isExtensionOf`) files
+            statlibs = filter (".a" `isExtensionOf`) others
+        let dir = pl </> cbl </> "build"
+        return (map (dir </>) dynlibs, map (dir </>) statlibs)
+    removeOlder removeFile $ concatMap fst libs
+    removeOlder removeFile $ concatMap snd libs
+
+withOneDirectory_ :: IO a -> IO a
+withOneDirectory_ act = do
+  ls <- listDirectory "."
+  case ls of
+    [l] -> withCurrentDirectory l act
+    _ -> do
+      cwd <- getCurrentDirectory
+      error $ show (length ls) ++ " directories found in " ++ cwd ++ ": " ++ unwords ls
+
+withOneDirectory :: (FilePath -> IO a) -> IO a
+withOneDirectory act = do
+  ls <- listDirectory "."
+  case ls of
+    [l] -> withCurrentDirectory l $ act l
+    _ -> do
+      cwd <- getCurrentDirectory
+      error $ show (length ls) ++ " directories found in " ++ cwd ++ ": " ++ unwords ls

verify-package

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+
+# Script to verify a package to build successfully
+# Provide package name by the first argument
+#
+# Example:
+#  ./verify-package mtl
+# or
+#  ./verify-package mtl-2.2.2
+# or
+#  ./verify-package mtl lts
+
+set -eu
+
+die() {
+    >&2 echo "$1"
+    exit 1
+}
+
+package="${1:-}"
+if [[ -z $package ]]; then
+    die "Package name is not given"
+fi
+
+resolver="${2:-nightly}"
+
+here="$(cd "$(dirname "$0")" > /dev/null; pwd)"
+dir="$(mktemp -d tmp.XXXX)"
+
+exit() {
+    cd "$here"
+    rm -rf "$dir"
+}
+trap exit EXIT
+
+# When updating these commands, make sure to update .github/PULL_REQUEST_TEMPLATE.md as well.
+cd "$dir"
+stack unpack "$package"
+cd "$(ls | head -n 1)"
+rm -f stack.yaml
+stack init --resolver $resolver --ignore-subdirs
+stack build --resolver $resolver --haddock --test --bench --no-run-benchmarks
+
+cat <<EOF
+
+
+ 🎉 It looks good!
+
+EOF