← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/resource/api/client/client.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/resource/api/client/client.go
9
9
        "strings"
10
10
 
11
11
        "github.com/juju/errors"
12
 
        "github.com/juju/loggo"
 
12
        "gopkg.in/juju/charm.v6-unstable"
13
13
        charmresource "gopkg.in/juju/charm.v6-unstable/resource"
 
14
        "gopkg.in/macaroon.v1"
14
15
 
15
 
        "github.com/juju/juju/apiserver/common"
16
16
        "github.com/juju/juju/resource"
17
17
        "github.com/juju/juju/resource/api"
18
18
)
19
19
 
20
 
var logger = loggo.GetLogger("juju.resource.api.client")
21
 
 
22
20
// TODO(ericsnow) Move FacadeCaller to a component-central package.
23
21
 
24
22
// FacadeCaller has the api/base.FacadeCaller methods needed for the component.
85
83
}
86
84
 
87
85
// Upload sends the provided resource blob up to Juju.
88
 
func (c Client) Upload(service, name string, reader io.ReadSeeker) error {
89
 
        uReq, err := api.NewUploadRequest(service, name, reader)
 
86
func (c Client) Upload(service, name, filename string, reader io.ReadSeeker) error {
 
87
        uReq, err := api.NewUploadRequest(service, name, filename, reader)
90
88
        if err != nil {
91
89
                return errors.Trace(err)
92
90
        }
103
101
        return nil
104
102
}
105
103
 
 
104
// AddPendingResourcesArgs holds the arguments to AddPendingResources().
 
105
type AddPendingResourcesArgs struct {
 
106
        // ServiceID identifies the service being deployed.
 
107
        ServiceID string
 
108
 
 
109
        // CharmURL identifies the service's charm.
 
110
        CharmURL *charm.URL
 
111
 
 
112
        // CharmStoreMacaroon is the macaroon to use for the charm when
 
113
        // interacting with the charm store.
 
114
        CharmStoreMacaroon *macaroon.Macaroon
 
115
 
 
116
        // Resources holds the charm store info for each of the resources
 
117
        // that should be added/updated on the controller.
 
118
        Resources []charmresource.Resource
 
119
}
 
120
 
106
121
// AddPendingResources sends the provided resource info up to Juju
107
122
// without making it available yet.
108
 
func (c Client) AddPendingResources(serviceID string, resources []charmresource.Resource) (pendingIDs []string, err error) {
109
 
        args, err := api.NewAddPendingResourcesArgs(serviceID, resources)
 
123
func (c Client) AddPendingResources(args AddPendingResourcesArgs) (pendingIDs []string, err error) {
 
124
        apiArgs, err := api.NewAddPendingResourcesArgs(args.ServiceID, args.CharmURL, args.CharmStoreMacaroon, args.Resources)
110
125
        if err != nil {
111
126
                return nil, errors.Trace(err)
112
127
        }
113
128
 
114
129
        var result api.AddPendingResourcesResult
115
 
        if err := c.FacadeCall("AddPendingResources", &args, &result); err != nil {
 
130
        if err := c.FacadeCall("AddPendingResources", &apiArgs, &result); err != nil {
116
131
                return nil, errors.Trace(err)
117
132
        }
118
133
        if result.Error != nil {
119
 
                err := common.RestoreError(result.Error)
 
134
                err := api.RestoreError(result.Error)
120
135
                return nil, errors.Trace(err)
121
136
        }
122
137
 
123
 
        if len(result.PendingIDs) != len(resources) {
124
 
                return nil, errors.Errorf("bad data from server: expected %d IDs, got %d", len(resources), len(result.PendingIDs))
 
138
        if len(result.PendingIDs) != len(args.Resources) {
 
139
                return nil, errors.Errorf("bad data from server: expected %d IDs, got %d", len(args.Resources), len(result.PendingIDs))
125
140
        }
126
141
        for i, id := range result.PendingIDs {
127
142
                if id == "" {
128
 
                        return nil, errors.Errorf("bad data from server: got an empty ID for resource %q", resources[i].Name)
 
143
                        return nil, errors.Errorf("bad data from server: got an empty ID for resource %q", args.Resources[i].Name)
129
144
                }
130
145
                // TODO(ericsnow) Do other validation?
131
146
        }
136
151
// AddPendingResource sends the provided resource blob up to Juju
137
152
// without making it available yet. For example, AddPendingResource()
138
153
// is used before the service is deployed.
139
 
func (c Client) AddPendingResource(serviceID string, res charmresource.Resource, reader io.ReadSeeker) (pendingID string, err error) {
140
 
        ids, err := c.AddPendingResources(serviceID, []charmresource.Resource{res})
 
154
func (c Client) AddPendingResource(serviceID string, res charmresource.Resource, filename string, reader io.ReadSeeker) (pendingID string, err error) {
 
155
        ids, err := c.AddPendingResources(AddPendingResourcesArgs{
 
156
                ServiceID: serviceID,
 
157
                CharmURL:  nil,
 
158
                Resources: []charmresource.Resource{res},
 
159
        })
141
160
        if err != nil {
142
161
                return "", errors.Trace(err)
143
162
        }
144
163
        pendingID = ids[0]
145
164
 
146
165
        if reader != nil {
147
 
                uReq, err := api.NewUploadRequest(serviceID, res.Name, reader)
 
166
                uReq, err := api.NewUploadRequest(serviceID, res.Name, filename, reader)
148
167
                if err != nil {
149
168
                        return "", errors.Trace(err)
150
169
                }