func (s *DeployLocalSuite) TestDeployForceMachineIdWithContainer(c *gc.C) {
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
c.Assert(machine.Id(), gc.Equals, "0")
cons := constraints.MustParse("mem=2G")
err = s.State.SetEnvironConstraints(cons)
c.Assert(err, gc.IsNil)
serviceCons := constraints.MustParse("cpu-cores=2")
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
Constraints: serviceCons,
NumUnits: 1,
ToMachineSpec: fmt.Sprintf("%s:0", instance.LXC),
})
c.Assert(err, gc.IsNil)
s.assertConstraints(c, service, serviceCons)
units, err := service.AllUnits()
c.Assert(err, gc.IsNil)
c.Assert(units, gc.HasLen, 1)
// The newly created container will use the constraints.
id, err := units[0].AssignedMachineId()
c.Assert(err, gc.IsNil)
machine, err = s.State.Machine(id)
c.Assert(err, gc.IsNil)
expectedCons, err := machine.Constraints()
c.Assert(err, gc.IsNil)
c.Assert(cons, gc.DeepEquals, expectedCons)
}
func (s *DeployLocalSuite) TestDeployWithForceMachineRejectsTooManyUnits(c *gc.C) {
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
c.Assert(machine.Id(), gc.Equals, "0")
_, err = juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
NumUnits: 2,
ToMachineSpec: "0",
})
c.Assert(err, gc.ErrorMatches, "cannot use --num-units with --to")
}
func (s *DeployLocalSuite) TestDeployConstraints(c *gc.C) {
err := s.State.SetEnvironConstraints(constraints.MustParse("mem=2G"))
c.Assert(err, gc.IsNil)
serviceCons := constraints.MustParse("cpu-cores=2")
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
Constraints: serviceCons,
})
c.Assert(err, gc.IsNil)
s.assertConstraints(c, service, serviceCons)
}
func (s *DeployLocalSuite) TestDeploySettingsError(c *gc.C) {
_, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
ConfigSettings: charm.Settings{
"skill-level": 99.01,
},
})
c.Assert(err, gc.ErrorMatches, `option "skill-level" expected int, got 99.01`)
_, err = s.State.Service("bob")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *DeployLocalSuite) TestDeployOwnerTag(c *gc.C) {
usermanager := usermanager.NewClient(s.APIState)
err := usermanager.AddUser("foobar", "")
c.Assert(err, gc.IsNil)
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bobwithowner",
Charm: s.charm,
ServiceOwner: "user-foobar",
})
c.Assert(err, gc.IsNil)
c.Assert(service.GetOwnerTag(), gc.Equals, "user-foobar")
}
func (s *DeployLocalSuite) TestDeployMinimal(c *gc.C) {
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
})
c.Assert(err, gc.IsNil)
s.assertCharm(c, service, s.charm.URL())
s.assertSettings(c, service, charm.Settings{})
s.assertConstraints(c, service, constraints.Value{})
s.assertMachines(c, service, constraints.Value{})
c.Assert(service.GetOwnerTag(), gc.Equals, "user-admin")
}
func (s *DeployLocalSuite) TestDeploySettings(c *gc.C) {
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
ConfigSettings: charm.Settings{
"title": "banana cupcakes",
"skill-level": 9901,
},
})
c.Assert(err, gc.IsNil)
s.assertSettings(c, service, charm.Settings{
"title": "banana cupcakes",
"skill-level": int64(9901),
})
}
func (s *DeployLocalSuite) TestDeployForceMachineId(c *gc.C) {
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
c.Assert(machine.Id(), gc.Equals, "0")
err = s.State.SetEnvironConstraints(constraints.MustParse("mem=2G"))
c.Assert(err, gc.IsNil)
serviceCons := constraints.MustParse("cpu-cores=2")
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
Constraints: serviceCons,
NumUnits: 1,
ToMachineSpec: "0",
})
c.Assert(err, gc.IsNil)
s.assertConstraints(c, service, serviceCons)
s.assertMachines(c, service, constraints.Value{}, "0")
}
// ServiceDeploy fetches the charm from the charm store and deploys it.
// AddCharm or AddLocalCharm should be called to add the charm
// before calling ServiceDeploy, although for backward compatibility
// this is not necessary until 1.16 support is removed.
func (c *Client) ServiceDeploy(args params.ServiceDeploy) error {
curl, err := charm.ParseURL(args.CharmUrl)
if err != nil {
return err
}
if curl.Revision < 0 {
return fmt.Errorf("charm url must include revision")
}
// Try to find the charm URL in state first.
ch, err := c.api.state.Charm(curl)
if errors.IsNotFound(err) {
// Remove this whole if block when 1.16 compatibility is dropped.
if curl.Schema != "cs" {
return fmt.Errorf(`charm url has unsupported schema %q`, curl.Schema)
}
err = c.AddCharm(params.CharmURL{args.CharmUrl})
if err != nil {
return err
}
ch, err = c.api.state.Charm(curl)
if err != nil {
return err
}
} else if err != nil {
return err
}
var settings charm.Settings
if len(args.ConfigYAML) > 0 {
settings, err = ch.Config().ParseSettingsYAML([]byte(args.ConfigYAML), args.ServiceName)
} else if len(args.Config) > 0 {
// Parse config in a compatile way (see function comment).
settings, err = parseSettingsCompatible(ch, args.Config)
}
if err != nil {
return err
}
// Convert network tags to names for any given networks.
includeNetworks, err := networkTagsToNames(args.IncludeNetworks)
if err != nil {
return err
}
excludeNetworks, err := networkTagsToNames(args.ExcludeNetworks)
if err != nil {
return err
}
_, err = juju.DeployService(c.api.state,
juju.DeployServiceParams{
ServiceName: args.ServiceName,
ServiceOwner: c.api.auth.GetAuthTag(),
Charm: ch,
NumUnits: args.NumUnits,
ConfigSettings: settings,
Constraints: args.Constraints,
ToMachineSpec: args.ToMachineSpec,
IncludeNetworks: includeNetworks,
ExcludeNetworks: excludeNetworks,
})
return err
}