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"
  12         "net/http"
  13         "os"
  14         "strings"
  15         "time"
  16
  17         "git.arvados.org/arvados.git/sdk/go/arvados"
  18         "golang.org/x/net/context"
  19         . "gopkg.in/check.v1"
  20 )
  21
  22 func busyboxDockerImage(c *C) string {
  23         fnm := "busybox_uclibc.tar"
  24         cachedir := c.MkDir()
  25         cachefile := cachedir + "/" + fnm
  26         if _, err := os.Stat(cachefile); err == nil {
  27                 return cachefile
  28         }
  29
  30         f, err := ioutil.TempFile(cachedir, "")
  31         c.Assert(err, IsNil)
  32         defer f.Close()
  33         defer os.Remove(f.Name())
  34
  35         resp, err := http.Get("https://cache.arvados.org/" + fnm)
  36         c.Assert(err, IsNil)
  37         defer resp.Body.Close()
  38         _, err = io.Copy(f, resp.Body)
  39         c.Assert(err, IsNil)
  40         err = f.Close()
  41         c.Assert(err, IsNil)
  42         err = os.Rename(f.Name(), cachefile)
  43         c.Assert(err, IsNil)
  44
  45         return cachefile
  46 }
  47
  48 type nopWriteCloser struct{ io.Writer }
  49
  50 func (nopWriteCloser) Close() error { return nil }
  51
  52 // embedded by dockerSuite and singularitySuite so they can share
  53 // tests.
  54 type executorSuite struct {
  55         newExecutor func(*C) // embedding struct's SetUpSuite method must set this
  56         executor    containerExecutor
  57         spec        containerSpec
  58         stdout      bytes.Buffer
  59         stderr      bytes.Buffer
  60 }
  61
  62 func (s *executorSuite) SetUpTest(c *C) {
  63         s.newExecutor(c)
  64         s.stdout = bytes.Buffer{}
  65         s.stderr = bytes.Buffer{}
  66         s.spec = containerSpec{
  67                 Image:       "busybox:uclibc",
  68                 VCPUs:       1,
  69                 WorkingDir:  "",
  70                 Env:         map[string]string{"PATH": "/bin:/usr/bin"},
  71                 NetworkMode: "default",
  72                 Stdout:      nopWriteCloser{&s.stdout},
  73                 Stderr:      nopWriteCloser{&s.stderr},
  74         }
  75         err := s.executor.LoadImage("", busyboxDockerImage(c), arvados.Container{}, "", nil)
  76         c.Assert(err, IsNil)
  77 }
  78
  79 func (s *executorSuite) TearDownTest(c *C) {
  80         s.executor.Close()
  81 }
  82
  83 func (s *executorSuite) TestExecTrivialContainer(c *C) {
  84         s.spec.Command = []string{"echo", "ok"}
  85         s.checkRun(c, 0)
  86         c.Check(s.stdout.String(), Equals, "ok\n")
  87         c.Check(s.stderr.String(), Equals, "")
  88 }
  89
  90 func (s *executorSuite) TestExitStatus(c *C) {
  91         s.spec.Command = []string{"false"}
  92         s.checkRun(c, 1)
  93 }
  94
  95 func (s *executorSuite) TestSignalExitStatus(c *C) {
  96         if _, isdocker := s.executor.(*dockerExecutor); isdocker {
  97                 // It's not quite this easy to make busybox kill
  98                 // itself in docker where it's pid 1.
  99                 c.Skip("kill -9 $$ doesn't work on busybox with pid=1 in docker")
 100                 return
 101         }
 102         s.spec.Command = []string{"sh", "-c", "kill -9 $$"}
 103         s.checkRun(c, 0x80+9)
 104 }
 105
 106 func (s *executorSuite) TestExecStop(c *C) {
 107         s.spec.Command = []string{"sh", "-c", "sleep 10; echo ok"}
 108         err := s.executor.Create(s.spec)
 109         c.Assert(err, IsNil)
 110         err = s.executor.Start()
 111         c.Assert(err, IsNil)
 112         go func() {
 113                 time.Sleep(time.Second / 10)
 114                 s.executor.Stop()
 115         }()
 116         ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(10*time.Second))
 117         defer cancel()
 118         code, err := s.executor.Wait(ctx)
 119         c.Check(code, Not(Equals), 0)
 120         c.Check(err, IsNil)
 121         c.Check(s.stdout.String(), Equals, "")
 122         c.Check(s.stderr.String(), Equals, "")
 123 }
 124
 125 func (s *executorSuite) TestExecCleanEnv(c *C) {
 126         s.spec.Command = []string{"env"}
 127         s.checkRun(c, 0)
 128         c.Check(s.stderr.String(), Equals, "")
 129         got := map[string]string{}
 130         for _, kv := range strings.Split(s.stdout.String(), "\n") {
 131                 if kv == "" {
 132                         continue
 133                 }
 134                 kv := strings.SplitN(kv, "=", 2)
 135                 switch kv[0] {
 136                 case "HOSTNAME", "HOME":
 137                         // docker sets these by itself
 138                 case "LD_LIBRARY_PATH", "SINGULARITY_NAME", "PWD", "LANG", "SHLVL", "SINGULARITY_INIT", "SINGULARITY_CONTAINER":
 139                         // singularity sets these by itself (cf. https://sylabs.io/guides/3.5/user-guide/environment_and_metadata.html)
 140                 case "SINGULARITY_APPNAME":
 141                         // singularity also sets this by itself (v3.5.2, but not v3.7.4)
 142                 case "PROMPT_COMMAND", "PS1", "SINGULARITY_BIND", "SINGULARITY_COMMAND", "SINGULARITY_ENVIRONMENT":
 143                         // singularity also sets these by itself (v3.7.4)
 144                 default:
 145                         got[kv[0]] = kv[1]
 146                 }
 147         }
 148         c.Check(got, DeepEquals, s.spec.Env)
 149 }
 150 func (s *executorSuite) TestExecEnableNetwork(c *C) {
 151         for _, enable := range []bool{false, true} {
 152                 s.SetUpTest(c)
 153                 s.spec.Command = []string{"ip", "route"}
 154                 s.spec.EnableNetwork = enable
 155                 s.checkRun(c, 0)
 156                 if enable {
 157                         c.Check(s.stdout.String(), Matches, "(?ms).*default via.*")
 158                 } else {
 159                         c.Check(s.stdout.String(), Equals, "")
 160                 }
 161         }
 162 }
 163
 164 func (s *executorSuite) TestExecWorkingDir(c *C) {
 165         s.spec.WorkingDir = "/tmp"
 166         s.spec.Command = []string{"sh", "-c", "pwd"}
 167         s.checkRun(c, 0)
 168         c.Check(s.stdout.String(), Equals, "/tmp\n")
 169 }
 170
 171 func (s *executorSuite) TestExecStdoutStderr(c *C) {
 172         s.spec.Command = []string{"sh", "-c", "echo foo; echo -n bar >&2; echo baz; echo waz >&2"}
 173         s.checkRun(c, 0)
 174         c.Check(s.stdout.String(), Equals, "foo\nbaz\n")
 175         c.Check(s.stderr.String(), Equals, "barwaz\n")
 176 }
 177
 178 func (s *executorSuite) TestIPAddress(c *C) {
 179         s.spec.Command = []string{"nc", "-l", "-p", "1951", "-e", "printf", `HTTP/1.1 418 I'm a teapot\r\n\r\n`}
 180         s.spec.EnableNetwork = true
 181         c.Assert(s.executor.Create(s.spec), IsNil)
 182         c.Assert(s.executor.Start(), IsNil)
 183         starttime := time.Now()
 184
 185         ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(2*time.Second))
 186         defer cancel()
 187
 188         for ctx.Err() == nil {
 189                 time.Sleep(time.Second / 10)
 190                 _, err := s.executor.IPAddress()
 191                 if err == nil {
 192                         break
 193                 }
 194         }
 195         ip, err := s.executor.IPAddress()
 196         if c.Check(err, IsNil) && c.Check(ip, Not(Equals), "") {
 197                 req, err := http.NewRequest("BREW", "http://"+net.JoinHostPort(ip, "1951"), nil)
 198                 c.Assert(err, IsNil)
 199                 resp, err := http.DefaultClient.Do(req)
 200                 c.Assert(err, IsNil)
 201                 c.Check(resp.StatusCode, Equals, http.StatusTeapot)
 202         }
 203
 204         s.executor.Stop()
 205         code, _ := s.executor.Wait(ctx)
 206         c.Logf("container ran for %v", time.Now().Sub(starttime))
 207         c.Check(code, Equals, -1)
 208 }
 209
 210 func (s *executorSuite) TestInject(c *C) {
 211         s.spec.Command = []string{"sleep", "10"}
 212         c.Assert(s.executor.Create(s.spec), IsNil)
 213         c.Assert(s.executor.Start(), IsNil)
 214         starttime := time.Now()
 215
 216         ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(2*time.Second))
 217         defer cancel()
 218
 219         injectcmd := []string{"cat", "/proc/1/cmdline"}
 220         cmd, err := s.executor.InjectCommand(ctx, "", "root", false, injectcmd)
 221         c.Assert(err, IsNil)
 222         out, err := cmd.CombinedOutput()
 223         c.Logf("inject %s => %q", injectcmd, out)
 224         c.Check(err, IsNil)
 225         c.Check(string(out), Equals, "sleep\00010\000")
 226
 227         s.executor.Stop()
 228         code, _ := s.executor.Wait(ctx)
 229         c.Logf("container ran for %v", time.Now().Sub(starttime))
 230         c.Check(code, Equals, -1)
 231 }
 232
 233 func (s *executorSuite) checkRun(c *C, expectCode int) {
 234         c.Assert(s.executor.Create(s.spec), IsNil)
 235         c.Assert(s.executor.Start(), IsNil)
 236         ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(10*time.Second))
 237         defer cancel()
 238         code, err := s.executor.Wait(ctx)
 239         c.Assert(err, IsNil)
 240         c.Check(code, Equals, expectCode)
 241 }