Pass bucket and repo as args to tests

To allow contributors to run the integration tests with their own GCS
buckets and image repos (since not all contributors will have accesss to
the projects used by the kaniko maintainers) this updates the
integration tests so that these can be provided on the command line.

This allows tests to be run individually, without using `make
integration-test`. Previously, part of the test setup was done
in the shell script (creating the context tarball that is required
for the tests that build images with context). Instead it will be
done in the test iself, so we can use `go test` to run tests
individually if we want to.

If we are running only one individual test, we don't want to build
all of the images, so this commit creates a builder which tracks which
images it has built and can be used by a tests to check if it should
build an image before running, or it will use the images that have
already been built by a previous test.

The name of the context tarball has also been made unique (it includes
the unix timestamp) to avoid potential test flakes if two tests using
the same GCS bucket run simultaneously.

DEVELOPMENT.md

@@ -70,12 +70,32 @@ _These tests will not run correctly unless you have [checked out your fork into
 The integration tests live in [`integration`](./integration) and can be run with:
 
 ```shell
+export GCS_BUCKET="gs://<your bucket>"
+export IMAGE_REPO="gcr.io/somerepo"
 make integration-test
 ```
 
-_These tests require push access to a project in GCP, and so can only be run
-by maintainers who have access. These tests will be kicked off by [reviewers](#reviews)
-for submitted PRs._
+If you want to run `make integration-test`, you must override the project using environment variables:
+
+* `GCS_BUCKET` - The name of your GCS bucket
+* `IMAGE_REPO` - The path to your docker image repo
+
+You can also run tests with `go test`, for example to run tests individually:
+
+```shell
+go test -v --bucket $GCS_BUCKET --repo $IMAGE_REPO -run TestLayers/test_layer_Dockerfile_test_copy_bucket
+```
+
+Requirements:
+
+* [`gcloud`](https://cloud.google.com/sdk/install)
+* [`gsutil`](https://cloud.google.com/storage/docs/gsutil_install)
+* [`container-diff`](https://github.com/GoogleContainerTools/container-diff#installation)
+* A bucket in [GCS](https://cloud.google.com/storage/) which you have write access to via
+  the user currently logged into `gcloud`
+* An image repo which you have write access to via the user currently logged into `gcloud`
+
+These tests will be kicked off by [reviewers](#reviews) for submitted PRs.
 
 ## Creating a PR
 

integration-test.sh

@@ -15,6 +15,10 @@
 #!/bin/bash
 set -ex
 
+GCS_BUCKET="${GCS_BUCKET:-gs://kaniko-test-bucket}"
+IMAGE_REPO="${IMAGE_REPO:-gcr.io/kaniko-test}"
+
+# Sets up a kokoro (Google internal integration testing tool) environment
 if [ -f "$KOKORO_GFILE_DIR"/common.sh ]; then
     echo "Installing dependencies..."
     source "$KOKORO_GFILE_DIR/common.sh"
@@ -28,12 +32,7 @@ if [ -f "$KOKORO_GFILE_DIR"/common.sh ]; then
     cp $KOKORO_ROOT/src/keystore/72508_gcr_application_creds $HOME/.config/gcloud/application_default_credentials.json
 fi
 
-echo "Creating build context tarball..."
-tar  -C ./integration -zcvf context.tar.gz .
-gsutil cp context.tar.gz gs://kaniko-test-bucket
-rm context.tar.gz
-
 echo "Running integration tests..."
 make out/executor
 pushd integration
-go test
+go test -v --bucket "${GCS_BUCKET}" --repo "${IMAGE_REPO}"

integration/cleanup.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2018 Google LLC
+
+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 integration
+
+import (
+	"log"
+	"os"
+	"os/signal"
+)
+
+// RunOnInterrupt will execute the function f if execution is interrupted with the
+// interrupt signal.
+func RunOnInterrupt(f func()) {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+	go func() {
+		for range c {
+			log.Println("Interrupted, cleaning up.")
+			f()
+			os.Exit(1)
+		}
+	}()
+}

integration/cmd.go

@@ -0,0 +1,48 @@
+/*
+Copyright 2018 Google LLC
+
+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 integration
+
+import (
+	"fmt"
+	"os/exec"
+	"testing"
+)
+
+// RunCommandWithoutTest will run cmd and if it fails will output relevant info
+// for debugging before returning an error. It can be run outside the context of a test.
+func RunCommandWithoutTest(cmd *exec.Cmd) ([]byte, error) {
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		fmt.Println(cmd.Args)
+		fmt.Println(string(output))
+	}
+	return output, nil
+}
+
+// RunCommand will run cmd and if it fails will output relevant info for debugging
+// before it fails. It must be run within the context of a test t and if the command
+// fails, it will the test. Returns the output from the command.
+func RunCommand(cmd *exec.Cmd, t *testing.T) []byte {
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Log(cmd.Args)
+		t.Log(string(output))
+		t.Error(err)
+		t.FailNow()
+	}
+	return output
+}

integration/gcs.go

@@ -0,0 +1,73 @@
+/*
+Copyright 2018 Google LLC
+
+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 integration
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+)
+
+// CreateIntegrationTarball will take the contents of the integration directory and write
+// them to a tarball in a temmporary dir. It will return a path to the tarball.
+func CreateIntegrationTarball() (string, error) {
+	log.Println("Creating tarball of integration test files to use as build context")
+	dir, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("Failed find path to integration dir: %s", err)
+	}
+	tempDir, err := ioutil.TempDir("", "")
+	if err != nil {
+		return "", fmt.Errorf("Failed to create temporary directoy to hold tarball: %s", err)
+	}
+	contextFile := fmt.Sprintf("%s/context_%d.tar.gz", tempDir, time.Now().UnixNano())
+	cmd := exec.Command("tar", "-C", dir, "-zcvf", contextFile, ".")
+	_, err = RunCommandWithoutTest(cmd)
+	if err != nil {
+		return "", fmt.Errorf("Failed to create build context tarball from integration dir: %s", err)
+	}
+	return contextFile, err
+}
+
+// UploadFileToBucket will upload the at filePath to gcsBucket. It will return the path
+// of the file in gcsBucket.
+func UploadFileToBucket(gcsBucket string, filePath string) (string, error) {
+	log.Printf("Uploading file at %s to GCS bucket at %s\n", filePath, gcsBucket)
+
+	cmd := exec.Command("gsutil", "cp", filePath, gcsBucket)
+	_, err := RunCommandWithoutTest(cmd)
+	if err != nil {
+		return "", fmt.Errorf("Failed to copy tarball to GCS bucket %s: %s", gcsBucket, err)
+	}
+
+	return filepath.Join(gcsBucket, filePath), err
+}
+
+// DeleteFromBucket will remove the content at path. path should be the full path
+// to a file in GCS.
+func DeleteFromBucket(path string) error {
+	cmd := exec.Command("gsutil", "rm", path)
+	_, err := RunCommandWithoutTest(cmd)
+	if err != nil {
+		return fmt.Errorf("Failed to delete file %s from GCS: %s", path, err)
+	}
+	return err
+}