moby/integration-cli/requirements_test.go

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"strings"
	"time"

	"github.com/docker/docker/integration-cli/requirement"
	"github.com/go-check/check"
)

func PlatformIs(platform string) bool {
	return testEnv.DaemonPlatform() == platform
}

func ArchitectureIs(arch string) bool {
	return os.Getenv("DOCKER_ENGINE_GOARCH") == arch
}

func ArchitectureIsNot(arch string) bool {
	return os.Getenv("DOCKER_ENGINE_GOARCH") != arch
}

func StorageDriverIs(storageDriver string) bool {
	return strings.HasPrefix(testEnv.DaemonStorageDriver(), storageDriver)
}

func StorageDriverIsNot(storageDriver string) bool {
	return !strings.HasPrefix(testEnv.DaemonStorageDriver(), storageDriver)
}

func DaemonIsWindows() bool {
	return PlatformIs("windows")
}

func DaemonIsWindowsAtLeastBuild(buildNumber int) func() bool {
	return func() bool {
		return DaemonIsWindows() && testEnv.DaemonKernelVersionNumeric() >= buildNumber
	}
}

func DaemonIsLinux() bool {
	return PlatformIs("linux")
}

func ExperimentalDaemon() bool {
	return testEnv.ExperimentalDaemon()
}

func NotExperimentalDaemon() bool {
	return !testEnv.ExperimentalDaemon()
}

func IsAmd64() bool {
	return ArchitectureIs("amd64")
}

func NotArm() bool {
	return ArchitectureIsNot("arm")
}

func NotArm64() bool {
	return ArchitectureIsNot("arm64")
}

func NotPpc64le() bool {
	return ArchitectureIsNot("ppc64le")
}

func NotS390X() bool {
	return ArchitectureIsNot("s390x")
}

func SameHostDaemon() bool {
	return testEnv.LocalDaemon()
}

func UnixCli() bool {
	return isUnixCli
}

func ExecSupport() bool {
	return supportsExec
}

func Network() bool {
	// Set a timeout on the GET at 15s
	var timeout = time.Duration(15 * time.Second)
	var url = "https://hub.docker.com"

	client := http.Client{
		Timeout: timeout,
	}

	resp, err := client.Get(url)
	if err != nil && strings.Contains(err.Error(), "use of closed network connection") {
		panic(fmt.Sprintf("Timeout for GET request on %s", url))
	}
	if resp != nil {
		resp.Body.Close()
	}
	return err == nil
}

func Apparmor() bool {
	buf, err := ioutil.ReadFile("/sys/module/apparmor/parameters/enabled")
	return err == nil && len(buf) > 1 && buf[0] == 'Y'
}

func NotaryHosting() bool {
	// for now notary binary is built only if we're running inside
	// container through `make test`. Figure that out by testing if
	// notary-server binary is in PATH.
	_, err := exec.LookPath(notaryServerBinary)
	return err == nil
}

func NotaryServerHosting() bool {
	// for now notary-server binary is built only if we're running inside
	// container through `make test`. Figure that out by testing if
	// notary-server binary is in PATH.
	_, err := exec.LookPath(notaryServerBinary)
	return err == nil
}

func NotOverlay() bool {
	return StorageDriverIsNot("overlay")
}

func Devicemapper() bool {
	return StorageDriverIs("devicemapper")
}

func IPv6() bool {
	cmd := exec.Command("test", "-f", "/proc/net/if_inet6")
	return cmd.Run() != nil
}

func UserNamespaceROMount() bool {
	// quick case--userns not enabled in this test run
	if os.Getenv("DOCKER_REMAP_ROOT") == "" {
		return true
	}
	if _, _, err := dockerCmdWithError("run", "--rm", "--read-only", "busybox", "date"); err != nil {
		return false
	}
	return true
}

func NotUserNamespace() bool {
	root := os.Getenv("DOCKER_REMAP_ROOT")
	return root == ""
}

func UserNamespaceInKernel() bool {
	if _, err := os.Stat("/proc/self/uid_map"); os.IsNotExist(err) {
		/*
		 * This kernel-provided file only exists if user namespaces are
		 * supported
		 */
		return false
	}

	// We need extra check on redhat based distributions
	if f, err := os.Open("/sys/module/user_namespace/parameters/enable"); err == nil {
		defer f.Close()
		b := make([]byte, 1)
		_, _ = f.Read(b)
		return string(b) != "N"
	}

	return true
}

func IsPausable() bool {
	if testEnv.DaemonPlatform() == "windows" {
		return testEnv.Isolation() == "hyperv"
	}
	return true
}

func NotPausable() bool {
	if testEnv.DaemonPlatform() == "windows" {
		return testEnv.Isolation() == "process"
	}
	return false
}

func IsolationIs(expectedIsolation string) bool {
	return testEnv.DaemonPlatform() == "windows" && string(testEnv.Isolation()) == expectedIsolation
}

func IsolationIsHyperv() bool {
	return IsolationIs("hyperv")
}

func IsolationIsProcess() bool {
	return IsolationIs("process")
}

// testRequires checks if the environment satisfies the requirements
// for the test to run or skips the tests.
func testRequires(c *check.C, requirements ...requirement.Test) {
	requirement.Is(c, requirements...)
}