| package main |
| |
| import ( |
| "fmt" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "strings" |
| |
| "github.com/docker/docker/internal/testutil" |
| "github.com/go-check/check" |
| "github.com/gotestyourself/gotestyourself/icmd" |
| "github.com/pkg/errors" |
| ) |
| |
| func getPrefixAndSlashFromDaemonPlatform() (prefix, slash string) { |
| if testEnv.DaemonPlatform() == "windows" { |
| return "c:", `\` |
| } |
| return "", "/" |
| } |
| |
| // TODO: update code to call cmd.RunCmd directly, and remove this function |
| // Deprecated: use gotestyourself/gotestyourself/icmd |
| func runCommandWithOutput(execCmd *exec.Cmd) (string, int, error) { |
| result := icmd.RunCmd(transformCmd(execCmd)) |
| return result.Combined(), result.ExitCode, result.Error |
| } |
| |
| // Temporary shim for migrating commands to the new function |
| func transformCmd(execCmd *exec.Cmd) icmd.Cmd { |
| return icmd.Cmd{ |
| Command: execCmd.Args, |
| Env: execCmd.Env, |
| Dir: execCmd.Dir, |
| Stdin: execCmd.Stdin, |
| Stdout: execCmd.Stdout, |
| } |
| } |
| |
| // ParseCgroupPaths parses 'procCgroupData', which is output of '/proc/<pid>/cgroup', and returns |
| // a map which cgroup name as key and path as value. |
| func ParseCgroupPaths(procCgroupData string) map[string]string { |
| cgroupPaths := map[string]string{} |
| for _, line := range strings.Split(procCgroupData, "\n") { |
| parts := strings.Split(line, ":") |
| if len(parts) != 3 { |
| continue |
| } |
| cgroupPaths[parts[1]] = parts[2] |
| } |
| return cgroupPaths |
| } |
| |
| // RandomTmpDirPath provides a temporary path with rand string appended. |
| // does not create or checks if it exists. |
| func RandomTmpDirPath(s string, platform string) string { |
| // TODO: why doesn't this use os.TempDir() ? |
| tmp := "/tmp" |
| if platform == "windows" { |
| tmp = os.Getenv("TEMP") |
| } |
| path := filepath.Join(tmp, fmt.Sprintf("%s.%s", s, testutil.GenerateRandomAlphaOnlyString(10))) |
| if platform == "windows" { |
| return filepath.FromSlash(path) // Using \ |
| } |
| return filepath.ToSlash(path) // Using / |
| } |
| |
| // RunCommandPipelineWithOutput runs the array of commands with the output |
| // of each pipelined with the following (like cmd1 | cmd2 | cmd3 would do). |
| // It returns the final output, the exitCode different from 0 and the error |
| // if something bad happened. |
| // Deprecated: use icmd instead |
| func RunCommandPipelineWithOutput(cmds ...*exec.Cmd) (output string, err error) { |
| if len(cmds) < 2 { |
| return "", errors.New("pipeline does not have multiple cmds") |
| } |
| |
| // connect stdin of each cmd to stdout pipe of previous cmd |
| for i, cmd := range cmds { |
| if i > 0 { |
| prevCmd := cmds[i-1] |
| cmd.Stdin, err = prevCmd.StdoutPipe() |
| |
| if err != nil { |
| return "", fmt.Errorf("cannot set stdout pipe for %s: %v", cmd.Path, err) |
| } |
| } |
| } |
| |
| // start all cmds except the last |
| for _, cmd := range cmds[:len(cmds)-1] { |
| if err = cmd.Start(); err != nil { |
| return "", fmt.Errorf("starting %s failed with error: %v", cmd.Path, err) |
| } |
| } |
| |
| defer func() { |
| var pipeErrMsgs []string |
| // wait all cmds except the last to release their resources |
| for _, cmd := range cmds[:len(cmds)-1] { |
| if pipeErr := cmd.Wait(); pipeErr != nil { |
| pipeErrMsgs = append(pipeErrMsgs, fmt.Sprintf("command %s failed with error: %v", cmd.Path, pipeErr)) |
| } |
| } |
| if len(pipeErrMsgs) > 0 && err == nil { |
| err = fmt.Errorf("pipelineError from Wait: %v", strings.Join(pipeErrMsgs, ", ")) |
| } |
| }() |
| |
| // wait on last cmd |
| out, err := cmds[len(cmds)-1].CombinedOutput() |
| return string(out), err |
| } |
| |
| type elementListOptions struct { |
| element, format string |
| } |
| |
| func existingElements(c *check.C, opts elementListOptions) []string { |
| args := []string{} |
| switch opts.element { |
| case "container": |
| args = append(args, "ps", "-a") |
| case "image": |
| args = append(args, "images", "-a") |
| case "network": |
| args = append(args, "network", "ls") |
| case "plugin": |
| args = append(args, "plugin", "ls") |
| case "volume": |
| args = append(args, "volume", "ls") |
| } |
| if opts.format != "" { |
| args = append(args, "--format", opts.format) |
| } |
| out, _ := dockerCmd(c, args...) |
| lines := []string{} |
| for _, l := range strings.Split(out, "\n") { |
| if l != "" { |
| lines = append(lines, l) |
| } |
| } |
| return lines |
| } |
| |
| // ExistingContainerIDs returns a list of currently existing container IDs. |
| func ExistingContainerIDs(c *check.C) []string { |
| return existingElements(c, elementListOptions{element: "container", format: "{{.ID}}"}) |
| } |
| |
| // ExistingContainerNames returns a list of existing container names. |
| func ExistingContainerNames(c *check.C) []string { |
| return existingElements(c, elementListOptions{element: "container", format: "{{.Names}}"}) |
| } |
| |
| // RemoveLinesForExistingElements removes existing elements from the output of a |
| // docker command. |
| // This function takes an output []string and returns a []string. |
| func RemoveLinesForExistingElements(output, existing []string) []string { |
| for _, e := range existing { |
| index := -1 |
| for i, line := range output { |
| if strings.Contains(line, e) { |
| index = i |
| break |
| } |
| } |
| if index != -1 { |
| output = append(output[:index], output[index+1:]...) |
| } |
| } |
| return output |
| } |
| |
| // RemoveOutputForExistingElements removes existing elements from the output of |
| // a docker command. |
| // This function takes an output string and returns a string. |
| func RemoveOutputForExistingElements(output string, existing []string) string { |
| res := RemoveLinesForExistingElements(strings.Split(output, "\n"), existing) |
| return strings.Join(res, "\n") |
| } |