func opClientModelSet(c *gc.C, st api.Connection, mst *state.State) (func(), error) { args := map[string]interface{}{"some-key": "some-value"} err := modelconfig.NewClient(st).ModelSet(args) if err != nil { return func() {}, err } return func() { args["some-key"] = nil modelconfig.NewClient(st).ModelSet(args) }, nil }
func opClientModelGet(c *gc.C, st api.Connection, mst *state.State) (func(), error) { _, err := modelconfig.NewClient(st).ModelGet() if err != nil { return func() {}, err } return func() {}, nil }
func (s *modelconfigSuite) TestModelGetWithMetadata(c *gc.C) { apiCaller := basetesting.APICallerFunc( func(objType string, version int, id, request string, a, result interface{}, ) error { c.Check(objType, gc.Equals, "ModelConfig") c.Check(id, gc.Equals, "") c.Check(request, gc.Equals, "ModelGet") c.Check(a, gc.IsNil) c.Assert(result, gc.FitsTypeOf, ¶ms.ModelConfigResults{}) results := result.(*params.ModelConfigResults) results.Config = map[string]params.ConfigValue{ "foo": {"bar", "model"}, } return nil }, ) client := modelconfig.NewClient(apiCaller) result, err := client.ModelGetWithMetadata() c.Assert(err, jc.ErrorIsNil) c.Assert(result, jc.DeepEquals, config.ConfigValues{ "foo": {"bar", "model"}, }) }
func (s *modelconfigSuite) TestModelSet(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, "ModelConfig") c.Check(id, gc.Equals, "") c.Check(request, gc.Equals, "ModelSet") c.Check(a, jc.DeepEquals, params.ModelSet{ Config: map[string]interface{}{ "some-name": "value", "other-name": true, }, }) called = true return nil }, ) client := modelconfig.NewClient(apiCaller) err := client.ModelSet(map[string]interface{}{ "some-name": "value", "other-name": true, }) c.Assert(err, jc.ErrorIsNil) c.Assert(called, jc.IsTrue) }
func NewDeployCommandWithDefaultAPI(steps []DeployStep) cmd.Command { deployCmd := &DeployCommand{Steps: steps} cmd := modelcmd.Wrap(deployCmd) deployCmd.NewAPIRoot = func() (DeployAPI, error) { apiRoot, err := deployCmd.ModelCommandBase.NewAPIRoot() if err != nil { return nil, errors.Trace(err) } bakeryClient, err := deployCmd.BakeryClient() if err != nil { return nil, errors.Trace(err) } cstoreClient := newCharmStoreClient(bakeryClient).WithChannel(deployCmd.Channel) adapter := &deployAPIAdapter{ Connection: apiRoot, apiClient: &apiClient{Client: apiRoot.Client()}, charmsClient: &charmsClient{Client: apicharms.NewClient(apiRoot)}, applicationClient: &applicationClient{Client: application.NewClient(apiRoot)}, modelConfigClient: &modelConfigClient{Client: modelconfig.NewClient(apiRoot)}, charmstoreClient: &charmstoreClient{Client: cstoreClient}, annotationsClient: &annotationsClient{Client: annotations.NewClient(apiRoot)}, charmRepoClient: &charmRepoClient{CharmStore: charmrepo.NewCharmStoreFromClient(cstoreClient)}, } return adapter, nil } return cmd }
// getAPI returns the API. This allows passing in a test configCommandAPI // implementation. func (c *configCommand) getAPI() (configCommandAPI, 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 := modelconfig.NewClient(api) return client, nil }
func (c *addCommand) getModelConfigAPI() (ModelConfigAPI, error) { if c.modelConfigAPI != nil { return c.modelConfigAPI, nil } api, err := c.NewAPIRoot() if err != nil { return nil, errors.Annotate(err, "opening API connection") } return modelconfig.NewClient(api), nil }
func opClientSetModelAgentVersion(c *gc.C, st api.Connection, mst *state.State) (func(), error) { attrs, err := modelconfig.NewClient(st).ModelGet() if err != nil { return func() {}, err } ver := version.Number{Major: 1, Minor: 2, Patch: 3} err = st.Client().SetModelAgentVersion(ver) if err != nil { return func() {}, err } return func() { oldAgentVersion, found := attrs["agent-version"] if found { versionString := oldAgentVersion.(string) st.Client().SetModelAgentVersion(version.MustParse(versionString)) } }, nil }
func (s *modelconfigSuite) TestModelUnset(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, "ModelConfig") c.Check(id, gc.Equals, "") c.Check(request, gc.Equals, "ModelUnset") c.Check(a, jc.DeepEquals, params.ModelUnset{ Keys: []string{"foo", "bar"}, }) called = true return nil }, ) client := modelconfig.NewClient(apiCaller) err := client.ModelUnset("foo", "bar") c.Assert(err, jc.ErrorIsNil) c.Assert(called, jc.IsTrue) }
func (s *RemoveCharmStoreCharmsSuite) SetUpTest(c *gc.C) { s.charmStoreSuite.SetUpTest(c) s.ctx = testing.Context(c) s.stub = &jutesting.Stub{} s.budgetAPIClient = &mockBudgetAPIClient{Stub: s.stub} s.PatchValue(&getBudgetAPIClient, func(*httpbakery.Client) budgetAPIClient { return s.budgetAPIClient }) testcharms.UploadCharm(c, s.client, "cs:quantal/metered-1", "metered") deployCmd := &DeployCommand{} cmd := modelcmd.Wrap(deployCmd) deployCmd.NewAPIRoot = func() (DeployAPI, error) { apiRoot, err := deployCmd.ModelCommandBase.NewAPIRoot() if err != nil { return nil, errors.Trace(err) } bakeryClient, err := deployCmd.BakeryClient() if err != nil { return nil, errors.Trace(err) } cstoreClient := newCharmStoreClient(bakeryClient).WithChannel(deployCmd.Channel) return &deployAPIAdapter{ Connection: apiRoot, apiClient: &apiClient{Client: apiRoot.Client()}, charmsClient: &charmsClient{Client: charms.NewClient(apiRoot)}, applicationClient: &applicationClient{Client: application.NewClient(apiRoot)}, modelConfigClient: &modelConfigClient{Client: modelconfig.NewClient(apiRoot)}, charmstoreClient: &charmstoreClient{Client: cstoreClient}, annotationsClient: &annotationsClient{Client: annotations.NewClient(apiRoot)}, charmRepoClient: &charmRepoClient{CharmStore: charmrepo.NewCharmStoreFromClient(cstoreClient)}, }, nil } _, err := testing.RunCommand(c, cmd, "cs:quantal/metered-1") c.Assert(err, jc.ErrorIsNil) }
// NewUpgradeCharmCommand returns a command which upgrades application's charm. func NewUpgradeCharmCommand() cmd.Command { cmd := &upgradeCharmCommand{ DeployResources: resourceadapters.DeployResources, ResolveCharm: resolveCharm, NewCharmAdder: newCharmAdder, NewCharmClient: func(conn api.Connection) CharmClient { return charms.NewClient(conn) }, NewCharmUpgradeClient: func(conn api.Connection) CharmUpgradeClient { return application.NewClient(conn) }, NewModelConfigGetter: func(conn api.Connection) ModelConfigGetter { return modelconfig.NewClient(conn) }, NewResourceLister: func(conn api.Connection) (ResourceLister, error) { resclient, err := resourceadapters.NewAPIClient(conn) if err != nil { return nil, err } return resclient, nil }, } return modelcmd.Wrap(cmd) }
type controllerAPI interface { ModelConfig() (map[string]interface{}, error) Close() error } var getUpgradeJujuAPI = func(c *upgradeJujuCommand) (upgradeJujuAPI, error) { return c.NewAPIClient() } var getModelConfigAPI = func(c *upgradeJujuCommand) (modelConfigAPI, error) { api, err := c.NewAPIRoot() if err != nil { return nil, errors.Trace(err) } return modelconfig.NewClient(api), nil } var getControllerAPI = func(c *upgradeJujuCommand) (controllerAPI, error) { api, err := c.NewControllerAPIRoot() if err != nil { return nil, errors.Trace(err) } return controller.NewClient(api), nil } // Run changes the version proposed for the juju envtools. func (c *upgradeJujuCommand) Run(ctx *cmd.Context) (err error) { client, err := getUpgradeJujuAPI(c) if err != nil {