func leadershipSettingsAccessorFactory(
st *state.State,
resources *common.Resources,
auth common.Authorizer,
) *leadershipapiserver.LeadershipSettingsAccessor {
registerWatcher := func(serviceId string) (string, error) {
settingsWatcher := st.WatchLeadershipSettings(serviceId)
if _, ok := <-settingsWatcher.Changes(); ok {
return resources.Register(settingsWatcher), nil
}
return "", watcher.EnsureErr(settingsWatcher)
}
// TODO(katco-): <2015-01-21 Wed>
// Due to time constraints, we're translating between
// map[string]interface{} and map[string]string. At some point we
// should support a native read of this format straight from
// state.
getSettings := func(serviceId string) (map[string]string, error) {
settings, err := st.ReadLeadershipSettings(serviceId)
if err != nil {
return nil, err
}
// Perform the conversion
rawMap := settings.Map()
leadershipSettings := make(map[string]string)
for k, v := range rawMap {
leadershipSettings[k] = v.(string)
}
return leadershipSettings, nil
}
writeSettings := func(serviceId string, settings map[string]string) error {
currentSettings, err := st.ReadLeadershipSettings(serviceId)
if err != nil {
return err
}
rawSettings := make(map[string]interface{})
for k, v := range settings {
rawSettings[k] = v
}
currentSettings.Update(rawSettings)
_, err = currentSettings.Write()
return errors.Annotate(err, "could not write changes")
}
ldrMgr := leadership.NewLeadershipManager(lease.Manager())
return leadershipapiserver.NewLeadershipSettingsAccessor(
auth,
registerWatcher,
getSettings,
writeSettings,
ldrMgr.Leader,
)
}
func (s *settingsSuite) TestBlockUntilChanges(c *gc.C) {
numSettingsWatcherCalls := 0
registerWatcher := func(serviceId string) (string, error) {
numSettingsWatcherCalls++
c.Check(serviceId, gc.Equals, StubServiceNm)
return "foo", nil
}
authorizer := &stubAuthorizer{tag: names.NewUnitTag(StubUnitNm)}
accessor := leadership.NewLeadershipSettingsAccessor(authorizer, registerWatcher, nil, nil, nil)
results, err := accessor.WatchLeadershipSettings(params.Entities{[]params.Entity{
{names.NewServiceTag(StubServiceNm).String()},
}})
c.Assert(err, gc.IsNil)
c.Assert(results.Results, gc.HasLen, 1)
c.Assert(results.Results[0].Error, gc.IsNil)
}
func (s *settingsSuite) TestWriteSettingsError(c *gc.C) {
expectToken := &fakeToken{}
numLeaderCheckCalls := 0
leaderCheck := func(serviceId, unitId string) coreleadership.Token {
numLeaderCheckCalls++
c.Check(serviceId, gc.Equals, StubServiceNm)
c.Check(unitId, gc.Equals, StubUnitNm)
return expectToken
}
numWriteSettingCalls := 0
writeSettings := func(token coreleadership.Token, serviceId string, settings map[string]string) error {
numWriteSettingCalls++
c.Check(serviceId, gc.Equals, StubServiceNm)
c.Check(token, gc.Equals, expectToken)
c.Check(settings, jc.DeepEquals, map[string]string{"baz": "biz"})
return errors.New("zap blort")
}
authorizer := stubAuthorizer{tag: names.NewUnitTag(StubUnitNm)}
accessor := leadership.NewLeadershipSettingsAccessor(authorizer, nil, nil, leaderCheck, writeSettings)
results, err := accessor.Merge(params.MergeLeadershipSettingsBulkParams{
[]params.MergeLeadershipSettingsParam{
{
ServiceTag: names.NewServiceTag(StubServiceNm).String(),
Settings: map[string]string{"baz": "biz"},
},
},
})
c.Assert(err, gc.IsNil)
c.Assert(results.Results, gc.HasLen, 1)
c.Check(results.Results[0].Error, gc.ErrorMatches, "zap blort")
c.Check(numWriteSettingCalls, gc.Equals, 1)
c.Check(numLeaderCheckCalls, gc.Equals, 1)
}
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,
)
}
func (s *settingsSuite) TestReadSettings(c *gc.C) {
settingsToReturn := params.Settings(map[string]string{"foo": "bar"})
numGetSettingCalls := 0
getSettings := func(serviceId string) (map[string]string, error) {
numGetSettingCalls++
c.Check(serviceId, gc.Equals, StubServiceNm)
return settingsToReturn, nil
}
authorizer := stubAuthorizer{tag: names.NewUnitTag(StubUnitNm)}
accessor := leadership.NewLeadershipSettingsAccessor(authorizer, nil, getSettings, nil, nil)
results, err := accessor.Read(params.Entities{
[]params.Entity{
{Tag: names.NewServiceTag(StubServiceNm).String()},
},
})
c.Assert(err, gc.IsNil)
c.Assert(numGetSettingCalls, gc.Equals, 1)
c.Assert(results.Results, gc.HasLen, 1)
c.Assert(results.Results[0].Error, gc.IsNil)
c.Check(results.Results[0].Settings, gc.DeepEquals, settingsToReturn)
}