← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/api/modelmanager/modelmanager.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/api/modelmanager/modelmanager.go
11
11
        "github.com/juju/juju/api/base"
12
12
        "github.com/juju/juju/apiserver/params"
13
13
        "github.com/juju/juju/environs/config"
14
 
        "github.com/juju/juju/juju/permission"
 
14
        "github.com/juju/juju/instance"
 
15
        "github.com/juju/juju/permission"
15
16
)
16
17
 
17
18
var logger = loggo.GetLogger("juju.api.modelmanager")
41
42
        name, owner, cloud, cloudRegion string,
42
43
        cloudCredential names.CloudCredentialTag,
43
44
        config map[string]interface{},
44
 
) (params.ModelInfo, error) {
45
 
        var result params.ModelInfo
 
45
) (base.ModelInfo, error) {
 
46
        var result base.ModelInfo
46
47
        if !names.IsValidUser(owner) {
47
48
                return result, errors.Errorf("invalid owner name %q", owner)
48
49
        }
65
66
                CloudRegion:        cloudRegion,
66
67
                CloudCredentialTag: cloudCredentialTag,
67
68
        }
68
 
        err := c.facade.FacadeCall("CreateModel", createArgs, &result)
 
69
        var modelInfo params.ModelInfo
 
70
        err := c.facade.FacadeCall("CreateModel", createArgs, &modelInfo)
69
71
        if err != nil {
70
72
                return result, errors.Trace(err)
71
73
        }
 
74
        return convertParamsModelInfo(modelInfo)
 
75
}
 
76
 
 
77
func convertParamsModelInfo(modelInfo params.ModelInfo) (base.ModelInfo, error) {
 
78
        cloud, err := names.ParseCloudTag(modelInfo.CloudTag)
 
79
        if err != nil {
 
80
                return base.ModelInfo{}, err
 
81
        }
 
82
        var credential string
 
83
        if modelInfo.CloudCredentialTag != "" {
 
84
                credTag, err := names.ParseCloudCredentialTag(modelInfo.CloudCredentialTag)
 
85
                if err != nil {
 
86
                        return base.ModelInfo{}, err
 
87
                }
 
88
                credential = credTag.Id()
 
89
        }
 
90
        ownerTag, err := names.ParseUserTag(modelInfo.OwnerTag)
 
91
        if err != nil {
 
92
                return base.ModelInfo{}, err
 
93
        }
 
94
        result := base.ModelInfo{
 
95
                Name:            modelInfo.Name,
 
96
                UUID:            modelInfo.UUID,
 
97
                ControllerUUID:  modelInfo.ControllerUUID,
 
98
                ProviderType:    modelInfo.ProviderType,
 
99
                DefaultSeries:   modelInfo.DefaultSeries,
 
100
                Cloud:           cloud.Id(),
 
101
                CloudRegion:     modelInfo.CloudRegion,
 
102
                CloudCredential: credential,
 
103
                Owner:           ownerTag.Id(),
 
104
                Life:            string(modelInfo.Life),
 
105
        }
 
106
        result.Status = base.Status{
 
107
                Status: modelInfo.Status.Status,
 
108
                Info:   modelInfo.Status.Info,
 
109
                Data:   make(map[string]interface{}),
 
110
                Since:  modelInfo.Status.Since,
 
111
        }
 
112
        for k, v := range modelInfo.Status.Data {
 
113
                result.Status.Data[k] = v
 
114
        }
 
115
        result.Users = make([]base.UserInfo, len(modelInfo.Users))
 
116
        for i, u := range modelInfo.Users {
 
117
                result.Users[i] = base.UserInfo{
 
118
                        UserName:       u.UserName,
 
119
                        DisplayName:    u.DisplayName,
 
120
                        Access:         string(u.Access),
 
121
                        LastConnection: u.LastConnection,
 
122
                }
 
123
        }
 
124
        result.Machines = make([]base.Machine, len(modelInfo.Machines))
 
125
        for i, m := range modelInfo.Machines {
 
126
                machine := base.Machine{
 
127
                        Id:         m.Id,
 
128
                        InstanceId: m.InstanceId,
 
129
                        HasVote:    m.HasVote,
 
130
                        WantsVote:  m.WantsVote,
 
131
                        Status:     m.Status,
 
132
                }
 
133
                if m.Hardware != nil {
 
134
                        machine.Hardware = &instance.HardwareCharacteristics{
 
135
                                Arch:             m.Hardware.Arch,
 
136
                                Mem:              m.Hardware.Mem,
 
137
                                RootDisk:         m.Hardware.RootDisk,
 
138
                                CpuCores:         m.Hardware.Cores,
 
139
                                CpuPower:         m.Hardware.CpuPower,
 
140
                                Tags:             m.Hardware.Tags,
 
141
                                AvailabilityZone: m.Hardware.AvailabilityZone,
 
142
                        }
 
143
                }
 
144
                result.Machines[i] = machine
 
145
        }
72
146
        return result, nil
73
147
}
74
148
 
182
256
        return nil
183
257
}
184
258
 
185
 
// ParseModelAccess parses an access permission argument into
186
 
// a type suitable for making an API facade call.
187
 
func ParseModelAccess(access string) (params.UserAccessPermission, error) {
188
 
        var fail params.UserAccessPermission
189
 
 
190
 
        modelAccess, err := permission.ParseModelAccess(access)
191
 
        if err != nil {
192
 
                return fail, errors.Trace(err)
193
 
        }
194
 
        var accessPermission params.UserAccessPermission
195
 
        switch modelAccess {
196
 
        case permission.ModelReadAccess:
197
 
                accessPermission = params.ModelReadAccess
198
 
        case permission.ModelWriteAccess:
199
 
                accessPermission = params.ModelWriteAccess
200
 
        case permission.ModelAdminAccess:
201
 
                accessPermission = params.ModelAdminAccess
202
 
        default:
203
 
                return fail, errors.Errorf("unsupported model access permission %v", modelAccess)
204
 
        }
205
 
        return accessPermission, nil
206
 
}
207
 
 
208
259
// GrantModel grants a user access to the specified models.
209
260
func (c *Client) GrantModel(user, access string, modelUUIDs ...string) error {
210
261
        return c.modifyModelUser(params.GrantModelAccess, user, access, modelUUIDs)
223
274
        }
224
275
        userTag := names.NewUserTag(user)
225
276
 
226
 
        accessPermission, err := ParseModelAccess(access)
227
 
        if err != nil {
 
277
        modelAccess := permission.Access(access)
 
278
        if err := permission.ValidateModelAccess(modelAccess); err != nil {
228
279
                return errors.Trace(err)
229
280
        }
230
281
        for _, model := range modelUUIDs {
235
286
                args.Changes = append(args.Changes, params.ModifyModelAccess{
236
287
                        UserTag:  userTag.String(),
237
288
                        Action:   action,
238
 
                        Access:   accessPermission,
 
289
                        Access:   params.UserAccessPermission(modelAccess),
239
290
                        ModelTag: modelTag.String(),
240
291
                })
241
292
        }
242
293
 
243
294
        var result params.ErrorResults
244
 
        err = c.facade.FacadeCall("ModifyModelAccess", args, &result)
 
295
        err := c.facade.FacadeCall("ModifyModelAccess", args, &result)
245
296
        if err != nil {
246
297
                return errors.Trace(err)
247
298
        }