services/crunch-run/crunchrun_test.go

   1 package main
   2
   3 import (
   4         "bytes"
   5         "crypto/md5"
   6         "encoding/json"
   7         "errors"
   8         "fmt"
   9         "git.curoverse.com/arvados.git/sdk/go/arvados"
  10         "git.curoverse.com/arvados.git/sdk/go/arvadosclient"
  11         "git.curoverse.com/arvados.git/sdk/go/keepclient"
  12         "git.curoverse.com/arvados.git/sdk/go/manifest"
  13         "github.com/curoverse/dockerclient"
  14         . "gopkg.in/check.v1"
  15         "io"
  16         "io/ioutil"
  17         "log"
  18         "os"
  19         "os/exec"
  20         "sort"
  21         "strings"
  22         "sync"
  23         "syscall"
  24         "testing"
  25         "time"
  26 )
  27
  28 // Gocheck boilerplate
  29 func TestCrunchExec(t *testing.T) {
  30         TestingT(t)
  31 }
  32
  33 type TestSuite struct{}
  34
  35 // Gocheck boilerplate
  36 var _ = Suite(&TestSuite{})
  37
  38 type ArvTestClient struct {
  39         Total   int64
  40         Calls   int
  41         Content []arvadosclient.Dict
  42         arvados.Container
  43         Logs          map[string]*bytes.Buffer
  44         WasSetRunning bool
  45         sync.Mutex
  46 }
  47
  48 type KeepTestClient struct {
  49         Called  bool
  50         Content []byte
  51 }
  52
  53 var hwManifest = ". 82ab40c24fc8df01798e57ba66795bb1+841216+Aa124ac75e5168396c73c0a18eda641a4f41791c0@569fa8c3 0:841216:9c31ee32b3d15268a0754e8edc74d4f815ee014b693bc5109058e431dd5caea7.tar\n"
  54 var hwPDH = "a45557269dcb65a6b78f9ac061c0850b+120"
  55 var hwImageId = "9c31ee32b3d15268a0754e8edc74d4f815ee014b693bc5109058e431dd5caea7"
  56
  57 var otherManifest = ". 68a84f561b1d1708c6baff5e019a9ab3+46+Ae5d0af96944a3690becb1decdf60cc1c937f556d@5693216f 0:46:md5sum.txt\n"
  58 var otherPDH = "a3e8f74c6f101eae01fa08bfb4e49b3a+54"
  59
  60 var fakeAuthUUID = "zzzzz-gj3su-55pqoyepgi2glem"
  61 var fakeAuthToken = "a3ltuwzqcu2u4sc0q7yhpc2w7s00fdcqecg5d6e0u3pfohmbjt"
  62
  63 type TestDockerClient struct {
  64         imageLoaded string
  65         logReader   io.ReadCloser
  66         logWriter   io.WriteCloser
  67         fn          func(t *TestDockerClient)
  68         finish      chan dockerclient.WaitResult
  69         stop        chan bool
  70         cwd         string
  71         env         []string
  72 }
  73
  74 func NewTestDockerClient() *TestDockerClient {
  75         t := &TestDockerClient{}
  76         t.logReader, t.logWriter = io.Pipe()
  77         t.finish = make(chan dockerclient.WaitResult)
  78         t.stop = make(chan bool)
  79         t.cwd = "/"
  80         return t
  81 }
  82
  83 func (t *TestDockerClient) StopContainer(id string, timeout int) error {
  84         t.stop <- true
  85         return nil
  86 }
  87
  88 func (t *TestDockerClient) InspectImage(id string) (*dockerclient.ImageInfo, error) {
  89         if t.imageLoaded == id {
  90                 return &dockerclient.ImageInfo{}, nil
  91         } else {
  92                 return nil, errors.New("")
  93         }
  94 }
  95
  96 func (t *TestDockerClient) LoadImage(reader io.Reader) error {
  97         _, err := io.Copy(ioutil.Discard, reader)
  98         if err != nil {
  99                 return err
 100         } else {
 101                 t.imageLoaded = hwImageId
 102                 return nil
 103         }
 104 }
 105
 106 func (t *TestDockerClient) CreateContainer(config *dockerclient.ContainerConfig, name string, authConfig *dockerclient.AuthConfig) (string, error) {
 107         if config.WorkingDir != "" {
 108                 t.cwd = config.WorkingDir
 109         }
 110         t.env = config.Env
 111         return "abcde", nil
 112 }
 113
 114 func (t *TestDockerClient) StartContainer(id string, config *dockerclient.HostConfig) error {
 115         if id == "abcde" {
 116                 go t.fn(t)
 117                 return nil
 118         } else {
 119                 return errors.New("Invalid container id")
 120         }
 121 }
 122
 123 func (t *TestDockerClient) AttachContainer(id string, options *dockerclient.AttachOptions) (io.ReadCloser, error) {
 124         return t.logReader, nil
 125 }
 126
 127 func (t *TestDockerClient) Wait(id string) <-chan dockerclient.WaitResult {
 128         return t.finish
 129 }
 130
 131 func (*TestDockerClient) RemoveImage(name string, force bool) ([]*dockerclient.ImageDelete, error) {
 132         return nil, nil
 133 }
 134
 135 func (this *ArvTestClient) Create(resourceType string,
 136         parameters arvadosclient.Dict,
 137         output interface{}) error {
 138
 139         this.Mutex.Lock()
 140         defer this.Mutex.Unlock()
 141
 142         this.Calls += 1
 143         this.Content = append(this.Content, parameters)
 144
 145         if resourceType == "logs" {
 146                 et := parameters["log"].(arvadosclient.Dict)["event_type"].(string)
 147                 if this.Logs == nil {
 148                         this.Logs = make(map[string]*bytes.Buffer)
 149                 }
 150                 if this.Logs[et] == nil {
 151                         this.Logs[et] = &bytes.Buffer{}
 152                 }
 153                 this.Logs[et].Write([]byte(parameters["log"].(arvadosclient.Dict)["properties"].(map[string]string)["text"]))
 154         }
 155
 156         if resourceType == "collections" && output != nil {
 157                 mt := parameters["collection"].(arvadosclient.Dict)["manifest_text"].(string)
 158                 outmap := output.(*CollectionRecord)
 159                 outmap.PortableDataHash = fmt.Sprintf("%x+%d", md5.Sum([]byte(mt)), len(mt))
 160         }
 161
 162         return nil
 163 }
 164
 165 func (this *ArvTestClient) Call(method, resourceType, uuid, action string, parameters arvadosclient.Dict, output interface{}) error {
 166         switch {
 167         case method == "GET" && resourceType == "containers" && action == "auth":
 168                 return json.Unmarshal([]byte(`{
 169                         "kind": "arvados#api_client_authorization",
 170                         "uuid": "`+fakeAuthUUID+`",
 171                         "api_token": "`+fakeAuthToken+`"
 172                         }`), output)
 173         default:
 174                 return fmt.Errorf("Not found")
 175         }
 176 }
 177
 178 func (this *ArvTestClient) Get(resourceType string, uuid string, parameters arvadosclient.Dict, output interface{}) error {
 179         if resourceType == "collections" {
 180                 if uuid == hwPDH {
 181                         output.(*CollectionRecord).ManifestText = hwManifest
 182                 } else if uuid == otherPDH {
 183                         output.(*CollectionRecord).ManifestText = otherManifest
 184                 }
 185         }
 186         if resourceType == "containers" {
 187                 (*output.(*arvados.Container)) = this.Container
 188         }
 189         return nil
 190 }
 191
 192 func (this *ArvTestClient) Update(resourceType string, uuid string, parameters arvadosclient.Dict, output interface{}) (err error) {
 193         this.Mutex.Lock()
 194         defer this.Mutex.Unlock()
 195         this.Calls += 1
 196         this.Content = append(this.Content, parameters)
 197         if resourceType == "containers" {
 198                 if parameters["container"].(arvadosclient.Dict)["state"] == "Running" {
 199                         this.WasSetRunning = true
 200                 }
 201         }
 202         return nil
 203 }
 204
 205 // CalledWith returns the parameters from the first API call whose
 206 // parameters match jpath/string. E.g., CalledWith(c, "foo.bar",
 207 // "baz") returns parameters with parameters["foo"]["bar"]=="baz". If
 208 // no call matches, it returns nil.
 209 func (this *ArvTestClient) CalledWith(jpath, expect string) arvadosclient.Dict {
 210 call:
 211         for _, content := range this.Content {
 212                 var v interface{} = content
 213                 for _, k := range strings.Split(jpath, ".") {
 214                         if dict, ok := v.(arvadosclient.Dict); !ok {
 215                                 continue call
 216                         } else {
 217                                 v = dict[k]
 218                         }
 219                 }
 220                 if v, ok := v.(string); ok && v == expect {
 221                         return content
 222                 }
 223         }
 224         return nil
 225 }
 226
 227 func (this *KeepTestClient) PutHB(hash string, buf []byte) (string, int, error) {
 228         this.Content = buf
 229         return fmt.Sprintf("%s+%d", hash, len(buf)), len(buf), nil
 230 }
 231
 232 type FileWrapper struct {
 233         io.ReadCloser
 234         len uint64
 235 }
 236
 237 func (this FileWrapper) Len() uint64 {
 238         return this.len
 239 }
 240
 241 func (this *KeepTestClient) ManifestFileReader(m manifest.Manifest, filename string) (keepclient.ReadCloserWithLen, error) {
 242         if filename == hwImageId+".tar" {
 243                 rdr := ioutil.NopCloser(&bytes.Buffer{})
 244                 this.Called = true
 245                 return FileWrapper{rdr, 1321984}, nil
 246         }
 247         return nil, nil
 248 }
 249
 250 func (s *TestSuite) TestLoadImage(c *C) {
 251         kc := &KeepTestClient{}
 252         docker := NewTestDockerClient()
 253         cr := NewContainerRunner(&ArvTestClient{}, kc, docker, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 254
 255         _, err := cr.Docker.RemoveImage(hwImageId, true)
 256
 257         _, err = cr.Docker.InspectImage(hwImageId)
 258         c.Check(err, NotNil)
 259
 260         cr.Container.ContainerImage = hwPDH
 261
 262         // (1) Test loading image from keep
 263         c.Check(kc.Called, Equals, false)
 264         c.Check(cr.ContainerConfig.Image, Equals, "")
 265
 266         err = cr.LoadImage()
 267
 268         c.Check(err, IsNil)
 269         defer func() {
 270                 cr.Docker.RemoveImage(hwImageId, true)
 271         }()
 272
 273         c.Check(kc.Called, Equals, true)
 274         c.Check(cr.ContainerConfig.Image, Equals, hwImageId)
 275
 276         _, err = cr.Docker.InspectImage(hwImageId)
 277         c.Check(err, IsNil)
 278
 279         // (2) Test using image that's already loaded
 280         kc.Called = false
 281         cr.ContainerConfig.Image = ""
 282
 283         err = cr.LoadImage()
 284         c.Check(err, IsNil)
 285         c.Check(kc.Called, Equals, false)
 286         c.Check(cr.ContainerConfig.Image, Equals, hwImageId)
 287
 288 }
 289
 290 type ArvErrorTestClient struct{}
 291 type KeepErrorTestClient struct{}
 292 type KeepReadErrorTestClient struct{}
 293
 294 func (this ArvErrorTestClient) Create(resourceType string,
 295         parameters arvadosclient.Dict,
 296         output interface{}) error {
 297         return nil
 298 }
 299
 300 func (this ArvErrorTestClient) Call(method, resourceType, uuid, action string, parameters arvadosclient.Dict, output interface{}) error {
 301         return errors.New("ArvError")
 302 }
 303
 304 func (this ArvErrorTestClient) Get(resourceType string, uuid string, parameters arvadosclient.Dict, output interface{}) error {
 305         return errors.New("ArvError")
 306 }
 307
 308 func (this ArvErrorTestClient) Update(resourceType string, uuid string, parameters arvadosclient.Dict, output interface{}) (err error) {
 309         return nil
 310 }
 311
 312 func (this KeepErrorTestClient) PutHB(hash string, buf []byte) (string, int, error) {
 313         return "", 0, errors.New("KeepError")
 314 }
 315
 316 func (this KeepErrorTestClient) ManifestFileReader(m manifest.Manifest, filename string) (keepclient.ReadCloserWithLen, error) {
 317         return nil, errors.New("KeepError")
 318 }
 319
 320 func (this KeepReadErrorTestClient) PutHB(hash string, buf []byte) (string, int, error) {
 321         return "", 0, nil
 322 }
 323
 324 type ErrorReader struct{}
 325
 326 func (this ErrorReader) Read(p []byte) (n int, err error) {
 327         return 0, errors.New("ErrorReader")
 328 }
 329
 330 func (this ErrorReader) Close() error {
 331         return nil
 332 }
 333
 334 func (this ErrorReader) Len() uint64 {
 335         return 0
 336 }
 337
 338 func (this KeepReadErrorTestClient) ManifestFileReader(m manifest.Manifest, filename string) (keepclient.ReadCloserWithLen, error) {
 339         return ErrorReader{}, nil
 340 }
 341
 342 func (s *TestSuite) TestLoadImageArvError(c *C) {
 343         // (1) Arvados error
 344         cr := NewContainerRunner(ArvErrorTestClient{}, &KeepTestClient{}, nil, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 345         cr.Container.ContainerImage = hwPDH
 346
 347         err := cr.LoadImage()
 348         c.Check(err.Error(), Equals, "While getting container image collection: ArvError")
 349 }
 350
 351 func (s *TestSuite) TestLoadImageKeepError(c *C) {
 352         // (2) Keep error
 353         docker := NewTestDockerClient()
 354         cr := NewContainerRunner(&ArvTestClient{}, KeepErrorTestClient{}, docker, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 355         cr.Container.ContainerImage = hwPDH
 356
 357         err := cr.LoadImage()
 358         c.Check(err.Error(), Equals, "While creating ManifestFileReader for container image: KeepError")
 359 }
 360
 361 func (s *TestSuite) TestLoadImageCollectionError(c *C) {
 362         // (3) Collection doesn't contain image
 363         cr := NewContainerRunner(&ArvTestClient{}, KeepErrorTestClient{}, nil, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 364         cr.Container.ContainerImage = otherPDH
 365
 366         err := cr.LoadImage()
 367         c.Check(err.Error(), Equals, "First file in the container image collection does not end in .tar")
 368 }
 369
 370 func (s *TestSuite) TestLoadImageKeepReadError(c *C) {
 371         // (4) Collection doesn't contain image
 372         docker := NewTestDockerClient()
 373         cr := NewContainerRunner(&ArvTestClient{}, KeepReadErrorTestClient{}, docker, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 374         cr.Container.ContainerImage = hwPDH
 375
 376         err := cr.LoadImage()
 377         c.Check(err, NotNil)
 378 }
 379
 380 type ClosableBuffer struct {
 381         bytes.Buffer
 382 }
 383
 384 type TestLogs struct {
 385         Stdout ClosableBuffer
 386         Stderr ClosableBuffer
 387 }
 388
 389 func (this *ClosableBuffer) Close() error {
 390         return nil
 391 }
 392
 393 func (this *TestLogs) NewTestLoggingWriter(logstr string) io.WriteCloser {
 394         if logstr == "stdout" {
 395                 return &this.Stdout
 396         }
 397         if logstr == "stderr" {
 398                 return &this.Stderr
 399         }
 400         return nil
 401 }
 402
 403 func dockerLog(fd byte, msg string) []byte {
 404         by := []byte(msg)
 405         header := make([]byte, 8+len(by))
 406         header[0] = fd
 407         header[7] = byte(len(by))
 408         copy(header[8:], by)
 409         return header
 410 }
 411
 412 func (s *TestSuite) TestRunContainer(c *C) {
 413         docker := NewTestDockerClient()
 414         docker.fn = func(t *TestDockerClient) {
 415                 t.logWriter.Write(dockerLog(1, "Hello world\n"))
 416                 t.logWriter.Close()
 417                 t.finish <- dockerclient.WaitResult{}
 418         }
 419         cr := NewContainerRunner(&ArvTestClient{}, &KeepTestClient{}, docker, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 420
 421         var logs TestLogs
 422         cr.NewLogWriter = logs.NewTestLoggingWriter
 423         cr.Container.ContainerImage = hwPDH
 424         cr.Container.Command = []string{"./hw"}
 425         err := cr.LoadImage()
 426         c.Check(err, IsNil)
 427
 428         err = cr.CreateContainer()
 429         c.Check(err, IsNil)
 430
 431         err = cr.StartContainer()
 432         c.Check(err, IsNil)
 433
 434         err = cr.WaitFinish()
 435         c.Check(err, IsNil)
 436
 437         c.Check(strings.HasSuffix(logs.Stdout.String(), "Hello world\n"), Equals, true)
 438         c.Check(logs.Stderr.String(), Equals, "")
 439 }
 440
 441 func (s *TestSuite) TestCommitLogs(c *C) {
 442         api := &ArvTestClient{}
 443         kc := &KeepTestClient{}
 444         cr := NewContainerRunner(api, kc, nil, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 445         cr.CrunchLog.Timestamper = (&TestTimestamper{}).Timestamp
 446
 447         cr.CrunchLog.Print("Hello world!")
 448         cr.CrunchLog.Print("Goodbye")
 449         cr.finalState = "Complete"
 450
 451         err := cr.CommitLogs()
 452         c.Check(err, IsNil)
 453
 454         c.Check(api.Calls, Equals, 2)
 455         c.Check(api.Content[1]["collection"].(arvadosclient.Dict)["name"], Equals, "logs for zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 456         c.Check(api.Content[1]["collection"].(arvadosclient.Dict)["manifest_text"], Equals, ". 744b2e4553123b02fa7b452ec5c18993+123 0:123:crunch-run.txt\n")
 457         c.Check(*cr.LogsPDH, Equals, "63da7bdacf08c40f604daad80c261e9a+60")
 458 }
 459
 460 func (s *TestSuite) TestUpdateContainerRunning(c *C) {
 461         api := &ArvTestClient{}
 462         kc := &KeepTestClient{}
 463         cr := NewContainerRunner(api, kc, nil, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 464
 465         err := cr.UpdateContainerRunning()
 466         c.Check(err, IsNil)
 467
 468         c.Check(api.Content[0]["container"].(arvadosclient.Dict)["state"], Equals, "Running")
 469 }
 470
 471 func (s *TestSuite) TestUpdateContainerComplete(c *C) {
 472         api := &ArvTestClient{}
 473         kc := &KeepTestClient{}
 474         cr := NewContainerRunner(api, kc, nil, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 475
 476         cr.LogsPDH = new(string)
 477         *cr.LogsPDH = "d3a229d2fe3690c2c3e75a71a153c6a3+60"
 478
 479         cr.ExitCode = new(int)
 480         *cr.ExitCode = 42
 481         cr.finalState = "Complete"
 482
 483         err := cr.UpdateContainerFinal()
 484         c.Check(err, IsNil)
 485
 486         c.Check(api.Content[0]["container"].(arvadosclient.Dict)["log"], Equals, *cr.LogsPDH)
 487         c.Check(api.Content[0]["container"].(arvadosclient.Dict)["exit_code"], Equals, *cr.ExitCode)
 488         c.Check(api.Content[0]["container"].(arvadosclient.Dict)["state"], Equals, "Complete")
 489 }
 490
 491 func (s *TestSuite) TestUpdateContainerCancelled(c *C) {
 492         api := &ArvTestClient{}
 493         kc := &KeepTestClient{}
 494         cr := NewContainerRunner(api, kc, nil, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 495         cr.Cancelled = true
 496         cr.finalState = "Cancelled"
 497
 498         err := cr.UpdateContainerFinal()
 499         c.Check(err, IsNil)
 500
 501         c.Check(api.Content[0]["container"].(arvadosclient.Dict)["log"], IsNil)
 502         c.Check(api.Content[0]["container"].(arvadosclient.Dict)["exit_code"], IsNil)
 503         c.Check(api.Content[0]["container"].(arvadosclient.Dict)["state"], Equals, "Cancelled")
 504 }
 505
 506 // Used by the TestFullRun*() test below to DRY up boilerplate setup to do full
 507 // dress rehearsal of the Run() function, starting from a JSON container record.
 508 func FullRunHelper(c *C, record string, fn func(t *TestDockerClient)) (api *ArvTestClient, cr *ContainerRunner) {
 509         rec := arvados.Container{}
 510         err := json.Unmarshal([]byte(record), &rec)
 511         c.Check(err, IsNil)
 512
 513         docker := NewTestDockerClient()
 514         docker.fn = fn
 515         docker.RemoveImage(hwImageId, true)
 516
 517         api = &ArvTestClient{Container: rec}
 518         cr = NewContainerRunner(api, &KeepTestClient{}, docker, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 519         am := &ArvMountCmdLine{}
 520         cr.RunArvMount = am.ArvMountTest
 521
 522         err = cr.Run()
 523         c.Check(err, IsNil)
 524         c.Check(api.WasSetRunning, Equals, true)
 525
 526         c.Check(api.Content[api.Calls-1]["container"].(arvadosclient.Dict)["log"], NotNil)
 527
 528         if err != nil {
 529                 for k, v := range api.Logs {
 530                         c.Log(k)
 531                         c.Log(v.String())
 532                 }
 533         }
 534
 535         return
 536 }
 537
 538 func (s *TestSuite) TestFullRunHello(c *C) {
 539         api, _ := FullRunHelper(c, `{
 540     "command": ["echo", "hello world"],
 541     "container_image": "d4ab34d3d4f8a72f5c4973051ae69fab+122",
 542     "cwd": ".",
 543     "environment": {},
 544     "mounts": {"/tmp": {"kind": "tmp"} },
 545     "output_path": "/tmp",
 546     "priority": 1,
 547     "runtime_constraints": {}
 548 }`, func(t *TestDockerClient) {
 549                 t.logWriter.Write(dockerLog(1, "hello world\n"))
 550                 t.logWriter.Close()
 551                 t.finish <- dockerclient.WaitResult{}
 552         })
 553
 554         c.Check(api.Calls, Equals, 7)
 555         c.Check(api.Content[6]["container"].(arvadosclient.Dict)["exit_code"], Equals, 0)
 556         c.Check(api.Content[6]["container"].(arvadosclient.Dict)["state"], Equals, "Complete")
 557
 558         c.Check(strings.HasSuffix(api.Logs["stdout"].String(), "hello world\n"), Equals, true)
 559
 560 }
 561
 562 func (s *TestSuite) TestFullRunStderr(c *C) {
 563         api, _ := FullRunHelper(c, `{
 564     "command": ["/bin/sh", "-c", "echo hello ; echo world 1>&2 ; exit 1"],
 565     "container_image": "d4ab34d3d4f8a72f5c4973051ae69fab+122",
 566     "cwd": ".",
 567     "environment": {},
 568     "mounts": {"/tmp": {"kind": "tmp"} },
 569     "output_path": "/tmp",
 570     "priority": 1,
 571     "runtime_constraints": {}
 572 }`, func(t *TestDockerClient) {
 573                 t.logWriter.Write(dockerLog(1, "hello\n"))
 574                 t.logWriter.Write(dockerLog(2, "world\n"))
 575                 t.logWriter.Close()
 576                 t.finish <- dockerclient.WaitResult{ExitCode: 1}
 577         })
 578
 579         c.Assert(api.Calls, Equals, 8)
 580         c.Check(api.Content[7]["container"].(arvadosclient.Dict)["log"], NotNil)
 581         c.Check(api.Content[7]["container"].(arvadosclient.Dict)["exit_code"], Equals, 1)
 582         c.Check(api.Content[7]["container"].(arvadosclient.Dict)["state"], Equals, "Complete")
 583
 584         c.Check(strings.HasSuffix(api.Logs["stdout"].String(), "hello\n"), Equals, true)
 585         c.Check(strings.HasSuffix(api.Logs["stderr"].String(), "world\n"), Equals, true)
 586 }
 587
 588 func (s *TestSuite) TestFullRunDefaultCwd(c *C) {
 589         api, _ := FullRunHelper(c, `{
 590     "command": ["pwd"],
 591     "container_image": "d4ab34d3d4f8a72f5c4973051ae69fab+122",
 592     "cwd": ".",
 593     "environment": {},
 594     "mounts": {"/tmp": {"kind": "tmp"} },
 595     "output_path": "/tmp",
 596     "priority": 1,
 597     "runtime_constraints": {}
 598 }`, func(t *TestDockerClient) {
 599                 t.logWriter.Write(dockerLog(1, t.cwd+"\n"))
 600                 t.logWriter.Close()
 601                 t.finish <- dockerclient.WaitResult{ExitCode: 0}
 602         })
 603
 604         c.Check(api.Calls, Equals, 7)
 605         c.Check(api.Content[6]["container"].(arvadosclient.Dict)["exit_code"], Equals, 0)
 606         c.Check(api.Content[6]["container"].(arvadosclient.Dict)["state"], Equals, "Complete")
 607
 608         log.Print(api.Logs["stdout"].String())
 609
 610         c.Check(strings.HasSuffix(api.Logs["stdout"].String(), "/\n"), Equals, true)
 611 }
 612
 613 func (s *TestSuite) TestFullRunSetCwd(c *C) {
 614         api, _ := FullRunHelper(c, `{
 615     "command": ["pwd"],
 616     "container_image": "d4ab34d3d4f8a72f5c4973051ae69fab+122",
 617     "cwd": "/bin",
 618     "environment": {},
 619     "mounts": {"/tmp": {"kind": "tmp"} },
 620     "output_path": "/tmp",
 621     "priority": 1,
 622     "runtime_constraints": {}
 623 }`, func(t *TestDockerClient) {
 624                 t.logWriter.Write(dockerLog(1, t.cwd+"\n"))
 625                 t.logWriter.Close()
 626                 t.finish <- dockerclient.WaitResult{ExitCode: 0}
 627         })
 628
 629         c.Check(api.Calls, Equals, 7)
 630         c.Check(api.Content[6]["container"].(arvadosclient.Dict)["exit_code"], Equals, 0)
 631         c.Check(api.Content[6]["container"].(arvadosclient.Dict)["state"], Equals, "Complete")
 632
 633         c.Check(strings.HasSuffix(api.Logs["stdout"].String(), "/bin\n"), Equals, true)
 634 }
 635
 636 func (s *TestSuite) TestCancel(c *C) {
 637         record := `{
 638     "command": ["/bin/sh", "-c", "echo foo && sleep 30 && echo bar"],
 639     "container_image": "d4ab34d3d4f8a72f5c4973051ae69fab+122",
 640     "cwd": ".",
 641     "environment": {},
 642     "mounts": {"/tmp": {"kind": "tmp"} },
 643     "output_path": "/tmp",
 644     "priority": 1,
 645     "runtime_constraints": {}
 646 }`
 647
 648         rec := arvados.Container{}
 649         err := json.Unmarshal([]byte(record), &rec)
 650         c.Check(err, IsNil)
 651
 652         docker := NewTestDockerClient()
 653         docker.fn = func(t *TestDockerClient) {
 654                 <-t.stop
 655                 t.logWriter.Write(dockerLog(1, "foo\n"))
 656                 t.logWriter.Close()
 657                 t.finish <- dockerclient.WaitResult{ExitCode: 0}
 658         }
 659         docker.RemoveImage(hwImageId, true)
 660
 661         api := &ArvTestClient{Container: rec}
 662         cr := NewContainerRunner(api, &KeepTestClient{}, docker, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 663         am := &ArvMountCmdLine{}
 664         cr.RunArvMount = am.ArvMountTest
 665
 666         go func() {
 667                 for cr.ContainerID == "" {
 668                         time.Sleep(time.Millisecond)
 669                 }
 670                 cr.SigChan <- syscall.SIGINT
 671         }()
 672
 673         err = cr.Run()
 674
 675         c.Check(err, IsNil)
 676         if err != nil {
 677                 for k, v := range api.Logs {
 678                         c.Log(k)
 679                         c.Log(v.String())
 680                 }
 681         }
 682
 683         c.Assert(api.Calls, Equals, 6)
 684         c.Check(api.Content[5]["container"].(arvadosclient.Dict)["log"], IsNil)
 685         c.Check(api.Content[5]["container"].(arvadosclient.Dict)["state"], Equals, "Cancelled")
 686         c.Check(strings.HasSuffix(api.Logs["stdout"].String(), "foo\n"), Equals, true)
 687
 688 }
 689
 690 func (s *TestSuite) TestFullRunSetEnv(c *C) {
 691         api, _ := FullRunHelper(c, `{
 692     "command": ["/bin/sh", "-c", "echo $FROBIZ"],
 693     "container_image": "d4ab34d3d4f8a72f5c4973051ae69fab+122",
 694     "cwd": "/bin",
 695     "environment": {"FROBIZ": "bilbo"},
 696     "mounts": {"/tmp": {"kind": "tmp"} },
 697     "output_path": "/tmp",
 698     "priority": 1,
 699     "runtime_constraints": {}
 700 }`, func(t *TestDockerClient) {
 701                 t.logWriter.Write(dockerLog(1, t.env[0][7:]+"\n"))
 702                 t.logWriter.Close()
 703                 t.finish <- dockerclient.WaitResult{ExitCode: 0}
 704         })
 705
 706         c.Check(api.Calls, Equals, 7)
 707         c.Check(api.Content[6]["container"].(arvadosclient.Dict)["exit_code"], Equals, 0)
 708         c.Check(api.Content[6]["container"].(arvadosclient.Dict)["state"], Equals, "Complete")
 709
 710         c.Check(strings.HasSuffix(api.Logs["stdout"].String(), "bilbo\n"), Equals, true)
 711 }
 712
 713 type ArvMountCmdLine struct {
 714         Cmd   []string
 715         token string
 716 }
 717
 718 func (am *ArvMountCmdLine) ArvMountTest(c []string, token string) (*exec.Cmd, error) {
 719         am.Cmd = c
 720         am.token = token
 721         return nil, nil
 722 }
 723
 724 func (s *TestSuite) TestSetupMounts(c *C) {
 725         api := &ArvTestClient{}
 726         kc := &KeepTestClient{}
 727         cr := NewContainerRunner(api, kc, nil, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 728         am := &ArvMountCmdLine{}
 729         cr.RunArvMount = am.ArvMountTest
 730
 731         i := 0
 732         cr.MkTempDir = func(string, string) (string, error) {
 733                 i += 1
 734                 d := fmt.Sprintf("/tmp/mktmpdir%d", i)
 735                 os.Mkdir(d, os.ModePerm)
 736                 return d, nil
 737         }
 738
 739         {
 740                 cr.Container.Mounts = make(map[string]arvados.Mount)
 741                 cr.Container.Mounts["/tmp"] = arvados.Mount{Kind: "tmp"}
 742                 cr.OutputPath = "/tmp"
 743
 744                 err := cr.SetupMounts()
 745                 c.Check(err, IsNil)
 746                 c.Check(am.Cmd, DeepEquals, []string{"--foreground", "--allow-other", "--read-write", "--mount-by-pdh", "by_id", "/tmp/mktmpdir1"})
 747                 c.Check(cr.Binds, DeepEquals, []string{"/tmp/mktmpdir2:/tmp"})
 748                 cr.CleanupDirs()
 749         }
 750
 751         {
 752                 i = 0
 753                 cr.Container.Mounts = make(map[string]arvados.Mount)
 754                 cr.Container.Mounts["/keeptmp"] = arvados.Mount{Kind: "collection", Writable: true}
 755                 cr.OutputPath = "/keeptmp"
 756
 757                 os.MkdirAll("/tmp/mktmpdir1/tmp0", os.ModePerm)
 758
 759                 err := cr.SetupMounts()
 760                 c.Check(err, IsNil)
 761                 c.Check(am.Cmd, DeepEquals, []string{"--foreground", "--allow-other", "--read-write", "--mount-tmp", "tmp0", "--mount-by-pdh", "by_id", "/tmp/mktmpdir1"})
 762                 c.Check(cr.Binds, DeepEquals, []string{"/tmp/mktmpdir1/tmp0:/keeptmp"})
 763                 cr.CleanupDirs()
 764         }
 765
 766         {
 767                 i = 0
 768                 cr.Container.Mounts = make(map[string]arvados.Mount)
 769                 cr.Container.Mounts["/keepinp"] = arvados.Mount{Kind: "collection", PortableDataHash: "59389a8f9ee9d399be35462a0f92541c+53"}
 770                 cr.Container.Mounts["/keepout"] = arvados.Mount{Kind: "collection", Writable: true}
 771                 cr.OutputPath = "/keepout"
 772
 773                 os.MkdirAll("/tmp/mktmpdir1/by_id/59389a8f9ee9d399be35462a0f92541c+53", os.ModePerm)
 774                 os.MkdirAll("/tmp/mktmpdir1/tmp0", os.ModePerm)
 775
 776                 err := cr.SetupMounts()
 777                 c.Check(err, IsNil)
 778                 c.Check(am.Cmd, DeepEquals, []string{"--foreground", "--allow-other", "--read-write", "--mount-tmp", "tmp0", "--mount-by-pdh", "by_id", "/tmp/mktmpdir1"})
 779                 var ss sort.StringSlice = cr.Binds
 780                 ss.Sort()
 781                 c.Check(cr.Binds, DeepEquals, []string{"/tmp/mktmpdir1/by_id/59389a8f9ee9d399be35462a0f92541c+53:/keepinp:ro",
 782                         "/tmp/mktmpdir1/tmp0:/keepout"})
 783                 cr.CleanupDirs()
 784         }
 785 }
 786
 787 func (s *TestSuite) TestStdout(c *C) {
 788         helperRecord := `{`
 789         helperRecord += `"command": ["/bin/sh", "-c", "echo $FROBIZ"],`
 790         helperRecord += `"container_image": "d4ab34d3d4f8a72f5c4973051ae69fab+122",`
 791         helperRecord += `"cwd": "/bin",`
 792         helperRecord += `"environment": {"FROBIZ": "bilbo"},`
 793         helperRecord += `"mounts": {"/tmp": {"kind": "tmp"}, "stdout": {"kind": "file", "path": "/tmp/a/b/c.out"} },`
 794         helperRecord += `"output_path": "/tmp",`
 795         helperRecord += `"priority": 1,`
 796         helperRecord += `"runtime_constraints": {}`
 797         helperRecord += `}`
 798
 799         api, _ := FullRunHelper(c, helperRecord, func(t *TestDockerClient) {
 800                 t.logWriter.Write(dockerLog(1, t.env[0][7:]+"\n"))
 801                 t.logWriter.Close()
 802                 t.finish <- dockerclient.WaitResult{ExitCode: 0}
 803         })
 804
 805         c.Assert(api.Calls, Equals, 6)
 806         c.Check(api.Content[5]["container"].(arvadosclient.Dict)["exit_code"], Equals, 0)
 807         c.Check(api.Content[5]["container"].(arvadosclient.Dict)["state"], Equals, "Complete")
 808         c.Check(api.CalledWith("collection.manifest_text", "./a/b 307372fa8fd5c146b22ae7a45b49bc31+6 0:6:c.out\n"), Not(IsNil))
 809 }
 810
 811 // Used by the TestStdoutWithWrongPath*()
 812 func StdoutErrorRunHelper(c *C, record string, fn func(t *TestDockerClient)) (api *ArvTestClient, cr *ContainerRunner, err error) {
 813         rec := arvados.Container{}
 814         err = json.Unmarshal([]byte(record), &rec)
 815         c.Check(err, IsNil)
 816
 817         docker := NewTestDockerClient()
 818         docker.fn = fn
 819         docker.RemoveImage(hwImageId, true)
 820
 821         api = &ArvTestClient{Container: rec}
 822         cr = NewContainerRunner(api, &KeepTestClient{}, docker, "zzzzz-zzzzz-zzzzzzzzzzzzzzz")
 823         am := &ArvMountCmdLine{}
 824         cr.RunArvMount = am.ArvMountTest
 825
 826         err = cr.Run()
 827         return
 828 }
 829
 830 func (s *TestSuite) TestStdoutWithWrongPath(c *C) {
 831         _, _, err := StdoutErrorRunHelper(c, `{
 832     "mounts": {"/tmp": {"kind": "tmp"}, "stdout": {"kind": "file", "path":"/tmpa.out"} },
 833     "output_path": "/tmp"
 834 }`, func(t *TestDockerClient) {})
 835
 836         c.Check(err, NotNil)
 837         c.Check(strings.Contains(err.Error(), "Stdout path does not start with OutputPath"), Equals, true)
 838 }
 839
 840 func (s *TestSuite) TestStdoutWithWrongKindTmp(c *C) {
 841         _, _, err := StdoutErrorRunHelper(c, `{
 842     "mounts": {"/tmp": {"kind": "tmp"}, "stdout": {"kind": "tmp", "path":"/tmp/a.out"} },
 843     "output_path": "/tmp"
 844 }`, func(t *TestDockerClient) {})
 845
 846         c.Check(err, NotNil)
 847         c.Check(strings.Contains(err.Error(), "Unsupported mount kind 'tmp' for stdout"), Equals, true)
 848 }
 849
 850 func (s *TestSuite) TestStdoutWithWrongKindCollection(c *C) {
 851         _, _, err := StdoutErrorRunHelper(c, `{
 852     "mounts": {"/tmp": {"kind": "tmp"}, "stdout": {"kind": "collection", "path":"/tmp/a.out"} },
 853     "output_path": "/tmp"
 854 }`, func(t *TestDockerClient) {})
 855
 856         c.Check(err, NotNil)
 857         c.Check(strings.Contains(err.Error(), "Unsupported mount kind 'collection' for stdout"), Equals, true)
 858 }