#!/usr/bin/env -S make -f
# Demonstrates importing a docker image, then using scaffolded targets
# Part of the `compose.mk` repo. This file runs as part of the test-suite.
# USAGE: demos/import-image.mk

include compose.mk

$(call docker.import, namespace=debian img=debian/buildd:bookworm)

__main__: test.dispatch test.low_level_runner

test.dispatch: debian.dispatch/flux.ok

test.low_level_runner:
    entrypoint=sh cmd='-c "echo hello-world"' ${make} debian

#!/usr/bin/env -S make -f
# Demonstrates inlining a Dockerfile, 
# building it, then working with the container.
#
# Part of the `compose.mk` repo, runs as part of the test-suite.
#
# USAGE: ./demos/inlined-dockerfile.mk

include compose.mk

# Minimal inlined dockerfile.  
# You can install anything or nothing here, but let's 
# have the minimal stuff that's required for using target dispatch.
define Dockerfile.demo_dockerfile
FROM ${IMG_ALPINE_BASE:-alpine:3.21.2}
RUN apk add -q --update --no-cache coreutils build-base bash procps-ng
endef

# After build, image is always at 'compose.mk:<def_name>'.
# This "absolute" name is expected by `docker.*` targets, 
# but the prefix is implied for `mk.docker.*`.
inlined_img=compose.mk:demo_dockerfile

# Entrypoint.  Ensures the container is built, then runs all the tests.
__main__: Dockerfile.build/demo_dockerfile flux.star/test

test.1.image_created_and_available:
    $(call log.test, Image is created and available to docker)
    docker image inspect ${inlined_img} > /dev/null
    docker run --entrypoint sh ${inlined_img} -x -c "true" > /dev/null

test.2.mk.docker.dispatch:
    $(call log.test, Omits image prefix & does target-dispatch)
    img=demo_dockerfile ${make} mk.docker.dispatch/self.demo.dispatch
self.demo.dispatch:
    printf "Running inside the inlined-container:\n"
    uname -a

test.3.docker.dispatch:
    $(call log.test, Expects image prefix & accepts targets)
    img=${inlined_img} ${make} docker.dispatch/self.demo.dispatch

test.4.docker.run.sh:
    $(call log.test, Low-level access to container)
    entrypoint=sh cmd='-c "pwd"' \
        img=${inlined_img} ${make} docker.run.sh 

test.5.build.cache_busting:
    $(call log.test, Caching by default. Pass force=1 to override)
    force=1 ${make} Dockerfile.build/demo_dockerfile

test.6.quiet_build:
    $(call log.test, Dockerfile.build silent by default. Pass quiet=0 to override)
    quiet=0 force=1 ${make} Dockerfile.build/demo_dockerfile

test.7.docker.lambda.target:
    $(call log.test, Builds/runs Dockerfile in 1 step with docker.lambda)
    cmd='pwd' ${make} docker.lambda/demo_dockerfile

#!/usr/bin/env -S make -f
# Demonstrating idioms for container-agnostic script dispatch with stock images.
# The target script always runs from the container, but does not care whether 
# it's called from the host, or inside the container.
#
# Part of the `compose.mk` repo. This file runs as part of the test-suite.  
# See also: http://robot-wranglers.github.io/compose.mk/container-dispatch
#
# USAGE: ./demos/script-dispatch-stock.mk

include compose.mk

img=debian/buildd:bookworm

__main__: script.sh wrapper_script

# Create target from the implied script and the given image
script.sh:; $(call docker.bind.script, img=${img})
define script.sh
echo hello `hostname` at `uname -a`
endef

# If target and script name differ, provide 2nd argument
wrapper_script:; $(call docker.bind.script, img=${img} def=script.sh)

#!/usr/bin/env -S make -f
# Demonstrating idioms for container-agnostic script dispatch with stock images.
# The target script always runs from the container, but does not care whether 
# it's called from the host, or inside the container.
#
# Part of the `compose.mk` repo. This file runs as part of the test-suite.  
# See also: http://robot-wranglers.github.io/compose.mk/container-dispatch
#
# USAGE: ./demos/script-dispatch-custom.mk

include compose.mk
__main__: my_script 

# Look, it's a container definition 
define Dockerfile.my_container
FROM debian/buildd:bookworm
# .. Other customization here .. 
endef

# Look, it's a script to run in the container 
define my_script
echo hello `hostname` at `uname -a`
endef

# Binds the given target to the given container + implied script
my_script:; $(call mk.docker.bind.script, img=my_container)

# If script and target names differ, provide `def` argument
script_wrapper:; $(call mk.docker.bind.script, img=my_container def=my_script)