1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
18 "git.arvados.org/arvados.git/sdk/go/arvados"
19 "git.arvados.org/arvados.git/sdk/go/arvadosclient"
20 "git.arvados.org/arvados.git/sdk/go/arvadostest"
21 "git.arvados.org/arvados.git/sdk/go/keepclient"
22 "github.com/AdRoll/goamz/aws"
23 "github.com/AdRoll/goamz/s3"
24 check "gopkg.in/check.v1"
29 ac *arvadosclient.ArvadosClient
30 kc *keepclient.KeepClient
33 coll arvados.Collection
37 func (s *IntegrationSuite) s3setup(c *check.C) s3stage {
38 var proj arvados.Group
39 var coll arvados.Collection
40 arv := arvados.NewClientFromEnv()
41 arv.AuthToken = arvadostest.ActiveToken
42 err := arv.RequestAndDecode(&proj, "POST", "arvados/v1/groups", nil, map[string]interface{}{
43 "group": map[string]interface{}{
44 "group_class": "project",
45 "name": "keep-web s3 test",
47 "ensure_unique_name": true,
49 c.Assert(err, check.IsNil)
50 err = arv.RequestAndDecode(&coll, "POST", "arvados/v1/collections", nil, map[string]interface{}{"collection": map[string]interface{}{
51 "owner_uuid": proj.UUID,
52 "name": "keep-web s3 test collection",
53 "manifest_text": ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:emptyfile\n./emptydir d41d8cd98f00b204e9800998ecf8427e+0 0:0:.\n",
55 c.Assert(err, check.IsNil)
56 ac, err := arvadosclient.New(arv)
57 c.Assert(err, check.IsNil)
58 kc, err := keepclient.MakeKeepClient(ac)
59 c.Assert(err, check.IsNil)
60 fs, err := coll.FileSystem(arv, kc)
61 c.Assert(err, check.IsNil)
62 f, err := fs.OpenFile("sailboat.txt", os.O_CREATE|os.O_WRONLY, 0644)
63 c.Assert(err, check.IsNil)
64 _, err = f.Write([]byte("⛵\n"))
65 c.Assert(err, check.IsNil)
67 c.Assert(err, check.IsNil)
69 c.Assert(err, check.IsNil)
70 err = arv.RequestAndDecode(&coll, "GET", "arvados/v1/collections/"+coll.UUID, nil, nil)
71 c.Assert(err, check.IsNil)
73 auth := aws.NewAuth(arvadostest.ActiveTokenUUID, arvadostest.ActiveToken, "", time.Now().Add(time.Hour))
75 Name: s.testServer.Addr,
76 S3Endpoint: "http://" + s.testServer.Addr,
78 client := s3.New(*auth, region)
79 client.Signature = aws.V4Signature
85 projbucket: &s3.Bucket{
90 collbucket: &s3.Bucket{
97 func (stage s3stage) teardown(c *check.C) {
98 if stage.coll.UUID != "" {
99 err := stage.arv.RequestAndDecode(&stage.coll, "DELETE", "arvados/v1/collections/"+stage.coll.UUID, nil, nil)
100 c.Check(err, check.IsNil)
102 if stage.proj.UUID != "" {
103 err := stage.arv.RequestAndDecode(&stage.proj, "DELETE", "arvados/v1/groups/"+stage.proj.UUID, nil, nil)
104 c.Check(err, check.IsNil)
108 func (s *IntegrationSuite) TestS3HeadBucket(c *check.C) {
109 stage := s.s3setup(c)
110 defer stage.teardown(c)
112 for _, bucket := range []*s3.Bucket{stage.collbucket, stage.projbucket} {
113 c.Logf("bucket %s", bucket.Name)
114 exists, err := bucket.Exists("")
115 c.Check(err, check.IsNil)
116 c.Check(exists, check.Equals, true)
120 func (s *IntegrationSuite) TestS3CollectionGetObject(c *check.C) {
121 stage := s.s3setup(c)
122 defer stage.teardown(c)
123 s.testS3GetObject(c, stage.collbucket, "")
125 func (s *IntegrationSuite) TestS3ProjectGetObject(c *check.C) {
126 stage := s.s3setup(c)
127 defer stage.teardown(c)
128 s.testS3GetObject(c, stage.projbucket, stage.coll.Name+"/")
130 func (s *IntegrationSuite) testS3GetObject(c *check.C, bucket *s3.Bucket, prefix string) {
131 rdr, err := bucket.GetReader(prefix + "emptyfile")
132 c.Assert(err, check.IsNil)
133 buf, err := ioutil.ReadAll(rdr)
134 c.Check(err, check.IsNil)
135 c.Check(len(buf), check.Equals, 0)
137 c.Check(err, check.IsNil)
140 rdr, err = bucket.GetReader(prefix + "missingfile")
141 c.Check(err, check.ErrorMatches, `404 Not Found`)
144 exists, err := bucket.Exists(prefix + "missingfile")
145 c.Check(err, check.IsNil)
146 c.Check(exists, check.Equals, false)
149 rdr, err = bucket.GetReader(prefix + "sailboat.txt")
150 c.Assert(err, check.IsNil)
151 buf, err = ioutil.ReadAll(rdr)
152 c.Check(err, check.IsNil)
153 c.Check(buf, check.DeepEquals, []byte("⛵\n"))
155 c.Check(err, check.IsNil)
158 resp, err := bucket.Head(prefix+"sailboat.txt", nil)
159 c.Check(err, check.IsNil)
160 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
161 c.Check(resp.ContentLength, check.Equals, int64(4))
164 func (s *IntegrationSuite) TestS3CollectionPutObjectSuccess(c *check.C) {
165 stage := s.s3setup(c)
166 defer stage.teardown(c)
167 s.testS3PutObjectSuccess(c, stage.collbucket, "")
169 func (s *IntegrationSuite) TestS3ProjectPutObjectSuccess(c *check.C) {
170 stage := s.s3setup(c)
171 defer stage.teardown(c)
172 s.testS3PutObjectSuccess(c, stage.projbucket, stage.coll.Name+"/")
174 func (s *IntegrationSuite) testS3PutObjectSuccess(c *check.C, bucket *s3.Bucket, prefix string) {
175 for _, trial := range []struct {
183 contentType: "application/octet-stream",
185 path: "newdir/newfile",
187 contentType: "application/octet-stream",
189 path: "newdir1/newdir2/newfile",
191 contentType: "application/octet-stream",
193 path: "newdir1/newdir2/newdir3/",
195 contentType: "application/x-directory",
198 c.Logf("=== %v", trial)
200 objname := prefix + trial.path
202 _, err := bucket.GetReader(objname)
203 c.Assert(err, check.ErrorMatches, `404 Not Found`)
205 buf := make([]byte, trial.size)
208 err = bucket.PutReader(objname, bytes.NewReader(buf), int64(len(buf)), trial.contentType, s3.Private, s3.Options{})
209 c.Check(err, check.IsNil)
211 rdr, err := bucket.GetReader(objname)
212 if strings.HasSuffix(trial.path, "/") && !s.testServer.Config.cluster.Collections.S3FolderObjects {
213 c.Check(err, check.NotNil)
215 } else if !c.Check(err, check.IsNil) {
218 buf2, err := ioutil.ReadAll(rdr)
219 c.Check(err, check.IsNil)
220 c.Check(buf2, check.HasLen, len(buf))
221 c.Check(bytes.Equal(buf, buf2), check.Equals, true)
225 func (s *IntegrationSuite) TestS3ProjectPutObjectNotSupported(c *check.C) {
226 stage := s.s3setup(c)
227 defer stage.teardown(c)
228 bucket := stage.projbucket
230 for _, trial := range []struct {
238 contentType: "application/octet-stream",
240 path: "newdir/newfile",
242 contentType: "application/octet-stream",
246 contentType: "application/x-directory",
249 c.Logf("=== %v", trial)
251 _, err := bucket.GetReader(trial.path)
252 c.Assert(err, check.ErrorMatches, `404 Not Found`)
254 buf := make([]byte, trial.size)
257 err = bucket.PutReader(trial.path, bytes.NewReader(buf), int64(len(buf)), trial.contentType, s3.Private, s3.Options{})
258 c.Check(err, check.ErrorMatches, `400 Bad Request`)
260 _, err = bucket.GetReader(trial.path)
261 c.Assert(err, check.ErrorMatches, `404 Not Found`)
265 func (s *IntegrationSuite) TestS3CollectionDeleteObject(c *check.C) {
266 stage := s.s3setup(c)
267 defer stage.teardown(c)
268 s.testS3DeleteObject(c, stage.collbucket, "")
270 func (s *IntegrationSuite) TestS3ProjectDeleteObject(c *check.C) {
271 stage := s.s3setup(c)
272 defer stage.teardown(c)
273 s.testS3DeleteObject(c, stage.projbucket, stage.coll.Name+"/")
275 func (s *IntegrationSuite) testS3DeleteObject(c *check.C, bucket *s3.Bucket, prefix string) {
276 s.testServer.Config.cluster.Collections.S3FolderObjects = true
277 for _, trial := range []struct {
288 objname := prefix + trial.path
289 comment := check.Commentf("objname %q", objname)
291 err := bucket.Del(objname)
292 if trial.path == "/" {
293 c.Check(err, check.NotNil)
296 c.Check(err, check.IsNil, comment)
297 _, err = bucket.GetReader(objname)
298 c.Check(err, check.NotNil, comment)
302 func (s *IntegrationSuite) TestS3CollectionPutObjectFailure(c *check.C) {
303 stage := s.s3setup(c)
304 defer stage.teardown(c)
305 s.testS3PutObjectFailure(c, stage.collbucket, "")
307 func (s *IntegrationSuite) TestS3ProjectPutObjectFailure(c *check.C) {
308 stage := s.s3setup(c)
309 defer stage.teardown(c)
310 s.testS3PutObjectFailure(c, stage.projbucket, stage.coll.Name+"/")
312 func (s *IntegrationSuite) testS3PutObjectFailure(c *check.C, bucket *s3.Bucket, prefix string) {
313 s.testServer.Config.cluster.Collections.S3FolderObjects = false
315 // Can't use V4 signature for these tests, because
316 // double-slash is incorrectly cleaned by the aws.V4Signature,
317 // resulting in a "bad signature" error. (Cleaning the path is
318 // appropriate for other services, but not in S3 where object
319 // names "foo//bar" and "foo/bar" are semantically different.)
320 bucket.S3.Auth = *(aws.NewAuth(arvadostest.ActiveToken, "none", "", time.Now().Add(time.Hour)))
321 bucket.S3.Signature = aws.V2Signature
323 var wg sync.WaitGroup
324 for _, trial := range []struct {
328 path: "emptyfile/newname", // emptyfile exists, see s3setup()
330 path: "emptyfile/", // emptyfile exists, see s3setup()
332 path: "emptydir", // dir already exists, see s3setup()
355 c.Logf("=== %v", trial)
357 objname := prefix + trial.path
359 buf := make([]byte, 1234)
362 err := bucket.PutReader(objname, bytes.NewReader(buf), int64(len(buf)), "application/octet-stream", s3.Private, s3.Options{})
363 if !c.Check(err, check.ErrorMatches, `400 Bad.*`, check.Commentf("PUT %q should fail", objname)) {
367 if objname != "" && objname != "/" {
368 _, err = bucket.GetReader(objname)
369 c.Check(err, check.ErrorMatches, `404 Not Found`, check.Commentf("GET %q should return 404", objname))
376 func (stage *s3stage) writeBigDirs(c *check.C, dirs int, filesPerDir int) {
377 fs, err := stage.coll.FileSystem(stage.arv, stage.kc)
378 c.Assert(err, check.IsNil)
379 for d := 0; d < dirs; d++ {
380 dir := fmt.Sprintf("dir%d", d)
381 c.Assert(fs.Mkdir(dir, 0755), check.IsNil)
382 for i := 0; i < filesPerDir; i++ {
383 f, err := fs.OpenFile(fmt.Sprintf("%s/file%d.txt", dir, i), os.O_CREATE|os.O_WRONLY, 0644)
384 c.Assert(err, check.IsNil)
385 c.Assert(f.Close(), check.IsNil)
388 c.Assert(fs.Sync(), check.IsNil)
391 func (s *IntegrationSuite) TestS3GetBucketVersioning(c *check.C) {
392 stage := s.s3setup(c)
393 defer stage.teardown(c)
394 for _, bucket := range []*s3.Bucket{stage.collbucket, stage.projbucket} {
395 req, err := http.NewRequest("GET", bucket.URL("/"), nil)
396 c.Check(err, check.IsNil)
397 req.Header.Set("Authorization", "AWS "+arvadostest.ActiveTokenV2+":none")
398 req.URL.RawQuery = "versioning"
399 resp, err := http.DefaultClient.Do(req)
400 c.Assert(err, check.IsNil)
401 c.Check(resp.Header.Get("Content-Type"), check.Equals, "application/xml")
402 buf, err := ioutil.ReadAll(resp.Body)
403 c.Assert(err, check.IsNil)
404 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")
408 // If there are no CommonPrefixes entries, the CommonPrefixes XML tag
409 // should not appear at all.
410 func (s *IntegrationSuite) TestS3ListNoCommonPrefixes(c *check.C) {
411 stage := s.s3setup(c)
412 defer stage.teardown(c)
414 req, err := http.NewRequest("GET", stage.collbucket.URL("/"), nil)
415 c.Assert(err, check.IsNil)
416 req.Header.Set("Authorization", "AWS "+arvadostest.ActiveTokenV2+":none")
417 req.URL.RawQuery = "prefix=asdfasdfasdf&delimiter=/"
418 resp, err := http.DefaultClient.Do(req)
419 c.Assert(err, check.IsNil)
420 buf, err := ioutil.ReadAll(resp.Body)
421 c.Assert(err, check.IsNil)
422 c.Check(string(buf), check.Not(check.Matches), `(?ms).*CommonPrefixes.*`)
425 // If there is no delimiter in the request, or the results are not
426 // truncated, the NextMarker XML tag should not appear in the response
428 func (s *IntegrationSuite) TestS3ListNoNextMarker(c *check.C) {
429 stage := s.s3setup(c)
430 defer stage.teardown(c)
432 for _, query := range []string{"prefix=e&delimiter=/", ""} {
433 req, err := http.NewRequest("GET", stage.collbucket.URL("/"), nil)
434 c.Assert(err, check.IsNil)
435 req.Header.Set("Authorization", "AWS "+arvadostest.ActiveTokenV2+":none")
436 req.URL.RawQuery = query
437 resp, err := http.DefaultClient.Do(req)
438 c.Assert(err, check.IsNil)
439 buf, err := ioutil.ReadAll(resp.Body)
440 c.Assert(err, check.IsNil)
441 c.Check(string(buf), check.Not(check.Matches), `(?ms).*NextMarker.*`)
445 func (s *IntegrationSuite) TestS3CollectionList(c *check.C) {
446 stage := s.s3setup(c)
447 defer stage.teardown(c)
450 for markers, s.testServer.Config.cluster.Collections.S3FolderObjects = range []bool{false, true} {
453 stage.writeBigDirs(c, dirs, filesPerDir)
454 // Total # objects is:
455 // 2 file entries from s3setup (emptyfile and sailboat.txt)
456 // +1 fake "directory" marker from s3setup (emptydir) (if enabled)
457 // +dirs fake "directory" marker from writeBigDirs (dir0/, dir1/) (if enabled)
458 // +filesPerDir*dirs file entries from writeBigDirs (dir0/file0.txt, etc.)
459 s.testS3List(c, stage.collbucket, "", 4000, markers+2+(filesPerDir+markers)*dirs)
460 s.testS3List(c, stage.collbucket, "", 131, markers+2+(filesPerDir+markers)*dirs)
461 s.testS3List(c, stage.collbucket, "dir0/", 71, filesPerDir+markers)
464 func (s *IntegrationSuite) testS3List(c *check.C, bucket *s3.Bucket, prefix string, pageSize, expectFiles int) {
465 c.Logf("testS3List: prefix=%q pageSize=%d S3FolderObjects=%v", prefix, pageSize, s.testServer.Config.cluster.Collections.S3FolderObjects)
466 expectPageSize := pageSize
467 if expectPageSize > 1000 {
468 expectPageSize = 1000
470 gotKeys := map[string]s3.Key{}
474 resp, err := bucket.List(prefix, "", nextMarker, pageSize)
475 if !c.Check(err, check.IsNil) {
478 c.Check(len(resp.Contents) <= expectPageSize, check.Equals, true)
479 if pages++; !c.Check(pages <= (expectFiles/expectPageSize)+1, check.Equals, true) {
482 for _, key := range resp.Contents {
483 gotKeys[key.Key] = key
484 if strings.Contains(key.Key, "sailboat.txt") {
485 c.Check(key.Size, check.Equals, int64(4))
488 if !resp.IsTruncated {
489 c.Check(resp.NextMarker, check.Equals, "")
492 if !c.Check(resp.NextMarker, check.Not(check.Equals), "") {
495 nextMarker = resp.NextMarker
497 c.Check(len(gotKeys), check.Equals, expectFiles)
500 func (s *IntegrationSuite) TestS3CollectionListRollup(c *check.C) {
501 for _, s.testServer.Config.cluster.Collections.S3FolderObjects = range []bool{false, true} {
502 s.testS3CollectionListRollup(c)
506 func (s *IntegrationSuite) testS3CollectionListRollup(c *check.C) {
507 stage := s.s3setup(c)
508 defer stage.teardown(c)
512 stage.writeBigDirs(c, dirs, filesPerDir)
513 err := stage.collbucket.PutReader("dingbats", &bytes.Buffer{}, 0, "application/octet-stream", s3.Private, s3.Options{})
514 c.Assert(err, check.IsNil)
515 var allfiles []string
516 for marker := ""; ; {
517 resp, err := stage.collbucket.List("", "", marker, 20000)
518 c.Check(err, check.IsNil)
519 for _, key := range resp.Contents {
520 if len(allfiles) == 0 || allfiles[len(allfiles)-1] != key.Key {
521 allfiles = append(allfiles, key.Key)
524 marker = resp.NextMarker
530 if s.testServer.Config.cluster.Collections.S3FolderObjects {
533 c.Check(allfiles, check.HasLen, dirs*(filesPerDir+markers)+3+markers)
535 gotDirMarker := map[string]bool{}
536 for _, name := range allfiles {
537 isDirMarker := strings.HasSuffix(name, "/")
539 c.Check(isDirMarker, check.Equals, false, check.Commentf("name %q", name))
540 } else if isDirMarker {
541 gotDirMarker[name] = true
542 } else if i := strings.LastIndex(name, "/"); i >= 0 {
543 c.Check(gotDirMarker[name[:i+1]], check.Equals, true, check.Commentf("name %q", name))
544 gotDirMarker[name[:i+1]] = true // skip redundant complaints about this dir marker
548 for _, trial := range []struct {
563 {"dir0", "/", "dir0/file14.txt"}, // no commonprefixes
564 {"", "", "dir0/file14.txt"}, // middle page, skip walking dir1
565 {"", "", "dir1/file14.txt"}, // middle page, skip walking dir0
566 {"", "", "dir1/file498.txt"}, // last page of results
567 {"dir1/file", "", "dir1/file498.txt"}, // last page of results, with prefix
568 {"dir1/file", "/", "dir1/file498.txt"}, // last page of results, with prefix + delimiter
569 {"dir1", "Z", "dir1/file498.txt"}, // delimiter "Z" never appears
570 {"dir2", "/", ""}, // prefix "dir2" does not exist
573 c.Logf("\n\n=== trial %+v markers=%d", trial, markers)
576 resp, err := stage.collbucket.List(trial.prefix, trial.delimiter, trial.marker, maxKeys)
577 c.Check(err, check.IsNil)
578 if resp.IsTruncated && trial.delimiter == "" {
579 // goamz List method fills in the missing
580 // NextMarker field if resp.IsTruncated, so
581 // now we can't really tell whether it was
582 // sent by the server or by goamz. In cases
583 // where it should be empty but isn't, assume
584 // it's goamz's fault.
588 var expectKeys []string
589 var expectPrefixes []string
590 var expectNextMarker string
591 var expectTruncated bool
592 for _, key := range allfiles {
593 full := len(expectKeys)+len(expectPrefixes) >= maxKeys
594 if !strings.HasPrefix(key, trial.prefix) || key < trial.marker {
596 } else if idx := strings.Index(key[len(trial.prefix):], trial.delimiter); trial.delimiter != "" && idx >= 0 {
597 prefix := key[:len(trial.prefix)+idx+1]
598 if len(expectPrefixes) > 0 && expectPrefixes[len(expectPrefixes)-1] == prefix {
599 // same prefix as previous key
601 expectNextMarker = key
602 expectTruncated = true
604 expectPrefixes = append(expectPrefixes, prefix)
607 if trial.delimiter != "" {
608 expectNextMarker = key
610 expectTruncated = true
613 expectKeys = append(expectKeys, key)
618 for _, key := range resp.Contents {
619 gotKeys = append(gotKeys, key.Key)
621 var gotPrefixes []string
622 for _, prefix := range resp.CommonPrefixes {
623 gotPrefixes = append(gotPrefixes, prefix)
625 commentf := check.Commentf("trial %+v markers=%d", trial, markers)
626 c.Check(gotKeys, check.DeepEquals, expectKeys, commentf)
627 c.Check(gotPrefixes, check.DeepEquals, expectPrefixes, commentf)
628 c.Check(resp.NextMarker, check.Equals, expectNextMarker, commentf)
629 c.Check(resp.IsTruncated, check.Equals, expectTruncated, commentf)
630 c.Logf("=== trial %+v keys %q prefixes %q nextMarker %q", trial, gotKeys, gotPrefixes, resp.NextMarker)