feat: wasi platform build

.github/workflows/wasi.yaml

@@ -0,0 +1,53 @@
+name: Integration test for wasi
+
+on:
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  wasi:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - ubuntu-latest
+    name: wasi
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v3
+        with:
+          go-version: 1.17
+          check-latest: true
+      - name: setup tinygo
+        shell: bash
+        env:
+          TINYGO_VERSION: 0.23.0
+        run: |
+          wget https://github.com/tinygo-org/tinygo/releases/download/v"${TINYGO_VERSION}"/tinygo_${TINYGO_VERSION}_amd64.deb
+          sudo dpkg -i tinygo_${TINYGO_VERSION}_amd64.deb
+      - name: create crun wasmedge binary
+        shell: bash
+        run: ./test/wasi/crun-wasmedge.sh
+
+      - name: Build and run ko container
+        env:
+          KO_DOCKER_REPO: ko.local
+        shell: bash
+        run: |
+          set -euxo pipefail
+
+          # Build and run the test/wasi binary, which should print "hello from wasi"
+          testimg=$(go run ./ build ./test/wasi/ --platform="wasm/wasi")
+
+          # export built image from docker into tar to load into podman
+          docker save $testimg -o testimg.tar
+
+          # run a nested podman container to use annotations (could be removed once docker is able to specify annotations on containers)
+          docker run --priviliged \
+            -v $(pwd)/testimg.tar:/tmp/testimg.tar \
+            -v /tmp/crun/crun:/usr/bin/crun \
+            quay.io/containers/podman:v4 \
+            sh -c "podman load -i /tmp/testimg.tar && podman run --runtime=/usr/bin/crun --annotations=module.wasm.image/variant=compat $testimg" \
+            | grep "hello from wasi"

.gitignore

@@ -2,3 +2,4 @@
 .idea/
 
 ko
+.vscode/

hack/install-crun-wasmedge.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+echo -e "Installing WasmEdge"
+if [ -f install.sh ]; then
+  rm -rf install.sh
+fi
+curl -L -o install.sh -q https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh
+sudo chmod a+x install.sh
+# use 0.9.1 because 0.10.0 had a breaking change which is not yet fixed in crun.
+# See https://github.com/containers/crun/pull/933
+sudo bash ./install.sh --path="/usr/local" -v 0.9.1
+rm -rf install.sh
+
+echo -e "Building and installing crun"
+sudo apt install -y make git gcc build-essential pkgconf libtool libsystemd-dev \
+    libprotobuf-c-dev libcap-dev libseccomp-dev libyajl-dev \
+    go-md2man libtool autoconf python3 automake
+
+git clone https://github.com/containers/crun /tmp/crun || true
+cd /tmp/crun
+./autogen.sh
+./configure --with-wasmedge
+make

pkg/build/gobuild.go

@@ -241,15 +241,6 @@ func getGoarm(platform v1.Platform) (string, error) {
 }
 
 func build(ctx context.Context, ip string, dir string, platform v1.Platform, config Config) (string, error) {
-	buildArgs, err := createBuildArgs(config)
-	if err != nil {
-		return "", err
-	}
-
-	args := make([]string, 0, 4+len(buildArgs))
-	args = append(args, "build")
-	args = append(args, buildArgs...)
-
 	env, err := buildEnv(platform, os.Environ(), config.Env)
 	if err != nil {
 		return "", fmt.Errorf("could not create env for %s: %w", ip, err)
@@ -279,27 +270,52 @@ func build(ctx context.Context, ip string, dir string, platform v1.Platform, con
 
 	file := filepath.Join(tmpDir, "out")
 
-	args = append(args, "-o", file)
-	args = append(args, ip)
-	cmd := exec.CommandContext(ctx, "go", args...)
-	cmd.Dir = dir
-	cmd.Env = env
-
+	goBinary := "go"
+	if platform.String() == "wasm/wasi" {
+		goBinary = "tinygo"
+	}
+	cmd, err := gobuildCommand(ctx, config, goBinary, ip, file, dir, env)
+	if err != nil {
+		return "", fmt.Errorf("creating %v build exec.Cmd: %w", goBinary, err)
+	}
 	var output bytes.Buffer
 	cmd.Stderr = &output
 	cmd.Stdout = &output
 
-	log.Printf("Building %s for %s", ip, platform)
+	log.Printf("Building %s for %v with %v", ip, platform, goBinary)
 	if err := cmd.Run(); err != nil {
 		if os.Getenv("KOCACHE") == "" {
 			os.RemoveAll(tmpDir)
 		}
-		log.Printf("Unexpected error running \"go build\": %v\n%v", err, output.String())
+		log.Printf("Unexpected error running \"%v build\": %v\n%v", goBinary, err, output.String())
 		return "", err
 	}
 	return file, nil
 }
 
+func gobuildCommand(ctx context.Context, config Config, goBinary string, ip string, outDir string, dir string, env []string) (*exec.Cmd, error) {
+	buildArgs, err := createBuildArgs(config)
+	if err != nil {
+		return nil, err
+	}
+
+	args := make([]string, 0, 4+len(buildArgs))
+	args = append(args, "build")
+	args = append(args, buildArgs...)
+	// if we are using tinygo, add wasi target
+	if goBinary == "tinygo" {
+		args = append(args, "-target", "wasi")
+	}
+
+	args = append(args, "-o", outDir)
+	args = append(args, ip)
+	cmd := exec.CommandContext(ctx, goBinary, args...)
+	cmd.Dir = dir
+	cmd.Env = env
+
+	return cmd, nil
+}
+
 func goversionm(ctx context.Context, file string, appPath string, _ v1.Image) ([]byte, types.MediaType, error) {
 	sbom := bytes.NewBuffer(nil)
 	cmd := exec.CommandContext(ctx, "go", "version", "-m", file)
@@ -689,6 +705,8 @@ func (g *gobuild) configForImportPath(ip string) Config {
 	return config
 }
 
+const wasmLayerAnnotationKey = "module.wasm.image/variant"
+
 func (g *gobuild) buildOne(ctx context.Context, refStr string, base v1.Image, platform *v1.Platform) (oci.SignedImage, error) {
 	if err := g.semaphore.Acquire(ctx, 1); err != nil {
 		return nil, err
@@ -709,6 +727,10 @@ func (g *gobuild) buildOne(ctx context.Context, refStr string, base v1.Image, pl
 		}
 	}
 
+	// disable trimpath flag because it doesn't exists in tinygo
+	if platform.String() == "wasm/wasi" {
+		g.trimpath = false
+	}
 	// Do the build into a temporary file.
 	file, err := g.build(ctx, ref.Path(), g.dir, *platform, g.configForImportPath(ref.Path()))
 	if err != nil {
@@ -720,30 +742,41 @@ func (g *gobuild) buildOne(ctx context.Context, refStr string, base v1.Image, pl
 
 	var layers []mutate.Addendum
 
-	// Create a layer from the kodata directory under this import path.
-	dataLayerBuf, err := g.tarKoData(ref, platform)
-	if err != nil {
-		return nil, err
-	}
-	dataLayerBytes := dataLayerBuf.Bytes()
-	dataLayer, err := tarball.LayerFromOpener(func() (io.ReadCloser, error) {
-		return ioutil.NopCloser(bytes.NewBuffer(dataLayerBytes)), nil
-	}, tarball.WithCompressedCaching)
-	if err != nil {
-		return nil, err
+	// don't add kodata layer into wasi image
+	if platform.String() != "wasm/wasi" {
+		// Create a layer from the kodata directory under this import path.
+		dataLayerBuf, err := g.tarKoData(ref, platform)
+		if err != nil {
+			return nil, err
+		}
+		dataLayerBytes := dataLayerBuf.Bytes()
+		dataLayer, err := tarball.LayerFromOpener(func() (io.ReadCloser, error) {
+			return ioutil.NopCloser(bytes.NewBuffer(dataLayerBytes)), nil
+		}, tarball.WithCompressedCaching)
+		if err != nil {
+			return nil, err
+		}
+		layers = append(layers, mutate.Addendum{
+			Layer: dataLayer,
+			History: v1.History{
+				Author:    "ko",
+				CreatedBy: "ko build " + ref.String(),
+				Created:   g.kodataCreationTime,
+				Comment:   "kodata contents, at $KO_DATA_PATH",
+			},
+		})
 	}
-	layers = append(layers, mutate.Addendum{
-		Layer: dataLayer,
-		History: v1.History{
-			Author:    "ko",
-			CreatedBy: "ko build " + ref.String(),
-			Created:   g.kodataCreationTime,
-			Comment:   "kodata contents, at $KO_DATA_PATH",
-		},
-	})
 
 	appDir := "/ko-app"
-	appPath := path.Join(appDir, appFilename(ref.Path()))
+	var filename string
+	if platform.String() == "wasm/wasi" {
+		// module.wasm.image/variant=compat-smart expects the entrypoint binary to be of form .wasm
+		filename = appFilename(fmt.Sprintf("%v.wasm", ref.Path()))
+	} else {
+		filename = appFilename(ref.Path())
+	}
+
+	appPath := path.Join(appDir, filename)
 
 	miss := func() (v1.Layer, error) {
 		return buildLayer(appPath, file, platform)
@@ -784,7 +817,7 @@ func (g *gobuild) buildOne(ctx context.Context, refStr string, base v1.Image, pl
 		cfg.Config.Entrypoint = []string{`C:\ko-app\` + appFilename(ref.Path())}
 		updatePath(cfg, `C:\ko-app`)
 		cfg.Config.Env = append(cfg.Config.Env, `KO_DATA_PATH=C:\var\run\ko`)
-	} else {
+	} else if platform.String() != "wasm/wasi" {
 		updatePath(cfg, appDir)
 		cfg.Config.Env = append(cfg.Config.Env, "KO_DATA_PATH="+kodataRoot)
 	}
@@ -909,7 +942,12 @@ func (g *gobuild) Build(ctx context.Context, s string) (Result, error) {
 		if !ok {
 			return nil, fmt.Errorf("failed to interpret base as image: %v", base)
 		}
-		res, err = g.buildOne(ctx, s, baseImage, nil)
+		// user specified a platform, so force this platform, even if it fails
+		var platform *v1.Platform
+		if len(g.platformMatcher.platforms) == 1 {
+			platform = &g.platformMatcher.platforms[0]
+		}
+		res, err = g.buildOne(ctx, s, baseImage, platform)
 	default:
 		return nil, fmt.Errorf("base image media type: %s", mt)
 	}

pkg/commands/config.go

@@ -34,6 +34,7 @@ import (
 	"github.com/google/go-containerregistry/pkg/name"
 	v1 "github.com/google/go-containerregistry/pkg/v1"
 	"github.com/google/go-containerregistry/pkg/v1/daemon"
+	"github.com/google/go-containerregistry/pkg/v1/empty"
 	"github.com/google/go-containerregistry/pkg/v1/google"
 	"github.com/google/go-containerregistry/pkg/v1/remote"
 
@@ -98,6 +99,15 @@ func getBaseImage(bo *options.BuildOptions) build.GetBase {
 		if bo.InsecureRegistry {
 			nameOpts = append(nameOpts, name.Insecure)
 		}
+
+		// look for wasm/wasi platform
+		for _, p := range bo.Platforms {
+			// use scratch image because wasm/wasi is not an official platform
+			if p == "wasm/wasi" {
+				// FIXME: not sure if returning a nil reference is a good idea
+				return nil, empty.Image, nil
+			}
+		}
 		ref, err := name.ParseReference(baseImage, nameOpts...)
 		if err != nil {
 			return nil, nil, fmt.Errorf("parsing base image (%q): %w", baseImage, err)

test/wasi/main.go

@@ -0,0 +1,21 @@
+// Copyright 2021 Google LLC All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello from wasi")
+}