Skip to content
Snippets Groups Projects
Commit e7a9d900 authored by Eric Timmons's avatar Eric Timmons
Browse files

Move to cl-docker-images org

parent e14cf9c7
No related branches found
No related tags found
No related merge requests found
[submodule "cl-docker-images-build"]
path = cl-docker-images-build
url = ../cl-docker-images-build.git
#+TITLE: ABCL Docker Images #+TITLE: CCL Docker Images
#+AUTHOR: Eric Timmons
This project contains Dockerfiles for a variety of stock CCL images as well as
* Supported Tags CI infrastructure to automatically build and push them.
+ =1.7.1-debian-buster=, =1.7.1-debian=, =1.7.1=, =latest= See [[file:hub-description.org]] for a more detailed description of the images.
* Quick Reference * Image Repos
+ ABCL Home Page :: [[https://abcl.org/]] The end goal is to get these images accepted into Docker's official image
+ Where to file Docker image related issues :: [[https://gitlab.com/mit-mers/docker/abcl/]] program. This drives the current layout of the repo as the official images
+ Where to file issues for build infrastructure :: [[https://gitlab.com/mit-mers/docker/library]] program does not allow images to be customized via build args.
+ Where to file issues for ABCL itself :: [[https://github.com/armedbear/abcl/issues]]
+ Maintained by :: [[https://github.com/daewok][Eric Timmons]] and the [[https://mers.csail.mit.edu/][MIT MERS Group]] (i.e., this is not an official ABCL image) Again, similar to the official images program, images are pushed to an arch
+ Supported platforms :: =linux/amd64= specific organization and then pushed to a common organization using Docker
+ Previously known as :: =daewok/abcl= manifests.
* What is ABCL? * CI
From [[https://abcl.org][ABCL's Home Page]] We use a mixture of Travis CI and GitHub Actions to build the images. Travis
is responsible for building all Linux based images and GitHub Actions builds
#+begin_quote the Windows based images. The reason for this split is primarily because
Armed Bear Common Lisp (ABCL) is a full implementation of the Common Lisp Travis provides hosted Arm instances, whereas GitHub currently does not.
language featuring both an interpreter and a compiler, running in the
JVM. Originally started to be a scripting language for the J editor, it now Building the images can take a *long* time and can occasionally fail due to
supports JSR-223 (Java scripting API): it can be a scripting engine in any transient conditions outside our control. Given that there are a large number
Java application. Additionally, it can be used to implement (parts of) the of images, we want to cache images between builds so we can reuse as much
application using Java to Lisp integration APIs. work as possible. Additionally, we don't want to waste time rebuilding images
#+end_quote that have already been released if the goal is to test changes to the nightly
images. Therefore, the CI jobs follow the following rules:
* What's in the image?
For jobs run on master, all images are built and pushed to the arch specific
This image contains ABCL binaries released by the upstream devs. repos with tags ending in =-tmp-master=. Nightly images are then retagged
without the suffix and pushed to the common org using manifests. When a
* License manual release job is triggered, all non-nightly images are retagged without
the suffix and pushed to the common org using manifests.
ABCL is licensed under the [[https://www.gnu.org/copyleft/gpl.html][GNU GPL]] with [[https://www.gnu.org/software/classpath/license.html][Classpath exception]].
For jobs run on a branch starting with =nightly-= only the nightly images are
The Dockerfiles used to build the images are licensed under BSD-2-Clause. built and are pushed (if possible) to the arch specific repos with the tag
suffix =-tmp=. These tags are used as potential cache sources when building
As with all Docker images, these likely also contain other software which may on any branch (including master).
be under other licenses (such as Bash, etc from the base distribution, along
with any direct or indirect dependencies of the primary software being For jobs run on any other branch, all images are built and pushed (if
contained). possible) to the arch specific repos with the tag suffix =-tmp=. These tags
are used as potential cache sources when building on any branch (including
As for any pre-built image usage, it is the image user's responsibility to master).
ensure that any use of this image complies with any relevant licenses for all
software contained within. This tagging scheme means that multiple non-master branches being developed
on in parallel will stomp on each other's caches. However, for now, that
seems like an acceptable tradeoff when compared to coming up with a more
robust tagging scheme.
** Rebuilding for new base images
CCL does not release on a regular cadence. As such, it is desirable to
occasionally rebuild and re-release images to account for the base image
being updated. Currently, this rebuild happens monthly and only for the
Linux images. Due to Travis CI not allowing cron jobs to have extra
configuration, the only way to distinguish between nightly builds and
rebuilds is by branch name. The stable branch should generally track master
and is the branch which rebuilds happen on.
Subproject commit 75ed003d3fdebf97efbcb14a19f870d4e8fc50c8
ARCHES=amd64
DEBIAN_LATEST=buster
DEBIAN_VERSIONS=buster
DEFAULT_LINUX_OS=debian
IMAGE_NAME=abcl
IMAGE_BUILD_NAMESPACE=daewok
IMAGE_TARGET_NAMESPACE=daewok
INCLUDE_WINDOWS_IN_MANIFEST=no
LATEST_VERSION=1.7.1
OSES=debian
WINDOWSSERVERCORE_LATEST=ltsc2019
WINDOWSSERVERCORE_VERSIONS=ltsc2019
- [Supported Tags](#org8cafceb)
- [Quick Reference](#org09cca26)
- [What is ABCL?](#org5f5eb1c)
- [What's in the image?](#orgbc5fdaf)
- [License](#org18d96cb)
<a id="org8cafceb"></a>
# Supported Tags
- `1.7.1-debian-buster`, `1.7.1-debian`, `1.7.1`, `latest`
<a id="org09cca26"></a>
# Quick Reference
- **ABCL Home Page:** <https://abcl.org/>
- **Where to file Docker image related issues:** <https://github.com/cl-docker-images/abcl/>
- **Where to file issues for ABCL itself:** <https://github.com/armedbear/abcl/issues>
- **Maintained by:** [Eric Timmons](https://github.com/daewok) and the [MIT MERS Group](https://mers.csail.mit.edu/) (i.e., this is not an official ABCL image)
- **Supported platforms:** `linux/amd64`
<a id="org5f5eb1c"></a>
# What is ABCL?
From [ABCL's Home Page](https://abcl.org)
> Armed Bear Common Lisp (ABCL) is a full implementation of the Common Lisp language featuring both an interpreter and a compiler, running in the JVM. Originally started to be a scripting language for the J editor, it now supports JSR-223 (Java scripting API): it can be a scripting engine in any Java application. Additionally, it can be used to implement (parts of) the application using Java to Lisp integration APIs.
<a id="orgbc5fdaf"></a>
# What's in the image?
This image contains ABCL binaries released by the upstream devs.
<a id="org18d96cb"></a>
# License
ABCL is licensed under the [GNU GPL](https://www.gnu.org/copyleft/gpl.html) with [Classpath exception](https://www.gnu.org/software/classpath/license.html).
The Dockerfiles used to build the images are licensed under BSD-2-Clause.
As with all Docker images, these likely also contain other software which may be under other licenses (such as Bash, etc from the base distribution, along with any direct or indirect dependencies of the primary software being contained).
As for any pre-built image usage, it is the image user's responsibility to ensure that any use of this image complies with any relevant licenses for all software contained within.
#+TITLE: ABCL Docker Images
#+AUTHOR: Eric Timmons
* Supported Tags
+ =1.7.1-debian-buster=, =1.7.1-debian=, =1.7.1=, =latest=
* Quick Reference
+ ABCL Home Page :: [[https://abcl.org/]]
+ Where to file Docker image related issues :: [[https://github.com/cl-docker-images/abcl/]]
+ Where to file issues for ABCL itself :: [[https://github.com/armedbear/abcl/issues]]
+ Maintained by :: [[https://github.com/daewok][Eric Timmons]] and the [[https://mers.csail.mit.edu/][MIT MERS Group]] (i.e., this is not an official ABCL image)
+ Supported platforms :: =linux/amd64=
* What is ABCL?
From [[https://abcl.org][ABCL's Home Page]]
#+begin_quote
Armed Bear Common Lisp (ABCL) is a full implementation of the Common Lisp
language featuring both an interpreter and a compiler, running in the
JVM. Originally started to be a scripting language for the J editor, it now
supports JSR-223 (Java scripting API): it can be a scripting engine in any
Java application. Additionally, it can be used to implement (parts of) the
application using Java to Lisp integration APIs.
#+end_quote
* What's in the image?
This image contains ABCL binaries released by the upstream devs.
* License
ABCL is licensed under the [[https://www.gnu.org/copyleft/gpl.html][GNU GPL]] with [[https://www.gnu.org/software/classpath/license.html][Classpath exception]].
The Dockerfiles used to build the images are licensed under BSD-2-Clause.
As with all Docker images, these likely also contain other software which may
be under other licenses (such as Bash, etc from the base distribution, along
with any direct or indirect dependencies of the primary software being
contained).
As for any pre-built image usage, it is the image user's responsibility to
ensure that any use of this image complies with any relevant licenses for all
software contained within.
#!/bin/bash
#-*- sh-basic-offset: 2; -*-
set -ex
if [ "$1" != "build" ] && [ "$1" != "nonbuild" ] && [ "$1" != "test" ]; then
echo "First argument must be build, nonbuild, or test"
exit 1
fi
. scripts/helpers.bash
build_os_version_arch() {
local image_variant
local os
local os_version
local arch
local docker_file
local image_name
image_variant="$1"
os="$2"
os_version="$3"
arch="$4"
image_name="$(versioned_repo)-$(os_version_string "$os" "$os_version")-$arch"
if [ "$image_variant" = "build" ]; then
docker_file="images/$os/$os_version/$arch/Dockerfile.build"
image_name="$image_name-build"
elif [ "$image_variant" = "test" ]; then
docker_file="images/$os/$os_version/$arch/Dockerfile.test"
image_name="$image_name-test"
else
docker_file="images/$os/$os_version/$arch/Dockerfile"
fi
docker_build_for_arch "$arch" -t "$image_name" -f "$docker_file" "images/$os/$os_version/$arch"
}
build_all_oses() {
mkdir -p build
if [ ! -f "build/image-ids.yaml" ]; then
echo "---" >> build/image-ids.yaml
fi
run_for_every_tuple "build_os_version_arch" "$@"
}
build_all_oses "$1"
#!/bin/bash
#-*- sh-basic-offset: 2; -*-
# export DOCKER_CONTENT_TRUST=1
docker_have_context_for_arch() {
[ -n "${CONTEXTS[$1]}" ]
}
docker_for_arch() {
local context
context=${CONTEXTS[$1]}
if [ -n "$context" ]; then
context="--context=$context"
fi
shift
docker "$context" "$@"
}
docker_build_for_arch() {
local platform
local arch
arch="$1"
platform=${ARCH_MAP[$arch]}
if [ -z "$platform" ]; then
echo "Unknown arch $arch"
exit 1
fi
shift
docker_for_arch "$arch" build --pull --platform "$platform" "$@"
}
versioned_repo() {
echo "$REPO:$ABCL_VERSION"
}
os_version_string() {
if [ "$1" = "alpine" ]; then
echo "$1$2"
else
echo "$1-$2"
fi
}
run_for_every_tuple() {
local os
local os_version
local arch
local fun
fun="$1"
shift
for os_dir in images/*; do
os="$(basename "$os_dir")"
for os_version_dir in "images/$os/"*; do
os_version="$(basename "$os_version_dir")"
for arch_dir in "images/$os/$os_version/"*; do
arch="$(basename "$arch_dir")"
if docker_have_context_for_arch "$arch"; then
"$fun" "$@" "$os" "$os_version" "$arch"
fi
done
done
done
}
. .env-defaults
. .env
#! /bin/bash
#-*- sh-basic-offset: 2; -*-
set -ex
. scripts/helpers.bash
export_digest() {
local image_variant
local os
local os_version
local arch
local digest
local var_name
image_variant="$1"
os="$2"
os_version="$3"
arch="$4"
image_name="$(versioned_repo)-$(os_version_string "$os" "$os_version")-$arch"
if [ "$image_variant" = "build" ]; then
image_name="$image_name-build"
fi
digest="$(docker_for_arch "$arch" inspect -f "{{(index .RepoDigests 0)}}" "$image_name")"
var_name="${os}_${os_version}_${arch}_${image_variant}_digest"
var_name="${var_name//./_}"
var_name="${var_name^^}"
eval "$var_name=\"$digest\""
export "${var_name?}"
}
export ABCL_VERSION
run_for_every_tuple export_digest nonbuild
mkdir -p manifests
if [ "$(ls -A manifests)" ]; then
echo "manifests folder MUST be empty"
exit 1
fi
for i in manifest-templates/* ; do
envsubst < "$i" > "manifests/$(basename "$i")"
done
#! /bin/bash
#-*- sh-basic-offset: 2; -*-
# This was inspired heavily by
# https://github.com/linuxkit/linuxkit/blob/master/tools/alpine/push-manifest.sh
set -ex
# if [ -z "$NOTARY_DELEGATION_PASSPHRASE" ]; then
# echo "You must set NOTARY_DELEGATION_PASSPHRASE"
# exit 1
# fi
# if [ -z "$DOCKER_USERNAME" ]; then
# echo "You must set DOCKER_USERNAME"
# exit 1
# fi
# if [ -z "$DOCKER_PASSWORD" ]; then
# echo "You must set DOCKER_PASSWORD"
# exit 1
# fi
sign_manifest() {
tagged_name="$(yq r "$1" image)"
tag="${tagged_name#*:}"
repo="${tagged_name%:*}"
gun="docker.io/$repo"
sha256=$(echo "$2" | cut -d' ' -f2 | cut -d':' -f2)
size=$(echo "$2" | cut -d' ' -f3)
notary -s https://notary.docker.io -d "$HOME/.docker/trust" addhash "$gun" "$tag" "$size" --sha256 "$sha256" -r targets/releases
}
for i in manifests/* ; do
OUT="$(manifest-tool push from-spec "$i")"
#sign_manifest "$i" "$OUT"
done
#notary publish -s https://notary.docker.io -d ~/.docker/trust docker.io/daewok/abcl
#!/bin/bash
#-*- sh-basic-offset: 2; -*-
set -ex
if [ "$1" != "build" ] && [ "$1" != "nonbuild" ]; then
echo "First argument must be build or nonbuild"
exit 1
fi
. scripts/helpers.bash
push_os_version_arch() {
local image_variant
local os
local os_version
local arch
local image_name
image_variant="$1"
os="$2"
os_version="$3"
arch="$4"
image_name="$(versioned_repo)-$(os_version_string "$os" "$os_version")-$arch"
if [ "$image_variant" = "build" ]; then
image_name="$image_name-build"
fi
docker_for_arch "$arch" push "$image_name"
}
push_all_oses() {
run_for_every_tuple "push_os_version_arch" "$@"
}
push_all_oses "$1"
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment