2018-06-04 18:25:40 +00:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
// Package testutil contains utility functions for runsc tests.
|
|
|
|
package testutil
|
|
|
|
|
|
|
|
import (
|
2018-07-26 00:36:52 +00:00
|
|
|
"context"
|
2018-06-04 18:25:40 +00:00
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2018-06-20 21:37:56 +00:00
|
|
|
"io"
|
2018-06-04 18:25:40 +00:00
|
|
|
"io/ioutil"
|
2018-08-07 20:47:16 +00:00
|
|
|
"net/http"
|
2018-06-04 18:25:40 +00:00
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"time"
|
|
|
|
|
2018-07-26 00:36:52 +00:00
|
|
|
"github.com/cenkalti/backoff"
|
2018-06-04 18:25:40 +00:00
|
|
|
specs "github.com/opencontainers/runtime-spec/specs-go"
|
|
|
|
"gvisor.googlesource.com/gvisor/runsc/boot"
|
|
|
|
"gvisor.googlesource.com/gvisor/runsc/specutils"
|
|
|
|
)
|
|
|
|
|
2018-07-23 20:30:29 +00:00
|
|
|
// RaceEnabled is set to true if it was built with '--race' option.
|
|
|
|
var RaceEnabled = false
|
|
|
|
|
2018-08-20 18:25:42 +00:00
|
|
|
// TmpDir returns the absolute path to a writable directory that can be used as
|
|
|
|
// scratch by the test.
|
|
|
|
func TmpDir() string {
|
|
|
|
dir := os.Getenv("TEST_TMPDIR")
|
|
|
|
if dir == "" {
|
|
|
|
dir = "/tmp"
|
|
|
|
}
|
|
|
|
return dir
|
|
|
|
}
|
|
|
|
|
2018-06-04 18:25:40 +00:00
|
|
|
// ConfigureExePath configures the executable for runsc in the test environment.
|
|
|
|
func ConfigureExePath() error {
|
2018-08-16 17:54:21 +00:00
|
|
|
path, err := FindFile("runsc/runsc")
|
2018-06-04 18:25:40 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-08-16 17:54:21 +00:00
|
|
|
specutils.ExePath = path
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// FindFile searchs for a file inside the test run environment. It returns the
|
|
|
|
// full path to the file. It fails if none or more than one file is found.
|
|
|
|
func FindFile(path string) (string, error) {
|
|
|
|
wd, err := os.Getwd()
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
// The test root is demarcated by a path element called "__main__". Search for
|
|
|
|
// it backwards from the in the working directory.
|
|
|
|
root := wd
|
|
|
|
for {
|
|
|
|
dir, name := filepath.Split(root)
|
|
|
|
if name == "__main__" {
|
|
|
|
break
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
2018-08-16 17:54:21 +00:00
|
|
|
if len(dir) == 0 {
|
|
|
|
return "", fmt.Errorf("directory __main__ not found in %q", wd)
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
2018-08-16 17:54:21 +00:00
|
|
|
// Remove ending slash to loop around.
|
|
|
|
root = dir[:len(dir)-1]
|
|
|
|
}
|
|
|
|
|
|
|
|
// bazel adds the build type to the directory structure. Since I don't want
|
|
|
|
// to guess what build type it's, just place '*' to match anything.
|
|
|
|
//
|
|
|
|
// The pattern goes like: /test-path/__main__/directories/*/file.
|
|
|
|
pattern := filepath.Join(root, filepath.Dir(path), "*", filepath.Base(path))
|
|
|
|
matches, err := filepath.Glob(pattern)
|
|
|
|
if err != nil {
|
|
|
|
return "", fmt.Errorf("error globbing %q: %v", pattern, err)
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
2018-08-16 17:54:21 +00:00
|
|
|
if len(matches) == 0 {
|
|
|
|
return "", fmt.Errorf("file %q not found", path)
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
2018-08-16 17:54:21 +00:00
|
|
|
if len(matches) != 1 {
|
|
|
|
return "", fmt.Errorf("more than one match found for %q: %s", path, matches)
|
|
|
|
}
|
|
|
|
return matches[0], nil
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
|
|
|
|
2018-07-23 20:30:29 +00:00
|
|
|
// TestConfig return the default configuration to use in tests.
|
|
|
|
func TestConfig() *boot.Config {
|
|
|
|
return &boot.Config{
|
|
|
|
Debug: true,
|
|
|
|
LogFormat: "text",
|
|
|
|
LogPackets: true,
|
|
|
|
Network: boot.NetworkNone,
|
|
|
|
Strace: true,
|
|
|
|
MultiContainer: true,
|
runsc: Change cache policy for root fs and volume mounts.
Previously, gofer filesystems were configured with the default "fscache"
policy, which caches filesystem metadata and contents aggressively. While this
setting is best for performance, it means that changes from inside the sandbox
may not be immediately propagated outside the sandbox, and vice-versa.
This CL changes volumes and the root fs configuration to use a new
"remote-revalidate" cache policy which tries to retain as much caching as
possible while still making fs changes visible across the sandbox boundary.
This cache policy is enabled by default for the root filesystem. The default
value for the "--file-access" flag is still "proxy", but the behavior is
changed to use the new cache policy.
A new value for the "--file-access" flag is added, called "proxy-exclusive",
which turns on the previous aggressive caching behavior. As the name implies,
this flag should be used when the sandbox has "exclusive" access to the
filesystem.
All volume mounts are configured to use the new cache policy, since it is
safest and most likely to be correct. There is not currently a way to change
this behavior, but it's possible to add such a mechanism in the future. The
configurability is a smaller issue for volumes, since most of the expensive
application fs operations (walking + stating files) will likely served by the
root fs.
PiperOrigin-RevId: 208735037
Change-Id: Ife048fab1948205f6665df8563434dbc6ca8cfc9
2018-08-14 23:24:46 +00:00
|
|
|
FileAccess: boot.FileAccessProxyExclusive,
|
2018-07-23 20:30:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-04 18:25:40 +00:00
|
|
|
// NewSpecWithArgs creates a simple spec with the given args suitable for use
|
|
|
|
// in tests.
|
|
|
|
func NewSpecWithArgs(args ...string) *specs.Spec {
|
2018-08-20 18:25:42 +00:00
|
|
|
return &specs.Spec{
|
2018-06-04 18:25:40 +00:00
|
|
|
// The host filesystem root is the container root.
|
|
|
|
Root: &specs.Root{
|
|
|
|
Path: "/",
|
|
|
|
Readonly: true,
|
|
|
|
},
|
|
|
|
Process: &specs.Process{
|
|
|
|
Args: args,
|
|
|
|
Env: []string{
|
|
|
|
"PATH=" + os.Getenv("PATH"),
|
|
|
|
},
|
|
|
|
},
|
2018-08-20 18:25:42 +00:00
|
|
|
Mounts: []specs.Mount{
|
|
|
|
// Root is readonly, but many tests want to write to tmpdir.
|
|
|
|
// This creates a writable mount inside the root. Also, when tmpdir points
|
|
|
|
// to "/tmp", it makes the the actual /tmp to be mounted and not a tmpfs
|
|
|
|
// inside the sentry.
|
|
|
|
specs.Mount{
|
|
|
|
Type: "bind",
|
|
|
|
Destination: TmpDir(),
|
|
|
|
Source: TmpDir(),
|
|
|
|
},
|
|
|
|
},
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-06 23:12:58 +00:00
|
|
|
// SetupRootDir creates a root directory for containers.
|
|
|
|
func SetupRootDir() (string, error) {
|
2018-08-20 18:25:42 +00:00
|
|
|
rootDir, err := ioutil.TempDir(TmpDir(), "containers")
|
2018-06-06 23:12:58 +00:00
|
|
|
if err != nil {
|
|
|
|
return "", fmt.Errorf("error creating root dir: %v", err)
|
|
|
|
}
|
|
|
|
return rootDir, nil
|
|
|
|
}
|
|
|
|
|
2018-06-04 18:25:40 +00:00
|
|
|
// SetupContainer creates a bundle and root dir for the container, generates a
|
|
|
|
// test config, and writes the spec to config.json in the bundle dir.
|
2018-07-23 20:30:29 +00:00
|
|
|
func SetupContainer(spec *specs.Spec, conf *boot.Config) (rootDir, bundleDir string, err error) {
|
2018-06-06 23:12:58 +00:00
|
|
|
rootDir, err = SetupRootDir()
|
2018-06-04 18:25:40 +00:00
|
|
|
if err != nil {
|
2018-07-23 20:30:29 +00:00
|
|
|
return "", "", err
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
2018-07-23 20:30:29 +00:00
|
|
|
bundleDir, err = SetupContainerInRoot(rootDir, spec, conf)
|
|
|
|
return rootDir, bundleDir, err
|
2018-06-06 23:12:58 +00:00
|
|
|
}
|
2018-06-04 18:25:40 +00:00
|
|
|
|
2018-06-06 23:12:58 +00:00
|
|
|
// SetupContainerInRoot creates a bundle for the container, generates a test
|
|
|
|
// config, and writes the spec to config.json in the bundle dir.
|
2018-07-23 20:30:29 +00:00
|
|
|
func SetupContainerInRoot(rootDir string, spec *specs.Spec, conf *boot.Config) (bundleDir string, err error) {
|
2018-08-20 18:25:42 +00:00
|
|
|
bundleDir, err = ioutil.TempDir(TmpDir(), "bundle")
|
2018-06-04 18:25:40 +00:00
|
|
|
if err != nil {
|
2018-07-23 20:30:29 +00:00
|
|
|
return "", fmt.Errorf("error creating bundle dir: %v", err)
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if err = writeSpec(bundleDir, spec); err != nil {
|
2018-07-23 20:30:29 +00:00
|
|
|
return "", fmt.Errorf("error writing spec: %v", err)
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
|
|
|
|
2018-07-23 20:30:29 +00:00
|
|
|
conf.RootDir = rootDir
|
|
|
|
return bundleDir, nil
|
2018-06-04 18:25:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// writeSpec writes the spec to disk in the given directory.
|
|
|
|
func writeSpec(dir string, spec *specs.Spec) error {
|
|
|
|
b, err := json.Marshal(spec)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return ioutil.WriteFile(filepath.Join(dir, "config.json"), b, 0755)
|
|
|
|
}
|
|
|
|
|
|
|
|
// UniqueContainerID generates a unique container id for each test.
|
|
|
|
//
|
|
|
|
// The container id is used to create an abstract unix domain socket, which must
|
|
|
|
// be unique. While the container forbids creating two containers with the same
|
|
|
|
// name, sometimes between test runs the socket does not get cleaned up quickly
|
|
|
|
// enough, causing container creation to fail.
|
|
|
|
func UniqueContainerID() string {
|
|
|
|
return fmt.Sprintf("test-container-%d", time.Now().UnixNano())
|
|
|
|
}
|
2018-06-20 21:37:56 +00:00
|
|
|
|
|
|
|
// Copy copies file from src to dst.
|
|
|
|
func Copy(src, dst string) error {
|
|
|
|
in, err := os.Open(src)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer in.Close()
|
|
|
|
|
|
|
|
out, err := os.Create(dst)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer out.Close()
|
|
|
|
|
|
|
|
_, err = io.Copy(out, in)
|
|
|
|
return err
|
|
|
|
}
|
2018-07-26 00:36:52 +00:00
|
|
|
|
|
|
|
// Poll is a shorthand function to poll for something with given timeout.
|
|
|
|
func Poll(cb func() error, timeout time.Duration) error {
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
|
|
defer cancel()
|
|
|
|
b := backoff.WithContext(backoff.NewConstantBackOff(100*time.Millisecond), ctx)
|
|
|
|
return backoff.Retry(cb, b)
|
|
|
|
}
|
2018-08-07 20:47:16 +00:00
|
|
|
|
|
|
|
// WaitForHTTP tries GET requests on a port until the call succeeds or timeout.
|
|
|
|
func WaitForHTTP(port int, timeout time.Duration) error {
|
|
|
|
cb := func() error {
|
|
|
|
_, err := http.Get(fmt.Sprintf("http://localhost:%d/", port))
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return Poll(cb, timeout)
|
|
|
|
}
|