summaryrefslogtreecommitdiffhomepage
path: root/runsc/test/image
diff options
context:
space:
mode:
Diffstat (limited to 'runsc/test/image')
-rw-r--r--runsc/test/image/image_test.go222
-rwxr-xr-xrunsc/test/image/install.sh92
-rw-r--r--runsc/test/image/python_test.go14
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)
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-18 00:13:40 +0000