// assertSetSuccess sets configuration options and checks the expected settings.
func assertSetSuccess(c *gc.C, dir string, svc *state.Service, args []string, expect charm.Settings) {
ctx := coretesting.ContextForDir(c, dir)
code := cmd.Main(envcmd.Wrap(&SetCommand{}), ctx, append([]string{"dummy-service"}, args...))
c.Check(code, gc.Equals, 0)
settings, err := svc.ConfigSettings()
c.Assert(err, gc.IsNil)
c.Assert(settings, gc.DeepEquals, expect)
}
func (s *runSuite) addUnit(c *gc.C, service *state.Service) *state.Unit {
unit, err := service.AddUnit()
c.Assert(err, gc.IsNil)
err = unit.AssignToNewMachine()
c.Assert(err, gc.IsNil)
mId, err := unit.AssignedMachineId()
c.Assert(err, gc.IsNil)
machine, err := s.State.Machine(mId)
c.Assert(err, gc.IsNil)
machine.SetAddresses(instance.NewAddress("10.3.2.1", instance.NetworkUnknown))
return unit
}
// serviceSetSettingsStrings updates the settings for the given service,
// taking the configuration from a map of strings.
func serviceSetSettingsStrings(service *state.Service, settings map[string]string) error {
ch, _, err := service.Charm()
if err != nil {
return err
}
// Parse config in a compatible way (see function comment).
changes, err := parseSettingsCompatible(ch, settings)
if err != nil {
return err
}
return service.UpdateConfigSettings(changes)
}
func (s *HookContextSuite) AddUnit(c *gc.C, svc *state.Service) *state.Unit {
unit, err := svc.AddUnit()
c.Assert(err, gc.IsNil)
s.machine, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
err = unit.AssignToMachine(s.machine)
c.Assert(err, gc.IsNil)
name := strings.Replace(unit.Name(), "/", "-", 1)
privateAddr := instance.NewAddress(name+".testing.invalid", instance.NetworkCloudLocal)
err = s.machine.SetAddresses(privateAddr)
c.Assert(err, gc.IsNil)
return unit
}
// newServiceSetSettingsStringsForClientAPI updates the settings for the given
// service, taking the configuration from a map of strings.
//
// TODO(Nate): replace serviceSetSettingsStrings with this onces the GUI no
// longer expects to be able to unset values by sending an empty string.
func newServiceSetSettingsStringsForClientAPI(service *state.Service, settings map[string]string) error {
ch, _, err := service.Charm()
if err != nil {
return err
}
// Validate the settings.
changes, err := ch.Config().ParseSettingsStrings(settings)
if err != nil {
return err
}
return service.UpdateConfigSettings(changes)
}
// serviceSetCharm1dot16 sets the charm for the given service in 1.16
// compatibility mode. Remove this when support for 1.16 is dropped.
func (c *Client) serviceSetCharm1dot16(service *state.Service, curl *charm.URL, force bool) error {
if curl.Schema != "cs" {
return fmt.Errorf(`charm url has unsupported schema %q`, curl.Schema)
}
if curl.Revision < 0 {
return fmt.Errorf("charm url must include revision")
}
err := c.AddCharm(params.CharmURL{curl.String()})
if err != nil {
return err
}
ch, err := c.api.state.Charm(curl)
if err != nil {
return err
}
return service.SetCharm(ch, force)
}
// serviceSetCharm sets the charm for the given service.
func (c *Client) serviceSetCharm(service *state.Service, url string, force bool) error {
curl, err := charm.ParseURL(url)
if err != nil {
return err
}
sch, err := c.api.state.Charm(curl)
if errors.IsNotFound(err) {
// Charms should be added before trying to use them, with
// AddCharm or AddLocalCharm API calls. When they're not,
// we're reverting to 1.16 compatibility mode.
return c.serviceSetCharm1dot16(service, curl, force)
}
if err != nil {
return err
}
return service.SetCharm(sch, force)
}
func assertOneRelation(c *gc.C, srv *state.Service, relId int, endpoints ...state.Endpoint) *state.Relation {
rels, err := srv.Relations()
c.Assert(err, gc.IsNil)
c.Assert(rels, gc.HasLen, 1)
rel := rels[0]
c.Assert(rel.Id(), gc.Equals, relId)
c.Assert(rel.Endpoints(), jc.SameContents, endpoints)
name := srv.Name()
expectEp := endpoints[0]
ep, err := rel.Endpoint(name)
c.Assert(err, gc.IsNil)
c.Assert(ep, gc.DeepEquals, expectEp)
if len(endpoints) == 2 {
expectEp = endpoints[1]
}
eps, err := rel.RelatedEndpoints(name)
c.Assert(err, gc.IsNil)
c.Assert(eps, gc.DeepEquals, []state.Endpoint{expectEp})
return rel
}
func NewProReqRelation(c *gc.C, s *ConnSuite, scope charm.RelationScope) *ProReqRelation {
psvc := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
var rsvc *state.Service
if scope == charm.ScopeGlobal {
rsvc = s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress"))
} else {
rsvc = s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging"))
}
eps, err := s.State.InferEndpoints([]string{"mysql", rsvc.Name()})
c.Assert(err, gc.IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, gc.IsNil)
prr := &ProReqRelation{rel: rel, psvc: psvc, rsvc: rsvc}
prr.pu0, prr.pru0 = addRU(c, psvc, rel, nil)
prr.pu1, prr.pru1 = addRU(c, psvc, rel, nil)
if scope == charm.ScopeGlobal {
prr.ru0, prr.rru0 = addRU(c, rsvc, rel, nil)
prr.ru1, prr.rru1 = addRU(c, rsvc, rel, nil)
} else {
prr.ru0, prr.rru0 = addRU(c, rsvc, rel, prr.pu0)
prr.ru1, prr.rru1 = addRU(c, rsvc, rel, prr.pu1)
}
return prr
}
// serviceSetSettingsYAML updates the settings for the given service,
// taking the configuration from a YAML string.
func serviceSetSettingsYAML(service *state.Service, settings string) error {
ch, _, err := service.Charm()
if err != nil {
return err
}
changes, err := ch.Config().ParseSettingsYAML([]byte(settings), service.Name())
if err != nil {
return err
}
return service.UpdateConfigSettings(changes)
}
func addRU(c *gc.C, svc *state.Service, rel *state.Relation, principal *state.Unit) (*state.Unit, *state.RelationUnit) {
// Given the service svc in the relation rel, add a unit of svc and create
// a RelationUnit with rel. If principal is supplied, svc is assumed to be
// subordinate and the unit will be created by temporarily entering the
// relation's scope as the principal.
var u *state.Unit
if principal == nil {
unit, err := svc.AddUnit()
c.Assert(err, gc.IsNil)
u = unit
} else {
origUnits, err := svc.AllUnits()
c.Assert(err, gc.IsNil)
pru, err := rel.Unit(principal)
c.Assert(err, gc.IsNil)
err = pru.EnterScope(nil) // to create the subordinate
c.Assert(err, gc.IsNil)
err = pru.LeaveScope() // to reset to initial expected state
c.Assert(err, gc.IsNil)
newUnits, err := svc.AllUnits()
c.Assert(err, gc.IsNil)
for _, unit := range newUnits {
found := false
for _, old := range origUnits {
if unit.Name() == old.Name() {
found = true
break
}
}
if !found {
u = unit
break
}
}
c.Assert(u, gc.NotNil)
}
preventUnitDestroyRemove(c, u)
ru, err := rel.Unit(u)
c.Assert(err, gc.IsNil)
return u, ru
}
func assertNoRelations(c *gc.C, srv *state.Service) {
rels, err := srv.Relations()
c.Assert(err, gc.IsNil)
c.Assert(rels, gc.HasLen, 0)
}
func (s *SSHCommonSuite) addUnit(srv *state.Service, m *state.Machine, c *gc.C) {
u, err := srv.AddUnit()
c.Assert(err, gc.IsNil)
err = u.AssignToMachine(m)
c.Assert(err, gc.IsNil)
}
func assertAllUnits(c *gc.C, service *state.Service, expected int) {
units, err := service.AllUnits()
c.Assert(err, gc.IsNil)
c.Assert(units, gc.HasLen, expected)
}