# Class Leader

java.lang.Object
org.apache.zookeeper.server.quorum.LearnerMaster
org.apache.zookeeper.server.quorum.Leader

public class Leader extends LearnerMaster
This class has the control logic for the Leader.

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static class`
`Leader.Proposal`
`static class`
`Leader.PureRequestProposal`
`static class`
`Leader.XidRolloverException`

## Field Summary

Fields
Modifier and Type
Field
Description
`static final int`
`ACKEPOCH`
This message is used by the follow to ack a proposed epoch.
`protected final Set<Long>`
`connectingFollowers`
`protected final Set<Long>`
`electingFollowers`
`protected boolean`
`electionFinished`
`static final int`
`LEADERINFO`
This message is the first that a follower receives from the leader.
`static final String`
`MAX_TIME_TO_WAIT_FOR_EPOCH`
`protected final Leader.Proposal`
`newLeaderProposal`
`static final int`
`PROPOSAL`
This message type is sent by a leader to propose a mutation.
`protected boolean`
`quorumFormed`

## Constructor Summary

Constructors
Constructor
Description
`Leader(QuorumPeer self, LeaderZooKeeperServer zk)`

## Method Summary

Modifier and Type
Method
Description
`void`
`addLearnerHandler(LearnerHandler learner)`
Adds peer to the leader.
`static QuorumPacket`
`buildInformAndActivePacket(long zxid, long designatedLeader, byte[] proposalData)`
`void`
`commit(long zxid)`
Create a commit packet and send it to all the members of the quorum
`void`
`commitAndActivate(long zxid, long designatedLeader)`
`static int`
`getAckLoggingFrequency()`
`long`
`getAndDecrementFollowerCounter()`
`int`
`getCurrentTick()`
`long`
`getEpoch()`
Returns the current epoch of the leader.
`long`
`getEpochToPropose(long sid, long lastAcceptedEpoch)`
`List<LearnerHandler>`
`getForwardingFollowers()`
Returns a copy of the current forwarding follower snapshot
`long`
`getLastProposed()`
`List<LearnerHandler>`
`getLearners()`
Returns a copy of the current learner snapshot
`List<LearnerHandler>`
`getNonVotingFollowers()`
`int`
`getNumPendingSyncs()`
`List<LearnerHandler>`
`getObservingLearners()`
Returns a copy of the current observer snapshot
`Iterable<Map<String,Object>>`
`getObservingLearnersInfo()`
`static String`
`getPacketType(int packetType)`
Get string representation of a given packet type
`String`
`getPeerInfo(long sid)`
`BufferStats`
`getProposalStats()`
`QuorumAuthServer`
`getQuorumAuthServer()`
`byte[]`
`getQuorumVerifierBytes()`
`long`
`getQuorumVerifierVersion()`
`int`
`getTickOfInitialAckDeadline()`
`int`
`getTickOfNextAckDeadline()`
`long`
`getUptime()`
`ZKDatabase`
`getZKDatabase()`
`void`
`inform(Leader.Proposal proposal)`
Create an inform packet and send it to all observers.
`void`
`informAndActivate(Leader.Proposal proposal, long designatedLeader)`
Create an inform and activate packet and send it to all observers.
`boolean`
`isQuorumSynced(QuorumVerifier qv)`
Returns true if a quorum in qv is connected and synced with the leader and false otherwise
`void`
`processAck(long sid, long zxid, SocketAddress followerAddr)`
Keep a count of acks that are received by the leader for a particular proposal
`void`
`processSync(LearnerSyncRequest r)`
Process sync requests
`Leader.Proposal`
`propose(Request request)`
create a proposal and send it out to all the members
`void`
`registerLearnerHandlerBean(LearnerHandler learnerHandler, Socket socket)`
`void`
`removeLearnerHandler(LearnerHandler peer)`
Remove the learner from the learner list
`void`
`reportLookingSid(long sid)`
`void`
`resetObserverConnectionStats()`
`void`
`revalidateSession(QuorumPacket qp, LearnerHandler learnerHandler)`
`void`
`sendSync(LearnerSyncRequest r)`
Sends a sync message to the appropriate server
`static void`
`setAckLoggingFrequency(int frequency)`
`void`
`setLeadingVoteSet(SyncedLearnerTracker voteSet)`
`static void`
`setMaxTimeToWaitForEpoch(int maxTimeToWaitForEpoch)`
`long`
`startForwarding(LearnerHandler handler, long lastSeenZxid)`
lets the leader know that a follower is capable of following and is done syncing
`void`
`submitLearnerRequest(Request si)`
`int`
`syncTimeout()`
`void`
`touch(long sess, int to)`
`boolean`
`tryToCommit(Leader.Proposal p, long zxid, SocketAddress followerAddr)`
`void`
`unregisterLearnerHandlerBean(LearnerHandler learnerHandler)`
`void`
`waitForEpochAck(long id, StateSummary ss)`
`void`
`waitForNewLeaderAck(long sid, long zxid)`
Process NEWLEADER ack of a given sid and wait until the leader receives sufficient acks.
`void`
`waitForStartup()`

### Methods inherited from class LearnerMaster

`getLearnerDiffSyncThrottler, getLearnerSnapSyncThrottler, getMaxConcurrentDiffSyncs, getMaxConcurrentSnapSyncs, setMaxConcurrentDiffSyncs, setMaxConcurrentSnapSyncs`

### Methods inherited from class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### quorumFormed

protected boolean quorumFormed

### LEADERINFO

public static final int LEADERINFO
This message is the first that a follower receives from the leader. It has the protocol version and the epoch of the leader.

See Also:
  - Constant Field Values

### ACKEPOCH

public static final int ACKEPOCH
This message is used by the follow to ack a proposed epoch.

See Also:
  - Constant Field Values

### PROPOSAL

public static final int PROPOSAL
This message type is sent by a leader to propose a mutation.

See Also:
  - Constant Field Values

### newLeaderProposal

protected final Leader.Proposal newLeaderProposal

### connectingFollowers

protected final Set<Long> connectingFollowers

### MAX_TIME_TO_WAIT_FOR_EPOCH

public static final String MAX_TIME_TO_WAIT_FOR_EPOCH

See Also:
  - Constant Field Values

### electingFollowers

protected final Set<Long> electingFollowers

### electionFinished

protected boolean electionFinished

## Constructor Details

### Leader

public Leader(QuorumPeer self, LeaderZooKeeperServer zk) throws IOException

Throws:
  `IOException`

## Method Details

### setAckLoggingFrequency

public static void setAckLoggingFrequency(int frequency)

### getAckLoggingFrequency

public static int getAckLoggingFrequency()

### getProposalStats

public BufferStats getProposalStats()

### getLearners

public List<LearnerHandler> getLearners()
Returns a copy of the current learner snapshot

### getForwardingFollowers

public List<LearnerHandler> getForwardingFollowers()
Returns a copy of the current forwarding follower snapshot

### getNonVotingFollowers

public List<LearnerHandler> getNonVotingFollowers()

### getObservingLearners

public List<LearnerHandler> getObservingLearners()
Returns a copy of the current observer snapshot

### getObservingLearnersInfo

public Iterable<Map<String,Object>> getObservingLearnersInfo()

### resetObserverConnectionStats

public void resetObserverConnectionStats()

### getNumPendingSyncs

public int getNumPendingSyncs()

### addLearnerHandler

public void addLearnerHandler(LearnerHandler learner)
Adds peer to the leader.

Parameters:
  `learner` - instance of learner handle

### removeLearnerHandler

public void removeLearnerHandler(LearnerHandler peer)
Remove the learner from the learner list

Parameters:
  `peer` -

### isQuorumSynced

public boolean isQuorumSynced(QuorumVerifier qv)
Returns true if a quorum in qv is connected and synced with the leader and false otherwise

Parameters:
  `qv` - is a QuorumVerifier

### getUptime

public long getUptime()

### tryToCommit

public boolean tryToCommit(Leader.Proposal p, long zxid, SocketAddress followerAddr)

Returns:
  True if committed, otherwise false.

### processAck

public void processAck(long sid, long zxid, SocketAddress followerAddr)
Keep a count of acks that are received by the leader for a particular proposal

Parameters:
  `sid` - is the id of the server that sent the ack
  `zxid` - is the zxid of the proposal sent out
  `followerAddr` -

### commit

public void commit(long zxid)
Create a commit packet and send it to all the members of the quorum

Parameters:
  `zxid` -

### commitAndActivate

public void commitAndActivate(long zxid, long designatedLeader)

### inform

public void inform(Leader.Proposal proposal)
Create an inform packet and send it to all observers.

### buildInformAndActivePacket

public static QuorumPacket buildInformAndActivePacket(long zxid, long designatedLeader, byte[] proposalData)

### informAndActivate

public void informAndActivate(Leader.Proposal proposal, long designatedLeader)
Create an inform and activate packet and send it to all observers.

### getLastProposed

public long getLastProposed()

### getEpoch

public long getEpoch()
Returns the current epoch of the leader.

### propose

public Leader.Proposal propose(Request request) throws Leader.XidRolloverException
create a proposal and send it out to all the members

Parameters:
  `request` -
Returns:
  the proposal that is queued to send to all the members
Throws:
  `Leader.XidRolloverException`

### processSync

public void processSync(LearnerSyncRequest r)
Process sync requests

Parameters:
  `r` - the request

### sendSync

public void sendSync(LearnerSyncRequest r)
Sends a sync message to the appropriate server

### startForwarding

public long startForwarding(LearnerHandler handler, long lastSeenZxid)
lets the leader know that a follower is capable of following and is done syncing

Parameters:
  `handler` - handler of the follower
Returns:
  last proposed zxid

### waitForStartup

public void waitForStartup() throws InterruptedException

Throws:
  `InterruptedException`

### setMaxTimeToWaitForEpoch

public static void setMaxTimeToWaitForEpoch(int maxTimeToWaitForEpoch)

### setLeadingVoteSet

public void setLeadingVoteSet(SyncedLearnerTracker voteSet)

### reportLookingSid

public void reportLookingSid(long sid)

### getEpochToPropose

public long getEpochToPropose(long sid, long lastAcceptedEpoch) throws InterruptedException, IOException

Throws:
  `InterruptedException`
  `IOException`

### getZKDatabase

public ZKDatabase getZKDatabase()

### waitForEpochAck

public void waitForEpochAck(long id, StateSummary ss) throws IOException, InterruptedException

Throws:
  `IOException`
  `InterruptedException`

### waitForNewLeaderAck

public void waitForNewLeaderAck(long sid, long zxid) throws InterruptedException
Process NEWLEADER ack of a given sid and wait until the leader receives sufficient acks.

Parameters:
  `sid` -
Throws:
  `InterruptedException`

### getPacketType

public static String getPacketType(int packetType)
Get string representation of a given packet type

Parameters:
  `packetType` -
Returns:
  string representing the packet type

### getCurrentTick

public int getCurrentTick()

### syncTimeout

public int syncTimeout()

### getTickOfNextAckDeadline

public int getTickOfNextAckDeadline()

### getTickOfInitialAckDeadline

public int getTickOfInitialAckDeadline()

### getAndDecrementFollowerCounter

public long getAndDecrementFollowerCounter()

### touch

public void touch(long sess, int to)

### submitLearnerRequest

public void submitLearnerRequest(Request si)

### getQuorumVerifierVersion

public long getQuorumVerifierVersion()

### getPeerInfo

public String getPeerInfo(long sid)

### getQuorumVerifierBytes

public byte[] getQuorumVerifierBytes()

### getQuorumAuthServer

public QuorumAuthServer getQuorumAuthServer()

### revalidateSession

public void revalidateSession(QuorumPacket qp, LearnerHandler learnerHandler) throws IOException

Throws:
  `IOException`

### registerLearnerHandlerBean

public void registerLearnerHandlerBean(LearnerHandler learnerHandler, Socket socket)

### unregisterLearnerHandlerBean

public void unregisterLearnerHandlerBean(LearnerHandler learnerHandler)