1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
18 "git.curoverse.com/arvados.git/sdk/go/arvados"
19 "git.curoverse.com/arvados.git/sdk/go/arvadostest"
20 "git.curoverse.com/arvados.git/sdk/go/httpserver"
21 "git.curoverse.com/arvados.git/sdk/go/keepclient"
22 "github.com/Sirupsen/logrus"
23 check "gopkg.in/check.v1"
26 // Gocheck boilerplate
27 var _ = check.Suite(&FederationSuite{})
29 type FederationSuite struct {
31 // testServer and testHandler are the controller being tested,
33 testServer *httpserver.Server
35 // remoteServer ("zzzzz") forwards requests to the Rails API
36 // provided by the integration test environment.
37 remoteServer *httpserver.Server
38 // remoteMock ("zmock") appends each incoming request to
39 // remoteMockRequests, and returns an empty 200 response.
40 remoteMock *httpserver.Server
41 remoteMockRequests []http.Request
44 func (s *FederationSuite) SetUpTest(c *check.C) {
46 s.log.Formatter = &logrus.JSONFormatter{}
47 s.log.Out = &logWriter{c.Log}
49 s.remoteServer = newServerFromIntegrationTestEnv(c)
50 c.Assert(s.remoteServer.Start(), check.IsNil)
52 s.remoteMock = newServerFromIntegrationTestEnv(c)
53 s.remoteMock.Server.Handler = http.HandlerFunc(s.remoteMockHandler)
54 c.Assert(s.remoteMock.Start(), check.IsNil)
56 nodeProfile := arvados.NodeProfile{
57 Controller: arvados.SystemServiceInstance{Listen: ":"},
58 RailsAPI: arvados.SystemServiceInstance{Listen: ":1"}, // local reqs will error "connection refused"
60 s.testHandler = &Handler{Cluster: &arvados.Cluster{
62 PostgreSQL: integrationTestCluster().PostgreSQL,
63 NodeProfiles: map[string]arvados.NodeProfile{
66 RequestLimits: arvados.RequestLimits{
67 MaxItemsPerResponse: 1000,
68 MultiClusterRequestConcurrency: 4,
70 }, NodeProfile: &nodeProfile}
71 s.testServer = newServerFromIntegrationTestEnv(c)
72 s.testServer.Server.Handler = httpserver.AddRequestIDs(httpserver.LogRequests(s.log, s.testHandler))
74 s.testHandler.Cluster.RemoteClusters = map[string]arvados.RemoteCluster{
76 Host: s.remoteServer.Addr,
81 Host: s.remoteMock.Addr,
87 c.Assert(s.testServer.Start(), check.IsNil)
89 s.remoteMockRequests = nil
92 func (s *FederationSuite) remoteMockHandler(w http.ResponseWriter, req *http.Request) {
93 s.remoteMockRequests = append(s.remoteMockRequests, *req)
96 func (s *FederationSuite) TearDownTest(c *check.C) {
97 if s.remoteServer != nil {
98 s.remoteServer.Close()
100 if s.testServer != nil {
105 func (s *FederationSuite) testRequest(req *http.Request) *http.Response {
106 resp := httptest.NewRecorder()
107 s.testServer.Server.Handler.ServeHTTP(resp, req)
111 func (s *FederationSuite) TestLocalRequest(c *check.C) {
112 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zhome-", 1), nil)
113 resp := s.testRequest(req)
114 s.checkHandledLocally(c, resp)
117 func (s *FederationSuite) checkHandledLocally(c *check.C, resp *http.Response) {
118 // Our "home" controller can't handle local requests because
119 // it doesn't have its own stub/test Rails API, so we rely on
120 // "connection refused" to indicate the controller tried to
121 // proxy the request to its local Rails API.
122 c.Check(resp.StatusCode, check.Equals, http.StatusBadGateway)
123 s.checkJSONErrorMatches(c, resp, `.*connection refused`)
126 func (s *FederationSuite) TestNoAuth(c *check.C) {
127 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
128 resp := s.testRequest(req)
129 c.Check(resp.StatusCode, check.Equals, http.StatusUnauthorized)
130 s.checkJSONErrorMatches(c, resp, `Not logged in`)
133 func (s *FederationSuite) TestBadAuth(c *check.C) {
134 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
135 req.Header.Set("Authorization", "Bearer aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
136 resp := s.testRequest(req)
137 c.Check(resp.StatusCode, check.Equals, http.StatusUnauthorized)
138 s.checkJSONErrorMatches(c, resp, `Not logged in`)
141 func (s *FederationSuite) TestNoAccess(c *check.C) {
142 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
143 req.Header.Set("Authorization", "Bearer "+arvadostest.SpectatorToken)
144 resp := s.testRequest(req)
145 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
146 s.checkJSONErrorMatches(c, resp, `.*not found`)
149 func (s *FederationSuite) TestGetUnknownRemote(c *check.C) {
150 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zz404-", 1), nil)
151 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
152 resp := s.testRequest(req)
153 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
154 s.checkJSONErrorMatches(c, resp, `.*no proxy available for cluster zz404`)
157 func (s *FederationSuite) TestRemoteError(c *check.C) {
158 rc := s.testHandler.Cluster.RemoteClusters["zzzzz"]
160 s.testHandler.Cluster.RemoteClusters["zzzzz"] = rc
162 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
163 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
164 resp := s.testRequest(req)
165 c.Check(resp.StatusCode, check.Equals, http.StatusBadGateway)
166 s.checkJSONErrorMatches(c, resp, `.*HTTP response to HTTPS client`)
169 func (s *FederationSuite) TestGetRemoteWorkflow(c *check.C) {
170 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
171 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
172 resp := s.testRequest(req)
173 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
174 var wf arvados.Workflow
175 c.Check(json.NewDecoder(resp.Body).Decode(&wf), check.IsNil)
176 c.Check(wf.UUID, check.Equals, arvadostest.WorkflowWithDefinitionYAMLUUID)
177 c.Check(wf.OwnerUUID, check.Equals, arvadostest.ActiveUserUUID)
180 func (s *FederationSuite) TestOptionsMethod(c *check.C) {
181 req := httptest.NewRequest("OPTIONS", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
182 req.Header.Set("Origin", "https://example.com")
183 resp := s.testRequest(req)
184 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
185 body, err := ioutil.ReadAll(resp.Body)
186 c.Check(err, check.IsNil)
187 c.Check(string(body), check.Equals, "")
188 c.Check(resp.Header.Get("Access-Control-Allow-Origin"), check.Equals, "*")
189 for _, hdr := range []string{"Authorization", "Content-Type"} {
190 c.Check(resp.Header.Get("Access-Control-Allow-Headers"), check.Matches, ".*"+hdr+".*")
192 for _, method := range []string{"GET", "HEAD", "PUT", "POST", "DELETE"} {
193 c.Check(resp.Header.Get("Access-Control-Allow-Methods"), check.Matches, ".*"+method+".*")
197 func (s *FederationSuite) TestRemoteWithTokenInQuery(c *check.C) {
198 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zmock-", 1)+"?api_token="+arvadostest.ActiveToken, nil)
200 c.Assert(s.remoteMockRequests, check.HasLen, 1)
201 pr := s.remoteMockRequests[0]
202 // Token is salted and moved from query to Authorization header.
203 c.Check(pr.URL.String(), check.Not(check.Matches), `.*api_token=.*`)
204 c.Check(pr.Header.Get("Authorization"), check.Equals, "Bearer v2/zzzzz-gj3su-077z32aux8dg2s1/7fd31b61f39c0e82a4155592163218272cedacdc")
207 func (s *FederationSuite) TestLocalTokenSalted(c *check.C) {
208 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zmock-", 1), nil)
209 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
211 c.Assert(s.remoteMockRequests, check.HasLen, 1)
212 pr := s.remoteMockRequests[0]
213 // The salted token here has a "zzzzz-" UUID instead of a
214 // "ztest-" UUID because ztest's local database has the
215 // "zzzzz-" test fixtures. The "secret" part is HMAC(sha1,
216 // arvadostest.ActiveToken, "zmock") = "7fd3...".
217 c.Check(pr.Header.Get("Authorization"), check.Equals, "Bearer v2/zzzzz-gj3su-077z32aux8dg2s1/7fd31b61f39c0e82a4155592163218272cedacdc")
220 func (s *FederationSuite) TestRemoteTokenNotSalted(c *check.C) {
221 // remoteToken can be any v1 token that doesn't appear in
223 remoteToken := "abcdef00000000000000000000000000000000000000000000"
224 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zmock-", 1), nil)
225 req.Header.Set("Authorization", "Bearer "+remoteToken)
227 c.Assert(s.remoteMockRequests, check.HasLen, 1)
228 pr := s.remoteMockRequests[0]
229 c.Check(pr.Header.Get("Authorization"), check.Equals, "Bearer "+remoteToken)
232 func (s *FederationSuite) TestWorkflowCRUD(c *check.C) {
233 wf := arvados.Workflow{
234 Description: "TestCRUD",
237 body := &strings.Builder{}
238 json.NewEncoder(body).Encode(&wf)
239 req := httptest.NewRequest("POST", "/arvados/v1/workflows", strings.NewReader(url.Values{
240 "workflow": {body.String()},
242 req.Header.Set("Content-type", "application/x-www-form-urlencoded")
243 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
244 rec := httptest.NewRecorder()
245 s.remoteServer.Server.Handler.ServeHTTP(rec, req) // direct to remote -- can't proxy a create req because no uuid
247 s.checkResponseOK(c, resp)
248 json.NewDecoder(resp.Body).Decode(&wf)
251 req := httptest.NewRequest("DELETE", "/arvados/v1/workflows/"+wf.UUID, nil)
252 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
253 s.remoteServer.Server.Handler.ServeHTTP(httptest.NewRecorder(), req)
255 c.Check(wf.UUID, check.Not(check.Equals), "")
257 c.Assert(wf.ModifiedAt, check.NotNil)
258 c.Logf("wf.ModifiedAt: %v", wf.ModifiedAt)
259 c.Check(time.Since(*wf.ModifiedAt) < time.Minute, check.Equals, true)
261 for _, method := range []string{"PATCH", "PUT", "POST"} {
263 "workflow": {`{"description": "Updated with ` + method + `"}`},
265 if method == "POST" {
266 form["_method"] = []string{"PATCH"}
268 req := httptest.NewRequest(method, "/arvados/v1/workflows/"+wf.UUID, strings.NewReader(form.Encode()))
269 req.Header.Set("Content-type", "application/x-www-form-urlencoded")
270 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
271 resp := s.testRequest(req)
272 s.checkResponseOK(c, resp)
273 err := json.NewDecoder(resp.Body).Decode(&wf)
274 c.Check(err, check.IsNil)
276 c.Check(wf.Description, check.Equals, "Updated with "+method)
279 req := httptest.NewRequest("DELETE", "/arvados/v1/workflows/"+wf.UUID, nil)
280 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
281 resp := s.testRequest(req)
282 s.checkResponseOK(c, resp)
283 err := json.NewDecoder(resp.Body).Decode(&wf)
284 c.Check(err, check.IsNil)
287 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+wf.UUID, nil)
288 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
289 resp := s.testRequest(req)
290 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
294 func (s *FederationSuite) checkResponseOK(c *check.C, resp *http.Response) {
295 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
296 if resp.StatusCode != http.StatusOK {
297 body, err := ioutil.ReadAll(resp.Body)
298 c.Logf("... response body = %q, %v\n", body, err)
302 func (s *FederationSuite) checkJSONErrorMatches(c *check.C, resp *http.Response, re string) {
303 var jresp httpserver.ErrorResponse
304 err := json.NewDecoder(resp.Body).Decode(&jresp)
305 c.Check(err, check.IsNil)
306 c.Assert(jresp.Errors, check.HasLen, 1)
307 c.Check(jresp.Errors[0], check.Matches, re)
310 func (s *FederationSuite) localServiceHandler(c *check.C, h http.Handler) *httpserver.Server {
311 srv := &httpserver.Server{
317 c.Assert(srv.Start(), check.IsNil)
319 np := arvados.NodeProfile{
320 Controller: arvados.SystemServiceInstance{Listen: ":"},
321 RailsAPI: arvados.SystemServiceInstance{Listen: srv.Addr,
322 TLS: false, Insecure: true}}
323 s.testHandler.Cluster.NodeProfiles["*"] = np
324 s.testHandler.NodeProfile = &np
329 func (s *FederationSuite) localServiceReturns404(c *check.C) *httpserver.Server {
330 return s.localServiceHandler(c, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
335 func (s *FederationSuite) TestGetLocalCollection(c *check.C) {
336 np := arvados.NodeProfile{
337 Controller: arvados.SystemServiceInstance{Listen: ":"},
338 RailsAPI: arvados.SystemServiceInstance{Listen: os.Getenv("ARVADOS_TEST_API_HOST"),
339 TLS: true, Insecure: true}}
340 s.testHandler.Cluster.ClusterID = "zzzzz"
341 s.testHandler.Cluster.NodeProfiles["*"] = np
342 s.testHandler.NodeProfile = &np
344 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementCollection, nil)
345 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
346 resp := s.testRequest(req)
348 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
349 var col arvados.Collection
350 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
351 c.Check(col.UUID, check.Equals, arvadostest.UserAgreementCollection)
352 c.Check(col.ManifestText, check.Matches,
353 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+A[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
357 func (s *FederationSuite) TestGetRemoteCollection(c *check.C) {
358 defer s.localServiceReturns404(c).Close()
360 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementCollection, nil)
361 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
362 resp := s.testRequest(req)
363 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
364 var col arvados.Collection
365 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
366 c.Check(col.UUID, check.Equals, arvadostest.UserAgreementCollection)
367 c.Check(col.ManifestText, check.Matches,
368 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+Rzzzzz-[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
372 func (s *FederationSuite) TestGetRemoteCollectionError(c *check.C) {
373 defer s.localServiceReturns404(c).Close()
375 req := httptest.NewRequest("GET", "/arvados/v1/collections/zzzzz-4zz18-fakefakefakefak", nil)
376 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
377 resp := s.testRequest(req)
378 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
381 func (s *FederationSuite) TestSignedLocatorPattern(c *check.C) {
382 // Confirm the regular expression identifies other groups of hints correctly
383 c.Check(keepclient.SignedLocatorRe.FindStringSubmatch(`6a4ff0499484c6c79c95cd8c566bd25f+249025+B1+C2+A05227438989d04712ea9ca1c91b556cef01d5cc7@5ba5405b+D3+E4`),
385 []string{"6a4ff0499484c6c79c95cd8c566bd25f+249025+B1+C2+A05227438989d04712ea9ca1c91b556cef01d5cc7@5ba5405b+D3+E4",
386 "6a4ff0499484c6c79c95cd8c566bd25f",
389 "+A05227438989d04712ea9ca1c91b556cef01d5cc7@5ba5405b",
390 "05227438989d04712ea9ca1c91b556cef01d5cc7", "5ba5405b",
394 func (s *FederationSuite) TestGetLocalCollectionByPDH(c *check.C) {
395 np := arvados.NodeProfile{
396 Controller: arvados.SystemServiceInstance{Listen: ":"},
397 RailsAPI: arvados.SystemServiceInstance{Listen: os.Getenv("ARVADOS_TEST_API_HOST"),
398 TLS: true, Insecure: true}}
399 s.testHandler.Cluster.NodeProfiles["*"] = np
400 s.testHandler.NodeProfile = &np
402 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementPDH, nil)
403 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
404 resp := s.testRequest(req)
406 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
407 var col arvados.Collection
408 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
409 c.Check(col.PortableDataHash, check.Equals, arvadostest.UserAgreementPDH)
410 c.Check(col.ManifestText, check.Matches,
411 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+A[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
415 func (s *FederationSuite) TestGetRemoteCollectionByPDH(c *check.C) {
416 defer s.localServiceReturns404(c).Close()
418 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementPDH, nil)
419 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
420 resp := s.testRequest(req)
422 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
424 var col arvados.Collection
425 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
426 c.Check(col.PortableDataHash, check.Equals, arvadostest.UserAgreementPDH)
427 c.Check(col.ManifestText, check.Matches,
428 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+Rzzzzz-[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
432 func (s *FederationSuite) TestGetCollectionByPDHError(c *check.C) {
433 defer s.localServiceReturns404(c).Close()
435 req := httptest.NewRequest("GET", "/arvados/v1/collections/99999999999999999999999999999999+99", nil)
436 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
438 resp := s.testRequest(req)
439 defer resp.Body.Close()
441 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
444 func (s *FederationSuite) TestGetCollectionByPDHErrorBadHash(c *check.C) {
445 defer s.localServiceReturns404(c).Close()
447 srv2 := &httpserver.Server{
449 Handler: http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
451 // Return a collection where the hash
452 // of the manifest text doesn't match
453 // PDH that was requested.
454 var col arvados.Collection
455 col.PortableDataHash = "99999999999999999999999999999999+99"
456 col.ManifestText = `. 6a4ff0499484c6c79c95cd8c566bd25f\+249025 0:249025:GNU_General_Public_License,_version_3.pdf
458 enc := json.NewEncoder(w)
464 c.Assert(srv2.Start(), check.IsNil)
467 // Direct zzzzz to service that returns a 200 result with a bogus manifest_text
468 s.testHandler.Cluster.RemoteClusters["zzzzz"] = arvados.RemoteCluster{
474 req := httptest.NewRequest("GET", "/arvados/v1/collections/99999999999999999999999999999999+99", nil)
475 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
477 resp := s.testRequest(req)
478 defer resp.Body.Close()
480 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
483 func (s *FederationSuite) TestSaltedTokenGetCollectionByPDH(c *check.C) {
484 np := arvados.NodeProfile{
485 Controller: arvados.SystemServiceInstance{Listen: ":"},
486 RailsAPI: arvados.SystemServiceInstance{Listen: os.Getenv("ARVADOS_TEST_API_HOST"),
487 TLS: true, Insecure: true}}
488 s.testHandler.Cluster.NodeProfiles["*"] = np
489 s.testHandler.NodeProfile = &np
491 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementPDH, nil)
492 req.Header.Set("Authorization", "Bearer v2/zzzzz-gj3su-077z32aux8dg2s1/282d7d172b6cfdce364c5ed12ddf7417b2d00065")
493 resp := s.testRequest(req)
495 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
496 var col arvados.Collection
497 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
498 c.Check(col.PortableDataHash, check.Equals, arvadostest.UserAgreementPDH)
499 c.Check(col.ManifestText, check.Matches,
500 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+A[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
504 func (s *FederationSuite) TestSaltedTokenGetCollectionByPDHError(c *check.C) {
505 np := arvados.NodeProfile{
506 Controller: arvados.SystemServiceInstance{Listen: ":"},
507 RailsAPI: arvados.SystemServiceInstance{Listen: os.Getenv("ARVADOS_TEST_API_HOST"),
508 TLS: true, Insecure: true}}
509 s.testHandler.Cluster.NodeProfiles["*"] = np
510 s.testHandler.NodeProfile = &np
512 req := httptest.NewRequest("GET", "/arvados/v1/collections/99999999999999999999999999999999+99", nil)
513 req.Header.Set("Authorization", "Bearer v2/zzzzz-gj3su-077z32aux8dg2s1/282d7d172b6cfdce364c5ed12ddf7417b2d00065")
514 resp := s.testRequest(req)
516 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
519 func (s *FederationSuite) TestGetRemoteContainerRequest(c *check.C) {
520 defer s.localServiceReturns404(c).Close()
521 req := httptest.NewRequest("GET", "/arvados/v1/container_requests/"+arvadostest.QueuedContainerRequestUUID, nil)
522 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
523 resp := s.testRequest(req)
524 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
525 var cr arvados.ContainerRequest
526 c.Check(json.NewDecoder(resp.Body).Decode(&cr), check.IsNil)
527 c.Check(cr.UUID, check.Equals, arvadostest.QueuedContainerRequestUUID)
528 c.Check(cr.Priority, check.Equals, 1)
531 func (s *FederationSuite) TestUpdateRemoteContainerRequest(c *check.C) {
532 defer s.localServiceReturns404(c).Close()
533 req := httptest.NewRequest("PATCH", "/arvados/v1/container_requests/"+arvadostest.QueuedContainerRequestUUID,
534 strings.NewReader(`{"container_request": {"priority": 696}}`))
535 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
536 req.Header.Set("Content-type", "application/json")
537 resp := s.testRequest(req)
538 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
539 var cr arvados.ContainerRequest
540 c.Check(json.NewDecoder(resp.Body).Decode(&cr), check.IsNil)
541 c.Check(cr.UUID, check.Equals, arvadostest.QueuedContainerRequestUUID)
542 c.Check(cr.Priority, check.Equals, 696)
545 func (s *FederationSuite) TestCreateRemoteContainerRequest(c *check.C) {
546 defer s.localServiceReturns404(c).Close()
547 // pass cluster_id via query parameter, this allows arvados-controller
548 // to avoid parsing the body
549 req := httptest.NewRequest("POST", "/arvados/v1/container_requests?cluster_id=zzzzz",
551 "container_request": {
552 "name": "hello world",
553 "state": "Uncommitted",
555 "container_image": "123",
560 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
561 req.Header.Set("Content-type", "application/json")
562 resp := s.testRequest(req)
563 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
564 var cr arvados.ContainerRequest
565 c.Check(json.NewDecoder(resp.Body).Decode(&cr), check.IsNil)
566 c.Check(cr.Name, check.Equals, "hello world")
567 c.Check(strings.HasPrefix(cr.UUID, "zzzzz-"), check.Equals, true)
570 func (s *FederationSuite) TestCreateRemoteContainerRequestError(c *check.C) {
571 defer s.localServiceReturns404(c).Close()
572 // pass cluster_id via query parameter, this allows arvados-controller
573 // to avoid parsing the body
574 req := httptest.NewRequest("POST", "/arvados/v1/container_requests?cluster_id=zz404",
576 "container_request": {
577 "name": "hello world",
578 "state": "Uncommitted",
580 "container_image": "123",
585 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
586 req.Header.Set("Content-type", "application/json")
587 resp := s.testRequest(req)
588 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
591 func (s *FederationSuite) TestGetRemoteContainer(c *check.C) {
592 defer s.localServiceReturns404(c).Close()
593 req := httptest.NewRequest("GET", "/arvados/v1/containers/"+arvadostest.QueuedContainerUUID, nil)
594 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
595 resp := s.testRequest(req)
596 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
597 var cn arvados.Container
598 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
599 c.Check(cn.UUID, check.Equals, arvadostest.QueuedContainerUUID)
602 func (s *FederationSuite) TestListRemoteContainer(c *check.C) {
603 defer s.localServiceReturns404(c).Close()
604 req := httptest.NewRequest("GET", "/arvados/v1/containers?count=none&filters="+
605 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v"]]]`, arvadostest.QueuedContainerUUID)), nil)
606 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
607 resp := s.testRequest(req)
608 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
609 var cn arvados.ContainerList
610 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
611 c.Check(cn.Items[0].UUID, check.Equals, arvadostest.QueuedContainerUUID)
614 func (s *FederationSuite) TestListMultiRemoteContainers(c *check.C) {
615 defer s.localServiceHandler(c, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
616 bd, _ := ioutil.ReadAll(req.Body)
617 c.Check(string(bd), check.Equals, `_method=GET&count=none&filters=%5B%5B%22uuid%22%2C+%22in%22%2C+%5B%22zhome-xvhdp-cr5queuedcontnr%22%5D%5D%5D&select=%5B%22uuid%22%2C+%22command%22%5D`)
619 w.Write([]byte(`{"kind": "arvados#containerList", "items": [{"uuid": "zhome-xvhdp-cr5queuedcontnr", "command": ["abc"]}]}`))
621 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&select=%s",
622 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
623 arvadostest.QueuedContainerUUID)),
624 url.QueryEscape(`["uuid", "command"]`)),
626 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
627 resp := s.testRequest(req)
628 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
629 var cn arvados.ContainerList
630 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
631 c.Check(cn.Items, check.HasLen, 2)
632 mp := make(map[string]arvados.Container)
633 for _, cr := range cn.Items {
636 c.Check(mp[arvadostest.QueuedContainerUUID].Command, check.DeepEquals, []string{"echo", "hello"})
637 c.Check(mp[arvadostest.QueuedContainerUUID].ContainerImage, check.Equals, "")
638 c.Check(mp["zhome-xvhdp-cr5queuedcontnr"].Command, check.DeepEquals, []string{"abc"})
639 c.Check(mp["zhome-xvhdp-cr5queuedcontnr"].ContainerImage, check.Equals, "")
642 func (s *FederationSuite) TestListMultiRemoteContainerError(c *check.C) {
643 defer s.localServiceReturns404(c).Close()
644 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&select=%s",
645 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
646 arvadostest.QueuedContainerUUID)),
647 url.QueryEscape(`["uuid", "command"]`)),
649 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
650 resp := s.testRequest(req)
651 c.Check(resp.StatusCode, check.Equals, http.StatusBadGateway)
652 s.checkJSONErrorMatches(c, resp, `error fetching from zhome \(404 Not Found\): EOF`)
655 func (s *FederationSuite) TestListMultiRemoteContainersPaged(c *check.C) {
658 defer s.localServiceHandler(c, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
659 bd, _ := ioutil.ReadAll(req.Body)
661 c.Check(string(bd), check.Equals, `_method=GET&count=none&filters=%5B%5B%22uuid%22%2C+%22in%22%2C+%5B%22zhome-xvhdp-cr5queuedcontnr%22%2C%22zhome-xvhdp-cr6queuedcontnr%22%5D%5D%5D`)
663 w.Write([]byte(`{"kind": "arvados#containerList", "items": [{"uuid": "zhome-xvhdp-cr5queuedcontnr", "command": ["abc"]}]}`))
664 } else if callCount == 1 {
665 c.Check(string(bd), check.Equals, `_method=GET&count=none&filters=%5B%5B%22uuid%22%2C+%22in%22%2C+%5B%22zhome-xvhdp-cr6queuedcontnr%22%5D%5D%5D`)
667 w.Write([]byte(`{"kind": "arvados#containerList", "items": [{"uuid": "zhome-xvhdp-cr6queuedcontnr", "command": ["efg"]}]}`))
671 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s",
672 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr", "zhome-xvhdp-cr6queuedcontnr"]]]`,
673 arvadostest.QueuedContainerUUID))),
675 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
676 resp := s.testRequest(req)
677 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
678 c.Check(callCount, check.Equals, 2)
679 var cn arvados.ContainerList
680 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
681 c.Check(cn.Items, check.HasLen, 3)
682 mp := make(map[string]arvados.Container)
683 for _, cr := range cn.Items {
686 c.Check(mp[arvadostest.QueuedContainerUUID].Command, check.DeepEquals, []string{"echo", "hello"})
687 c.Check(mp["zhome-xvhdp-cr5queuedcontnr"].Command, check.DeepEquals, []string{"abc"})
688 c.Check(mp["zhome-xvhdp-cr6queuedcontnr"].Command, check.DeepEquals, []string{"efg"})
691 func (s *FederationSuite) TestListMultiRemoteContainersMissing(c *check.C) {
694 defer s.localServiceHandler(c, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
695 bd, _ := ioutil.ReadAll(req.Body)
697 c.Check(string(bd), check.Equals, `_method=GET&count=none&filters=%5B%5B%22uuid%22%2C+%22in%22%2C+%5B%22zhome-xvhdp-cr5queuedcontnr%22%2C%22zhome-xvhdp-cr6queuedcontnr%22%5D%5D%5D`)
699 w.Write([]byte(`{"kind": "arvados#containerList", "items": [{"uuid": "zhome-xvhdp-cr6queuedcontnr", "command": ["efg"]}]}`))
700 } else if callCount == 1 {
701 c.Check(string(bd), check.Equals, `_method=GET&count=none&filters=%5B%5B%22uuid%22%2C+%22in%22%2C+%5B%22zhome-xvhdp-cr5queuedcontnr%22%5D%5D%5D`)
703 w.Write([]byte(`{"kind": "arvados#containerList", "items": []}`))
707 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s",
708 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr", "zhome-xvhdp-cr6queuedcontnr"]]]`,
709 arvadostest.QueuedContainerUUID))),
711 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
712 resp := s.testRequest(req)
713 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
714 c.Check(callCount, check.Equals, 2)
715 var cn arvados.ContainerList
716 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
717 c.Check(cn.Items, check.HasLen, 2)
718 mp := make(map[string]arvados.Container)
719 for _, cr := range cn.Items {
722 c.Check(mp[arvadostest.QueuedContainerUUID].Command, check.DeepEquals, []string{"echo", "hello"})
723 c.Check(mp["zhome-xvhdp-cr6queuedcontnr"].Command, check.DeepEquals, []string{"efg"})
726 func (s *FederationSuite) TestListMultiRemoteContainerPageSizeError(c *check.C) {
727 s.testHandler.Cluster.RequestLimits.MaxItemsPerResponse = 1
728 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s",
729 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
730 arvadostest.QueuedContainerUUID))),
732 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
733 resp := s.testRequest(req)
734 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
735 s.checkJSONErrorMatches(c, resp, `Federated multi-object request for 2 objects which is more than max page size 1.`)
738 func (s *FederationSuite) TestListMultiRemoteContainerLimitError(c *check.C) {
739 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&limit=1",
740 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
741 arvadostest.QueuedContainerUUID))),
743 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
744 resp := s.testRequest(req)
745 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
746 s.checkJSONErrorMatches(c, resp, `Federated multi-object may not provide 'limit', 'offset' or 'order'.`)
749 func (s *FederationSuite) TestListMultiRemoteContainerOffsetError(c *check.C) {
750 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&offset=1",
751 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
752 arvadostest.QueuedContainerUUID))),
754 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
755 resp := s.testRequest(req)
756 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
757 s.checkJSONErrorMatches(c, resp, `Federated multi-object may not provide 'limit', 'offset' or 'order'.`)
760 func (s *FederationSuite) TestListMultiRemoteContainerOrderError(c *check.C) {
761 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&order=uuid",
762 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
763 arvadostest.QueuedContainerUUID))),
765 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
766 resp := s.testRequest(req)
767 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
768 s.checkJSONErrorMatches(c, resp, `Federated multi-object may not provide 'limit', 'offset' or 'order'.`)
771 func (s *FederationSuite) TestListMultiRemoteContainerSelectError(c *check.C) {
772 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&select=%s",
773 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
774 arvadostest.QueuedContainerUUID)),
775 url.QueryEscape(`["command"]`)),
777 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
778 resp := s.testRequest(req)
779 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
780 s.checkJSONErrorMatches(c, resp, `Federated multi-object request must include 'uuid' in 'select'`)