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 MaxItemsPerResponse: 1000,
67 ParallelRemoteRequests: 4,
68 }, NodeProfile: &nodeProfile}
69 s.testServer = newServerFromIntegrationTestEnv(c)
70 s.testServer.Server.Handler = httpserver.AddRequestIDs(httpserver.LogRequests(s.log, s.testHandler))
72 s.testHandler.Cluster.RemoteClusters = map[string]arvados.RemoteCluster{
74 Host: s.remoteServer.Addr,
79 Host: s.remoteMock.Addr,
85 c.Assert(s.testServer.Start(), check.IsNil)
87 s.remoteMockRequests = nil
90 func (s *FederationSuite) remoteMockHandler(w http.ResponseWriter, req *http.Request) {
91 s.remoteMockRequests = append(s.remoteMockRequests, *req)
94 func (s *FederationSuite) TearDownTest(c *check.C) {
95 if s.remoteServer != nil {
96 s.remoteServer.Close()
98 if s.testServer != nil {
103 func (s *FederationSuite) testRequest(req *http.Request) *http.Response {
104 resp := httptest.NewRecorder()
105 s.testServer.Server.Handler.ServeHTTP(resp, req)
109 func (s *FederationSuite) TestLocalRequest(c *check.C) {
110 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zhome-", 1), nil)
111 resp := s.testRequest(req)
112 s.checkHandledLocally(c, resp)
115 func (s *FederationSuite) checkHandledLocally(c *check.C, resp *http.Response) {
116 // Our "home" controller can't handle local requests because
117 // it doesn't have its own stub/test Rails API, so we rely on
118 // "connection refused" to indicate the controller tried to
119 // proxy the request to its local Rails API.
120 c.Check(resp.StatusCode, check.Equals, http.StatusBadGateway)
121 s.checkJSONErrorMatches(c, resp, `.*connection refused`)
124 func (s *FederationSuite) TestNoAuth(c *check.C) {
125 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
126 resp := s.testRequest(req)
127 c.Check(resp.StatusCode, check.Equals, http.StatusUnauthorized)
128 s.checkJSONErrorMatches(c, resp, `Not logged in`)
131 func (s *FederationSuite) TestBadAuth(c *check.C) {
132 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
133 req.Header.Set("Authorization", "Bearer aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
134 resp := s.testRequest(req)
135 c.Check(resp.StatusCode, check.Equals, http.StatusUnauthorized)
136 s.checkJSONErrorMatches(c, resp, `Not logged in`)
139 func (s *FederationSuite) TestNoAccess(c *check.C) {
140 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
141 req.Header.Set("Authorization", "Bearer "+arvadostest.SpectatorToken)
142 resp := s.testRequest(req)
143 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
144 s.checkJSONErrorMatches(c, resp, `.*not found`)
147 func (s *FederationSuite) TestGetUnknownRemote(c *check.C) {
148 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zz404-", 1), nil)
149 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
150 resp := s.testRequest(req)
151 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
152 s.checkJSONErrorMatches(c, resp, `.*no proxy available for cluster zz404`)
155 func (s *FederationSuite) TestRemoteError(c *check.C) {
156 rc := s.testHandler.Cluster.RemoteClusters["zzzzz"]
158 s.testHandler.Cluster.RemoteClusters["zzzzz"] = rc
160 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
161 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
162 resp := s.testRequest(req)
163 c.Check(resp.StatusCode, check.Equals, http.StatusBadGateway)
164 s.checkJSONErrorMatches(c, resp, `.*HTTP response to HTTPS client`)
167 func (s *FederationSuite) TestGetRemoteWorkflow(c *check.C) {
168 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
169 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
170 resp := s.testRequest(req)
171 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
172 var wf arvados.Workflow
173 c.Check(json.NewDecoder(resp.Body).Decode(&wf), check.IsNil)
174 c.Check(wf.UUID, check.Equals, arvadostest.WorkflowWithDefinitionYAMLUUID)
175 c.Check(wf.OwnerUUID, check.Equals, arvadostest.ActiveUserUUID)
178 func (s *FederationSuite) TestOptionsMethod(c *check.C) {
179 req := httptest.NewRequest("OPTIONS", "/arvados/v1/workflows/"+arvadostest.WorkflowWithDefinitionYAMLUUID, nil)
180 req.Header.Set("Origin", "https://example.com")
181 resp := s.testRequest(req)
182 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
183 body, err := ioutil.ReadAll(resp.Body)
184 c.Check(err, check.IsNil)
185 c.Check(string(body), check.Equals, "")
186 c.Check(resp.Header.Get("Access-Control-Allow-Origin"), check.Equals, "*")
187 for _, hdr := range []string{"Authorization", "Content-Type"} {
188 c.Check(resp.Header.Get("Access-Control-Allow-Headers"), check.Matches, ".*"+hdr+".*")
190 for _, method := range []string{"GET", "HEAD", "PUT", "POST", "DELETE"} {
191 c.Check(resp.Header.Get("Access-Control-Allow-Methods"), check.Matches, ".*"+method+".*")
195 func (s *FederationSuite) TestRemoteWithTokenInQuery(c *check.C) {
196 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zmock-", 1)+"?api_token="+arvadostest.ActiveToken, nil)
198 c.Assert(s.remoteMockRequests, check.HasLen, 1)
199 pr := s.remoteMockRequests[0]
200 // Token is salted and moved from query to Authorization header.
201 c.Check(pr.URL.String(), check.Not(check.Matches), `.*api_token=.*`)
202 c.Check(pr.Header.Get("Authorization"), check.Equals, "Bearer v2/zzzzz-gj3su-077z32aux8dg2s1/7fd31b61f39c0e82a4155592163218272cedacdc")
205 func (s *FederationSuite) TestLocalTokenSalted(c *check.C) {
206 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zmock-", 1), nil)
207 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
209 c.Assert(s.remoteMockRequests, check.HasLen, 1)
210 pr := s.remoteMockRequests[0]
211 // The salted token here has a "zzzzz-" UUID instead of a
212 // "ztest-" UUID because ztest's local database has the
213 // "zzzzz-" test fixtures. The "secret" part is HMAC(sha1,
214 // arvadostest.ActiveToken, "zmock") = "7fd3...".
215 c.Check(pr.Header.Get("Authorization"), check.Equals, "Bearer v2/zzzzz-gj3su-077z32aux8dg2s1/7fd31b61f39c0e82a4155592163218272cedacdc")
218 func (s *FederationSuite) TestRemoteTokenNotSalted(c *check.C) {
219 // remoteToken can be any v1 token that doesn't appear in
221 remoteToken := "abcdef00000000000000000000000000000000000000000000"
222 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+strings.Replace(arvadostest.WorkflowWithDefinitionYAMLUUID, "zzzzz-", "zmock-", 1), nil)
223 req.Header.Set("Authorization", "Bearer "+remoteToken)
225 c.Assert(s.remoteMockRequests, check.HasLen, 1)
226 pr := s.remoteMockRequests[0]
227 c.Check(pr.Header.Get("Authorization"), check.Equals, "Bearer "+remoteToken)
230 func (s *FederationSuite) TestWorkflowCRUD(c *check.C) {
231 wf := arvados.Workflow{
232 Description: "TestCRUD",
235 body := &strings.Builder{}
236 json.NewEncoder(body).Encode(&wf)
237 req := httptest.NewRequest("POST", "/arvados/v1/workflows", strings.NewReader(url.Values{
238 "workflow": {body.String()},
240 req.Header.Set("Content-type", "application/x-www-form-urlencoded")
241 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
242 rec := httptest.NewRecorder()
243 s.remoteServer.Server.Handler.ServeHTTP(rec, req) // direct to remote -- can't proxy a create req because no uuid
245 s.checkResponseOK(c, resp)
246 json.NewDecoder(resp.Body).Decode(&wf)
249 req := httptest.NewRequest("DELETE", "/arvados/v1/workflows/"+wf.UUID, nil)
250 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
251 s.remoteServer.Server.Handler.ServeHTTP(httptest.NewRecorder(), req)
253 c.Check(wf.UUID, check.Not(check.Equals), "")
255 c.Assert(wf.ModifiedAt, check.NotNil)
256 c.Logf("wf.ModifiedAt: %v", wf.ModifiedAt)
257 c.Check(time.Since(*wf.ModifiedAt) < time.Minute, check.Equals, true)
259 for _, method := range []string{"PATCH", "PUT", "POST"} {
261 "workflow": {`{"description": "Updated with ` + method + `"}`},
263 if method == "POST" {
264 form["_method"] = []string{"PATCH"}
266 req := httptest.NewRequest(method, "/arvados/v1/workflows/"+wf.UUID, strings.NewReader(form.Encode()))
267 req.Header.Set("Content-type", "application/x-www-form-urlencoded")
268 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
269 resp := s.testRequest(req)
270 s.checkResponseOK(c, resp)
271 err := json.NewDecoder(resp.Body).Decode(&wf)
272 c.Check(err, check.IsNil)
274 c.Check(wf.Description, check.Equals, "Updated with "+method)
277 req := httptest.NewRequest("DELETE", "/arvados/v1/workflows/"+wf.UUID, nil)
278 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
279 resp := s.testRequest(req)
280 s.checkResponseOK(c, resp)
281 err := json.NewDecoder(resp.Body).Decode(&wf)
282 c.Check(err, check.IsNil)
285 req := httptest.NewRequest("GET", "/arvados/v1/workflows/"+wf.UUID, nil)
286 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
287 resp := s.testRequest(req)
288 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
292 func (s *FederationSuite) checkResponseOK(c *check.C, resp *http.Response) {
293 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
294 if resp.StatusCode != http.StatusOK {
295 body, err := ioutil.ReadAll(resp.Body)
296 c.Logf("... response body = %q, %v\n", body, err)
300 func (s *FederationSuite) checkJSONErrorMatches(c *check.C, resp *http.Response, re string) {
301 var jresp httpserver.ErrorResponse
302 err := json.NewDecoder(resp.Body).Decode(&jresp)
303 c.Check(err, check.IsNil)
304 c.Assert(jresp.Errors, check.HasLen, 1)
305 c.Check(jresp.Errors[0], check.Matches, re)
308 func (s *FederationSuite) localServiceHandler(c *check.C, h http.Handler) *httpserver.Server {
309 srv := &httpserver.Server{
315 c.Assert(srv.Start(), check.IsNil)
317 np := arvados.NodeProfile{
318 Controller: arvados.SystemServiceInstance{Listen: ":"},
319 RailsAPI: arvados.SystemServiceInstance{Listen: srv.Addr,
320 TLS: false, Insecure: true}}
321 s.testHandler.Cluster.NodeProfiles["*"] = np
322 s.testHandler.NodeProfile = &np
327 func (s *FederationSuite) localServiceReturns404(c *check.C) *httpserver.Server {
328 return s.localServiceHandler(c, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
333 func (s *FederationSuite) TestGetLocalCollection(c *check.C) {
334 np := arvados.NodeProfile{
335 Controller: arvados.SystemServiceInstance{Listen: ":"},
336 RailsAPI: arvados.SystemServiceInstance{Listen: os.Getenv("ARVADOS_TEST_API_HOST"),
337 TLS: true, Insecure: true}}
338 s.testHandler.Cluster.ClusterID = "zzzzz"
339 s.testHandler.Cluster.NodeProfiles["*"] = np
340 s.testHandler.NodeProfile = &np
342 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementCollection, nil)
343 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
344 resp := s.testRequest(req)
346 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
347 var col arvados.Collection
348 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
349 c.Check(col.UUID, check.Equals, arvadostest.UserAgreementCollection)
350 c.Check(col.ManifestText, check.Matches,
351 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+A[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
355 func (s *FederationSuite) TestGetRemoteCollection(c *check.C) {
356 defer s.localServiceReturns404(c).Close()
358 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementCollection, nil)
359 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
360 resp := s.testRequest(req)
361 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
362 var col arvados.Collection
363 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
364 c.Check(col.UUID, check.Equals, arvadostest.UserAgreementCollection)
365 c.Check(col.ManifestText, check.Matches,
366 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+Rzzzzz-[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
370 func (s *FederationSuite) TestGetRemoteCollectionError(c *check.C) {
371 defer s.localServiceReturns404(c).Close()
373 req := httptest.NewRequest("GET", "/arvados/v1/collections/zzzzz-4zz18-fakefakefakefak", nil)
374 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
375 resp := s.testRequest(req)
376 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
379 func (s *FederationSuite) TestSignedLocatorPattern(c *check.C) {
380 // Confirm the regular expression identifies other groups of hints correctly
381 c.Check(keepclient.SignedLocatorRe.FindStringSubmatch(`6a4ff0499484c6c79c95cd8c566bd25f+249025+B1+C2+A05227438989d04712ea9ca1c91b556cef01d5cc7@5ba5405b+D3+E4`),
383 []string{"6a4ff0499484c6c79c95cd8c566bd25f+249025+B1+C2+A05227438989d04712ea9ca1c91b556cef01d5cc7@5ba5405b+D3+E4",
384 "6a4ff0499484c6c79c95cd8c566bd25f",
387 "+A05227438989d04712ea9ca1c91b556cef01d5cc7@5ba5405b",
388 "05227438989d04712ea9ca1c91b556cef01d5cc7", "5ba5405b",
392 func (s *FederationSuite) TestGetLocalCollectionByPDH(c *check.C) {
393 np := arvados.NodeProfile{
394 Controller: arvados.SystemServiceInstance{Listen: ":"},
395 RailsAPI: arvados.SystemServiceInstance{Listen: os.Getenv("ARVADOS_TEST_API_HOST"),
396 TLS: true, Insecure: true}}
397 s.testHandler.Cluster.NodeProfiles["*"] = np
398 s.testHandler.NodeProfile = &np
400 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementPDH, nil)
401 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
402 resp := s.testRequest(req)
404 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
405 var col arvados.Collection
406 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
407 c.Check(col.PortableDataHash, check.Equals, arvadostest.UserAgreementPDH)
408 c.Check(col.ManifestText, check.Matches,
409 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+A[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
413 func (s *FederationSuite) TestGetRemoteCollectionByPDH(c *check.C) {
414 defer s.localServiceReturns404(c).Close()
416 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementPDH, nil)
417 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
418 resp := s.testRequest(req)
420 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
422 var col arvados.Collection
423 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
424 c.Check(col.PortableDataHash, check.Equals, arvadostest.UserAgreementPDH)
425 c.Check(col.ManifestText, check.Matches,
426 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+Rzzzzz-[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
430 func (s *FederationSuite) TestGetCollectionByPDHError(c *check.C) {
431 defer s.localServiceReturns404(c).Close()
433 req := httptest.NewRequest("GET", "/arvados/v1/collections/99999999999999999999999999999999+99", nil)
434 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
436 resp := s.testRequest(req)
437 defer resp.Body.Close()
439 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
442 func (s *FederationSuite) TestGetCollectionByPDHErrorBadHash(c *check.C) {
443 defer s.localServiceReturns404(c).Close()
445 srv2 := &httpserver.Server{
447 Handler: http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
449 // Return a collection where the hash
450 // of the manifest text doesn't match
451 // PDH that was requested.
452 var col arvados.Collection
453 col.PortableDataHash = "99999999999999999999999999999999+99"
454 col.ManifestText = `. 6a4ff0499484c6c79c95cd8c566bd25f\+249025 0:249025:GNU_General_Public_License,_version_3.pdf
456 enc := json.NewEncoder(w)
462 c.Assert(srv2.Start(), check.IsNil)
465 // Direct zzzzz to service that returns a 200 result with a bogus manifest_text
466 s.testHandler.Cluster.RemoteClusters["zzzzz"] = arvados.RemoteCluster{
472 req := httptest.NewRequest("GET", "/arvados/v1/collections/99999999999999999999999999999999+99", nil)
473 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
475 resp := s.testRequest(req)
476 defer resp.Body.Close()
478 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
481 func (s *FederationSuite) TestSaltedTokenGetCollectionByPDH(c *check.C) {
482 np := arvados.NodeProfile{
483 Controller: arvados.SystemServiceInstance{Listen: ":"},
484 RailsAPI: arvados.SystemServiceInstance{Listen: os.Getenv("ARVADOS_TEST_API_HOST"),
485 TLS: true, Insecure: true}}
486 s.testHandler.Cluster.NodeProfiles["*"] = np
487 s.testHandler.NodeProfile = &np
489 req := httptest.NewRequest("GET", "/arvados/v1/collections/"+arvadostest.UserAgreementPDH, nil)
490 req.Header.Set("Authorization", "Bearer v2/zzzzz-gj3su-077z32aux8dg2s1/282d7d172b6cfdce364c5ed12ddf7417b2d00065")
491 resp := s.testRequest(req)
493 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
494 var col arvados.Collection
495 c.Check(json.NewDecoder(resp.Body).Decode(&col), check.IsNil)
496 c.Check(col.PortableDataHash, check.Equals, arvadostest.UserAgreementPDH)
497 c.Check(col.ManifestText, check.Matches,
498 `\. 6a4ff0499484c6c79c95cd8c566bd25f\+249025\+A[0-9a-f]{40}@[0-9a-f]{8} 0:249025:GNU_General_Public_License,_version_3.pdf
502 func (s *FederationSuite) TestSaltedTokenGetCollectionByPDHError(c *check.C) {
503 np := arvados.NodeProfile{
504 Controller: arvados.SystemServiceInstance{Listen: ":"},
505 RailsAPI: arvados.SystemServiceInstance{Listen: os.Getenv("ARVADOS_TEST_API_HOST"),
506 TLS: true, Insecure: true}}
507 s.testHandler.Cluster.NodeProfiles["*"] = np
508 s.testHandler.NodeProfile = &np
510 req := httptest.NewRequest("GET", "/arvados/v1/collections/99999999999999999999999999999999+99", nil)
511 req.Header.Set("Authorization", "Bearer v2/zzzzz-gj3su-077z32aux8dg2s1/282d7d172b6cfdce364c5ed12ddf7417b2d00065")
512 resp := s.testRequest(req)
514 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
517 func (s *FederationSuite) TestGetRemoteContainerRequest(c *check.C) {
518 defer s.localServiceReturns404(c).Close()
519 req := httptest.NewRequest("GET", "/arvados/v1/container_requests/"+arvadostest.QueuedContainerRequestUUID, nil)
520 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
521 resp := s.testRequest(req)
522 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
523 var cr arvados.ContainerRequest
524 c.Check(json.NewDecoder(resp.Body).Decode(&cr), check.IsNil)
525 c.Check(cr.UUID, check.Equals, arvadostest.QueuedContainerRequestUUID)
526 c.Check(cr.Priority, check.Equals, 1)
529 func (s *FederationSuite) TestUpdateRemoteContainerRequest(c *check.C) {
530 defer s.localServiceReturns404(c).Close()
531 req := httptest.NewRequest("PATCH", "/arvados/v1/container_requests/"+arvadostest.QueuedContainerRequestUUID,
532 strings.NewReader(`{"container_request": {"priority": 696}}`))
533 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
534 req.Header.Set("Content-type", "application/json")
535 resp := s.testRequest(req)
536 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
537 var cr arvados.ContainerRequest
538 c.Check(json.NewDecoder(resp.Body).Decode(&cr), check.IsNil)
539 c.Check(cr.UUID, check.Equals, arvadostest.QueuedContainerRequestUUID)
540 c.Check(cr.Priority, check.Equals, 696)
543 func (s *FederationSuite) TestCreateRemoteContainerRequest(c *check.C) {
544 defer s.localServiceReturns404(c).Close()
545 // pass cluster_id via query parameter, this allows arvados-controller
546 // to avoid parsing the body
547 req := httptest.NewRequest("POST", "/arvados/v1/container_requests?cluster_id=zzzzz",
549 "container_request": {
550 "name": "hello world",
551 "state": "Uncommitted",
553 "container_image": "123",
558 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
559 req.Header.Set("Content-type", "application/json")
560 resp := s.testRequest(req)
561 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
562 var cr arvados.ContainerRequest
563 c.Check(json.NewDecoder(resp.Body).Decode(&cr), check.IsNil)
564 c.Check(cr.Name, check.Equals, "hello world")
565 c.Check(strings.HasPrefix(cr.UUID, "zzzzz-"), check.Equals, true)
568 func (s *FederationSuite) TestCreateRemoteContainerRequestError(c *check.C) {
569 defer s.localServiceReturns404(c).Close()
570 // pass cluster_id via query parameter, this allows arvados-controller
571 // to avoid parsing the body
572 req := httptest.NewRequest("POST", "/arvados/v1/container_requests?cluster_id=zz404",
574 "container_request": {
575 "name": "hello world",
576 "state": "Uncommitted",
578 "container_image": "123",
583 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
584 req.Header.Set("Content-type", "application/json")
585 resp := s.testRequest(req)
586 c.Check(resp.StatusCode, check.Equals, http.StatusNotFound)
589 func (s *FederationSuite) TestGetRemoteContainer(c *check.C) {
590 defer s.localServiceReturns404(c).Close()
591 req := httptest.NewRequest("GET", "/arvados/v1/containers/"+arvadostest.QueuedContainerUUID, nil)
592 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
593 resp := s.testRequest(req)
594 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
595 var cn arvados.Container
596 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
597 c.Check(cn.UUID, check.Equals, arvadostest.QueuedContainerUUID)
600 func (s *FederationSuite) TestListRemoteContainer(c *check.C) {
601 defer s.localServiceReturns404(c).Close()
602 req := httptest.NewRequest("GET", "/arvados/v1/containers?count=none&filters="+
603 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v"]]]`, arvadostest.QueuedContainerUUID)), nil)
604 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
605 resp := s.testRequest(req)
606 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
607 var cn arvados.ContainerList
608 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
609 c.Check(cn.Items[0].UUID, check.Equals, arvadostest.QueuedContainerUUID)
612 func (s *FederationSuite) TestListMultiRemoteContainers(c *check.C) {
613 defer s.localServiceHandler(c, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
614 bd, _ := ioutil.ReadAll(req.Body)
615 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`)
617 w.Write([]byte(`{"kind": "arvados#containerList", "items": [{"uuid": "zhome-xvhdp-cr5queuedcontnr", "command": ["abc"]}]}`))
619 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&select=%s",
620 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
621 arvadostest.QueuedContainerUUID)),
622 url.QueryEscape(`["uuid", "command"]`)),
624 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
625 resp := s.testRequest(req)
626 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
627 var cn arvados.ContainerList
628 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
629 c.Check(cn.Items, check.HasLen, 2)
630 mp := make(map[string]arvados.Container)
631 for _, cr := range cn.Items {
634 c.Check(mp[arvadostest.QueuedContainerUUID].Command, check.DeepEquals, []string{"echo", "hello"})
635 c.Check(mp[arvadostest.QueuedContainerUUID].ContainerImage, check.Equals, "")
636 c.Check(mp["zhome-xvhdp-cr5queuedcontnr"].Command, check.DeepEquals, []string{"abc"})
637 c.Check(mp["zhome-xvhdp-cr5queuedcontnr"].ContainerImage, check.Equals, "")
640 func (s *FederationSuite) TestListMultiRemoteContainersPaged(c *check.C) {
643 defer s.localServiceHandler(c, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
644 bd, _ := ioutil.ReadAll(req.Body)
646 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`)
648 w.Write([]byte(`{"kind": "arvados#containerList", "items": [{"uuid": "zhome-xvhdp-cr5queuedcontnr", "command": ["abc"]}]}`))
649 } else if callCount == 1 {
650 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`)
652 w.Write([]byte(`{"kind": "arvados#containerList", "items": [{"uuid": "zhome-xvhdp-cr6queuedcontnr", "command": ["efg"]}]}`))
656 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s",
657 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr", "zhome-xvhdp-cr6queuedcontnr"]]]`,
658 arvadostest.QueuedContainerUUID))),
660 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
661 resp := s.testRequest(req)
662 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
663 c.Check(callCount, check.Equals, 2)
664 var cn arvados.ContainerList
665 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
666 c.Check(cn.Items, check.HasLen, 3)
667 mp := make(map[string]arvados.Container)
668 for _, cr := range cn.Items {
671 c.Check(mp[arvadostest.QueuedContainerUUID].Command, check.DeepEquals, []string{"echo", "hello"})
672 c.Check(mp["zhome-xvhdp-cr5queuedcontnr"].Command, check.DeepEquals, []string{"abc"})
673 c.Check(mp["zhome-xvhdp-cr6queuedcontnr"].Command, check.DeepEquals, []string{"efg"})
676 func (s *FederationSuite) TestListMultiRemoteContainersMissing(c *check.C) {
679 defer s.localServiceHandler(c, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
680 bd, _ := ioutil.ReadAll(req.Body)
682 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`)
684 w.Write([]byte(`{"kind": "arvados#containerList", "items": [{"uuid": "zhome-xvhdp-cr6queuedcontnr", "command": ["efg"]}]}`))
685 } else if callCount == 1 {
686 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`)
688 w.Write([]byte(`{"kind": "arvados#containerList", "items": []}`))
692 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s",
693 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr", "zhome-xvhdp-cr6queuedcontnr"]]]`,
694 arvadostest.QueuedContainerUUID))),
696 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
697 resp := s.testRequest(req)
698 c.Check(resp.StatusCode, check.Equals, http.StatusOK)
699 c.Check(callCount, check.Equals, 2)
700 var cn arvados.ContainerList
701 c.Check(json.NewDecoder(resp.Body).Decode(&cn), check.IsNil)
702 c.Check(cn.Items, check.HasLen, 2)
703 mp := make(map[string]arvados.Container)
704 for _, cr := range cn.Items {
707 c.Check(mp[arvadostest.QueuedContainerUUID].Command, check.DeepEquals, []string{"echo", "hello"})
708 c.Check(mp["zhome-xvhdp-cr6queuedcontnr"].Command, check.DeepEquals, []string{"efg"})
711 func (s *FederationSuite) TestListMultiRemoteContainerPageSizeError(c *check.C) {
712 s.testHandler.Cluster.MaxItemsPerResponse = 1
713 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s",
714 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
715 arvadostest.QueuedContainerUUID))),
717 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
718 resp := s.testRequest(req)
719 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
720 s.checkJSONErrorMatches(c, resp, `Federated multi-object request for 2 objects which is more than max page size 1.`)
723 func (s *FederationSuite) TestListMultiRemoteContainerLimitError(c *check.C) {
724 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&limit=1",
725 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
726 arvadostest.QueuedContainerUUID))),
728 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
729 resp := s.testRequest(req)
730 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
731 s.checkJSONErrorMatches(c, resp, `Federated multi-object may not provide 'limit', 'offset' or 'order'.`)
734 func (s *FederationSuite) TestListMultiRemoteContainerOffsetError(c *check.C) {
735 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&offset=1",
736 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
737 arvadostest.QueuedContainerUUID))),
739 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
740 resp := s.testRequest(req)
741 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
742 s.checkJSONErrorMatches(c, resp, `Federated multi-object may not provide 'limit', 'offset' or 'order'.`)
745 func (s *FederationSuite) TestListMultiRemoteContainerOrderError(c *check.C) {
746 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&order=uuid",
747 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
748 arvadostest.QueuedContainerUUID))),
750 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
751 resp := s.testRequest(req)
752 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
753 s.checkJSONErrorMatches(c, resp, `Federated multi-object may not provide 'limit', 'offset' or 'order'.`)
756 func (s *FederationSuite) TestListMultiRemoteContainerSelectError(c *check.C) {
757 req := httptest.NewRequest("GET", fmt.Sprintf("/arvados/v1/containers?count=none&filters=%s&select=%s",
758 url.QueryEscape(fmt.Sprintf(`[["uuid", "in", ["%v", "zhome-xvhdp-cr5queuedcontnr"]]]`,
759 arvadostest.QueuedContainerUUID)),
760 url.QueryEscape(`["command"]`)),
762 req.Header.Set("Authorization", "Bearer "+arvadostest.ActiveToken)
763 resp := s.testRequest(req)
764 c.Check(resp.StatusCode, check.Equals, http.StatusBadRequest)
765 s.checkJSONErrorMatches(c, resp, `Federated multi-object request must include 'uuid' in 'select'`)