12167: Generate only one request ID per get/put.
[arvados.git] / sdk / go / keepclient / keepclient_test.go
1 // Copyright (C) The Arvados Authors. All rights reserved.
2 //
3 // SPDX-License-Identifier: Apache-2.0
4
5 package keepclient
6
7 import (
8         "bytes"
9         "crypto/md5"
10         "errors"
11         "fmt"
12         "io"
13         "io/ioutil"
14         "log"
15         "net"
16         "net/http"
17         "os"
18         "strings"
19         "testing"
20         "time"
21
22         "git.curoverse.com/arvados.git/sdk/go/arvadosclient"
23         "git.curoverse.com/arvados.git/sdk/go/arvadostest"
24         . "gopkg.in/check.v1"
25 )
26
27 // Gocheck boilerplate
28 func Test(t *testing.T) {
29         TestingT(t)
30 }
31
32 // Gocheck boilerplate
33 var _ = Suite(&ServerRequiredSuite{})
34 var _ = Suite(&StandaloneSuite{})
35
36 // Tests that require the Keep server running
37 type ServerRequiredSuite struct{}
38
39 // Standalone tests
40 type StandaloneSuite struct{}
41
42 func (s *StandaloneSuite) SetUpTest(c *C) {
43         RefreshServiceDiscovery()
44 }
45
46 func pythonDir() string {
47         cwd, _ := os.Getwd()
48         return fmt.Sprintf("%s/../../python/tests", cwd)
49 }
50
51 func (s *ServerRequiredSuite) SetUpSuite(c *C) {
52         arvadostest.StartAPI()
53         arvadostest.StartKeep(2, false)
54 }
55
56 func (s *ServerRequiredSuite) TearDownSuite(c *C) {
57         arvadostest.StopKeep(2)
58         arvadostest.StopAPI()
59 }
60
61 func (s *ServerRequiredSuite) SetUpTest(c *C) {
62         RefreshServiceDiscovery()
63 }
64
65 func (s *ServerRequiredSuite) TestMakeKeepClient(c *C) {
66         arv, err := arvadosclient.MakeArvadosClient()
67         c.Assert(err, Equals, nil)
68
69         kc, err := MakeKeepClient(arv)
70
71         c.Assert(err, Equals, nil)
72         c.Check(len(kc.LocalRoots()), Equals, 2)
73         for _, root := range kc.LocalRoots() {
74                 c.Check(root, Matches, "http://localhost:\\d+")
75         }
76 }
77
78 func (s *ServerRequiredSuite) TestDefaultReplications(c *C) {
79         arv, err := arvadosclient.MakeArvadosClient()
80         c.Assert(err, Equals, nil)
81
82         kc, err := MakeKeepClient(arv)
83         c.Assert(kc.Want_replicas, Equals, 2)
84
85         arv.DiscoveryDoc["defaultCollectionReplication"] = 3.0
86         kc, err = MakeKeepClient(arv)
87         c.Assert(kc.Want_replicas, Equals, 3)
88
89         arv.DiscoveryDoc["defaultCollectionReplication"] = 1.0
90         kc, err = MakeKeepClient(arv)
91         c.Check(err, IsNil)
92         c.Assert(kc.Want_replicas, Equals, 1)
93 }
94
95 type StubPutHandler struct {
96         c              *C
97         expectPath     string
98         expectApiToken string
99         expectBody     string
100         handled        chan string
101 }
102
103 func (sph StubPutHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
104         sph.c.Check(req.URL.Path, Equals, "/"+sph.expectPath)
105         sph.c.Check(req.Header.Get("Authorization"), Equals, fmt.Sprintf("OAuth2 %s", sph.expectApiToken))
106         body, err := ioutil.ReadAll(req.Body)
107         sph.c.Check(err, Equals, nil)
108         sph.c.Check(body, DeepEquals, []byte(sph.expectBody))
109         resp.WriteHeader(200)
110         sph.handled <- fmt.Sprintf("http://%s", req.Host)
111 }
112
113 func RunFakeKeepServer(st http.Handler) (ks KeepServer) {
114         var err error
115         // If we don't explicitly bind it to localhost, ks.listener.Addr() will
116         // bind to 0.0.0.0 or [::] which is not a valid address for Dial()
117         ks.listener, err = net.ListenTCP("tcp", &net.TCPAddr{IP: []byte{127, 0, 0, 1}, Port: 0})
118         if err != nil {
119                 panic(fmt.Sprintf("Could not listen on any port"))
120         }
121         ks.url = fmt.Sprintf("http://%s", ks.listener.Addr().String())
122         go http.Serve(ks.listener, st)
123         return
124 }
125
126 func UploadToStubHelper(c *C, st http.Handler, f func(*KeepClient, string,
127         io.ReadCloser, io.WriteCloser, chan uploadStatus)) {
128
129         ks := RunFakeKeepServer(st)
130         defer ks.listener.Close()
131
132         arv, _ := arvadosclient.MakeArvadosClient()
133         arv.ApiToken = "abc123"
134
135         kc, _ := MakeKeepClient(arv)
136
137         reader, writer := io.Pipe()
138         upload_status := make(chan uploadStatus)
139
140         f(kc, ks.url, reader, writer, upload_status)
141 }
142
143 func (s *StandaloneSuite) TestUploadToStubKeepServer(c *C) {
144         log.Printf("TestUploadToStubKeepServer")
145
146         st := StubPutHandler{
147                 c,
148                 "acbd18db4cc2f85cedef654fccc4a4d8",
149                 "abc123",
150                 "foo",
151                 make(chan string)}
152
153         UploadToStubHelper(c, st,
154                 func(kc *KeepClient, url string, reader io.ReadCloser, writer io.WriteCloser, upload_status chan uploadStatus) {
155
156                         go kc.uploadToKeepServer(url, st.expectPath, reader, upload_status, int64(len("foo")), kc.getRequestID())
157
158                         writer.Write([]byte("foo"))
159                         writer.Close()
160
161                         <-st.handled
162                         status := <-upload_status
163                         c.Check(status, DeepEquals, uploadStatus{nil, fmt.Sprintf("%s/%s", url, st.expectPath), 200, 1, ""})
164                 })
165 }
166
167 func (s *StandaloneSuite) TestUploadToStubKeepServerBufferReader(c *C) {
168         st := StubPutHandler{
169                 c,
170                 "acbd18db4cc2f85cedef654fccc4a4d8",
171                 "abc123",
172                 "foo",
173                 make(chan string)}
174
175         UploadToStubHelper(c, st,
176                 func(kc *KeepClient, url string, _ io.ReadCloser, _ io.WriteCloser, upload_status chan uploadStatus) {
177                         go kc.uploadToKeepServer(url, st.expectPath, bytes.NewBuffer([]byte("foo")), upload_status, 3, kc.getRequestID())
178
179                         <-st.handled
180
181                         status := <-upload_status
182                         c.Check(status, DeepEquals, uploadStatus{nil, fmt.Sprintf("%s/%s", url, st.expectPath), 200, 1, ""})
183                 })
184 }
185
186 type FailHandler struct {
187         handled chan string
188 }
189
190 func (fh FailHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
191         resp.WriteHeader(500)
192         fh.handled <- fmt.Sprintf("http://%s", req.Host)
193 }
194
195 type FailThenSucceedHandler struct {
196         handled        chan string
197         count          int
198         successhandler StubGetHandler
199 }
200
201 func (fh *FailThenSucceedHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
202         if fh.count == 0 {
203                 resp.WriteHeader(500)
204                 fh.count += 1
205                 fh.handled <- fmt.Sprintf("http://%s", req.Host)
206         } else {
207                 fh.successhandler.ServeHTTP(resp, req)
208         }
209 }
210
211 type Error404Handler struct {
212         handled chan string
213 }
214
215 func (fh Error404Handler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
216         resp.WriteHeader(404)
217         fh.handled <- fmt.Sprintf("http://%s", req.Host)
218 }
219
220 func (s *StandaloneSuite) TestFailedUploadToStubKeepServer(c *C) {
221         st := FailHandler{
222                 make(chan string)}
223
224         hash := "acbd18db4cc2f85cedef654fccc4a4d8"
225
226         UploadToStubHelper(c, st,
227                 func(kc *KeepClient, url string, reader io.ReadCloser,
228                         writer io.WriteCloser, upload_status chan uploadStatus) {
229
230                         go kc.uploadToKeepServer(url, hash, reader, upload_status, 3, kc.getRequestID())
231
232                         writer.Write([]byte("foo"))
233                         writer.Close()
234
235                         <-st.handled
236
237                         status := <-upload_status
238                         c.Check(status.url, Equals, fmt.Sprintf("%s/%s", url, hash))
239                         c.Check(status.statusCode, Equals, 500)
240                 })
241 }
242
243 type KeepServer struct {
244         listener net.Listener
245         url      string
246 }
247
248 func RunSomeFakeKeepServers(st http.Handler, n int) (ks []KeepServer) {
249         ks = make([]KeepServer, n)
250
251         for i := 0; i < n; i += 1 {
252                 ks[i] = RunFakeKeepServer(st)
253         }
254
255         return ks
256 }
257
258 func (s *StandaloneSuite) TestPutB(c *C) {
259         hash := Md5String("foo")
260
261         st := StubPutHandler{
262                 c,
263                 hash,
264                 "abc123",
265                 "foo",
266                 make(chan string, 5)}
267
268         arv, _ := arvadosclient.MakeArvadosClient()
269         kc, _ := MakeKeepClient(arv)
270
271         kc.Want_replicas = 2
272         arv.ApiToken = "abc123"
273         localRoots := make(map[string]string)
274         writableLocalRoots := make(map[string]string)
275
276         ks := RunSomeFakeKeepServers(st, 5)
277
278         for i, k := range ks {
279                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
280                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
281                 defer k.listener.Close()
282         }
283
284         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
285
286         kc.PutB([]byte("foo"))
287
288         shuff := NewRootSorter(
289                 kc.LocalRoots(), Md5String("foo")).GetSortedRoots()
290
291         s1 := <-st.handled
292         s2 := <-st.handled
293         c.Check((s1 == shuff[0] && s2 == shuff[1]) ||
294                 (s1 == shuff[1] && s2 == shuff[0]),
295                 Equals,
296                 true)
297 }
298
299 func (s *StandaloneSuite) TestPutHR(c *C) {
300         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
301
302         st := StubPutHandler{
303                 c,
304                 hash,
305                 "abc123",
306                 "foo",
307                 make(chan string, 5)}
308
309         arv, _ := arvadosclient.MakeArvadosClient()
310         kc, _ := MakeKeepClient(arv)
311
312         kc.Want_replicas = 2
313         arv.ApiToken = "abc123"
314         localRoots := make(map[string]string)
315         writableLocalRoots := make(map[string]string)
316
317         ks := RunSomeFakeKeepServers(st, 5)
318
319         for i, k := range ks {
320                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
321                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
322                 defer k.listener.Close()
323         }
324
325         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
326
327         reader, writer := io.Pipe()
328
329         go func() {
330                 writer.Write([]byte("foo"))
331                 writer.Close()
332         }()
333
334         kc.PutHR(hash, reader, 3)
335
336         shuff := NewRootSorter(kc.LocalRoots(), hash).GetSortedRoots()
337
338         s1 := <-st.handled
339         s2 := <-st.handled
340
341         c.Check((s1 == shuff[0] && s2 == shuff[1]) ||
342                 (s1 == shuff[1] && s2 == shuff[0]),
343                 Equals,
344                 true)
345 }
346
347 func (s *StandaloneSuite) TestPutWithFail(c *C) {
348         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
349
350         st := StubPutHandler{
351                 c,
352                 hash,
353                 "abc123",
354                 "foo",
355                 make(chan string, 4)}
356
357         fh := FailHandler{
358                 make(chan string, 1)}
359
360         arv, err := arvadosclient.MakeArvadosClient()
361         kc, _ := MakeKeepClient(arv)
362
363         kc.Want_replicas = 2
364         arv.ApiToken = "abc123"
365         localRoots := make(map[string]string)
366         writableLocalRoots := make(map[string]string)
367
368         ks1 := RunSomeFakeKeepServers(st, 4)
369         ks2 := RunSomeFakeKeepServers(fh, 1)
370
371         for i, k := range ks1 {
372                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
373                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
374                 defer k.listener.Close()
375         }
376         for i, k := range ks2 {
377                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
378                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
379                 defer k.listener.Close()
380         }
381
382         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
383
384         shuff := NewRootSorter(
385                 kc.LocalRoots(), Md5String("foo")).GetSortedRoots()
386         c.Logf("%+v", shuff)
387
388         phash, replicas, err := kc.PutB([]byte("foo"))
389
390         <-fh.handled
391
392         c.Check(err, Equals, nil)
393         c.Check(phash, Equals, "")
394         c.Check(replicas, Equals, 2)
395
396         s1 := <-st.handled
397         s2 := <-st.handled
398
399         c.Check((s1 == shuff[1] && s2 == shuff[2]) ||
400                 (s1 == shuff[2] && s2 == shuff[1]),
401                 Equals,
402                 true)
403 }
404
405 func (s *StandaloneSuite) TestPutWithTooManyFail(c *C) {
406         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
407
408         st := StubPutHandler{
409                 c,
410                 hash,
411                 "abc123",
412                 "foo",
413                 make(chan string, 1)}
414
415         fh := FailHandler{
416                 make(chan string, 4)}
417
418         arv, err := arvadosclient.MakeArvadosClient()
419         kc, _ := MakeKeepClient(arv)
420
421         kc.Want_replicas = 2
422         kc.Retries = 0
423         arv.ApiToken = "abc123"
424         localRoots := make(map[string]string)
425         writableLocalRoots := make(map[string]string)
426
427         ks1 := RunSomeFakeKeepServers(st, 1)
428         ks2 := RunSomeFakeKeepServers(fh, 4)
429
430         for i, k := range ks1 {
431                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
432                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
433                 defer k.listener.Close()
434         }
435         for i, k := range ks2 {
436                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
437                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
438                 defer k.listener.Close()
439         }
440
441         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
442
443         _, replicas, err := kc.PutB([]byte("foo"))
444
445         c.Check(err, FitsTypeOf, InsufficientReplicasError(errors.New("")))
446         c.Check(replicas, Equals, 1)
447         c.Check(<-st.handled, Equals, ks1[0].url)
448 }
449
450 type StubGetHandler struct {
451         c              *C
452         expectPath     string
453         expectApiToken string
454         httpStatus     int
455         body           []byte
456 }
457
458 func (sgh StubGetHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
459         sgh.c.Check(req.URL.Path, Equals, "/"+sgh.expectPath)
460         sgh.c.Check(req.Header.Get("Authorization"), Equals, fmt.Sprintf("OAuth2 %s", sgh.expectApiToken))
461         resp.WriteHeader(sgh.httpStatus)
462         resp.Header().Set("Content-Length", fmt.Sprintf("%d", len(sgh.body)))
463         resp.Write(sgh.body)
464 }
465
466 func (s *StandaloneSuite) TestGet(c *C) {
467         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
468
469         st := StubGetHandler{
470                 c,
471                 hash,
472                 "abc123",
473                 http.StatusOK,
474                 []byte("foo")}
475
476         ks := RunFakeKeepServer(st)
477         defer ks.listener.Close()
478
479         arv, err := arvadosclient.MakeArvadosClient()
480         kc, _ := MakeKeepClient(arv)
481         arv.ApiToken = "abc123"
482         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
483
484         r, n, url2, err := kc.Get(hash)
485         defer r.Close()
486         c.Check(err, Equals, nil)
487         c.Check(n, Equals, int64(3))
488         c.Check(url2, Equals, fmt.Sprintf("%s/%s", ks.url, hash))
489
490         content, err2 := ioutil.ReadAll(r)
491         c.Check(err2, Equals, nil)
492         c.Check(content, DeepEquals, []byte("foo"))
493 }
494
495 func (s *StandaloneSuite) TestGet404(c *C) {
496         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
497
498         st := Error404Handler{make(chan string, 1)}
499
500         ks := RunFakeKeepServer(st)
501         defer ks.listener.Close()
502
503         arv, err := arvadosclient.MakeArvadosClient()
504         kc, _ := MakeKeepClient(arv)
505         arv.ApiToken = "abc123"
506         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
507
508         r, n, url2, err := kc.Get(hash)
509         c.Check(err, Equals, BlockNotFound)
510         c.Check(n, Equals, int64(0))
511         c.Check(url2, Equals, "")
512         c.Check(r, Equals, nil)
513 }
514
515 func (s *StandaloneSuite) TestGetEmptyBlock(c *C) {
516         st := Error404Handler{make(chan string, 1)}
517
518         ks := RunFakeKeepServer(st)
519         defer ks.listener.Close()
520
521         arv, err := arvadosclient.MakeArvadosClient()
522         kc, _ := MakeKeepClient(arv)
523         arv.ApiToken = "abc123"
524         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
525
526         r, n, url2, err := kc.Get("d41d8cd98f00b204e9800998ecf8427e+0")
527         c.Check(err, IsNil)
528         c.Check(n, Equals, int64(0))
529         c.Check(url2, Equals, "")
530         c.Assert(r, NotNil)
531         buf, err := ioutil.ReadAll(r)
532         c.Check(err, IsNil)
533         c.Check(buf, DeepEquals, []byte{})
534 }
535
536 func (s *StandaloneSuite) TestGetFail(c *C) {
537         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
538
539         st := FailHandler{make(chan string, 1)}
540
541         ks := RunFakeKeepServer(st)
542         defer ks.listener.Close()
543
544         arv, err := arvadosclient.MakeArvadosClient()
545         kc, _ := MakeKeepClient(arv)
546         arv.ApiToken = "abc123"
547         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
548         kc.Retries = 0
549
550         r, n, url2, err := kc.Get(hash)
551         errNotFound, _ := err.(*ErrNotFound)
552         c.Check(errNotFound, NotNil)
553         c.Check(strings.Contains(errNotFound.Error(), "HTTP 500"), Equals, true)
554         c.Check(errNotFound.Temporary(), Equals, true)
555         c.Check(n, Equals, int64(0))
556         c.Check(url2, Equals, "")
557         c.Check(r, Equals, nil)
558 }
559
560 func (s *StandaloneSuite) TestGetFailRetry(c *C) {
561         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
562
563         st := &FailThenSucceedHandler{make(chan string, 1), 0,
564                 StubGetHandler{
565                         c,
566                         hash,
567                         "abc123",
568                         http.StatusOK,
569                         []byte("foo")}}
570
571         ks := RunFakeKeepServer(st)
572         defer ks.listener.Close()
573
574         arv, err := arvadosclient.MakeArvadosClient()
575         kc, _ := MakeKeepClient(arv)
576         arv.ApiToken = "abc123"
577         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
578
579         r, n, url2, err := kc.Get(hash)
580         defer r.Close()
581         c.Check(err, Equals, nil)
582         c.Check(n, Equals, int64(3))
583         c.Check(url2, Equals, fmt.Sprintf("%s/%s", ks.url, hash))
584
585         content, err2 := ioutil.ReadAll(r)
586         c.Check(err2, Equals, nil)
587         c.Check(content, DeepEquals, []byte("foo"))
588 }
589
590 func (s *StandaloneSuite) TestGetNetError(c *C) {
591         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
592
593         arv, err := arvadosclient.MakeArvadosClient()
594         kc, _ := MakeKeepClient(arv)
595         arv.ApiToken = "abc123"
596         kc.SetServiceRoots(map[string]string{"x": "http://localhost:62222"}, nil, nil)
597
598         r, n, url2, err := kc.Get(hash)
599         errNotFound, _ := err.(*ErrNotFound)
600         c.Check(errNotFound, NotNil)
601         c.Check(strings.Contains(errNotFound.Error(), "connection refused"), Equals, true)
602         c.Check(errNotFound.Temporary(), Equals, true)
603         c.Check(n, Equals, int64(0))
604         c.Check(url2, Equals, "")
605         c.Check(r, Equals, nil)
606 }
607
608 func (s *StandaloneSuite) TestGetWithServiceHint(c *C) {
609         uuid := "zzzzz-bi6l4-123451234512345"
610         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
611
612         // This one shouldn't be used:
613         ks0 := RunFakeKeepServer(StubGetHandler{
614                 c,
615                 "error if used",
616                 "abc123",
617                 http.StatusOK,
618                 []byte("foo")})
619         defer ks0.listener.Close()
620         // This one should be used:
621         ks := RunFakeKeepServer(StubGetHandler{
622                 c,
623                 hash + "+K@" + uuid,
624                 "abc123",
625                 http.StatusOK,
626                 []byte("foo")})
627         defer ks.listener.Close()
628
629         arv, err := arvadosclient.MakeArvadosClient()
630         kc, _ := MakeKeepClient(arv)
631         arv.ApiToken = "abc123"
632         kc.SetServiceRoots(
633                 map[string]string{"x": ks0.url},
634                 nil,
635                 map[string]string{uuid: ks.url})
636
637         r, n, uri, err := kc.Get(hash + "+K@" + uuid)
638         defer r.Close()
639         c.Check(err, Equals, nil)
640         c.Check(n, Equals, int64(3))
641         c.Check(uri, Equals, fmt.Sprintf("%s/%s", ks.url, hash+"+K@"+uuid))
642
643         content, err := ioutil.ReadAll(r)
644         c.Check(err, Equals, nil)
645         c.Check(content, DeepEquals, []byte("foo"))
646 }
647
648 // Use a service hint to fetch from a local disk service, overriding
649 // rendezvous probe order.
650 func (s *StandaloneSuite) TestGetWithLocalServiceHint(c *C) {
651         uuid := "zzzzz-bi6l4-zzzzzzzzzzzzzzz"
652         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
653
654         // This one shouldn't be used, although it appears first in
655         // rendezvous probe order:
656         ks0 := RunFakeKeepServer(StubGetHandler{
657                 c,
658                 "error if used",
659                 "abc123",
660                 http.StatusOK,
661                 []byte("foo")})
662         defer ks0.listener.Close()
663         // This one should be used:
664         ks := RunFakeKeepServer(StubGetHandler{
665                 c,
666                 hash + "+K@" + uuid,
667                 "abc123",
668                 http.StatusOK,
669                 []byte("foo")})
670         defer ks.listener.Close()
671
672         arv, err := arvadosclient.MakeArvadosClient()
673         kc, _ := MakeKeepClient(arv)
674         arv.ApiToken = "abc123"
675         kc.SetServiceRoots(
676                 map[string]string{
677                         "zzzzz-bi6l4-yyyyyyyyyyyyyyy": ks0.url,
678                         "zzzzz-bi6l4-xxxxxxxxxxxxxxx": ks0.url,
679                         "zzzzz-bi6l4-wwwwwwwwwwwwwww": ks0.url,
680                         uuid: ks.url},
681                 nil,
682                 map[string]string{
683                         "zzzzz-bi6l4-yyyyyyyyyyyyyyy": ks0.url,
684                         "zzzzz-bi6l4-xxxxxxxxxxxxxxx": ks0.url,
685                         "zzzzz-bi6l4-wwwwwwwwwwwwwww": ks0.url,
686                         uuid: ks.url},
687         )
688
689         r, n, uri, err := kc.Get(hash + "+K@" + uuid)
690         defer r.Close()
691         c.Check(err, Equals, nil)
692         c.Check(n, Equals, int64(3))
693         c.Check(uri, Equals, fmt.Sprintf("%s/%s", ks.url, hash+"+K@"+uuid))
694
695         content, err := ioutil.ReadAll(r)
696         c.Check(err, Equals, nil)
697         c.Check(content, DeepEquals, []byte("foo"))
698 }
699
700 func (s *StandaloneSuite) TestGetWithServiceHintFailoverToLocals(c *C) {
701         uuid := "zzzzz-bi6l4-123451234512345"
702         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
703
704         ksLocal := RunFakeKeepServer(StubGetHandler{
705                 c,
706                 hash + "+K@" + uuid,
707                 "abc123",
708                 http.StatusOK,
709                 []byte("foo")})
710         defer ksLocal.listener.Close()
711         ksGateway := RunFakeKeepServer(StubGetHandler{
712                 c,
713                 hash + "+K@" + uuid,
714                 "abc123",
715                 http.StatusInternalServerError,
716                 []byte("Error")})
717         defer ksGateway.listener.Close()
718
719         arv, err := arvadosclient.MakeArvadosClient()
720         kc, _ := MakeKeepClient(arv)
721         arv.ApiToken = "abc123"
722         kc.SetServiceRoots(
723                 map[string]string{"zzzzz-bi6l4-keepdisk0000000": ksLocal.url},
724                 nil,
725                 map[string]string{uuid: ksGateway.url})
726
727         r, n, uri, err := kc.Get(hash + "+K@" + uuid)
728         c.Assert(err, Equals, nil)
729         defer r.Close()
730         c.Check(n, Equals, int64(3))
731         c.Check(uri, Equals, fmt.Sprintf("%s/%s", ksLocal.url, hash+"+K@"+uuid))
732
733         content, err := ioutil.ReadAll(r)
734         c.Check(err, Equals, nil)
735         c.Check(content, DeepEquals, []byte("foo"))
736 }
737
738 type BarHandler struct {
739         handled chan string
740 }
741
742 func (this BarHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
743         resp.Write([]byte("bar"))
744         this.handled <- fmt.Sprintf("http://%s", req.Host)
745 }
746
747 func (s *StandaloneSuite) TestChecksum(c *C) {
748         foohash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
749         barhash := fmt.Sprintf("%x", md5.Sum([]byte("bar")))
750
751         st := BarHandler{make(chan string, 1)}
752
753         ks := RunFakeKeepServer(st)
754         defer ks.listener.Close()
755
756         arv, err := arvadosclient.MakeArvadosClient()
757         kc, _ := MakeKeepClient(arv)
758         arv.ApiToken = "abc123"
759         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
760
761         r, n, _, err := kc.Get(barhash)
762         _, err = ioutil.ReadAll(r)
763         c.Check(n, Equals, int64(3))
764         c.Check(err, Equals, nil)
765
766         <-st.handled
767
768         r, n, _, err = kc.Get(foohash)
769         _, err = ioutil.ReadAll(r)
770         c.Check(n, Equals, int64(3))
771         c.Check(err, Equals, BadChecksum)
772
773         <-st.handled
774 }
775
776 func (s *StandaloneSuite) TestGetWithFailures(c *C) {
777         content := []byte("waz")
778         hash := fmt.Sprintf("%x", md5.Sum(content))
779
780         fh := Error404Handler{
781                 make(chan string, 4)}
782
783         st := StubGetHandler{
784                 c,
785                 hash,
786                 "abc123",
787                 http.StatusOK,
788                 content}
789
790         arv, err := arvadosclient.MakeArvadosClient()
791         kc, _ := MakeKeepClient(arv)
792         arv.ApiToken = "abc123"
793         localRoots := make(map[string]string)
794         writableLocalRoots := make(map[string]string)
795
796         ks1 := RunSomeFakeKeepServers(st, 1)
797         ks2 := RunSomeFakeKeepServers(fh, 4)
798
799         for i, k := range ks1 {
800                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
801                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
802                 defer k.listener.Close()
803         }
804         for i, k := range ks2 {
805                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
806                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
807                 defer k.listener.Close()
808         }
809
810         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
811         kc.Retries = 0
812
813         // This test works only if one of the failing services is
814         // attempted before the succeeding service. Otherwise,
815         // <-fh.handled below will just hang! (Probe order depends on
816         // the choice of block content "waz" and the UUIDs of the fake
817         // servers, so we just tried different strings until we found
818         // an example that passes this Assert.)
819         c.Assert(NewRootSorter(localRoots, hash).GetSortedRoots()[0], Not(Equals), ks1[0].url)
820
821         r, n, url2, err := kc.Get(hash)
822
823         <-fh.handled
824         c.Check(err, Equals, nil)
825         c.Check(n, Equals, int64(3))
826         c.Check(url2, Equals, fmt.Sprintf("%s/%s", ks1[0].url, hash))
827
828         read_content, err2 := ioutil.ReadAll(r)
829         c.Check(err2, Equals, nil)
830         c.Check(read_content, DeepEquals, content)
831 }
832
833 func (s *ServerRequiredSuite) TestPutGetHead(c *C) {
834         content := []byte("TestPutGetHead")
835
836         arv, err := arvadosclient.MakeArvadosClient()
837         kc, err := MakeKeepClient(arv)
838         c.Assert(err, Equals, nil)
839
840         hash := fmt.Sprintf("%x", md5.Sum(content))
841
842         {
843                 n, _, err := kc.Ask(hash)
844                 c.Check(err, Equals, BlockNotFound)
845                 c.Check(n, Equals, int64(0))
846         }
847         {
848                 hash2, replicas, err := kc.PutB(content)
849                 c.Check(hash2, Matches, fmt.Sprintf(`%s\+%d\b.*`, hash, len(content)))
850                 c.Check(replicas, Equals, 2)
851                 c.Check(err, Equals, nil)
852         }
853         {
854                 r, n, url2, err := kc.Get(hash)
855                 c.Check(err, Equals, nil)
856                 c.Check(n, Equals, int64(len(content)))
857                 c.Check(url2, Matches, fmt.Sprintf("http://localhost:\\d+/%s", hash))
858
859                 read_content, err2 := ioutil.ReadAll(r)
860                 c.Check(err2, Equals, nil)
861                 c.Check(read_content, DeepEquals, content)
862         }
863         {
864                 n, url2, err := kc.Ask(hash)
865                 c.Check(err, Equals, nil)
866                 c.Check(n, Equals, int64(len(content)))
867                 c.Check(url2, Matches, fmt.Sprintf("http://localhost:\\d+/%s", hash))
868         }
869 }
870
871 type StubProxyHandler struct {
872         handled chan string
873 }
874
875 func (this StubProxyHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
876         resp.Header().Set("X-Keep-Replicas-Stored", "2")
877         this.handled <- fmt.Sprintf("http://%s", req.Host)
878 }
879
880 func (s *StandaloneSuite) TestPutProxy(c *C) {
881         st := StubProxyHandler{make(chan string, 1)}
882
883         arv, err := arvadosclient.MakeArvadosClient()
884         kc, _ := MakeKeepClient(arv)
885
886         kc.Want_replicas = 2
887         arv.ApiToken = "abc123"
888         localRoots := make(map[string]string)
889         writableLocalRoots := make(map[string]string)
890
891         ks1 := RunSomeFakeKeepServers(st, 1)
892
893         for i, k := range ks1 {
894                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
895                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
896                 defer k.listener.Close()
897         }
898
899         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
900
901         _, replicas, err := kc.PutB([]byte("foo"))
902         <-st.handled
903
904         c.Check(err, Equals, nil)
905         c.Check(replicas, Equals, 2)
906 }
907
908 func (s *StandaloneSuite) TestPutProxyInsufficientReplicas(c *C) {
909         st := StubProxyHandler{make(chan string, 1)}
910
911         arv, err := arvadosclient.MakeArvadosClient()
912         kc, _ := MakeKeepClient(arv)
913
914         kc.Want_replicas = 3
915         arv.ApiToken = "abc123"
916         localRoots := make(map[string]string)
917         writableLocalRoots := make(map[string]string)
918
919         ks1 := RunSomeFakeKeepServers(st, 1)
920
921         for i, k := range ks1 {
922                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
923                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
924                 defer k.listener.Close()
925         }
926         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
927
928         _, replicas, err := kc.PutB([]byte("foo"))
929         <-st.handled
930
931         c.Check(err, FitsTypeOf, InsufficientReplicasError(errors.New("")))
932         c.Check(replicas, Equals, 2)
933 }
934
935 func (s *StandaloneSuite) TestMakeLocator(c *C) {
936         l, err := MakeLocator("91f372a266fe2bf2823cb8ec7fda31ce+3+Aabcde@12345678")
937         c.Check(err, Equals, nil)
938         c.Check(l.Hash, Equals, "91f372a266fe2bf2823cb8ec7fda31ce")
939         c.Check(l.Size, Equals, 3)
940         c.Check(l.Hints, DeepEquals, []string{"3", "Aabcde@12345678"})
941 }
942
943 func (s *StandaloneSuite) TestMakeLocatorNoHints(c *C) {
944         l, err := MakeLocator("91f372a266fe2bf2823cb8ec7fda31ce")
945         c.Check(err, Equals, nil)
946         c.Check(l.Hash, Equals, "91f372a266fe2bf2823cb8ec7fda31ce")
947         c.Check(l.Size, Equals, -1)
948         c.Check(l.Hints, DeepEquals, []string{})
949 }
950
951 func (s *StandaloneSuite) TestMakeLocatorNoSizeHint(c *C) {
952         l, err := MakeLocator("91f372a266fe2bf2823cb8ec7fda31ce+Aabcde@12345678")
953         c.Check(err, Equals, nil)
954         c.Check(l.Hash, Equals, "91f372a266fe2bf2823cb8ec7fda31ce")
955         c.Check(l.Size, Equals, -1)
956         c.Check(l.Hints, DeepEquals, []string{"Aabcde@12345678"})
957 }
958
959 func (s *StandaloneSuite) TestMakeLocatorPreservesUnrecognizedHints(c *C) {
960         str := "91f372a266fe2bf2823cb8ec7fda31ce+3+Unknown+Kzzzzz+Afoobar"
961         l, err := MakeLocator(str)
962         c.Check(err, Equals, nil)
963         c.Check(l.Hash, Equals, "91f372a266fe2bf2823cb8ec7fda31ce")
964         c.Check(l.Size, Equals, 3)
965         c.Check(l.Hints, DeepEquals, []string{"3", "Unknown", "Kzzzzz", "Afoobar"})
966         c.Check(l.String(), Equals, str)
967 }
968
969 func (s *StandaloneSuite) TestMakeLocatorInvalidInput(c *C) {
970         _, err := MakeLocator("91f372a266fe2bf2823cb8ec7fda31c")
971         c.Check(err, Equals, InvalidLocatorError)
972 }
973
974 func (s *StandaloneSuite) TestPutBWant2ReplicasWithOnlyOneWritableLocalRoot(c *C) {
975         hash := Md5String("foo")
976
977         st := StubPutHandler{
978                 c,
979                 hash,
980                 "abc123",
981                 "foo",
982                 make(chan string, 5)}
983
984         arv, _ := arvadosclient.MakeArvadosClient()
985         kc, _ := MakeKeepClient(arv)
986
987         kc.Want_replicas = 2
988         arv.ApiToken = "abc123"
989         localRoots := make(map[string]string)
990         writableLocalRoots := make(map[string]string)
991
992         ks := RunSomeFakeKeepServers(st, 5)
993
994         for i, k := range ks {
995                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
996                 if i == 0 {
997                         writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
998                 }
999                 defer k.listener.Close()
1000         }
1001
1002         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
1003
1004         _, replicas, err := kc.PutB([]byte("foo"))
1005
1006         c.Check(err, FitsTypeOf, InsufficientReplicasError(errors.New("")))
1007         c.Check(replicas, Equals, 1)
1008
1009         c.Check(<-st.handled, Equals, localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", 0)])
1010 }
1011
1012 func (s *StandaloneSuite) TestPutBWithNoWritableLocalRoots(c *C) {
1013         hash := Md5String("foo")
1014
1015         st := StubPutHandler{
1016                 c,
1017                 hash,
1018                 "abc123",
1019                 "foo",
1020                 make(chan string, 5)}
1021
1022         arv, _ := arvadosclient.MakeArvadosClient()
1023         kc, _ := MakeKeepClient(arv)
1024
1025         kc.Want_replicas = 2
1026         arv.ApiToken = "abc123"
1027         localRoots := make(map[string]string)
1028         writableLocalRoots := make(map[string]string)
1029
1030         ks := RunSomeFakeKeepServers(st, 5)
1031
1032         for i, k := range ks {
1033                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
1034                 defer k.listener.Close()
1035         }
1036
1037         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
1038
1039         _, replicas, err := kc.PutB([]byte("foo"))
1040
1041         c.Check(err, FitsTypeOf, InsufficientReplicasError(errors.New("")))
1042         c.Check(replicas, Equals, 0)
1043 }
1044
1045 type StubGetIndexHandler struct {
1046         c              *C
1047         expectPath     string
1048         expectAPIToken string
1049         httpStatus     int
1050         body           []byte
1051 }
1052
1053 func (h StubGetIndexHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
1054         h.c.Check(req.URL.Path, Equals, h.expectPath)
1055         h.c.Check(req.Header.Get("Authorization"), Equals, fmt.Sprintf("OAuth2 %s", h.expectAPIToken))
1056         resp.WriteHeader(h.httpStatus)
1057         resp.Header().Set("Content-Length", fmt.Sprintf("%d", len(h.body)))
1058         resp.Write(h.body)
1059 }
1060
1061 func (s *StandaloneSuite) TestGetIndexWithNoPrefix(c *C) {
1062         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
1063
1064         st := StubGetIndexHandler{
1065                 c,
1066                 "/index",
1067                 "abc123",
1068                 http.StatusOK,
1069                 []byte(hash + "+3 1443559274\n\n")}
1070
1071         ks := RunFakeKeepServer(st)
1072         defer ks.listener.Close()
1073
1074         arv, err := arvadosclient.MakeArvadosClient()
1075         c.Assert(err, IsNil)
1076         kc, err := MakeKeepClient(arv)
1077         c.Assert(err, IsNil)
1078         arv.ApiToken = "abc123"
1079         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
1080
1081         r, err := kc.GetIndex("x", "")
1082         c.Check(err, IsNil)
1083
1084         content, err2 := ioutil.ReadAll(r)
1085         c.Check(err2, Equals, nil)
1086         c.Check(content, DeepEquals, st.body[0:len(st.body)-1])
1087 }
1088
1089 func (s *StandaloneSuite) TestGetIndexWithPrefix(c *C) {
1090         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
1091
1092         st := StubGetIndexHandler{
1093                 c,
1094                 "/index/" + hash[0:3],
1095                 "abc123",
1096                 http.StatusOK,
1097                 []byte(hash + "+3 1443559274\n\n")}
1098
1099         ks := RunFakeKeepServer(st)
1100         defer ks.listener.Close()
1101
1102         arv, err := arvadosclient.MakeArvadosClient()
1103         kc, _ := MakeKeepClient(arv)
1104         arv.ApiToken = "abc123"
1105         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
1106
1107         r, err := kc.GetIndex("x", hash[0:3])
1108         c.Assert(err, Equals, nil)
1109
1110         content, err2 := ioutil.ReadAll(r)
1111         c.Check(err2, Equals, nil)
1112         c.Check(content, DeepEquals, st.body[0:len(st.body)-1])
1113 }
1114
1115 func (s *StandaloneSuite) TestGetIndexIncomplete(c *C) {
1116         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
1117
1118         st := StubGetIndexHandler{
1119                 c,
1120                 "/index/" + hash[0:3],
1121                 "abc123",
1122                 http.StatusOK,
1123                 []byte(hash)}
1124
1125         ks := RunFakeKeepServer(st)
1126         defer ks.listener.Close()
1127
1128         arv, err := arvadosclient.MakeArvadosClient()
1129         kc, _ := MakeKeepClient(arv)
1130         arv.ApiToken = "abc123"
1131         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
1132
1133         _, err = kc.GetIndex("x", hash[0:3])
1134         c.Check(err, Equals, ErrIncompleteIndex)
1135 }
1136
1137 func (s *StandaloneSuite) TestGetIndexWithNoSuchServer(c *C) {
1138         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
1139
1140         st := StubGetIndexHandler{
1141                 c,
1142                 "/index/" + hash[0:3],
1143                 "abc123",
1144                 http.StatusOK,
1145                 []byte(hash)}
1146
1147         ks := RunFakeKeepServer(st)
1148         defer ks.listener.Close()
1149
1150         arv, err := arvadosclient.MakeArvadosClient()
1151         kc, _ := MakeKeepClient(arv)
1152         arv.ApiToken = "abc123"
1153         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
1154
1155         _, err = kc.GetIndex("y", hash[0:3])
1156         c.Check(err, Equals, ErrNoSuchKeepServer)
1157 }
1158
1159 func (s *StandaloneSuite) TestGetIndexWithNoSuchPrefix(c *C) {
1160         st := StubGetIndexHandler{
1161                 c,
1162                 "/index/abcd",
1163                 "abc123",
1164                 http.StatusOK,
1165                 []byte("\n")}
1166
1167         ks := RunFakeKeepServer(st)
1168         defer ks.listener.Close()
1169
1170         arv, err := arvadosclient.MakeArvadosClient()
1171         kc, _ := MakeKeepClient(arv)
1172         arv.ApiToken = "abc123"
1173         kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
1174
1175         r, err := kc.GetIndex("x", "abcd")
1176         c.Check(err, Equals, nil)
1177
1178         content, err2 := ioutil.ReadAll(r)
1179         c.Check(err2, Equals, nil)
1180         c.Check(content, DeepEquals, st.body[0:len(st.body)-1])
1181 }
1182
1183 type FailThenSucceedPutHandler struct {
1184         handled        chan string
1185         count          int
1186         successhandler StubPutHandler
1187 }
1188
1189 func (h *FailThenSucceedPutHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
1190         if h.count == 0 {
1191                 resp.WriteHeader(500)
1192                 h.count += 1
1193                 h.handled <- fmt.Sprintf("http://%s", req.Host)
1194         } else {
1195                 h.successhandler.ServeHTTP(resp, req)
1196         }
1197 }
1198
1199 func (s *StandaloneSuite) TestPutBRetry(c *C) {
1200         st := &FailThenSucceedPutHandler{make(chan string, 1), 0,
1201                 StubPutHandler{
1202                         c,
1203                         Md5String("foo"),
1204                         "abc123",
1205                         "foo",
1206                         make(chan string, 5)}}
1207
1208         arv, _ := arvadosclient.MakeArvadosClient()
1209         kc, _ := MakeKeepClient(arv)
1210
1211         kc.Want_replicas = 2
1212         arv.ApiToken = "abc123"
1213         localRoots := make(map[string]string)
1214         writableLocalRoots := make(map[string]string)
1215
1216         ks := RunSomeFakeKeepServers(st, 2)
1217
1218         for i, k := range ks {
1219                 localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
1220                 writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
1221                 defer k.listener.Close()
1222         }
1223
1224         kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
1225
1226         hash, replicas, err := kc.PutB([]byte("foo"))
1227
1228         c.Check(err, Equals, nil)
1229         c.Check(hash, Equals, "")
1230         c.Check(replicas, Equals, 2)
1231 }
1232
1233 func (s *ServerRequiredSuite) TestMakeKeepClientWithNonDiskTypeService(c *C) {
1234         arv, err := arvadosclient.MakeArvadosClient()
1235         c.Assert(err, Equals, nil)
1236
1237         // Add an additional "testblobstore" keepservice
1238         blobKeepService := make(arvadosclient.Dict)
1239         err = arv.Create("keep_services",
1240                 arvadosclient.Dict{"keep_service": arvadosclient.Dict{
1241                         "service_host": "localhost",
1242                         "service_port": "21321",
1243                         "service_type": "testblobstore"}},
1244                 &blobKeepService)
1245         c.Assert(err, Equals, nil)
1246         defer func() { arv.Delete("keep_services", blobKeepService["uuid"].(string), nil, nil) }()
1247         RefreshServiceDiscovery()
1248
1249         // Make a keepclient and ensure that the testblobstore is included
1250         kc, err := MakeKeepClient(arv)
1251         c.Assert(err, Equals, nil)
1252
1253         // verify kc.LocalRoots
1254         c.Check(len(kc.LocalRoots()), Equals, 3)
1255         for _, root := range kc.LocalRoots() {
1256                 c.Check(root, Matches, "http://localhost:\\d+")
1257         }
1258         c.Assert(kc.LocalRoots()[blobKeepService["uuid"].(string)], Not(Equals), "")
1259
1260         // verify kc.GatewayRoots
1261         c.Check(len(kc.GatewayRoots()), Equals, 3)
1262         for _, root := range kc.GatewayRoots() {
1263                 c.Check(root, Matches, "http://localhost:\\d+")
1264         }
1265         c.Assert(kc.GatewayRoots()[blobKeepService["uuid"].(string)], Not(Equals), "")
1266
1267         // verify kc.WritableLocalRoots
1268         c.Check(len(kc.WritableLocalRoots()), Equals, 3)
1269         for _, root := range kc.WritableLocalRoots() {
1270                 c.Check(root, Matches, "http://localhost:\\d+")
1271         }
1272         c.Assert(kc.WritableLocalRoots()[blobKeepService["uuid"].(string)], Not(Equals), "")
1273
1274         c.Assert(kc.replicasPerService, Equals, 0)
1275         c.Assert(kc.foundNonDiskSvc, Equals, true)
1276         c.Assert(kc.httpClient().(*http.Client).Timeout, Equals, 300*time.Second)
1277 }