6db32fde |
package main
import ( |
ba5e0980 |
"bufio" |
c8a3d313 |
"bytes" |
f6a037d4 |
"crypto/tls" |
c8a3d313 |
"encoding/json" |
054b921a |
"errors" |
6db32fde |
"fmt" |
5b27fbc0 |
"io" |
2e855688 |
"io/ioutil" |
054b921a |
"net" |
2e855688 |
"net/http"
"net/http/httptest" |
054b921a |
"net/http/httputil" |
e1ef3344 |
"net/url" |
2e855688 |
"os" |
6db32fde |
"os/exec" |
2e855688 |
"path" |
5b0d4cf2 |
"path/filepath" |
77f54252 |
"strconv" |
6db32fde |
"strings" |
054b921a |
"time" |
ed345fb1 |
|
4b9fe9c2 |
"github.com/docker/docker/opts" |
da44d0fc |
"github.com/docker/docker/pkg/httputils" |
7efa0f37 |
"github.com/docker/docker/pkg/integration" |
8232cc77 |
"github.com/docker/docker/pkg/ioutils" |
b80fae73 |
"github.com/docker/docker/pkg/stringutils" |
907407d0 |
"github.com/docker/engine-api/types" |
8e034802 |
"github.com/docker/go-connections/sockets"
"github.com/docker/go-connections/tlsconfig" |
dc944ea7 |
"github.com/go-check/check" |
6db32fde |
)
|
44da8617 |
func init() {
out, err := exec.Command(dockerBinary, "images").CombinedOutput()
if err != nil {
panic(err)
}
lines := strings.Split(string(out), "\n")[1:]
for _, l := range lines {
if l == "" {
continue
}
fields := strings.Fields(l)
imgTag := fields[0] + ":" + fields[1]
// just for case if we have dangling images in tested daemon
if imgTag != "<none>:<none>" {
protectedImages[imgTag] = struct{}{}
}
}
// Obtain the daemon platform so that it can be used by tests to make
// intelligent decisions about how to configure themselves, and validate
// that the target platform is valid.
res, _, err := sockRequestRaw("GET", "/version", nil, "application/json")
if err != nil || res == nil || (res != nil && res.StatusCode != http.StatusOK) {
panic(fmt.Errorf("Init failed to get version: %v. Res=%v", err.Error(), res))
}
svrHeader, _ := httputils.ParseServerHeader(res.Header.Get("Server"))
daemonPlatform = svrHeader.OS
if daemonPlatform != "linux" && daemonPlatform != "windows" {
panic("Cannot run tests against platform: " + daemonPlatform)
}
// On Windows, extract out the version as we need to make selective
// decisions during integration testing as and when features are implemented.
if daemonPlatform == "windows" {
if body, err := ioutil.ReadAll(res.Body); err == nil {
var server types.Version
if err := json.Unmarshal(body, &server); err == nil {
// eg in "10.0 10550 (10550.1000.amd64fre.branch.date-time)" we want 10550
windowsDaemonKV, _ = strconv.Atoi(strings.Split(server.KernelVersion, " ")[1])
}
}
}
// Now we know the daemon platform, can set paths used by tests.
_, body, err := sockRequest("GET", "/info", nil)
if err != nil {
panic(err)
}
var info types.Info
err = json.Unmarshal(body, &info)
dockerBasePath = info.DockerRootDir
volumesConfigPath = filepath.Join(dockerBasePath, "volumes")
containerStoragePath = filepath.Join(dockerBasePath, "containers") |
1847641b |
// Make sure in context of daemon, not the local platform. Note we can't
// use filepath.FromSlash or ToSlash here as they are a no-op on Unix.
if daemonPlatform == "windows" {
volumesConfigPath = strings.Replace(volumesConfigPath, `/`, `\`, -1)
containerStoragePath = strings.Replace(containerStoragePath, `/`, `\`, -1)
} else {
volumesConfigPath = strings.Replace(volumesConfigPath, `\`, `/`, -1)
containerStoragePath = strings.Replace(containerStoragePath, `\`, `/`, -1)
} |
44da8617 |
}
|
054b921a |
// Daemon represents a Docker daemon for the testing framework.
type Daemon struct { |
e7fc6321 |
// Defaults to "daemon" |
51462327 |
// Useful to set to --daemon or -d for checking backwards compatibility |
e7fc6321 |
Command string
GlobalFlags []string
|
fbb01b81 |
id string
c *check.C
logFile *os.File
folder string
root string
stdin io.WriteCloser
stdout, stderr io.ReadCloser
cmd *exec.Cmd
storageDriver string
wait chan error
userlandProxy bool
useDefaultHost bool
useDefaultTLSHost bool
}
type clientConfig struct {
transport *http.Transport
scheme string
addr string |
44de5fec |
}
|
054b921a |
// NewDaemon returns a Daemon instance to be used for testing. |
54ac3d9c |
// This will create a directory such as d123456789 in the folder specified by $DEST. |
054b921a |
// The daemon will not automatically start. |
dc944ea7 |
func NewDaemon(c *check.C) *Daemon { |
054b921a |
dest := os.Getenv("DEST") |
a1d4b7dd |
c.Assert(dest, check.Not(check.Equals), "", check.Commentf("Please set the DEST environment variable")) |
054b921a |
|
e7fc6321 |
id := fmt.Sprintf("d%d", time.Now().UnixNano()%100000000)
dir := filepath.Join(dest, id) |
054b921a |
daemonFolder, err := filepath.Abs(dir) |
a1d4b7dd |
c.Assert(err, check.IsNil, check.Commentf("Could not make %q an absolute path", dir)) |
442b4562 |
daemonRoot := filepath.Join(daemonFolder, "root") |
054b921a |
|
a1d4b7dd |
c.Assert(os.MkdirAll(daemonRoot, 0755), check.IsNil, check.Commentf("Could not create daemon root %q", dir)) |
054b921a |
|
50d7fba7 |
userlandProxy := true |
44de5fec |
if env := os.Getenv("DOCKER_USERLANDPROXY"); env != "" {
if val, err := strconv.ParseBool(env); err != nil {
userlandProxy = val
}
}
|
054b921a |
return &Daemon{ |
e7fc6321 |
Command: "daemon",
id: id, |
dc944ea7 |
c: c, |
054b921a |
folder: daemonFolder, |
442b4562 |
root: daemonRoot, |
054b921a |
storageDriver: os.Getenv("DOCKER_GRAPHDRIVER"), |
44de5fec |
userlandProxy: userlandProxy, |
054b921a |
}
}
|
fbb01b81 |
func (d *Daemon) getClientConfig() (*clientConfig, error) {
var (
transport *http.Transport
scheme string
addr string
proto string
)
if d.useDefaultTLSHost {
option := &tlsconfig.Options{
CAFile: "fixtures/https/ca.pem",
CertFile: "fixtures/https/client-cert.pem",
KeyFile: "fixtures/https/client-key.pem",
}
tlsConfig, err := tlsconfig.Client(*option)
if err != nil {
return nil, err
}
transport = &http.Transport{
TLSClientConfig: tlsConfig,
}
addr = fmt.Sprintf("%s:%d", opts.DefaultHTTPHost, opts.DefaultTLSHTTPPort)
scheme = "https"
proto = "tcp"
} else if d.useDefaultHost {
addr = opts.DefaultUnixSocket
proto = "unix"
scheme = "http"
transport = &http.Transport{}
} else {
addr = filepath.Join(d.folder, "docker.sock")
proto = "unix"
scheme = "http"
transport = &http.Transport{}
}
sockets.ConfigureTCPTransport(transport, proto, addr)
return &clientConfig{
transport: transport,
scheme: scheme,
addr: addr,
}, nil
}
|
054b921a |
// Start will start the daemon and return once it is ready to receive requests. |
39310448 |
// You can specify additional daemon flags. |
054b921a |
func (d *Daemon) Start(arg ...string) error {
dockerBinary, err := exec.LookPath(dockerBinary) |
a1d4b7dd |
d.c.Assert(err, check.IsNil, check.Commentf("[%s] could not find docker binary in $PATH", d.id)) |
054b921a |
|
e7fc6321 |
args := append(d.GlobalFlags,
d.Command, |
442b4562 |
"--graph", d.root, |
054b921a |
"--pidfile", fmt.Sprintf("%s/docker.pid", d.folder), |
44de5fec |
fmt.Sprintf("--userland-proxy=%t", d.userlandProxy), |
e7fc6321 |
) |
fbb01b81 |
if !(d.useDefaultHost || d.useDefaultTLSHost) { |
e38767e1 |
args = append(args, []string{"--host", d.sock()}...)
} |
ea3afdad |
if root := os.Getenv("DOCKER_REMAP_ROOT"); root != "" { |
a85e6a4d |
args = append(args, []string{"--userns-remap", root}...) |
ea3afdad |
}
|
2facc046 |
// If we don't explicitly set the log-level or debug flag(-D) then
// turn on debug mode
foundIt := false
for _, a := range arg { |
e7fc6321 |
if strings.Contains(a, "--log-level") || strings.Contains(a, "-D") || strings.Contains(a, "--debug") { |
2facc046 |
foundIt = true
}
}
if !foundIt {
args = append(args, "--debug")
}
|
39310448 |
if d.storageDriver != "" {
args = append(args, "--storage-driver", d.storageDriver)
}
|
054b921a |
args = append(args, arg...)
d.cmd = exec.Command(dockerBinary, args...)
|
2facc046 |
d.logFile, err = os.OpenFile(filepath.Join(d.folder, "docker.log"), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0600) |
a1d4b7dd |
d.c.Assert(err, check.IsNil, check.Commentf("[%s] Could not create %s/docker.log", d.id, d.folder)) |
054b921a |
d.cmd.Stdout = d.logFile
d.cmd.Stderr = d.logFile
if err := d.cmd.Start(); err != nil { |
e7fc6321 |
return fmt.Errorf("[%s] could not start daemon container: %v", d.id, err) |
054b921a |
}
|
defe01da |
wait := make(chan error) |
054b921a |
go func() { |
defe01da |
wait <- d.cmd.Wait() |
e7fc6321 |
d.c.Logf("[%s] exiting daemon", d.id) |
defe01da |
close(wait) |
054b921a |
}()
|
defe01da |
d.wait = wait
|
054b921a |
tick := time.Tick(500 * time.Millisecond)
// make sure daemon is ready to receive requests |
2facc046 |
startTime := time.Now().Unix() |
054b921a |
for { |
e7fc6321 |
d.c.Logf("[%s] waiting for daemon to start", d.id) |
2facc046 |
if time.Now().Unix()-startTime > 5 {
// After 5 seconds, give up |
e7fc6321 |
return fmt.Errorf("[%s] Daemon exited and never started", d.id) |
2facc046 |
} |
054b921a |
select {
case <-time.After(2 * time.Second): |
e7fc6321 |
return fmt.Errorf("[%s] timeout: daemon does not respond", d.id) |
054b921a |
case <-tick: |
fbb01b81 |
clientConfig, err := d.getClientConfig() |
054b921a |
if err != nil { |
fbb01b81 |
return err |
054b921a |
}
|
fbb01b81 |
client := &http.Client{
Transport: clientConfig.transport,
} |
054b921a |
req, err := http.NewRequest("GET", "/_ping", nil) |
a1d4b7dd |
d.c.Assert(err, check.IsNil, check.Commentf("[%s] could not create new request", d.id)) |
fbb01b81 |
req.URL.Host = clientConfig.addr
req.URL.Scheme = clientConfig.scheme |
054b921a |
resp, err := client.Do(req)
if err != nil {
continue
}
if resp.StatusCode != http.StatusOK { |
e7fc6321 |
d.c.Logf("[%s] received status != 200 OK: %s", d.id, resp.Status) |
054b921a |
} |
e7fc6321 |
d.c.Logf("[%s] daemon started", d.id) |
442b4562 |
d.root, err = d.queryRootDir()
if err != nil {
return fmt.Errorf("[%s] error querying daemon for root directory: %v", d.id, err)
} |
054b921a |
return nil
}
}
}
// StartWithBusybox will first start the daemon with Daemon.Start()
// then save the busybox image from the main daemon and load it into this Daemon instance.
func (d *Daemon) StartWithBusybox(arg ...string) error {
if err := d.Start(arg...); err != nil {
return err
}
bb := filepath.Join(d.folder, "busybox.tar")
if _, err := os.Stat(bb); err != nil {
if !os.IsNotExist(err) {
return fmt.Errorf("unexpected error on busybox.tar stat: %v", err)
}
// saving busybox image from main daemon
if err := exec.Command(dockerBinary, "save", "--output", bb, "busybox:latest").Run(); err != nil {
return fmt.Errorf("could not save busybox image: %v", err)
}
}
// loading busybox image to this daemon |
bb8e1dc8 |
if out, err := d.Cmd("load", "--input", bb); err != nil {
return fmt.Errorf("could not load busybox image: %s", out) |
054b921a |
}
if err := os.Remove(bb); err != nil { |
bb8e1dc8 |
d.c.Logf("could not remove %s: %v", bb, err) |
054b921a |
}
return nil
}
// Stop will send a SIGINT every second and wait for the daemon to stop.
// If it timeouts, a SIGKILL is sent.
// Stop will not delete the daemon directory. If a purged daemon is needed,
// instantiate a new one with NewDaemon.
func (d *Daemon) Stop() error {
if d.cmd == nil || d.wait == nil { |
c0e63224 |
return errors.New("daemon not started") |
054b921a |
}
defer func() {
d.logFile.Close()
d.cmd = nil
}()
i := 1
tick := time.Tick(time.Second)
if err := d.cmd.Process.Signal(os.Interrupt); err != nil { |
c0e63224 |
return fmt.Errorf("could not send signal: %v", err) |
054b921a |
} |
8dc86c0e |
out1: |
054b921a |
for {
select {
case err := <-d.wait:
return err |
8dc86c0e |
case <-time.After(15 * time.Second):
// time for stopping jobs and run onShutdown hooks |
dc944ea7 |
d.c.Log("timeout") |
8dc86c0e |
break out1
}
}
out2:
for {
select {
case err := <-d.wait:
return err |
054b921a |
case <-tick: |
8dc86c0e |
i++
if i > 4 { |
dc944ea7 |
d.c.Logf("tried to interrupt daemon for %d times, now try to kill it", i) |
8dc86c0e |
break out2
} |
dc944ea7 |
d.c.Logf("Attempt #%d: daemon is still running with pid %d", i, d.cmd.Process.Pid) |
054b921a |
if err := d.cmd.Process.Signal(os.Interrupt); err != nil { |
c0e63224 |
return fmt.Errorf("could not send signal: %v", err) |
054b921a |
}
}
}
if err := d.cmd.Process.Kill(); err != nil { |
dc944ea7 |
d.c.Logf("Could not kill daemon: %v", err) |
054b921a |
return err
}
return nil
}
// Restart will restart the daemon by first stopping it and then starting it.
func (d *Daemon) Restart(arg ...string) error {
d.Stop() |
0c57b9f5 |
// in the case of tests running a user namespace-enabled daemon, we have resolved
// d.root to be the actual final path of the graph dir after the "uid.gid" of
// remapped root is added--we need to subtract it from the path before calling
// start or else we will continue making subdirectories rather than truly restarting
// with the same location/root:
if root := os.Getenv("DOCKER_REMAP_ROOT"); root != "" {
d.root = filepath.Dir(d.root)
} |
054b921a |
return d.Start(arg...)
}
|
442b4562 |
func (d *Daemon) queryRootDir() (string, error) {
// update daemon root by asking /info endpoint (to support user
// namespaced daemon with root remapped uid.gid directory) |
fbb01b81 |
clientConfig, err := d.getClientConfig() |
442b4562 |
if err != nil {
return "", err
} |
fbb01b81 |
client := &http.Client{
Transport: clientConfig.transport,
} |
442b4562 |
req, err := http.NewRequest("GET", "/info", nil)
if err != nil {
return "", err
}
req.Header.Set("Content-Type", "application/json") |
fbb01b81 |
req.URL.Host = clientConfig.addr
req.URL.Scheme = clientConfig.scheme |
442b4562 |
resp, err := client.Do(req)
if err != nil {
return "", err
}
body := ioutils.NewReadCloserWrapper(resp.Body, func() error {
return resp.Body.Close()
})
type Info struct {
DockerRootDir string
}
var b []byte
var i Info
b, err = readBody(body)
if err == nil && resp.StatusCode == 200 {
// read the docker root dir
if err = json.Unmarshal(b, &i); err == nil {
return i.DockerRootDir, nil
}
}
return "", err
}
|
054b921a |
func (d *Daemon) sock() string {
return fmt.Sprintf("unix://%s/docker.sock", d.folder)
}
// Cmd will execute a docker CLI command against this Daemon.
// Example: d.Cmd("version") will run docker -H unix://path/to/unix.sock version
func (d *Daemon) Cmd(name string, arg ...string) (string, error) {
args := []string{"--host", d.sock(), name}
args = append(args, arg...)
c := exec.Command(dockerBinary, args...)
b, err := c.CombinedOutput()
return string(b), err
}
|
6b3c9281 |
// CmdWithArgs will execute a docker CLI command against a daemon with the
// given additional arguments |
05013f12 |
func (d *Daemon) CmdWithArgs(daemonArgs []string, name string, arg ...string) (string, error) {
args := append(daemonArgs, name)
args = append(args, arg...)
c := exec.Command(dockerBinary, args...)
b, err := c.CombinedOutput()
return string(b), err
}
|
6b3c9281 |
// LogfileName returns the path the the daemon's log file |
459e58ff |
func (d *Daemon) LogfileName() string {
return d.logFile.Name()
}
|
e1ef3344 |
func daemonHost() string { |
6b3c9281 |
daemonURLStr := "unix://" + opts.DefaultUnixSocket |
ed345fb1 |
if daemonHostVar := os.Getenv("DOCKER_HOST"); daemonHostVar != "" { |
6b3c9281 |
daemonURLStr = daemonHostVar |
e1ef3344 |
} |
6b3c9281 |
return daemonURLStr |
e1ef3344 |
}
|
f6a037d4 |
func getTLSConfig() (*tls.Config, error) {
dockerCertPath := os.Getenv("DOCKER_CERT_PATH")
if dockerCertPath == "" {
return nil, fmt.Errorf("DOCKER_TLS_VERIFY specified, but no DOCKER_CERT_PATH environment variable")
}
option := &tlsconfig.Options{
CAFile: filepath.Join(dockerCertPath, "ca.pem"),
CertFile: filepath.Join(dockerCertPath, "cert.pem"),
KeyFile: filepath.Join(dockerCertPath, "key.pem"),
}
tlsConfig, err := tlsconfig.Client(*option)
if err != nil {
return nil, err
}
return tlsConfig, nil
}
|
ac6cb41d |
func sockConn(timeout time.Duration) (net.Conn, error) { |
e1ef3344 |
daemon := daemonHost() |
6b3c9281 |
daemonURL, err := url.Parse(daemon) |
e1ef3344 |
if err != nil {
return nil, fmt.Errorf("could not parse url %q: %v", daemon, err)
}
var c net.Conn |
6b3c9281 |
switch daemonURL.Scheme { |
e1ef3344 |
case "unix": |
6b3c9281 |
return net.DialTimeout(daemonURL.Scheme, daemonURL.Path, timeout) |
e1ef3344 |
case "tcp": |
f6a037d4 |
if os.Getenv("DOCKER_TLS_VERIFY") != "" {
// Setup the socket TLS configuration.
tlsConfig, err := getTLSConfig()
if err != nil {
return nil, err
}
dialer := &net.Dialer{Timeout: timeout}
return tls.DialWithDialer(dialer, daemonURL.Scheme, daemonURL.Host, tlsConfig)
} |
6b3c9281 |
return net.DialTimeout(daemonURL.Scheme, daemonURL.Host, timeout) |
e1ef3344 |
default: |
6b3c9281 |
return c, fmt.Errorf("unknown scheme %v (%s)", daemonURL.Scheme, daemon) |
ac6cb41d |
}
}
|
91bfed60 |
func sockRequest(method, endpoint string, data interface{}) (int, []byte, error) { |
ac6cb41d |
jsonData := bytes.NewBuffer(nil)
if err := json.NewEncoder(jsonData).Encode(data); err != nil { |
91bfed60 |
return -1, nil, err |
e1ef3344 |
} |
ac6cb41d |
|
bb1c576e |
res, body, err := sockRequestRaw(method, endpoint, jsonData, "application/json") |
8232cc77 |
if err != nil { |
09b86c46 |
return -1, nil, err |
8232cc77 |
} |
09b86c46 |
b, err := readBody(body) |
bb1c576e |
return res.StatusCode, b, err |
ac6cb41d |
}
|
bb1c576e |
func sockRequestRaw(method, endpoint string, data io.Reader, ct string) (*http.Response, io.ReadCloser, error) { |
ba5e0980 |
req, client, err := newRequestClient(method, endpoint, data, ct)
if err != nil {
return nil, nil, err
}
resp, err := client.Do(req)
if err != nil {
client.Close()
return nil, nil, err
}
body := ioutils.NewReadCloserWrapper(resp.Body, func() error {
defer resp.Body.Close()
return client.Close()
})
return resp, body, nil
}
func sockRequestHijack(method, endpoint string, data io.Reader, ct string) (net.Conn, *bufio.Reader, error) {
req, client, err := newRequestClient(method, endpoint, data, ct)
if err != nil {
return nil, nil, err
}
client.Do(req)
conn, br := client.Hijack()
return conn, br, nil
}
func newRequestClient(method, endpoint string, data io.Reader, ct string) (*http.Request, *httputil.ClientConn, error) { |
ac6cb41d |
c, err := sockConn(time.Duration(10 * time.Second)) |
f49c3f28 |
if err != nil { |
bb1c576e |
return nil, nil, fmt.Errorf("could not dial docker daemon: %v", err) |
f49c3f28 |
}
client := httputil.NewClientConn(c, nil)
|
198ff76d |
req, err := http.NewRequest(method, endpoint, data) |
f49c3f28 |
if err != nil { |
8232cc77 |
client.Close() |
bb1c576e |
return nil, nil, fmt.Errorf("could not create new request: %v", err) |
f49c3f28 |
}
|
5dc02a2f |
if ct != "" {
req.Header.Set("Content-Type", ct) |
198ff76d |
} |
ba5e0980 |
return req, client, nil |
8232cc77 |
} |
91bfed60 |
|
8232cc77 |
func readBody(b io.ReadCloser) ([]byte, error) {
defer b.Close()
return ioutil.ReadAll(b) |
f49c3f28 |
}
|
6db32fde |
func deleteContainer(container string) error { |
255b8444 |
container = strings.TrimSpace(strings.Replace(container, "\n", " ", -1)) |
887ad57c |
rmArgs := strings.Split(fmt.Sprintf("rm -fv %v", container), " ") |
255b8444 |
exitCode, err := runCommand(exec.Command(dockerBinary, rmArgs...)) |
6db32fde |
// set error manually if not set
if exitCode != 0 && err == nil {
err = fmt.Errorf("failed to remove container: `docker rm` exit is non-zero")
}
return err
}
func getAllContainers() (string, error) {
getContainersCmd := exec.Command(dockerBinary, "ps", "-q", "-a")
out, exitCode, err := runCommandWithOutput(getContainersCmd)
if exitCode != 0 && err == nil {
err = fmt.Errorf("failed to get a list of containers: %v\n", out)
}
return out, err
}
func deleteAllContainers() error {
containers, err := getAllContainers()
if err != nil {
fmt.Println(containers)
return err
}
|
bfa5027e |
if containers != "" {
if err = deleteContainer(containers); err != nil {
return err
} |
6db32fde |
}
return nil |
28ad7c58 |
}
func deleteAllNetworks() error {
networks, err := getAllNetworks()
if err != nil {
return err
}
var errors []string
for _, n := range networks { |
5970e940 |
if n.Name == "bridge" || n.Name == "none" || n.Name == "host" {
continue
}
status, b, err := sockRequest("DELETE", "/networks/"+n.Name, nil)
if err != nil {
errors = append(errors, err.Error())
continue
}
if status != http.StatusNoContent {
errors = append(errors, fmt.Sprintf("error deleting network %s: %s", n.Name, string(b))) |
28ad7c58 |
}
}
if len(errors) > 0 {
return fmt.Errorf(strings.Join(errors, "\n"))
}
return nil
}
func getAllNetworks() ([]types.NetworkResource, error) {
var networks []types.NetworkResource
_, b, err := sockRequest("GET", "/networks", nil)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &networks); err != nil {
return nil, err
}
return networks, nil |
6db32fde |
}
|
b3b7eb27 |
func deleteAllVolumes() error {
volumes, err := getAllVolumes()
if err != nil {
return err
}
var errors []string
for _, v := range volumes {
status, b, err := sockRequest("DELETE", "/volumes/"+v.Name, nil)
if err != nil {
errors = append(errors, err.Error())
continue
}
if status != http.StatusNoContent {
errors = append(errors, fmt.Sprintf("error deleting volume %s: %s", v.Name, string(b)))
}
}
if len(errors) > 0 {
return fmt.Errorf(strings.Join(errors, "\n"))
}
return nil
}
func getAllVolumes() ([]*types.Volume, error) {
var volumes types.VolumesListResponse
_, b, err := sockRequest("GET", "/volumes", nil)
if err != nil {
return nil, err
}
if err := json.Unmarshal(b, &volumes); err != nil {
return nil, err
}
return volumes.Volumes, nil
}
|
a9688cdc |
var protectedImages = map[string]struct{}{}
func deleteAllImages() error {
out, err := exec.Command(dockerBinary, "images").CombinedOutput()
if err != nil {
return err
}
lines := strings.Split(string(out), "\n")[1:]
var imgs []string
for _, l := range lines {
if l == "" {
continue
}
fields := strings.Fields(l)
imgTag := fields[0] + ":" + fields[1]
if _, ok := protectedImages[imgTag]; !ok {
if fields[0] == "<none>" {
imgs = append(imgs, fields[2])
continue
}
imgs = append(imgs, imgTag)
}
}
if len(imgs) == 0 {
return nil
}
args := append([]string{"rmi", "-f"}, imgs...)
if err := exec.Command(dockerBinary, args...).Run(); err != nil {
return err
}
return nil
}
|
1bb02117 |
func getPausedContainers() (string, error) {
getPausedContainersCmd := exec.Command(dockerBinary, "ps", "-f", "status=paused", "-q", "-a")
out, exitCode, err := runCommandWithOutput(getPausedContainersCmd)
if exitCode != 0 && err == nil {
err = fmt.Errorf("failed to get a list of paused containers: %v\n", out)
}
return out, err
}
|
0ce42dcc |
func getSliceOfPausedContainers() ([]string, error) {
out, err := getPausedContainers()
if err == nil { |
8636a219 |
if len(out) == 0 {
return nil, err
} |
0ce42dcc |
slice := strings.Split(strings.TrimSpace(out), "\n")
return slice, err
} |
664ef0cb |
return []string{out}, err |
0ce42dcc |
}
|
1bb02117 |
func unpauseContainer(container string) error {
unpauseCmd := exec.Command(dockerBinary, "unpause", container)
exitCode, err := runCommand(unpauseCmd)
if exitCode != 0 && err == nil {
err = fmt.Errorf("failed to unpause container")
}
return nil
}
func unpauseAllContainers() error {
containers, err := getPausedContainers()
if err != nil {
fmt.Println(containers)
return err
}
containers = strings.Replace(containers, "\n", " ", -1)
containers = strings.Trim(containers, " ")
containerList := strings.Split(containers, " ")
for _, value := range containerList {
if err = unpauseContainer(value); err != nil {
return err
}
}
return nil
}
|
50fa9dff |
func deleteImages(images ...string) error { |
563708d7 |
args := []string{"rmi", "-f"} |
bbb245de |
args = append(args, images...)
rmiCmd := exec.Command(dockerBinary, args...) |
6db32fde |
exitCode, err := runCommand(rmiCmd)
// set error manually if not set
if exitCode != 0 && err == nil {
err = fmt.Errorf("failed to remove image: `docker rmi` exit is non-zero")
}
return err
} |
30f22ee9 |
|
eb1e8e88 |
func imageExists(image string) error {
inspectCmd := exec.Command(dockerBinary, "inspect", image)
exitCode, err := runCommand(inspectCmd)
if exitCode != 0 && err == nil { |
949ab477 |
err = fmt.Errorf("couldn't find image %q", image) |
eb1e8e88 |
}
return err
}
|
b7009a4b |
func pullImageIfNotExist(image string) error { |
dad47680 |
if err := imageExists(image); err != nil {
pullCmd := exec.Command(dockerBinary, "pull", image)
_, exitCode, err := runCommandWithOutput(pullCmd)
if err != nil || exitCode != 0 { |
b7009a4b |
return fmt.Errorf("image %q wasn't found locally and it couldn't be pulled: %s", image, err) |
dad47680 |
}
} |
b7009a4b |
return nil |
dad47680 |
}
|
693ba98c |
func dockerCmdWithError(args ...string) (string, int, error) { |
7efa0f37 |
return integration.DockerCmdWithError(dockerBinary, args...) |
4290bdef |
}
|
c6cde91b |
func dockerCmdWithStdoutStderr(c *check.C, args ...string) (string, string, int) { |
7efa0f37 |
return integration.DockerCmdWithStdoutStderr(dockerBinary, c, args...) |
c6cde91b |
}
|
dc944ea7 |
func dockerCmd(c *check.C, args ...string) (string, int) { |
7efa0f37 |
return integration.DockerCmd(dockerBinary, c, args...) |
30f22ee9 |
} |
7cc27b20 |
|
a0225657 |
// execute a docker command with a timeout |
c6965e3e |
func dockerCmdWithTimeout(timeout time.Duration, args ...string) (string, int, error) { |
7efa0f37 |
return integration.DockerCmdWithTimeout(dockerBinary, timeout, args...) |
c6965e3e |
}
|
f60c8e9e |
// execute a docker command in a directory |
dc944ea7 |
func dockerCmdInDir(c *check.C, path string, args ...string) (string, int, error) { |
7efa0f37 |
return integration.DockerCmdInDir(dockerBinary, path, args...) |
c6965e3e |
}
// execute a docker command in a directory with a timeout
func dockerCmdInDirWithTimeout(timeout time.Duration, path string, args ...string) (string, int, error) { |
7efa0f37 |
return integration.DockerCmdInDirWithTimeout(dockerBinary, timeout, path, args...) |
f60c8e9e |
}
|
41de7a18 |
// find the State.ExitCode in container metadata
func findContainerExitCode(c *check.C, name string, vargs ...string) string {
args := append(vargs, "inspect", "--format='{{ .State.ExitCode }} {{ .State.Error }}'", name)
cmd := exec.Command(dockerBinary, args...)
out, _, err := runCommandWithOutput(cmd)
if err != nil {
c.Fatal(err, out)
}
return out
}
|
1b9a08e7 |
func findContainerIP(c *check.C, id string, network string) string {
out, _ := dockerCmd(c, "inspect", fmt.Sprintf("--format='{{ .NetworkSettings.Networks.%s.IPAddress }}'", network), id) |
7cc27b20 |
return strings.Trim(out, " \r\n'")
} |
77f54252 |
|
dd0666e6 |
func (d *Daemon) findContainerIP(id string) string { |
25682577 |
out, err := d.Cmd("inspect", fmt.Sprintf("--format='{{ .NetworkSettings.Networks.bridge.IPAddress }}'"), id)
if err != nil {
d.c.Log(err)
}
return strings.Trim(out, " \r\n'") |
f3f5ff9d |
}
|
77f54252 |
func getContainerCount() (int, error) {
const containers = "Containers:"
cmd := exec.Command(dockerBinary, "info")
out, _, err := runCommandWithOutput(cmd)
if err != nil {
return 0, err
}
lines := strings.Split(out, "\n")
for _, line := range lines {
if strings.Contains(line, containers) { |
475c6531 |
output := strings.TrimSpace(line) |
77f54252 |
output = strings.TrimLeft(output, containers)
output = strings.Trim(output, " ")
containerCount, err := strconv.Atoi(output)
if err != nil {
return 0, err
}
return containerCount, nil
}
}
return 0, fmt.Errorf("couldn't find the Container count in the output")
} |
2e855688 |
|
6b3c9281 |
// FakeContext creates directories that can be used as a build context |
2e855688 |
type FakeContext struct {
Dir string
}
|
6b3c9281 |
// Add a file at a path, creating directories where necessary |
2e855688 |
func (f *FakeContext) Add(file, content string) error { |
d48bface |
return f.addFile(file, []byte(content))
}
func (f *FakeContext) addFile(file string, content []byte) error { |
2e855688 |
filepath := path.Join(f.Dir, file)
dirpath := path.Dir(filepath)
if dirpath != "." {
if err := os.MkdirAll(dirpath, 0755); err != nil {
return err
}
} |
d48bface |
return ioutil.WriteFile(filepath, content, 0644)
|
2e855688 |
}
|
6b3c9281 |
// Delete a file at a path |
2e855688 |
func (f *FakeContext) Delete(file string) error {
filepath := path.Join(f.Dir, file)
return os.RemoveAll(filepath)
}
|
6b3c9281 |
// Close deletes the context |
2e855688 |
func (f *FakeContext) Close() error {
return os.RemoveAll(f.Dir)
}
|
d48bface |
func fakeContextFromNewTempDir() (*FakeContext, error) { |
2e855688 |
tmp, err := ioutil.TempDir("", "fake-context")
if err != nil {
return nil, err
} |
51a56399 |
if err := os.Chmod(tmp, 0755); err != nil {
return nil, err
} |
d48bface |
return fakeContextFromDir(tmp), nil
}
func fakeContextFromDir(dir string) *FakeContext {
return &FakeContext{dir}
} |
44ffb199 |
|
d48bface |
func fakeContextWithFiles(files map[string]string) (*FakeContext, error) {
ctx, err := fakeContextFromNewTempDir()
if err != nil {
return nil, err
} |
2e855688 |
for file, content := range files {
if err := ctx.Add(file, content); err != nil {
ctx.Close()
return nil, err
}
} |
44ffb199 |
return ctx, nil
}
func fakeContextAddDockerfile(ctx *FakeContext, dockerfile string) error { |
2e855688 |
if err := ctx.Add("Dockerfile", dockerfile); err != nil {
ctx.Close() |
44ffb199 |
return err
}
return nil
}
func fakeContext(dockerfile string, files map[string]string) (*FakeContext, error) {
ctx, err := fakeContextWithFiles(files)
if err != nil {
return nil, err
}
if err := fakeContextAddDockerfile(ctx, dockerfile); err != nil { |
2e855688 |
return nil, err
}
return ctx, nil
}
|
2e95bb5f |
// FakeStorage is a static file server. It might be running locally or remotely
// on test host.
type FakeStorage interface {
Close() error
URL() string
CtxDir() string
}
|
d48bface |
func fakeBinaryStorage(archives map[string]*bytes.Buffer) (FakeStorage, error) {
ctx, err := fakeContextFromNewTempDir()
if err != nil {
return nil, err
}
for name, content := range archives {
if err := ctx.addFile(name, content.Bytes()); err != nil {
return nil, err
}
}
return fakeStorageWithContext(ctx)
}
|
2e95bb5f |
// fakeStorage returns either a local or remote (at daemon machine) file server
func fakeStorage(files map[string]string) (FakeStorage, error) { |
44ffb199 |
ctx, err := fakeContextWithFiles(files)
if err != nil {
return nil, err
}
return fakeStorageWithContext(ctx)
}
// fakeStorageWithContext returns either a local or remote (at daemon machine) file server
func fakeStorageWithContext(ctx *FakeContext) (FakeStorage, error) { |
2e95bb5f |
if isLocalDaemon { |
44ffb199 |
return newLocalFakeStorage(ctx) |
2e95bb5f |
} |
44ffb199 |
return newRemoteFileServer(ctx) |
2e95bb5f |
}
// localFileStorage is a file storage on the running machine
type localFileStorage struct { |
2e855688 |
*FakeContext
*httptest.Server
}
|
2e95bb5f |
func (s *localFileStorage) URL() string {
return s.Server.URL
}
func (s *localFileStorage) CtxDir() string {
return s.FakeContext.Dir
}
func (s *localFileStorage) Close() error {
defer s.Server.Close()
return s.FakeContext.Close() |
2e855688 |
}
|
44ffb199 |
func newLocalFakeStorage(ctx *FakeContext) (*localFileStorage, error) { |
2e855688 |
handler := http.FileServer(http.Dir(ctx.Dir))
server := httptest.NewServer(handler) |
2e95bb5f |
return &localFileStorage{ |
2e855688 |
FakeContext: ctx,
Server: server,
}, nil
}
|
2e95bb5f |
// remoteFileServer is a containerized static file server started on the remote
// testing machine to be used in URL-accepting docker build functionality.
type remoteFileServer struct {
host string // hostname/port web server is listening to on docker host e.g. 0.0.0.0:43712
container string
image string
ctx *FakeContext
}
func (f *remoteFileServer) URL() string {
u := url.URL{
Scheme: "http",
Host: f.host}
return u.String()
}
func (f *remoteFileServer) CtxDir() string {
return f.ctx.Dir
}
func (f *remoteFileServer) Close() error {
defer func() {
if f.ctx != nil {
f.ctx.Close()
}
if f.image != "" {
deleteImages(f.image)
}
}()
if f.container == "" {
return nil |
2e855688 |
} |
2e95bb5f |
return deleteContainer(f.container) |
2e855688 |
} |
e5e8669c |
|
44ffb199 |
func newRemoteFileServer(ctx *FakeContext) (*remoteFileServer, error) { |
2e95bb5f |
var ( |
b80fae73 |
image = fmt.Sprintf("fileserver-img-%s", strings.ToLower(stringutils.GenerateRandomAlphaOnlyString(10)))
container = fmt.Sprintf("fileserver-cnt-%s", strings.ToLower(stringutils.GenerateRandomAlphaOnlyString(10))) |
2e95bb5f |
)
// Build the image |
44ffb199 |
if err := fakeContextAddDockerfile(ctx, `FROM httpserver
COPY . /static`); err != nil {
return nil, fmt.Errorf("Cannot add Dockerfile to context: %v", err)
} |
2e95bb5f |
if _, err := buildImageFromContext(image, ctx, false); err != nil {
return nil, fmt.Errorf("failed building file storage container image: %v", err) |
e5e8669c |
} |
2e95bb5f |
// Start the container
runCmd := exec.Command(dockerBinary, "run", "-d", "-P", "--name", container, image)
if out, ec, err := runCommandWithOutput(runCmd); err != nil {
return nil, fmt.Errorf("failed to start file storage container. ec=%v\nout=%s\nerr=%v", ec, out, err)
}
// Find out the system assigned port
out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "port", container, "80/tcp"))
if err != nil {
return nil, fmt.Errorf("failed to find container port: err=%v\nout=%s", err, out)
}
|
d06ffd0a |
fileserverHostPort := strings.Trim(out, "\n")
_, port, err := net.SplitHostPort(fileserverHostPort)
if err != nil {
return nil, fmt.Errorf("unable to parse file server host:port: %v", err)
}
dockerHostURL, err := url.Parse(daemonHost())
if err != nil {
return nil, fmt.Errorf("unable to parse daemon host URL: %v", err)
}
host, _, err := net.SplitHostPort(dockerHostURL.Host)
if err != nil {
return nil, fmt.Errorf("unable to parse docker daemon host:port: %v", err)
}
|
2e95bb5f |
return &remoteFileServer{
container: container,
image: image, |
d06ffd0a |
host: fmt.Sprintf("%s:%s", host, port), |
2e95bb5f |
ctx: ctx}, nil |
e5e8669c |
} |
2e855688 |
|
abb5e9a0 |
func inspectFieldAndMarshall(name, field string, output interface{}) error {
str, err := inspectFieldJSON(name, field)
if err != nil {
return err
}
return json.Unmarshal([]byte(str), output)
}
|
2e95bb5f |
func inspectFilter(name, filter string) (string, error) {
format := fmt.Sprintf("{{%s}}", filter) |
964f9965 |
inspectCmd := exec.Command(dockerBinary, "inspect", "-f", format, name)
out, exitCode, err := runCommandWithOutput(inspectCmd)
if err != nil || exitCode != 0 { |
2e95bb5f |
return "", fmt.Errorf("failed to inspect container %s: %s", name, out) |
964f9965 |
}
return strings.TrimSpace(out), nil
}
|
2e95bb5f |
func inspectField(name, field string) (string, error) {
return inspectFilter(name, fmt.Sprintf(".%s", field))
}
func inspectFieldJSON(name, field string) (string, error) {
return inspectFilter(name, fmt.Sprintf("json .%s", field))
}
func inspectFieldMap(name, path, field string) (string, error) {
return inspectFilter(name, fmt.Sprintf("index .%s %q", path, field))
}
|
1c3cb2d3 |
func inspectMountSourceField(name, destination string) (string, error) {
m, err := inspectMountPoint(name, destination)
if err != nil {
return "", err
}
return m.Source, nil
}
func inspectMountPoint(name, destination string) (types.MountPoint, error) {
out, err := inspectFieldJSON(name, "Mounts")
if err != nil {
return types.MountPoint{}, err
}
return inspectMountPointJSON(out, destination)
}
|
6b3c9281 |
var errMountNotFound = errors.New("mount point not found") |
1c3cb2d3 |
func inspectMountPointJSON(j, destination string) (types.MountPoint, error) {
var mp []types.MountPoint
if err := unmarshalJSON([]byte(j), &mp); err != nil {
return types.MountPoint{}, err
}
var m *types.MountPoint
for _, c := range mp {
if c.Destination == destination {
m = &c
break
}
}
if m == nil { |
6b3c9281 |
return types.MountPoint{}, errMountNotFound |
1c3cb2d3 |
}
return *m, nil
}
|
2e855688 |
func getIDByName(name string) (string, error) {
return inspectField(name, "Id")
}
|
5d1cb9d0 |
// getContainerState returns the exit code of the container
// and true if it's running
// the exit code should be ignored if it's running |
dc944ea7 |
func getContainerState(c *check.C, id string) (int, bool, error) { |
5d1cb9d0 |
var (
exitStatus int
running bool
) |
dc944ea7 |
out, exitCode := dockerCmd(c, "inspect", "--format={{.State.Running}} {{.State.ExitCode}}", id) |
621b601b |
if exitCode != 0 {
return 0, false, fmt.Errorf("%q doesn't exist: %s", id, out) |
5d1cb9d0 |
}
out = strings.Trim(out, "\n")
splitOutput := strings.Split(out, " ")
if len(splitOutput) != 2 {
return 0, false, fmt.Errorf("failed to get container state: output is broken")
}
if splitOutput[0] == "true" {
running = true
}
if n, err := strconv.Atoi(splitOutput[1]); err == nil {
exitStatus = n
} else {
return 0, false, fmt.Errorf("failed to get container state: couldn't parse integer")
}
return exitStatus, running, nil
}
|
54240f8d |
func buildImageCmd(name, dockerfile string, useCache bool, buildFlags ...string) *exec.Cmd { |
871d2b96 |
args := []string{"-D", "build", "-t", name} |
2e855688 |
if !useCache {
args = append(args, "--no-cache")
} |
54240f8d |
args = append(args, buildFlags...) |
2e855688 |
args = append(args, "-")
buildCmd := exec.Command(dockerBinary, args...)
buildCmd.Stdin = strings.NewReader(dockerfile) |
871d2b96 |
return buildCmd
}
|
54240f8d |
func buildImageWithOut(name, dockerfile string, useCache bool, buildFlags ...string) (string, string, error) {
buildCmd := buildImageCmd(name, dockerfile, useCache, buildFlags...) |
2e855688 |
out, exitCode, err := runCommandWithOutput(buildCmd)
if err != nil || exitCode != 0 { |
075e1bc1 |
return "", out, fmt.Errorf("failed to build the image: %s", out) |
2e855688 |
} |
075e1bc1 |
id, err := getIDByName(name)
if err != nil {
return "", out, err
}
return id, out, nil
}
|
54240f8d |
func buildImageWithStdoutStderr(name, dockerfile string, useCache bool, buildFlags ...string) (string, string, string, error) {
buildCmd := buildImageCmd(name, dockerfile, useCache, buildFlags...) |
5c91bb93 |
stdout, stderr, exitCode, err := runCommandWithStdoutStderr(buildCmd)
if err != nil || exitCode != 0 {
return "", stdout, stderr, fmt.Errorf("failed to build the image: %s", stdout)
}
id, err := getIDByName(name)
if err != nil {
return "", stdout, stderr, err
}
return id, stdout, stderr, nil
}
|
54240f8d |
func buildImage(name, dockerfile string, useCache bool, buildFlags ...string) (string, error) {
id, _, err := buildImageWithOut(name, dockerfile, useCache, buildFlags...) |
075e1bc1 |
return id, err |
2e855688 |
}
|
54240f8d |
func buildImageFromContext(name string, ctx *FakeContext, useCache bool, buildFlags ...string) (string, error) { |
47da59f7 |
id, _, err := buildImageFromContextWithOut(name, ctx, useCache, buildFlags...)
if err != nil {
return "", err
}
return id, nil
}
func buildImageFromContextWithOut(name string, ctx *FakeContext, useCache bool, buildFlags ...string) (string, string, error) { |
2e855688 |
args := []string{"build", "-t", name}
if !useCache {
args = append(args, "--no-cache")
} |
54240f8d |
args = append(args, buildFlags...) |
2e855688 |
args = append(args, ".")
buildCmd := exec.Command(dockerBinary, args...)
buildCmd.Dir = ctx.Dir
out, exitCode, err := runCommandWithOutput(buildCmd)
if err != nil || exitCode != 0 { |
47da59f7 |
return "", "", fmt.Errorf("failed to build the image: %s", out) |
2e855688 |
} |
47da59f7 |
id, err := getIDByName(name)
if err != nil {
return "", "", err
}
return id, out, nil |
2e855688 |
} |
5b0d4cf2 |
|
60b4db7e |
func buildImageFromContextWithStdoutStderr(name string, ctx *FakeContext, useCache bool, buildFlags ...string) (string, string, string, error) {
args := []string{"build", "-t", name}
if !useCache {
args = append(args, "--no-cache")
}
args = append(args, buildFlags...)
args = append(args, ".")
buildCmd := exec.Command(dockerBinary, args...)
buildCmd.Dir = ctx.Dir
stdout, stderr, exitCode, err := runCommandWithStdoutStderr(buildCmd)
if err != nil || exitCode != 0 {
return "", stdout, stderr, fmt.Errorf("failed to build the image: %s", stdout)
}
id, err := getIDByName(name)
if err != nil {
return "", stdout, stderr, err
}
return id, stdout, stderr, nil
}
func buildImageFromGitWithStdoutStderr(name string, ctx *fakeGit, useCache bool, buildFlags ...string) (string, string, string, error) {
args := []string{"build", "-t", name}
if !useCache {
args = append(args, "--no-cache")
}
args = append(args, buildFlags...)
args = append(args, ctx.RepoURL)
buildCmd := exec.Command(dockerBinary, args...)
stdout, stderr, exitCode, err := runCommandWithStdoutStderr(buildCmd)
if err != nil || exitCode != 0 {
return "", stdout, stderr, fmt.Errorf("failed to build the image: %s", stdout)
}
id, err := getIDByName(name)
if err != nil {
return "", stdout, stderr, err
}
return id, stdout, stderr, nil
}
|
54240f8d |
func buildImageFromPath(name, path string, useCache bool, buildFlags ...string) (string, error) { |
5b0d4cf2 |
args := []string{"build", "-t", name}
if !useCache {
args = append(args, "--no-cache")
} |
54240f8d |
args = append(args, buildFlags...) |
5b0d4cf2 |
args = append(args, path)
buildCmd := exec.Command(dockerBinary, args...)
out, exitCode, err := runCommandWithOutput(buildCmd)
if err != nil || exitCode != 0 {
return "", fmt.Errorf("failed to build the image: %s", out)
}
return getIDByName(name)
}
|
6b3c9281 |
type gitServer interface { |
44ffb199 |
URL() string
Close() error
}
type localGitServer struct { |
5b0d4cf2 |
*httptest.Server |
44ffb199 |
}
func (r *localGitServer) Close() error {
r.Server.Close()
return nil
}
func (r *localGitServer) URL() string {
return r.Server.URL
}
|
6b3c9281 |
type fakeGit struct { |
44ffb199 |
root string |
6b3c9281 |
server gitServer |
5b0d4cf2 |
RepoURL string
}
|
6b3c9281 |
func (g *fakeGit) Close() { |
44ffb199 |
g.server.Close()
os.RemoveAll(g.root) |
5b0d4cf2 |
}
|
6b3c9281 |
func newFakeGit(name string, files map[string]string, enforceLocalServer bool) (*fakeGit, error) { |
44ffb199 |
ctx, err := fakeContextWithFiles(files) |
5b0d4cf2 |
if err != nil {
return nil, err
}
defer ctx.Close()
curdir, err := os.Getwd()
if err != nil {
return nil, err
}
defer os.Chdir(curdir)
if output, err := exec.Command("git", "init", ctx.Dir).CombinedOutput(); err != nil { |
c0e63224 |
return nil, fmt.Errorf("error trying to init repo: %s (%s)", err, output) |
5b0d4cf2 |
}
err = os.Chdir(ctx.Dir)
if err != nil {
return nil, err
} |
ed345fb1 |
if output, err := exec.Command("git", "config", "user.name", "Fake User").CombinedOutput(); err != nil {
return nil, fmt.Errorf("error trying to set 'user.name': %s (%s)", err, output)
}
if output, err := exec.Command("git", "config", "user.email", "fake.user@example.com").CombinedOutput(); err != nil {
return nil, fmt.Errorf("error trying to set 'user.email': %s (%s)", err, output)
} |
5b0d4cf2 |
if output, err := exec.Command("git", "add", "*").CombinedOutput(); err != nil { |
c0e63224 |
return nil, fmt.Errorf("error trying to add files to repo: %s (%s)", err, output) |
5b0d4cf2 |
}
if output, err := exec.Command("git", "commit", "-a", "-m", "Initial commit").CombinedOutput(); err != nil { |
c0e63224 |
return nil, fmt.Errorf("error trying to commit to repo: %s (%s)", err, output) |
5b0d4cf2 |
}
root, err := ioutil.TempDir("", "docker-test-git-repo")
if err != nil {
return nil, err
}
repoPath := filepath.Join(root, name+".git")
if output, err := exec.Command("git", "clone", "--bare", ctx.Dir, repoPath).CombinedOutput(); err != nil {
os.RemoveAll(root) |
c0e63224 |
return nil, fmt.Errorf("error trying to clone --bare: %s (%s)", err, output) |
5b0d4cf2 |
}
err = os.Chdir(repoPath)
if err != nil {
os.RemoveAll(root)
return nil, err
}
if output, err := exec.Command("git", "update-server-info").CombinedOutput(); err != nil {
os.RemoveAll(root) |
c0e63224 |
return nil, fmt.Errorf("error trying to git update-server-info: %s (%s)", err, output) |
5b0d4cf2 |
}
err = os.Chdir(curdir)
if err != nil {
os.RemoveAll(root)
return nil, err
} |
44ffb199 |
|
6b3c9281 |
var server gitServer |
44ffb199 |
if !enforceLocalServer {
// use fakeStorage server, which might be local or remote (at test daemon)
server, err = fakeStorageWithContext(fakeContextFromDir(root))
if err != nil {
return nil, fmt.Errorf("cannot start fake storage: %v", err)
}
} else { |
927b334e |
// always start a local http server on CLI test machine |
44ffb199 |
httpServer := httptest.NewServer(http.FileServer(http.Dir(root)))
server = &localGitServer{httpServer}
} |
6b3c9281 |
return &fakeGit{ |
44ffb199 |
root: root,
server: server,
RepoURL: fmt.Sprintf("%s/%s.git", server.URL(), name), |
5b0d4cf2 |
}, nil
} |
5b27fbc0 |
// Write `content` to the file at path `dst`, creating it if necessary,
// as well as any missing directories.
// The file is truncated if it already exists. |
927b334e |
// Fail the test when error occurs. |
dc944ea7 |
func writeFile(dst, content string, c *check.C) { |
5b27fbc0 |
// Create subdirectories if necessary |
a1d4b7dd |
c.Assert(os.MkdirAll(path.Dir(dst), 0700), check.IsNil) |
5b27fbc0 |
f, err := os.OpenFile(dst, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0700) |
a1d4b7dd |
c.Assert(err, check.IsNil) |
d28b0ba1 |
defer f.Close() |
5b27fbc0 |
// Write content (truncate if it exists) |
a1d4b7dd |
_, err = io.Copy(f, strings.NewReader(content))
c.Assert(err, check.IsNil) |
5b27fbc0 |
}
// Return the contents of file at path `src`. |
927b334e |
// Fail the test when error occurs. |
dc944ea7 |
func readFile(src string, c *check.C) (content string) { |
d5ea4bae |
data, err := ioutil.ReadFile(src) |
a1d4b7dd |
c.Assert(err, check.IsNil) |
d5ea4bae |
|
5b27fbc0 |
return string(data)
} |
20575d20 |
|
6b3c9281 |
func containerStorageFile(containerID, basename string) string { |
442b4562 |
return filepath.Join(containerStoragePath, containerID, basename) |
20575d20 |
}
|
68bc8de1 |
// docker commands that use this function must be run with the '-d' switch. |
20575d20 |
func runCommandAndReadContainerFile(filename string, cmd *exec.Cmd) ([]byte, error) {
out, _, err := runCommandWithOutput(cmd)
if err != nil { |
68bc8de1 |
return nil, fmt.Errorf("%v: %q", err, out) |
20575d20 |
}
contID := strings.TrimSpace(out)
|
799d9605 |
if err := waitRun(contID); err != nil {
return nil, fmt.Errorf("%v: %q", contID, err)
}
|
20575d20 |
return readContainerFile(contID, filename)
}
|
6b3c9281 |
func readContainerFile(containerID, filename string) ([]byte, error) {
f, err := os.Open(containerStorageFile(containerID, filename)) |
20575d20 |
if err != nil {
return nil, err
}
defer f.Close()
content, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
return content, nil
} |
dbec2317 |
|
6b3c9281 |
func readContainerFileWithExec(containerID, filename string) ([]byte, error) {
out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "exec", containerID, "cat", filename)) |
6bbb4561 |
return []byte(out), err
}
|
e424c54d |
// daemonTime provides the current time on the daemon host |
dc944ea7 |
func daemonTime(c *check.C) time.Time { |
e424c54d |
if isLocalDaemon {
return time.Now()
}
|
c7845e27 |
status, body, err := sockRequest("GET", "/info", nil)
c.Assert(err, check.IsNil) |
a1d4b7dd |
c.Assert(status, check.Equals, http.StatusOK) |
e424c54d |
type infoJSON struct {
SystemTime string
}
var info infoJSON |
a1d4b7dd |
err = json.Unmarshal(body, &info)
c.Assert(err, check.IsNil, check.Commentf("unable to unmarshal GET /info response")) |
e424c54d |
dt, err := time.Parse(time.RFC3339Nano, info.SystemTime) |
a1d4b7dd |
c.Assert(err, check.IsNil, check.Commentf("invalid time format in GET /info response")) |
e424c54d |
return dt
}
|
1fa2e311 |
func setupRegistry(c *check.C, schema1 bool) *testRegistryV2 { |
dc944ea7 |
testRequires(c, RegistryHosting) |
1fa2e311 |
reg, err := newTestRegistryV2(c, schema1) |
a1d4b7dd |
c.Assert(err, check.IsNil) |
de8ea06d |
// Wait for registry to be ready to serve requests. |
88c1bc10 |
for i := 0; i != 50; i++ { |
de8ea06d |
if err = reg.Ping(); err == nil {
break
}
time.Sleep(100 * time.Millisecond)
}
|
a1d4b7dd |
c.Assert(err, check.IsNil, check.Commentf("Timeout waiting for test registry to become available")) |
f696b107 |
return reg |
dbec2317 |
} |
4f377fbe |
|
58a1de9b |
func setupNotary(c *check.C) *testNotary {
testRequires(c, NotaryHosting)
ts, err := newTestNotary(c) |
a1d4b7dd |
c.Assert(err, check.IsNil) |
58a1de9b |
return ts
}
|
d18689df |
// appendBaseEnv appends the minimum set of environment variables to exec the
// docker cli binary for testing with correct configuration to the given env
// list.
func appendBaseEnv(env []string) []string {
preserveList := []string{
// preserve remote test host
"DOCKER_HOST",
// windows: requires preserving SystemRoot, otherwise dial tcp fails
// with "GetAddrInfoW: A non-recoverable error occurred during a database lookup."
"SystemRoot",
}
for _, key := range preserveList {
if val := os.Getenv(key); val != "" {
env = append(env, fmt.Sprintf("%s=%s", key, val))
} |
4f377fbe |
}
return env
} |
38295d4b |
func createTmpFile(c *check.C, content string) string {
f, err := ioutil.TempFile("", "testfile")
c.Assert(err, check.IsNil)
filename := f.Name()
err = ioutil.WriteFile(filename, []byte(content), 0644)
c.Assert(err, check.IsNil)
return filename
} |
6b8129d1 |
|
6549d651 |
func buildImageWithOutInDamon(socket string, name, dockerfile string, useCache bool) (string, error) {
args := []string{"--host", socket} |
6b8129d1 |
buildCmd := buildImageCmdArgs(args, name, dockerfile, useCache)
out, exitCode, err := runCommandWithOutput(buildCmd)
if err != nil || exitCode != 0 { |
6549d651 |
return out, fmt.Errorf("failed to build the image: %s, error: %v", out, err) |
6b8129d1 |
} |
6549d651 |
return out, nil |
6b8129d1 |
}
func buildImageCmdArgs(args []string, name, dockerfile string, useCache bool) *exec.Cmd {
args = append(args, []string{"-D", "build", "-t", name}...)
if !useCache {
args = append(args, "--no-cache")
}
args = append(args, "-")
buildCmd := exec.Command(dockerBinary, args...)
buildCmd.Stdin = strings.NewReader(dockerfile)
return buildCmd
} |
51090717 |
func waitForContainer(contID string, args ...string) error {
args = append([]string{"run", "--name", contID}, args...)
cmd := exec.Command(dockerBinary, args...)
if _, err := runCommand(cmd); err != nil {
return err
}
if err := waitRun(contID); err != nil {
return err
}
return nil
}
// waitRun will wait for the specified container to be running, maximum 5 seconds.
func waitRun(contID string) error { |
8a5ab83d |
return waitInspect(contID, "{{.State.Running}}", "true", 5*time.Second)
}
// waitExited will wait for the specified container to state exit, subject
// to a maximum time limit in seconds supplied by the caller
func waitExited(contID string, duration time.Duration) error {
return waitInspect(contID, "{{.State.Status}}", "exited", duration) |
51090717 |
}
// waitInspect will wait for the specified container to have the specified string
// in the inspect output. It will wait until the specified timeout (in seconds)
// is reached. |
8a5ab83d |
func waitInspect(name, expr, expected string, timeout time.Duration) error {
after := time.After(timeout) |
51090717 |
for {
cmd := exec.Command(dockerBinary, "inspect", "-f", expr, name)
out, _, err := runCommandWithOutput(cmd)
if err != nil {
if !strings.Contains(out, "No such") {
return fmt.Errorf("error executing docker inspect: %v\n%s", err, out)
}
select {
case <-after:
return err
default:
time.Sleep(10 * time.Millisecond)
continue
}
}
out = strings.TrimSpace(out)
if out == expected {
break
}
select {
case <-after:
return fmt.Errorf("condition \"%q == %q\" not true in time", out, expected)
default:
}
time.Sleep(100 * time.Millisecond)
}
return nil
} |
f301c576 |
func getInspectBody(c *check.C, version, id string) []byte {
endpoint := fmt.Sprintf("/%s/containers/%s/json", version, id)
status, body, err := sockRequest("GET", endpoint, nil)
c.Assert(err, check.IsNil)
c.Assert(status, check.Equals, http.StatusOK)
return body
} |