hyperledger/fabric · error

error peeking [%d] bytes from block file

Error message

error peeking [%d] bytes from block file

What it means

Wraps the bufio.Reader.Peek error when fewer than the requested peekBytes are available in the buffer/file. peekBytes is clamped to remainingBytes beforehand, so this normally signals a real read/buffer problem rather than plain EOF. Peek returns io.EOF when it cannot fill the requested count.

Source

Thrown at common/ledger/blkstorage/block_stream.go:106

	if fileInfo, err = s.file.Stat(); err != nil {
		return nil, nil, errors.Wrapf(err, "error getting block file stat")
	}
	if s.currentOffset == fileInfo.Size() {
		logger.Debugf("Finished reading file number [%d]", s.fileNum)
		return nil, nil, nil
	}
	remainingBytes := fileInfo.Size() - s.currentOffset
	// Peek 8 or smaller number of bytes (if remaining bytes are less than 8)
	// Assumption is that a block size would be small enough to be represented in 8 bytes varint
	peekBytes := 8
	if remainingBytes < int64(peekBytes) {
		peekBytes = int(remainingBytes)
		moreContentAvailable = false
	}
	logger.Debugf("Remaining bytes=[%d], Going to peek [%d] bytes", remainingBytes, peekBytes)
	if lenBytes, err = s.reader.Peek(peekBytes); err != nil {
		return nil, nil, errors.Wrapf(err, "error peeking [%d] bytes from block file", peekBytes)
	}
	length, n := protowire.ConsumeVarint(lenBytes)
	if n <= 0 {
		// proto.DecodeVarint did not consume any byte at all which means that the bytes
		// representing the size of the block are partial bytes
		if !moreContentAvailable {
			return nil, nil, ErrUnexpectedEndOfBlockfile
		}
		panic(errors.Errorf("Error in decoding varint bytes [%#v]", lenBytes))
	}
	bytesExpected := int64(n) + int64(length)
	if bytesExpected > remainingBytes {
		logger.Debugf("At least [%d] bytes expected. Remaining bytes = [%d]. Returning with error [%s]",
			bytesExpected, remainingBytes, ErrUnexpectedEndOfBlockfile)
		return nil, nil, ErrUnexpectedEndOfBlockfile
	}
	// skip the bytes representing the block size
	if _, err = s.reader.Discard(n); err != nil {

View on GitHub (pinned to 2736b63f8f)

Solutions

1. Verify the blockfile is not being truncated or modified while the stream is open (stop peer or external writers)
2. Retry the stream from a stable offset; transient I/O errors may resolve
3. If the file shrank (rolled back improperly), run peer rollback/rebuild to resync ledger files with the checkpoint

if info, err := os.Stat(blockfilePath); err == nil && info.Size() < currentOffset {
    return fmt.Errorf("file shrank below offset %d; rollback needed", currentOffset)
}

blk, err := stream.nextBlockBytes()
if err != nil {
    if errors.Is(errors.Cause(err), io.EOF) || errors.Is(errors.Cause(err), io.ErrUnexpectedEOF) {
        return rescanFromLastCheckpoint()
    }
    return err
}

When it happens

Trigger: nextBlockBytesAndPlacementInfo calls s.reader.Peek(peekBytes) where peekBytes was already clamped to remainingBytes (fileSize - currentOffset); an error means the buffered reader could not return even the clamped byte count.

Common situations: File truncated concurrently after the Stat call (reader sees fewer bytes than expected); I/O error from the underlying file; racing writers repositioning the file.

Related errors

• error discarding [%d] bytes
• error reading [%d] bytes from file number [%d]
• failed to create target folder for connection.json: %s
• error reading input
• error encoding output

AI-assisted analysis of hyperledger/fabric@2736b63f8f (2026-09-04). Data as JSON: /api/errors/5704e044b5cdaa8d. Report an issue: GitHub.