1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
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"
26 // Gocheck boilerplate
27 func Test(t *testing.T) {
31 // Gocheck boilerplate
32 var _ = Suite(&ServerRequiredSuite{})
33 var _ = Suite(&DoMainTestSuite{})
35 type ServerRequiredSuite struct{}
36 type DoMainTestSuite struct{}
38 var kc *keepclient.KeepClient
39 var logBuffer bytes.Buffer
41 var TestHash = "aaaa09c290d0fb1ca068ffaddf22cbd0"
42 var TestHash2 = "aaaac516f788aec4f30932ffb6395c39"
44 var blobSignatureTTL = time.Duration(2*7*24) * time.Hour
46 func (s *ServerRequiredSuite) TearDownSuite(c *C) {
47 arvadostest.ResetEnv()
50 func (s *ServerRequiredSuite) SetUpTest(c *C) {
51 logOutput := io.MultiWriter(&logBuffer)
52 log.SetOutput(logOutput)
55 func (s *ServerRequiredSuite) TearDownTest(c *C) {
56 arvadostest.StopKeep(2)
57 log.SetOutput(os.Stdout)
58 log.Printf("%v", logBuffer.String())
61 func (s *DoMainTestSuite) SetUpSuite(c *C) {
64 func (s *DoMainTestSuite) SetUpTest(c *C) {
65 logOutput := io.MultiWriter(&logBuffer)
66 log.SetOutput(logOutput)
67 keepclient.RefreshServiceDiscovery()
70 func (s *DoMainTestSuite) TearDownTest(c *C) {
71 log.SetOutput(os.Stdout)
72 log.Printf("%v", logBuffer.String())
75 func setupKeepBlockCheck(c *C, enforcePermissions bool, keepServicesJSON string) {
76 setupKeepBlockCheckWithTTL(c, enforcePermissions, keepServicesJSON, blobSignatureTTL)
79 func setupKeepBlockCheckWithTTL(c *C, enforcePermissions bool, keepServicesJSON string, ttl time.Duration) {
81 config.APIHost = os.Getenv("ARVADOS_API_HOST")
82 config.APIToken = arvadostest.DataManagerToken
83 config.APIHostInsecure = arvadosclient.StringBool(os.Getenv("ARVADOS_API_HOST_INSECURE"))
86 arvadostest.StartKeep(2, enforcePermissions)
90 kc, ttl, err = setupKeepClient(config, keepServicesJSON, ttl)
91 c.Assert(ttl, Equals, blobSignatureTTL)
94 keepclient.RefreshServiceDiscovery()
98 func setupTestData(c *C) []string {
99 allLocators := []string{}
102 for i := 0; i < 5; i++ {
103 hash, _, err := kc.PutB([]byte(fmt.Sprintf("keep-block-check-test-data-%d", i)))
105 allLocators = append(allLocators, strings.Split(hash, "+A")[0])
111 func setupConfigFile(c *C, fileName string) string {
112 // Setup a config file
113 file, err := ioutil.TempFile(os.TempDir(), fileName)
116 // Add config to file. While at it, throw some extra white space
117 fileContent := "ARVADOS_API_HOST=" + os.Getenv("ARVADOS_API_HOST") + "\n"
118 fileContent += "ARVADOS_API_TOKEN=" + arvadostest.DataManagerToken + "\n"
120 fileContent += "ARVADOS_API_HOST_INSECURE=" + os.Getenv("ARVADOS_API_HOST_INSECURE") + "\n"
121 fileContent += " ARVADOS_EXTERNAL_CLIENT = false \n"
122 fileContent += " NotANameValuePairAndShouldGetIgnored \n"
123 fileContent += "ARVADOS_BLOB_SIGNING_KEY=abcdefg\n"
125 _, err = file.Write([]byte(fileContent))
131 func setupBlockHashFile(c *C, name string, blocks []string) string {
132 // Setup a block hash file
133 file, err := ioutil.TempFile(os.TempDir(), name)
136 // Add the hashes to the file. While at it, throw some extra white space
138 for _, hash := range blocks {
139 fileContent += fmt.Sprintf(" %s \n", hash)
142 _, err = file.Write([]byte(fileContent))
148 func checkErrorLog(c *C, blocks []string, prefix, suffix string) {
149 for _, hash := range blocks {
150 expected := `(?ms).*` + prefix + `.*` + hash + `.*` + suffix + `.*`
151 c.Check(logBuffer.String(), Matches, expected)
155 func checkNoErrorsLogged(c *C, prefix, suffix string) {
156 expected := prefix + `.*` + suffix
157 match, _ := regexp.MatchString(expected, logBuffer.String())
158 c.Assert(match, Equals, false)
161 func (s *ServerRequiredSuite) TestBlockCheck(c *C) {
162 setupKeepBlockCheck(c, false, "")
163 allLocators := setupTestData(c)
164 err := performKeepBlockCheck(kc, blobSignatureTTL, "", allLocators, true)
166 checkNoErrorsLogged(c, "Error verifying block", "Block not found")
169 func (s *ServerRequiredSuite) TestBlockCheckWithBlobSigning(c *C) {
170 setupKeepBlockCheck(c, true, "")
171 allLocators := setupTestData(c)
172 err := performKeepBlockCheck(kc, blobSignatureTTL, arvadostest.BlobSigningKey, allLocators, true)
174 checkNoErrorsLogged(c, "Error verifying block", "Block not found")
177 func (s *ServerRequiredSuite) TestBlockCheckWithBlobSigningAndTTLFromDiscovery(c *C) {
178 setupKeepBlockCheckWithTTL(c, true, "", 0)
179 allLocators := setupTestData(c)
180 err := performKeepBlockCheck(kc, blobSignatureTTL, arvadostest.BlobSigningKey, allLocators, true)
182 checkNoErrorsLogged(c, "Error verifying block", "Block not found")
185 func (s *ServerRequiredSuite) TestBlockCheck_NoSuchBlock(c *C) {
186 setupKeepBlockCheck(c, false, "")
187 allLocators := setupTestData(c)
188 allLocators = append(allLocators, TestHash)
189 allLocators = append(allLocators, TestHash2)
190 err := performKeepBlockCheck(kc, blobSignatureTTL, "", allLocators, true)
192 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 7 blocks with matching prefix")
193 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "Block not found")
196 func (s *ServerRequiredSuite) TestBlockCheck_NoSuchBlock_WithMatchingPrefix(c *C) {
197 setupKeepBlockCheck(c, false, "")
198 allLocators := setupTestData(c)
199 allLocators = append(allLocators, TestHash)
200 allLocators = append(allLocators, TestHash2)
201 locatorFile := setupBlockHashFile(c, "block-hash", allLocators)
202 defer os.Remove(locatorFile)
203 locators, err := getBlockLocators(locatorFile, "aaa")
205 err = performKeepBlockCheck(kc, blobSignatureTTL, "", locators, true)
207 // Of the 7 blocks in allLocators, only two match the prefix and hence only those are checked
208 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 2 blocks with matching prefix")
209 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "Block not found")
212 func (s *ServerRequiredSuite) TestBlockCheck_NoSuchBlock_WithPrefixMismatch(c *C) {
213 setupKeepBlockCheck(c, false, "")
214 allLocators := setupTestData(c)
215 allLocators = append(allLocators, TestHash)
216 allLocators = append(allLocators, TestHash2)
217 locatorFile := setupBlockHashFile(c, "block-hash", allLocators)
218 defer os.Remove(locatorFile)
219 locators, err := getBlockLocators(locatorFile, "999")
221 err = performKeepBlockCheck(kc, blobSignatureTTL, "", locators, true)
222 c.Check(err, IsNil) // there were no matching locators in file and hence nothing was checked
225 func (s *ServerRequiredSuite) TestBlockCheck_BadSignature(c *C) {
226 setupKeepBlockCheck(c, true, "")
228 err := performKeepBlockCheck(kc, blobSignatureTTL, "badblobsigningkey", []string{TestHash, TestHash2}, false)
229 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 2 blocks with matching prefix")
230 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "HTTP 403")
231 // verbose logging not requested
232 c.Assert(strings.Contains(logBuffer.String(), "Verifying block 1 of 2"), Equals, false)
235 var testKeepServicesJSON = `{
236 "kind":"arvados#keepServiceList",
239 "offset":null, "limit":null,
241 {"href":"/keep_services/zzzzz-bi6l4-123456789012340",
242 "kind":"arvados#keepService",
243 "uuid":"zzzzz-bi6l4-123456789012340",
244 "service_host":"keep0.zzzzz.arvadosapi.com",
245 "service_port":25107,
246 "service_ssl_flag":false,
247 "service_type":"disk",
249 {"href":"/keep_services/zzzzz-bi6l4-123456789012341",
250 "kind":"arvados#keepService",
251 "uuid":"zzzzz-bi6l4-123456789012341",
252 "service_host":"keep0.zzzzz.arvadosapi.com",
253 "service_port":25108,
254 "service_ssl_flag":false,
255 "service_type":"disk",
258 "items_available":2 }`
260 // Setup block-check using keepServicesJSON with fake keepservers.
261 // Expect error during performKeepBlockCheck due to unreachable keepservers.
262 func (s *ServerRequiredSuite) TestErrorDuringKeepBlockCheck_FakeKeepservers(c *C) {
263 setupKeepBlockCheck(c, false, testKeepServicesJSON)
264 err := performKeepBlockCheck(kc, blobSignatureTTL, "", []string{TestHash, TestHash2}, true)
265 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 2 blocks with matching prefix")
266 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "")
269 // Test keep-block-check initialization with keepServicesJSON
270 func (s *ServerRequiredSuite) TestKeepBlockCheck_InitializeWithKeepServicesJSON(c *C) {
271 setupKeepBlockCheck(c, false, testKeepServicesJSON)
273 for k := range kc.LocalRoots() {
274 if k == "zzzzz-bi6l4-123456789012340" || k == "zzzzz-bi6l4-123456789012341" {
278 c.Check(found, Equals, 2)
281 // Test loadConfig func
282 func (s *ServerRequiredSuite) TestLoadConfig(c *C) {
284 configFile := setupConfigFile(c, "config")
285 defer os.Remove(configFile)
287 // load configuration from the file
288 config, blobSigningKey, err := loadConfig(configFile)
291 c.Assert(config.APIHost, Equals, os.Getenv("ARVADOS_API_HOST"))
292 c.Assert(config.APIToken, Equals, arvadostest.DataManagerToken)
293 c.Assert(config.APIHostInsecure, Equals, arvadosclient.StringBool(os.Getenv("ARVADOS_API_HOST_INSECURE")))
294 c.Assert(config.ExternalClient, Equals, false)
295 c.Assert(blobSigningKey, Equals, "abcdefg")
298 func (s *DoMainTestSuite) Test_doMain_WithNoConfig(c *C) {
299 args := []string{"-prefix", "a"}
302 c.Assert(strings.Contains(err.Error(), "config file not specified"), Equals, true)
305 func (s *DoMainTestSuite) Test_doMain_WithNoSuchConfigFile(c *C) {
306 args := []string{"-config", "no-such-file"}
309 c.Assert(strings.Contains(err.Error(), "no such file or directory"), Equals, true)
312 func (s *DoMainTestSuite) Test_doMain_WithNoBlockHashFile(c *C) {
313 config := setupConfigFile(c, "config")
314 defer os.Remove(config)
316 // Start keepservers.
317 arvadostest.StartKeep(2, false)
318 defer arvadostest.StopKeep(2)
320 args := []string{"-config", config}
322 c.Assert(strings.Contains(err.Error(), "block-hash-file not specified"), Equals, true)
325 func (s *DoMainTestSuite) Test_doMain_WithNoSuchBlockHashFile(c *C) {
326 config := setupConfigFile(c, "config")
327 defer os.Remove(config)
329 arvadostest.StartKeep(2, false)
330 defer arvadostest.StopKeep(2)
332 args := []string{"-config", config, "-block-hash-file", "no-such-file"}
334 c.Assert(strings.Contains(err.Error(), "no such file or directory"), Equals, true)
337 func (s *DoMainTestSuite) Test_doMain(c *C) {
338 // Start keepservers.
339 arvadostest.StartKeep(2, false)
340 defer arvadostest.StopKeep(2)
342 config := setupConfigFile(c, "config")
343 defer os.Remove(config)
345 locatorFile := setupBlockHashFile(c, "block-hash", []string{TestHash, TestHash2})
346 defer os.Remove(locatorFile)
348 args := []string{"-config", config, "-block-hash-file", locatorFile, "-v"}
351 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 2 blocks with matching prefix")
352 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "Block not found")
353 c.Assert(strings.Contains(logBuffer.String(), "Verifying block 1 of 2"), Equals, true)