rubydb 0.1.0

data/lib/rubydb/storage/file_manager.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module RubyDB
+  module Storage
+    # FileManager - Handles low-level file I/O
+    class FileManager
+      attr_reader :path, :page_size, :file, :file_size, :num_pages
+
+      def initialize(path, page_size = Constants::DEFAULT_PAGE_SIZE, config = {})
+        @path = path
+        @page_size = page_size
+        @io_fault_injector = config[:io_fault_injector] || config["io_fault_injector"]
+        @file = nil
+        @file_size = 0
+        @num_pages = 0
+        @read_only = false
+        @is_open = false
+      end
+
+      def create_or_open
+        opened_successfully = false
+        exists = File.exist?(@path)
+
+        if exists
+          @file = File.open(@path, "r+b")
+          @file_size = @file.size
+          @num_pages = @file_size / @page_size
+          @is_open = true
+          validate_file
+        else
+          @file = File.open(@path, "w+b")
+          @file_size = 0
+          @num_pages = 0
+          @is_open = true
+          initialize_file
+        end
+
+        opened_successfully = true
+        self
+      rescue SystemCallError => e
+        raise StorageError, "Failed to open database file: #{e.message}"
+      ensure
+        unless opened_successfully
+          @file&.close rescue nil
+          @file = nil
+          @file_size = 0
+          @num_pages = 0
+          @is_open = false
+        end
+      end
+
+      def read_page(page_number)
+        raise StorageError, "File not open" unless @is_open
+        raise StorageError, "Invalid page number: #{page_number}" if page_number >= @num_pages
+
+        @file.seek(page_number * @page_size)
+        data = @file.read(@page_size)
+
+        if data.nil? || data.bytesize != @page_size
+          raise CorruptionError, "Failed to read page #{page_number}"
+        end
+
+        data
+      end
+
+      def write_page(page_number, data)
+        raise StorageError, "File not open" unless @is_open
+        raise StorageError, "File is read-only" if @read_only
+        inject_fault(:page_write, page_number: page_number, bytes: data.bytesize)
+
+        if page_number == 0 && @num_pages.zero?
+          # This is the initial superblock allocation before the file has been sized.
+        elsif page_number >= @num_pages
+          raise StorageError, "Invalid page number: #{page_number}"
+        end
+
+        raise StorageError, "Data size mismatch" if data.bytesize != @page_size
+
+        @file.seek(page_number * @page_size)
+        @file.write(data)
+        @file.flush
+      rescue SystemCallError => e
+        raise StorageError, "Failed to write page: #{e.message}"
+      end
+
+      def extend_file(num_pages = 1)
+        raise StorageError, "File not open" unless @is_open
+        raise StorageError, "File is read-only" if @read_only
+        inject_fault(:file_extend, num_pages: num_pages)
+
+        new_size = (@num_pages + num_pages) * @page_size
+        @file.truncate(new_size)
+        @file_size = new_size
+        @num_pages += num_pages
+        @num_pages
+      rescue SystemCallError => e
+        raise StorageError, "Failed to extend file: #{e.message}"
+      end
+
+      def truncate_file(num_pages)
+        raise StorageError, "File not open" unless @is_open
+        raise StorageError, "File is read-only" if @read_only
+        inject_fault(:file_truncate, num_pages: num_pages)
+
+        new_size = num_pages * @page_size
+        @file.truncate(new_size)
+        @file_size = new_size
+        @num_pages = num_pages
+        @num_pages
+      rescue SystemCallError => e
+        raise StorageError, "Failed to truncate file: #{e.message}"
+      end
+
+      def close
+        return unless @is_open
+
+        @file.close if @file
+        @is_open = false
+        true
+      end
+
+      def sync
+        inject_fault(:file_sync)
+        @file.fsync if @file
+      rescue SystemCallError => e
+        raise StorageError, "Failed to sync file: #{e.message}"
+      end
+
+      def read_only?
+        @read_only
+      end
+
+      def open?
+        @is_open
+      end
+
+      private
+
+      # Fault injection is an explicit test/deployment hook. It is disabled
+      # unless a caller supplies a callable and is invoked before each
+      # durability-sensitive filesystem operation.
+      def inject_fault(operation, context = {})
+        return unless @io_fault_injector
+
+        @io_fault_injector.call(operation, context.merge(path: @path))
+      rescue StorageError
+        raise
+      rescue => e
+        raise StorageError, "Injected #{operation} failure: #{e.message}"
+      end
+
+      def initialize_file
+        # Write initial superblock page. The file must be allowed to accept page 0
+        # before the page count is established on a brand-new database.
+        @num_pages = 1
+        @file_size = @page_size
+
+        superblock = Page.new(0, @page_size)
+        superblock.write_header
+        write_page(0, superblock.data)
+      end
+
+      def validate_file
+        # Check file size is multiple of page size
+        if @file_size % @page_size != 0
+          raise CorruptionError, "File size is not a multiple of page size"
+        end
+
+        # Read and validate the first page header before interpreting the file.
+        # Refuse unknown format versions instead of silently opening a database
+        # written by an incompatible release.
+        begin
+          data = read_page(0)
+          header = PageHeader.deserialize(data[0, PageHeader::SIZE])
+          raise CorruptionError, "Invalid superblock" unless header.page_number == 0
+          raise CorruptionError, "Storage page size mismatch" unless header.page_size == @page_size
+          raise CorruptionError, "Unsupported storage page format version: #{header.version}" unless header.version == 1
+          raise CorruptionError, "Invalid page header size" unless header.header_size == PageHeader::SIZE
+        rescue => e
+          raise CorruptionError, "File validation failed: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/storage/free_space_map.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # FreeSpaceMap - Tracks free space on each page
+    class FreeSpaceMap
+      def initialize(page_manager)
+        @page_manager = page_manager
+        @free_space = {}
+        @lock = Mutex.new
+        load_free_space
+      end
+
+      def update_page(page_number, free_space)
+        @lock.synchronize do
+          @free_space[page_number] = free_space
+        end
+      end
+
+      def get_free_space(page_number)
+        @lock.synchronize do
+          @free_space[page_number] || 0
+        end
+      end
+
+      def find_page_with_space(needed_bytes)
+        @lock.synchronize do
+          # Find page with enough free space
+          best_page = nil
+          best_space = Float::INFINITY
+
+          @free_space.each do |page_number, free_space|
+            if free_space >= needed_bytes && free_space < best_space
+              best_page = page_number
+              best_space = free_space
+            end
+          end
+
+          best_page
+        end
+      end
+
+      def remove_page(page_number)
+        @lock.synchronize do
+          @free_space.delete(page_number)
+        end
+      end
+
+      def total_free_space
+        @lock.synchronize do
+          @free_space.values.sum
+        end
+      end
+
+      def load_free_space
+        @lock.synchronize do
+          @free_space.clear
+
+          (1...@page_manager.total_pages).each do |page_number|
+            begin
+              page = @page_manager.get_page(page_number)
+              @free_space[page_number] = page.free_space
+            rescue => e
+              # Ignore errors
+            end
+          end
+        end
+      end
+
+      def page_free_space_percentage(page_number)
+        total = @page_manager.file_manager.page_size
+        free = get_free_space(page_number)
+        (free.to_f / total * 100).round(2)
+      end
+
+      def to_s
+        "FreeSpaceMap: #{@free_space.size} pages, total free space: #{total_free_space}"
+      end
+    end
+  end
+end

data/lib/rubydb/storage/page.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Storage
+    # Page - Fixed-size block of storage
+    class Page
+      attr_reader :page_number, :size, :data, :dirty
+
+      def initialize(page_number, size = Constants::DEFAULT_PAGE_SIZE)
+        @page_number = page_number
+        @size = size
+        @data = "\x00".b * size
+        @dirty = false
+        @header = PageHeader.new
+        @header.page_number = page_number
+        @header.page_size = size
+      end
+
+      def read(offset, length)
+        @data[offset, length]
+      end
+
+      def write(offset, data)
+        @data[offset, data.bytesize] = data
+        @dirty = true
+      end
+
+      def write_header
+        serialized = @header.serialize
+        @data[0, serialized.bytesize] = serialized
+        @dirty = true
+      end
+
+      def read_header
+        header_data = @data[0, PageHeader::SIZE]
+        @header = PageHeader.deserialize(header_data)
+      end
+
+      def header
+        @header
+      end
+
+      def free_space
+        @size - (@header.header_size + @header.data_end)
+      end
+
+      def used_space
+        @header.data_end - @header.header_size
+      end
+
+      def is_empty?
+        @header.data_end <= @header.header_size
+      end
+
+      def is_full?
+        free_space == 0
+      end
+
+      def reset
+        @data = "\x00".b * @size
+        @dirty = true
+        @header = PageHeader.new
+        @header.page_number = @page_number
+        @header.page_size = @size
+        write_header
+      end
+
+      def serialize
+        {
+          page_number: @page_number,
+          size: @size,
+          data: @data,
+          header: @header.serialize
+        }
+      end
+
+      def self.deserialize(data)
+        page_data = data[:data]
+        page = new(data[:page_number], data[:size])
+        page.instance_variable_set(:@data, page_data)
+        page.read_header
+        page
+      end
+
+      def to_s
+        "Page(#{@page_number}) size=#{@size} used=#{used_space} free=#{free_space}"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+  end
+end