func (s *machineSuite) TestMachineHardwareInfo(c *gc.C) {
one := uint64(1)
amd64 := "amd64"
gig := uint64(1024)
st := mockState{
machines: map[string]*mockMachine{
"1": {id: "1", life: state.Alive, containerType: instance.NONE,
hw: &instance.HardwareCharacteristics{
Arch: &amd64,
Mem: &gig,
CpuCores: &one,
CpuPower: &one,
}},
"2": {id: "2", life: state.Alive, containerType: instance.LXD},
"3": {life: state.Dying},
},
}
info, err := common.ModelMachineInfo(&st)
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, jc.DeepEquals, []params.ModelMachineInfo{
{
Id: "1",
Hardware: ¶ms.MachineHardware{
Arch: &amd64,
Mem: &gig,
Cores: &one,
CpuPower: &one,
},
}, {
Id: "2",
},
})
}
func (c *ControllerAPI) modelStatus(tag string) (params.ModelStatus, error) {
var status params.ModelStatus
modelTag, err := names.ParseModelTag(tag)
if err != nil {
return status, errors.Trace(err)
}
st, err := c.state.ForModel(modelTag)
if err != nil {
return status, errors.Trace(err)
}
defer st.Close()
machines, err := st.AllMachines()
if err != nil {
return status, errors.Trace(err)
}
var hostedMachines []*state.Machine
for _, m := range machines {
if !m.IsManager() {
hostedMachines = append(hostedMachines, m)
}
}
applications, err := st.AllApplications()
if err != nil {
return status, errors.Trace(err)
}
model, err := st.Model()
if err != nil {
return status, errors.Trace(err)
}
if err != nil {
return status, errors.Trace(err)
}
modelMachines, err := common.ModelMachineInfo(common.NewModelManagerBackend(st))
if err != nil {
return status, errors.Trace(err)
}
return params.ModelStatus{
ModelTag: tag,
OwnerTag: model.Owner().String(),
Life: params.Life(model.Life().String()),
HostedMachineCount: len(hostedMachines),
ApplicationCount: len(applications),
Machines: modelMachines,
}, nil
}
func (s *machineSuite) TestMachineInstanceInfo(c *gc.C) {
st := mockState{
machines: map[string]*mockMachine{
"1": {id: "1", instId: instance.Id("123"), status: status.Down, hasVote: true, wantsVote: true},
},
}
info, err := common.ModelMachineInfo(&st)
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, jc.DeepEquals, []params.ModelMachineInfo{
{
Id: "1",
InstanceId: "123",
Status: "down",
HasVote: true,
WantsVote: true,
},
})
}
func (m *ModelManagerAPI) getModelInfo(tag names.ModelTag) (params.ModelInfo, error) {
st, err := m.state.ForModel(tag)
if errors.IsNotFound(err) {
return params.ModelInfo{}, common.ErrPerm
} else if err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
defer st.Close()
model, err := st.Model()
if errors.IsNotFound(err) {
return params.ModelInfo{}, common.ErrPerm
} else if err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
cfg, err := model.Config()
if err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
controllerCfg, err := st.ControllerConfig()
if err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
users, err := model.Users()
if err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
status, err := model.Status()
if err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
owner := model.Owner()
info := params.ModelInfo{
Name: cfg.Name(),
UUID: cfg.UUID(),
ControllerUUID: controllerCfg.ControllerUUID(),
OwnerTag: owner.String(),
Life: params.Life(model.Life().String()),
Status: common.EntityStatusFromState(status),
ProviderType: cfg.Type(),
DefaultSeries: config.PreferredSeries(cfg),
CloudTag: names.NewCloudTag(model.Cloud()).String(),
CloudRegion: model.CloudRegion(),
}
if cloudCredentialTag, ok := model.CloudCredential(); ok {
info.CloudCredentialTag = cloudCredentialTag.String()
}
authorizedOwner := m.authCheck(owner) == nil
for _, user := range users {
if !authorizedOwner && m.authCheck(user.UserTag) != nil {
// The authenticated user is neither the owner
// nor administrator, nor the model user, so
// has no business knowing about the model user.
continue
}
userInfo, err := common.ModelUserInfo(user, st)
if err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
info.Users = append(info.Users, userInfo)
}
if len(info.Users) == 0 {
// No users, which means the authenticated user doesn't
// have access to the model.
return params.ModelInfo{}, common.ErrPerm
}
canSeeMachines := authorizedOwner
if !canSeeMachines {
if canSeeMachines, err = m.hasWriteAccess(tag); err != nil {
return params.ModelInfo{}, errors.Trace(err)
}
}
if canSeeMachines {
if info.Machines, err = common.ModelMachineInfo(st); err != nil {
return params.ModelInfo{}, err
}
}
return info, nil
}