14 "git.curoverse.com/arvados.git/sdk/go/arvadostest"
15 "git.curoverse.com/arvados.git/sdk/go/keepclient"
20 // Gocheck boilerplate
21 func Test(t *testing.T) {
25 // Gocheck boilerplate
26 var _ = Suite(&ServerRequiredSuite{})
27 var _ = Suite(&DoMainTestSuite{})
29 type ServerRequiredSuite struct{}
30 type DoMainTestSuite struct{}
32 var kc *keepclient.KeepClient
33 var logBuffer bytes.Buffer
35 var TestHash = "aaaa09c290d0fb1ca068ffaddf22cbd0"
36 var TestHash2 = "aaaac516f788aec4f30932ffb6395c39"
38 func (s *ServerRequiredSuite) SetUpSuite(c *C) {
39 arvadostest.StartAPI()
42 func (s *ServerRequiredSuite) TearDownSuite(c *C) {
44 arvadostest.ResetEnv()
47 func (s *ServerRequiredSuite) SetUpTest(c *C) {
48 logOutput := io.MultiWriter(&logBuffer)
49 log.SetOutput(logOutput)
52 func (s *ServerRequiredSuite) TearDownTest(c *C) {
53 arvadostest.StopKeep(2)
54 log.SetOutput(os.Stdout)
55 log.Printf("%v", logBuffer.String())
58 func (s *DoMainTestSuite) SetUpSuite(c *C) {
61 func (s *DoMainTestSuite) SetUpTest(c *C) {
62 logOutput := io.MultiWriter(&logBuffer)
63 log.SetOutput(logOutput)
66 func (s *DoMainTestSuite) TearDownTest(c *C) {
67 log.SetOutput(os.Stdout)
68 log.Printf("%v", logBuffer.String())
71 func setupKeepBlockCheck(c *C, enforcePermissions bool, keepServicesJSON string) {
73 config.APIHost = os.Getenv("ARVADOS_API_HOST")
74 config.APIToken = arvadostest.DataManagerToken
75 config.APIHostInsecure = matchTrue.MatchString(os.Getenv("ARVADOS_API_HOST_INSECURE"))
78 arvadostest.StartKeep(2, enforcePermissions)
82 kc, err = setupKeepClient(config, keepServicesJSON)
87 func setupTestData(c *C) []string {
88 allLocators := []string{}
91 for i := 0; i < 5; i++ {
92 hash, _, err := kc.PutB([]byte(fmt.Sprintf("keep-block-check-test-data-%d", i)))
94 allLocators = append(allLocators, strings.Split(hash, "+A")[0])
100 func setupConfigFile(c *C, fileName string) string {
101 // Setup a config file
102 file, err := ioutil.TempFile(os.TempDir(), fileName)
105 // Add config to file. While at it, throw some extra white space
106 fileContent := "ARVADOS_API_HOST=" + os.Getenv("ARVADOS_API_HOST") + "\n"
107 fileContent += "ARVADOS_API_TOKEN=" + arvadostest.DataManagerToken + "\n"
109 fileContent += "ARVADOS_API_HOST_INSECURE=" + os.Getenv("ARVADOS_API_HOST_INSECURE") + "\n"
110 fileContent += " ARVADOS_EXTERNAL_CLIENT = false \n"
111 fileContent += " NotANameValuePairAndShouldGetIgnored \n"
112 fileContent += "ARVADOS_BLOB_SIGNING_KEY=abcdefg\n"
114 _, err = file.Write([]byte(fileContent))
120 func setupBlockHashFile(c *C, name string, blocks []string) string {
121 // Setup a block hash file
122 file, err := ioutil.TempFile(os.TempDir(), name)
125 // Add the hashes to the file. While at it, throw some extra white space
127 for _, hash := range blocks {
128 fileContent += fmt.Sprintf(" %s \n", hash)
131 _, err = file.Write([]byte(fileContent))
137 func checkErrorLog(c *C, blocks []string, prefix, suffix string) {
138 for _, hash := range blocks {
139 expected := prefix + `.*` + hash + `.*` + suffix
140 match, _ := regexp.MatchString(expected, logBuffer.String())
141 c.Assert(match, Equals, true)
145 func checkNoErrorsLogged(c *C, prefix, suffix string) {
146 expected := prefix + `.*` + suffix
147 match, _ := regexp.MatchString(expected, logBuffer.String())
148 c.Assert(match, Equals, false)
151 func (s *ServerRequiredSuite) TestBlockCheck(c *C) {
152 setupKeepBlockCheck(c, false, "")
153 allLocators := setupTestData(c)
154 err := performKeepBlockCheck(kc, "", allLocators, true)
156 checkNoErrorsLogged(c, "Error verifying block", "Block not found")
159 func (s *ServerRequiredSuite) TestBlockCheckWithBlobSigning(c *C) {
160 setupKeepBlockCheck(c, true, "")
161 allLocators := setupTestData(c)
162 err := performKeepBlockCheck(kc, arvadostest.BlobSigningKey, allLocators, true)
164 checkNoErrorsLogged(c, "Error verifying block", "Block not found")
167 func (s *ServerRequiredSuite) TestBlockCheck_NoSuchBlock(c *C) {
168 setupKeepBlockCheck(c, false, "")
169 allLocators := setupTestData(c)
170 allLocators = append(allLocators, TestHash)
171 allLocators = append(allLocators, TestHash2)
172 err := performKeepBlockCheck(kc, "", allLocators, true)
174 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 7 blocks with matching prefix.")
175 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "Block not found")
178 func (s *ServerRequiredSuite) TestBlockCheck_NoSuchBlock_WithMatchingPrefix(c *C) {
179 setupKeepBlockCheck(c, false, "")
180 allLocators := setupTestData(c)
181 allLocators = append(allLocators, TestHash)
182 allLocators = append(allLocators, TestHash2)
183 locatorFile := setupBlockHashFile(c, "block-hash", allLocators)
184 defer os.Remove(locatorFile)
185 locators, err := getBlockLocators(locatorFile, "aaa")
187 err = performKeepBlockCheck(kc, "", locators, true)
189 // Of the 7 blocks in allLocators, only two match the prefix and hence only those are checked
190 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 2 blocks with matching prefix.")
191 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "Block not found")
194 func (s *ServerRequiredSuite) TestBlockCheck_NoSuchBlock_WithPrefixMismatch(c *C) {
195 setupKeepBlockCheck(c, false, "")
196 allLocators := setupTestData(c)
197 allLocators = append(allLocators, TestHash)
198 allLocators = append(allLocators, TestHash2)
199 locatorFile := setupBlockHashFile(c, "block-hash", allLocators)
200 defer os.Remove(locatorFile)
201 locators, err := getBlockLocators(locatorFile, "999")
203 err = performKeepBlockCheck(kc, "", locators, true)
204 c.Check(err, IsNil) // there were no matching locators in file and hence nothing was checked
207 func (s *ServerRequiredSuite) TestBlockCheck_BadSignature(c *C) {
208 setupKeepBlockCheck(c, true, "")
210 err := performKeepBlockCheck(kc, "badblobsigningkey", []string{TestHash, TestHash2}, false)
211 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 2 blocks with matching prefix.")
212 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "HTTP 403")
213 // verbose logging not requested
214 c.Assert(strings.Contains(logBuffer.String(), "Verifying block 1 of 2"), Equals, false)
217 var testKeepServicesJSON = `{
218 "kind":"arvados#keepServiceList",
221 "offset":null, "limit":null,
223 {"href":"/keep_services/zzzzz-bi6l4-123456789012340",
224 "kind":"arvados#keepService",
225 "uuid":"zzzzz-bi6l4-123456789012340",
226 "service_host":"keep0.zzzzz.arvadosapi.com",
227 "service_port":25107,
228 "service_ssl_flag":false,
229 "service_type":"disk",
231 {"href":"/keep_services/zzzzz-bi6l4-123456789012341",
232 "kind":"arvados#keepService",
233 "uuid":"zzzzz-bi6l4-123456789012341",
234 "service_host":"keep0.zzzzz.arvadosapi.com",
235 "service_port":25108,
236 "service_ssl_flag":false,
237 "service_type":"disk",
240 "items_available":2 }`
242 // Setup block-check using keepServicesJSON with fake keepservers.
243 // Expect error during performKeepBlockCheck due to unreachable keepservers.
244 func (s *ServerRequiredSuite) TestErrorDuringKeepBlockCheck_FakeKeepservers(c *C) {
245 setupKeepBlockCheck(c, false, testKeepServicesJSON)
246 err := performKeepBlockCheck(kc, "", []string{TestHash, TestHash2}, true)
247 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 2 blocks with matching prefix.")
248 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "")
251 // Test keep-block-check initialization with keepServicesJSON
252 func (s *ServerRequiredSuite) TestKeepBlockCheck_InitializeWithKeepServicesJSON(c *C) {
253 setupKeepBlockCheck(c, false, testKeepServicesJSON)
255 for k := range kc.LocalRoots() {
256 if k == "zzzzz-bi6l4-123456789012340" || k == "zzzzz-bi6l4-123456789012341" {
260 c.Check(found, Equals, 2)
263 // Test loadConfig func
264 func (s *ServerRequiredSuite) TestLoadConfig(c *C) {
266 configFile := setupConfigFile(c, "config")
267 defer os.Remove(configFile)
269 // load configuration from the file
270 config, blobSigningKey, err := loadConfig(configFile)
273 c.Assert(config.APIHost, Equals, os.Getenv("ARVADOS_API_HOST"))
274 c.Assert(config.APIToken, Equals, arvadostest.DataManagerToken)
275 c.Assert(config.APIHostInsecure, Equals, matchTrue.MatchString(os.Getenv("ARVADOS_API_HOST_INSECURE")))
276 c.Assert(config.ExternalClient, Equals, false)
277 c.Assert(blobSigningKey, Equals, "abcdefg")
280 func (s *DoMainTestSuite) Test_doMain_WithNoConfig(c *C) {
281 args := []string{"-prefix", "a"}
284 c.Assert(strings.Contains(err.Error(), "config file not specified"), Equals, true)
287 func (s *DoMainTestSuite) Test_doMain_WithNoSuchConfigFile(c *C) {
288 args := []string{"-config", "no-such-file"}
291 c.Assert(strings.Contains(err.Error(), "no such file or directory"), Equals, true)
294 func (s *DoMainTestSuite) Test_doMain_WithNoBlockHashFile(c *C) {
295 config := setupConfigFile(c, "config")
296 defer os.Remove(config)
298 // Start keepservers.
299 arvadostest.StartKeep(2, false)
300 defer arvadostest.StopKeep(2)
302 args := []string{"-config", config}
304 c.Assert(strings.Contains(err.Error(), "block-hash-file not specified"), Equals, true)
307 func (s *DoMainTestSuite) Test_doMain_WithNoSuchBlockHashFile(c *C) {
308 config := setupConfigFile(c, "config")
309 defer os.Remove(config)
311 arvadostest.StartKeep(2, false)
312 defer arvadostest.StopKeep(2)
314 args := []string{"-config", config, "-block-hash-file", "no-such-file"}
316 c.Assert(strings.Contains(err.Error(), "no such file or directory"), Equals, true)
319 func (s *DoMainTestSuite) Test_doMain(c *C) {
320 // Start keepservers.
321 arvadostest.StartKeep(2, false)
322 defer arvadostest.StopKeep(2)
324 config := setupConfigFile(c, "config")
325 defer os.Remove(config)
327 locatorFile := setupBlockHashFile(c, "block-hash", []string{TestHash, TestHash2})
328 defer os.Remove(locatorFile)
330 args := []string{"-config", config, "-block-hash-file", locatorFile, "-v"}
333 c.Assert(err.Error(), Equals, "Block verification failed for 2 out of 2 blocks with matching prefix.")
334 checkErrorLog(c, []string{TestHash, TestHash2}, "Error verifying block", "Block not found")
335 c.Assert(strings.Contains(logBuffer.String(), "Verifying block 1 of 2"), Equals, true)