Created runsc and docker integration tests.

Moved some of the docker image functions to testutil.go.
Test runsc commands create, start, stop, pause, and resume.

PiperOrigin-RevId: 204138452
Change-Id: Id00bc58d2ad230db5e9e905eed942187e68e7c7b

3 files changed, 43 insertions, 285 deletions

diff --git a/runsc/test/image/image_test.go b/runsc/test/image/image_test.go
index ed2111107..04c334d92 100644
--- a/runsc/test/image/image_test.go
+++ b/runsc/test/image/image_test.go
@@ -15,7 +15,7 @@
 // Package image provides end-to-end image tests for runsc. These tests require
 // docker and runsc to be installed on the machine. To set it up, run:
 //
-//     ./runsc/test/image/install.sh [--runtime <name>]
+//     ./runsc/test/install.sh [--runtime <name>]
 //
 // The tests expect the runtime name to be provided in the RUNSC_RUNTIME
 // environment variable (default: runsc-test).
@@ -28,14 +28,8 @@ package image
 import (
 	"fmt"
 	"io/ioutil"
-	"log"
-	"math/rand"
 	"net/http"
 	"os"
-	"os/exec"
-	"path"
-	"regexp"
-	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -43,144 +37,14 @@ import (
 	"gvisor.googlesource.com/gvisor/runsc/test/testutil"
 )
 
-func init() {
-	rand.Seed(time.Now().UnixNano())
-}
-
-func runtime() string {
-	r := os.Getenv("RUNSC_RUNTIME")
-	if r == "" {
-		return "runsc-test"
-	}
-	return r
-}
-
-func mountArg(source, target string) string {
-	return fmt.Sprintf("%s:%s", source, target)
-}
-
-func linkArg(source *docker, target string) string {
-	return fmt.Sprintf("%s:%s", source.name, target)
-}
-
-// prepareFiles creates temp directory to copy files there. The sandbox doesn't
-// have access to files in the test dir.
-func prepareFiles(names ...string) (string, error) {
-	dir, err := ioutil.TempDir("", "image-test")
-	if err != nil {
-		return "", fmt.Errorf("ioutil.TempDir failed: %v", err)
-	}
-	if err := os.Chmod(dir, 0777); err != nil {
-		return "", fmt.Errorf("os.Chmod(%q, 0777) failed: %v", dir, err)
-	}
-	for _, name := range names {
-		src := getLocalPath(name)
-		dst := path.Join(dir, name)
-		if err := testutil.Copy(src, dst); err != nil {
-			return "", fmt.Errorf("testutil.Copy(%q, %q) failed: %v", src, dst, err)
-		}
-	}
-	return dir, nil
-}
-
-func getLocalPath(file string) string {
-	return path.Join(".", file)
-}
-
-type docker struct {
-	runtime string
-	name    string
-}
-
-func makeDocker(namePrefix string) docker {
-	suffix := fmt.Sprintf("-%06d", rand.Int())[:7]
-	return docker{name: namePrefix + suffix, runtime: runtime()}
-}
-
-// do executes docker command.
-func (d *docker) do(args ...string) (string, error) {
-	fmt.Printf("Running: docker %s\n", args)
-	cmd := exec.Command("docker", args...)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return "", fmt.Errorf("error executing docker %s: %v", args, err)
-	}
-	return string(out), nil
-}
-
-// run calls 'docker run' with the arguments provided.
-func (d *docker) run(args ...string) (string, error) {
-	a := []string{"run", "--runtime", d.runtime, "--name", d.name, "-d"}
-	a = append(a, args...)
-	return d.do(a...)
-}
-
-// cleanUp kills and deletes the container.
-func (d *docker) cleanUp() error {
-	if _, err := d.do("kill", d.name); err != nil {
-		return fmt.Errorf("error killing container %q: %v", d.name, err)
-	}
-	if _, err := d.do("rm", d.name); err != nil {
-		return fmt.Errorf("error deleting container %q: %v", d.name, err)
-	}
-	return nil
-}
-
-// findPort returns the host port that is mapped to 'sandboxPort'. This calls
-// docker to allocate a free port in the host and prevent conflicts.
-func (d *docker) findPort(sandboxPort int) (int, error) {
-	format := fmt.Sprintf(`{{ (index (index .NetworkSettings.Ports "%d/tcp") 0).HostPort }}`, sandboxPort)
-	out, err := d.do("inspect", "-f", format, d.name)
-	if err != nil {
-		return -1, fmt.Errorf("error retrieving port: %v", err)
-	}
-	port, err := strconv.Atoi(strings.TrimSuffix(string(out), "\n"))
-	if err != nil {
-		return -1, fmt.Errorf("error parsing port %q: %v", out, err)
-	}
-	return port, nil
-}
-
-// waitForOutput calls 'docker logs' to retrieve containers output and searches
-// for the given pattern.
-func (d *docker) waitForOutput(pattern string, timeout time.Duration) error {
-	re := regexp.MustCompile(pattern)
-	var out string
-	for exp := time.Now().Add(timeout); time.Now().Before(exp); {
-		var err error
-		out, err = d.do("logs", d.name)
-		if err != nil {
-			return err
-		}
-		if re.MatchString(out) {
-			// Success!
-			return nil
-		}
-		time.Sleep(100 * time.Millisecond)
-	}
-	return fmt.Errorf("timeout waiting for output %q: %s", re.String(), out)
-}
-
-func (d *docker) waitForHTTP(port int, timeout time.Duration) error {
-	for exp := time.Now().Add(timeout); time.Now().Before(exp); {
-		url := fmt.Sprintf("http://localhost:%d/", port)
-		if _, err := http.Get(url); err == nil {
-			// Success!
-			return nil
-		}
-		time.Sleep(100 * time.Millisecond)
-	}
-	return fmt.Errorf("timeout waiting for HTTP server on port %d", port)
-}
-
 func TestHelloWorld(t *testing.T) {
-	d := makeDocker("hello-test")
-	if out, err := d.run("hello-world"); err != nil {
+	d := testutil.MakeDocker("hello-test")
+	if out, err := d.Run("hello-world"); err != nil {
 		t.Fatalf("docker run failed: %v\nout: %s", err, out)
 	}
-	defer d.cleanUp()
+	defer d.CleanUp()
 
-	if err := d.waitForOutput("Hello from Docker!", 5*time.Second); err != nil {
+	if err := d.WaitForOutput("Hello from Docker!", 5*time.Second); err != nil {
 		t.Fatalf("docker didn't say hello: %v", err)
 	}
 }
@@ -218,27 +82,27 @@ func testHTTPServer(port int) error {
 }
 
 func TestHttpd(t *testing.T) {
-	d := makeDocker("http-test")
+	d := testutil.MakeDocker("http-test")
 
-	dir, err := prepareFiles("latin10k.txt")
+	dir, err := testutil.PrepareFiles("latin10k.txt")
 	if err != nil {
-		t.Fatalf("prepareFiles() failed: %v", err)
+		t.Fatalf("PrepareFiles() failed: %v", err)
 	}
 
 	// Start the container.
-	if out, err := d.run("-p", "80", "-v", mountArg(dir, "/usr/local/apache2/htdocs:ro"), "httpd"); err != nil {
+	if out, err := d.Run("-p", "80", "-v", testutil.MountArg(dir, "/usr/local/apache2/htdocs:ro"), "httpd"); err != nil {
 		t.Fatalf("docker run failed: %v\nout: %s", err, out)
 	}
-	defer d.cleanUp()
+	defer d.CleanUp()
 
 	// Find where port 80 is mapped to.
-	port, err := d.findPort(80)
+	port, err := d.FindPort(80)
 	if err != nil {
-		t.Fatalf("docker.findPort(80) failed: %v", err)
+		t.Fatalf("docker.FindPort(80) failed: %v", err)
 	}
 
 	// Wait until it's up and running.
-	if err := d.waitForHTTP(port, 5*time.Second); err != nil {
+	if err := d.WaitForHTTP(port, 5*time.Second); err != nil {
 		t.Fatalf("docker.WaitForHTTP() timeout: %v", err)
 	}
 
@@ -248,27 +112,27 @@ func TestHttpd(t *testing.T) {
 }
 
 func TestNginx(t *testing.T) {
-	d := makeDocker("net-test")
+	d := testutil.MakeDocker("net-test")
 
-	dir, err := prepareFiles("latin10k.txt")
+	dir, err := testutil.PrepareFiles("latin10k.txt")
 	if err != nil {
-		t.Fatalf("prepareFiles() failed: %v", err)
+		t.Fatalf("PrepareFiles() failed: %v", err)
 	}
 
 	// Start the container.
-	if out, err := d.run("-p", "80", "-v", mountArg(dir, "/usr/share/nginx/html:ro"), "nginx"); err != nil {
+	if out, err := d.Run("-p", "80", "-v", testutil.MountArg(dir, "/usr/share/nginx/html:ro"), "nginx"); err != nil {
 		t.Fatalf("docker run failed: %v\nout: %s", err, out)
 	}
-	defer d.cleanUp()
+	defer d.CleanUp()
 
 	// Find where port 80 is mapped to.
-	port, err := d.findPort(80)
+	port, err := d.FindPort(80)
 	if err != nil {
-		t.Fatalf("docker.findPort(80) failed: %v", err)
+		t.Fatalf("docker.FindPort(80) failed: %v", err)
 	}
 
 	// Wait until it's up and running.
-	if err := d.waitForHTTP(port, 5*time.Second); err != nil {
+	if err := d.WaitForHTTP(port, 5*time.Second); err != nil {
 		t.Fatalf("docker.WaitForHTTP() timeout: %v", err)
 	}
 
@@ -278,64 +142,48 @@ func TestNginx(t *testing.T) {
 }
 
 func TestMysql(t *testing.T) {
-	d := makeDocker("mysql-test")
+	d := testutil.MakeDocker("mysql-test")
 
 	// Start the container.
-	if out, err := d.run("-e", "MYSQL_ROOT_PASSWORD=foobar123", "mysql"); err != nil {
+	if out, err := d.Run("-e", "MYSQL_ROOT_PASSWORD=foobar123", "mysql"); err != nil {
 		t.Fatalf("docker run failed: %v\nout: %s", err, out)
 	}
-	defer d.cleanUp()
+	defer d.CleanUp()
 
 	// Wait until it's up and running.
-	if err := d.waitForOutput("port: 3306  MySQL Community Server", 3*time.Minute); err != nil {
+	if err := d.WaitForOutput("port: 3306  MySQL Community Server", 3*time.Minute); err != nil {
 		t.Fatalf("docker.WaitForOutput() timeout: %v", err)
 	}
 
-	client := makeDocker("mysql-client-test")
-	dir, err := prepareFiles("mysql.sql")
+	client := testutil.MakeDocker("mysql-client-test")
+	dir, err := testutil.PrepareFiles("mysql.sql")
 	if err != nil {
-		t.Fatalf("prepareFiles() failed: %v", err)
+		t.Fatalf("PrepareFiles() failed: %v", err)
 	}
 
 	// Tell mysql client to connect to the server and execute the file in verbose
 	// mode to verify the output.
 	args := []string{
-		"--link", linkArg(&d, "mysql"),
-		"-v", mountArg(dir, "/sql"),
+		"--link", testutil.LinkArg(&d, "mysql"),
+		"-v", testutil.MountArg(dir, "/sql"),
 		"mysql",
 		"mysql", "-hmysql", "-uroot", "-pfoobar123", "-v", "-e", "source /sql/mysql.sql",
 	}
-	if out, err := client.run(args...); err != nil {
+	if out, err := client.Run(args...); err != nil {
 		t.Fatalf("docker run failed: %v\nout: %s", err, out)
 	}
-	defer client.cleanUp()
+	defer client.CleanUp()
 
 	// Ensure file executed to the end and shutdown mysql.
-	if err := client.waitForOutput("--------------\nshutdown\n--------------", 15*time.Second); err != nil {
+	if err := client.WaitForOutput("--------------\nshutdown\n--------------", 15*time.Second); err != nil {
 		t.Fatalf("docker.WaitForOutput() timeout: %v", err)
 	}
-	if err := d.waitForOutput("mysqld: Shutdown complete", 30*time.Second); err != nil {
+	if err := d.WaitForOutput("mysqld: Shutdown complete", 30*time.Second); err != nil {
 		t.Fatalf("docker.WaitForOutput() timeout: %v", err)
 	}
 }
 
 func MainTest(m *testing.M) {
-	// Check correct docker is installed.
-	cmd := exec.Command("docker", "version")
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		log.Fatalf("Error running %q: %v", "docker version", err)
-	}
-	re := regexp.MustCompile(`Version:\s+(\d+)\.(\d+)\.\d.*`)
-	matches := re.FindStringSubmatch(string(out))
-	if len(matches) != 3 {
-		log.Fatalf("Invalid docker output: %s", out)
-	}
-	major, _ := strconv.Atoi(matches[1])
-	minor, _ := strconv.Atoi(matches[2])
-	if major < 17 || (major == 17 && minor < 9) {
-		log.Fatalf("Docker version 17.09.0 or greater is required, found: %02d.%02d", major, minor)
-	}
-
+	testutil.EnsureSupportedDockerVersion()
 	os.Exit(m.Run())
 }
diff --git a/runsc/test/image/install.sh b/runsc/test/image/install.sh
deleted file mode 100755
index c110d96f9..000000000
--- a/runsc/test/image/install.sh
+++ /dev/null
@@ -1,92 +0,0 @@
-#!/bin/bash
-
-# Copyright 2018 Google Inc.
-#
-# 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.
-
-# Fail on any error
-set -e
-
-# Defaults
-declare runtime=runsc-test
-declare uninstall=0
-
-function findExe() {
-  local exe=${1}
-
-  local path=$(find bazel-bin/runsc -type f -executable -name "${exe}" | head -n1)
-  if [[ "${path}" == "" ]]; then
-    echo "Location of ${exe} not found in bazel-bin" >&2
-    exit 1
-  fi
-  echo "${path}"
-}
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --runtime)
-      shift
-      [ "$#" -le 0 ] && echo "No runtime provided" && exit 1
-      runtime=$1
-      ;;
-    -u)
-      uninstall=1
-      ;;
-    *)
-      echo "Unknown option: ${1}"
-      echo ""
-      echo "Usage: ${0} [--runtime <name>] [-u]"
-      echo "  --runtime    sets the runtime name, default: runsc-test"
-      echo "  -u           uninstall the runtime"
-      exit 1
-  esac
-  shift
-done
-
-# Find location of executables.
-declare -r dockercfg=$(findExe dockercfg)
-[[ "${dockercfg}" == "" ]] && exit 1
-
-declare runsc=$(findExe runsc)
-[[ "${runsc}" == "" ]] && exit 1
-
-if [[ ${uninstall} == 0 ]]; then
-  rm -rf /tmp/${runtime}
-  mkdir -p /tmp/${runtime}
-  cp "${runsc}" /tmp/${runtime}/runsc
-  runsc=/tmp/${runtime}/runsc
-
-  # Make tmp dir and runsc binary readable and executable to all users, since it
-  # will run in an empty user namespace.
-  chmod a+rx "${runsc}" $(dirname "${runsc}")
-
-  # Make log dir executable and writable to all users for the same reason.
-  declare logdir=/tmp/"${runtime?}/logs"
-  mkdir -p "${logdir}"
-  sudo -n chmod a+wx "${logdir}"
-
-  declare -r args="--debug-log-dir "${logdir}" --debug --strace --log-packets"
-  sudo -n "${dockercfg}" runtime-add "${runtime}" "${runsc}" ${args}
-  sudo -n "${dockercfg}" runtime-add "${runtime}"-kvm "${runsc}" --platform=kvm ${args}
-  sudo -n "${dockercfg}" runtime-add "${runtime}"-hostnet "${runsc}" --network=host ${args}
-  sudo -n "${dockercfg}" runtime-add "${runtime}"-overlay "${runsc}" --overlay ${args}
-
-else
-  sudo -n "${dockercfg}" runtime-rm "${runtime}"
-  sudo -n "${dockercfg}" runtime-rm "${runtime}"-kvm
-  sudo -n "${dockercfg}" runtime-rm "${runtime}"-hostnet
-  sudo -n "${dockercfg}" runtime-rm "${runtime}"-overlay
-fi
-
-echo "Restarting docker service..."
-sudo -n /etc/init.d/docker restart
diff --git a/runsc/test/image/python_test.go b/runsc/test/image/python_test.go
index e931bb444..f0dab3989 100644
--- a/runsc/test/image/python_test.go
+++ b/runsc/test/image/python_test.go
@@ -19,23 +19,25 @@ import (
 	"net/http"
 	"testing"
 	"time"
+
+	"gvisor.googlesource.com/gvisor/runsc/test/testutil"
 )
 
 func TestPythonHello(t *testing.T) {
-	d := makeDocker("python-hello-test")
-	if out, err := d.run("-p", "8080", "google/python-hello"); err != nil {
+	d := testutil.MakeDocker("python-hello-test")
+	if out, err := d.Run("-p", "8080", "google/python-hello"); err != nil {
 		t.Fatalf("docker run failed: %v\nout: %s", err, out)
 	}
-	defer d.cleanUp()
+	defer d.CleanUp()
 
 	// Find where port 8080 is mapped to.
-	port, err := d.findPort(8080)
+	port, err := d.FindPort(8080)
 	if err != nil {
-		t.Fatalf("docker.findPort(8080) failed: %v", err)
+		t.Fatalf("docker.FindPort(8080) failed: %v", err)
 	}
 
 	// Wait until it's up and running.
-	if err := d.waitForHTTP(port, 5*time.Second); err != nil {
+	if err := d.WaitForHTTP(port, 5*time.Second); err != nil {
 		t.Fatalf("docker.WaitForHTTP() timeout: %v", err)
 	}