natswork-server 0.0.1

data/lib/natswork/retry_handler.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module NatsWork
+  class RetryHandler
+    DEFAULT_MAX_RETRIES = 3
+    DEFAULT_BASE_DELAY = 1
+    DEFAULT_MAX_DELAY = 300 # 5 minutes
+
+    attr_reader :base_delay, :max_delay, :jitter, :strategy
+
+    def initialize(options = {})
+      @base_delay = options[:base_delay] || DEFAULT_BASE_DELAY
+      @max_delay = options[:max_delay] || DEFAULT_MAX_DELAY
+      @jitter = options[:jitter] || false
+      @strategy = options[:strategy] || :exponential
+
+      @retry_callbacks = []
+      @failure_callbacks = []
+    end
+
+    def should_retry?(job_message)
+      retry_count = job_message['retry_count'] || 0
+      max_retries = job_message['max_retries'] || DEFAULT_MAX_RETRIES
+
+      retry_count < max_retries
+    end
+
+    def calculate_delay(attempt)
+      delay = case @strategy
+              when :exponential
+                @base_delay * (2**attempt)
+              when :linear
+                @base_delay * (attempt + 1)
+              when :constant
+                @base_delay
+              when Proc
+                @strategy.call(attempt)
+              else
+                @base_delay * (2**attempt)
+              end
+
+      # Apply max delay cap
+      delay = [delay, @max_delay].min
+
+      # Apply jitter if enabled (±10% randomness)
+      if @jitter && delay.positive?
+        jitter_amount = delay * 0.1
+        delay += (rand * 2 - 1) * jitter_amount
+      end
+
+      delay
+    end
+
+    def schedule_retry(connection, job_message, error)
+      retry_count = (job_message['retry_count'] || 0) + 1
+      delay = calculate_delay(retry_count - 1)
+
+      retry_message = job_message.merge(
+        'retry_count' => retry_count,
+        'retry_at' => (Time.now + delay).iso8601,
+        'last_error' => {
+          'type' => error.class.name,
+          'message' => error.message,
+          'backtrace' => error.backtrace&.first(10) || []
+        }
+      )
+
+      # Track retry history
+      retry_history = retry_message['retry_history'] || []
+      retry_history << {
+        'attempt' => retry_count,
+        'error' => error.message,
+        'retried_at' => Time.now.iso8601
+      }
+      retry_message['retry_history'] = retry_history
+
+      # Publish to retry queue
+      retry_queue = "natswork.queue.retry.#{job_message['queue'] || 'default'}"
+      connection.publish(retry_queue, retry_message)
+
+      # Call retry callbacks
+      @retry_callbacks.each do |callback|
+        callback.call(job_message, error)
+      end
+    end
+
+    def send_to_dead_letter(connection, job_message, error)
+      dead_letter_message = job_message.merge(
+        'final_error' => {
+          'type' => error.class.name,
+          'message' => error.message,
+          'backtrace' => error.backtrace || []
+        },
+        'failed_at' => Time.now.iso8601,
+        'exhausted_retries' => true,
+        'total_attempts' => (job_message['retry_count'] || 0) + 1
+      )
+
+      connection.publish('natswork.queue.dead_letter', dead_letter_message)
+
+      # Call failure callbacks
+      @failure_callbacks.each do |callback|
+        callback.call(job_message, error)
+      end
+    end
+
+    def on_retry(&block)
+      @retry_callbacks << block
+    end
+
+    def on_failure(&block)
+      @failure_callbacks << block
+    end
+
+    def handle_failure(connection, job_message, error)
+      if should_retry?(job_message)
+        schedule_retry(connection, job_message, error)
+      else
+        send_to_dead_letter(connection, job_message, error)
+      end
+    end
+  end
+end

data/lib/natswork/server/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module NatsWork
+  module Server
+    VERSION = '0.0.1'
+  end
+end

data/lib/natswork/server.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'natswork/server/version'
+require 'concurrent'
+
+module NatsWork
+  module Server
+    class Error < StandardError; end
+
+    class << self
+      attr_accessor :worker_manager
+
+      def start
+        require 'natswork'
+        NatsWork.logger.info 'Starting NatsWork Server...'
+
+        # Initialize connection
+        NatsWork::Client.start
+
+        # Start worker manager with pool size as concurrency
+        self.worker_manager = WorkerManager.new(
+          concurrency: NatsWork.config.pool_size || 5
+        )
+        worker_manager.start
+
+        NatsWork.logger.info "NatsWork Server started with #{NatsWork.config.pool_size || 5} workers"
+      end
+
+      def stop
+        NatsWork.logger.info 'Stopping NatsWork Server...'
+        worker_manager&.stop
+        NatsWork::Client.stop if defined?(NatsWork::Client)
+        NatsWork.logger.info 'NatsWork Server stopped'
+      end
+
+      def running?
+        worker_manager&.running? || false
+      end
+    end
+
+    # Auto-load server components
+    autoload :Worker, 'natswork/worker'
+    autoload :WorkerManager, 'natswork/worker_manager'
+    autoload :JobExecutor, 'natswork/job_executor'
+    autoload :MiddlewareChain, 'natswork/middleware_chain'
+  end
+end

data/lib/natswork/simple_worker.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module NatsWork
+  module Server
+    class SimpleWorker
+      attr_reader :id, :pool, :queues
+
+      def initialize(id, queues = nil)
+        @id = id
+        @queues = queues || NatsWork.config.worker_queues || ['default']
+        @pool = Concurrent::FixedThreadPool.new(5)
+        @running = false
+        @subscriptions = []
+      end
+
+      def start
+        @running = true
+        NatsWork.logger.info "Worker #{@id} starting..."
+
+        # Subscribe to job queues
+        subscribe_to_queues
+      end
+
+      def stop
+        @running = false
+
+        # Unsubscribe from all queues
+        @subscriptions.each do |sid|
+          NatsWork::Client.instance.connection_pool.with_connection do |conn|
+            conn.unsubscribe(sid)
+          end
+        rescue StandardError => e
+          NatsWork.logger.error "Error unsubscribing: #{e.message}"
+        end
+
+        @subscriptions.clear
+        NatsWork.logger.info "Worker #{@id} stopped"
+      end
+
+      private
+
+      def subscribe_to_queues
+        # Subscribe to configured queues
+        @queues.each do |queue|
+          subject = "natswork.queue.#{queue}"
+
+          NatsWork::Client.instance.connection_pool.with_connection do |conn|
+            sid = conn.subscribe(subject, queue: "workers.#{queue}") do |msg|
+              # Process job in thread pool
+              @pool.post do
+                process_job(msg, queue)
+              end
+            end
+
+            @subscriptions << sid
+            NatsWork.logger.info "Worker #{@id} subscribed to #{subject}"
+          end
+        end
+      rescue StandardError => e
+        NatsWork.logger.error "Worker #{@id} subscription error: #{e.message}"
+      end
+
+      def process_job(msg, queue)
+        return unless @running
+
+        begin
+          # Parse the message - it comes as a hash from NATS subscription
+          job_data = if msg.is_a?(Hash)
+                       # Message comes pre-parsed from NATS subscription
+                       msg.transform_keys(&:to_sym)
+                     elsif msg.is_a?(String)
+                       JSON.parse(msg, symbolize_names: true)
+                     else
+                       msg
+                     end
+
+          NatsWork.logger.info "Worker #{@id} processing job from #{queue}: #{job_data[:job_class]}"
+
+          # Execute the job directly
+          job_class_name = job_data[:job_class] || job_data['job_class']
+          arguments = job_data[:arguments] || job_data['arguments'] || {}
+
+          # Get the job class
+          job_class = Object.const_get(job_class_name)
+
+          # Create job instance and execute
+          raise "Unknown job class: #{job_class_name}" unless job_class.respond_to?(:new)
+
+          job_instance = job_class.new
+          job_instance.perform(arguments)
+          NatsWork.logger.info "Worker #{@id} completed job: #{job_data[:job_id]}"
+        rescue StandardError => e
+          NatsWork.logger.error "Worker #{@id} job error: #{e.message}"
+          NatsWork.logger.error e.backtrace[0..5].join("\n") if e.backtrace
+        end
+      end
+    end
+  end
+end

data/lib/natswork/thread_pool.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require 'concurrent'
+
+module NatsWork
+  class ThreadPoolError < StandardError; end
+
+  class ThreadPool
+    attr_reader :size, :max_queue_size
+
+    def initialize(size: 10, max_queue: nil)
+      @size = size
+      @max_queue_size = max_queue
+
+      # Use SizedQueue for limited queue, regular Queue otherwise
+      if max_queue&.positive?
+        @queue = SizedQueue.new(max_queue)
+        @limited = true
+      else
+        @queue = Queue.new
+        @limited = false
+      end
+
+      @workers = []
+      @shutdown = false
+      @mutex = Mutex.new
+
+      @active_count = Concurrent::AtomicFixnum.new(0)
+      @completed_count = Concurrent::AtomicFixnum.new(0)
+      @rejected_count = Concurrent::AtomicFixnum.new(0)
+
+      start_workers
+    end
+
+    def submit(&block)
+      raise ThreadPoolError, 'Pool is shutting down' if @shutdown
+
+      if @limited
+        # For SizedQueue, use non-blocking push
+
+        # Try non-blocking push
+        success = false
+        begin
+          @queue.push(block, true)
+          success = true
+        rescue ThreadError
+          # Queue is full
+          success = false
+        end
+
+        unless success
+          @rejected_count.increment
+          raise ThreadPoolError, "Queue is full (size: #{@max_queue_size})"
+        end
+
+      else
+        # Regular queue, just add
+        @queue.push(block)
+      end
+    end
+
+    def active_count
+      @active_count.value
+    end
+
+    def queue_size
+      @queue.size
+    end
+
+    def shutdown
+      @mutex.synchronize do
+        return if @shutdown
+
+        @shutdown = true
+      end
+
+      # Don't push terminate signals yet - let existing tasks complete
+      # The workers will check @shutdown flag
+    end
+
+    def shutdown!
+      @mutex.synchronize do
+        @shutdown = true
+      end
+
+      # Clear the queue and terminate immediately
+      @queue.clear
+      @workers.each(&:kill)
+    end
+
+    def wait_for_termination(timeout: nil)
+      if timeout
+        deadline = Time.now + timeout
+
+        # Wait for queue to empty and active tasks to complete
+        sleep 0.01 while (@queue.size.positive? || @active_count.value.positive?) && Time.now < deadline
+
+        # Then wait for workers to finish
+        @workers.each do |worker|
+          remaining = deadline - Time.now
+          return false if remaining <= 0
+
+          joined = worker.join(remaining)
+          return false unless joined
+        end
+
+        # Check if all tasks completed
+        @queue.empty? && @active_count.value.zero?
+      else
+        # Wait indefinitely for queue to empty and active tasks to complete
+        sleep 0.01 while @queue.size.positive? || @active_count.value.positive?
+
+        # Then join all workers
+        @workers.each(&:join)
+        true
+      end
+    end
+
+    def stats
+      {
+        size: @size,
+        active: active_count,
+        queued: queue_size,
+        max_queue: @max_queue_size,
+        completed: @completed_count.value,
+        rejected: @rejected_count.value,
+        shutdown: @shutdown,
+        memory_usage: memory_usage
+      }
+    end
+
+    def memory_usage
+      # Get process memory usage
+      if defined?(GetProcessMem)
+        GetProcessMem.new.bytes
+      else
+        # Fallback to RSS from /proc (Linux)
+        begin
+          File.read("/proc/#{Process.pid}/status").match(/VmRSS:\s+(\d+)/)[1].to_i * 1024
+        rescue StandardError
+          # Fallback for non-Linux or if reading fails
+          0
+        end
+      end
+    end
+
+    private
+
+    def start_workers
+      @size.times do
+        worker = Thread.new do
+          worker_loop
+        end
+        @workers << worker
+      end
+    end
+
+    def worker_loop
+      loop do
+        task = nil
+
+        # Non-blocking check for tasks
+        begin
+          task = @queue.pop(true) # Non-blocking pop
+        rescue ThreadError
+          # Queue is empty
+          break if @shutdown
+
+          sleep 0.01
+          next
+        end
+
+        # Process the task
+        next unless task.respond_to?(:call)
+
+        begin
+          @active_count.increment
+          task.call
+          @completed_count.increment
+        rescue StandardError
+          # Log error but don't crash the worker
+          # In production, would use proper logging
+        ensure
+          @active_count.decrement
+        end
+      end
+    rescue StandardError
+      # Worker crashed, log in production
+    end
+  end
+end

data/lib/natswork/worker.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'securerandom'
+require 'concurrent'
+
+module NatsWork
+  class Worker
+    attr_reader :name, :queues, :concurrency, :connection
+
+    def initialize(connection, options = {})
+      @connection = connection
+      @name = options[:name] || generate_worker_name
+      @queues = Array(options[:queues] || 'default')
+      @concurrency = options[:concurrency] || 10
+
+      @running = false
+      @paused = false
+      @stopping = false
+      @mutex = Mutex.new
+
+      @jobs_processed = Concurrent::AtomicFixnum.new(0)
+      @jobs_failed = Concurrent::AtomicFixnum.new(0)
+      @active_jobs = Concurrent::AtomicFixnum.new(0)
+
+      @heartbeat_thread = nil
+      @polling_threads = []
+      @started_at = nil
+    end
+
+    def start
+      @mutex.synchronize do
+        return if @running
+
+        @running = true
+        @stopping = false
+        @started_at = Time.now
+
+        start_heartbeat
+        start_polling
+      end
+    end
+
+    def stop
+      @mutex.synchronize do
+        return unless @running
+
+        @stopping = true
+        wait_for_jobs
+
+        stop_polling
+        stop_heartbeat
+
+        @running = false
+        @stopping = false
+      end
+    end
+
+    def pause
+      @mutex.synchronize do
+        @paused = true
+      end
+    end
+
+    def resume
+      @mutex.synchronize do
+        @paused = false
+      end
+    end
+
+    def running?
+      @running
+    end
+
+    def paused?
+      @paused
+    end
+
+    def stopping?
+      @stopping
+    end
+
+    def accepting_jobs?
+      @running && !@paused && !@stopping
+    end
+
+    def stats
+      {
+        name: @name,
+        status: current_status,
+        queues: @queues,
+        concurrency: @concurrency,
+        jobs_processed: @jobs_processed.value,
+        jobs_failed: @jobs_failed.value,
+        active_jobs: @active_jobs.value,
+        started_at: @started_at,
+        uptime: @started_at ? Time.now - @started_at : 0
+      }
+    end
+
+    def heartbeat
+      @connection.publish('natswork.workers.heartbeat', {
+                            worker_id: @name,
+                            status: current_status,
+                            queues: @queues,
+                            concurrency: @concurrency,
+                            jobs_processed: @jobs_processed.value,
+                            jobs_failed: @jobs_failed.value,
+                            active_jobs: @active_jobs.value,
+                            timestamp: Time.now.to_f
+                          })
+    end
+
+    def graceful_shutdown(timeout: 30)
+      stop_thread = Thread.new { stop }
+      stop_thread.join(timeout)
+
+      return unless stop_thread.alive?
+
+      stop_thread.kill
+      force_shutdown
+    end
+
+    private
+
+    def generate_worker_name
+      "worker-#{Socket.gethostname}-#{Process.pid}-#{SecureRandom.hex(4)}"
+    end
+
+    def current_status
+      return :stopped unless @running
+      return :paused if @paused
+      return :stopping if @stopping
+
+      :running
+    end
+
+    def start_heartbeat
+      @heartbeat_thread = Thread.new do
+        loop do
+          break unless @running
+
+          begin
+            heartbeat
+          rescue StandardError
+            # Log error but don't crash heartbeat thread
+          end
+
+          sleep 5
+        end
+      end
+    end
+
+    def stop_heartbeat
+      return unless @heartbeat_thread
+
+      @heartbeat_thread.kill if @heartbeat_thread.alive?
+      @heartbeat_thread = nil
+    end
+
+    def start_polling
+      @queues.each do |queue|
+        thread = Thread.new do
+          poll_queue(queue)
+        end
+        @polling_threads << thread
+      end
+    end
+
+    def stop_polling
+      @polling_threads.each do |thread|
+        thread.kill if thread&.alive?
+      end
+      @polling_threads.clear
+    end
+
+    def poll_queue(_queue)
+      loop do
+        break unless @running
+        next if @paused
+
+        # Polling logic will be implemented with queue subscription
+        sleep 0.1
+      end
+    end
+
+    def wait_for_jobs
+      timeout = 30
+      deadline = Time.now + timeout
+
+      sleep 0.1 while @active_jobs.value.positive? && Time.now < deadline
+    end
+
+    def force_shutdown
+      @mutex.synchronize do
+        stop_polling
+        stop_heartbeat
+        @running = false
+        @stopping = false
+      end
+    end
+
+    def heartbeat_loop
+      loop do
+        break unless @running
+
+        begin
+          heartbeat
+        rescue StandardError
+          # Log error
+        end
+
+        sleep 5
+      end
+    end
+  end
+end