lib/crunchrun/executor_test.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package crunchrun
   6
   7 import (
   8         "bytes"
   9         "io"
  10         "io/ioutil"
  11         "net/http"
  12         "os"
  13         "strings"
  14         "time"
  15
  16         "git.arvados.org/arvados.git/sdk/go/arvados"
  17         "golang.org/x/net/context"
  18         . "gopkg.in/check.v1"
  19 )
  20
  21 func busyboxDockerImage(c *C) string {
  22         fnm := "busybox_uclibc.tar"
  23         cachedir := c.MkDir()
  24         cachefile := cachedir + "/" + fnm
  25         if _, err := os.Stat(cachefile); err == nil {
  26                 return cachefile
  27         }
  28
  29         f, err := ioutil.TempFile(cachedir, "")
  30         c.Assert(err, IsNil)
  31         defer f.Close()
  32         defer os.Remove(f.Name())
  33
  34         resp, err := http.Get("https://cache.arvados.org/" + fnm)
  35         c.Assert(err, IsNil)
  36         defer resp.Body.Close()
  37         _, err = io.Copy(f, resp.Body)
  38         c.Assert(err, IsNil)
  39         err = f.Close()
  40         c.Assert(err, IsNil)
  41         err = os.Rename(f.Name(), cachefile)
  42         c.Assert(err, IsNil)
  43
  44         return cachefile
  45 }
  46
  47 type nopWriteCloser struct{ io.Writer }
  48
  49 func (nopWriteCloser) Close() error { return nil }
  50
  51 // embedded by dockerSuite and singularitySuite so they can share
  52 // tests.
  53 type executorSuite struct {
  54         newExecutor func(*C) // embedding struct's SetUpSuite method must set this
  55         executor    containerExecutor
  56         spec        containerSpec
  57         stdout      bytes.Buffer
  58         stderr      bytes.Buffer
  59 }
  60
  61 func (s *executorSuite) SetUpTest(c *C) {
  62         s.newExecutor(c)
  63         s.stdout = bytes.Buffer{}
  64         s.stderr = bytes.Buffer{}
  65         s.spec = containerSpec{
  66                 Image:       "busybox:uclibc",
  67                 VCPUs:       1,
  68                 WorkingDir:  "",
  69                 Env:         map[string]string{"PATH": "/bin:/usr/bin"},
  70                 NetworkMode: "default",
  71                 Stdout:      nopWriteCloser{&s.stdout},
  72                 Stderr:      nopWriteCloser{&s.stderr},
  73         }
  74         err := s.executor.LoadImage("", busyboxDockerImage(c), arvados.Container{}, "", nil)
  75         c.Assert(err, IsNil)
  76 }
  77
  78 func (s *executorSuite) TearDownTest(c *C) {
  79         s.executor.Close()
  80 }
  81
  82 func (s *executorSuite) TestExecTrivialContainer(c *C) {
  83         s.spec.Command = []string{"echo", "ok"}
  84         s.checkRun(c, 0)
  85         c.Check(s.stdout.String(), Equals, "ok\n")
  86         c.Check(s.stderr.String(), Equals, "")
  87 }
  88
  89 func (s *executorSuite) TestExitStatus(c *C) {
  90         s.spec.Command = []string{"false"}
  91         s.checkRun(c, 1)
  92 }
  93
  94 func (s *executorSuite) TestSignalExitStatus(c *C) {
  95         if _, isdocker := s.executor.(*dockerExecutor); isdocker {
  96                 // It's not quite this easy to make busybox kill
  97                 // itself in docker where it's pid 1.
  98                 c.Skip("kill -9 $$ doesn't work on busybox with pid=1 in docker")
  99                 return
 100         }
 101         s.spec.Command = []string{"sh", "-c", "kill -9 $$"}
 102         s.checkRun(c, 0x80+9)
 103 }
 104
 105 func (s *executorSuite) TestExecStop(c *C) {
 106         s.spec.Command = []string{"sh", "-c", "sleep 10; echo ok"}
 107         err := s.executor.Create(s.spec)
 108         c.Assert(err, IsNil)
 109         err = s.executor.Start()
 110         c.Assert(err, IsNil)
 111         go func() {
 112                 time.Sleep(time.Second / 10)
 113                 s.executor.Stop()
 114         }()
 115         ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(10*time.Second))
 116         defer cancel()
 117         code, err := s.executor.Wait(ctx)
 118         c.Check(code, Not(Equals), 0)
 119         c.Check(err, IsNil)
 120         c.Check(s.stdout.String(), Equals, "")
 121         c.Check(s.stderr.String(), Equals, "")
 122 }
 123
 124 func (s *executorSuite) TestExecCleanEnv(c *C) {
 125         s.spec.Command = []string{"env"}
 126         s.checkRun(c, 0)
 127         c.Check(s.stderr.String(), Equals, "")
 128         got := map[string]string{}
 129         for _, kv := range strings.Split(s.stdout.String(), "\n") {
 130                 if kv == "" {
 131                         continue
 132                 }
 133                 kv := strings.SplitN(kv, "=", 2)
 134                 switch kv[0] {
 135                 case "HOSTNAME", "HOME":
 136                         // docker sets these by itself
 137                 case "LD_LIBRARY_PATH", "SINGULARITY_NAME", "PWD", "LANG", "SHLVL", "SINGULARITY_INIT", "SINGULARITY_CONTAINER":
 138                         // singularity sets these by itself (cf. https://sylabs.io/guides/3.5/user-guide/environment_and_metadata.html)
 139                 case "SINGULARITY_APPNAME":
 140                         // singularity also sets this by itself (v3.5.2, but not v3.7.4)
 141                 case "PROMPT_COMMAND", "PS1", "SINGULARITY_BIND", "SINGULARITY_COMMAND", "SINGULARITY_ENVIRONMENT":
 142                         // singularity also sets these by itself (v3.7.4)
 143                 default:
 144                         got[kv[0]] = kv[1]
 145                 }
 146         }
 147         c.Check(got, DeepEquals, s.spec.Env)
 148 }
 149 func (s *executorSuite) TestExecEnableNetwork(c *C) {
 150         for _, enable := range []bool{false, true} {
 151                 s.SetUpTest(c)
 152                 s.spec.Command = []string{"ip", "route"}
 153                 s.spec.EnableNetwork = enable
 154                 s.checkRun(c, 0)
 155                 if enable {
 156                         c.Check(s.stdout.String(), Matches, "(?ms).*default via.*")
 157                 } else {
 158                         c.Check(s.stdout.String(), Equals, "")
 159                 }
 160         }
 161 }
 162
 163 func (s *executorSuite) TestExecWorkingDir(c *C) {
 164         s.spec.WorkingDir = "/tmp"
 165         s.spec.Command = []string{"sh", "-c", "pwd"}
 166         s.checkRun(c, 0)
 167         c.Check(s.stdout.String(), Equals, "/tmp\n")
 168 }
 169
 170 func (s *executorSuite) TestExecStdoutStderr(c *C) {
 171         s.spec.Command = []string{"sh", "-c", "echo foo; echo -n bar >&2; echo baz; echo waz >&2"}
 172         s.checkRun(c, 0)
 173         c.Check(s.stdout.String(), Equals, "foo\nbaz\n")
 174         c.Check(s.stderr.String(), Equals, "barwaz\n")
 175 }
 176
 177 func (s *executorSuite) checkRun(c *C, expectCode int) {
 178         c.Assert(s.executor.Create(s.spec), IsNil)
 179         c.Assert(s.executor.Start(), IsNil)
 180         ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(10*time.Second))
 181         defer cancel()
 182         code, err := s.executor.Wait(ctx)
 183         c.Assert(err, IsNil)
 184         c.Check(code, Equals, expectCode)
 185 }