Initial commit with support for GitHub actions

Author: cplee

.editorconfig

@@ -0,0 +1,4 @@
+# Override for Makefile
+[{Makefile, makefile, GNUmakefile}]
+indent_style = tab
+indent_size = 4

.github/actions/check/Dockerfile

@@ -0,0 +1,10 @@
+FROM golang:1.11.4-stretch
+
+RUN go get -u honnef.co/go/tools/cmd/staticcheck
+RUN go get -u golang.org/x/lint/golint
+RUN go get -u github.com/fzipp/gocyclo
+
+COPY "entrypoint.sh" "/entrypoint.sh"
+RUN chmod +x /entrypoint.sh
+
+ENTRYPOINT ["/entrypoint.sh"]

.github/actions/check/entrypoint.sh

@@ -0,0 +1,10 @@
+#!/bin/sh 
+
+#GOPATH=/go
+#PATH=${GOPATH}/bin:/usr/local/go/bin:${PATH}
+
+go vet ./...
+golint -set_exit_status ./...
+staticcheck ./...
+gocyclo -over 10 .
+go test -cover ./...

.github/main.workflow

@@ -0,0 +1,21 @@
+workflow "check-and-release" {
+  on = "push"
+  resolves = ["release"]
+}
+
+action "check" {
+  uses = "./.github/actions/check"
+}
+
+ action "branch-filter" {
+  needs = ["check"]
+  uses = "actions/bin/filter@master"
+  args = "tag v*"
+ }
+
+ action "release" {
+  needs = ["branch-filter"]
+  uses = "docker://goreleaser/goreleaser:v0.97"
+  args = "release"
+  secrets = ["GITHUB_TOKEN"]
+ }

.gitignore

@@ -10,3 +10,6 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+
+dist/
+.todo

.goreleaser.yml

@@ -0,0 +1,37 @@
+before:
+  hooks:
+  - go mod download
+builds:
+- env:
+  - CGO_ENABLED=0
+  goos:
+  - darwin
+  - linux
+  - windows
+  goarch:
+  - amd64
+  - 386
+checksum:
+  name_template: 'checksums.txt'
+snapshot:
+  name_template: "{{ .Env.SNAPSHOT_VERSION }}"
+archive:
+  name_template: '{{ .ProjectName }}_{{ .Os }}_{{ .Arch }}'
+  replacements:
+    darwin: Darwin
+    linux: Linux
+    windows: Windows
+    386: i386
+    amd64: x86_64
+  format_overrides:
+  - goos: windows
+    format: zip
+brew:
+  github:
+    owner: nektos
+    name: homebrew-tap
+  folder: Formula
+  homepage:  https://github.com/nektos/act
+  description: Run GitHub Actions locally
+  test: |
+    system "#{bin}/act --version"

CONTRIBUTING.md

@@ -0,0 +1,67 @@
+# Contributing to Act
+
+Help wanted!  We'd love your contributions to Act.  Please review the following guidelines before contributing.  Also, feel free to propose changes to these guidelines by updating this file and submitting a pull request.
+
+* [I have a question...](#questions)
+* [I found a bug...](#bugs)
+* [I have a feature request...](#features)
+* [I have a contribution to share...](#process)
+
+## <a name="questions"></a> Have a Question?
+
+Please don't open a GitHub issue for questions about how to use `act`, as the goal is to use issues for managing bugs and feature requests.  Issues that are related to general support will be closed and redirected to our gitter room.
+
+For all support related questions, please ask the question in our gitter room: [nektos/act](https://gitter.im/nektos/act).
+
+## <a name="bugs"></a> Found a Bug?
+
+If you've identified a bug in `act`, please [submit an issue](#issue) to our GitHub repo: [nektos/act](https://github.com/nektos/act/issues/new).  Please also feel free to submit a [Pull Request](#pr) with a fix for the bug!
+
+## <a name="features"></a> Have a Feature Request?
+
+All feature requests should start with [submitting an issue](#issue) documenting the user story and acceptance criteria.  Again, feel free to submit a [Pull Request](#pr) with a proposed implementation of the feature.
+
+## <a name="process"></a> Ready to Contribute!
+
+### <a name="issue"></a> Create an issue
+
+Before submitting a new issue, please search the issues to make sure there isn't a similar issue doesn't already exist.
+
+Assuming no existing issues exist, please ensure you include the following bits of information when submitting the issue to ensure we can quickly reproduce your issue:
+
+* Version of `act`
+* Platform (Linux, OS X, Windows)
+* The complete `main.workflow` file used
+* The complete command that was executed
+* Any output from the command
+* Details of the expected results and how they differed from the actual results
+
+We may have additional questions and will communicate through the GitHub issue, so please respond back to our questions to help reproduce and resolve the issue as quickly as possible.
+
+New issues can be created with in our [GitHub repo](https://github.com/nektos/act/issues/new).
+
+### <a name="pr"></a>Pull Requests
+
+Pull requests should target the `master` branch.  Please also reference the issue from the description of the pull request using [special keyword syntax](https://help.github.com/articles/closing-issues-via-commit-messages/) to auto close the issue when the PR is merged.  For example, include the phrase `fixes #14` in the PR description to have issue #14 auto close.
+
+### <a name="style"></a> Styleguide
+
+When submitting code, please make every effort to follow existing conventions and style in order to keep the code as readable as possible.  Here are a few points to keep in mind:
+
+* Please run `go fmt ./...` before committing to ensure code aligns with go standards.
+* All dependencies must be defined in the `go.mod` file.
+* For details on the approved style, check out [Effective Go](https://golang.org/doc/effective_go.html).
+
+Also, consider the original design principles:
+
+* **Polyglot** - There will be no prescribed language or framework for developing the microservices.  The only requirement will be that the service will be run inside a container and exposed via an HTTP endpoint.
+* **Cloud Provider** - At this point, the tool will assume AWS for the cloud provider and will not be written in a cloud agnostic manner.  However, this does not preclude refactoring to add support for other providers at a later time.
+* **Declarative** - All resource administration will be handled in a declarative vs. imperative manner.  A file will be used to declared the desired state of the resources and the tool will simply assert the actual state matches the desired state.  The tool will accomplish this by generating CloudFormation templates.
+* **Stateless** - The tool will not maintain its own state.  Rather, it will rely on the CloudFormation stacks to determine the state of the platform.
+* **Secure** - All security will be managed by AWS IAM credentials.  No additional authentication or authorization mechanisms will be introduced.
+
+### License
+
+By contributing your code, you agree to license your contribution under the terms of the [MIT License](LICENSE.md).
+
+All files are released with the MIT license.

Makefile

@@ -0,0 +1,56 @@
+LATEST_VERSION := $(shell git tag -l --sort=creatordate | grep "^v[0-9]*.[0-9]*.[0-9]*$$" | tail -1 | cut -c 2-)
+ifeq "$(shell git tag -l v$(LATEST_VERSION) --points-at HEAD)" "v$(LATEST_VERSION)"
+### latest tag points to current commit, this is a release build
+VERSION ?= $(LATEST_VERSION)
+else
+### latest tag points to prior commit, this is a snapshot build
+MAJOR_VERSION := $(word 1, $(subst ., ,$(LATEST_VERSION)))
+MINOR_VERSION := $(word 2, $(subst ., ,$(LATEST_VERSION)))
+PATCH_VERSION := $(word 3, $(subst ., ,$(LATEST_VERSION)))
+VERSION ?= $(MAJOR_VERSION).$(MINOR_VERSION).$(shell echo $$(( $(PATCH_VERSION) + 1)) )-develop
+endif
+IS_SNAPSHOT = $(if $(findstring -, $(VERSION)),true,false)
+TAG_VERSION = v$(VERSION)
+
+default: check
+
+deps:
+	@GO111MODULE=off go get honnef.co/go/tools/cmd/staticcheck
+	@GO111MODULE=off go get golang.org/x/lint/golint
+	@GO111MODULE=off go get github.com/fzipp/gocyclo
+
+check:
+	go vet ./...
+	golint -set_exit_status ./...
+	staticcheck ./...
+	gocyclo -over 10 .
+	go test -cover ./...
+
+build: deps check
+	@GO111MODULE=off go get github.com/goreleaser/goreleaser
+	$(eval export SNAPSHOT_VERSION=$(VERSION))
+	@goreleaser --snapshot --rm-dist
+
+install: build
+	@cp dist/$(shell go env GOOS)_$(shell go env GOARCH)/act /usr/local/bin/act
+	@chmod 755 /usr/local/bin/act
+	@act --version
+
+installer:
+	@GO111MODULE=off go get github.com/goreleaser/godownloader
+	godownloader -r nektos/act -o install.sh
+
+
+promote: 
+	@echo "VERSION:$(VERSION) IS_SNAPSHOT:$(IS_SNAPSHOT) LATEST_VERSION:$(LATEST_VERSION)"
+ifeq (false,$(IS_SNAPSHOT))
+	@echo "Unable to promote a non-snapshot"
+	@exit 1
+endif
+ifneq ($(shell git status -s),)
+	@echo "Unable to promote a dirty workspace"
+	@exit 1
+endif
+	$(eval NEW_VERSION := $(word 1,$(subst -, , $(TAG_VERSION))))
+	git tag -a -m "releasing $(NEW_VERSION)" $(NEW_VERSION)
+	git push origin $(NEW_VERSION)

README.md

@@ -1 +1,57 @@
-# act
+[![Join the chat at https://gitter.im/nektos/act](https://badges.gitter.im/nektos/act.svg)](https://gitter.im/nektos/act?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Go Report Card](https://goreportcard.com/badge/github.com/nektos/act)](https://goreportcard.com/report/github.com/nektos/act)
+
+# Overview
+Run your [GitHub Actions](https://developer.github.com/actions/) locally!  Why would you want to do this?  Two reasons:
+
+* **Fast Feedback** - Rather than having to commit/push every time you want test out the changes you are making to your `main.workflow` file (or for any changes to embedded GitHub actions), you can use `act` to run the actions locally.  The [environment variables](https://developer.github.com/actions/creating-github-actions/accessing-the-runtime-environment/#environment-variables) and [filesystem](https://developer.github.com/actions/creating-github-actions/accessing-the-runtime-environment/#filesystem) are all configured to match what GitHub provides.
+* **Local Task Runner** - I love [make](https://en.wikipedia.org/wiki/Make_(software)).  However, I also hate repeating myself.  With `act`, you can use the GitHub Actions defined in your `main.workflow` file to replace your `Makefile`!  
+
+# How Does It Work?
+When you run `act` it reads in your GitHub Actions from `.github/main.workflow` and determines the set of actions that need to be run.  It uses the Docker API to either pull or build the necessary images, as defined in your `main.workflow` file and finally determines the execution path based on the dependencies that were defined.  Once it has the execution path, it the uses the Docker API to run containers for each action based on the images prepared earlier.  The [environment variables](https://developer.github.com/actions/creating-github-actions/accessing-the-runtime-environment/#environment-variables) and [filesystem](https://developer.github.com/actions/creating-github-actions/accessing-the-runtime-environment/#filesystem) are all configured to match what GitHub provides.
+
+Let's see it in action with a [sample repo](https://github.com/cplee/github-actions-demo)!
+
+![Demo](https://github.com/nektos/act/wiki/quickstart/act-quickstart.gif)
+
+# Installation
+To install with [Homebrew](https://brew.sh/), run: 
+
+```brew install nektos/tap/act```
+
+Alternatively, you can use the following: 
+
+```curl  https://raw.githubusercontent.com/nektos/act/master/install.sh | sudo sh```
+
+# Commands
+
+```
+# List the actions
+act -l
+
+# Run the default (`push`) event:
+act
+
+# Run a specific event:
+act pull-request
+
+# Run a specific action:
+act -t test
+
+# Run in dry-run mode:
+act -n
+```
+
+# Support
+
+Need help? Ask on [Gitter](https://gitter.im/nektos/act)!
+
+# Contributing
+
+Want to contribute to act?  Awesome!  Check out the [contributing guidelines](CONTRIBUTING.md) to get involved.
+
+## Building from source
+
+* Install Go tools 1.11+ - (https://golang.org/doc/install)
+* Clone this repo `git clone git@github.com:nektos/act.git`
+* Run unit tests with `make check`
+* Build and install: `make install`

actions/log.go

@@ -0,0 +1,109 @@
+package actions
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+type actionLogFormatter struct {
+}
+
+var formatter *actionLogFormatter
+
+func init() {
+	formatter = new(actionLogFormatter)
+}
+
+const (
+	//nocolor = 0
+	red    = 31
+	green  = 32
+	yellow = 33
+	blue   = 36
+	gray   = 37
+)
+
+func newActionLogger(actionName string, dryrun bool) *logrus.Entry {
+	logger := logrus.New()
+	logger.SetFormatter(formatter)
+	logger.SetLevel(logrus.GetLevel())
+	rtn := logger.WithFields(logrus.Fields{"action_name": actionName, "dryrun": dryrun})
+	return rtn
+}
+
+func (f *actionLogFormatter) Format(entry *logrus.Entry) ([]byte, error) {
+	b := &bytes.Buffer{}
+
+	if f.isColored(entry) {
+		f.printColored(b, entry)
+	} else {
+		f.print(b, entry)
+	}
+
+	b.WriteByte('\n')
+	return b.Bytes(), nil
+}
+
+func (f *actionLogFormatter) printColored(b *bytes.Buffer, entry *logrus.Entry) {
+	var levelColor int
+	switch entry.Level {
+	case logrus.DebugLevel, logrus.TraceLevel:
+		levelColor = gray
+	case logrus.WarnLevel:
+		levelColor = yellow
+	case logrus.ErrorLevel, logrus.FatalLevel, logrus.PanicLevel:
+		levelColor = red
+	default:
+		levelColor = blue
+	}
+
+	entry.Message = strings.TrimSuffix(entry.Message, "\n")
+	actionName := entry.Data["action_name"]
+
+	if entry.Data["dryrun"] == true {
+		fmt.Fprintf(b, "\x1b[%dm*DRYRUN* \x1b[%dm[%s] \x1b[0m%s", green, levelColor, actionName, entry.Message)
+	} else {
+		fmt.Fprintf(b, "\x1b[%dm[%s] \x1b[0m%s", levelColor, actionName, entry.Message)
+	}
+}
+
+func (f *actionLogFormatter) print(b *bytes.Buffer, entry *logrus.Entry) {
+	entry.Message = strings.TrimSuffix(entry.Message, "\n")
+	actionName := entry.Data["action_name"]
+
+	if entry.Data["dryrun"] == true {
+		fmt.Fprintf(b, "*DRYRUN* [%s] %s", actionName, entry.Message)
+	} else {
+		fmt.Fprintf(b, "[%s] %s", actionName, entry.Message)
+	}
+}
+
+func (f *actionLogFormatter) isColored(entry *logrus.Entry) bool {
+
+	isColored := checkIfTerminal(entry.Logger.Out)
+
+	if force, ok := os.LookupEnv("CLICOLOR_FORCE"); ok && force != "0" {
+		isColored = true
+	} else if ok && force == "0" {
+		isColored = false
+	} else if os.Getenv("CLICOLOR") == "0" {
+		isColored = false
+	}
+
+	return isColored
+}
+
+func checkIfTerminal(w io.Writer) bool {
+	switch v := w.(type) {
+	case *os.File:
+		return terminal.IsTerminal(int(v.Fd()))
+	default:
+		return false
+	}
+}