func (s *UnitFacadeSuite) TestGetResourceInfoOkay(c *gc.C) { opened1 := resourcetesting.NewResource(c, s.stub, "spam", "a-application", "some data") res1 := opened1.Resource opened2 := resourcetesting.NewResource(c, s.stub, "eggs", "a-application", "other data") res2 := opened2.Resource store := &stubUnitDataStore{Stub: s.stub} store.ReturnListResources = resource.ServiceResources{ Resources: []resource.Resource{res1, res2}, } uf := server.UnitFacade{DataStore: store} results, err := uf.GetResourceInfo(private.ListResourcesArgs{ ResourceNames: []string{"spam", "eggs"}, }) c.Assert(err, jc.ErrorIsNil) s.stub.CheckCallNames(c, "ListResources") c.Check(results, jc.DeepEquals, private.ResourcesResult{ Resources: []private.ResourceResult{{ Resource: api.Resource2API(res1), }, { Resource: api.Resource2API(res2), }}, }) }
// HandleRequest handles a resource upload request. func (uh UploadHandler) HandleRequest(req *http.Request) (*api.UploadResult, error) { defer req.Body.Close() uploaded, err := uh.ReadResource(req) if err != nil { return nil, errors.Trace(err) } var stored resource.Resource if uploaded.PendingID != "" { stored, err = uh.Store.UpdatePendingResource(uploaded.Service, uploaded.PendingID, uh.Username, uploaded.Resource, uploaded.Data) if err != nil { return nil, errors.Trace(err) } } else { stored, err = uh.Store.SetResource(uploaded.Service, uh.Username, uploaded.Resource, uploaded.Data) if err != nil { return nil, errors.Trace(err) } } result := &api.UploadResult{ Resource: api.Resource2API(stored), } return result, nil }
func (s *UploadSuite) TestHandleRequestPending(c *gc.C) { content := "<some data>" res, _ := newResource(c, "spam", "a-user", content) res.PendingID = "some-unique-id" stored, _ := newResource(c, "spam", "", "") stored.PendingID = "some-unique-id" s.data.ReturnGetPendingResource = stored s.data.ReturnUpdatePendingResource = res uh := server.UploadHandler{ Username: "******", Store: s.data, } req, body := newUploadRequest(c, "spam", "a-service", content) req.URL.RawQuery += "&pendingid=some-unique-id" result, err := uh.HandleRequest(req) c.Assert(err, jc.ErrorIsNil) s.stub.CheckCallNames(c, "GetPendingResource", "UpdatePendingResource") s.stub.CheckCall(c, 0, "GetPendingResource", "a-service", "spam", "some-unique-id") s.stub.CheckCall(c, 1, "UpdatePendingResource", "a-service", "some-unique-id", "a-user", res.Resource, ioutil.NopCloser(body)) c.Check(result, jc.DeepEquals, &api.UploadResult{ Resource: api.Resource2API(res), }) }
func (s *stubAPI) setResource(info resource.Resource, reader io.ReadCloser) { s.ReturnFacadeCall = private.ResourcesResult{ Resources: []private.ResourceResult{{ Resource: api.Resource2API(info), }}, } s.ReturnDo = &http.Response{ Body: reader, } }
// ListResources returns the list of resources for the given service. func (f Facade) ListResources(args api.ListResourcesArgs) (api.ResourcesResults, error) { var r api.ResourcesResults r.Results = make([]api.ResourcesResult, len(args.Entities)) for i, e := range args.Entities { logger.Tracef("Listing resources for %q", e.Tag) tag, apierr := parseServiceTag(e.Tag) if apierr != nil { r.Results[i] = api.ResourcesResult{ ErrorResult: params.ErrorResult{ Error: apierr, }, } continue } svcRes, err := f.store.ListResources(tag.Id()) if err != nil { r.Results[i] = errorResult(err) continue } var result api.ResourcesResult for _, res := range svcRes.Resources { result.Resources = append(result.Resources, api.Resource2API(res)) } for _, unitRes := range svcRes.UnitResources { unit := api.UnitResources{ Entity: params.Entity{Tag: unitRes.Tag.String()}, } for _, res := range unitRes.Resources { unit.Resources = append(unit.Resources, api.Resource2API(res)) } result.UnitResources = append(result.UnitResources, unit) } r.Results[i] = result } return r, nil }
func (helpersSuite) TestResource2API(c *gc.C) { fp, err := charmresource.NewFingerprint([]byte(fingerprint)) c.Assert(err, jc.ErrorIsNil) now := time.Now() res := resource.Resource{ Resource: charmresource.Resource{ Meta: charmresource.Meta{ Name: "spam", Type: charmresource.TypeFile, Path: "spam.tgz", Description: "you need it", }, Origin: charmresource.OriginUpload, Revision: 1, Fingerprint: fp, Size: 10, }, ID: "a-service/spam", PendingID: "some-unique-ID", ServiceID: "a-service", Username: "******", Timestamp: now, } err = res.Validate() c.Assert(err, jc.ErrorIsNil) apiRes := api.Resource2API(res) c.Check(apiRes, jc.DeepEquals, api.Resource{ CharmResource: api.CharmResource{ Name: "spam", Type: "file", Path: "spam.tgz", Description: "you need it", Origin: "upload", Revision: 1, Fingerprint: []byte(fingerprint), Size: 10, }, ID: "a-service/spam", PendingID: "some-unique-ID", ServiceID: "a-service", Username: "******", Timestamp: now, }) }
// GetResourceInfo returns the resource info for each of the given // resource names (for the implicit service). If any one is missing then // the corresponding result is set with errors.NotFound. func (uf UnitFacade) GetResourceInfo(args private.ListResourcesArgs) (private.ResourcesResult, error) { var r private.ResourcesResult r.Resources = make([]private.ResourceResult, len(args.ResourceNames)) resources, err := uf.DataStore.ListResources() if err != nil { r.Error = common.ServerError(err) return r, nil } for i, name := range args.ResourceNames { res, ok := lookUpResource(name, resources.Resources) if !ok { r.Resources[i].Error = common.ServerError(errors.NotFoundf("resource %q", name)) continue } r.Resources[i].Resource = api.Resource2API(res) } return r, nil }
func (s *UploadSuite) TestHandleRequestOkay(c *gc.C) { content := "<some data>" res, _ := newResource(c, "spam", "a-user", content) stored, _ := newResource(c, "spam", "", "") s.data.ReturnGetResource = stored s.data.ReturnSetResource = res uh := server.UploadHandler{ Username: "******", Store: s.data, } req, body := newUploadRequest(c, "spam", "a-service", content) result, err := uh.HandleRequest(req) c.Assert(err, jc.ErrorIsNil) s.stub.CheckCallNames(c, "GetResource", "SetResource") s.stub.CheckCall(c, 0, "GetResource", "a-service", "spam") s.stub.CheckCall(c, 1, "SetResource", "a-service", "a-user", res.Resource, ioutil.NopCloser(body)) c.Check(result, jc.DeepEquals, &api.UploadResult{ Resource: api.Resource2API(res), }) }
func (HelpersSuite) TestServiceResources2API(c *gc.C) { res1 := resourcetesting.NewResource(c, nil, "res1", "a-service", "data").Resource res2 := resourcetesting.NewResource(c, nil, "res2", "a-service", "data2").Resource tag0 := names.NewUnitTag("a-service/0") tag1 := names.NewUnitTag("a-service/1") chres1 := res1.Resource chres2 := res2.Resource chres1.Revision++ chres2.Revision++ svcRes := resource.ServiceResources{ Resources: []resource.Resource{ res1, res2, }, UnitResources: []resource.UnitResources{ { Tag: tag0, Resources: []resource.Resource{ res1, res2, }, DownloadProgress: map[string]int64{ res2.Name: 2, }, }, { Tag: tag1, }, }, CharmStoreResources: []charmresource.Resource{ chres1, chres2, }, } result := api.ServiceResources2APIResult(svcRes) apiRes1 := api.Resource2API(res1) apiRes2 := api.Resource2API(res2) apiChRes1 := api.CharmResource2API(chres1) apiChRes2 := api.CharmResource2API(chres2) c.Check(result, jc.DeepEquals, api.ResourcesResult{ Resources: []api.Resource{ apiRes1, apiRes2, }, UnitResources: []api.UnitResources{ { Entity: params.Entity{ Tag: "unit-a-service-0", }, Resources: []api.Resource{ apiRes1, apiRes2, }, DownloadProgress: map[string]int64{ res2.Name: 2, }, }, { // we should have a listing for every unit, even if they // have no resources. Entity: params.Entity{ Tag: "unit-a-service-1", }, }, }, CharmStoreResources: []api.CharmResource{ apiChRes1, apiChRes2, }, }) }