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