func opClientDestroyRelation(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
err := application.NewClient(st).DestroyRelation("nosuch1", "nosuch2")
if params.IsCodeNotFound(err) {
err = nil
}
return func() {}, err
}
func (c *removeRelationCommand) getAPI() (serviceDestroyRelationAPI, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return application.NewClient(root), nil
}
func (s *getSuite) TestGetMaxResolutionInt(c *gc.C) {
// See the bug http://pad.lv/1217742
// Get ends up pushing a map[string]interface{} which containts
// an int64 through a JSON Marshal & Unmarshal which ends up changing
// the int64 into a float64. We will fix it if we find it is actually a
// problem.
const nonFloatInt = (int64(1) << 54) + 1
const asFloat = float64(nonFloatInt)
c.Assert(int64(asFloat), gc.Not(gc.Equals), nonFloatInt)
c.Assert(int64(asFloat)+1, gc.Equals, nonFloatInt)
ch := s.AddTestingCharm(c, "dummy")
svc := s.AddTestingService(c, "test-service", ch)
err := svc.UpdateConfigSettings(map[string]interface{}{"skill-level": nonFloatInt})
c.Assert(err, jc.ErrorIsNil)
client := apiapplication.NewClient(s.APIState)
got, err := client.Get(svc.Name())
c.Assert(err, jc.ErrorIsNil)
c.Assert(got.Config["skill-level"], jc.DeepEquals, map[string]interface{}{
"description": "A number indicating skill.",
"type": "int",
"value": asFloat,
})
}
func (c *debugHooksCommand) getServiceAPI() (charmRelationsApi, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return application.NewClient(root), nil
}
func opClientAddServiceUnits(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
_, err := application.NewClient(st).AddUnits("nosuch", 1, nil)
if params.IsCodeNotFound(err) {
err = nil
}
return func() {}, err
}
func opClientServiceUnexpose(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
err := application.NewClient(st).Unexpose("wordpress")
if err != nil {
return func() {}, err
}
return func() {}, nil
}
func opClientServiceDestroy(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
err := application.NewClient(st).Destroy("non-existent")
if params.IsCodeNotFound(err) {
err = nil
}
return func() {}, err
}
func (s *getSuite) TestServiceGet(c *gc.C) {
for i, t := range getTests {
c.Logf("test %d. %s", i, t.about)
ch := s.AddTestingCharm(c, t.charm)
svc := s.AddTestingService(c, fmt.Sprintf("test%d", i), ch)
var constraintsv constraints.Value
if t.constraints != "" {
constraintsv = constraints.MustParse(t.constraints)
err := svc.SetConstraints(constraintsv)
c.Assert(err, jc.ErrorIsNil)
}
if t.config != nil {
err := svc.UpdateConfigSettings(t.config)
c.Assert(err, jc.ErrorIsNil)
}
expect := t.expect
expect.Constraints = constraintsv
expect.Application = svc.Name()
expect.Charm = ch.Meta().Name
client := apiapplication.NewClient(s.APIState)
got, err := client.Get(svc.Name())
c.Assert(err, jc.ErrorIsNil)
c.Assert(*got, gc.DeepEquals, expect)
}
}
func opClientDestroyServiceUnits(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
err := application.NewClient(st).DestroyUnits("wordpress/99")
if err != nil && strings.HasPrefix(err.Error(), "no units were destroyed") {
err = nil
}
return func() {}, err
}
func (c *exposeCommand) getAPI() (serviceExposeAPI, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return application.NewClient(root), nil
}
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
}
func resetBlogTitle(c *gc.C, st api.Connection) func() {
return func() {
err := application.NewClient(st).Set("wordpress", map[string]string{
"blog-title": "",
})
c.Assert(err, jc.ErrorIsNil)
}
}
func opClientSetServiceConstraints(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
nullConstraints := constraints.Value{}
err := application.NewClient(st).SetConstraints("wordpress", nullConstraints)
if err != nil {
return func() {}, err
}
return func() {}, nil
}
func opClientServiceSet(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
err := application.NewClient(st).Set("wordpress", map[string]string{
"blog-title": "foo",
})
if err != nil {
return func() {}, err
}
return resetBlogTitle(c, st), nil
}
func (c *serviceConstraintsCommand) getAPI() (serviceConstraintsAPI, error) {
if c.api != nil {
return c.api, nil
}
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return application.NewClient(root), nil
}
func opClientServiceExpose(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
err := application.NewClient(st).Expose("wordpress")
if err != nil {
return func() {}, err
}
return func() {
svc, err := mst.Application("wordpress")
c.Assert(err, jc.ErrorIsNil)
svc.ClearExposed()
}, nil
}
// getAPI either uses the fake API set at test time or that is nil, gets a real
// API and sets that as the API.
func (c *configCommand) getAPI() (configCommandAPI, error) {
if c.api != nil {
return c.api, nil
}
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
client := application.NewClient(root)
return client, nil
}
// NewAddRelationCommand returns a command to add a relation between 2 services.
func NewAddRelationCommand() cmd.Command {
cmd := &addRelationCommand{}
cmd.newAPIFunc = func() (ApplicationAddRelationAPI, error) {
root, err := cmd.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return application.NewClient(root), nil
}
return modelcmd.Wrap(cmd)
}
func opClientServiceSetCharm(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
cfg := application.SetCharmConfig{
ApplicationName: "nosuch",
CharmID: charmstore.CharmID{
URL: charm.MustParseURL("local:quantal/wordpress"),
},
}
err := application.NewClient(st).SetCharm(cfg)
if params.IsCodeNotFound(err) {
err = nil
}
return func() {}, err
}
func opClientServiceUpdate(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
args := params.ApplicationUpdate{
ApplicationName: "no-such-charm",
CharmURL: "cs:quantal/wordpress-42",
ForceCharmURL: true,
SettingsStrings: map[string]string{"blog-title": "foo"},
SettingsYAML: `"wordpress": {"blog-title": "foo"}`,
}
err := application.NewClient(st).Update(args)
if params.IsCodeNotFound(err) {
err = nil
}
return func() {}, err
}
// Run implements cmd.Command.
func (c *setPlanCommand) Run(ctx *cmd.Context) error {
root, err := c.NewAPIRoot()
if err != nil {
return errors.Trace(err)
}
client := application.NewClient(root)
credentials, err := c.requestMetricCredentials(client, ctx)
if err != nil {
return errors.Trace(err)
}
err = client.SetMetricCredentials(c.Application, credentials)
if err != nil {
return errors.Trace(err)
}
return nil
}
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)
}
func opClientGetServiceConstraints(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
_, err := application.NewClient(st).GetConstraints("wordpress")
return func() {}, err
}
func (s *serviceSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.client = application.NewClient(s.APIState)
c.Assert(s.client, gc.NotNil)
}
