solid_mcp 0.0.1 → 0.2.1

data/lib/solid_mcp/cleanup_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SolidMCP
+  class CleanupJob < ActiveJob::Base
+    def perform
+      SolidMCP::Message.cleanup(
+        delivered_retention: SolidMCP.configuration.delivered_retention_seconds,
+        undelivered_retention: SolidMCP.configuration.undelivered_retention_seconds
+      )
+    end
+  end
+end

data/lib/solid_mcp/configuration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SolidMCP
+  class Configuration
+    attr_accessor :batch_size, :flush_interval, :delivered_retention, 
+                  :undelivered_retention, :polling_interval, :max_wait_time, :logger
+
+    def initialize
+      @batch_size = 200
+      @flush_interval = 0.05 # 50ms
+      @polling_interval = 0.1 # 100ms
+      @max_wait_time = 30 # 30 seconds
+      @delivered_retention = 3600 # 1 hour in seconds
+      @undelivered_retention = 86400 # 24 hours in seconds
+      @logger = default_logger
+    end
+
+    def delivered_retention_seconds
+      @delivered_retention.seconds
+    end
+
+    def undelivered_retention_seconds
+      @undelivered_retention.seconds
+    end
+
+    private
+
+    def default_logger
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger
+      else
+        require 'active_support/tagged_logging'
+        ActiveSupport::TaggedLogging.new(::Logger.new($stdout))
+      end
+    end
+  end
+end

data/lib/solid_mcp/engine.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SolidMCP
+  class Engine < ::Rails::Engine
+    isolate_namespace SolidMCP
+
+    config.generators do |g|
+      g.test_framework :minitest
+    end
+
+    # Ensure app/models is in the autoload paths
+    config.autoload_paths << root.join("app/models")
+
+    # Don't automatically add migrations - use the generator instead
+    # initializer "solid_mcp.migrations" do
+    #   config.paths["db/migrate"].expanded.each do |expanded_path|
+    #     Rails.application.config.paths["db/migrate"] << expanded_path
+    #   end
+    # end
+
+    initializer "solid_mcp.configuration" do
+      # Set default configuration if not already configured
+      SolidMCP.configuration ||= Configuration.new
+    end
+
+    initializer "solid_mcp.start_message_writer" do
+      # Start the message writer in non-test environments
+      unless Rails.env.test?
+        Rails.application.config.to_prepare do
+          SolidMCP::MessageWriter.instance
+        end
+      end
+    end
+  end
+end

data/lib/solid_mcp/logger.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SolidMCP
+  module Logger
+    class << self
+      def logger
+        SolidMCP.configuration.logger
+      end
+
+      def tagged(*tags, &block)
+        logger.tagged(*tags, &block)
+      end
+
+      def debug(message = nil, &block)
+        logger.debug(message, &block)
+      end
+
+      def info(message = nil, &block)
+        logger.info(message, &block)
+      end
+
+      def warn(message = nil, &block)
+        logger.warn(message, &block)
+      end
+
+      def error(message = nil, &block)
+        logger.error(message, &block)
+      end
+
+      def fatal(message = nil, &block)
+        logger.fatal(message, &block)
+      end
+    end
+  end
+end

data/lib/solid_mcp/message_writer.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "concurrent"
+
+module SolidMCP
+  class MessageWriter
+    include Singleton
+    
+    # Reset the singleton (for testing only)
+    def self.reset!
+      @singleton__instance__ = nil
+    end
+
+    def initialize
+      @queue = Queue.new
+      @shutdown = Concurrent::AtomicBoolean.new(false)
+      @executor = Concurrent::ThreadPoolExecutor.new(
+        min_threads: 1,
+        max_threads: 1,  # Single thread for ordered writes
+        max_queue: 0,    # Unbounded queue
+        fallback_policy: :caller_runs
+      )
+      start_worker
+    end
+
+    # Called by publish API - non-blocking
+    def enqueue(session_id, event_type, data)
+      @queue << {
+        session_id: session_id,
+        event_type: event_type,
+        data: data.is_a?(String) ? data : data.to_json,
+        created_at: Time.current
+      }
+    end
+
+    # Blocks until executor has flushed everything
+    def shutdown
+      # Process any remaining messages in the queue
+      flush if @executor.running?
+      
+      @shutdown.make_true
+      @executor.shutdown
+      @executor.wait_for_termination(10) # Wait up to 10 seconds
+    end
+
+    # Force flush any pending messages (useful for tests)
+    def flush
+      return unless @executor.running?
+      
+      # Add a marker and wait for it to be processed
+      processed = Concurrent::CountDownLatch.new(1)
+      @queue << { flush_marker: processed }
+      
+      # Wait up to 1 second for flush to complete
+      processed.wait(1)
+    end
+
+    private
+
+    def start_worker
+      @executor.post do
+        begin
+          SolidMCP::Logger.debug "MessageWriter worker thread started" if ENV["DEBUG_SOLID_MCP"]
+          run_loop
+        rescue => e
+          SolidMCP::Logger.error "MessageWriter worker thread crashed: #{e.message}"
+          SolidMCP::Logger.error e.backtrace.join("\n")
+        end
+      end
+    end
+
+    def run_loop
+      loop do
+        break if @shutdown.true? && @queue.empty?
+
+        batch = drain_batch
+        if batch.any?
+          SolidMCP::Logger.debug "MessageWriter processing batch of #{batch.size} messages" if ENV["DEBUG_SOLID_MCP"]
+          write_batch(batch)
+        else
+          sleep SolidMCP.configuration.flush_interval
+        end
+      end
+    rescue => e
+      SolidMCP::Logger.error "SolidMCP::MessageWriter error: #{e.message}"
+      retry unless @shutdown.true?
+    end
+
+    def drain_batch
+      batch = []
+      batch_size = SolidMCP.configuration.batch_size
+      flush_markers = []
+
+      # Try to get first item (non-blocking)
+      begin
+        item = @queue.pop(true)
+        # Handle flush markers
+        if item.is_a?(Hash) && item[:flush_marker]
+          flush_markers << item[:flush_marker]
+        else
+          batch << item
+        end
+      rescue ThreadError
+        # Signal any flush markers we've collected
+        flush_markers.each(&:count_down)
+        return batch
+      end
+
+      # Get remaining items up to batch size
+      while batch.size < batch_size
+        begin
+          item = @queue.pop(true)
+          # Handle flush markers
+          if item.is_a?(Hash) && item[:flush_marker]
+            flush_markers << item[:flush_marker]
+          else
+            batch << item
+          end
+        rescue ThreadError
+          break
+        end
+      end
+
+      # Signal any flush markers we've collected
+      flush_markers.each(&:count_down)
+      batch
+    end
+
+    def write_batch(batch)
+      return if batch.empty?
+
+      # Use raw SQL for maximum performance
+      SolidMCP::Message.connection_pool.with_connection do |conn|
+        values = batch.map do |msg|
+          [
+            conn.quote(msg[:session_id]),
+            conn.quote(msg[:event_type]),
+            conn.quote(msg[:data]),
+            conn.quote(msg[:created_at].utc.to_fs(:db))
+          ].join(",")
+        end
+
+        sql = <<-SQL
+          INSERT INTO solid_mcp_messages (session_id, event_type, data, created_at)
+          VALUES #{values.map { |v| "(#{v})" }.join(",")}
+        SQL
+
+        conn.execute(sql)
+      end
+    rescue => e
+      SolidMCP::Logger.error "SolidMCP::MessageWriter batch write error: #{e.message}"
+      # Could implement retry logic or dead letter queue here
+    end
+  end
+end

data/lib/solid_mcp/pub_sub.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "concurrent/array"
+
+module SolidMCP
+  class PubSub
+    def initialize(options = {})
+      @options = options
+      @subscriptions = Concurrent::Map.new
+      @listeners = Concurrent::Map.new
+    end
+
+    # Subscribe to messages for a specific session
+    def subscribe(session_id, &block)
+      @subscriptions[session_id] ||= Concurrent::Array.new
+      @subscriptions[session_id] << block
+      
+      # Start a listener for this session if not already running
+      ensure_listener_for(session_id)
+    end
+
+    # Unsubscribe from a session
+    def unsubscribe(session_id)
+      @subscriptions.delete(session_id)
+      stop_listener_for(session_id)
+    end
+
+    # Broadcast a message to a session (uses MessageWriter for batching)
+    def broadcast(session_id, event_type, data)
+      MessageWriter.instance.enqueue(session_id, event_type, data)
+    end
+
+    # Shutdown all listeners
+    def shutdown
+      @listeners.each do |_, listener|
+        listener.stop
+      end
+      @listeners.clear
+      MessageWriter.instance.shutdown
+    end
+
+    private
+
+    def ensure_listener_for(session_id)
+      return if @listeners[session_id]
+
+      listener = Subscriber.new(session_id, @subscriptions[session_id])
+      listener.start
+      @listeners[session_id] = listener
+    end
+
+    def stop_listener_for(session_id)
+      listener = @listeners.delete(session_id)
+      listener&.stop
+    end
+  end # class PubSub
+end

data/lib/solid_mcp/subscriber.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "concurrent/atomic/atomic_boolean"
+require "concurrent/timer_task"
+
+module SolidMCP
+  class Subscriber
+    def initialize(session_id, callbacks)
+      @session_id = session_id
+      @callbacks = callbacks
+      @running = Concurrent::AtomicBoolean.new(false)
+      @last_message_id = 0
+      @timer_task = nil
+      @max_retries = ENV["RAILS_ENV"] == "test" ? 3 : Float::INFINITY
+      @retry_count = 0
+    end
+
+    def start
+      return if @running.true?
+
+      @running.make_true
+      @retry_count = 0
+      
+      @timer_task = Concurrent::TimerTask.new(
+        execution_interval: SolidMCP.configuration.polling_interval,
+        run_now: true
+      ) do
+        poll_once
+      end
+      
+      @timer_task.execute
+    end
+
+    def stop
+      @running.make_false
+      @timer_task&.shutdown
+      @timer_task&.wait_for_termination(5)
+    end
+
+    private
+
+    def poll_once
+      return unless @running.true?
+      
+      # Ensure connection in thread
+      SolidMCP::Message.connection_pool.with_connection do
+        messages = fetch_new_messages
+        if messages.any?
+          process_messages(messages)
+          mark_delivered(messages)
+          @retry_count = 0
+        end
+      end
+    rescue => e
+      @retry_count += 1
+      SolidMCP::Logger.error "SolidMCP::Subscriber error for session #{@session_id}: #{e.message} (retry #{@retry_count}/#{@max_retries})"
+      
+      if @retry_count >= @max_retries && @max_retries != Float::INFINITY
+        SolidMCP::Logger.error "SolidMCP::Subscriber max retries reached for session #{@session_id}, stopping"
+        stop
+      end
+    end
+
+    def fetch_new_messages
+      SolidMCP::Message
+        .for_session(@session_id)
+        .undelivered
+        .after_id(@last_message_id)
+        .order(:id)
+        .limit(100)
+        .to_a
+    end
+
+    def process_messages(messages)
+      messages.each do |message|
+        @callbacks.each do |callback|
+          begin
+            callback.call({
+              event_type: message.event_type,
+              data: message.data,  # data is already a JSON string from the database
+              id: message.id
+            })
+          rescue => e
+            SolidMCP::Logger.error "SolidMCP callback error: #{e.message}"
+          end
+        end
+        @last_message_id = message.id
+      end
+    end
+
+    def mark_delivered(messages)
+      SolidMCP::Message.mark_delivered(messages.map(&:id))
+    end
+  end
+end

data/lib/solid_mcp/test_pub_sub.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "concurrent/array"
+
+module SolidMCP
+  # Test implementation of PubSub for use in tests
+  class TestPubSub
+    attr_reader :subscriptions, :messages
+
+    def initialize(options = {})
+      @options = options
+      @subscriptions = Concurrent::Map.new
+      @messages = Concurrent::Array.new
+    end
+
+    def subscribe(session_id, &block)
+      @subscriptions[session_id] ||= Concurrent::Array.new
+      @subscriptions[session_id] << block
+    end
+
+    def unsubscribe(session_id)
+      @subscriptions.delete(session_id)
+    end
+
+    def broadcast(session_id, event_type, data)
+      message = { session_id: session_id, event_type: event_type, data: data }
+      @messages << message
+      
+      callbacks = @subscriptions[session_id] || []
+      callbacks.each do |callback|
+        callback.call({ event_type: event_type, data: data })
+      end
+    end
+
+    def shutdown
+      @subscriptions.clear
+      @messages.clear
+    end
+  end
+end

data/lib/solid_mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module SolidMcp
-  VERSION = "0.0.1"
+module SolidMCP
+  VERSION = "0.2.1"
 end

data/lib/solid_mcp.rb

@@ -1,8 +1,39 @@
 # frozen_string_literal: true
 
 require_relative "solid_mcp/version"
+require_relative "solid_mcp/configuration"
+require_relative "solid_mcp/logger"
+require_relative "solid_mcp/engine" if defined?(Rails)
 
-module SolidMcp
+# Always load core components
+require_relative "solid_mcp/message_writer"
+require_relative "solid_mcp/subscriber"
+require_relative "solid_mcp/cleanup_job"
+
+# Load test components in test environment
+if ENV["RAILS_ENV"] == "test"
+  require_relative "solid_mcp/test_pub_sub"
+end
+
+# Always require pub_sub after environment-specific components
+require_relative "solid_mcp/pub_sub"
+
+module SolidMCP
   class Error < StandardError; end
-  # Your code goes here...
+
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+
+    def configured?
+      configuration.present?
+    end
+  end
+
+  # Initialize with default configuration
+  self.configuration = Configuration.new
 end

data/release-please-config.json

@@ -0,0 +1,8 @@
+{
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "package-name": "solid_mcp"
+    }
+  }
+}

data/sig/solid_mcp.rbs

@@ -1,4 +1,4 @@
-module SolidMcp
+module SolidMCP
   VERSION: String
   # See the writing guide of rbs: https://github.com/ruby/rbs#guides
 end

data/solid_mcp.gemspec

@@ -4,7 +4,7 @@ require_relative "lib/solid_mcp/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "solid_mcp"
-  spec.version       = SolidMcp::VERSION
+  spec.version       = SolidMCP::VERSION
   spec.authors       = ["Abdelkader Boudih"]
   spec.email         = ["terminale@gmail.com"]
 
@@ -28,7 +28,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "actionmcp"
-  spec.add_dependency "activerecord", ">= 8"
-  spec.add_dependency "railties", ">= 8"
+  spec.add_dependency "activerecord", ">= 8.0"
+  spec.add_dependency "railties", ">= 8.0"
+  spec.add_dependency "activejob", ">= 8.0"
+  spec.add_dependency "concurrent-ruby", "~> 1.0"
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "sqlite3", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
 end