innodb_ruby 0.9.13 → 0.11.0

data/lib/innodb/log.rb

@@ -1,126 +1,155 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
 
 # An InnoDB transaction log file.
-class Innodb::Log
-  # A map of the name and position of the blocks that form the log header.
-  LOG_HEADER_BLOCK_MAP = {
-    :LOG_FILE_HEADER  => 0,
-    :LOG_CHECKPOINT_1 => 1,
-    :EMPTY            => 2,
-    :LOG_CHECKPOINT_2 => 3,
-  }
-
-  # Number of blocks in the log file header.
-  LOG_HEADER_BLOCKS = LOG_HEADER_BLOCK_MAP.size
-
-  # The size in bytes of the log file header.
-  LOG_HEADER_SIZE = LOG_HEADER_BLOCKS * Innodb::LogBlock::BLOCK_SIZE
-
-  # Maximum number of log group checkpoints.
-  LOG_CHECKPOINT_GROUPS = 32
-
-  # Open a log file.
-  def initialize(filename)
-    @file = File.open(filename)
-    @size = @file.stat.size
-    @blocks = (@size / Innodb::LogBlock::BLOCK_SIZE) - LOG_HEADER_BLOCKS
-    @capacity = @blocks * Innodb::LogBlock::BLOCK_SIZE
-  end
+module Innodb
+  class Log
+    Header = Struct.new(
+      :group_id,
+      :start_lsn,
+      :file_no,
+      :created_by,
+      keyword_init: true
+    )
 
-  # The size (in bytes) of the log.
-  attr_reader :size
+    Checkpoint = Struct.new(
+      :number,
+      :lsn,
+      :lsn_offset,
+      :buffer_size,
+      :archived_lsn,
+      :group_array,
+      :checksum_1,
+      :checksum_2,
+      :fsp_free_limit,
+      :fsp_magic,
+      keyword_init: true
+    )
 
-  # The log capacity (in bytes).
-  attr_reader :capacity
+    CheckpointGroup = Struct.new(
+      :archived_file_no,
+      :archived_offset,
+      keyword_init: true
+    )
 
-  # The number of blocks in the log.
-  attr_reader :blocks
+    CheckpointSet = Struct.new(
+      :checkpoint_1,
+      :checkpoint_2,
+      keyword_init: true
+    )
 
-  # Get the raw byte buffer for a specific block by block offset.
-  def block_data(offset)
-    raise "Invalid block offset" unless (offset % Innodb::LogBlock::BLOCK_SIZE).zero?
-    @file.sysseek(offset)
-    @file.sysread(Innodb::LogBlock::BLOCK_SIZE)
-  end
+    # A map of the name and position of the blocks that form the log header.
+    LOG_HEADER_BLOCK_MAP = {
+      LOG_FILE_HEADER: 0,
+      LOG_CHECKPOINT_1: 1,
+      EMPTY: 2,
+      LOG_CHECKPOINT_2: 3,
+    }.freeze
 
-  # Get a cursor to a block in a given offset of the log.
-  def block_cursor(offset)
-    BufferCursor.new(block_data(offset), 0)
-  end
+    # Number of blocks in the log file header.
+    LOG_HEADER_BLOCKS = LOG_HEADER_BLOCK_MAP.size
 
-  # Return the log header.
-  def header
-    offset = LOG_HEADER_BLOCK_MAP[:LOG_FILE_HEADER] * Innodb::LogBlock::BLOCK_SIZE
-    @header ||= block_cursor(offset).name("header") do |c|
-      {
-        :group_id   => c.name("group_id")   { c.get_uint32 },
-        :start_lsn  => c.name("start_lsn")  { c.get_uint64 },
-        :file_no    => c.name("file_no")    { c.get_uint32 },
-        :created_by => c.name("created_by") { c.get_string(32) }
-      }
+    # The size in bytes of the log file header.
+    LOG_HEADER_SIZE = LOG_HEADER_BLOCKS * Innodb::LogBlock::BLOCK_SIZE
+
+    # Maximum number of log group checkpoints.
+    LOG_CHECKPOINT_GROUPS = 32
+
+    # Open a log file.
+    def initialize(filename)
+      @file = File.open(filename)
+      @size = @file.stat.size
+      @blocks = (@size / Innodb::LogBlock::BLOCK_SIZE) - LOG_HEADER_BLOCKS
+      @capacity = @blocks * Innodb::LogBlock::BLOCK_SIZE
     end
-  end
 
-  # Read a log checkpoint from the given cursor.
-  def read_checkpoint(c)
-    # Log archive related fields (e.g. group_array) are not currently in
-    # use or even read by InnoDB. However, for the sake of completeness,
-    # they are included.
-    {
-      :number         => c.name("number")       { c.get_uint64 },
-      :lsn            => c.name("lsn")          { c.get_uint64 },
-      :lsn_offset     => c.name("lsn_offset")   { c.get_uint32 },
-      :buffer_size    => c.name("buffer_size")  { c.get_uint32 },
-      :archived_lsn   => c.name("archived_lsn") { c.get_uint64 },
-      :group_array    =>
-        (0 .. LOG_CHECKPOINT_GROUPS - 1).map do |n|
-          c.name("group_array[#{n}]") do
-            {
-              :archived_file_no => c.name("archived_file_no") { c.get_uint32 },
-              :archived_offset  => c.name("archived_offset")  { c.get_uint32 },
-            }
-          end
-        end,
-      :checksum_1     => c.name("checksum_1")     { c.get_uint32 },
-      :checksum_2     => c.name("checksum_2")     { c.get_uint32 },
-      :fsp_free_limit => c.name("fsp_free_limit") { c.get_uint32 },
-      :fsp_magic      => c.name("fsp_magic")      { c.get_uint32 },
-    }
-  end
+    # The size (in bytes) of the log.
+    attr_reader :size
 
-  # Return the log checkpoints.
-  def checkpoint
-    offset1 = LOG_HEADER_BLOCK_MAP[:LOG_CHECKPOINT_1] * Innodb::LogBlock::BLOCK_SIZE
-    offset2 = LOG_HEADER_BLOCK_MAP[:LOG_CHECKPOINT_2] * Innodb::LogBlock::BLOCK_SIZE
-    @checkpoint ||=
-      {
-        :checkpoint_1 => block_cursor(offset1).name("checkpoint_1") do |cursor|
-          cp = read_checkpoint(cursor)
-          cp.delete(:group_array)
-          cp
-        end,
-        :checkpoint_2 => block_cursor(offset2).name("checkpoint_2") do |cursor|
-          cp = read_checkpoint(cursor)
-          cp.delete(:group_array)
-          cp
-        end
-      }
-  end
+    # The log capacity (in bytes).
+    attr_reader :capacity
 
-  # Return a log block with a given block index as an InnoDB::LogBlock object.
-  # Blocks are indexed after the log file header, starting from 0.
-  def block(block_index)
-    return nil unless block_index.between?(0, @blocks - 1)
-    offset = (LOG_HEADER_BLOCKS + block_index.to_i) * Innodb::LogBlock::BLOCK_SIZE
-    Innodb::LogBlock.new(block_data(offset))
-  end
+    # The number of blocks in the log.
+    attr_reader :blocks
+
+    # Get the raw byte buffer for a specific block by block offset.
+    def block_data(offset)
+      raise "Invalid block offset" unless (offset % Innodb::LogBlock::BLOCK_SIZE).zero?
+
+      @file.sysseek(offset)
+      @file.sysread(Innodb::LogBlock::BLOCK_SIZE)
+    end
+
+    # Get a cursor to a block in a given offset of the log.
+    def block_cursor(offset)
+      BufferCursor.new(block_data(offset), 0)
+    end
+
+    # Return the log header.
+    def header
+      offset = LOG_HEADER_BLOCK_MAP[:LOG_FILE_HEADER] * Innodb::LogBlock::BLOCK_SIZE
+      @header ||= block_cursor(offset).name("header") do |c|
+        Header.new(
+          group_id: c.name("group_id") { c.read_uint32 },
+          start_lsn: c.name("start_lsn") { c.read_uint64 },
+          file_no: c.name("file_no") { c.read_uint32 },
+          created_by: c.name("created_by") { c.read_string(32) }
+        )
+      end
+    end
+
+    # Read a log checkpoint from the given cursor.
+    def read_checkpoint(cursor)
+      # Log archive related fields (e.g. group_array) are not currently in
+      # use or even read by InnoDB. However, for the sake of completeness,
+      # they are included.
+      Checkpoint.new(
+        number: cursor.name("number") { cursor.read_uint64 },
+        lsn: cursor.name("lsn") { cursor.read_uint64 },
+        lsn_offset: cursor.name("lsn_offset") { cursor.read_uint32 },
+        buffer_size: cursor.name("buffer_size") { cursor.read_uint32 },
+        archived_lsn: cursor.name("archived_lsn") { cursor.read_uint64 },
+        group_array:
+          (0..(LOG_CHECKPOINT_GROUPS - 1)).map do |n|
+            cursor.name("group_array[#{n}]") do
+              CheckpointGroup.new(
+                archived_file_no: cursor.name("archived_file_no") { cursor.read_uint32 },
+                archived_offset: cursor.name("archived_offset") { cursor.read_uint32 }
+              )
+            end
+          end,
+        checksum_1: cursor.name("checksum_1") { cursor.read_uint32 },
+        checksum_2: cursor.name("checksum_2") { cursor.read_uint32 },
+        fsp_free_limit: cursor.name("fsp_free_limit") { cursor.read_uint32 },
+        fsp_magic: cursor.name("fsp_magic") { cursor.read_uint32 }
+      )
+    end
+
+    # Return the log checkpoints.
+    def checkpoint
+      offset1 = LOG_HEADER_BLOCK_MAP[:LOG_CHECKPOINT_1] * Innodb::LogBlock::BLOCK_SIZE
+      offset2 = LOG_HEADER_BLOCK_MAP[:LOG_CHECKPOINT_2] * Innodb::LogBlock::BLOCK_SIZE
+      @checkpoint ||= CheckpointSet.new(
+        checkpoint_1: block_cursor(offset1).name("checkpoint_1") { |c| read_checkpoint(c) },
+        checkpoint_2: block_cursor(offset2).name("checkpoint_2") { |c| read_checkpoint(c) }
+      )
+    end
+
+    # Return a log block with a given block index as an InnoDB::LogBlock object.
+    # Blocks are indexed after the log file header, starting from 0.
+    def block(block_index)
+      return nil unless block_index.between?(0, @blocks - 1)
+
+      offset = (LOG_HEADER_BLOCKS + block_index.to_i) * Innodb::LogBlock::BLOCK_SIZE
+      Innodb::LogBlock.new(block_data(offset))
+    end
 
-  # Iterate through all log blocks, returning the block index and an
-  # InnoDB::LogBlock object for each block.
-  def each_block
-    (0...@blocks).each do |block_index|
-      current_block = block(block_index)
-      yield block_index, current_block if current_block
+    # Iterate through all log blocks, returning the block index and an
+    # InnoDB::LogBlock object for each block.
+    def each_block
+      (0...@blocks).each do |block_index|
+        current_block = block(block_index)
+        yield block_index, current_block if current_block
+      end
     end
   end
 end

data/lib/innodb/log_block.rb

@@ -1,120 +1,129 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
+require "forwardable"
 
 # An InnoDB transaction log block.
-class Innodb::LogBlock
-  # Log blocks are fixed-length at 512 bytes in InnoDB.
-  BLOCK_SIZE = 512
+module Innodb
+  class LogBlock
+    extend Forwardable
 
-  # Offset of the header within the log block.
-  HEADER_OFFSET = 0
+    Header = Struct.new(
+      :flush,
+      :block_number,
+      :data_length,
+      :first_rec_group,
+      :checkpoint_no,
+      keyword_init: true
+    )
 
-  # The size of the block header.
-  HEADER_SIZE = 4 + 2 + 2 + 4
+    Trailer = Struct.new(
+      :checksum,
+      keyword_init: true
+    )
 
-  # Offset of the trailer within ths log block.
-  TRAILER_OFFSET = BLOCK_SIZE - 4
+    # Log blocks are fixed-length at 512 bytes in InnoDB.
+    BLOCK_SIZE = 512
 
-  # The size of the block trailer.
-  TRAILER_SIZE = 4
+    # Offset of the header within the log block.
+    HEADER_OFFSET = 0
 
-  # Offset of the start of data in the block.
-  DATA_OFFSET = HEADER_SIZE
+    # The size of the block header.
+    HEADER_SIZE = 4 + 2 + 2 + 4
 
-  # Size of the space available for log records.
-  DATA_SIZE = BLOCK_SIZE - HEADER_SIZE - TRAILER_SIZE
+    # Offset of the trailer within ths log block.
+    TRAILER_OFFSET = BLOCK_SIZE - 4
 
-  # Mask used to get the flush bit in the header.
-  HEADER_FLUSH_BIT_MASK = 0x80000000
+    # The size of the block trailer.
+    TRAILER_SIZE = 4
 
-  # Initialize a log block by passing in a 512-byte buffer containing the raw
-  # log block contents.
-  def initialize(buffer)
-    unless buffer.size == BLOCK_SIZE
-      raise "Log block buffer provided was not #{BLOCK_SIZE} bytes"
-    end
+    # Offset of the start of data in the block.
+    DATA_OFFSET = HEADER_SIZE
 
-    @buffer = buffer
-  end
+    # Size of the space available for log records.
+    DATA_SIZE = BLOCK_SIZE - HEADER_SIZE - TRAILER_SIZE
 
-  # Return an BufferCursor object positioned at a specific offset.
-  def cursor(offset)
-    BufferCursor.new(@buffer, offset)
-  end
+    # Mask used to get the flush bit in the header.
+    HEADER_FLUSH_BIT_MASK = 0x80000000
 
-  # Return the log block header.
-  def header
-    @header ||= cursor(HEADER_OFFSET).name("header") do |c|
-      {
-        :flush => c.name("flush") {
-          c.peek { (c.get_uint32 & HEADER_FLUSH_BIT_MASK) > 0 }
-        },
-        :block_number => c.name("block_number") {
-          c.get_uint32 & ~HEADER_FLUSH_BIT_MASK
-        },
-        :data_length      => c.name("data_length")     { c.get_uint16 },
-        :first_rec_group  => c.name("first_rec_group") { c.get_uint16 },
-        :checkpoint_no    => c.name("checkpoint_no")   { c.get_uint32 },
-      }
-    end
-  end
+    # Initialize a log block by passing in a 512-byte buffer containing the raw
+    # log block contents.
+    def initialize(buffer)
+      raise "Log block buffer provided was not #{BLOCK_SIZE} bytes" unless buffer.size == BLOCK_SIZE
 
-  # Return a slice of actual block data (that is, excluding header and
-  # trailer) starting at the given offset.
-  def data(offset = DATA_OFFSET)
-    length = header[:data_length]
+      @buffer = buffer
+    end
 
-    if length == BLOCK_SIZE
-      length -= TRAILER_SIZE
+    # Return an BufferCursor object positioned at a specific offset.
+    def cursor(offset)
+      BufferCursor.new(@buffer, offset)
     end
 
-    if offset < DATA_OFFSET || offset > length
-      raise "Invalid block data offset"
+    # Return the log block header.
+    def header
+      @header ||= cursor(HEADER_OFFSET).name("header") do |c|
+        Header.new(
+          flush: c.name("flush") { c.peek { (c.read_uint32 & HEADER_FLUSH_BIT_MASK).positive? } },
+          block_number: c.name("block_number") { c.read_uint32 & ~HEADER_FLUSH_BIT_MASK },
+          data_length: c.name("data_length") { c.read_uint16 },
+          first_rec_group: c.name("first_rec_group") { c.read_uint16 },
+          checkpoint_no: c.name("checkpoint_no") { c.read_uint32 }
+        )
+      end
     end
 
-    @buffer.slice(offset, length - offset)
-  end
+    def_delegator :header, :flush
+    def_delegator :header, :block_number
+    def_delegator :header, :data_length
+    def_delegator :header, :first_rec_group
+    def_delegator :header, :checkpoint_no
+
+    # Return a slice of actual block data (that is, excluding header and
+    # trailer) starting at the given offset.
+    def data(offset = DATA_OFFSET)
+      length = data_length
+      length -= TRAILER_SIZE if length == BLOCK_SIZE
 
-  # Return the log block trailer.
-  def trailer
-    @trailer ||= cursor(TRAILER_OFFSET).name("trailer") do |c|
-      {
-        :checksum => c.name("checksum") { c.get_uint32 },
-      }
+      raise "Invalid block data offset" if offset < DATA_OFFSET || offset > length
+
+      @buffer.slice(offset, length - offset)
     end
-  end
 
-  # A helper function to return the checksum from the trailer, for
-  # easier access.
-  def checksum
-    trailer[:checksum]
-  end
+    # Return the log block trailer.
+    def trailer
+      @trailer ||= cursor(TRAILER_OFFSET).name("trailer") do |c|
+        Trailer.new(checksum: c.name("checksum") { c.read_uint32 })
+      end
+    end
 
-  # Calculate the checksum of the block using InnoDB's log block
-  # checksum algorithm.
-  def calculate_checksum
-    cksum = 1
-    shift = (0..24).cycle
-    cursor(0).each_byte_as_uint8(TRAILER_OFFSET) do |b|
-      cksum &= 0x7fffffff
-      cksum += b + (b << shift.next)
+    def_delegator :trailer, :checksum
+
+    # Calculate the checksum of the block using InnoDB's log block
+    # checksum algorithm.
+    def calculate_checksum
+      csum = 1
+      shift = (0..24).cycle
+      cursor(0).each_byte_as_uint8(TRAILER_OFFSET) do |b|
+        csum &= 0x7fffffff
+        csum += b + (b << shift.next)
+      end
+      csum
     end
-    cksum
-  end
 
-  # Is the block corrupt? Calculate the checksum of the block and compare to
-  # the stored checksum; return true or false.
-  def corrupt?
-    checksum != calculate_checksum
-  end
+    # Is the block corrupt? Calculate the checksum of the block and compare to
+    # the stored checksum; return true or false.
+    def corrupt?
+      checksum != calculate_checksum
+    end
 
-  # Dump the contents of a log block for debugging purposes.
-  def dump
-    puts
-    puts "header:"
-    pp header
+    # Dump the contents of a log block for debugging purposes.
+    def dump
+      puts
+      puts "header:"
+      pp header
 
-    puts
-    puts "trailer:"
-    pp trailer
+      puts
+      puts "trailer:"
+      pp trailer
+    end
   end
 end