前言：
前一篇文章中分析了事务日志的相关内容。在Zookeeper中，还有一个重要的日志就是快照日志。
快照日志本质上是Zookeeper全部节点信息的一个快照，从内存中保存在磁盘上。
1.查看快照日志
快照日志默认存储在?%ZOOKEEPER_DIR%/data/文件夹下，笔者的目录下产生了如下一个快照日志文件
同样的，这也是一个二进制文件，无法直接查看。而Zookeeper也提供了一个查看类org.apache.zookeeper.server.SnapshotFormatter。通过在main()方法中指定快照日志路径即可，笔者在查看snapshot.123c2文件时产生以下内容：
ZNode Details (count=74685):
----
/
cZxid = 0x00000000000000
ctime = Thu Jan 01 08:00:00 GMT+08:00 1970
mZxid = 0x00000000000000
mtime = Thu Jan 01 08:00:00 GMT+08:00 1970
pZxid = 0x000000000123c2
cversion = 74681
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x00000000000000
dataLength = 0
----
/hello24507
cZxid = 0x00000000004c3b
ctime = Tue Oct 05 17:15:30 GMT+08:00 2021
mZxid = 0x00000000004c3b
mtime = Tue Oct 05 17:15:30 GMT+08:00 2021
pZxid = 0x00000000004c3b
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x00000000000000
dataLength = 10
----
/hello24508
cZxid = 0x00000000004c3c
ctime = Tue Oct 05 17:15:30 GMT+08:00 2021
mZxid = 0x00000000004c3c
mtime = Tue Oct 05 17:15:30 GMT+08:00 2021
pZxid = 0x00000000004c3c
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x00000000000000
dataLength = 10
----
...
可以看到以上都是每个节点的基本信息（当然没有把节点value值展示出来）。
2.快照日志的生成入口
快照日志是在哪里生成的呢？在之前事务日志查看与分析中，我们有过分析，就是在SyncRequestProcessor?中生成的。代码如下
public class SyncRequestProcessor extends ZooKeeperCriticalThread implements RequestProcessor {
// 默认为100000，后续会用到
private static int snapCount = ZooKeeperServer.getSnapCount();
// 后续会被设置
private static int randRoll;
public void run() {
try {
int logCount = 0;
// 设置randRoll值为一个不定值
setRandRoll(r.nextInt(snapCount/2));
while (true) {
Request si = null;
if (toFlush.isEmpty()) {
si = queuedRequests.take();
} else {
si = queuedRequests.poll();
if (si == null) {
flush(toFlush);
continue;
}
}
if (si == requestOfDeath) {
break;
}
if (si != null) {
// track the number of records written to the log
if (zks.getZKDatabase().append(si)) {
logCount++;
// 添加完事务日志后，判断总共添加的事务日志数是否大于snapCount / 2 + randRoll，snapCount默认为100000，
// 也就是说至少执行50000+次事务操作才会生成一次快照日志
if (logCount > (snapCount / 2 + randRoll)) {
setRandRoll(r.nextInt(snapCount/2));
// roll the log
zks.getZKDatabase().rollLog();
// take a snapshot
if (snapInProcess != null && snapInProcess.isAlive()) {
LOG.warn("Too busy to snap, skipping");
} else {
snapInProcess = new ZooKeeperThread("Snapshot Thread") {
public void run() {
try {
// 启动一个子线程单独执行快照日志生成
zks.takeSnapshot();
} catch(Exception e) {
LOG.warn("Unexpected exception", e);
}
}
};
snapInProcess.start();
}
logCount = 0;
}
} else if (toFlush.isEmpty()) {
// optimization for read heavy workloads
// iff this is a read, and there are no pending
// flushes (writes), then just pass this to the next
// processor
if (nextProcessor != null) {
nextProcessor.processRequest(si);
if (nextProcessor instanceof Flushable) {
((Flushable)nextProcessor).flush();
}
}
continue;
}
toFlush.add(si);
if (toFlush.size() > 1000) {
flush(toFlush);
}
}
}
} catch (Throwable t) {
handleException(this.getName(), t);
running = false;
}
LOG.info("SyncRequestProcessor exited!");
}
}
可以看到，快照日志生成的入口就是SyncRequestProcessor，单独启动线程来完成日志生成（我们可以自定义snapCount，笔者测试的时候就是重新设置该值，不然很难看到snapshot log的生成）。
3.ZookeeperServer.takeSnapshot() 生成快照日志
public class ZooKeeperServer implements SessionExpirer, ServerStats.Provider {
public void takeSnapshot(){
try {
// 直接调用FileTxnSnapLog.save，具体见3.1
txnLogFactory.save(zkDb.getDataTree(), zkDb.getSessionWithTimeOuts());
} catch (IOException e) {
LOG.error("Severe unrecoverable error, exiting", e);
// This is a severe error that we cannot recover from,
// so we need to exit
System.exit(10);
}
}
}
3.1 FileTxnSnapLog.save()
public class FileTxnSnapLog {
public void save(DataTree dataTree,
ConcurrentHashMap<Long, Integer> sessionsWithTimeouts)
throws IOException {
long lastZxid = dataTree.lastProcessedZxid;
// 获取最新一次zxid，以此生成一个文件名
File snapshotFile = new File(snapDir, Util.makeSnapshotName(lastZxid));
LOG.info("Snapshotting: 0x{} to {}", Long.toHexString(lastZxid),
snapshotFile);
// 序列化dataTree内存信息
snapLog.serialize(dataTree, sessionsWithTimeouts, snapshotFile);
}
}
3.2 FileSnap.serialize() 真正的序列化操作
public class FileSnap implements SnapShot {
public synchronized void serialize(DataTree dt, Map<Long, Integer> sessions, File snapShot)
throws IOException {
if (!close) {
OutputStream sessOS = new BufferedOutputStream(new FileOutputStream(snapShot));
CheckedOutputStream crcOut = new CheckedOutputStream(sessOS, new Adler32());
//CheckedOutputStream cout = new CheckedOutputStream()
OutputArchive oa = BinaryOutputArchive.getArchive(crcOut);
// 同样是先创建文件头
FileHeader header = new FileHeader(SNAP_MAGIC, VERSION, dbId);
// 序列化DataTree，具体见3.2.1
serialize(dt,sessions,oa, header);
// 写入checksum值
long val = crcOut.getChecksum().getValue();
oa.writeLong(val, "val");
oa.writeString("/", "path");
sessOS.flush();
crcOut.close();
sessOS.close();
}
}
}
3.2.1 SerializeUtils.serializeSnapshot()
public class SerializeUtils {
public static void serializeSnapshot(DataTree dt,OutputArchive oa,
Map<Long, Integer> sessions) throws IOException {
HashMap<Long, Integer> sessSnap = new HashMap<Long, Integer>(sessions);
// 先将sessionId --> timeout值写入
oa.writeInt(sessSnap.size(), "count");
for (Entry<Long, Integer> entry : sessSnap.entrySet()) {
oa.writeLong(entry.getKey().longValue(), "id");
oa.writeInt(entry.getValue().intValue(), "timeout");
}
// 调用DataTree的序列化方法
dt.serialize(oa, "tree");
}
}
3.2.2 DataTree.serialize() 序列化DataTree内容
public class DataTree {
public void serialize(OutputArchive oa, String tag) throws IOException {
scount = 0;
aclCache.serialize(oa);
serializeNode(oa, new StringBuilder(""));
// / marks end of stream
// we need to check if clear had been called in between the snapshot.
if (root != null) {
oa.writeString("/", "path");
}
}
}
有关于DataTree序列化的具体细节就不再详述了，读者可以自行查看。主要就是将DataTree中的所有节点逐个序列化到文件中，包括节点的path value acl等相关信息。
总结：
流程并不算复杂，相对事务日志而言，不需要填充数字，而是在使用的时候一次性的将数据写入到磁盘上。
DataTree算是Zookeeper的一个核心知识点，在启动时会将文件中节点的信息反序列化到DataTree中，在内存中可以更快的响应客户端的请求，每次事务操作也都会对DataTree进行实时操作，下一篇文章中会详述DataTree的相关知识点。
|