update

cue.mod/pkg/universe.dagger.io/go/build.cue

@@ -0,0 +1,51 @@
+package go
+
+import (
+	"dagger.io/dagger"
+)
+
+// Build a go binary
+#Build: {
+	// Source code
+	source: dagger.#FS
+
+	// Target package to build
+	package: *"." | string
+
+	// Target architecture
+	arch: *"amd64" | string
+
+	// Target OS
+	os: *"linux" | string
+
+	// Build tags to use for building
+	tags: *"" | string
+
+	// LDFLAGS to use for linking
+	ldflags: *"" | string
+
+	env: [string]: string
+
+	container: #Container & {
+		"source": source
+		"env": {
+			env
+			GOOS:   os
+			GOARCH: arch
+		}
+		command: {
+			args: [package]
+			flags: {
+				build:      true
+				"-v":       true
+				"-tags":    tags
+				"-ldflags": ldflags
+				"-o":       "/output/"
+			}
+		}
+		export: directories: "/output": _
+	}
+
+	// Directory containing the output of the build
+	output: container.export.directories."/output"
+}

cue.mod/pkg/universe.dagger.io/go/container.cue

@@ -0,0 +1,42 @@
+// Go operation
+package go
+
+import (
+	"dagger.io/dagger"
+	"dagger.io/dagger/core"
+	"universe.dagger.io/docker"
+)
+
+// A standalone go environment to run go command
+#Container: {
+	// Container app name
+	name: *"go_builder" | string
+
+	// Source code
+	source: dagger.#FS
+
+	// Use go image
+	_image: #Image
+
+	_sourcePath: "/src"
+	_cachePath:  "/root/.cache/gocache"
+
+	docker.#Run & {
+		input:   *_image.output | docker.#Image
+		workdir: "/src"
+		command: name: "go"
+		mounts: {
+			"source": {
+				dest:     _sourcePath
+				contents: source
+			}
+			"go assets cache": {
+				contents: core.#CacheDir & {
+					id: "\(name)_assets"
+				}
+				dest: _cachePath
+			}
+		}
+		env: GOMODCACHE: _cachePath
+	}
+}

cue.mod/pkg/universe.dagger.io/go/image.cue

@@ -0,0 +1,37 @@
+package go
+
+import (
+	"universe.dagger.io/docker"
+)
+
+// Go image default version
+#DefaultVersion: "1.16"
+
+// Build a go base image
+#Image: {
+	version: *#DefaultVersion | string
+
+	packages: [pkgName=string]: version: string | *""
+
+	// FIXME Basically a copy of alpine.#Build with a different image
+	// Should we create a special definition?
+	docker.#Build & {
+		steps: [
+			docker.#Pull & {
+				source: "index.docker.io/golang:\(version)-alpine"
+			},
+			for pkgName, pkg in packages {
+				docker.#Run & {
+					command: {
+						name: "apk"
+						args: ["add", "\(pkgName)\(pkg.version)"]
+						flags: {
+							"-U":         true
+							"--no-cache": true
+						}
+					}
+				}
+			},
+		]
+	}
+}

cue.mod/pkg/universe.dagger.io/go/test.cue

@@ -0,0 +1,17 @@
+package go
+
+// Test a go package
+#Test: {
+	// Package to test
+	package: *"." | string
+
+	#Container & {
+		command: {
+			args: [package]
+			flags: {
+				test: true
+				"-v": true
+			}
+		}
+	}
+}

cue.mod/pkg/universe.dagger.io/go/test/build.cue

@@ -0,0 +1,44 @@
+package go
+
+import (
+	"dagger.io/dagger"
+	"dagger.io/dagger/core"
+	"universe.dagger.io/go"
+	"universe.dagger.io/docker"
+	"universe.dagger.io/alpine"
+)
+
+dagger.#Plan & {
+	client: filesystem: "./data/hello": read: contents: dagger.#FS
+
+	actions: test: {
+		_baseImage: alpine.#Build
+
+		simple: {
+			build: go.#Build & {
+				source: client.filesystem."./data/hello".read.contents
+			}
+
+			exec: docker.#Run & {
+				input: _baseImage.output
+				command: {
+					name: "/bin/sh"
+					args: ["-c", "/bin/hello >> /output.txt"]
+				}
+				env: NAME: "dagger"
+				mounts: binary: {
+					dest:     "/bin/hello"
+					contents: build.output
+					source:   "/test"
+				}
+			}
+
+			verify: core.#ReadFile & {
+				input: exec.output.rootfs
+				path:  "/output.txt"
+			} & {
+				contents: "Hi dagger!"
+			}
+		}
+	}
+}

cue.mod/pkg/universe.dagger.io/go/test/container.cue

@@ -0,0 +1,30 @@
+package go
+
+import (
+	"dagger.io/dagger"
+	"universe.dagger.io/go"
+	"universe.dagger.io/alpine"
+)
+
+dagger.#Plan & {
+	actions: test: {
+		_source: dagger.#Scratch & {}
+
+		simple: go.#Container & {
+			source: _source
+			command: args: ["version"]
+		}
+
+		override: {
+			base: alpine.#Build & {
+				packages: go: _
+			}
+
+			command: go.#Container & {
+				input:  base.output
+				source: _source
+				command: args: ["version"]
+			}
+		}
+	}
+}

cue.mod/pkg/universe.dagger.io/go/test/image.cue

@@ -0,0 +1,44 @@
+package go
+
+import (
+	"dagger.io/dagger"
+	"universe.dagger.io/go"
+	"universe.dagger.io/docker"
+)
+
+dagger.#Plan & {
+	actions: test: {
+		_source: dagger.#Scratch & {}
+
+		simple: {
+			_image: go.#Image & {}
+
+			verify: docker.#Run & {
+				input: _image.output
+				command: {
+					name: "/bin/sh"
+					args: ["-c", """
+							go version | grep "1.16"
+						"""]
+				}
+			}
+		}
+
+		custom: {
+			_image: go.#Image & {
+				version: "1.17"
+				packages: bash: _
+			}
+
+			verify: docker.#Run & {
+				input: _image.output
+				command: {
+					name: "/bin/bash"
+					args: ["-c", """
+							go version | grep "1.17"
+						"""]
+				}
+			}
+		}
+	}
+}

cue.mod/pkg/universe.dagger.io/go/test/test.bats

@@ -0,0 +1,12 @@
+setup() {
+    load '../../bats_helpers'
+
+    common_setup
+}
+
+@test "bash" {
+    dagger "do" -p ./build.cue test
+    dagger "do" -p ./container.cue test
+    dagger "do" -p ./image.cue test
+    dagger "do" -p ./test.cue test
+}

cue.mod/pkg/universe.dagger.io/go/test/test.cue

@@ -0,0 +1,15 @@
+package go
+
+import (
+	"dagger.io/dagger"
+	"universe.dagger.io/go"
+)
+
+dagger.#Plan & {
+	client: filesystem: "./data/hello": read: contents: dagger.#FS
+
+	actions: test: go.#Test & {
+		source:  client.filesystem."./data/hello".read.contents
+		package: "./greeting"
+	}
+}