Initial commit with support for GitHub actions

container/docker_build.go

@@ -0,0 +1,106 @@
+package container
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/builder/dockerignore"
+	"github.com/docker/docker/client"
+	"github.com/docker/docker/pkg/archive"
+	"github.com/docker/docker/pkg/fileutils"
+	"github.com/nektos/act/common"
+	log "github.com/sirupsen/logrus"
+)
+
+// NewDockerBuildExecutorInput the input for the NewDockerBuildExecutor function
+type NewDockerBuildExecutorInput struct {
+	DockerExecutorInput
+	ContextDir string
+	ImageTag   string
+}
+
+// NewDockerBuildExecutor function to create a run executor for the container
+func NewDockerBuildExecutor(input NewDockerBuildExecutorInput) common.Executor {
+	return func() error {
+		input.Logger.Infof("docker build -t %s %s", input.ImageTag, input.ContextDir)
+		if input.Dryrun {
+			return nil
+		}
+
+		cli, err := client.NewClientWithOpts()
+		if err != nil {
+			return err
+		}
+
+		input.Logger.Debugf("Building image from '%v'", input.ContextDir)
+
+		tags := []string{input.ImageTag}
+		options := types.ImageBuildOptions{
+			Tags: tags,
+		}
+
+		buildContext, err := createBuildContext(input.ContextDir, "Dockerfile")
+		if err != nil {
+			return err
+		}
+
+		defer buildContext.Close()
+
+		input.Logger.Debugf("Creating image from context dir '%s' with tag '%s'", input.ContextDir, input.ImageTag)
+		resp, err := cli.ImageBuild(input.Ctx, buildContext, options)
+		input.logDockerResponse(resp.Body, err != nil)
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+
+}
+func createBuildContext(contextDir string, relDockerfile string) (io.ReadCloser, error) {
+	log.Debugf("Creating archive for build context dir '%s' with relative dockerfile '%s'", contextDir, relDockerfile)
+
+	// And canonicalize dockerfile name to a platform-independent one
+	relDockerfile = archive.CanonicalTarNameForPath(relDockerfile)
+
+	f, err := os.Open(filepath.Join(contextDir, ".dockerignore"))
+	if err != nil && !os.IsNotExist(err) {
+		return nil, err
+	}
+	defer f.Close()
+
+	var excludes []string
+	if err == nil {
+		excludes, err = dockerignore.ReadAll(f)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// If .dockerignore mentions .dockerignore or the Dockerfile
+	// then make sure we send both files over to the daemon
+	// because Dockerfile is, obviously, needed no matter what, and
+	// .dockerignore is needed to know if either one needs to be
+	// removed. The daemon will remove them for us, if needed, after it
+	// parses the Dockerfile. Ignore errors here, as they will have been
+	// caught by validateContextDirectory above.
+	var includes = []string{"."}
+	keepThem1, _ := fileutils.Matches(".dockerignore", excludes)
+	keepThem2, _ := fileutils.Matches(relDockerfile, excludes)
+	if keepThem1 || keepThem2 {
+		includes = append(includes, ".dockerignore", relDockerfile)
+	}
+
+	compression := archive.Uncompressed
+	buildCtx, err := archive.TarWithOptions(contextDir, &archive.TarOptions{
+		Compression:     compression,
+		ExcludePatterns: excludes,
+		IncludeFiles:    includes,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return buildCtx, nil
+}

container/docker_common.go

@@ -0,0 +1,104 @@
+package container
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/sirupsen/logrus"
+)
+
+// DockerExecutorInput common input params
+type DockerExecutorInput struct {
+	Ctx    context.Context
+	Logger *logrus.Entry
+	Dryrun bool
+}
+
+type dockerMessage struct {
+	ID          string `json:"id"`
+	Stream      string `json:"stream"`
+	Error       string `json:"error"`
+	ErrorDetail struct {
+		Message string
+	}
+	Status   string `json:"status"`
+	Progress string `json:"progress"`
+}
+
+func (i *DockerExecutorInput) logDockerOutput(dockerResponse io.Reader) error {
+	scanner := bufio.NewScanner(dockerResponse)
+	if i.Logger == nil {
+		return nil
+	}
+	for scanner.Scan() {
+		i.Logger.Infof(scanner.Text())
+	}
+	return nil
+}
+
+func (i *DockerExecutorInput) streamDockerOutput(dockerResponse io.Reader) error {
+	out := os.Stdout
+	go func() {
+		<-i.Ctx.Done()
+		fmt.Println()
+	}()
+
+	_, err := io.Copy(out, dockerResponse)
+	return err
+}
+
+func (i *DockerExecutorInput) writeLog(isError bool, format string, args ...interface{}) {
+	if i.Logger == nil {
+		return
+	}
+	if isError {
+		i.Logger.Errorf(format, args...)
+	} else {
+		i.Logger.Debugf(format, args...)
+	}
+
+}
+
+func (i *DockerExecutorInput) logDockerResponse(dockerResponse io.ReadCloser, isError bool) error {
+	if dockerResponse == nil {
+		return nil
+	}
+	defer dockerResponse.Close()
+
+	scanner := bufio.NewScanner(dockerResponse)
+	msg := dockerMessage{}
+	for scanner.Scan() {
+		line := scanner.Bytes()
+		msg.ID = ""
+		msg.Stream = ""
+		msg.Error = ""
+		msg.ErrorDetail.Message = ""
+		msg.Status = ""
+		msg.Progress = ""
+		if err := json.Unmarshal(line, &msg); err == nil {
+			if msg.Error != "" {
+				return fmt.Errorf("%s", msg.Error)
+			}
+
+			if msg.Status != "" {
+				if msg.Progress != "" {
+					i.writeLog(isError, "%s :: %s :: %s\n", msg.Status, msg.ID, msg.Progress)
+				} else {
+					i.writeLog(isError, "%s :: %s\n", msg.Status, msg.ID)
+				}
+			} else if msg.Stream != "" {
+				i.writeLog(isError, msg.Stream)
+			} else {
+				i.writeLog(false, "Unable to handle line: %s", string(line))
+			}
+		} else {
+			i.writeLog(false, "Unable to unmarshal line [%s] ==> %v", string(line), err)
+		}
+	}
+
+	return nil
+}

container/docker_pull.go

@@ -0,0 +1,55 @@
+package container
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
+	"github.com/nektos/act/common"
+)
+
+// NewDockerPullExecutorInput the input for the NewDockerPullExecutor function
+type NewDockerPullExecutorInput struct {
+	DockerExecutorInput
+	Image string
+}
+
+// NewDockerPullExecutor function to create a run executor for the container
+func NewDockerPullExecutor(input NewDockerPullExecutorInput) common.Executor {
+	return func() error {
+		input.Logger.Infof("docker pull %v", input.Image)
+
+		if input.Dryrun {
+			return nil
+		}
+
+		imageRef := cleanImage(input.Image)
+		input.Logger.Debugf("pulling image '%v'", imageRef)
+
+		cli, err := client.NewClientWithOpts()
+		if err != nil {
+			return err
+		}
+
+		reader, err := cli.ImagePull(input.Ctx, imageRef, types.ImagePullOptions{})
+		input.logDockerResponse(reader, err != nil)
+		if err != nil {
+			return err
+		}
+		return nil
+
+	}
+
+}
+
+func cleanImage(image string) string {
+	imageParts := len(strings.Split(image, "/"))
+	if imageParts == 1 {
+		image = fmt.Sprintf("docker.io/library/%s", image)
+	} else if imageParts == 2 {
+		image = fmt.Sprintf("docker.io/%s", image)
+	}
+
+	return image
+}

container/docker_pull_test.go

@@ -0,0 +1,29 @@
+package container
+
+import (
+	"testing"
+
+	log "github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	log.SetLevel(log.DebugLevel)
+}
+
+func TestCleanImage(t *testing.T) {
+	tables := []struct {
+		imageIn  string
+		imageOut string
+	}{
+		{"myhost.com/foo/bar", "myhost.com/foo/bar"},
+		{"ubuntu", "docker.io/library/ubuntu"},
+		{"ubuntu:18.04", "docker.io/library/ubuntu:18.04"},
+		{"cibuilds/hugo:0.53", "docker.io/cibuilds/hugo:0.53"},
+	}
+
+	for _, table := range tables {
+		imageOut := cleanImage(table.imageIn)
+		assert.Equal(t, table.imageOut, imageOut)
+	}
+}

container/docker_run.go

@@ -0,0 +1,184 @@
+package container
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/client"
+	"github.com/nektos/act/common"
+	log "github.com/sirupsen/logrus"
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+// NewDockerRunExecutorInput the input for the NewDockerRunExecutor function
+type NewDockerRunExecutorInput struct {
+	DockerExecutorInput
+	Image      string
+	Entrypoint string
+	Cmd        []string
+	WorkingDir string
+	Env        []string
+	Binds      []string
+	Content    map[string]io.Reader
+	Volumes    []string
+	Name       string
+}
+
+// NewDockerRunExecutor function to create a run executor for the container
+func NewDockerRunExecutor(input NewDockerRunExecutorInput) common.Executor {
+	return func() error {
+
+		input.Logger.Infof("docker run %s %s", input.Image, input.Cmd)
+		if input.Dryrun {
+			return nil
+		}
+
+		cli, err := client.NewClientWithOpts()
+		if err != nil {
+			return err
+		}
+
+		containerID, err := createContainer(input, cli)
+		if err != nil {
+			return err
+		}
+		defer removeContainer(input, cli, containerID)
+
+		err = copyContentToContainer(input, cli, containerID)
+		if err != nil {
+			return err
+		}
+
+		err = attachContainer(input, cli, containerID)
+		if err != nil {
+			return err
+		}
+
+		err = startContainer(input, cli, containerID)
+		if err != nil {
+			return err
+		}
+
+		return waitContainer(input, cli, containerID)
+
+	}
+
+}
+
+func createContainer(input NewDockerRunExecutorInput, cli *client.Client) (string, error) {
+	isTerminal := terminal.IsTerminal(int(os.Stdout.Fd()))
+
+	cmd := input.Cmd
+	if len(input.Cmd) == 1 {
+		cmd = strings.Split(cmd[0], " ")
+	}
+
+	config := &container.Config{
+		Image:      input.Image,
+		Cmd:        cmd,
+		WorkingDir: input.WorkingDir,
+		Env:        input.Env,
+		Tty:        isTerminal,
+	}
+
+	if len(input.Volumes) > 0 {
+		config.Volumes = make(map[string]struct{})
+		for _, vol := range input.Volumes {
+			config.Volumes[vol] = struct{}{}
+		}
+	}
+
+	if input.Entrypoint != "" {
+		config.Entrypoint = []string{input.Entrypoint}
+	}
+	resp, err := cli.ContainerCreate(input.Ctx, config, &container.HostConfig{
+		Binds: input.Binds,
+	}, nil, input.Name)
+	if err != nil {
+		return "", err
+	}
+	input.Logger.Debugf("Created container name=%s id=%v from image %v", input.Name, resp.ID, input.Image)
+	log.Debugf("ENV ==> %v", input.Env)
+
+	return resp.ID, nil
+}
+
+func removeContainer(input NewDockerRunExecutorInput, cli *client.Client, containerID string) {
+	err := cli.ContainerRemove(context.Background(), containerID, types.ContainerRemoveOptions{
+		RemoveVolumes: true,
+		Force:         true,
+	})
+	if err != nil {
+		input.Logger.Errorf("%v", err)
+	}
+
+	input.Logger.Debugf("Removed container: %v", containerID)
+}
+
+func copyContentToContainer(input NewDockerRunExecutorInput, cli *client.Client, containerID string) error {
+	for dstPath, srcReader := range input.Content {
+		input.Logger.Debugf("Extracting content to '%s'", dstPath)
+		err := cli.CopyToContainer(input.Ctx, containerID, dstPath, srcReader, types.CopyToContainerOptions{})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func attachContainer(input NewDockerRunExecutorInput, cli *client.Client, containerID string) error {
+	out, err := cli.ContainerAttach(input.Ctx, containerID, types.ContainerAttachOptions{
+		Stream: true,
+		Stdout: true,
+		Stderr: true,
+	})
+	if err != nil {
+		return err
+	}
+	isTerminal := terminal.IsTerminal(int(os.Stdout.Fd()))
+	if !isTerminal || os.Getenv("NORAW") != "" {
+		go input.logDockerOutput(out.Reader)
+	} else {
+		go input.streamDockerOutput(out.Reader)
+	}
+	return nil
+}
+
+func startContainer(input NewDockerRunExecutorInput, cli *client.Client, containerID string) error {
+	input.Logger.Debugf("STARTING image=%s entrypoint=%s cmd=%v", input.Image, input.Entrypoint, input.Cmd)
+
+	if err := cli.ContainerStart(input.Ctx, containerID, types.ContainerStartOptions{}); err != nil {
+		return err
+	}
+
+	input.Logger.Debugf("Started container: %v", containerID)
+	return nil
+}
+
+func waitContainer(input NewDockerRunExecutorInput, cli *client.Client, containerID string) error {
+	statusCh, errCh := cli.ContainerWait(input.Ctx, containerID, container.WaitConditionNotRunning)
+	var statusCode int64
+	select {
+	case err := <-errCh:
+		if err != nil {
+			return err
+		}
+	case status := <-statusCh:
+		statusCode = status.StatusCode
+	}
+
+	input.Logger.Debugf("Return status: %v", statusCode)
+
+	if statusCode == 0 {
+		return nil
+	} else if statusCode == 78 {
+		return fmt.Errorf("exiting with `NEUTRAL`: 78")
+	}
+
+	return fmt.Errorf("exit with `FAILURE`: %v", statusCode)
+}