139 lines
2.8 KiB
CUE
139 lines
2.8 KiB
CUE
// docker: build and run Docker containers
|
|
// https://docker.com
|
|
|
|
package docker
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"dagger.io/dagger"
|
|
"dagger.io/dagger/op"
|
|
)
|
|
|
|
// Run a Docker container
|
|
#Container: {
|
|
|
|
// Container image
|
|
image: dagger.#Artifact
|
|
|
|
// Independently cacheable setup commands
|
|
setup: [...string]
|
|
|
|
// Command to execute
|
|
command: string
|
|
|
|
// Environment variables shared by all commands
|
|
env: [string]: string
|
|
|
|
// Directory in which the command is executed
|
|
dir: string | *"/"
|
|
|
|
// Directory to expose as the output.
|
|
// By default the root filesystem is the output.
|
|
outputDir: string | *"/"
|
|
|
|
// If true, the command is never cached.
|
|
// (false by default).
|
|
always: true | *false
|
|
|
|
// External volumes. There are 4 types:
|
|
//
|
|
// 1. "mount": mount any artifact.
|
|
// Changes are not included in the final output.
|
|
//
|
|
// 2. "copy": copy any artifact.
|
|
// Changes are included in the final output.
|
|
//
|
|
// 3. "tmpfs": create a temporary directory.
|
|
//
|
|
// 4. "cache": create a persistent cache diretory.
|
|
//
|
|
volume: [name=string]: {
|
|
// Destination path
|
|
dest: string | *"/"
|
|
|
|
*{
|
|
type: "mount"
|
|
from: dagger.#Artifact
|
|
source: string | *"/"
|
|
} | {
|
|
type: "copy"
|
|
from: dagger.#Artifact
|
|
source: string | *"/"
|
|
} | {
|
|
type: "tmpfs" | "cache"
|
|
}
|
|
}
|
|
|
|
// Configure the shell which executes all commands.
|
|
shell: {
|
|
// Path of the shell to execute
|
|
path: string | *"/bin/sh"
|
|
// Arguments to pass to the shell prior to the command
|
|
args: [...string] | *["-c"]
|
|
// Map of directories to search for commands
|
|
// In POSIX shells this is used to generate the $PATH
|
|
// environment variable.
|
|
search: [string]: bool
|
|
search: {
|
|
"/sbin": true
|
|
"/bin": true
|
|
"/usr/sbin": true
|
|
"/usr/bin": true
|
|
"/usr/local/sbin": true
|
|
"/usr/local/bin": true
|
|
}
|
|
}
|
|
env: PATH: string | *strings.Join([ for p, v in shell.search if v {p}], ":")
|
|
|
|
// Export values from the container to the cue configuration
|
|
export: *null | {
|
|
source: string
|
|
format: op.#Export.format
|
|
}
|
|
|
|
#up: [
|
|
op.#Load & {from: image},
|
|
// Copy volumes with type=copy
|
|
for _, v in volume if v.type == "copy" {
|
|
op.#Copy & {
|
|
from: v.from
|
|
dest: v.dest
|
|
src: v.source
|
|
}
|
|
},
|
|
// Execute setup commands, then main command
|
|
for cmd in setup + [command] {
|
|
op.#Exec & {
|
|
args: [shell.path] + shell.args + [cmd]
|
|
"env": env
|
|
"dir": dir
|
|
"always": always
|
|
mount: {
|
|
for _, v in volume if v.type == "cache" {
|
|
"\(v.dest)": "cache"
|
|
}
|
|
for _, v in volume if v.type == "tmpfs" {
|
|
"\(v.dest)": "tmpfs"
|
|
}
|
|
for _, v in volume if v.type == "mount" {
|
|
"\(v.dest)": {
|
|
from: v.from
|
|
path: v.source
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
op.#Subdir & {
|
|
dir: outputDir
|
|
},
|
|
if export != null {
|
|
op.#Export & {
|
|
source: export.source
|
|
format: export.format
|
|
}
|
|
},
|
|
]
|
|
}
|