zk源码阅读37:ZooKeeperServer源码分析
2017-08-14 本文已影响1702人
赤子心_d709
摘要
前面针对server启动到选举leader进行了一个小结，现在进入leader和follower的启动交互过程，需要先讲ZooKeeperServer，
在之前源码阅读的25节里面带过了一部分，这里详细讲解ZooKeeperServer的源码
继承关系如下
ZooKeeperServer继承关系
本节主要讲解内容如下
父接口
ServerStats.Provider
SessionTracker.SessionExpirer
属性
内部类
DataTreeBuilder && BasicDataTreeBuilder
MissingSessionException
ChangeRecord
State
函数
构造函数
加载数据相关函数
启动相关函数
实现SessionTracker.SessionExpirer接口的函数
client重连相关函数
其他函数
思考
父接口
ServerStats.Provider
在源码阅读第24节讲解了，这里不赘述
SessionTracker.SessionExpirer
是SessionTracker的内部接口
public static interface SessionExpirer {
void expire(Session session);//过期某个session
long getServerId();//获取serverId
}
属性
如下图
ZooKeeperServer属性
除去log，jmx相关部分，源码如下
public static final int DEFAULT_TICK_TIME = 3000;//默认最短周期
protected int tickTime = DEFAULT_TICK_TIME;//周期时长
/** value of -1 indicates unset, use default */
protected int minSessionTimeout = -1;//默认最短会话超时时间
/** value of -1 indicates unset, use default */
protected int maxSessionTimeout = -1;//默认最长会话超时时间
protected SessionTracker sessionTracker;//会化跟踪器
private FileTxnSnapLog txnLogFactory = null;//事务，快照日志
private ZKDatabase zkDb;//数据库
private final AtomicLong hzxid = new AtomicLong(0);//即zxid
public final static Exception ok = new Exception("No prob");
protected RequestProcessor firstProcessor;//首个请求处理器
protected volatile State state = State.INITIAL;//初始状态
/**
* This is the secret that we use to generate passwords, for the moment it
* is more of a sanity check.
*/
static final private long superSecret = 0XB3415C00L;//密码相关
private final AtomicInteger requestsInProcess = new AtomicInteger(0);//正在处理的请求个数
final List<ChangeRecord> outstandingChanges = new ArrayList<ChangeRecord>();//变更列表
// this data structure must be accessed under the outstandingChanges lock
final HashMap<String, ChangeRecord> outstandingChangesForPath =//变更的path到变更记录的map
new HashMap<String, ChangeRecord>();
private ServerCnxnFactory serverCnxnFactory;//连接工厂
private final ServerStats serverStats;//服务器统计器
private final ZooKeeperServerListener listener;//监听，处理服务器stop状态
private ZooKeeperServerShutdownHandler zkShutdownHandler;//server的关闭处理器
ChangeRecord是ZooKeeperServer的内部类，下面会介绍
ServerStats,ZooKeeperServerListener都在25节的源码介绍过
内部类
内部类
DataTreeBuilder && BasicDataTreeBuilder
这个类并没有调用，不用管
/**
* The server delegates loading of the tree to an instance of the interface
*/
public interface DataTreeBuilder {
public DataTree build();
}
static public class BasicDataTreeBuilder implements DataTreeBuilder {
public DataTree build() {
return new DataTree();
}
}
MissingSessionException
定义异常
public static class MissingSessionException extends IOException {
private static final long serialVersionUID = 7467414635467261007L;
public MissingSessionException(String msg) {
super(msg);
}
}
ChangeRecord
这个数据结构为了促进PrepRequestProcessor以及FinalRequestProcessor的信息共享,讲到调用链的时候再讲。
static class ChangeRecord {
ChangeRecord(long zxid, String path, StatPersisted stat, int childCount,
List<ACL> acl) {
this.zxid = zxid;
this.path = path;
this.stat = stat;
this.childCount = childCount;
this.acl = acl;
}
long zxid;
String path;//路径
//持久化状态
StatPersisted stat; /* Make sure to create a new object when changing */
int childCount;
List<ACL> acl; /* Make sure to create a new object when changing */
@SuppressWarnings("unchecked")
ChangeRecord duplicate(long zxid) {//复制一份
StatPersisted stat = new StatPersisted();
if (this.stat != null) {
DataTree.copyStatPersisted(this.stat, stat);
}
return new ChangeRecord(zxid, path, stat, childCount,
acl == null ? new ArrayList<ACL>() : new ArrayList(acl));
}
}
其中，StatPersisted在源码阅读7中讲DataNode的时候讲过了
State
描述当前server所处的状态
protected enum State {
INITIAL, RUNNING, SHUTDOWN, ERROR;
}
函数
构造函数
这里列举处两个底层调用的构造函数
/**
* Creates a ZooKeeperServer instance. Nothing is setup, use the setX
* methods to prepare the instance (eg datadir, datalogdir, ticktime,
* builder, etc...)
*
* @throws IOException
*/
public ZooKeeperServer() {//利用set方法设置其他属性
serverStats = new ServerStats(this);
listener = new ZooKeeperServerListenerImpl(this);
}
/**
* Creates a ZooKeeperServer instance. It sets everything up, but doesn't
* actually start listening for clients until run() is invoked.
*
* @param dataDir the directory to put the data
*/
public ZooKeeperServer(FileTxnSnapLog txnLogFactory, int tickTime,
int minSessionTimeout, int maxSessionTimeout,
DataTreeBuilder treeBuilder, ZKDatabase zkDb) {//配置各种属性，等run方法被调用才真正开始接收clients
serverStats = new ServerStats(this);
this.txnLogFactory = txnLogFactory;
this.zkDb = zkDb;
this.tickTime = tickTime;
this.minSessionTimeout = minSessionTimeout;
this.maxSessionTimeout = maxSessionTimeout;
listener = new ZooKeeperServerListenerImpl(this);
LOG.info("Created server with tickTime " + tickTime
+ " minSessionTimeout " + getMinSessionTimeout()
+ " maxSessionTimeout " + getMaxSessionTimeout()
+ " datadir " + txnLogFactory.getDataDir()
+ " snapdir " + txnLogFactory.getSnapDir());
}
加载数据相关
启动涉及到db的数据加载，这里也有集群和单机两种，调用顺序为
集群调用顺序:
Leader#lead
ZooKeeperServer#loadData
单机调用顺序:
ServerCnxnFactory#startup
ZooKeeperServer#startdata
ZooKeeperServer#loadData
主要是集群的时候，server选完了leader，由leader才能调用数据加载loadData
下面按照单机版startdata函数展开
startdata
初始化zkDb完成数据加载
public void startdata()
throws IOException, InterruptedException {
//check to see if zkDb is not null
if (zkDb == null) {
zkDb = new ZKDatabase(this.txnLogFactory);//没有就构造
}
if (!zkDb.isInitialized()) {//没有初始化就加载数据，完成初始化
loadData();
}
}
loadData
恢复session和数据，单机版启动或者集群版leader选举之后调用lead方法时，会调用该方法。
主要完成设置zxid以及把无效的session给kill掉的工作
/**
* Restore sessions and data
*/
public void loadData() throws IOException, InterruptedException {//设置zxid，再从db中把旧的session给kill掉
/*
* When a new leader starts executing Leader#lead, it
* invokes this method. The database, however, has been
* initialized before running leader election so that
* the server could pick its zxid for its initial vote.
* It does it by invoking QuorumPeer#getLastLoggedZxid.
* Consequently, we don't need to initialize it once more
* and avoid the penalty of loading it a second time. Not
* reloading it is particularly important for applications
* that host a large database.
*
* The following if block checks whether the database has
* been initialized or not. Note that this method is
* invoked by at least one other method:
* ZooKeeperServer#startdata.
*
* See ZOOKEEPER-1642 for more detail.
*/
if(zkDb.isInitialized()){
setZxid(zkDb.getDataTreeLastProcessedZxid());//设置当前server的zxid
}
else {
setZxid(zkDb.loadDataBase());//设置当前server的zxid
}
// Clean up dead sessions
LinkedList<Long> deadSessions = new LinkedList<Long>();
for (Long session : zkDb.getSessions()) {//获取临时会话记录
if (zkDb.getSessionWithTimeOuts().get(session) == null) {//如果会话已经被tracker超时检测给清除掉了,应该是已经处理检测过期，但是异步发送请求还未完成的情况
deadSessions.add(session);
}
}
zkDb.setDataTreeInit(true);//设置标志位
for (long session : deadSessions) {
// XXX: Is lastProcessedZxid really the best thing to use?
killSession(session, zkDb.getDataTreeLastProcessedZxid());
}
}
这里注意，为什么需要干这件事情，在下面思考中会说
里面调用了setZxid(不展开)以及killSession函数
killSession
清除db中临时会话记录，会话跟踪器也清除记录
protected void killSession(long sessionId, long zxid) {
zkDb.killSession(sessionId, zxid);//清除db中相关临时会话记录
if (LOG.isTraceEnabled()) {
ZooTrace.logTraceMessage(LOG, ZooTrace.SESSION_TRACE_MASK,
"ZooKeeperServer --- killSession: 0x"
+ Long.toHexString(sessionId));
}
if (sessionTracker != null) {
sessionTracker.removeSession(sessionId);//会化跟踪器清除记录
}
}
启动相关
入口是ZooKeeperServer#startup，zkServer都是在上述加载了db的数据之后，调用startup来完成启动
startup
启动的入口函数
public synchronized void startup() {
if (sessionTracker == null) {
createSessionTracker();//创建会化跟踪器
}
startSessionTracker();//启动会话管理
setupRequestProcessors();//初始化请求处理链路
registerJMX();//注册jmx
setState(State.RUNNING);//提供服务
notifyAll();
}
调用了createSessionTracker等函数，介绍如下
createSessionTracker & startSessionTracker
createSessionTracker 完成会话跟踪器的创建
protected void createSessionTracker() {
sessionTracker = new SessionTrackerImpl(this, zkDb.getSessionWithTimeOuts(),
tickTime, 1, getZooKeeperServerListener());//1是默认单机版实现的sid
}
这里是默认的单机版实现，在集群版不同的角色有不同的实现,主要是参数sid不会传1，而是配置中的sid
startSessionTracker 启动会话跟踪器
protected void startSessionTracker() {
((SessionTrackerImpl)sessionTracker).start();
}
setState
设置服务器运行状态，对于ERROR和SHUTDOWN的state，进行对应的操作
protected void setState(State state) {//根据zkShutdownHandler处理state
this.state = state;
// Notify server state changes to the registered shutdown handler, if any.
if (zkShutdownHandler != null) {
zkShutdownHandler.handle(state);//如果是错误的state就进行关闭操作
} else {
LOG.error("ZKShutdownHandler is not registered, so ZooKeeper server "
+ "won't take any action on ERROR or SHUTDOWN server state changes");
}
}
在源码阅读25:服务器异常报警，关闭机制讲过，这里不赘述
setupRequestProcessors
安装请求处理链路,是PrepRequestProcessor -> SyncRequestProcessor -> FinalRequestProcessor顺序
具体在后面请求处理链路再讲
protected void setupRequestProcessors() {//安装请求处理链路
RequestProcessor finalProcessor = new FinalRequestProcessor(this);
RequestProcessor syncProcessor = new SyncRequestProcessor(this,
finalProcessor);
((SyncRequestProcessor)syncProcessor).start();
firstProcessor = new PrepRequestProcessor(this, syncProcessor);//链路是PrepRequestProcessor -> SyncRequestProcessor -> FinalRequestProcessor顺序
((PrepRequestProcessor)firstProcessor).start();//启动链路
}
实现SessionTracker.SessionExpirer接口的函数
两个函数getServerId和expire
public long getServerId() {//默认实现,不同角色的实现返回值不同
return 0;
}
public void expire(Session session) {//过期某个session
long sessionId = session.getSessionId();
LOG.info("Expiring session 0x" + Long.toHexString(sessionId)
+ ", timeout of " + session.getTimeout() + "ms exceeded");
close(sessionId);
}
close函数在下面会讲
client重连相关
processConnectRequest用于处理client的连接请求，不展开
值得注意的地方是重连的调用
处理client重连
展开如下
reopenSession
重连的核心函数
public void reopenSession(ServerCnxn cnxn, long sessionId, byte[] passwd,
int sessionTimeout) throws IOException {
if (!checkPasswd(sessionId, passwd)) {//如果密码不对
finishSessionInit(cnxn, false);//完成初始化，传入valid值为false
} else {
revalidateSession(cnxn, sessionId, sessionTimeout);//如果密码正确，判断会话跟踪器的记录
}
}
checkPasswd
验证sessionId和传递来的密码的正确性
protected boolean checkPasswd(long sessionId, byte[] passwd) {
return sessionId != 0
&& Arrays.equals(passwd, generatePasswd(sessionId));
}
generatePasswd
根据sessionId生成密码
byte[] generatePasswd(long id) {
Random r = new Random(id ^ superSecret);
byte p[] = new byte[16];
r.nextBytes(p);
return p;
}
revalidateSession
在会话跟踪器SessionTracker中判断会话是否还有小
protected void revalidateSession(ServerCnxn cnxn, long sessionId,
int sessionTimeout) throws IOException {//验证会话跟踪器是否有对应记录，获取结果，再调用finishSessionInit
boolean rc = sessionTracker.touchSession(sessionId, sessionTimeout);
if (LOG.isTraceEnabled()) {
ZooTrace.logTraceMessage(LOG,ZooTrace.SESSION_TRACE_MASK,
"Session 0x" + Long.toHexString(sessionId) +
" is valid: " + rc);
}
finishSessionInit(cnxn, rc);
}
finishSessionInit
完成会话初始化，根据参数valid代表认证通过与否，用来判断server是接收连接请求，还是发出closeConn的请求,不展开，重要部分如下
valid不同的处理方式
其他函数
除去的get,set,jmx,shutdown相关函数，剩下重要函数如下
部分函数列举如下
getNextZxid
获取下一个server的zxid,调用方需要确保控制并发顺序
long getNextZxid() {
return hzxid.incrementAndGet();
}
close
上面ZooKeeperServer#expire调用了close函数，介绍如下
该函数用于提交一个 关闭某个sessionId 的请求
private void close(long sessionId) {
submitRequest(null, sessionId, OpCode.closeSession, 0, null, null);
}
submitRequest
这里有两个函数
private void submitRequest(ServerCnxn cnxn, long sessionId, int type,
int xid, ByteBuffer bb, List<Id> authInfo) {
Request si = new Request(cnxn, sessionId, xid, type, bb, authInfo);//生成request
submitRequest(si);//提交请求
}
public void submitRequest(Request si) {
if (firstProcessor == null) {//等待第一个处理器构造完成
synchronized (this) {
try {
// Since all requests are passed to the request
// processor it should wait for setting up the request
// processor chain. The state will be updated to RUNNING
// after the setup.
while (state == State.INITIAL) {
wait(1000);
}
} catch (InterruptedException e) {
LOG.warn("Unexpected interruption", e);
}
if (firstProcessor == null || state != State.RUNNING) {
throw new RuntimeException("Not started");
}
}
}
try {
touch(si.cnxn);//更新SessionTracker相关统计
boolean validpacket = Request.isValid(si.type);//验证Request的OpCode
if (validpacket) {
firstProcessor.processRequest(si);//支持的type就调用第一个处理链来处理
if (si.cnxn != null) {
incInProcess();//正在处理的请求个数 +1
}
} else {
LOG.warn("Received packet at server of unknown type " + si.type);
new UnimplementedRequestProcessor().processRequest(si);
}
} catch (MissingSessionException e) {
if (LOG.isDebugEnabled()) {
LOG.debug("Dropping request: " + e.getMessage());
}
} catch (RequestProcessorException e) {
LOG.error("Unable to process request:" + e.getMessage(), e);
}
}
剩下的
| 函数 | 备注 |
|---|---|
| public void dumpConf(PrintWriter pwriter) | ServerCnxn接收"conf"的cmd时，输出配置到PrintWriter |
| void removeCnxn(ServerCnxn cnxn) | db中删除这个ServerCnxn(清除Watcher记录) |
| public void takeSnapshot() | 记录快照，把sessions和dataTree信息保存至快照 |
| void touch(ServerCnxn cnxn) | touch一个ServerCnxn的sessionId，更新SessionTracker对应统计，在submitRequest即提交请求时调用 |
| processPacket | 处理普通请求的函数，除了sasl以及auth以外，大部分进入submitRequest |
| dumpEphemerals | ServerCnxn接收"dump"的cmd时，把临时节点信息输出到PrintWriter |
| processSasl | 处理请求中是sasl的部分 |
| processTxn | 调用链处理完之后，最终处理事务请求 |
思考
ZooKeeperServer#loadData为什么会出现数据不一致而需要清理session
之前在源码21节 会话管理中讲解了会话清除，在sessionTracker的记录是马上清除的，而DateTree中临时会话的清除是通过调用链一步步来的，也就是说两个步骤不是同步的，所以如果中间服务器状态改变了，会出现不一致的情况
属性requestsInProcess什么时候变化
requestsInProcess代表正在处理的请求个数
增加时，调用链
ZooKeeperServer#submitRequest(org.apache.zookeeper.server.Request)调用
ZooKeeperServer#incInProcess
减少时，调用链
FinalRequestProcessor#processRequest
ZooKeeperServer#decInProcess
就是说发出请求时，requestsInProcess+1，最后完成请求时，requestsInProcess-1.涉及到请求处理链。
每个连接的密码是怎么生成的
ZooKeeperServer#checkPasswd调用
ZooKeeperServer#generatePasswd
就是sessionId要和sessionId^superSecret生成的第一个随机数相匹配即可
密码不是client端设置的，是根据sessionId生成的
client重连的机制是怎样的
ZooKeeperServer#processConnectRequest 里面调用reopenSession中
在上面已经讲了,核心就是
1.先看密码对不对
2.再看SessionTracker中是否还有效
3.都通过了才允许重连
问题
ChangeRecord如何促进PrepRequestProcessor以及FinalRequestProcessor的信息共享
这里还没有深入看，先存疑
吐槽
需要思考的细节太多了
比如思考中提到的loadData为什么会出现数据不一致，属于某种异常情况的处理
client重连的代码
为什么不放到另外一个类里面去
