rubydb 0.1.4 → 0.1.6

data/lib/rubydb/concurrency/worker_pool.rb

@@ -1,143 +1,145 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Concurrency
-    # WorkerPool - Manages a pool of worker threads
-    class WorkerPool
-      attr_reader :stats, :size, :active_count, :idle_count
-
-      def initialize(config = {})
-        @size = config[:size] || Etc.nprocessors
-        @max_size = config[:max_size] || @size * 2
-        @min_size = config[:min_size] || [1, @size].min
-        @workers = []
-        @task_queue = Queue.new
-        @stats = {
-          tasks_processed: 0,
-          tasks_failed: 0,
-          tasks_queued: 0,
-          avg_processing_time_ms: 0,
-          total_processing_time_ms: 0,
-          worker_creations: 0,
-          worker_destructions: 0
-        }
-        @shutdown = false
-        @lock = Mutex.new
-        @cond = ConditionVariable.new
-        @idle_count = 0
-        @active_count = 0
-        @worker_id_counter = 0
-
-        # Pre-create workers
-        @size.times { create_worker }
-      end
-
-      def submit(task)
-        @task_queue << task
-        @stats[:tasks_queued] += 1
-        @cond.signal
-        task
-      end
-
-      def submit_block(&block)
-        submit(block)
-      end
-
-      def shutdown(wait = true)
-        @lock.synchronize do
-          @shutdown = true
-          @cond.broadcast
-
-          if wait
-            @workers.each(&:join)
-          end
-        end
-      end
-
-      def resize(new_size)
-        @lock.synchronize do
-          new_size = [new_size, @min_size].max
-          new_size = [new_size, @max_size].min
-
-          if new_size > @workers.size
-            (new_size - @workers.size).times { create_worker }
-          elsif new_size < @workers.size
-            (new_size - @workers.size).times do
-              worker = @workers.pop
-              worker&.kill
-              @stats[:worker_destructions] += 1
-            end
-          end
-
-          @size = new_size
-        end
-      end
-
-      def stats
-        @lock.synchronize do
-          @stats.merge({
-            size: @size,
-            workers: @workers.size,
-            active: @active_count,
-            idle: @idle_count,
-            queue_size: @task_queue.size,
-            max_size: @max_size,
-            min_size: @min_size,
-            shutdown: @shutdown
-          })
-        end
-      end
-
-      private
-
-      def create_worker
-        @worker_id_counter += 1
-        worker_id = @worker_id_counter
-
-        worker = Thread.new do
-          worker_loop(worker_id)
-        end
-
-        @workers << worker
-        @stats[:worker_creations] += 1
-        worker
-      end
-
-      def worker_loop(worker_id)
-        while !@shutdown
-          task = nil
-
-          begin
-            task = @task_queue.pop
-            @lock.synchronize { @idle_count -= 1; @active_count += 1 }
-
-            start_time = Time.now
-
-            if task.is_a?(Proc)
-              task.call
-            elsif task.respond_to?(:call)
-              task.call
-            end
-
-            processing_time = (Time.now - start_time) * 1000
-            @lock.synchronize do
-              @stats[:tasks_processed] += 1
-              @stats[:total_processing_time_ms] += processing_time
-              @stats[:avg_processing_time_ms] = @stats[:total_processing_time_ms] / @stats[:tasks_processed]
-            end
-
-          rescue => e
-            @lock.synchronize do
-              @stats[:tasks_failed] += 1
-            end
-          ensure
-            @lock.synchronize do
-              @active_count -= 1
-              @idle_count += 1
-            end
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Concurrency
+    # WorkerPool - Manages a pool of worker threads
+    class WorkerPool
+      attr_reader :stats, :size, :active_count, :idle_count
+
+      def initialize(config = {})
+        @size = config[:size] || Etc.nprocessors
+        @max_size = config[:max_size] || @size * 2
+        @min_size = config[:min_size] || [1, @size].min
+        @workers = []
+        @task_queue = Queue.new
+        @stats = {
+          tasks_processed: 0,
+          tasks_failed: 0,
+          tasks_queued: 0,
+          avg_processing_time_ms: 0,
+          total_processing_time_ms: 0,
+          worker_creations: 0,
+          worker_destructions: 0
+        }
+        @shutdown = false
+        @lock = Mutex.new
+        @cond = ConditionVariable.new
+        @idle_count = 0
+        @active_count = 0
+        @worker_id_counter = 0
+
+        # Pre-create workers
+        @size.times { create_worker }
+      end
+
+      def submit(task)
+        @task_queue << task
+        @stats[:tasks_queued] += 1
+        @cond.signal
+        task
+      end
+
+      def submit_block(&block)
+        submit(block)
+      end
+
+      def shutdown(wait = true)
+        @lock.synchronize do
+          @shutdown = true
+          @cond.broadcast
+
+          if wait
+            @workers.each(&:join)
+          end
+        end
+      end
+
+      def resize(new_size)
+        @lock.synchronize do
+          new_size = [new_size, @min_size].max
+          new_size = [new_size, @max_size].min
+
+          if new_size > @workers.size
+            (new_size - @workers.size).times { create_worker }
+          elsif new_size < @workers.size
+            (new_size - @workers.size).times do
+              worker = @workers.pop
+              worker&.kill
+              @stats[:worker_destructions] += 1
+            end
+          end
+
+          @size = new_size
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            size: @size,
+            workers: @workers.size,
+            active: @active_count,
+            idle: @idle_count,
+            queue_size: @task_queue.size,
+            max_size: @max_size,
+            min_size: @min_size,
+            shutdown: @shutdown
+          })
+        end
+      end
+
+      private
+
+      def create_worker
+        @worker_id_counter += 1
+        worker_id = @worker_id_counter
+
+        worker = Thread.new do
+          worker_loop(worker_id)
+        end
+
+        @workers << worker
+        @stats[:worker_creations] += 1
+        worker
+      end
+
+      def worker_loop(worker_id)
+        until @shutdown
+          task = nil
+
+          begin
+            task = @task_queue.pop
+            @lock.synchronize {
+              @idle_count -= 1
+              @active_count += 1
+            }
+
+            start_time = Time.now
+
+            if task.is_a?(Proc)
+              task.call
+            elsif task.respond_to?(:call)
+              task.call
+            end
+
+            processing_time = (Time.now - start_time) * 1000
+            @lock.synchronize do
+              @stats[:tasks_processed] += 1
+              @stats[:total_processing_time_ms] += processing_time
+              @stats[:avg_processing_time_ms] = @stats[:total_processing_time_ms] / @stats[:tasks_processed]
+            end
+          rescue
+            @lock.synchronize do
+              @stats[:tasks_failed] += 1
+            end
+          ensure
+            @lock.synchronize do
+              @active_count -= 1
+              @idle_count += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/configuration/config.rb

@@ -1,170 +1,170 @@
-# frozen_string_literal: true
-
-require "singleton"
-
-module RubyDB
-  module Configuration
-    # Config - Main configuration access point
-    class Config
-      include Singleton
-
-      attr_reader :environment, :parser, :validation
-
-      def initialize
-        @environment = Environment.new
-        @parser = Parser.new
-        @validation = Validation.new
-        @loaded = false
-        @config_path = nil
-        @config = {}
-        @lock = Mutex.new
-      end
-
-      def self.load(config_path = nil)
-        instance.load(config_path)
-      end
-
-      def self.get(path)
-        instance.get(path)
-      end
-
-      def self.set(path, value)
-        instance.set(path, value)
-      end
-
-      def self.[](key)
-        instance[key]
-      end
-
-      def self.[]=(key, value)
-        instance[key] = value
-      end
-
-      def self.to_hash
-        instance.to_hash
-      end
-
-      def self.valid?
-        instance.valid?
-      end
-
-      def self.errors
-        instance.errors
-      end
-
-      def self.warnings
-        instance.warnings
-      end
-
-      def self.environment
-        instance.environment.name
-      end
-
-      def self.environment=(env)
-        instance.environment = env
-      end
-
-      def load(config_path = nil)
-        @lock.synchronize do
-          @config_path = config_path
-          @config = @environment.load(config_path)
-          @loaded = true
-          @config
-        end
-      end
-
-      def reload
-        config_path = @lock.synchronize do
-          @loaded = false
-          @config_path
-        end
-        load(config_path)
-      end
-
-      def get(path)
-        ensure_loaded
-        @environment.get(path)
-      end
-
-      def set(path, value)
-        ensure_loaded
-        @environment.set(path, value)
-      end
-
-      def [](key)
-        ensure_loaded
-        @environment[key]
-      end
-
-      def []=(key, value)
-        ensure_loaded
-        @environment[key] = value
-      end
-
-      def to_hash
-        ensure_loaded
-        @environment.to_hash
-      end
-
-      def valid?
-        ensure_loaded
-        @environment.valid?
-      end
-
-      def errors
-        ensure_loaded
-        @environment.errors
-      end
-
-      def warnings
-        ensure_loaded
-        @environment.warnings
-      end
-
-      def environment=(env)
-        @lock.synchronize do
-          @environment = Environment.new(env)
-          @loaded = false
-        end
-      end
-
-      def environment
-        @environment.name
-      end
-
-      def production?
-        @environment.production?
-      end
-
-      def development?
-        @environment.development?
-      end
-
-      def test?
-        @environment.test?
-      end
-
-      def staging?
-        @environment.staging?
-      end
-
-      def stats
-        {
-          loaded: @loaded,
-          config_path: @config_path,
-          environment: environment,
-          config_keys: @config.keys.size,
-          errors: errors.size,
-          warnings: warnings.size,
-          valid: valid?
-        }
-      end
-
-      private
-
-      def ensure_loaded
-        load unless @loaded
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "singleton"
+
+module RubyDB
+  module Configuration
+    # Config - Main configuration access point
+    class Config
+      include Singleton
+
+      attr_reader :environment, :parser, :validation
+
+      def initialize
+        @environment = Environment.new
+        @parser = Parser.new
+        @validation = Validation.new
+        @loaded = false
+        @config_path = nil
+        @config = {}
+        @lock = Mutex.new
+      end
+
+      def self.load(config_path = nil)
+        instance.load(config_path)
+      end
+
+      def self.get(path)
+        instance.get(path)
+      end
+
+      def self.set(path, value)
+        instance.set(path, value)
+      end
+
+      def self.[](key)
+        instance[key]
+      end
+
+      def self.[]=(key, value)
+        instance[key] = value
+      end
+
+      def self.to_hash
+        instance.to_hash
+      end
+
+      def self.valid?
+        instance.valid?
+      end
+
+      def self.errors
+        instance.errors
+      end
+
+      def self.warnings
+        instance.warnings
+      end
+
+      def self.environment
+        instance.environment.name
+      end
+
+      def self.environment=(env)
+        instance.environment = env
+      end
+
+      def load(config_path = nil)
+        @lock.synchronize do
+          @config_path = config_path
+          @config = @environment.load(config_path)
+          @loaded = true
+          @config
+        end
+      end
+
+      def reload
+        config_path = @lock.synchronize do
+          @loaded = false
+          @config_path
+        end
+        load(config_path)
+      end
+
+      def get(path)
+        ensure_loaded
+        @environment.get(path)
+      end
+
+      def set(path, value)
+        ensure_loaded
+        @environment.set(path, value)
+      end
+
+      def [](key)
+        ensure_loaded
+        @environment[key]
+      end
+
+      def []=(key, value)
+        ensure_loaded
+        @environment[key] = value
+      end
+
+      def to_hash
+        ensure_loaded
+        @environment.to_hash
+      end
+
+      def valid?
+        ensure_loaded
+        @environment.valid?
+      end
+
+      def errors
+        ensure_loaded
+        @environment.errors
+      end
+
+      def warnings
+        ensure_loaded
+        @environment.warnings
+      end
+
+      def environment=(env)
+        @lock.synchronize do
+          @environment = Environment.new(env)
+          @loaded = false
+        end
+      end
+
+      def environment
+        @environment.name
+      end
+
+      def production?
+        @environment.production?
+      end
+
+      def development?
+        @environment.development?
+      end
+
+      def test?
+        @environment.test?
+      end
+
+      def staging?
+        @environment.staging?
+      end
+
+      def stats
+        {
+          loaded: @loaded,
+          config_path: @config_path,
+          environment: environment,
+          config_keys: @config.keys.size,
+          errors: errors.size,
+          warnings: warnings.size,
+          valid: valid?
+        }
+      end
+
+      private
+
+      def ensure_loaded
+        load unless @loaded
+      end
+    end
+  end
+end