LogDog: Use per-project settings for archival.

server/internal/logdog/archivist/archivist_test.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package archivist
 
 import (
         "fmt"
         "strings"
         "sync"
@@ skipping 279 matching lines @@
                 sc := testServicesClient{
                         lsCallback: func(req *logdog.LoadStreamRequest) (*logdog.LoadStreamResponse, error) {
                                 return &stream, nil
                         },
                         asCallback: func(req *logdog.ArchiveStreamRequest) error {
                                 archiveRequest = req
                                 return archiveStreamErr
                         },
                 }
 
+                stBase := Settings{}
+
                 ar := Archivist{
-                        Service:       &sc,
-                        Storage:       &st,
-                        GSClient:      &gsc,
-                        GSBase:        gs.Path("gs://archive-test/path/to/archive/"),         // Extra slashes to test concatenation.
-                        GSStagingBase: gs.Path("gs://archive-test-staging/path/to/archive/"), // Extra slashes to test concatenation.
+                        Service: &sc,
+                        SettingsLoader: func(c context.Context, proj config.ProjectName) (*Settings, error) {
+                                if proj == "" {
+                                        proj = "_"
+                                }
+
+                                // Extra slashes to test concatenation,.
+                                st := stBase
+                                st.GSBase = gs.Path(fmt.Sprintf("gs://archival/%s/path/to/archive/", proj))
+                                st.GSStagingBase = gs.Path(fmt.Sprintf("gs://archival-staging/%s/path/to/archive/", proj))
+                                return &st, nil
+                        },
+                        Storage:  &st,
+                        GSClient: &gsc,
                 }
 
                 gsURL := func(project, name string) string {
-                        return fmt.Sprintf("gs://archive-test/path/to/archive/%s/%s/%s", project, desc.Path(), name)
+                        if project == "" {
+                                project = "_"
+                        }
+
+                        return fmt.Sprintf("gs://archival/%s/path/to/archive/%s/%s/%s", project, project, desc.Path(), name)
                 }
 
                 // hasStreams can be called to check that the retained archiveRequest had
                 // data sizes for the named archive stream types.
                 //
                 // After checking, the values are set to zero. This allows us to use
                 // ShouldEqual without hardcoding specific archival sizes into the results.
                 hasStreams := func(log, index, data bool) bool {
                         So(archiveRequest, ShouldNotBeNil)
                         if (log && archiveRequest.StreamSize <= 0) ||
@@ skipping 330 matching lines @@
 
                                                 So(ar.archiveTaskImpl(c, task), ShouldErrLike, "test error")
                                                 So(task.consumed, ShouldBeFalse)
                                                 So(archiveRequest, ShouldBeNil)
                                         })
                                 }
                         }
                 })
         })
 }