一、背景
作为一个分布式的消息队列，kafka的日志模块主要用来存储、读取消息，它为kafka集群的高可用、高性能提供了基础。下面结合kafka的源码分析一下日志模块的设计思路。
二、日志格式
kafka的以topic为单位组织消息，为了提高系统的吞吐率，将一个topic分为N个partition。以partition为单位接收、消费消息。一个partition有多个分片，主分片接收生成者发送的消息，同时副分片从主分片出拉取消息，消费者也从主分片出消费消息。其工作原理如下图。
图1-kafka消息流转过程
kafka集群中的每个broker中都会创建对应的日志文件来存储partition中的数据，每个partition都会有一个Log对象来进行管理。Log的定义如下：
class Log(val dir: File,
@volatile var config: LogConfig,
@volatile var recoveryPoint: Long = 0L,
scheduler: Scheduler,
time: Time = SystemTime) extends Logging with KafkaMetricsGroup {
//segments是一个map结构，记录了这个Log下的所有的LogSegment
private val segments: ConcurrentNavigableMap[java.lang.Long, LogSegment] = new ConcurrentSkipListMap[java.lang.Long, LogSegment]
......
//topicAndPartition保存了topic和partition
val topicAndPartition: TopicAndPartition = Log.parseTopicPartitionName(name)
......
}Log中的topicAndPartition表示这个log对象对应的topic和partition，segments记录了这个log所有的LogSegment。LogSegment是Log的下一级单位，由于一个partition中的消息会非常多，所以系统不会把这些消息记录到一个文件里面，会将一个partition消息存放在多个文件，partition是分段的，每个段叫LogSegment，包括了一个数据文件和一个索引文件，下图是某个partition目录下的文件
kafka是顺序写入，所以这些LogSegment是随着数据的写入而依次产生的。代码如下：
/*产生LogSegment的函数
* 入参messagesSize：即将写入的消息的大小
* 出参LogSegment：该消息需要写入的LogSegment
private def maybeRoll(messagesSize: Int): LogSegment = {
//当前写入的LogSegment
val segment = activeSegment
//rollJitterMs 是日志段新增扰动值
if (segment.size > config.segmentSize - messagesSize ||
segment.size > 0 && time.milliseconds - segment.created > config.segmentMs - segment.rollJitterMs ||
segment.index.isFull) {
debug("Rolling new log segment in %s (log_size = %d/%d, index_size = %d/%d, age_ms = %d/%d)."
.format(name,
segment.size,
config.segmentSize,
segment.index.entries,
segment.index.maxEntries,
time.milliseconds - segment.created,
config.segmentMs - segment.rollJitterMs))
roll()
} else {
segment
}
}每当写入消息时，会判断是否需要生成新的LogSegment（当前的LogSegment的大小+即将写入消息的大小是否大于规定的大小，或者当前时间-创建时间大于规定的时间间隔，或者索引文件已满）。如果需要就会创建LogSegment，生成新的文件，否则就写入到原先的文件。LogSegment的定义如下：
class LogSegment(val log: FileMessageSet, //实际保存消息的对象
val index: OffsetIndex, //位移索引
val baseOffset: Long, //起始位移
val indexIntervalBytes: Int, //多少字节插入一个索引
val rollJitterMs: Long, 日志段新增扰动值
time: Time) extends Logging {
......
}从上面的定义可以看出，LogSegment中即包含了实际的保存消息的对象，又包含了一个索引对象。索引文件和日志文件的关系如下：
三、Kafka消息的写入
kafka中的broker在接收到写入的请求时，会先根据topic和partition确定需要写入的Partition对象，然后找到这个partition对象对应的log对象，执行Log对象的append方法来写入消息。append函数的代码如下：
def append(messages: ByteBufferMessageSet, assignOffsets: Boolean = true): LogAppendInfo = { //将消息添加到分片尾
val appendInfo = analyzeAndValidateMessageSet(messages) //这里验证messages信息和创建logappendinfo.
// if we have any valid messages, append them to the log
if(appendInfo.shallowCount == 0) //如果消息为空的话,就直接返回信息.
return appendInfo
// trim any invalid bytes or partial messages before appending it to the on-disk log
var validMessages = trimInvalidBytes(messages, appendInfo) //这个函数将消息里多余的部分截掉.
try {
// they are valid, insert them in the log
lock synchronized {
appendInfo.firstOffset = nextOffsetMetadata.messageOffset //这里开始分配offset值.即上最后一个分片的最后一个offset值.
if(assignOffsets) {
// assign offsets to the message set
val offset = new AtomicLong(nextOffsetMetadata.messageOffset) //创建新的offset
try {
validMessages = validMessages.assignOffsets(offset, appendInfo.codec) //使用ByteBufferMessageSet类中的分配方法分配offset值.
} catch {
case e: IOException => throw new KafkaException("Error in validating messages while appending to log '%s'".format(name), e)
}
appendInfo.lastOffset = offset.get - 1 //因为offset被assignOffsets方法累加过.所以最后要减1.
} else {
// we are taking the offsets we are given
if(!appendInfo.offsetsMonotonic || appendInfo.firstOffset < nextOffsetMetadata.messageOffset)
throw new IllegalArgumentException("Out of order offsets found in " + messages)
}
// re-validate message sizes since after re-compression some may exceed the limit
for(messageAndOffset <- validMessages.shallowIterator) {
if(MessageSet.entrySize(messageAndOffset.message) > config.maxMessageSize) { //这里判断每一个消息是否大于配置的消息最大长度.
// we record the original message set size instead of trimmed size
// to be consistent with pre-compression bytesRejectedRate recording
BrokerTopicStats.getBrokerTopicStats(topicAndPartition.topic).bytesRejectedRate.mark(messages.sizeInBytes)
BrokerTopicStats.getBrokerAllTopicsStats.bytesRejectedRate.mark(messages.sizeInBytes)
throw new MessageSizeTooLargeException("Message size is %d bytes which exceeds the maximum configured message size of %d."
.format(MessageSet.entrySize(messageAndOffset.message), config.maxMessageSize))
}
}
// check messages set size may be exceed config.segmentSize
if(validMessages.sizeInBytes > config.segmentSize) { //判断要写入的消息集大小是否超过配置的分片大小.
throw new MessageSetSizeTooLargeException("Message set size is %d bytes which exceeds the maximum configured segment size of %d."
.format(validMessages.sizeInBytes, config.segmentSize))
}
// maybe roll the log if this segment is full
val segment = maybeRoll(validMessages.sizeInBytes) //这里是判断是否需要滚动分片.
// now append to the log
segment.append(appendInfo.firstOffset, validMessages) //这里真正调用LogSegment对象写入消息.
// increment the log end offset
updateLogEndOffset(appendInfo.lastOffset + 1) //更新lastoffset.
trace("Appended message set to log %s with first offset: %d, next offset: %d, and messages: %s"
.format(this.name, appendInfo.firstOffset, nextOffsetMetadata.messageOffset, validMessages))
if(unflushedMessages >= config.flush) //判断是否需要刷新到磁盘
flush()
appendInfo
}
} catch {
case e: IOException => throw new KafkaStorageException("I/O exception in append to log '%s'".format(name), e)
}
}append函数的流程如下：
1、验证messages信息和创建logappendinfo，将多余的部分剪裁掉。
2、分配offset值，将最新的位移值nextOffsetMetadata.messageOffset设置为当前messages的第一个消息的offset，由于messages中含有N个消息，所以会滚动分配每个消息的position和offset（函数assignOffsets）
3、判断要写入的消息集大小是否超过配置的分片大小，超过则抛出异常
4、这里是判断是否需要滚动分片，即判断当前的分片LogSegment是否适合写入当前message是，如果适合就用当前分片；否则就创建新的LogSegment。
5、调用LogSegment的append方法来真正写入messages。
6、更新lastoffset.、判断是否需要刷新磁盘。
从上面的分析中可以看出，主要是LogSegment来执行写入的操作。下面看一下LogSegment的append的主要流程：
def append(offset: Long, messages: ByteBufferMessageSet) {
if (messages.sizeInBytes > 0) {
trace("Inserting %d bytes at offset %d at position %d".format(messages.sizeInBytes, offset, log.sizeInBytes()))
// append an entry to the index (if needed)
//如果超过索引的间隔，写入索引文件
if(bytesSinceLastIndexEntry > indexIntervalBytes) {
index.append(offset, log.sizeInBytes())
this.bytesSinceLastIndexEntry = 0
}
// append the messages
//写入数据
log.append(messages)
//更新bytesSinceLastIndexEntry
this.bytesSinceLastIndexEntry += messages.sizeInBytes
}
}可以看出，主要是通过log的append方法来写入的，这里的log不是前面提到的Log对象，这里的log是一个FileMessageSet对象，FileMessageSet对象的代码如下：
class FileMessageSet private[kafka](@volatile var file: File,
private[log] val channel: FileChannel,
private[log] val start: Int,
private[log] val end: Int,
isSlice: Boolean) extends MessageSet with Logging {
/* the size of the message set in bytes */
private val _size =
if(isSlice)
new AtomicInteger(end - start) // don't check the file size if this is just a slice view
else
new AtomicInteger(math.min(channel.size().toInt, end) - start)
/* if this is not a slice, update the file pointer to the end of the file */
if (!isSlice)
/* set the file position to the last byte in the file */
channel.position(channel.size)
......
def append(messages: ByteBufferMessageSet) {
val written = messages.writeTo(channel, 0, messages.sizeInBytes)
_size.getAndAdd(written)
}
......
}FileMessageSet 核心字段
file: 指向磁盘上日志文件
channel：FileChannel类型，用于读写对应的日志文件
start：FileMessageSet对象除了表示一个完整的日志文件，还可以表示日志文件的分片，start表示分片的开始位置
end：表示分片的结束位置
isSlice：表示当前FileMessageSet是否为日志文件的分片
_size：FileMessageSet大小，单位是字节，如果是分片则表示分片大小
从上面可以看出，append主要是将messages写入到FileChannel中，并且更新_size的大小。到这里，写入流程就结束了。但是现在messages只写入到内存中，还需要定时将调用函数flush将内存中的消息写入到磁盘，这个主要是LogManager控制的，这里不作介绍。
四、kafka消息的读取
kafka消息的读取，会调用Log对象中的read方法来进行。下面来看一下Log的read方法。
def read(startOffset: Long, maxLength: Int, maxOffset: Option[Long] = None): FetchDataInfo = {
val next = nextOffsetMetadata.messageOffset
//如果是最新的offset，则无数据读取
if(startOffset == next)
return FetchDataInfo(nextOffsetMetadata, MessageSet.Empty)
//根据startOffset定位位于哪个LogSegment
var entry = segments.floorEntry(startOffset)
//异常判断，如果startOffset大于当前最大的偏移量或者没有找到具体的LogSegment，则抛出异常
if(startOffset > next || entry == null)
throw new OffsetOutOfRangeException("Request for offset %d but we only have log segments in the range %d to %d.".format(startOffset, segments.firstKey, next))
//调用LogSegment的read方法读取具体的数据
while(entry != null) {
val fetchInfo = entry.getValue.read(startOffset, maxOffset, maxLength)
if(fetchInfo == null) {
entry = segments.higherEntry(entry.getKey)
} else {
return fetchInfo
}
}从上面的代码可以看出，主要分为两个步骤：
1、根据startOffset定位位于哪个LogSegment，Log中包含多个LogSegment，这些LogSegment保存在segments，segments的定义如下：
private val segments: ConcurrentNavigableMap[java.lang.Long, LogSegment] = new ConcurrentSkipListMap[java.lang.Long, LogSegment]segments是一个ConcurrentSkipListMap，它的内部将key组织成一个跳跃表，segments的key就是LogSegment的baseOffset，即它的第一个消息的offset。 通过segments.floorEntry(startOffset)就能找到不大于当前startOffset的最大的baseOffset对应的entry，然后调用LogSegment的read方法读取对应的消息。LogSegment的read方法如下：
def read(startOffset: Long, maxOffset: Option[Long], maxSize: Int): FetchDataInfo = {
if(maxSize < 0)
throw new IllegalArgumentException("Invalid max size for log read (%d)".format(maxSize))
val logSize = log.sizeInBytes // this may change, need to save a consistent copy
val startPosition = translateOffset(startOffset) //获取对应offset的读取点位置.
// if the start position is already off the end of the log, return null
if(startPosition == null) //没有读取点位置则返回空
return null
val offsetMetadata = new LogOffsetMetadata(startOffset, this.baseOffset, startPosition.position) //定义offsetMetadata
// if the size is zero, still return a log segment but with zero size
if(maxSize == 0) //最大读取尺寸是0的话.返回空消息.
return FetchDataInfo(offsetMetadata, MessageSet.Empty)
// calculate the length of the message set to read based on whether or not they gave us a maxOffset
val length = //计算最大读取的消息总长度.
maxOffset match {
case None => //未设置maxoffset则使用maxsize.
// no max offset, just use the max size they gave unmolested
maxSize
case Some(offset) => { //如果设置了Maxoffset,则计算对应的消息长度.
// there is a max offset, translate it to a file position and use that to calculate the max read size
if(offset < startOffset) //maxoffset小于startoffset则返回异常
throw new IllegalArgumentException("Attempt to read with a maximum offset (%d) less than the start offset (%d).".format(offset, startOffset))
val mapping = translateOffset(offset, startPosition.position) //获取相对maxoffset读取点.
val endPosition =
if(mapping == null)
logSize // the max offset is off the end of the log, use the end of the file
else
mapping.position
min(endPosition - startPosition.position, maxSize) //用maxoffset读取点减去开始的读取点.获取需要读取的数据长度.如果长度比maxsize大则返回maxsize
}
}
FetchDataInfo(offsetMetadata, log.read(startPosition.position, length)) //使用FileMessageSet.read读取相应长度的数据返回FetchDataInfo的封装对象.
}读取函数通过映射offset到读取长度.来读取多个offset.
private[log] def translateOffset(offset: Long, startingFilePosition: Int = 0): OffsetPosition = { //用来将offset映射到读取指针位置的函数.
val mapping = index.lookup(offset) //通过查找index获取对应的指针对象.
log.searchFor(offset, max(mapping.position, startingFilePosition)) //通过FileMessageSet获取对应的指针位置.
}最终还是通过调用FileMessageSet的read方法来进行读取。FileMessageSet的read方法如下：
def read(position: Int, size: Int): FileMessageSet = {
if(position < 0)
throw new IllegalArgumentException("Invalid position: " + position)
if(size < 0)
throw new IllegalArgumentException("Invalid size: " + size)
new FileMessageSet(file,
channel,
start = this.start + position,
end = math.min(this.start + position + size, sizeInBytes()))
}最终返回一个日志分片，然后组装成一个FetchDataInfo对象给请求端。自此，kafka的消息读取流程结束。
