services/keep-web/s3_test.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package main
   6
   7 import (
   8         "bytes"
   9         "crypto/rand"
  10         "fmt"
  11         "io/ioutil"
  12         "net/http"
  13         "net/url"
  14         "os"
  15         "os/exec"
  16         "strings"
  17         "sync"
  18         "time"
  19
  20         "git.arvados.org/arvados.git/sdk/go/arvados"
  21         "git.arvados.org/arvados.git/sdk/go/arvadosclient"
  22         "git.arvados.org/arvados.git/sdk/go/arvadostest"
  23         "git.arvados.org/arvados.git/sdk/go/keepclient"
  24         "github.com/AdRoll/goamz/aws"
  25         "github.com/AdRoll/goamz/s3"
  26         check "gopkg.in/check.v1"
  27 )
  28
  29 type s3stage struct {
  30         arv        *arvados.Client
  31         ac         *arvadosclient.ArvadosClient
  32         kc         *keepclient.KeepClient
  33         proj       arvados.Group
  34         projbucket *s3.Bucket
  35         coll       arvados.Collection
  36         collbucket *s3.Bucket
  37 }
  38
  39 func (s *IntegrationSuite) s3setup(c *check.C) s3stage {
  40         var proj arvados.Group
  41         var coll arvados.Collection
  42         arv := arvados.NewClientFromEnv()
  43         arv.AuthToken = arvadostest.ActiveToken
  44         err := arv.RequestAndDecode(&proj, "POST", "arvados/v1/groups", nil, map[string]interface{}{
  45                 "group": map[string]interface{}{
  46                         "group_class": "project",
  47                         "name":        "keep-web s3 test",
  48                 },
  49                 "ensure_unique_name": true,
  50         })
  51         c.Assert(err, check.IsNil)
  52         err = arv.RequestAndDecode(&coll, "POST", "arvados/v1/collections", nil, map[string]interface{}{"collection": map[string]interface{}{
  53                 "owner_uuid":    proj.UUID,
  54                 "name":          "keep-web s3 test collection",
  55                 "manifest_text": ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:emptyfile\n./emptydir d41d8cd98f00b204e9800998ecf8427e+0 0:0:.\n",
  56         }})
  57         c.Assert(err, check.IsNil)
  58         ac, err := arvadosclient.New(arv)
  59         c.Assert(err, check.IsNil)
  60         kc, err := keepclient.MakeKeepClient(ac)
  61         c.Assert(err, check.IsNil)
  62         fs, err := coll.FileSystem(arv, kc)
  63         c.Assert(err, check.IsNil)
  64         f, err := fs.OpenFile("sailboat.txt", os.O_CREATE|os.O_WRONLY, 0644)
  65         c.Assert(err, check.IsNil)
  66         _, err = f.Write([]byte("⛵\n"))
  67         c.Assert(err, check.IsNil)
  68         err = f.Close()
  69         c.Assert(err, check.IsNil)
  70         err = fs.Sync()
  71         c.Assert(err, check.IsNil)
  72         err = arv.RequestAndDecode(&coll, "GET", "arvados/v1/collections/"+coll.UUID, nil, nil)
  73         c.Assert(err, check.IsNil)
  74
  75         auth := aws.NewAuth(arvadostest.ActiveTokenUUID, arvadostest.ActiveToken, "", time.Now().Add(time.Hour))
  76         region := aws.Region{
  77                 Name:       s.testServer.Addr,
  78                 S3Endpoint: "http://" + s.testServer.Addr,
  79         }
  80         client := s3.New(*auth, region)
  81         client.Signature = aws.V4Signature
  82         return s3stage{
  83                 arv:  arv,
  84                 ac:   ac,
  85                 kc:   kc,
  86                 proj: proj,
  87                 projbucket: &s3.Bucket{
  88                         S3:   client,
  89                         Name: proj.UUID,
  90                 },
  91                 coll: coll,
  92                 collbucket: &s3.Bucket{
  93                         S3:   client,
  94                         Name: coll.UUID,
  95                 },
  96         }
  97 }
  98
  99 func (stage s3stage) teardown(c *check.C) {
 100         if stage.coll.UUID != "" {
 101                 err := stage.arv.RequestAndDecode(&stage.coll, "DELETE", "arvados/v1/collections/"+stage.coll.UUID, nil, nil)
 102                 c.Check(err, check.IsNil)
 103         }
 104         if stage.proj.UUID != "" {
 105                 err := stage.arv.RequestAndDecode(&stage.proj, "DELETE", "arvados/v1/groups/"+stage.proj.UUID, nil, nil)
 106                 c.Check(err, check.IsNil)
 107         }
 108 }
 109
 110 func (s *IntegrationSuite) TestS3Signatures(c *check.C) {
 111         stage := s.s3setup(c)
 112         defer stage.teardown(c)
 113
 114         bucket := stage.collbucket
 115         for _, trial := range []struct {
 116                 success   bool
 117                 signature int
 118                 accesskey string
 119                 secretkey string
 120         }{
 121                 {true, aws.V2Signature, arvadostest.ActiveToken, "none"},
 122                 {true, aws.V2Signature, url.QueryEscape(arvadostest.ActiveTokenV2), "none"},
 123                 {true, aws.V2Signature, strings.Replace(arvadostest.ActiveTokenV2, "/", "_", -1), "none"},
 124                 {false, aws.V2Signature, "none", "none"},
 125                 {false, aws.V2Signature, "none", arvadostest.ActiveToken},
 126
 127                 {true, aws.V4Signature, arvadostest.ActiveTokenUUID, arvadostest.ActiveToken},
 128                 {true, aws.V4Signature, arvadostest.ActiveToken, arvadostest.ActiveToken},
 129                 {true, aws.V4Signature, url.QueryEscape(arvadostest.ActiveTokenV2), url.QueryEscape(arvadostest.ActiveTokenV2)},
 130                 {true, aws.V4Signature, strings.Replace(arvadostest.ActiveTokenV2, "/", "_", -1), strings.Replace(arvadostest.ActiveTokenV2, "/", "_", -1)},
 131                 {false, aws.V4Signature, arvadostest.ActiveToken, ""},
 132                 {false, aws.V4Signature, arvadostest.ActiveToken, "none"},
 133                 {false, aws.V4Signature, "none", arvadostest.ActiveToken},
 134                 {false, aws.V4Signature, "none", "none"},
 135         } {
 136                 c.Logf("%#v", trial)
 137                 bucket.S3.Auth = *(aws.NewAuth(trial.accesskey, trial.secretkey, "", time.Now().Add(time.Hour)))
 138                 bucket.S3.Signature = trial.signature
 139                 _, err := bucket.GetReader("emptyfile")
 140                 if trial.success {
 141                         c.Check(err, check.IsNil)
 142                 } else {
 143                         c.Check(err, check.NotNil)
 144                 }
 145         }
 146 }
 147
 148 func (s *IntegrationSuite) TestS3HeadBucket(c *check.C) {
 149         stage := s.s3setup(c)
 150         defer stage.teardown(c)
 151
 152         for _, bucket := range []*s3.Bucket{stage.collbucket, stage.projbucket} {
 153                 c.Logf("bucket %s", bucket.Name)
 154                 exists, err := bucket.Exists("")
 155                 c.Check(err, check.IsNil)
 156                 c.Check(exists, check.Equals, true)
 157         }
 158 }
 159
 160 func (s *IntegrationSuite) TestS3CollectionGetObject(c *check.C) {
 161         stage := s.s3setup(c)
 162         defer stage.teardown(c)
 163         s.testS3GetObject(c, stage.collbucket, "")
 164 }
 165 func (s *IntegrationSuite) TestS3ProjectGetObject(c *check.C) {
 166         stage := s.s3setup(c)
 167         defer stage.teardown(c)
 168         s.testS3GetObject(c, stage.projbucket, stage.coll.Name+"/")
 169 }
 170 func (s *IntegrationSuite) testS3GetObject(c *check.C, bucket *s3.Bucket, prefix string) {
 171         rdr, err := bucket.GetReader(prefix + "emptyfile")
 172         c.Assert(err, check.IsNil)
 173         buf, err := ioutil.ReadAll(rdr)
 174         c.Check(err, check.IsNil)
 175         c.Check(len(buf), check.Equals, 0)
 176         err = rdr.Close()
 177         c.Check(err, check.IsNil)
 178
 179         // GetObject
 180         rdr, err = bucket.GetReader(prefix + "missingfile")
 181         c.Check(err.(*s3.Error).StatusCode, check.Equals, 404)
 182         c.Check(err.(*s3.Error).Code, check.Equals, `NoSuchKey`)
 183         c.Check(err, check.ErrorMatches, `The specified key does not exist.`)
 184
 185         // HeadObject
 186         exists, err := bucket.Exists(prefix + "missingfile")
 187         c.Check(err, check.IsNil)
 188         c.Check(exists, check.Equals, false)
 189
 190         // GetObject
 191         rdr, err = bucket.GetReader(prefix + "sailboat.txt")
 192         c.Assert(err, check.IsNil)
 193         buf, err = ioutil.ReadAll(rdr)
 194         c.Check(err, check.IsNil)
 195         c.Check(buf, check.DeepEquals, []byte("⛵\n"))
 196         err = rdr.Close()
 197         c.Check(err, check.IsNil)
 198
 199         // HeadObject
 200         resp, err := bucket.Head(prefix+"sailboat.txt", nil)
 201         c.Check(err, check.IsNil)
 202         c.Check(resp.StatusCode, check.Equals, http.StatusOK)
 203         c.Check(resp.ContentLength, check.Equals, int64(4))
 204 }
 205
 206 func (s *IntegrationSuite) TestS3CollectionPutObjectSuccess(c *check.C) {
 207         stage := s.s3setup(c)
 208         defer stage.teardown(c)
 209         s.testS3PutObjectSuccess(c, stage.collbucket, "")
 210 }
 211 func (s *IntegrationSuite) TestS3ProjectPutObjectSuccess(c *check.C) {
 212         stage := s.s3setup(c)
 213         defer stage.teardown(c)
 214         s.testS3PutObjectSuccess(c, stage.projbucket, stage.coll.Name+"/")
 215 }
 216 func (s *IntegrationSuite) testS3PutObjectSuccess(c *check.C, bucket *s3.Bucket, prefix string) {
 217         for _, trial := range []struct {
 218                 path        string
 219                 size        int
 220                 contentType string
 221         }{
 222                 {
 223                         path:        "newfile",
 224                         size:        128000000,
 225                         contentType: "application/octet-stream",
 226                 }, {
 227                         path:        "newdir/newfile",
 228                         size:        1 << 26,
 229                         contentType: "application/octet-stream",
 230                 }, {
 231                         path:        "newdir1/newdir2/newfile",
 232                         size:        0,
 233                         contentType: "application/octet-stream",
 234                 }, {
 235                         path:        "newdir1/newdir2/newdir3/",
 236                         size:        0,
 237                         contentType: "application/x-directory",
 238                 },
 239         } {
 240                 c.Logf("=== %v", trial)
 241
 242                 objname := prefix + trial.path
 243
 244                 _, err := bucket.GetReader(objname)
 245                 c.Check(err.(*s3.Error).StatusCode, check.Equals, 404)
 246                 c.Check(err.(*s3.Error).Code, check.Equals, `NoSuchKey`)
 247                 c.Assert(err, check.ErrorMatches, `The specified key does not exist.`)
 248
 249                 buf := make([]byte, trial.size)
 250                 rand.Read(buf)
 251
 252                 err = bucket.PutReader(objname, bytes.NewReader(buf), int64(len(buf)), trial.contentType, s3.Private, s3.Options{})
 253                 c.Check(err, check.IsNil)
 254
 255                 rdr, err := bucket.GetReader(objname)
 256                 if strings.HasSuffix(trial.path, "/") && !s.testServer.Config.cluster.Collections.S3FolderObjects {
 257                         c.Check(err, check.NotNil)
 258                         continue
 259                 } else if !c.Check(err, check.IsNil) {
 260                         continue
 261                 }
 262                 buf2, err := ioutil.ReadAll(rdr)
 263                 c.Check(err, check.IsNil)
 264                 c.Check(buf2, check.HasLen, len(buf))
 265                 c.Check(bytes.Equal(buf, buf2), check.Equals, true)
 266         }
 267 }
 268
 269 func (s *IntegrationSuite) TestS3ProjectPutObjectNotSupported(c *check.C) {
 270         stage := s.s3setup(c)
 271         defer stage.teardown(c)
 272         bucket := stage.projbucket
 273
 274         for _, trial := range []struct {
 275                 path        string
 276                 size        int
 277                 contentType string
 278         }{
 279                 {
 280                         path:        "newfile",
 281                         size:        1234,
 282                         contentType: "application/octet-stream",
 283                 }, {
 284                         path:        "newdir/newfile",
 285                         size:        1234,
 286                         contentType: "application/octet-stream",
 287                 }, {
 288                         path:        "newdir2/",
 289                         size:        0,
 290                         contentType: "application/x-directory",
 291                 },
 292         } {
 293                 c.Logf("=== %v", trial)
 294
 295                 _, err := bucket.GetReader(trial.path)
 296                 c.Check(err.(*s3.Error).StatusCode, check.Equals, 404)
 297                 c.Check(err.(*s3.Error).Code, check.Equals, `NoSuchKey`)
 298                 c.Assert(err, check.ErrorMatches, `The specified key does not exist.`)
 299
 300                 buf := make([]byte, trial.size)
 301                 rand.Read(buf)
 302
 303                 err = bucket.PutReader(trial.path, bytes.NewReader(buf), int64(len(buf)), trial.contentType, s3.Private, s3.Options{})
 304                 c.Check(err.(*s3.Error).StatusCode, check.Equals, 400)
 305                 c.Check(err.(*s3.Error).Code, check.Equals, `InvalidArgument`)
 306                 c.Check(err, check.ErrorMatches, `(mkdir "by_id/zzzzz-j7d0g-[a-z0-9]{15}/newdir2?"|open "/zzzzz-j7d0g-[a-z0-9]{15}/newfile") failed: invalid argument`)
 307
 308                 _, err = bucket.GetReader(trial.path)
 309                 c.Check(err.(*s3.Error).StatusCode, check.Equals, 404)
 310                 c.Check(err.(*s3.Error).Code, check.Equals, `NoSuchKey`)
 311                 c.Assert(err, check.ErrorMatches, `The specified key does not exist.`)
 312         }
 313 }
 314
 315 func (s *IntegrationSuite) TestS3CollectionDeleteObject(c *check.C) {
 316         stage := s.s3setup(c)
 317         defer stage.teardown(c)
 318         s.testS3DeleteObject(c, stage.collbucket, "")
 319 }
 320 func (s *IntegrationSuite) TestS3ProjectDeleteObject(c *check.C) {
 321         stage := s.s3setup(c)
 322         defer stage.teardown(c)
 323         s.testS3DeleteObject(c, stage.projbucket, stage.coll.Name+"/")
 324 }
 325 func (s *IntegrationSuite) testS3DeleteObject(c *check.C, bucket *s3.Bucket, prefix string) {
 326         s.testServer.Config.cluster.Collections.S3FolderObjects = true
 327         for _, trial := range []struct {
 328                 path string
 329         }{
 330                 {"/"},
 331                 {"nonexistentfile"},
 332                 {"emptyfile"},
 333                 {"sailboat.txt"},
 334                 {"sailboat.txt/"},
 335                 {"emptydir"},
 336                 {"emptydir/"},
 337         } {
 338                 objname := prefix + trial.path
 339                 comment := check.Commentf("objname %q", objname)
 340
 341                 err := bucket.Del(objname)
 342                 if trial.path == "/" {
 343                         c.Check(err, check.NotNil)
 344                         continue
 345                 }
 346                 c.Check(err, check.IsNil, comment)
 347                 _, err = bucket.GetReader(objname)
 348                 c.Check(err, check.NotNil, comment)
 349         }
 350 }
 351
 352 func (s *IntegrationSuite) TestS3CollectionPutObjectFailure(c *check.C) {
 353         stage := s.s3setup(c)
 354         defer stage.teardown(c)
 355         s.testS3PutObjectFailure(c, stage.collbucket, "")
 356 }
 357 func (s *IntegrationSuite) TestS3ProjectPutObjectFailure(c *check.C) {
 358         stage := s.s3setup(c)
 359         defer stage.teardown(c)
 360         s.testS3PutObjectFailure(c, stage.projbucket, stage.coll.Name+"/")
 361 }
 362 func (s *IntegrationSuite) testS3PutObjectFailure(c *check.C, bucket *s3.Bucket, prefix string) {
 363         s.testServer.Config.cluster.Collections.S3FolderObjects = false
 364
 365         // Can't use V4 signature for these tests, because
 366         // double-slash is incorrectly cleaned by the aws.V4Signature,
 367         // resulting in a "bad signature" error. (Cleaning the path is
 368         // appropriate for other services, but not in S3 where object
 369         // names "foo//bar" and "foo/bar" are semantically different.)
 370         bucket.S3.Auth = *(aws.NewAuth(arvadostest.ActiveToken, "none", "", time.Now().Add(time.Hour)))
 371         bucket.S3.Signature = aws.V2Signature
 372
 373         var wg sync.WaitGroup
 374         for _, trial := range []struct {
 375                 path string
 376         }{
 377                 {
 378                         path: "emptyfile/newname", // emptyfile exists, see s3setup()
 379                 }, {
 380                         path: "emptyfile/", // emptyfile exists, see s3setup()
 381                 }, {
 382                         path: "emptydir", // dir already exists, see s3setup()
 383                 }, {
 384                         path: "emptydir/",
 385                 }, {
 386                         path: "emptydir//",
 387                 }, {
 388                         path: "newdir/",
 389                 }, {
 390                         path: "newdir//",
 391                 }, {
 392                         path: "/",
 393                 }, {
 394                         path: "//",
 395                 }, {
 396                         path: "foo//bar",
 397                 }, {
 398                         path: "",
 399                 },
 400         } {
 401                 trial := trial
 402                 wg.Add(1)
 403                 go func() {
 404                         defer wg.Done()
 405                         c.Logf("=== %v", trial)
 406
 407                         objname := prefix + trial.path
 408
 409                         buf := make([]byte, 1234)
 410                         rand.Read(buf)
 411
 412                         err := bucket.PutReader(objname, bytes.NewReader(buf), int64(len(buf)), "application/octet-stream", s3.Private, s3.Options{})
 413                         if !c.Check(err, check.ErrorMatches, `(invalid object name.*|open ".*" failed.*|object name conflicts with existing object|Missing object name in PUT request.)`, check.Commentf("PUT %q should fail", objname)) {
 414                                 return
 415                         }
 416
 417                         if objname != "" && objname != "/" {
 418                                 _, err = bucket.GetReader(objname)
 419                                 c.Check(err.(*s3.Error).StatusCode, check.Equals, 404)
 420                                 c.Check(err.(*s3.Error).Code, check.Equals, `NoSuchKey`)
 421                                 c.Check(err, check.ErrorMatches, `The specified key does not exist.`, check.Commentf("GET %q should return 404", objname))
 422                         }
 423                 }()
 424         }
 425         wg.Wait()
 426 }
 427
 428 func (stage *s3stage) writeBigDirs(c *check.C, dirs int, filesPerDir int) {
 429         fs, err := stage.coll.FileSystem(stage.arv, stage.kc)
 430         c.Assert(err, check.IsNil)
 431         for d := 0; d < dirs; d++ {
 432                 dir := fmt.Sprintf("dir%d", d)
 433                 c.Assert(fs.Mkdir(dir, 0755), check.IsNil)
 434                 for i := 0; i < filesPerDir; i++ {
 435                         f, err := fs.OpenFile(fmt.Sprintf("%s/file%d.txt", dir, i), os.O_CREATE|os.O_WRONLY, 0644)
 436                         c.Assert(err, check.IsNil)
 437                         c.Assert(f.Close(), check.IsNil)
 438                 }
 439         }
 440         c.Assert(fs.Sync(), check.IsNil)
 441 }
 442
 443 func (s *IntegrationSuite) TestS3GetBucketVersioning(c *check.C) {
 444         stage := s.s3setup(c)
 445         defer stage.teardown(c)
 446         for _, bucket := range []*s3.Bucket{stage.collbucket, stage.projbucket} {
 447                 req, err := http.NewRequest("GET", bucket.URL("/"), nil)
 448                 c.Check(err, check.IsNil)
 449                 req.Header.Set("Authorization", "AWS "+arvadostest.ActiveTokenV2+":none")
 450                 req.URL.RawQuery = "versioning"
 451                 resp, err := http.DefaultClient.Do(req)
 452                 c.Assert(err, check.IsNil)
 453                 c.Check(resp.Header.Get("Content-Type"), check.Equals, "application/xml")
 454                 buf, err := ioutil.ReadAll(resp.Body)
 455                 c.Assert(err, check.IsNil)
 456                 c.Check(string(buf), check.Equals, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<VersioningConfiguration xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\"/>\n")
 457         }
 458 }
 459
 460 // If there are no CommonPrefixes entries, the CommonPrefixes XML tag
 461 // should not appear at all.
 462 func (s *IntegrationSuite) TestS3ListNoCommonPrefixes(c *check.C) {
 463         stage := s.s3setup(c)
 464         defer stage.teardown(c)
 465
 466         req, err := http.NewRequest("GET", stage.collbucket.URL("/"), nil)
 467         c.Assert(err, check.IsNil)
 468         req.Header.Set("Authorization", "AWS "+arvadostest.ActiveTokenV2+":none")
 469         req.URL.RawQuery = "prefix=asdfasdfasdf&delimiter=/"
 470         resp, err := http.DefaultClient.Do(req)
 471         c.Assert(err, check.IsNil)
 472         buf, err := ioutil.ReadAll(resp.Body)
 473         c.Assert(err, check.IsNil)
 474         c.Check(string(buf), check.Not(check.Matches), `(?ms).*CommonPrefixes.*`)
 475 }
 476
 477 // If there is no delimiter in the request, or the results are not
 478 // truncated, the NextMarker XML tag should not appear in the response
 479 // body.
 480 func (s *IntegrationSuite) TestS3ListNoNextMarker(c *check.C) {
 481         stage := s.s3setup(c)
 482         defer stage.teardown(c)
 483
 484         for _, query := range []string{"prefix=e&delimiter=/", ""} {
 485                 req, err := http.NewRequest("GET", stage.collbucket.URL("/"), nil)
 486                 c.Assert(err, check.IsNil)
 487                 req.Header.Set("Authorization", "AWS "+arvadostest.ActiveTokenV2+":none")
 488                 req.URL.RawQuery = query
 489                 resp, err := http.DefaultClient.Do(req)
 490                 c.Assert(err, check.IsNil)
 491                 buf, err := ioutil.ReadAll(resp.Body)
 492                 c.Assert(err, check.IsNil)
 493                 c.Check(string(buf), check.Not(check.Matches), `(?ms).*NextMarker.*`)
 494         }
 495 }
 496
 497 // List response should include KeyCount field.
 498 func (s *IntegrationSuite) TestS3ListKeyCount(c *check.C) {
 499         stage := s.s3setup(c)
 500         defer stage.teardown(c)
 501
 502         req, err := http.NewRequest("GET", stage.collbucket.URL("/"), nil)
 503         c.Assert(err, check.IsNil)
 504         req.Header.Set("Authorization", "AWS "+arvadostest.ActiveTokenV2+":none")
 505         req.URL.RawQuery = "prefix=&delimiter=/"
 506         resp, err := http.DefaultClient.Do(req)
 507         c.Assert(err, check.IsNil)
 508         buf, err := ioutil.ReadAll(resp.Body)
 509         c.Assert(err, check.IsNil)
 510         c.Check(string(buf), check.Matches, `(?ms).*<KeyCount>2</KeyCount>.*`)
 511 }
 512
 513 func (s *IntegrationSuite) TestS3CollectionList(c *check.C) {
 514         stage := s.s3setup(c)
 515         defer stage.teardown(c)
 516
 517         var markers int
 518         for markers, s.testServer.Config.cluster.Collections.S3FolderObjects = range []bool{false, true} {
 519                 dirs := 2
 520                 filesPerDir := 1001
 521                 stage.writeBigDirs(c, dirs, filesPerDir)
 522                 // Total # objects is:
 523                 //                 2 file entries from s3setup (emptyfile and sailboat.txt)
 524                 //                +1 fake "directory" marker from s3setup (emptydir) (if enabled)
 525                 //             +dirs fake "directory" marker from writeBigDirs (dir0/, dir1/) (if enabled)
 526                 // +filesPerDir*dirs file entries from writeBigDirs (dir0/file0.txt, etc.)
 527                 s.testS3List(c, stage.collbucket, "", 4000, markers+2+(filesPerDir+markers)*dirs)
 528                 s.testS3List(c, stage.collbucket, "", 131, markers+2+(filesPerDir+markers)*dirs)
 529                 s.testS3List(c, stage.collbucket, "dir0/", 71, filesPerDir+markers)
 530         }
 531 }
 532 func (s *IntegrationSuite) testS3List(c *check.C, bucket *s3.Bucket, prefix string, pageSize, expectFiles int) {
 533         c.Logf("testS3List: prefix=%q pageSize=%d S3FolderObjects=%v", prefix, pageSize, s.testServer.Config.cluster.Collections.S3FolderObjects)
 534         expectPageSize := pageSize
 535         if expectPageSize > 1000 {
 536                 expectPageSize = 1000
 537         }
 538         gotKeys := map[string]s3.Key{}
 539         nextMarker := ""
 540         pages := 0
 541         for {
 542                 resp, err := bucket.List(prefix, "", nextMarker, pageSize)
 543                 if !c.Check(err, check.IsNil) {
 544                         break
 545                 }
 546                 c.Check(len(resp.Contents) <= expectPageSize, check.Equals, true)
 547                 if pages++; !c.Check(pages <= (expectFiles/expectPageSize)+1, check.Equals, true) {
 548                         break
 549                 }
 550                 for _, key := range resp.Contents {
 551                         gotKeys[key.Key] = key
 552                         if strings.Contains(key.Key, "sailboat.txt") {
 553                                 c.Check(key.Size, check.Equals, int64(4))
 554                         }
 555                 }
 556                 if !resp.IsTruncated {
 557                         c.Check(resp.NextMarker, check.Equals, "")
 558                         break
 559                 }
 560                 if !c.Check(resp.NextMarker, check.Not(check.Equals), "") {
 561                         break
 562                 }
 563                 nextMarker = resp.NextMarker
 564         }
 565         c.Check(len(gotKeys), check.Equals, expectFiles)
 566 }
 567
 568 func (s *IntegrationSuite) TestS3CollectionListRollup(c *check.C) {
 569         for _, s.testServer.Config.cluster.Collections.S3FolderObjects = range []bool{false, true} {
 570                 s.testS3CollectionListRollup(c)
 571         }
 572 }
 573
 574 func (s *IntegrationSuite) testS3CollectionListRollup(c *check.C) {
 575         stage := s.s3setup(c)
 576         defer stage.teardown(c)
 577
 578         dirs := 2
 579         filesPerDir := 500
 580         stage.writeBigDirs(c, dirs, filesPerDir)
 581         err := stage.collbucket.PutReader("dingbats", &bytes.Buffer{}, 0, "application/octet-stream", s3.Private, s3.Options{})
 582         c.Assert(err, check.IsNil)
 583         var allfiles []string
 584         for marker := ""; ; {
 585                 resp, err := stage.collbucket.List("", "", marker, 20000)
 586                 c.Check(err, check.IsNil)
 587                 for _, key := range resp.Contents {
 588                         if len(allfiles) == 0 || allfiles[len(allfiles)-1] != key.Key {
 589                                 allfiles = append(allfiles, key.Key)
 590                         }
 591                 }
 592                 marker = resp.NextMarker
 593                 if marker == "" {
 594                         break
 595                 }
 596         }
 597         markers := 0
 598         if s.testServer.Config.cluster.Collections.S3FolderObjects {
 599                 markers = 1
 600         }
 601         c.Check(allfiles, check.HasLen, dirs*(filesPerDir+markers)+3+markers)
 602
 603         gotDirMarker := map[string]bool{}
 604         for _, name := range allfiles {
 605                 isDirMarker := strings.HasSuffix(name, "/")
 606                 if markers == 0 {
 607                         c.Check(isDirMarker, check.Equals, false, check.Commentf("name %q", name))
 608                 } else if isDirMarker {
 609                         gotDirMarker[name] = true
 610                 } else if i := strings.LastIndex(name, "/"); i >= 0 {
 611                         c.Check(gotDirMarker[name[:i+1]], check.Equals, true, check.Commentf("name %q", name))
 612                         gotDirMarker[name[:i+1]] = true // skip redundant complaints about this dir marker
 613                 }
 614         }
 615
 616         for _, trial := range []struct {
 617                 prefix    string
 618                 delimiter string
 619                 marker    string
 620         }{
 621                 {"", "", ""},
 622                 {"di", "/", ""},
 623                 {"di", "r", ""},
 624                 {"di", "n", ""},
 625                 {"dir0", "/", ""},
 626                 {"dir0/", "/", ""},
 627                 {"dir0/f", "/", ""},
 628                 {"dir0", "", ""},
 629                 {"dir0/", "", ""},
 630                 {"dir0/f", "", ""},
 631                 {"dir0", "/", "dir0/file14.txt"},       // no commonprefixes
 632                 {"", "", "dir0/file14.txt"},            // middle page, skip walking dir1
 633                 {"", "", "dir1/file14.txt"},            // middle page, skip walking dir0
 634                 {"", "", "dir1/file498.txt"},           // last page of results
 635                 {"dir1/file", "", "dir1/file498.txt"},  // last page of results, with prefix
 636                 {"dir1/file", "/", "dir1/file498.txt"}, // last page of results, with prefix + delimiter
 637                 {"dir1", "Z", "dir1/file498.txt"},      // delimiter "Z" never appears
 638                 {"dir2", "/", ""},                      // prefix "dir2" does not exist
 639                 {"", "/", ""},
 640         } {
 641                 c.Logf("\n\n=== trial %+v markers=%d", trial, markers)
 642
 643                 maxKeys := 20
 644                 resp, err := stage.collbucket.List(trial.prefix, trial.delimiter, trial.marker, maxKeys)
 645                 c.Check(err, check.IsNil)
 646                 if resp.IsTruncated && trial.delimiter == "" {
 647                         // goamz List method fills in the missing
 648                         // NextMarker field if resp.IsTruncated, so
 649                         // now we can't really tell whether it was
 650                         // sent by the server or by goamz. In cases
 651                         // where it should be empty but isn't, assume
 652                         // it's goamz's fault.
 653                         resp.NextMarker = ""
 654                 }
 655
 656                 var expectKeys []string
 657                 var expectPrefixes []string
 658                 var expectNextMarker string
 659                 var expectTruncated bool
 660                 for _, key := range allfiles {
 661                         full := len(expectKeys)+len(expectPrefixes) >= maxKeys
 662                         if !strings.HasPrefix(key, trial.prefix) || key < trial.marker {
 663                                 continue
 664                         } else if idx := strings.Index(key[len(trial.prefix):], trial.delimiter); trial.delimiter != "" && idx >= 0 {
 665                                 prefix := key[:len(trial.prefix)+idx+1]
 666                                 if len(expectPrefixes) > 0 && expectPrefixes[len(expectPrefixes)-1] == prefix {
 667                                         // same prefix as previous key
 668                                 } else if full {
 669                                         expectNextMarker = key
 670                                         expectTruncated = true
 671                                 } else {
 672                                         expectPrefixes = append(expectPrefixes, prefix)
 673                                 }
 674                         } else if full {
 675                                 if trial.delimiter != "" {
 676                                         expectNextMarker = key
 677                                 }
 678                                 expectTruncated = true
 679                                 break
 680                         } else {
 681                                 expectKeys = append(expectKeys, key)
 682                         }
 683                 }
 684
 685                 var gotKeys []string
 686                 for _, key := range resp.Contents {
 687                         gotKeys = append(gotKeys, key.Key)
 688                 }
 689                 var gotPrefixes []string
 690                 for _, prefix := range resp.CommonPrefixes {
 691                         gotPrefixes = append(gotPrefixes, prefix)
 692                 }
 693                 commentf := check.Commentf("trial %+v markers=%d", trial, markers)
 694                 c.Check(gotKeys, check.DeepEquals, expectKeys, commentf)
 695                 c.Check(gotPrefixes, check.DeepEquals, expectPrefixes, commentf)
 696                 c.Check(resp.NextMarker, check.Equals, expectNextMarker, commentf)
 697                 c.Check(resp.IsTruncated, check.Equals, expectTruncated, commentf)
 698                 c.Logf("=== trial %+v keys %q prefixes %q nextMarker %q", trial, gotKeys, gotPrefixes, resp.NextMarker)
 699         }
 700 }
 701
 702 // TestS3cmd checks compatibility with the s3cmd command line tool, if
 703 // it's installed. As of Debian buster, s3cmd is only in backports, so
 704 // `arvados-server install` don't install it, and this test skips if
 705 // it's not installed.
 706 func (s *IntegrationSuite) TestS3cmd(c *check.C) {
 707         if _, err := exec.LookPath("s3cmd"); err != nil {
 708                 c.Skip("s3cmd not found")
 709                 return
 710         }
 711
 712         stage := s.s3setup(c)
 713         defer stage.teardown(c)
 714
 715         cmd := exec.Command("s3cmd", "--no-ssl", "--host="+s.testServer.Addr, "--host-bucket="+s.testServer.Addr, "--access_key="+arvadostest.ActiveTokenUUID, "--secret_key="+arvadostest.ActiveToken, "ls", "s3://"+arvadostest.FooCollection)
 716         buf, err := cmd.CombinedOutput()
 717         c.Check(err, check.IsNil)
 718         c.Check(string(buf), check.Matches, `.* 3 +s3://`+arvadostest.FooCollection+`/foo\n`)
 719 }
 720
 721 func (s *IntegrationSuite) TestS3BucketInHost(c *check.C) {
 722         stage := s.s3setup(c)
 723         defer stage.teardown(c)
 724
 725         hdr, body, _ := s.runCurl(c, "AWS "+arvadostest.ActiveTokenV2+":none", stage.coll.UUID+".collections.example.com", "/sailboat.txt")
 726         c.Check(hdr, check.Matches, `(?s)HTTP/1.1 200 OK\r\n.*`)
 727         c.Check(body, check.Equals, "⛵\n")
 728 }