fbe 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c33c559724c991d4aabc2ad9c097170e53de0002e362dcfadfe956d77eed7ec
-  data.tar.gz: 787dbc8ce12ebacbd0b96cd8174ced19aa11665f29d3d410fb93c397dbb80d87
+  metadata.gz: ae9a9de76ff2dba753f10923fb0f984acc0c0e2e4f2a626a15c0ae6622d64392
+  data.tar.gz: ceeef4187f94f32b39569cf7f1e98c1a25559b1730c742f8c01073520456afce
 SHA512:
-  metadata.gz: ca43bc96f5c8f426a72fb3ab722684d36b67613526b9d2e1be175abae03581c4fc0318314e92628c9064d2c7ba8637814ed950e349ba86b64caedc768619be8f
-  data.tar.gz: 81d737f13af364095e871df44000f6293d1c062929d7f859cd3836d23c3cf602a1362a9653fd739f1726c4d1004e0bad1806e3cb3fde23dc4aef081e39dfbd6a
+  metadata.gz: c2cec9308283d6d2ced937184b6e62b09bee329a10b7d65d69d369002dfb797b7e2b513611d64911d09cbaa50b7c00aec6480040f5955510297a20128528b443
+  data.tar.gz: 4d901bf3b1a062683dd481398e4961447676af8ae97ef8d938b321c6b0774fdadde71ba69e4875859e138e1853be2f1a734db1bf0fbe72f5ea62695c67fb67e3

data/lib/fbe/middleware/sqlite_store.rb

@@ -6,26 +6,66 @@
 require 'time'
 require 'json'
 require 'sqlite3'
+require 'loog'
 require_relative '../../fbe'
 require_relative '../../fbe/middleware'
 
 # Persisted SQLite store for Faraday::HttpCache
 #
+# This class provides a persistent cache store backed by SQLite for use with
+# Faraday::HttpCache middleware. It's designed to cache HTTP responses from
+# GitHub API calls to reduce API rate limit consumption and improve performance.
+#
+# Key features:
+# - Automatic version management to invalidate cache on version changes
+# - Size-based cache eviction (configurable, defaults to 10MB)
+# - Thread-safe SQLite transactions
+# - JSON serialization for cached values
+# - Filtering of non-cacheable requests (non-GET, URLs with query parameters)
+#
+# Usage example:
+#   store = Fbe::Middleware::SqliteStore.new(
+#     '/path/to/cache.db',
+#     '1.0.0',
+#     loog: logger,
+#     maxsize: 50 * 1024 * 1024  # 50MB max size
+#   )
+#
+#   # Use with Faraday
+#   Faraday.new do |builder|
+#     builder.use Faraday::HttpCache, store: store
+#   end
+#
+# The store automatically manages the SQLite database schema and handles
+# cleanup operations when the database grows too large. Old entries are
+# deleted based on their last access time to maintain the configured size limit.
+#
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
 # Copyright:: Copyright (c) 2024-2025 Zerocracy
 # License:: MIT
 class Fbe::Middleware::SqliteStore
   attr_reader :path
 
-  def initialize(path, version)
+  # Initialize the SQLite store.
+  # @param path [String] Path to the SQLite database file
+  # @param version [String] Version identifier for cache compatibility
+  # @param loog [Loog] Logger instance (optional, defaults to Loog::NULL)
+  # @param maxsize [Integer] Maximum database size in bytes (optional, defaults to 10MB)
+  # @raise [ArgumentError] If path is nil/empty, directory doesn't exist, or version is nil/empty
+  def initialize(path, version, loog: Loog::NULL, maxsize: 10 * 1024 * 1024)
     raise ArgumentError, 'Database path cannot be nil or empty' if path.nil? || path.empty?
     dir = File.dirname(path)
     raise ArgumentError, "Directory #{dir} does not exist" unless File.directory?(dir)
     raise ArgumentError, 'Version cannot be nil or empty' if version.nil? || version.empty?
     @path = File.absolute_path(path)
     @version = version
+    @loog = loog
+    @maxsize = maxsize
   end
 
+  # Read a value from the cache.
+  # @param key [String] The cache key to read
+  # @return [Object, nil] The cached value parsed from JSON, or nil if not found
   def read(key)
     value = perform do |t|
       t.execute('UPDATE cache SET touched_at = ?2 WHERE key = ?1;', [key, Time.now.utc.iso8601])
@@ -34,11 +74,20 @@ class Fbe::Middleware::SqliteStore
     JSON.parse(value) if value
   end
 
+  # Delete a key from the cache.
+  # @param key [String] The cache key to delete
+  # @return [nil]
   def delete(key)
     perform { _1.execute('DELETE FROM cache WHERE key = ?', [key]) }
     nil
   end
 
+  # Write a value to the cache.
+  # @param key [String] The cache key to write
+  # @param value [Object] The value to cache (will be JSON encoded)
+  # @return [nil]
+  # @note Values larger than 10KB are not cached
+  # @note Non-GET requests and URLs with query parameters are not cached
   def write(key, value)
     return if value.is_a?(Array) && value.any? do |vv|
       req = JSON.parse(vv[0])
@@ -55,6 +104,8 @@ class Fbe::Middleware::SqliteStore
     nil
   end
 
+  # Clear all entries from the cache.
+  # @return [void]
   def clear
     perform do |t|
       t.execute 'DELETE FROM cache;'
@@ -63,6 +114,8 @@ class Fbe::Middleware::SqliteStore
     @db.execute 'VACUUM;'
   end
 
+  # Get all entries from the cache.
+  # @return [Array<Array>] Array of [key, value] pairs
   def all
     perform { _1.execute('SELECT key, value FROM cache') }
   end
@@ -84,15 +137,22 @@ class Fbe::Middleware::SqliteStore
           t.execute 'CREATE INDEX IF NOT EXISTS meta_key_idx ON meta(key);'
           t.execute "INSERT INTO meta(key, value) VALUES('version', ?) ON CONFLICT(key) DO NOTHING;", [@version]
         end
-        if d.execute("SELECT value FROM meta WHERE key = 'version' LIMIT 1;").dig(0, 0) != @version
+        found = d.execute("SELECT value FROM meta WHERE key = 'version' LIMIT 1;").dig(0, 0)
+        if found != @version
+          @loog.info("Version mismatch in SQLite cache: stored '#{found}' != current '#{@version}', cleaning up")
           d.transaction do |t|
             t.execute 'DELETE FROM cache;'
             t.execute "UPDATE meta SET value = ? WHERE key = 'version';", [@version]
           end
           d.execute 'VACUUM;'
         end
-        if File.size(@path) > 10 * 1024 * 1024
-          while d.execute(<<~SQL).dig(0, 0) > 10 * 1024 * 1024
+        if File.size(@path) > @maxsize
+          @loog.info(
+            "SQLite cache file size (#{File.size(@path)} bytes) exceeds " \
+            "#{@maxsize / 1024 / 1024}MB, cleaning up old entries"
+          )
+          deleted = 0
+          while d.execute(<<~SQL).dig(0, 0) > @maxsize
             SELECT (page_count - freelist_count) * page_size AS size
             FROM pragma_page_count(), pragma_freelist_count(), pragma_page_size();
           SQL
@@ -101,9 +161,11 @@ class Fbe::Middleware::SqliteStore
                 DELETE FROM cache
                 WHERE key IN (SELECT key FROM cache ORDER BY touched_at LIMIT 50)
               SQL
+              deleted += t.changes
             end
           end
           d.execute 'VACUUM;'
+          @loog.info("Deleted #{deleted} old cache entries, new file size: #{File.size(@path)} bytes")
         end
         at_exit { @db&.close }
       end

data/lib/fbe/octo.rb

@@ -25,6 +25,10 @@ require_relative 'middleware/sqlite_store'
 # logging, and caching.
 #
 # @param [Judges::Options] options The options available globally
+# @option options [String] :github_token GitHub API token for authentication
+# @option options [Boolean] :testing When true, uses FakeOctokit for testing
+# @option options [String] :sqlite_cache Path to SQLite cache file for HTTP responses
+# @option options [Integer] :sqlite_cache_maxsize Maximum size of SQLite cache in bytes (default: 10MB)
 # @param [Hash] global Hash of global options
 # @param [Loog] loog Logging facility
 # @return [Hash] Usually returns a JSON, as it comes from the GitHub API
@@ -77,11 +81,12 @@ def Fbe.octo(options: $options, global: $global, loog: $loog)
               backoff_factor: 2
             )
             if options.sqlite_cache
-              store = Fbe::Middleware::SqliteStore.new(options.sqlite_cache, Fbe::VERSION)
+              maxsize = options.sqlite_cache_maxsize || (10 * 1024 * 1024)
+              store = Fbe::Middleware::SqliteStore.new(options.sqlite_cache, Fbe::VERSION, loog:, maxsize:)
               loog.info(
                 "Using HTTP cache in SQLite file: #{store.path} (" \
-                "#{File.exist?(store.path) ? "#{File.size(store.path)} bytes" : 'file is absent'}" \
-                ')'
+                "#{File.exist?(store.path) ? "#{File.size(store.path)} bytes" : 'file is absent'}, " \
+                "max size: #{maxsize / 1024 / 1024}MB)"
               )
               builder.use(
                 Faraday::HttpCache,

data/lib/fbe.rb

@@ -10,5 +10,5 @@
 # License:: MIT
 module Fbe
   # Current version of the gem (changed by +.rultor.yml+ on every release)
-  VERSION = '0.20.0' unless const_defined?(:VERSION)
+  VERSION = '0.21.0' unless const_defined?(:VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fbe
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Yegor Bugayenko