func (s *StandaloneSuite) TestGetFailRetry(c *C) {
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
st := &FailThenSucceedHandler{make(chan string, 1), 0,
StubGetHandler{
c,
hash,
"abc123",
http.StatusOK,
[]byte("foo")}}
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
r, n, url2, err := kc.Get(hash)
defer r.Close()
c.Check(err, Equals, nil)
c.Check(n, Equals, int64(3))
c.Check(url2, Equals, fmt.Sprintf("%s/%s", ks.url, hash))
content, err2 := ioutil.ReadAll(r)
c.Check(err2, Equals, nil)
c.Check(content, DeepEquals, []byte("foo"))
}
func (s *StandaloneSuite) TestPutBRetry(c *C) {
st := &FailThenSucceedPutHandler{make(chan string, 1), 0,
StubPutHandler{
c,
Md5String("foo"),
"abc123",
"foo",
make(chan string, 5)}}
arv, _ := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
kc.Want_replicas = 2
arv.ApiToken = "abc123"
localRoots := make(map[string]string)
writableLocalRoots := make(map[string]string)
ks := RunSomeFakeKeepServers(st, 2)
for i, k := range ks {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
defer k.listener.Close()
}
kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
hash, replicas, err := kc.PutB([]byte("foo"))
c.Check(err, Equals, nil)
c.Check(hash, Equals, "")
c.Check(replicas, Equals, 2)
}
func (s *StandaloneSuite) TestGetIndexWithPrefix(c *C) {
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
st := StubGetIndexHandler{
c,
"/index/" + hash[0:3],
"abc123",
http.StatusOK,
[]byte(hash + "+3 1443559274\n\n")}
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
r, err := kc.GetIndex("x", hash[0:3])
c.Check(err, Equals, nil)
content, err2 := ioutil.ReadAll(r)
c.Check(err2, Equals, nil)
c.Check(content, DeepEquals, st.body[0:len(st.body)-1])
}
func (s *StandaloneSuite) TestChecksum(c *C) {
foohash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
barhash := fmt.Sprintf("%x", md5.Sum([]byte("bar")))
st := BarHandler{make(chan string, 1)}
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
r, n, _, err := kc.Get(barhash)
_, err = ioutil.ReadAll(r)
c.Check(n, Equals, int64(3))
c.Check(err, Equals, nil)
<-st.handled
r, n, _, err = kc.Get(foohash)
_, err = ioutil.ReadAll(r)
c.Check(n, Equals, int64(3))
c.Check(err, Equals, BadChecksum)
<-st.handled
}
func (s *StandaloneSuite) TestPutBWithNoWritableLocalRoots(c *C) {
hash := Md5String("foo")
st := StubPutHandler{
c,
hash,
"abc123",
"foo",
make(chan string, 5)}
arv, _ := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
kc.Want_replicas = 2
arv.ApiToken = "abc123"
localRoots := make(map[string]string)
writableLocalRoots := make(map[string]string)
ks := RunSomeFakeKeepServers(st, 5)
for i, k := range ks {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
defer k.listener.Close()
}
kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
_, replicas, err := kc.PutB([]byte("foo"))
c.Check(err, Equals, InsufficientReplicasError)
c.Check(replicas, Equals, 0)
}
func (s *StandaloneSuite) TestPutProxyInsufficientReplicas(c *C) {
log.Printf("TestPutProxy")
st := StubProxyHandler{make(chan string, 1)}
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
kc.Want_replicas = 3
kc.Using_proxy = true
arv.ApiToken = "abc123"
localRoots := make(map[string]string)
writableLocalRoots := make(map[string]string)
ks1 := RunSomeFakeKeepServers(st, 1)
for i, k := range ks1 {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
defer k.listener.Close()
}
kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
_, replicas, err := kc.PutB([]byte("foo"))
<-st.handled
c.Check(err, Equals, InsufficientReplicasError)
c.Check(replicas, Equals, 2)
log.Printf("TestPutProxy done")
}
func (s *StandaloneSuite) TestPutWithFail(c *C) {
log.Printf("TestPutWithFail")
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
st := StubPutHandler{
c,
hash,
"abc123",
"foo",
make(chan string, 4)}
fh := FailHandler{
make(chan string, 1)}
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
kc.Want_replicas = 2
arv.ApiToken = "abc123"
localRoots := make(map[string]string)
writableLocalRoots := make(map[string]string)
ks1 := RunSomeFakeKeepServers(st, 4)
ks2 := RunSomeFakeKeepServers(fh, 1)
for i, k := range ks1 {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
defer k.listener.Close()
}
for i, k := range ks2 {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
defer k.listener.Close()
}
kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
shuff := NewRootSorter(
kc.LocalRoots(), Md5String("foo")).GetSortedRoots()
phash, replicas, err := kc.PutB([]byte("foo"))
<-fh.handled
c.Check(err, Equals, nil)
c.Check(phash, Equals, "")
c.Check(replicas, Equals, 2)
s1 := <-st.handled
s2 := <-st.handled
c.Check((s1 == shuff[1] && s2 == shuff[2]) ||
(s1 == shuff[2] && s2 == shuff[1]),
Equals,
true)
}
// Since keepstore does not come into picture in tests,
// we need to explicitly start the goroutine in tests.
func RunTestPullWorker(c *C) {
arv, err := arvadosclient.MakeArvadosClient()
c.Assert(err, Equals, nil)
keepClient, err := keepclient.MakeKeepClient(&arv)
c.Assert(err, Equals, nil)
pullq = NewWorkQueue()
go RunPullWorker(pullq, keepClient)
}
func (s *StandaloneSuite) TestGetWithFailures(c *C) {
content := []byte("waz")
hash := fmt.Sprintf("%x", md5.Sum(content))
fh := Error404Handler{
make(chan string, 4)}
st := StubGetHandler{
c,
hash,
"abc123",
http.StatusOK,
content}
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
localRoots := make(map[string]string)
writableLocalRoots := make(map[string]string)
ks1 := RunSomeFakeKeepServers(st, 1)
ks2 := RunSomeFakeKeepServers(fh, 4)
for i, k := range ks1 {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
defer k.listener.Close()
}
for i, k := range ks2 {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
defer k.listener.Close()
}
kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
kc.Retries = 0
// This test works only if one of the failing services is
// attempted before the succeeding service. Otherwise,
// <-fh.handled below will just hang! (Probe order depends on
// the choice of block content "waz" and the UUIDs of the fake
// servers, so we just tried different strings until we found
// an example that passes this Assert.)
c.Assert(NewRootSorter(localRoots, hash).GetSortedRoots()[0], Not(Equals), ks1[0].url)
r, n, url2, err := kc.Get(hash)
<-fh.handled
c.Check(err, Equals, nil)
c.Check(n, Equals, int64(3))
c.Check(url2, Equals, fmt.Sprintf("%s/%s", ks1[0].url, hash))
read_content, err2 := ioutil.ReadAll(r)
c.Check(err2, Equals, nil)
c.Check(read_content, DeepEquals, content)
}
func ExampleRefreshServices() {
arv, err := arvadosclient.MakeArvadosClient()
if err != nil {
panic(err)
}
kc, err := MakeKeepClient(&arv)
if err != nil {
panic(err)
}
go kc.RefreshServices(5*time.Minute, 3*time.Second)
fmt.Printf("LocalRoots: %#v\n", kc.LocalRoots())
}
func (s *ServerRequiredSuite) TestMakeKeepClient(c *C) {
arv, err := arvadosclient.MakeArvadosClient()
c.Assert(err, Equals, nil)
kc, err := MakeKeepClient(&arv)
c.Assert(err, Equals, nil)
c.Check(len(kc.LocalRoots()), Equals, 2)
for _, root := range kc.LocalRoots() {
c.Check(root, Matches, "http://localhost:\\d+")
}
}
func (s *StandaloneSuite) TestPutHR(c *C) {
log.Printf("TestPutHR")
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
st := StubPutHandler{
c,
hash,
"abc123",
"foo",
make(chan string, 5)}
arv, _ := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
kc.Want_replicas = 2
arv.ApiToken = "abc123"
localRoots := make(map[string]string)
writableLocalRoots := make(map[string]string)
ks := RunSomeFakeKeepServers(st, 5)
for i, k := range ks {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
defer k.listener.Close()
}
kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
reader, writer := io.Pipe()
go func() {
writer.Write([]byte("foo"))
writer.Close()
}()
kc.PutHR(hash, reader, 3)
shuff := NewRootSorter(kc.LocalRoots(), hash).GetSortedRoots()
log.Print(shuff)
s1 := <-st.handled
s2 := <-st.handled
c.Check((s1 == shuff[0] && s2 == shuff[1]) ||
(s1 == shuff[1] && s2 == shuff[0]),
Equals,
true)
log.Printf("TestPutHR done")
}
// Use a service hint to fetch from a local disk service, overriding
// rendezvous probe order.
func (s *StandaloneSuite) TestGetWithLocalServiceHint(c *C) {
uuid := "zzzzz-bi6l4-zzzzzzzzzzzzzzz"
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
// This one shouldn't be used, although it appears first in
// rendezvous probe order:
ks0 := RunFakeKeepServer(StubGetHandler{
c,
"error if used",
"abc123",
http.StatusOK,
[]byte("foo")})
defer ks0.listener.Close()
// This one should be used:
ks := RunFakeKeepServer(StubGetHandler{
c,
hash + "+K@" + uuid,
"abc123",
http.StatusOK,
[]byte("foo")})
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(
map[string]string{
"zzzzz-bi6l4-yyyyyyyyyyyyyyy": ks0.url,
"zzzzz-bi6l4-xxxxxxxxxxxxxxx": ks0.url,
"zzzzz-bi6l4-wwwwwwwwwwwwwww": ks0.url,
uuid: ks.url},
nil,
map[string]string{
"zzzzz-bi6l4-yyyyyyyyyyyyyyy": ks0.url,
"zzzzz-bi6l4-xxxxxxxxxxxxxxx": ks0.url,
"zzzzz-bi6l4-wwwwwwwwwwwwwww": ks0.url,
uuid: ks.url},
)
r, n, uri, err := kc.Get(hash + "+K@" + uuid)
defer r.Close()
c.Check(err, Equals, nil)
c.Check(n, Equals, int64(3))
c.Check(uri, Equals, fmt.Sprintf("%s/%s", ks.url, hash+"+K@"+uuid))
content, err := ioutil.ReadAll(r)
c.Check(err, Equals, nil)
c.Check(content, DeepEquals, []byte("foo"))
}
func (s *ServerRequiredSuite) TestDefaultReplications(c *C) {
arv, err := arvadosclient.MakeArvadosClient()
c.Assert(err, Equals, nil)
kc, err := MakeKeepClient(&arv)
c.Assert(kc.Want_replicas, Equals, 2)
arv.DiscoveryDoc["defaultCollectionReplication"] = 3.0
kc, err = MakeKeepClient(&arv)
c.Assert(kc.Want_replicas, Equals, 3)
arv.DiscoveryDoc["defaultCollectionReplication"] = 1.0
kc, err = MakeKeepClient(&arv)
c.Assert(kc.Want_replicas, Equals, 1)
}
func SetupPullWorkerIntegrationTest(t *testing.T, testData PullWorkIntegrationTestData, wantData bool) PullRequest {
os.Setenv("ARVADOS_API_HOST_INSECURE", "true")
// start api and keep servers
arvadostest.StartAPI()
arvadostest.StartKeep(2, false)
// make arvadosclient
arv, err := arvadosclient.MakeArvadosClient()
if err != nil {
t.Error("Error creating arv")
}
// keep client
keepClient = &keepclient.KeepClient{
Arvados: &arv,
Want_replicas: 1,
Using_proxy: true,
Client: &http.Client{},
}
// discover keep services
var servers []string
if err := keepClient.DiscoverKeepServers(); err != nil {
t.Error("Error discovering keep services")
}
for _, host := range keepClient.LocalRoots() {
servers = append(servers, host)
}
// Put content if the test needs it
if wantData {
locator, _, err := keepClient.PutB([]byte(testData.Content))
if err != nil {
t.Errorf("Error putting test data in setup for %s %s %v", testData.Content, locator, err)
}
if locator == "" {
t.Errorf("No locator found after putting test data")
}
}
// Create pullRequest for the test
pullRequest := PullRequest{
Locator: testData.Locator,
Servers: servers,
}
return pullRequest
}
func (s *StandaloneSuite) TestPutWithTooManyFail(c *C) {
log.Printf("TestPutWithTooManyFail")
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
st := StubPutHandler{
c,
hash,
"abc123",
"foo",
make(chan string, 1)}
fh := FailHandler{
make(chan string, 4)}
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
kc.Want_replicas = 2
kc.Retries = 0
arv.ApiToken = "abc123"
localRoots := make(map[string]string)
writableLocalRoots := make(map[string]string)
ks1 := RunSomeFakeKeepServers(st, 1)
ks2 := RunSomeFakeKeepServers(fh, 4)
for i, k := range ks1 {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
defer k.listener.Close()
}
for i, k := range ks2 {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
writableLocalRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i+len(ks1))] = k.url
defer k.listener.Close()
}
kc.SetServiceRoots(localRoots, writableLocalRoots, nil)
_, replicas, err := kc.PutB([]byte("foo"))
c.Check(err, Equals, InsufficientReplicasError)
c.Check(replicas, Equals, 1)
c.Check(<-st.handled, Equals, ks1[0].url)
log.Printf("TestPutWithTooManyFail done")
}
func UploadToStubHelper(c *C, st http.Handler, f func(*KeepClient, string,
io.ReadCloser, io.WriteCloser, chan uploadStatus)) {
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, _ := arvadosclient.MakeArvadosClient()
arv.ApiToken = "abc123"
kc, _ := MakeKeepClient(&arv)
reader, writer := io.Pipe()
upload_status := make(chan uploadStatus)
f(kc, ks.url, reader, writer, upload_status)
}
func (s *StandaloneSuite) TestGetNetError(c *C) {
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": "http://localhost:62222"}, nil, nil)
r, n, url2, err := kc.Get(hash)
errNotFound, _ := err.(*ErrNotFound)
c.Check(errNotFound, NotNil)
c.Check(strings.Contains(errNotFound.Error(), "connection refused"), Equals, true)
c.Check(errNotFound.Temporary(), Equals, true)
c.Check(n, Equals, int64(0))
c.Check(url2, Equals, "")
c.Check(r, Equals, nil)
}
func (s *StandaloneSuite) TestGet404(c *C) {
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
st := Error404Handler{make(chan string, 1)}
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
r, n, url2, err := kc.Get(hash)
c.Check(err, Equals, BlockNotFound)
c.Check(n, Equals, int64(0))
c.Check(url2, Equals, "")
c.Check(r, Equals, nil)
}
func (s *CollectionReaderUnit) SetUpTest(c *check.C) {
var err error
s.arv, err = arvadosclient.MakeArvadosClient()
c.Assert(err, check.IsNil)
s.arv.ApiToken = arvadostest.ActiveToken
s.kc, err = MakeKeepClient(&s.arv)
c.Assert(err, check.IsNil)
s.handler = SuccessHandler{
disk: make(map[string][]byte),
lock: make(chan struct{}, 1),
ops: new(int),
}
localRoots := make(map[string]string)
for i, k := range RunSomeFakeKeepServers(s.handler, 4) {
localRoots[fmt.Sprintf("zzzzz-bi6l4-fakefakefake%03d", i)] = k.url
}
s.kc.SetServiceRoots(localRoots, localRoots, nil)
}
func (s *StandaloneSuite) TestGetIndexWithNoSuchServer(c *C) {
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
st := StubGetIndexHandler{
c,
"/index/" + hash[0:3],
"abc123",
http.StatusOK,
[]byte(hash)}
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
_, err = kc.GetIndex("y", hash[0:3])
c.Check(err, Equals, ErrNoSuchKeepServer)
}
func (s *StandaloneSuite) TestGetIndexWithNoSuchPrefix(c *C) {
st := StubGetIndexHandler{
c,
"/index/abcd",
"abc123",
http.StatusOK,
[]byte("\n")}
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
r, err := kc.GetIndex("x", "abcd")
c.Check(err, Equals, nil)
content, err2 := ioutil.ReadAll(r)
c.Check(err2, Equals, nil)
c.Check(content, DeepEquals, st.body[0:len(st.body)-1])
}
func (s *StandaloneSuite) TestGetFail(c *C) {
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
st := FailHandler{make(chan string, 1)}
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": ks.url}, nil, nil)
kc.Retries = 0
r, n, url2, err := kc.Get(hash)
errNotFound, _ := err.(*ErrNotFound)
c.Check(errNotFound, NotNil)
c.Check(strings.Contains(errNotFound.Error(), "HTTP 500"), Equals, true)
c.Check(errNotFound.Temporary(), Equals, true)
c.Check(n, Equals, int64(0))
c.Check(url2, Equals, "")
c.Check(r, Equals, nil)
}
func (s *ServerRequiredSuite) TestPutGetHead(c *C) {
content := []byte("TestPutGetHead")
arv, err := arvadosclient.MakeArvadosClient()
kc, err := MakeKeepClient(&arv)
c.Assert(err, Equals, nil)
hash := fmt.Sprintf("%x", md5.Sum(content))
{
n, _, err := kc.Ask(hash)
c.Check(err, Equals, BlockNotFound)
c.Check(n, Equals, int64(0))
}
{
hash2, replicas, err := kc.PutB(content)
c.Check(hash2, Matches, fmt.Sprintf(`%s\+%d\b.*`, hash, len(content)))
c.Check(replicas, Equals, 2)
c.Check(err, Equals, nil)
}
{
r, n, url2, err := kc.Get(hash)
c.Check(err, Equals, nil)
c.Check(n, Equals, int64(len(content)))
c.Check(url2, Matches, fmt.Sprintf("http://localhost:\\d+/%s", hash))
read_content, err2 := ioutil.ReadAll(r)
c.Check(err2, Equals, nil)
c.Check(read_content, DeepEquals, content)
}
{
n, url2, err := kc.Ask(hash)
c.Check(err, Equals, nil)
c.Check(n, Equals, int64(len(content)))
c.Check(url2, Matches, fmt.Sprintf("http://localhost:\\d+/%s", hash))
}
}
func (s *StandaloneSuite) TestGetWithServiceHintFailoverToLocals(c *C) {
uuid := "zzzzz-bi6l4-123451234512345"
hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
ksLocal := RunFakeKeepServer(StubGetHandler{
c,
hash + "+K@" + uuid,
"abc123",
http.StatusOK,
[]byte("foo")})
defer ksLocal.listener.Close()
ksGateway := RunFakeKeepServer(StubGetHandler{
c,
hash + "+K@" + uuid,
"abc123",
http.StatusInternalServerError,
[]byte("Error")})
defer ksGateway.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(
map[string]string{"zzzzz-bi6l4-keepdisk0000000": ksLocal.url},
nil,
map[string]string{uuid: ksGateway.url})
r, n, uri, err := kc.Get(hash + "+K@" + uuid)
c.Assert(err, Equals, nil)
defer r.Close()
c.Check(n, Equals, int64(3))
c.Check(uri, Equals, fmt.Sprintf("%s/%s", ksLocal.url, hash+"+K@"+uuid))
content, err := ioutil.ReadAll(r)
c.Check(err, Equals, nil)
c.Check(content, DeepEquals, []byte("foo"))
}
