# ClaimLeadership

api/leadership/client.go|31| <<ClaimLeadership>>  func (c *client) ClaimLeadership(serviceId, unitId string, duration time.Duration) error {
api/leadership/client_test.go|73| <<TestClaimLeadershipTranslation>>  err := client.ClaimLeadership(StubServiceNm, StubUnitNm, claimTime)
api/leadership/client_test.go|96| <<TestClaimLeadershipDeniedError>>  err := client.ClaimLeadership(StubServiceNm, StubUnitNm, 0)
api/leadership/client_test.go|119| <<TestClaimLeadershipUnknownError>>  err := client.ClaimLeadership(StubServiceNm, StubUnitNm, 0)
api/leadership/client_test.go|133| <<TestClaimLeadershipFacadeCallError>>  err := client.ClaimLeadership(StubServiceNm, StubUnitNm, 0)
api/uniter/application_test.go|179| <<claimLeadership>>  err := claimer.ClaimLeadership(service.Name(), unit.Name(), time.Minute)
apiserver/client/status_test.go|63| <<TestFullStatusUnitLeadership>>  s.State.LeadershipClaimer().ClaimLeadership(u.ApplicationName(), u.Name(), time.Minute)
apiserver/common/getstatus_test.go|215| <<TestGetUnitStatusIsLeader>>  s.State.LeadershipClaimer().ClaimLeadership(
apiserver/common/setstatus_test.go|246| <<TestSetUnitStatusIsLeader>>  s.State.LeadershipClaimer().ClaimLeadership(
apiserver/leadership/interface.go|17| <<->>  ClaimLeadership(params params.ClaimLeadershipBulkParams) (params.ClaimLeadershipBulkResults, error)
apiserver/leadership/leadership.go|73| <<ClaimLeadership>>  func (m *leadershipService) ClaimLeadership(args params.ClaimLeadershipBulkParams) (params.ClaimLeadershipBulkResults, error) {
apiserver/leadership/leadership.go|98| <<ClaimLeadership>>  err = m.claimer.ClaimLeadership(ApplicationTag.Id(), unitTag.Id(), duration)
apiserver/leadership/leadership_test.go|43| <<ClaimLeadership>>  func (m *stubClaimer) ClaimLeadership(sid, uid string, duration time.Duration) error {
apiserver/leadership/leadership_test.go|105| <<TestClaimLeadershipTranslation>>  results, err := ldrSvc.ClaimLeadership(params.ClaimLeadershipBulkParams{
apiserver/leadership/leadership_test.go|132| <<TestClaimLeadershipDeniedError>>  results, err := ldrSvc.ClaimLeadership(params.ClaimLeadershipBulkParams{
apiserver/leadership/leadership_test.go|150| <<TestClaimLeadershipBadService>>  results, err := ldrSvc.ClaimLeadership(params.ClaimLeadershipBulkParams{
apiserver/leadership/leadership_test.go|167| <<TestClaimLeadershipBadUnit>>  results, err := ldrSvc.ClaimLeadership(params.ClaimLeadershipBulkParams{
apiserver/leadership/leadership_test.go|184| <<TestClaimLeadershipDurationTooShort>>  results, err := ldrSvc.ClaimLeadership(params.ClaimLeadershipBulkParams{
apiserver/leadership/leadership_test.go|201| <<TestClaimLeadershipDurationTooLong>>  results, err := ldrSvc.ClaimLeadership(params.ClaimLeadershipBulkParams{
apiserver/leadership/leadership_test.go|236| <<TestClaimLeadershipFailBadUnit>>  results, err := ldrSvc.ClaimLeadership(params.ClaimLeadershipBulkParams{
apiserver/leadership/leadership_test.go|254| <<TestClaimLeadershipFailBadService>>  results, err := ldrSvc.ClaimLeadership(params.ClaimLeadershipBulkParams{
core/leadership/interface.go|29| <<->>  ClaimLeadership(applicationId, unitId string, duration time.Duration) error
state/leadership.go|123| <<ClaimLeadership>>  func (m leadershipClaimer) ClaimLeadership(applicationname, unitName string, duration time.Duration) error {
state/migration_export_test.go|92| <<makeApplicationWithLeader>>  err := s.State.LeadershipClaimer().ClaimLeadership(
state/migration_import.go|748| <<application>> if err := i.st.LeadershipClaimer().ClaimLeadership(
state/state_leader_test.go|35| <<TestClaimValidatesApplicationname>>  err := s.claimer.ClaimLeadership("not/a/service", "u/0", time.Minute)
state/state_leader_test.go|41| <<TestClaimValidatesUnitName>>  err := s.claimer.ClaimLeadership("application", "not/a/unit", time.Minute)
state/state_leader_test.go|47| <<TestClaimValidateDuration>>  err := s.claimer.ClaimLeadership("application", "u/0", 0)
state/state_leader_test.go|75| <<TestClaimExpire>>  err := s.claimer.ClaimLeadership("application", "application/0", time.Minute)
state/state_leader_test.go|79| <<TestClaimExpire>>  err = s.claimer.ClaimLeadership("application", "service/1", time.Minute)
state/state_leader_test.go|86| <<TestClaimExpire>>  err = s.claimer.ClaimLeadership("application", "service/1", time.Minute)
state/state_leader_test.go|96| <<TestCheck>>  err := s.claimer.ClaimLeadership("application", "application/0", time.Minute)
state/state_leader_test.go|116| <<TestKillWorkersUnblocksClaimer>>  err := s.claimer.ClaimLeadership("blah", "blah/0", time.Minute)
state/state_leader_test.go|130| <<TestApplicationLeaders>>  err := s.claimer.ClaimLeadership("blah", "blah/0", time.Minute)
state/state_leader_test.go|132| <<TestApplicationLeaders>>  err = s.claimer.ClaimLeadership("application", "application/1", time.Minute)
worker/leadership/tracker.go|171| <<refresh>>  err := t.claimer.ClaimLeadership(t.applicationName, t.unitName, leaseDuration)
worker/leadership/util_test.go|20| <<ClaimLeadership>>  func (stub *StubClaimer) ClaimLeadership(serviceName, unitName string, duration time.Duration) error {
worker/uniter/util_test.go|1615| <<setLeader>>  err := mock.ctx.leaderClaimer.ClaimLeadership(

# present in worker/leadership/tracker.go

# nothing related per jujuc

juju/juju/worker/uniter/runner/jujuc

➜  jujuc git:(staging) ✗ grep -RiP 'leader'
context.go:	ContextLeadership
context.go:// ContextLeadership is the part of a hook context related to the
context.go:// unit leadership.
context.go:type ContextLeadership interface {
context.go:	// IsLeader returns true if the local unit is known to be leader for at
context.go:	IsLeader() (bool, error)
context.go:	// LeaderSettings returns the current leader settings. Once leader settings
context.go:	// via successful calls to WriteLeaderSettings.
context.go:	LeaderSettings() (map[string]string, error)
context.go:	// WriteLeaderSettings writes the supplied settings directly to state, or
context.go:	// fails if the local unit is not the service's leader.
context.go:	WriteLeaderSettings(map[string]string) error
is-leader.go:// isLeaderCommand implements the is-leader command.
is-leader.go:type isLeaderCommand struct {
is-leader.go:// NewIsLeaderCommand returns a new isLeaderCommand with the given context.
is-leader.go:func NewIsLeaderCommand(ctx Context) (cmd.Command, error) {
is-leader.go:	return &isLeaderCommand{ctx: ctx}, nil
is-leader.go:func (c *isLeaderCommand) Info() *cmd.Info {
is-leader.go:is-leader prints a boolean indicating whether the local unit is guaranteed to
is-leader.go:be application leader for at least 30 seconds. If it fails, you should assume that
is-leader.go:		Name:    "is-leader",
is-leader.go:		Purpose: "print application leadership status",
is-leader.go:func (c *isLeaderCommand) SetFlags(f *gnuflag.FlagSet) {
is-leader.go:func (c *isLeaderCommand) Run(ctx *cmd.Context) error {
is-leader.go:	success, err := c.ctx.IsLeader()
is-leader.go:		return errors.Annotatef(err, "leadership status unknown")
is-leader_test.go:type isLeaderSuite struct {
is-leader_test.go:var _ = gc.Suite(&isLeaderSuite{})
is-leader_test.go:func (s *isLeaderSuite) TestInitError(c *gc.C) {
is-leader_test.go:	command, err := jujuc.NewIsLeaderCommand(nil)
is-leader_test.go:func (s *isLeaderSuite) TestInitSuccess(c *gc.C) {
is-leader_test.go:	command, err := jujuc.NewIsLeaderCommand(nil)
is-leader_test.go:func (s *isLeaderSuite) TestFormatError(c *gc.C) {
is-leader_test.go:	command, err := jujuc.NewIsLeaderCommand(nil)
is-leader_test.go:func (s *isLeaderSuite) TestIsLeaderError(c *gc.C) {
is-leader_test.go:	jujucContext := &isLeaderContext{err: errors.New("pow")}
is-leader_test.go:	command, err := jujuc.NewIsLeaderCommand(jujucContext)
is-leader_test.go:	c.Check(bufferString(runContext.Stderr), gc.Equals, "error: leadership status unknown: pow\n")
is-leader_test.go:func (s *isLeaderSuite) TestFormatDefaultYes(c *gc.C) {
is-leader_test.go:func (s *isLeaderSuite) TestFormatDefaultNo(c *gc.C) {
is-leader_test.go:func (s *isLeaderSuite) TestFormatSmartYes(c *gc.C) {
is-leader_test.go:func (s *isLeaderSuite) TestFormatSmartNo(c *gc.C) {
is-leader_test.go:func (s *isLeaderSuite) TestFormatYamlYes(c *gc.C) {
is-leader_test.go:func (s *isLeaderSuite) TestFormatYamlNo(c *gc.C) {
is-leader_test.go:func (s *isLeaderSuite) TestFormatJsonYes(c *gc.C) {
is-leader_test.go:func (s *isLeaderSuite) TestFormatJsonNo(c *gc.C) {
is-leader_test.go:func (s *isLeaderSuite) testOutput(c *gc.C, leader bool, args []string, expect string) {
is-leader_test.go:	jujucContext := &isLeaderContext{leader: leader}
is-leader_test.go:	command, err := jujuc.NewIsLeaderCommand(jujucContext)
is-leader_test.go:func (s *isLeaderSuite) testParseOutput(c *gc.C, leader bool, args []string, checker gc.Checker) {
is-leader_test.go:	jujucContext := &isLeaderContext{leader: leader}
is-leader_test.go:	command, err := jujuc.NewIsLeaderCommand(jujucContext)
is-leader_test.go:	c.Check(bufferString(runContext.Stdout), checker, leader)
is-leader_test.go:type isLeaderContext struct {
is-leader_test.go:	leader bool
is-leader_test.go:func (ctx *isLeaderContext) IsLeader() (bool, error) {
is-leader_test.go:	return ctx.leader, ctx.err
leader-get.go:// leaderGetCommand implements the leader-get command.
leader-get.go:type leaderGetCommand struct {
leader-get.go:// NewLeaderGetCommand returns a new leaderGetCommand with the given context.
leader-get.go:func NewLeaderGetCommand(ctx Context) (cmd.Command, error) {
leader-get.go:	return &leaderGetCommand{ctx: ctx}, nil
leader-get.go:func (c *leaderGetCommand) Info() *cmd.Info {
leader-get.go:leader-get prints the value of a leadership setting specified by key. If no key
leader-get.go:		Name:    "leader-get",
leader-get.go:		Purpose: "print application leadership settings",
leader-get.go:func (c *leaderGetCommand) SetFlags(f *gnuflag.FlagSet) {
leader-get.go:func (c *leaderGetCommand) Init(args []string) error {
leader-get.go:func (c *leaderGetCommand) Run(ctx *cmd.Context) error {
leader-get.go:	settings, err := c.ctx.LeaderSettings()
leader-get.go:		return errors.Annotatef(err, "cannot read leadership settings")
leader-get_test.go:type leaderGetSuite struct {
leader-get_test.go:var _ = gc.Suite(&leaderGetSuite{})
leader-get_test.go:func (s *leaderGetSuite) SetUpTest(c *gc.C) {
leader-get_test.go:	s.command, err = jujuc.NewLeaderGetCommand(nil)
leader-get_test.go:func (s *leaderGetSuite) TestInitError(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestInitKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestInitAll(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestInitEmpty(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestFormatError(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsError(c *gc.C) {
leader-get_test.go:	jujucContext := newLeaderGetContext(errors.New("zap"))
leader-get_test.go:	command, err := jujuc.NewLeaderGetCommand(jujucContext)
leader-get_test.go:	c.Check(bufferString(runContext.Stderr), gc.Equals, "error: cannot read leadership settings: zap\n")
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatDefaultMissingKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatDefaultKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatDefaultAll(c *gc.C) {
leader-get_test.go:	s.testParseOutput(c, []string{"-"}, jc.YAMLEquals, leaderGetSettings())
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatDefaultEmpty(c *gc.C) {
leader-get_test.go:	s.testParseOutput(c, nil, jc.YAMLEquals, leaderGetSettings())
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatSmartMissingKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatSmartKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatSmartAll(c *gc.C) {
leader-get_test.go:	s.testParseOutput(c, []string{"--format", "smart", "-"}, jc.YAMLEquals, leaderGetSettings())
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatSmartEmpty(c *gc.C) {
leader-get_test.go:	s.testParseOutput(c, []string{"--format", "smart"}, jc.YAMLEquals, leaderGetSettings())
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatJSONMissingKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatJSONKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatJSONAll(c *gc.C) {
leader-get_test.go:	s.testParseOutput(c, []string{"--format", "json", "-"}, jc.JSONEquals, leaderGetSettings())
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatJSONEmpty(c *gc.C) {
leader-get_test.go:	s.testParseOutput(c, []string{"--format", "json"}, jc.JSONEquals, leaderGetSettings())
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatYAMLMissingKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatYAMLKey(c *gc.C) {
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatYAMLAll(c *gc.C) {
leader-get_test.go:	s.testParseOutput(c, []string{"--format", "yaml", "-"}, jc.YAMLEquals, leaderGetSettings())
leader-get_test.go:func (s *leaderGetSuite) TestSettingsFormatYAMLEmpty(c *gc.C) {
leader-get_test.go:	s.testParseOutput(c, []string{"--format", "yaml"}, jc.YAMLEquals, leaderGetSettings())
leader-get_test.go:func (s *leaderGetSuite) testOutput(c *gc.C, args []string, expect string) {
leader-get_test.go:func (s *leaderGetSuite) testParseOutput(c *gc.C, args []string, checker gc.Checker, expect interface{}) {
leader-get_test.go:	jujucContext := newLeaderGetContext(nil)
leader-get_test.go:	command, err := jujuc.NewLeaderGetCommand(jujucContext)
leader-get_test.go:func leaderGetSettings() map[string]string {
leader-get_test.go:func newLeaderGetContext(err error) *leaderGetContext {
leader-get_test.go:		return &leaderGetContext{err: err}
leader-get_test.go:	return &leaderGetContext{settings: leaderGetSettings()}
leader-get_test.go:type leaderGetContext struct {
leader-get_test.go:func (c *leaderGetContext) LeaderSettings() (map[string]string, error) {
leader-set.go:// leaderSetCommand implements the leader-set command.
leader-set.go:type leaderSetCommand struct {
leader-set.go:// NewLeaderSetCommand returns a new leaderSetCommand with the given context.
leader-set.go:func NewLeaderSetCommand(ctx Context) (cmd.Command, error) {
leader-set.go:	return &leaderSetCommand{ctx: ctx}, nil
leader-set.go:func (c *leaderSetCommand) Info() *cmd.Info {
leader-set.go:leader-set immediate writes the supplied key/value pairs to the controller,
leader-set.go:which will then inform non-leader units of the change. It will fail if called
leader-set.go:without arguments, or if called by a unit that is not currently application leader.
leader-set.go:		Name:    "leader-set",
leader-set.go:		Purpose: "write application leadership settings",
leader-set.go:func (c *leaderSetCommand) Init(args []string) (err error) {
leader-set.go:func (c *leaderSetCommand) Run(_ *cmd.Context) error {
leader-set.go:	err := c.ctx.WriteLeaderSettings(c.settings)
leader-set.go:	return errors.Annotatef(err, "cannot write leadership settings")
leader-set_test.go:type leaderSetSuite struct {
leader-set_test.go:var _ = gc.Suite(&leaderSetSuite{})
leader-set_test.go:func (s *leaderSetSuite) SetUpTest(c *gc.C) {
leader-set_test.go:	s.command, err = jujuc.NewLeaderSetCommand(nil)
leader-set_test.go:func (s *leaderSetSuite) TestInitEmpty(c *gc.C) {
leader-set_test.go:func (s *leaderSetSuite) TestInitValues(c *gc.C) {
leader-set_test.go:func (s *leaderSetSuite) TestInitError(c *gc.C) {
leader-set_test.go:func (s *leaderSetSuite) TestWriteEmpty(c *gc.C) {
leader-set_test.go:	jujucContext := &leaderSetContext{}
leader-set_test.go:	command, err := jujuc.NewLeaderSetCommand(jujucContext)
leader-set_test.go:func (s *leaderSetSuite) TestWriteValues(c *gc.C) {
leader-set_test.go:	jujucContext := &leaderSetContext{}
leader-set_test.go:	command, err := jujuc.NewLeaderSetCommand(jujucContext)
leader-set_test.go:func (s *leaderSetSuite) TestWriteError(c *gc.C) {
leader-set_test.go:	jujucContext := &leaderSetContext{err: errors.New("splat")}
leader-set_test.go:	command, err := jujuc.NewLeaderSetCommand(jujucContext)
leader-set_test.go:	c.Check(bufferString(runContext.Stderr), gc.Equals, "error: cannot write leadership settings: splat\n")
leader-set_test.go:type leaderSetContext struct {
leader-set_test.go:func (s *leaderSetContext) WriteLeaderSettings(settings map[string]string) error {
restricted.go:// IsLeader implements jujuc.Context.
restricted.go:func (*RestrictedContext) IsLeader() (bool, error) { return false, ErrRestrictedContext }
restricted.go:// LeaderSettings implements jujuc.Context.
restricted.go:func (*RestrictedContext) LeaderSettings() (map[string]string, error) {
restricted.go:// WriteLeaderSettings implements jujuc.Context.
restricted.go:func (*RestrictedContext) WriteLeaderSettings(map[string]string) error { return ErrRestrictedContext }
server.go:var leaderCommands = map[string]creator{
server.go:	"is-leader" + cmdSuffix:  NewIsLeaderCommand,
server.go:	"leader-get" + cmdSuffix: NewLeaderGetCommand,
server.go:	"leader-set" + cmdSuffix: NewLeaderSetCommand,
server.go:	add(leaderCommands)
status-get.go:	f.BoolVar(&c.serviceWide, "application", false, "print status for all units of this application if this unit is the leader")
status-get_test.go:		"    print status for all units of this application if this unit is the leader\n" +
status-set.go:	f.BoolVar(&c.service, "application", false, "set this status for the application to which the unit belongs if the unit is the leader")
status-set.go:	f.BoolVar(&c.service, "service", false, "set this status for the application to which the unit belongs if the unit is the leader")
status-set_test.go:		"    set this status for the application to which the unit belongs if the unit is the leader\n" +
testing/context.go:	Leadership
testing/context.go:	ContextLeader
testing/context.go:	ctx.ContextLeader.stub = stub
testing/context.go:	ctx.ContextLeader.info = &info.Leadership
testing/leadership.go:// Leadership holds the values for the hook context.
testing/leadership.go:type Leadership struct {
testing/leadership.go:	IsLeader       bool
testing/leadership.go:	LeaderSettings map[string]string
testing/leadership.go:// ContextLeader is a test double for jujuc.ContextLeader.
testing/leadership.go:type ContextLeader struct {
testing/leadership.go:	info *Leadership
testing/leadership.go:// IsLeader implements jujuc.ContextLeader.
testing/leadership.go:func (c *ContextLeader) IsLeader() (bool, error) {
testing/leadership.go:	c.stub.AddCall("IsLeader")
testing/leadership.go:	return c.info.IsLeader, nil
testing/leadership.go:// LeaderSettings implements jujuc.ContextLeader.
testing/leadership.go:func (c *ContextLeader) LeaderSettings() (map[string]string, error) {
testing/leadership.go:	c.stub.AddCall("LeaderSettings")
testing/leadership.go:	return c.info.LeaderSettings, nil
testing/leadership.go:// WriteLeaderSettings implements jujuc.ContextLeader.
testing/leadership.go:func (c *ContextLeader) WriteLeaderSettings(settings map[string]string) error {
testing/leadership.go:	c.stub.AddCall("WriteLeaderSettings")
testing/leadership.go:	c.info.LeaderSettings = settings