natswork-client 0.0.1

data/lib/natswork/client/version.rb

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

data/lib/natswork/client.rb

@@ -0,0 +1,397 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'securerandom'
+require 'timeout'
+require 'natswork/client/version'
+require 'natswork/errors'
+require 'natswork/serializer'
+require 'natswork/message'
+require 'natswork/job'
+require 'natswork/connection'
+require 'natswork/connection_pool'
+require 'natswork/configuration'
+require 'natswork/jetstream_manager'
+require 'natswork/circuit_breaker'
+
+module NatsWork
+  class Client
+    include Singleton
+
+    attr_reader :connection_pool, :jetstream_manager, :configuration
+
+    def initialize
+      @configuration = Configuration.instance
+      @connection_pool = nil
+      @jetstream_manager = nil
+      @mutex = Mutex.new
+      @result_store = {}
+      @result_callbacks = {}
+      @scheduled_jobs = []
+      @result_expiration_times = {}
+      start_result_expiration_thread
+    end
+
+    def configure
+      yield @configuration if block_given?
+      reset_connection!
+    end
+
+    def reset_connection!
+      shutdown_existing_connections
+      @connection_pool = ConnectionPool.new(
+        size: @configuration.pool_size || 5,
+        timeout: @configuration.pool_timeout || 5,
+        connection_options: {
+          servers: @configuration.servers || ['nats://localhost:4222'],
+          max_reconnect_attempts: @configuration.max_reconnect_attempts || 10,
+          reconnect_time_wait: @configuration.reconnect_time_wait || 2
+        }
+      )
+      # JetStreamManager will be created lazily when needed
+      ensure_streams_exist
+    end
+
+    # Connection management
+    def self.start
+      instance.start_connection
+    end
+
+    def self.stop
+      instance.stop_connection
+    end
+
+    # Main API for job dispatching
+    def self.push(options)
+      instance.push(options)
+    end
+
+    def self.perform_sync(options)
+      instance.perform_sync(options)
+    end
+
+    def self.perform_async(options)
+      instance.push(options)
+    end
+
+    def self.perform_in(delay, options)
+      instance.perform_in(delay, options)
+    end
+
+    def self.perform_at(time, options)
+      instance.perform_at(time, options)
+    end
+
+    def self.batch(jobs)
+      instance.batch(jobs)
+    end
+
+    # Instance methods
+    def push(options)
+      ensure_connected!
+
+      message = build_message(options)
+      message.validate!
+
+      connection_pool.with_connection do |connection|
+        subject = subject_for_queue(message.queue)
+
+        # For JetStream persistence
+        if configuration.use_jetstream
+          js = connection.jetstream
+          js.publish(subject, message.to_json)
+        else
+          # For Core NATS
+          connection.publish(subject, message.to_json)
+        end
+      end
+
+      message.job_id
+    end
+
+    def perform_sync(options)
+      ensure_connected!
+
+      message = build_message(options)
+      message.validate!
+
+      result = nil
+      error = nil
+
+      connection_pool.with_connection do |connection|
+        subject = subject_for_queue(message.queue)
+        timeout_seconds = options[:timeout] || configuration.sync_timeout || 5
+
+        # Use NATS request-reply pattern
+        response = connection.connection.request(subject, message.to_json, timeout: timeout_seconds)
+
+        raise TimeoutError, "Job #{message.job_id} timed out after #{timeout_seconds} seconds" unless response
+
+        reply_data = JSON.parse(response.data, symbolize_names: true)
+
+        if reply_data[:success]
+          result = reply_data[:result]
+        else
+          error = reply_data[:error] || 'Job execution failed'
+          raise JobError.new(
+            error,
+            job_class: message.job_class,
+            job_id: message.job_id,
+            original_error: reply_data
+          )
+        end
+
+        result
+      rescue NATS::IO::Timeout
+        raise TimeoutError, "Job #{message.job_id} timed out after #{timeout_seconds} seconds"
+      rescue JSON::ParserError => e
+        raise JobError.new("Failed to parse response: #{e.message}", job_class: message.job_class,
+                                                                     job_id: message.job_id)
+      end
+    end
+
+    def perform_in(delay, options)
+      perform_at(Time.now + delay, options)
+    end
+
+    def perform_at(time, options)
+      ensure_connected!
+
+      message = build_message(options)
+      message.metadata['scheduled_at'] = time.iso8601
+      message.metadata['scheduled_for'] = time.to_i
+      message.validate!
+
+      # Store scheduled job for later processing
+      @mutex.synchronize do
+        @scheduled_jobs << {
+          message: message,
+          scheduled_for: time,
+          status: 'pending'
+        }
+      end
+
+      # Start scheduler thread if not running
+      ensure_scheduler_running
+
+      message.job_id
+    end
+
+    def batch(jobs)
+      ensure_connected!
+
+      batch_id = SecureRandom.uuid
+      job_ids = []
+
+      connection_pool.with_connection do |connection|
+        jobs.each do |job_options|
+          # Merge batch metadata into existing metadata
+          merged_metadata = (job_options[:metadata] || {}).merge(
+            'batch_id' => batch_id,
+            'batch_size' => jobs.size
+          )
+
+          message = build_message(job_options)
+          message.metadata.merge!(merged_metadata)
+          message.validate!
+
+          subject = subject_for_queue(message.queue)
+
+          if configuration.use_jetstream
+            js = connection.jetstream
+            js.publish(subject, message.to_json)
+          else
+            connection.publish(subject, message.to_json)
+          end
+
+          job_ids << message.job_id
+        end
+      end
+
+      { batch_id: batch_id, job_ids: job_ids }
+    end
+
+    # Job status and management
+    def job_status(job_id)
+      @mutex.synchronize do
+        @result_store[job_id]
+      end
+    end
+
+    def store_result(job_id, result, ttl = 3600)
+      @mutex.synchronize do
+        @result_store[job_id] = result
+        @result_expiration_times[job_id] = Time.now + ttl
+
+        # Trigger callbacks if any
+        if @result_callbacks[job_id]
+          @result_callbacks[job_id].each { |callback| callback.call(result) }
+          @result_callbacks.delete(job_id)
+        end
+      end
+    end
+
+    def cancel_job(job_id)
+      # Publish cancellation message
+      connection_pool.with_connection do |connection|
+        cancel_subject = "#{configuration.namespace}.control.cancel"
+
+        cancel_message = {
+          type: 'job.cancel',
+          job_id: job_id,
+          timestamp: Time.now.iso8601
+        }
+
+        connection.publish(cancel_subject, cancel_message.to_json)
+      end
+      true
+    end
+
+    def on_result(job_id, &block)
+      @mutex.synchronize do
+        @result_callbacks[job_id] ||= []
+        @result_callbacks[job_id] << block
+      end
+    end
+
+    def shutdown
+      @mutex.synchronize do
+        shutdown_existing_connections
+      end
+    end
+
+    def start_connection
+      ensure_connected!
+    end
+
+    def stop_connection
+      shutdown
+    end
+
+    private
+
+    def ensure_connected!
+      @mutex.synchronize do
+        reset_connection! if @connection_pool.nil?
+      end
+    end
+
+    def shutdown_existing_connections
+      @connection_pool&.shutdown
+      @jetstream_manager = nil
+    end
+
+    def ensure_streams_exist
+      return unless configuration.use_jetstream && @jetstream_manager
+
+      # Create default streams for common queues
+      %w[default high low].each do |queue|
+        @jetstream_manager.create_stream(
+          queue,
+          subjects: ["#{configuration.namespace}.queue.#{queue}"]
+        )
+      end
+    rescue StandardError => e
+      # Log but don't fail if streams can't be created
+      configuration.logger&.warn "Failed to create JetStream streams: #{e.message}"
+    end
+
+    def build_message(options)
+      Message.new(
+        type: Message::TYPE_JOB_DISPATCH,
+        job_id: options[:job_id] || SecureRandom.uuid,
+        job_class: options[:job_class],
+        queue: options[:queue] || 'default',
+        arguments: options[:arguments] || [],
+        retry_count: options[:retry_count] || 0,
+        max_retries: options[:max_retries] || configuration.max_retries,
+        timeout: options[:timeout] || configuration.job_timeout,
+        metadata: options[:metadata] || {},
+        created_at: Time.now.iso8601
+      )
+    end
+
+    def subject_for_queue(queue_name)
+      "#{configuration.namespace}.queue.#{queue_name}"
+    end
+
+    def ensure_scheduler_running
+      return if @scheduler_thread&.alive?
+
+      @scheduler_thread = Thread.new do
+        loop do
+          process_scheduled_jobs
+          sleep 1
+        rescue StandardError => e
+          configuration.logger&.error "Scheduler error: #{e.message}"
+        end
+      end
+    end
+
+    def process_scheduled_jobs
+      now = Time.now
+
+      jobs_to_process = @mutex.synchronize do
+        ready_jobs = @scheduled_jobs.select do |job|
+          job[:status] == 'pending' && job[:scheduled_for] <= now
+        end
+
+        ready_jobs.each { |job| job[:status] = 'processing' }
+        ready_jobs
+      end
+
+      jobs_to_process.each do |scheduled_job|
+        message = scheduled_job[:message]
+        message.metadata.delete('scheduled_at')
+        message.metadata.delete('scheduled_for')
+        message.enqueued_at = Time.now.iso8601
+
+        push(message.to_hash)
+
+        @mutex.synchronize do
+          scheduled_job[:status] = 'completed'
+        end
+      rescue StandardError => e
+        configuration.logger&.error "Failed to enqueue scheduled job: #{e.message}"
+        @mutex.synchronize do
+          scheduled_job[:status] = 'failed'
+        end
+      end
+
+      # Clean up completed/failed jobs
+      @mutex.synchronize do
+        @scheduled_jobs.reject! { |job| %w[completed failed].include?(job[:status]) }
+      end
+    end
+
+    def start_result_expiration_thread
+      @result_expiration_thread = Thread.new do
+        loop do
+          expire_old_results
+          sleep 60 # Check every minute
+        rescue StandardError => e
+          configuration.logger&.error "Result expiration error: #{e.message}"
+        end
+      end
+    end
+
+    def expire_old_results
+      now = Time.now
+      expired_job_ids = []
+
+      @mutex.synchronize do
+        @result_expiration_times.each do |job_id, expiration_time|
+          expired_job_ids << job_id if expiration_time <= now
+        end
+
+        expired_job_ids.each do |job_id|
+          @result_store.delete(job_id)
+          @result_expiration_times.delete(job_id)
+          @result_callbacks.delete(job_id) # Clean up any stale callbacks
+        end
+      end
+
+      configuration.logger&.debug "Expired #{expired_job_ids.size} job results" if expired_job_ids.any?
+    end
+  end
+end

data/lib/natswork/compression.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'zlib'
+require 'base64'
+
+module NatsWork
+  module Compression
+    COMPRESSION_THRESHOLD = 10_240 # 10KB
+
+    class << self
+      def compress(data)
+        json = data.is_a?(String) ? data : data.to_json
+
+        # Only compress if data is large enough
+        return { compressed: false, data: data } if json.bytesize < COMPRESSION_THRESHOLD
+
+        compressed = Zlib::Deflate.deflate(json, Zlib::BEST_COMPRESSION)
+        encoded = Base64.strict_encode64(compressed)
+
+        # Only use compression if it actually reduces size
+        if encoded.bytesize < json.bytesize * 0.9
+          {
+            compressed: true,
+            data: encoded,
+            original_size: json.bytesize,
+            compressed_size: encoded.bytesize
+          }
+        else
+          { compressed: false, data: data }
+        end
+      rescue StandardError => e
+        # If compression fails, return original data
+        { compressed: false, data: data, error: e.message }
+      end
+
+      def decompress(payload)
+        return payload unless payload.is_a?(Hash) && payload[:compressed]
+
+        decoded = Base64.strict_decode64(payload[:data])
+        json = Zlib::Inflate.inflate(decoded)
+        JSON.parse(json, symbolize_names: true)
+      rescue StandardError => e
+        raise InvalidMessageError, "Failed to decompress data: #{e.message}"
+      end
+
+      def should_compress?(data)
+        json = data.is_a?(String) ? data : data.to_json
+        json.bytesize >= COMPRESSION_THRESHOLD
+      end
+
+      def compression_ratio(original_size, compressed_size)
+        return 0 if original_size.zero?
+
+        ((1 - (compressed_size.to_f / original_size)) * 100).round(2)
+      end
+    end
+  end
+end

data/lib/natswork/configuration.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'natswork/errors'
+
+module NatsWork
+  class ConfigurationError < Error; end
+
+  class Configuration
+    include Singleton
+
+    attr_accessor :servers, :pool_size, :pool_timeout, :max_reconnect_attempts,
+                  :reconnect_time_wait, :request_timeout, :user, :password,
+                  :token, :tls, :jetstream_enabled, :jetstream_prefix,
+                  :use_jetstream, :namespace, :max_retries, :job_timeout,
+                  :sync_timeout, :logger
+
+    def initialize
+      @servers = ['nats://localhost:4222']
+      @pool_size = 5
+      @pool_timeout = 5
+      @max_reconnect_attempts = 10
+      @reconnect_time_wait = 2
+      @request_timeout = 5
+      @user = nil
+      @password = nil
+      @token = nil
+      @tls = nil
+      @jetstream_enabled = true
+      @jetstream_prefix = 'natswork'
+      @use_jetstream = true
+      @namespace = 'natswork'
+      @max_retries = 3
+      @job_timeout = 30
+      @sync_timeout = 30
+      @logger = nil
+    end
+
+    def to_connection_options
+      opts = {
+        servers: servers,
+        max_reconnect_attempts: max_reconnect_attempts,
+        reconnect_time_wait: reconnect_time_wait
+      }
+
+      opts[:user] = user if user
+      opts[:password] = password if password
+      opts[:token] = token if token
+      opts[:tls] = tls if tls
+
+      opts
+    end
+
+    alias connection_options to_connection_options
+
+    def to_pool_options
+      {
+        size: pool_size,
+        timeout: pool_timeout,
+        connection_options: to_connection_options
+      }
+    end
+
+    def validate!
+      raise ConfigurationError, 'At least one server must be configured' if servers.empty?
+
+      servers.each do |server|
+        raise ConfigurationError, "Invalid server URL: #{server}" unless server =~ %r{^nats://}
+      end
+
+      raise ConfigurationError, 'Pool size must be positive' if pool_size <= 0
+      raise ConfigurationError, 'Pool timeout must be positive' if pool_timeout <= 0
+      raise ConfigurationError, 'Max reconnect attempts must be non-negative' if max_reconnect_attempts.negative?
+      raise ConfigurationError, 'Reconnect time wait must be positive' if reconnect_time_wait <= 0
+      raise ConfigurationError, 'Request timeout must be positive' if request_timeout <= 0
+
+      true
+    end
+
+    class << self
+      def from_hash(hash)
+        config = new
+
+        hash.each do |key, value|
+          setter = "#{key}="
+          config.send(setter, value) if config.respond_to?(setter)
+        end
+
+        config
+      end
+
+      def from_env
+        config = new
+
+        config.servers = ENV['NATSWORK_SERVERS'].split(',').map(&:strip) if ENV['NATSWORK_SERVERS']
+
+        config.pool_size = ENV['NATSWORK_POOL_SIZE'].to_i if ENV['NATSWORK_POOL_SIZE']
+        config.pool_timeout = ENV['NATSWORK_POOL_TIMEOUT'].to_i if ENV['NATSWORK_POOL_TIMEOUT']
+        config.max_reconnect_attempts = ENV['NATSWORK_MAX_RECONNECT'].to_i if ENV['NATSWORK_MAX_RECONNECT']
+        config.reconnect_time_wait = ENV['NATSWORK_RECONNECT_WAIT'].to_i if ENV['NATSWORK_RECONNECT_WAIT']
+        config.request_timeout = ENV['NATSWORK_REQUEST_TIMEOUT'].to_i if ENV['NATSWORK_REQUEST_TIMEOUT']
+
+        config.user = ENV['NATSWORK_USER'] if ENV['NATSWORK_USER']
+        config.password = ENV['NATSWORK_PASSWORD'] if ENV['NATSWORK_PASSWORD']
+        config.token = ENV['NATSWORK_TOKEN'] if ENV['NATSWORK_TOKEN']
+
+        if ENV['NATSWORK_JETSTREAM_ENABLED']
+          config.jetstream_enabled = ENV['NATSWORK_JETSTREAM_ENABLED'].downcase == 'true'
+        end
+
+        config.jetstream_prefix = ENV['NATSWORK_JETSTREAM_PREFIX'] if ENV['NATSWORK_JETSTREAM_PREFIX']
+
+        config
+      end
+    end
+  end
+end