litestack 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88034778fbac75441d1a9ed2e066ad6ba1aa4962eb48629de1d9ba7ae85f3468
-  data.tar.gz: d6ac66ffd1e78856bd74aa1d88163b95581494aaa481de88b673d84b5a8b8ff6
+  metadata.gz: 01c10017cec21bcabea357aecb8746779060718bb2e6b6e36f250c37d80656f1
+  data.tar.gz: 863b319c7a658f2a19410c614035068f8a2dec72b189698a5a081f595ecf5853
 SHA512:
-  metadata.gz: 37043f1eab519ea41e81e5b9cb6b20798ea5f6e7ed7ce99d8105454067129e7f49f4b8357b0855948e6df51bf6d466966802085b67943b1f9416ee90f443502a
-  data.tar.gz: 602d0e03d53eeb8e780c31b2f9bb1b3add550035c3cb3fd07f1d14fe94d94aea50a93dea19ab819454465c7824249bb40f7768ec4eebf6662af713218175071d
+  metadata.gz: 7bb0fd84ee582eddfe32e48b0373a7545cad8581217ba56d7ac6c984b60b137b86d5196e1bc37486b88d21c28bc5ff62da573a1ba6ce6b49d66ba744ddbcabc6
+  data.tar.gz: 38da99eae6a37222a8689577900504ea1b131f0ec56f67531dff00f5ae4f4c62a29baca21ba2a102435cc334773f8ef4709a361dff6f28de988471eac0937e08

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.1.6] - 2022-03-03
+
+- Revamped the locking model, more robust, minimal performance hit
+- Introduced a new resource pooling class
+- Litecache and Litejob now use the resource pool
+- Much less memory usage for Litecache and Litejob
+
 ## [0.1.0] - 2022-02-26
 
 - Initial release

data/README.md

@@ -152,9 +152,9 @@ You can add more configuration in litejob.yml (or config/litejob.yml if you are
 
 ```yaml
 queues:
-    - [default 1]
-    - [urgent 5]
-    - [critical 10 "spawn"]
+    - [default, 1]
+    - [urgent, 5]
+    - [critical, 10, "spawn"]
 ```
 
 The queues need to include a name and a priority (a number between 1 and 10) and can also optionally add the token "spawn", which means every job will run it its own concurrency context (thread or fiber)

data/bench/bench_cache_raw.rb

@@ -9,7 +9,7 @@ Fiber.set_scheduler Async::Scheduler.new
 Fiber.scheduler.run
 
 require_relative '../lib/litestack'
-
+#require 'litestack'
 
 cache = Litecache.new({path: '../db/cache.db'}) # default settings
 redis = Redis.new # default settings

data/bench/bench_queue.rb

@@ -5,11 +5,11 @@ count = 1000
 
 q = Litequeue.new({path: '../db/queue.db' })
 
-bench("enqueue", count) do |i|
+bench("Litequeue enqueue", count) do |i|
   q.push i.to_s
 end
 
-bench("dequeue", count) do |i|
+bench("Litequeue dequeue", count) do |i|
   q.pop  
 end
 

data/lib/active_support/cache/litecache.rb

@@ -25,12 +25,14 @@ module ActiveSupport
       def increment(key, amount = 1, options = nil)
         key = key.to_s
         options = merged_options(options)
-        @cache.transaction(:immediate) do
+        # todo: fix me
+        # this is currently a hack to avoid dealing with Rails cache encoding and decoding
+        #@cache.transaction(:immediate) do
           if value = read(key, options)
             value = value.to_i + amount
             write(key, value, options)
           end
-        end
+        #end
       end
 
       def decrement(key, amount = 1, options = nil)

data/lib/litestack/litecache.rb

@@ -72,9 +72,7 @@ class Litecache
       :counter => "SELECT count(*) FROM data",
       :sizer => "SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count" 
     }
-    @cache = create_store
-    @stmts = {}
-    @sql.each_pair{|k, v| @stmts[k] = @cache.prepare(v)}
+    @cache = Litesupport::Pool.new(1){create_db}
     @stats = {hit: 0, miss: 0}
     @last_visited = {}
     @running = true
@@ -85,12 +83,14 @@ class Litecache
   def set(key, value, expires_in = nil)
     key = key.to_s
     expires_in = @options[:expires_in] if expires_in.nil? or expires_in.zero?
-    begin
-      @stmts[:setter].execute!(key, value, expires_in)
-    rescue SQLite3::FullException
-      @stmts[:extra_pruner].execute!(0.2)
-      @cache.execute("vacuum")
-      retry
+    @cache.acquire do |cache|
+      begin
+        cache.stmts[:setter].execute!(key, value, expires_in)
+      rescue SQLite3::FullException
+        cache.stmts[:extra_pruner].execute!(0.2)
+        cache.execute("vacuum")
+        retry
+      end
     end
     return true
   end
@@ -99,15 +99,18 @@ class Litecache
   def set_unless_exists(key, value, expires_in = nil)
     key = key.to_s
     expires_in = @options[:expires_in] if expires_in.nil? or expires_in.zero?
-    begin
-      transaction(:immediate) do
-        @stmts[:inserter].execute!(key, value, expires_in)
-        changes = @cache.changes
+    changes = 0
+    @cache.acquire do |cache|
+      begin
+        transaction(:immediate) do
+          cache.stmts[:inserter].execute!(key, value, expires_in)
+          changes = @cache.changes
+        end
+      rescue SQLite3::FullException
+        cache.stmts[:extra_pruner].execute!(0.2)
+        cache.execute("vacuum")
+        retry
       end
-    rescue SQLite3::FullException
-      @stmts[:extra_pruner].execute!(0.2)
-      @cache.execute("vacuum")
-      retry
     end
     return changes > 0
   end
@@ -116,7 +119,7 @@ class Litecache
   # if the key doesn't exist or it is expired then null will be returned
   def get(key)
     key = key.to_s
-    if record = @stmts[:getter].execute!(key)[0]
+    if record = @cache.acquire{|cache| cache.stmts[:getter].execute!(key)[0] }
       @last_visited[key] = true
       @stats[:hit] +=1
       return record[1]
@@ -127,14 +130,18 @@ class Litecache
   
   # delete a key, value pair from the cache
   def delete(key)
-    @stmts[:deleter].execute!(key)
-    return @cache.changes > 0
+    changes = 0
+    @cache.aquire do |cache|
+      cache.stmts[:deleter].execute!(key)
+      changes = cache.changes
+    end
+    return changes > 0
   end
   
   # increment an integer value by amount, optionally add an expiry value (in seconds)
   def increment(key, amount, expires_in = nil)
     expires_in = @expires_in unless expires_in
-    @stmts[:incrementer].execute!(key.to_s, amount, expires_in)
+    @cache.acquire{|cache| cache.stmts[:incrementer].execute!(key.to_s, amount, expires_in) }
   end
   
   # decrement an integer value by amount, optionally add an expiry value (in seconds)
@@ -144,43 +151,43 @@ class Litecache
   
   # delete all entries in the cache up limit (ordered by LRU), if no limit is provided approximately 20% of the entries will be deleted
   def prune(limit=nil)
-    if limit and limit.is_a? Integer
-      @stmts[:limited_pruner].execute!(limit)
-    elsif limit and limit.is_a? Float
-      @stmts[:extra_pruner].execute!(limit)
-    else
-      @stmts[:pruner].execute!      
+    @cache.acquire do |cache|
+      if limit and limit.is_a? Integer
+        cache.stmts[:limited_pruner].execute!(limit)
+      elsif limit and limit.is_a? Float
+        cache.stmts[:extra_pruner].execute!(limit)
+      else
+        cache.stmts[:pruner].execute!      
+      end
     end
   end
   
   # return the number of key, value pairs in the cache
   def count
-    @stmts[:counter].execute!.to_a[0][0]
+    @cache.acquire{|cache| cache.stmts[:counter].execute!.to_a[0][0] }
   end
   
   # return the actual size of the cache file
   def size
-    @stmts[:sizer].execute!.to_a[0][0]
+    @cache.acquire{|cache| cache.stmts[:sizer].execute!.to_a[0][0] }
   end
   
   # delete all key, value pairs in the cache
   def clear
-    @cache.execute("delete FROM data")
+    @cache.acquire{|cache| cache.execute("delete FROM data") }
   end
   
   # close the connection to the cache file
   def close
     @running = false
     #Litesupport.synchronize do
-    @cache.close
+    @cache.acquire{|cache| cache.close }
     #end
   end
   
   # return the maximum size of the cache
   def max_size
-    Litesupport.synchronize do
-      @cache.get_first_value("SELECT s.page_size * c.max_page_count FROM pragma_page_size() as s, pragma_max_page_count() as c")
-    end
+    @cache.acquire{|cache| cache.get_first_value("SELECT s.page_size * c.max_page_count FROM pragma_page_size() as s, pragma_max_page_count() as c") }
   end
   
   # hits and misses for get operations performed over this particular connection (not cache wide)
@@ -192,8 +199,10 @@ class Litecache
 
   # low level access to SQLite transactions, use with caution
   def transaction(mode)
-    @cache.transaction(mode) do
-      yield
+    @cache.acquire do |cache|
+      cache.transaction(mode) do
+        yield
+      end
     end
   end
 
@@ -201,35 +210,29 @@ class Litecache
   
   def spawn_worker
     Litesupport.spawn do
-      # create a specific cache instance for this worker
-      # to overcome SQLite3 Database is locked error
-      cache = create_store
-      stmts = {}
-      [:toucher, :pruner, :extra_pruner].each do |stmt|
-        stmts[stmt] = cache.prepare(@sql[stmt])
-      end
       while @running
-        Litesupport.synchronize do
+        @cache.acquire do |cache|
           begin
             cache.transaction(:immediate) do
               @last_visited.delete_if do |k| # there is a race condition here, but not a serious one
-                stmts[:toucher].execute!(k) || true
+                cache.stmts[:toucher].execute!(k) || true
               end
-              stmts[:pruner].execute!             
+              cache.stmts[:pruner].execute!             
             end
           rescue SQLite3::BusyException
             retry
           rescue SQLite3::FullException
-            stmts[:extra_pruner].execute!(0.2)
+            cache.stmts[:extra_pruner].execute!(0.2)
+          rescue Exception
+            # database is closed
           end
         end
         sleep @options[:sleep_interval]
       end
-      cache.close
     end
   end
   
-  def create_store
+  def create_db
     db = Litesupport.create_db(@options[:path])
     db.synchronous = 0
     db.cache_size = 2000
@@ -240,6 +243,7 @@ class Litecache
     db.execute("CREATE table if not exists data(id text primary key, value text, expires_in integer, last_used integer)")
     db.execute("CREATE index if not exists expiry_index on data (expires_in)")
     db.execute("CREATE index if not exists last_used_index on data (last_used)")
+    @sql.each_pair{|k, v| db.stmts[k] = db.prepare(v)}
     db
   end
   

data/lib/litestack/litejobqueue.rb

@@ -116,16 +116,13 @@ class Litejobqueue
   # create a worker according to environment
   def create_worker
     Litesupport.spawn do
-      # we create a queue object specific to this worker here
-      # this way we can survive potential SQLite3 Database is locked errors
-      queue = Litequeue.new(@options)
       loop do
         processed = 0
         @queues.each do |level| # iterate through the levels
           level[1].each do |q| # iterate through the queues in the level
             index = 0
             max = level[0]
-            while index < max && payload = queue.pop(q[0])  
+            while index < max && payload = @queue.pop(q[0]) # fearlessly use the same queue object 
               processed += 1
               index += 1
               begin

data/lib/litestack/litequeue.rb

@@ -34,15 +34,18 @@ class Litequeue
   
   def initialize(options = {})
     @options = DEFAULT_OPTIONS.merge(options)
-    @queue = create_db #(@options[:path])
-    prepare
+    @queue = Litesupport::Pool.new(1){create_db} # delegate the db creation to the litepool
   end
    
   # push an item to the queue, optionally specifying the queue name (defaults to default) and after how many seconds it should be ready to pop (defaults to zero)
   # a unique job id is returned from this method, can be used later to delete it before it fires. You can push string, integer, float, true, false or nil values
   #
   def push(value, delay=0, queue='default')
-    result = @push.execute!(queue, delay, value)[0]
+    # @todo - check if queue is busy, back off if it is
+    # also bring back the synchronize block, to prevent
+    # a race condition if a thread hits the busy handler
+    # before the current thread proceeds after a backoff
+    result = @queue.acquire { |q| q.stmts[:push].execute!(queue, delay, value)[0] }
     return result[0] if result
   end
   
@@ -50,7 +53,7 @@ class Litequeue
   
   # pop an item from the queue, optionally with a specific queue name (default queue name is 'default')
   def pop(queue='default')
-    @pop.execute!(queue)[0]
+    @queue.acquire {|q| q.stmts[:pop].execute!(queue)[0] }
   end
   
   # delete an item from the queue
@@ -60,22 +63,22 @@ class Litequeue
   #   queue.pop # => nil
   def delete(id, queue='default')
     fire_at, id = id.split("_")
-    result = @deleter.execute!(queue, fire_at.to_i, id)[0]
+    result = @queue.acquire{|q| q.stmts[:delete].execute!(queue, fire_at.to_i, id)[0] } 
   end
   
   # deletes all the entries in all queues, or if a queue name is given, deletes all entries in that specific queue
   def clear(queue=nil)
-    @queue.execute("DELETE FROM _ul_queue_ WHERE iif(?, queue = ?,  1)", queue)
+    @queue.acquire{|q| q.execute("DELETE FROM _ul_queue_ WHERE iif(?, queue = ?,  1)", queue) }
   end
 
   # returns a count of entries in all queues, or if a queue name is given, reutrns the count of entries in that queue
   def count(queue=nil)
-    @queue.get_first_value("SELECT count(*) FROM _ul_queue_ WHERE iif(?, queue = ?, 1)", queue)
+    @queue.acquire{|q| q.get_first_value("SELECT count(*) FROM _ul_queue_ WHERE iif(?, queue = ?, 1)", queue) }
   end
   
   # return the size of the queue file on disk
   def size
-    @queue.get_first_value("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count")
+    @queue.acquire{|q| q.get_first_value("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count") }
   end
 
   private  
@@ -86,14 +89,12 @@ class Litequeue
     db.wal_autocheckpoint = 10000 
     db.mmap_size = @options[:mmap_size]
     db.execute("CREATE TABLE IF NOT EXISTS _ul_queue_(queue TEXT DEFAULT('default') NOT NULL ON CONFLICT REPLACE, fire_at INTEGER DEFAULT(unixepoch()) NOT NULL ON CONFLICT REPLACE, id TEXT DEFAULT(hex(randomblob(8)) || (strftime('%f') * 100)) NOT NULL ON CONFLICT REPLACE, value TEXT, created_at INTEGER DEFAULT(unixepoch()) NOT NULL ON CONFLICT REPLACE, PRIMARY KEY(queue, fire_at ASC, id) ) WITHOUT ROWID")
+    db.stmts[:push] = db.prepare("INSERT INTO _ul_queue_(queue, fire_at, value) VALUES ($1, (strftime('%s') + $2), $3) RETURNING fire_at || '-' || id")
+    db.stmts[:pop] = db.prepare("DELETE FROM _ul_queue_ WHERE (queue, fire_at, id) = (SELECT queue, min(fire_at), id FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at <= (unixepoch()) limit 1) RETURNING fire_at || '-' || id, value")
+    db.stmts[:delete] = db.prepare("DELETE FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at = $2 AND id = $3 RETURNING value")
     db
   end
 
-  def prepare
-     @push = @queue.prepare("INSERT INTO _ul_queue_(queue, fire_at, value) VALUES ($1, (strftime('%s') + $2), $3) RETURNING fire_at || '-' || id")
-     @pop = @queue.prepare("DELETE FROM _ul_queue_ WHERE (queue, fire_at, id) = (SELECT queue, min(fire_at), id FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at <= (unixepoch()) limit 1) RETURNING fire_at || '-' || id, value")
-     @deleter = @queue.prepare("DELETE FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at = $2 AND id = $3 RETURNING value")
-  end
 
 end  
 

data/lib/litestack/litesupport.rb

@@ -33,6 +33,18 @@ module Litesupport
     # we should never reach here
   end
   
+  def self.detect_context
+    if environment == :fiber || environment == :poylphony
+      Fiber.current.storage
+    else
+      Thread.current
+    end
+  end
+  
+  def self.context
+    @ctx ||= detect_context
+  end
+  
   # switch the execution context to allow others to run
   def self.switch
     if self.environment == :fiber
@@ -71,7 +83,65 @@ module Litesupport
     db = SQLite3::Database.new(path)
     db.busy_handler{ switch || sleep(0.001) }
     db.journal_mode = "WAL"
+    db.instance_variable_set(:@stmts, {})
+    class << db
+      attr_reader :stmts
+    end
     db
   end
   
+  class Mutex
+  
+    def initialize
+      @mutex = Thread::Mutex.new
+    end
+    
+    def synchronize(&block)
+      if Litesupport.environment == :threaded || Litesupport.environment == :iodine
+        @mutex.synchronize{ block.call }
+      else
+        block.call
+      end
+    end
+  
+  end
+  
+  class Pool
+  
+    def initialize(count, &block)
+      @count = count
+      @block = block
+      @resources = []
+      @mutex = Litesupport::Mutex.new
+      @count.times do
+        resource = @mutex.synchronize{ block.call }
+        @resources << [resource, :free]
+      end
+    end
+    
+    def acquire
+      acquired = false
+      result = nil
+      while !acquired do
+        @mutex.synchronize do
+          if resource = @resources.find{|r| r[1] == :free}
+            resource[1] = :busy
+            begin
+              result = yield resource[0]
+            rescue Exception => e
+              raise e
+            ensure
+              resource[1] = :free
+              acquired = true
+              return nil              
+            end
+          end
+        end
+        sleep 0.0001 unless acquired
+      end
+      result
+    end
+    
+  end
+  
 end  

data/lib/litestack/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Litestack
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end       

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: litestack
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Mohamed Hassan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-27 00:00:00.000000000 Z
+date: 2023-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3