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
}
func AssertPrincipalServiceDeployed(c *gc.C, st *state.State, serviceName string, curl *charm.URL, forced bool, bundle charm.Charm, cons constraints.Value) *state.Application {
service, err := st.Application(serviceName)
c.Assert(err, jc.ErrorIsNil)
charm, force, err := service.Charm()
c.Assert(err, jc.ErrorIsNil)
c.Assert(force, gc.Equals, forced)
c.Assert(charm.URL(), gc.DeepEquals, curl)
// When charms are read from state, storage properties are
// always deserialised as empty slices if empty or nil, so
// update bundle to match (bundle comes from parsing charm
// metadata yaml where nil means nil).
for name, bundleMeta := range bundle.Meta().Storage {
if bundleMeta.Properties == nil {
bundleMeta.Properties = []string{}
bundle.Meta().Storage[name] = bundleMeta
}
}
c.Assert(charm.Meta(), jc.DeepEquals, bundle.Meta())
c.Assert(charm.Config(), jc.DeepEquals, bundle.Config())
serviceCons, err := service.Constraints()
c.Assert(err, jc.ErrorIsNil)
c.Assert(serviceCons, gc.DeepEquals, cons)
for a := coretesting.LongAttempt.Start(); a.Next(); {
units, err := service.AllUnits()
c.Assert(err, jc.ErrorIsNil)
for _, unit := range units {
mid, err := unit.AssignedMachineId()
if !a.HasNext() {
c.Assert(err, jc.ErrorIsNil)
} else if err != nil {
continue
}
machine, err := st.Machine(mid)
c.Assert(err, jc.ErrorIsNil)
machineCons, err := machine.Constraints()
c.Assert(err, jc.ErrorIsNil)
c.Assert(machineCons, gc.DeepEquals, cons)
}
break
}
return service
}
// getAllUnitNames returns a sequence of valid Unit objects from state. If any
// of the service names or unit names are not found, an error is returned.
func getAllUnitNames(st *state.State, units, services []string) (result []names.Tag, err error) {
unitsSet := set.NewStrings(units...)
for _, name := range services {
service, err := st.Application(name)
if err != nil {
return nil, err
}
units, err := service.AllUnits()
if err != nil {
return nil, err
}
for _, unit := range units {
unitsSet.Add(unit.Name())
}
}
for _, unitName := range unitsSet.SortedValues() {
if !names.IsValidUnit(unitName) {
return nil, errors.Errorf("invalid unit name %q", unitName)
}
result = append(result, names.NewUnitTag(unitName))
}
return result, nil
}
func leadershipSettingsAccessorFactory(
st *state.State,
resources facade.Resources,
auth facade.Authorizer,
) *leadershipapiserver.LeadershipSettingsAccessor {
registerWatcher := func(serviceId string) (string, error) {
service, err := st.Application(serviceId)
if err != nil {
return "", err
}
w := service.WatchLeaderSettings()
if _, ok := <-w.Changes(); ok {
return resources.Register(w), nil
}
return "", watcher.EnsureErr(w)
}
getSettings := func(serviceId string) (map[string]string, error) {
service, err := st.Application(serviceId)
if err != nil {
return nil, err
}
return service.LeaderSettings()
}
writeSettings := func(token leadership.Token, serviceId string, settings map[string]string) error {
service, err := st.Application(serviceId)
if err != nil {
return err
}
return service.UpdateLeaderSettings(token, settings)
}
return leadershipapiserver.NewLeadershipSettingsAccessor(
auth,
registerWatcher,
getSettings,
st.LeadershipChecker().LeadershipCheck,
writeSettings,
)
}