fix: func run now uses Docker API, not binary

Signed-off-by: Matej Vasek <mvasek@redhat.com>

Author: matejvasek

client.go

@@ -1,6 +1,7 @@
 package function
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -54,7 +55,7 @@ type Deployer interface {
 // Runner runs the Function locally.
 type Runner interface {
 	// Run the Function locally.
-	Run(Function) error
+	Run(context.Context, Function) error
 }
 
 // Remover of deployed services.
@@ -444,7 +445,7 @@ func (c *Client) Route(path string) (err error) {
 }
 
 // Run the Function whose code resides at root.
-func (c *Client) Run(root string) error {
+func (c *Client) Run(ctx context.Context, root string) error {
 
 	// Create an instance of a Function representation at the given root.
 	f, err := NewFunction(root)
@@ -458,7 +459,7 @@ func (c *Client) Run(root string) error {
 	}
 
 	// delegate to concrete implementation of runner entirely.
-	return c.runner.Run(f)
+	return c.runner.Run(ctx, f)
 }
 
 // List currently deployed Functions.
@@ -527,7 +528,7 @@ func (n *noopDeployer) Deploy(_ Function) error { return nil }
 
 type noopRunner struct{ output io.Writer }
 
-func (n *noopRunner) Run(_ Function) error { return nil }
+func (n *noopRunner) Run(_ context.Context, _ Function) error { return nil }
 
 type noopRemover struct{ output io.Writer }
 

client_test.go

@@ -3,6 +3,7 @@
 package function_test
 
 import (
+	"context"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -429,7 +430,7 @@ func TestRun(t *testing.T) {
 	}
 
 	// Run the newly created function
-	if err := client.Run(root); err != nil {
+	if err := client.Run(context.Background(), root); err != nil {
 		t.Fatal(err)
 	}
 

cmd/func/main.go

@@ -1,14 +1,29 @@
 package main
 
 import (
+	"context"
 	"github.com/boson-project/func/cmd"
+	"os"
+	"os/signal"
+	"syscall"
 )
 
 // Statically-populated build metadata set
 // by `make build`.
 var date, vers, hash string
 
 func main() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		<-sigs
+		cancel()
+	}()
+
 	cmd.SetMeta(date, vers, hash)
-	cmd.Execute()
+	cmd.Execute(ctx)
 }

cmd/root.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -71,12 +72,11 @@ func init() {
 // Execute the command tree by executing the root command, which runs
 // according to the context defined by:  the optional config file,
 // Environment Variables, command arguments and flags.
-func Execute() {
+func Execute(ctx context.Context) {
 	// Sets version to a string partially populated by compile-time flags.
 	root.Version = version.String()
-
 	// Execute the root of the command tree.
-	if err := root.Execute(); err != nil {
+	if err := root.ExecuteContext(ctx); err != nil {
 		// Errors are printed to STDERR output and the process exits with code of 1.
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		os.Exit(1)

cmd/run.go

@@ -1,7 +1,9 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
+	"github.com/pkg/errors"
 
 	"github.com/ory/viper"
 	"github.com/spf13/cobra"
@@ -64,7 +66,11 @@ func runRun(cmd *cobra.Command, args []string) (err error) {
 		bosonFunc.WithRunner(runner),
 		bosonFunc.WithVerbose(config.Verbose))
 
-	return client.Run(config.Path)
+	err = client.Run(cmd.Context(), config.Path)
+	if errors.Cause(err) == context.Canceled {
+		err = nil
+	}
+	return
 }
 
 type runConfig struct {

docker/runner.go

@@ -1,11 +1,18 @@
 package docker
 
 import (
-	"errors"
+	"context"
 	"fmt"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/pkg/stdcopy"
+	"github.com/docker/go-connections/nat"
+	"github.com/pkg/errors"
 	"os"
-	"os/exec"
 	"strings"
+	"time"
+
+	"github.com/docker/docker/client"
 
 	bosonFunc "github.com/boson-project/func"
 )
@@ -22,52 +29,107 @@ func NewRunner() *Runner {
 }
 
 // Run the function at path
-func (n *Runner) Run(f bosonFunc.Function) error {
-	// Check for the docker binary explicitly so that we can return
-	// an extra-friendly error message.
-	_, err := exec.LookPath("docker")
+func (n *Runner) Run(ctx context.Context, f bosonFunc.Function) error {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
 	if err != nil {
-		return errors.New("please install 'docker'")
+		return errors.Wrap(err, "failed to create docker api client")
 	}
 
 	if f.Image == "" {
 		return errors.New("Function has no associated Image. Has it been built?")
 	}
 
-	// Extra arguments to docker
-	args := []string{"run", "--rm", "-t", "-p=8080:8080"}
-
+	envs := make([]string, 0, len(f.EnvVars)+1)
 	for name, value := range f.EnvVars {
 		if !strings.HasSuffix(name, "-") {
-			args = append(args, fmt.Sprintf("-e%s=%s", name, value))
+			envs = append(envs, fmt.Sprintf("%s=%s", name, value))
 		}
 	}
-
-	// If verbosity is enabled, pass along as an environment variable to the Function.
 	if n.Verbose {
-		args = append(args, "-e VERBOSE=true")
+		envs = append(envs, "VERBOSE=true")
 	}
-	args = append(args, f.Image)
 
-	// Set up the command with extra arguments and to run rooted at path
-	cmd := exec.Command("docker", args...)
-	cmd.Dir = f.Root
+	ports := map[nat.Port][]nat.PortBinding{
+		nat.Port("8080/tcp"): {
+			nat.PortBinding{
+				HostPort: "8080",
+				HostIP:   "127.0.0.1",
+			},
+		},
+	}
 
-	// If verbose logging is enabled, echo command
-	if n.Verbose {
-		fmt.Println(cmd)
+	conf := &container.Config{
+		Env:          envs,
+		Tty:          false,
+		AttachStderr: true,
+		AttachStdout: true,
+		AttachStdin:  false,
+		Image:        f.Image,
+	}
+
+	hostConf := &container.HostConfig{
+		PortBindings: ports,
+	}
+
+	cont, err := cli.ContainerCreate(ctx, conf, hostConf, nil, nil, "")
+	if err != nil {
+		return errors.Wrap(err, "failed to create container")
+	}
+	defer func() {
+		err := cli.ContainerRemove(context.Background(), cont.ID, types.ContainerRemoveOptions{})
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to remove container: %v", err)
+		}
+	}()
+
+	attachOptions := types.ContainerAttachOptions{
+		Stdout: true,
+		Stderr: true,
+		Stdin:  false,
+		Stream: true,
+	}
+
+	resp, err := cli.ContainerAttach(ctx, cont.ID, attachOptions)
+	if err != nil {
+		return errors.Wrap(err, "failed to attach container")
+	}
+	defer resp.Close()
+
+	copyErrChan := make(chan error, 1)
+	go func() {
+		_, err := stdcopy.StdCopy(os.Stdout, os.Stderr, resp.Reader)
+		copyErrChan <- err
+	}()
+
+	waitBodyChan, waitErrChan := cli.ContainerWait(ctx, cont.ID, container.WaitConditionNextExit)
+
+	err = cli.ContainerStart(ctx, cont.ID, types.ContainerStartOptions{})
+	if err != nil {
+		return errors.Wrap(err, "failed to start container")
+	}
+	defer func() {
+		t := time.Second * 10
+		err := cli.ContainerStop(context.Background(), cont.ID, &t)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to stop container: %v", err)
+		}
+	}()
+
+	select {
+	case body := <-waitBodyChan:
+		if body.StatusCode != 0 {
+			return fmt.Errorf("failed with status code: %d", body.StatusCode)
+		}
+	case err := <-waitErrChan:
+		return err
+	case err := <-copyErrChan:
+		return err
+	case <-ctx.Done():
+		return ctx.Err()
 	}
 
-	// We need to show the user all output, so a method to squelch
-	// docker's chattiness is not immediately apparent.
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	// Run the command, echoing captured stderr as well ass the cmd internal error.
-	// Will run until explicitly canceled.
-	// TODO: this runner is current stubbed pending an architectural discussion
-	// on how closely we would like to emulate the previous funcitonality, and
-	// if we can use Grid as a localhost integraiton events fabric.
-	fmt.Println(cmd)
-	return cmd.Run()
+	return nil
 }

docker/runner_test.go

@@ -3,6 +3,7 @@
 package docker_test
 
 import (
+	"context"
 	"flag"
 	"fmt"
 	"os"
@@ -35,7 +36,7 @@ func TestDockerRun(t *testing.T) {
 
 	runner := docker.NewRunner()
 	runner.Verbose = true
-	if err = runner.Run(f); err != nil {
+	if err = runner.Run(context.Background(), f); err != nil {
 		t.Fatal(err)
 	}
 	/* TODO

go.mod

@@ -4,9 +4,12 @@ go 1.14
 
 require (
 	github.com/buildpacks/pack v0.17.1-0.20210221000942-0c84b4ae7a30
+	github.com/docker/docker v20.10.0-beta1.0.20201110211921-af34b94a78a1+incompatible
+	github.com/docker/go-connections v0.4.0
 	github.com/markbates/pkger v0.17.1
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/ory/viper v1.7.4
+	github.com/pkg/errors v0.9.1
 	github.com/spf13/cobra v1.1.3
 	gopkg.in/yaml.v2 v2.4.0
 	k8s.io/api v0.18.12

mock/runner.go

@@ -1,6 +1,9 @@
 package mock
 
-import bosonFunc "github.com/boson-project/func"
+import (
+	"context"
+	bosonFunc "github.com/boson-project/func"
+)
 
 type Runner struct {
 	RunInvoked    bool
@@ -11,7 +14,7 @@ func NewRunner() *Runner {
 	return &Runner{}
 }
 
-func (r *Runner) Run(f bosonFunc.Function) error {
+func (r *Runner) Run(ctx context.Context, f bosonFunc.Function) error {
 	r.RunInvoked = true
 	r.RootRequested = f.Root
 	return nil

plugin/plugin.go

@@ -1,9 +1,12 @@
 package plugin
 
 import (
+	"context"
 	"os"
+	"os/signal"
 	"runtime/debug"
 	"strings"
+	"syscall"
 
 	"knative.dev/client/pkg/kn/plugin"
 
@@ -21,6 +24,17 @@ func (f *funcPlugin) Name() string {
 }
 
 func (f *funcPlugin) Execute(args []string) error {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		<-sigs
+		cancel()
+	}()
+
 	rootCmd := cmd.NewRootCmd()
 	info, _ := debug.ReadBuildInfo()
 	for _, dep := range info.Deps {
@@ -33,7 +47,7 @@ func (f *funcPlugin) Execute(args []string) error {
 		os.Args = oldArgs
 	})()
 	os.Args = append([]string{"kn-func"}, args...)
-	return rootCmd.Execute()
+	return rootCmd.ExecuteContext(ctx)
 }
 
 // Description for function subcommand visible in 'kn --help'