← Back to branch summary

~rogpeppe/juju-core/504-errgo-cause

« back to all changes in this revision

Viewing changes to state/apiserver/provisioner/provisioner.go

  • Committer: Roger Peppe
  • Date: 2014-02-17 16:42:22 UTC
  • Revision ID: roger.peppe@canonical.com-20140217164222-mtkvplyqxfqiqp05
bzr diff -r 2313..2312 | patch -p0

Show diffs side-by-side

added added

removed removed

Lines of Context:
state/apiserver/provisioner/provisioner.go
96
96
        }
97
97
        entity, err := p.st.FindEntity(tag)
98
98
        if err != nil {
99
 
                return nil, mask(
 
99
                return nil, errors.Mask(
100
100
 
101
101
                        // The authorization function guarantees that the tag represents a
102
102
                        // machine.
110
110
        nothing := params.StringsWatchResult{}
111
111
        canAccess, err := p.getAuthFunc()
112
112
        if err != nil {
113
 
                return nothing, mask(err)
 
113
                return nothing, errors.Mask(err)
114
114
        }
115
115
        if !canAccess(arg.MachineTag) {
116
116
                return nothing, common.ErrPerm
117
117
        }
118
118
        _, id, err := names.ParseTag(arg.MachineTag, names.MachineTagKind)
119
119
        if err != nil {
120
 
                return nothing, mask(err)
 
120
                return nothing, errors.Mask(err)
121
121
        }
122
122
        machine, err := p.st.Machine(id)
123
123
        if err != nil {
124
 
                return nothing, mask(err)
 
124
                return nothing, errors.Mask(err)
125
125
        }
126
126
        var watch state.StringsWatcher
127
127
        if arg.ContainerType != "" {
169
169
        for i, arg := range args.Params {
170
170
                canAccess, err := p.getAuthFunc()
171
171
                if err != nil {
172
 
                        return result, mask(err)
 
172
                        return result, errors.Mask(err)
173
173
                }
174
174
                machine, err := p.getMachine(canAccess, arg.MachineTag)
175
175
                if err != nil {
194
194
        result := params.ContainerConfig{}
195
195
        config, err := p.st.EnvironConfig()
196
196
        if err != nil {
197
 
                return result, mask(err)
 
197
                return result, errors.Mask(err)
198
198
        }
199
199
        result.ProviderType = config.Type()
200
200
        result.AuthorizedKeys = config.AuthorizedKeys()
212
212
        }
213
213
        canAccess, err := p.getAuthFunc()
214
214
        if err != nil {
215
 
                return result, mask(err)
 
215
                return result, errors.Mask(err)
216
216
        }
217
217
        for i, entity := range args.Entities {
218
218
                machine, err := p.getMachine(canAccess, entity.Tag)
232
232
        }
233
233
        canAccess, err := p.getAuthFunc()
234
234
        if err != nil {
235
 
                return result, mask(err)
 
235
                return result, errors.Mask(err)
236
236
        }
237
237
        for i, entity := range args.Entities {
238
238
                machine, err := p.getMachine(canAccess, entity.Tag)
251
251
        }
252
252
        canAccess, err := p.getAuthFunc()
253
253
        if err != nil {
254
 
                return result, mask(err)
 
254
                return result, errors.Mask(err)
255
255
        }
256
256
        for i, entity := range args.Entities {
257
257
                machine, err := p.getMachine(canAccess, entity.Tag)
276
276
        }
277
277
        canAccess, err := p.getAuthFunc()
278
278
        if err != nil {
279
 
                return result, mask(err)
 
279
                return result, errors.Mask(err)
280
280
        }
281
281
        for i, arg := range args.Machines {
282
282
                machine, err := p.getMachine(canAccess, arg.Tag)