func (s *dumpModelSuite) TestDumpModelDB(c *gc.C) {
expected := map[string]interface{}{
"models": []map[string]interface{}{{
"name": "admin",
"uuid": "some-uuid",
}},
"machines": []map[string]interface{}{{
"id": "0",
"life": 0,
}},
}
results := params.MapResults{Results: []params.MapResult{{
Result: expected,
}}}
apiCaller := basetesting.APICallerFunc(
func(objType string, version int, id, request string, args, result interface{}) error {
c.Check(objType, gc.Equals, "ModelManager")
c.Check(request, gc.Equals, "DumpModelsDB")
in, ok := args.(params.Entities)
c.Assert(ok, jc.IsTrue)
c.Assert(in, gc.DeepEquals, params.Entities{[]params.Entity{{testing.ModelTag.String()}}})
res, ok := result.(*params.MapResults)
c.Assert(ok, jc.IsTrue)
*res = results
return nil
})
client := modelmanager.NewClient(apiCaller)
out, err := client.DumpModelDB(testing.ModelTag)
c.Assert(err, jc.ErrorIsNil)
c.Assert(out, jc.DeepEquals, expected)
}
func newAPIClientImpl(c *showBudgetCommand) (APIClient, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return modelmanager.NewClient(root), nil
}
func (s *modelmanagerSuite) TestUnsetModelDefaults(c *gc.C) {
called := false
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, result interface{},
) error {
c.Check(objType, gc.Equals, "ModelManager")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "UnsetModelDefaults")
c.Check(a, jc.DeepEquals, params.UnsetModelDefaults{
Keys: []params.ModelUnsetKeys{{
CloudTag: "cloud-mycloud",
CloudRegion: "region",
Keys: []string{"foo", "bar"},
}}})
c.Assert(result, gc.FitsTypeOf, ¶ms.ErrorResults{})
*(result.(*params.ErrorResults)) = params.ErrorResults{
Results: []params.ErrorResult{{Error: nil}},
}
called = true
return nil
},
)
client := modelmanager.NewClient(apiCaller)
err := client.UnsetModelDefaults("mycloud", "region", "foo", "bar")
c.Assert(err, jc.ErrorIsNil)
c.Assert(called, jc.IsTrue)
}
func (s *modelmanagerSuite) TestModelDefaults(c *gc.C) {
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, result interface{},
) error {
c.Check(objType, gc.Equals, "ModelManager")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "ModelDefaults")
c.Check(a, gc.IsNil)
c.Assert(result, gc.FitsTypeOf, ¶ms.ModelDefaultsResult{})
results := result.(*params.ModelDefaultsResult)
results.Config = map[string]params.ModelDefaults{
"foo": {"bar", "model", []params.RegionDefaults{{
"dummy-region",
"dummy-value"}}},
}
return nil
},
)
client := modelmanager.NewClient(apiCaller)
result, err := client.ModelDefaults()
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, config.ModelDefaultAttributes{
"foo": {"bar", "model", []config.RegionDefaultValue{{
"dummy-region",
"dummy-value"}}},
})
}
// NewModelManagerAPIClient returns an API client for the
// ModelManager on the current controller using the current credentials.
func (c *ControllerCommandBase) NewModelManagerAPIClient() (*modelmanager.Client, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return modelmanager.NewClient(root), nil
}
func (s *cmdControllerSuite) createModelAdminUser(c *gc.C, modelname string, isServer bool) {
modelManager := modelmanager.NewClient(s.APIState)
_, err := modelManager.CreateModel(s.AdminUserTag(c).Id(), nil, map[string]interface{}{
"name": modelname,
"controller": isServer,
})
c.Assert(err, jc.ErrorIsNil)
}
func (c *registerCommand) listModels(store jujuclient.ClientStore, controllerName, userName string) ([]base.UserModel, error) {
api, err := c.NewAPIRoot(store, controllerName, "")
if err != nil {
return nil, errors.Trace(err)
}
defer api.Close()
mm := modelmanager.NewClient(api)
return mm.ListModels(userName)
}
// NewAddModelCommand returns a command to add a model.
func NewAddModelCommand() cmd.Command {
return modelcmd.WrapController(&addModelCommand{
newAddModelAPI: func(caller base.APICallCloser) AddModelAPI {
return modelmanager.NewClient(caller)
},
newCloudAPI: func(caller base.APICallCloser) CloudAPI {
return cloudapi.NewClient(caller)
},
})
}
func (c *showModelCommand) getAPI() (ShowModelAPI, error) {
if c.api != nil {
return c.api, nil
}
api, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return modelmanager.NewClient(api), nil
}
func (s *cmdControllerSuite) createModelNormalUser(c *gc.C, modelname string, isServer bool) {
s.run(c, "add-user", "test")
modelManager := modelmanager.NewClient(s.APIState)
_, err := modelManager.CreateModel(names.NewLocalUserTag("test").Id(), nil, map[string]interface{}{
"name": modelname,
"authorized-keys": "ssh-key",
"controller": isServer,
})
c.Assert(err, jc.ErrorIsNil)
}
func (c *destroyCommand) getAPI() (DestroyModelAPI, error) {
if c.api != nil {
return c.api, nil
}
root, err := c.NewControllerAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return modelmanager.NewClient(root), nil
}
func (c *JujuCommandBase) modelAPI(store jujuclient.ClientStore, controllerName string) (ModelAPI, error) {
if c.modelAPI_ != nil {
return c.modelAPI_, nil
}
conn, err := c.NewAPIRoot(store, controllerName, "")
if err != nil {
return nil, errors.Trace(err)
}
c.modelAPI_ = modelmanager.NewClient(conn)
return c.modelAPI_, nil
}
func (s *cmdControllerSuite) createModelAdminUser(c *gc.C, modelname string, isServer bool) base.ModelInfo {
modelManager := modelmanager.NewClient(s.OpenControllerAPI(c))
defer modelManager.Close()
model, err := modelManager.CreateModel(
modelname, s.AdminUserTag(c).Id(), "", "", names.CloudCredentialTag{}, map[string]interface{}{
"controller": isServer,
},
)
c.Assert(err, jc.ErrorIsNil)
return model
}
// NewDefaultsCommand wraps defaultsCommand with sane model settings.
func NewDefaultsCommand() cmd.Command {
defaultsCmd := &defaultsCommand{
newCloudAPI: func(caller base.APICallCloser) cloudAPI {
return cloudapi.NewClient(caller)
},
newDefaultsAPI: func(caller base.APICallCloser) defaultsCommandAPI {
return modelmanager.NewClient(caller)
},
}
defaultsCmd.newAPIRoot = defaultsCmd.NewAPIRoot
return modelcmd.WrapController(defaultsCmd)
}
func (s *cmdControllerSuite) createEnv(c *gc.C, envname string, isServer bool) {
conn, err := juju.NewAPIState(s.AdminUserTag(c), s.Environ, api.DialOpts{})
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(*gc.C) { conn.Close() })
modelManager := modelmanager.NewClient(conn)
_, err = modelManager.CreateModel(s.AdminUserTag(c).Id(), nil, map[string]interface{}{
"name": envname,
"authorized-keys": "ssh-key",
"controller": isServer,
})
c.Assert(err, jc.ErrorIsNil)
}
func (s *cmdControllerSuite) createModelNormalUser(c *gc.C, modelname string, isServer bool) {
s.run(c, "add-user", "test")
modelManager := modelmanager.NewClient(s.OpenControllerAPI(c))
defer modelManager.Close()
_, err := modelManager.CreateModel(
modelname, names.NewLocalUserTag("test").Id(), "", "", names.CloudCredentialTag{}, map[string]interface{}{
"authorized-keys": "ssh-key",
"controller": isServer,
},
)
c.Assert(err, jc.ErrorIsNil)
}
// getAPI sets the api on the command. This allows passing in a test
// ModelDefaultsAPI implementation.
func (c *defaultsCommand) getAPI() (defaultsCommandAPI, error) {
if c.api != nil {
return c.api, nil
}
api, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Annotate(err, "opening API connection")
}
client := modelmanager.NewClient(api)
return client, nil
}
func (s *accessSuite) TestInvalidResultCount(c *gc.C) {
apiCaller := basetesting.APICallerFunc(
func(objType string, version int, id, request string, a, result interface{}) error {
checkCall(c, objType, id, request)
assertRequest(c, a)
resp := assertResponse(c, result)
*resp = params.ErrorResults{Results: nil}
return nil
})
client := modelmanager.NewClient(apiCaller)
err := client.GrantModel("bob", "write", someModelUUID, someModelUUID)
c.Assert(err, gc.ErrorMatches, "expected 2 results, got 0")
}
func (s *apiEnvironmentSuite) TestGrantModel(c *gc.C) {
username := "******"
model, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
mm := modelmanager.NewClient(s.APIState)
err = mm.GrantModel(username, "read", model.UUID())
c.Assert(err, jc.ErrorIsNil)
user := names.NewUserTag(username)
modelUser, err := s.State.ModelUser(user)
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelUser.UserName(), gc.Equals, user.Canonical())
lastConn, err := modelUser.LastConnection()
c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
c.Assert(lastConn.IsZero(), jc.IsTrue)
}
func (s *modelInfoSuite) TestInvalidResultCount(c *gc.C) {
apiCaller := basetesting.APICallerFunc(
func(objType string, version int, id, request string, a, result interface{}) error {
s.checkCall(c, objType, id, request)
c.Assert(a, jc.DeepEquals, params.Entities{
Entities: []params.Entity{{testing.ModelTag.String()}, {testing.ModelTag.String()}},
})
resp := s.assertResponse(c, result)
*resp = params.ModelInfoResults{Results: []params.ModelInfoResult{{}}}
return nil
},
)
client := modelmanager.NewClient(apiCaller)
_, err := client.ModelInfo([]names.ModelTag{testing.ModelTag, testing.ModelTag})
c.Assert(err, gc.ErrorMatches, "expected 2 result\\(s\\), got 1")
}
func (s *dumpModelSuite) TestDumpModelDBError(c *gc.C) {
results := params.MapResults{Results: []params.MapResult{{
Error: ¶ms.Error{Message: "fake error"},
}}}
apiCaller := basetesting.APICallerFunc(
func(objType string, version int, id, request string, args, result interface{}) error {
res, ok := result.(*params.MapResults)
c.Assert(ok, jc.IsTrue)
*res = results
return nil
})
client := modelmanager.NewClient(apiCaller)
out, err := client.DumpModelDB(testing.ModelTag)
c.Assert(err, gc.ErrorMatches, "fake error")
c.Assert(out, gc.IsNil)
}
func (s *apiEnvironmentSuite) TestGrantModel(c *gc.C) {
username := "******"
model, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
mm := modelmanager.NewClient(s.OpenControllerAPI(c))
defer mm.Close()
err = mm.GrantModel(username, "read", model.UUID())
c.Assert(err, jc.ErrorIsNil)
user := names.NewUserTag(username)
modelUser, err := s.State.UserAccess(user, model.ModelTag())
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelUser.UserName, gc.Equals, user.Id())
lastConn, err := s.State.LastModelConnection(modelUser.UserTag)
c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
c.Assert(lastConn.IsZero(), jc.IsTrue)
}
func (s *stateSuite) TestLoginSetsControllerAccess(c *gc.C) {
// The default user has admin access.
c.Assert(s.APIState.ControllerAccess(), gc.Equals, "superuser")
manager := usermanager.NewClient(s.OpenControllerAPI(c))
defer manager.Close()
usertag, _, err := manager.AddUser("ro", "ro", "ro-password")
c.Assert(err, jc.ErrorIsNil)
mmanager := modelmanager.NewClient(s.OpenControllerAPI(c))
defer mmanager.Close()
modeltag, ok := s.APIState.ModelTag()
c.Assert(ok, jc.IsTrue)
err = mmanager.GrantModel(usertag.Id(), "read", modeltag.Id())
c.Assert(err, jc.ErrorIsNil)
conn := s.OpenAPIAs(c, usertag, "ro-password")
c.Assert(conn.ControllerAccess(), gc.Equals, "login")
}
func (s *apiEnvironmentSuite) TestRevokeModel(c *gc.C) {
// First share an environment with a user.
user := s.Factory.MakeModelUser(c, &factory.ModelUserParams{User: "******"})
model, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
mm := modelmanager.NewClient(s.APIState)
modelUser, err := s.State.ModelUser(user.UserTag())
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelUser, gc.NotNil)
// Then test unsharing the environment.
err = mm.RevokeModel(user.UserName(), "read", model.UUID())
c.Assert(err, jc.ErrorIsNil)
modelUser, err = s.State.ModelUser(user.UserTag())
c.Assert(errors.IsNotFound(err), jc.IsTrue)
c.Assert(modelUser, gc.IsNil)
}
func (s *accessSuite) adminUser(c *gc.C, action params.ModelAction) {
apiCaller := basetesting.APICallerFunc(
func(objType string, version int, id, request string, a, result interface{}) error {
checkCall(c, objType, id, request)
req := assertRequest(c, a)
c.Assert(req.Changes, gc.HasLen, 1)
c.Assert(string(req.Changes[0].Action), gc.Equals, string(action))
c.Assert(string(req.Changes[0].Access), gc.Equals, string(params.ModelWriteAccess))
c.Assert(req.Changes[0].ModelTag, gc.Equals, someModelTag)
resp := assertResponse(c, result)
*resp = params.ErrorResults{Results: []params.ErrorResult{{Error: nil}}}
return nil
})
client := modelmanager.NewClient(apiCaller)
err := accessCall(client, action, "bob", "write", someModelUUID)
c.Assert(err, jc.ErrorIsNil)
}
func (s *apiEnvironmentSuite) TestRevokeModel(c *gc.C) {
// First share an environment with a user.
user := s.Factory.MakeModelUser(c, &factory.ModelUserParams{User: "******"})
model, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
mm := modelmanager.NewClient(s.OpenControllerAPI(c))
defer mm.Close()
modelUser, err := s.State.UserAccess(user.UserTag, s.State.ModelTag())
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelUser, gc.Not(gc.DeepEquals), permission.UserAccess{})
// Then test unsharing the environment.
err = mm.RevokeModel(user.UserName, "read", model.UUID())
c.Assert(err, jc.ErrorIsNil)
modelUser, err = s.State.UserAccess(user.UserTag, s.State.ModelTag())
c.Assert(errors.IsNotFound(err), jc.IsTrue)
c.Assert(modelUser, gc.DeepEquals, permission.UserAccess{})
}
func (s *modelInfoSuite) TestModelInfo(c *gc.C) {
results := params.ModelInfoResults{
Results: []params.ModelInfoResult{{
Result: ¶ms.ModelInfo{Name: "name", UUID: "etc."},
}, {
Error: ¶ms.Error{Message: "woop"},
}},
}
apiCaller := basetesting.APICallerFunc(
func(objType string, version int, id, request string, a, result interface{}) error {
s.checkCall(c, objType, id, request)
resp := s.assertResponse(c, result)
*resp = results
return nil
})
client := modelmanager.NewClient(apiCaller)
info, err := client.ModelInfo([]names.ModelTag{testing.ModelTag, testing.ModelTag})
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, jc.DeepEquals, results.Results)
}
func (s *accessSuite) errorResult(c *gc.C, action params.ModelAction) {
apiCaller := basetesting.APICallerFunc(
func(objType string, version int, id, request string, a, result interface{}) error {
checkCall(c, objType, id, request)
req := assertRequest(c, a)
c.Assert(req.Changes, gc.HasLen, 1)
c.Assert(string(req.Changes[0].Action), gc.Equals, string(action))
c.Assert(req.Changes[0].UserTag, gc.Equals, names.NewUserTag("aaa").String())
c.Assert(req.Changes[0].ModelTag, gc.Equals, someModelTag)
resp := assertResponse(c, result)
err := ¶ms.Error{Message: "unfortunate mishap"}
*resp = params.ErrorResults{Results: []params.ErrorResult{{Error: err}}}
return nil
})
client := modelmanager.NewClient(apiCaller)
err := accessCall(client, action, "aaa", "write", someModelUUID)
c.Assert(err, gc.ErrorMatches, "unfortunate mishap")
}
func (s *modelmanagerSuite) TestSetModelDefaults(c *gc.C) {
called := false
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, result interface{},
) error {
c.Check(objType, gc.Equals, "ModelManager")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "SetModelDefaults")
c.Check(a, jc.DeepEquals, params.SetModelDefaults{
Config: []params.ModelDefaultValues{{
CloudTag: "cloud-mycloud",
CloudRegion: "region",
Config: map[string]interface{}{
"some-name": "value",
"other-name": true,
},
}}})
c.Assert(result, gc.FitsTypeOf, ¶ms.ErrorResults{})
*(result.(*params.ErrorResults)) = params.ErrorResults{
Results: []params.ErrorResult{{Error: nil}},
}
called = true
return nil
},
)
client := modelmanager.NewClient(apiCaller)
err := client.SetModelDefaults("mycloud", "region", map[string]interface{}{
"some-name": "value",
"other-name": true,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(called, jc.IsTrue)
}
func (s *modelmanagerSuite) OpenAPI(c *gc.C) *modelmanager.Client {
conn, err := juju.NewAPIState(s.AdminUserTag(c), s.Environ, api.DialOpts{})
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(*gc.C) { conn.Close() })
return modelmanager.NewClient(conn)
}