add entrypoint image

What is the problem being solved?
This PR adds an entrypoint image which is capable of running another command with some pre-run/post-run hooks.  The goal of this is to allow for the the entrypoint of a container in a Build Step to have it's entrypoint rewritten by mounting this entrypoint image into the container provided in a Step, rewriting the entrypoint, then running the user container w/ the additional pre-run/post-run hooks.  The addition of this image enables the removal of init containers as per knative#521

What future work remains to be done?
This PR adds the entrypoint image and release step.  The future work involved is modifying Build to stop using init container and use this entrypoint image as a way of making that possible.

cmd/entrypoint/main.go

@@ -0,0 +1,69 @@
+/*
+Copyright 2018 The Knative Authors.
+
+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 (
+	"os"
+
+	"github.com/knative/build/pkg/entrypoint"
+	"github.com/knative/build/pkg/entrypoint/options"
+	"github.com/sirupsen/logrus"
+	"k8s.io/test-infra/prow/logrusutil"
+)
+
+/*
+The tool is used to rewrite the entrypoint of a container image.
+To override the base shell image update `.ko.yaml` file.
+
+To use it, run
+```
+image: github.com/knative/build/cmd/entrypoint
+```
+
+It used in knative/build as a method of running containers in
+order that are in the same pod this is done by:
+1) for the Pod(containing user Steps) created by a Build,
+create a shared directory with the entrypoint binary
+2) change the entrypoint of all the user specified containers in Steps to be the
+entrypoint binary with configuration to run the user specified entrypoint with some custom logic
+3) one piece of "custom logic" is having the entrypoint binary wait for the previous step
+as seen in knative/build/pkg/entrypoint/run.go -- waitForPrevStep()
+
+Example use case:
+```
+image: github.com/build-pipeline/cmd/entrypoint
+args: ['-args', 'ARGUMENTS_FOR_SHELL_COMMAND']
+"args":["/kaniko/executor"],shouldWaitForPrevStep":false,"preRunFile":"/tools/0","shouldRunPostRun":true,"postRunFile":"/tools/1"
+```
+*/
+
+func main() {
+	o := entrypoint.NewOptions()
+	if err := options.Load(o); err != nil {
+		logrus.Fatalf("Could not resolve options: %v", err)
+	}
+
+	if err := o.Validate(); err != nil {
+		logrus.Fatalf("Invalid options: %v", err)
+	}
+
+	logrus.SetFormatter(
+		logrusutil.NewDefaultFieldsFormatter(nil, logrus.Fields{"component": "entrypoint"}),
+	)
+
+	os.Exit(o.Run())
+}

config/999-cache.yaml

@@ -24,6 +24,16 @@ spec:
 ---
 apiVersion: caching.internal.knative.dev/v1alpha1
 kind: Image
+metadata:
+  name: entrypoint
+  namespace: knative-build
+spec:
+  # This is the Go import path for the binary that is containerized
+  # and substituted here.
+  image: github.com/knative/build/cmd/entrypoint
+---
+apiVersion: caching.internal.knative.dev/v1alpha1
+kind: Image
 metadata:
   name: git-init
   namespace: knative-build

pkg/entrypoint/doc.go

@@ -0,0 +1,19 @@
+/*
+Copyright 2018 The Knative Authors.
+
+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 entrypoint is a library that knows how to wrap
+// a process and write it's output and exit code to disk
+package entrypoint

pkg/entrypoint/options.go

@@ -0,0 +1,95 @@
+/*
+Copyright 2018 The Knative Authors.
+
+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 entrypoint
+
+import (
+	"encoding/json"
+	"errors"
+	"flag"
+
+	"github.com/knative/build/pkg/entrypoint/wrapper"
+)
+
+// NewOptions returns an empty Options with no nil fields
+func NewOptions() *Options {
+	return &Options{
+		Options: &wrapper.Options{},
+	}
+}
+
+// Options exposes the configuration necessary
+// for defining the process being watched and
+// where in the image repository an upload will land.
+type Options struct {
+	// Args is the process and args to run
+	Args []string `json:"args"`
+
+	*wrapper.Options
+}
+
+// Validate ensures that the set of options are
+// self-consistent and valid
+func (o *Options) Validate() error {
+	if len(o.Args) == 0 {
+		return errors.New("no process to wrap specified")
+	}
+
+	return o.Options.Validate()
+}
+
+const (
+	// JSONConfigEnvVar is the environment variable that
+	// utilities expect to find a full JSON configuration
+	// in when run.
+	JSONConfigEnvVar = "ENTRYPOINT_OPTIONS"
+)
+
+// ConfigVar exposes the environment variable used
+// to store serialized configuration
+func (o *Options) ConfigVar() string {
+	return JSONConfigEnvVar
+}
+
+// LoadConfig loads options from serialized config
+func (o *Options) LoadConfig(config string) error {
+	return json.Unmarshal([]byte(config), o)
+}
+
+// AddFlags binds flags to options
+func (o *Options) AddFlags(flags *flag.FlagSet) {
+	flags.BoolVar(&o.ShouldWaitForPrevStep, "should-wait-for-prev-step",
+		DefaultShouldWaitForPrevStep, "If we should wait for prev step.")
+	flags.BoolVar(&o.ShouldRunPostRun, "should-run-post-run",
+		DefaultShouldRunPostRun, "If the post run step should be run after execution finishes.")
+	flags.StringVar(&o.PreRunFile, "prerun-file",
+		DefaultPreRunFile, "The path of the file that acts as a lock for the entrypoint.  The entrypoint binary will wait until that file is present to launch the specified command.")
+	flags.StringVar(&o.PostRunFile, "postrun-file",
+		DefaultPostRunFile, "The path of the file that will be written once the command finishes for the entrypoint.  This can act as a lock for other entrypoint rewritten containers.")
+	o.Options.AddFlags(flags)
+}
+
+// Complete internalizes command line arguments
+func (o *Options) Complete(args []string) {
+	o.Args = args
+}
+
+// Encode will encode the set of options in the format that
+// is expected for the configuration environment variable
+func Encode(options Options) (string, error) {
+	encoded, err := json.Marshal(options)
+	return string(encoded), err
+}

pkg/entrypoint/options/doc.go

@@ -0,0 +1,19 @@
+/*
+Copyright 2017 The Knative Authors.
+
+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 options abstracts the options loading
+// flow for pod utilities
+package options

pkg/entrypoint/options/load.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2017 The Knative Authors.
+
+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 options
+
+import (
+	"flag"
+	"fmt"
+	"os"
+)
+
+// OptionLoader allows loading options from either the environment or flags.
+type OptionLoader interface {
+	ConfigVar() string
+	LoadConfig(config string) error
+	AddFlags(flags *flag.FlagSet)
+	Complete(args []string)
+}
+
+// Load loads the set of options, preferring to use
+// JSON config from an env var, but falling back to
+// command line flags if not possible.
+func Load(loader OptionLoader) error {
+	if jsonConfig, provided := os.LookupEnv(loader.ConfigVar()); provided {
+		if err := loader.LoadConfig(jsonConfig); err != nil {
+			return fmt.Errorf("could not load config from JSON var %s: %v", loader.ConfigVar(), err)
+		}
+		return nil
+	}
+
+	fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
+	loader.AddFlags(fs)
+	fs.Parse(os.Args[1:])
+	loader.Complete(fs.Args())
+
+	return nil
+}