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) }