faye-redis-ng 1.0.0

data/lib/faye/redis/message_queue.rb

@@ -0,0 +1,207 @@
+require 'json'
+require 'securerandom'
+
+module Faye
+  class Redis
+    class MessageQueue
+      attr_reader :connection, :options
+
+      def initialize(connection, options = {})
+        @connection = connection
+        @options = options
+      end
+
+      # Enqueue a message for a client
+      def enqueue(client_id, message, &callback)
+        message_id = generate_message_id
+        timestamp = Time.now.to_i
+
+        message_data = {
+          id: message_id,
+          channel: message['channel'],
+          data: message['data'],
+          client_id: message['clientId'],
+          timestamp: timestamp
+        }
+
+        @connection.with_redis do |redis|
+          redis.multi do |multi|
+            # Store message data
+            multi.hset(message_key(message_id), message_data.transform_keys(&:to_s).transform_values { |v| v.to_json })
+
+            # Add message to client's queue
+            multi.rpush(queue_key(client_id), message_id)
+
+            # Set TTL on message
+            multi.expire(message_key(message_id), message_ttl)
+
+            # Set TTL on queue
+            multi.expire(queue_key(client_id), message_ttl)
+          end
+        end
+
+        EventMachine.next_tick { callback.call(true) } if callback
+      rescue => e
+        log_error("Failed to enqueue message for client #{client_id}: #{e.message}")
+        EventMachine.next_tick { callback.call(false) } if callback
+      end
+
+      # Dequeue all messages for a client
+      def dequeue_all(client_id, &callback)
+        # Get all message IDs from queue
+        message_ids = @connection.with_redis do |redis|
+          redis.lrange(queue_key(client_id), 0, -1)
+        end
+
+        # Fetch all messages using pipeline
+        messages = []
+        unless message_ids.empty?
+          @connection.with_redis do |redis|
+            redis.pipelined do |pipeline|
+              message_ids.each do |message_id|
+                pipeline.hgetall(message_key(message_id))
+              end
+            end.each do |data|
+              next if data.nil? || data.empty?
+
+              # Parse JSON values
+              parsed_data = data.transform_values do |v|
+                begin
+                  JSON.parse(v)
+                rescue JSON::ParserError
+                  v
+                end
+              end
+
+              # Convert to Faye message format
+              messages << {
+                'channel' => parsed_data['channel'],
+                'data' => parsed_data['data'],
+                'clientId' => parsed_data['client_id'],
+                'id' => parsed_data['id']
+              }
+            end
+          end
+        end
+
+        # Delete queue and all message data using pipeline
+        unless message_ids.empty?
+          @connection.with_redis do |redis|
+            redis.pipelined do |pipeline|
+              pipeline.del(queue_key(client_id))
+              message_ids.each do |message_id|
+                pipeline.del(message_key(message_id))
+              end
+            end
+          end
+        end
+
+        EventMachine.next_tick { callback.call(messages) } if callback
+        messages
+      rescue => e
+        log_error("Failed to dequeue messages for client #{client_id}: #{e.message}")
+        EventMachine.next_tick { callback.call([]) } if callback
+        []
+      end
+
+      # Peek at messages without removing them
+      def peek(client_id, limit = 10, &callback)
+        message_ids = @connection.with_redis do |redis|
+          redis.lrange(queue_key(client_id), 0, limit - 1)
+        end
+
+        messages = message_ids.map do |message_id|
+          fetch_message(message_id)
+        end.compact
+
+        EventMachine.next_tick { callback.call(messages) } if callback
+        messages
+      rescue => e
+        log_error("Failed to peek messages for client #{client_id}: #{e.message}")
+        EventMachine.next_tick { callback.call([]) } if callback
+        []
+      end
+
+      # Get queue size for a client
+      def size(client_id, &callback)
+        queue_size = @connection.with_redis do |redis|
+          redis.llen(queue_key(client_id))
+        end
+
+        EventMachine.next_tick { callback.call(queue_size) } if callback
+        queue_size
+      rescue => e
+        log_error("Failed to get queue size for client #{client_id}: #{e.message}")
+        EventMachine.next_tick { callback.call(0) } if callback
+        0
+      end
+
+      # Clear a client's message queue
+      def clear(client_id, &callback)
+        @connection.with_redis do |redis|
+          redis.del(queue_key(client_id))
+        end
+
+        EventMachine.next_tick { callback.call(true) } if callback
+      rescue => e
+        log_error("Failed to clear queue for client #{client_id}: #{e.message}")
+        EventMachine.next_tick { callback.call(false) } if callback
+      end
+
+      private
+
+      def fetch_message(message_id)
+        data = @connection.with_redis do |redis|
+          redis.hgetall(message_key(message_id))
+        end
+
+        return nil if data.empty?
+
+        # Parse JSON values
+        parsed_data = data.transform_values do |v|
+          begin
+            JSON.parse(v)
+          rescue JSON::ParserError
+            v
+          end
+        end
+
+        # Convert to Faye message format
+        {
+          'channel' => parsed_data['channel'],
+          'data' => parsed_data['data'],
+          'clientId' => parsed_data['client_id'],
+          'id' => parsed_data['id']
+        }
+      rescue => e
+        log_error("Failed to fetch message #{message_id}: #{e.message}")
+        nil
+      end
+
+      def queue_key(client_id)
+        namespace_key("messages:#{client_id}")
+      end
+
+      def message_key(message_id)
+        namespace_key("message:#{message_id}")
+      end
+
+      def namespace_key(key)
+        namespace = @options[:namespace] || 'faye'
+        "#{namespace}:#{key}"
+      end
+
+      def message_ttl
+        @options[:message_ttl] || 3600
+      end
+
+      def generate_message_id
+        SecureRandom.uuid
+      end
+
+      def log_error(message)
+        puts "[Faye::Redis::MessageQueue] ERROR: #{message}" if @options[:log_level] != :silent
+      end
+    end
+  end
+end

data/lib/faye/redis/pubsub_coordinator.rb

@@ -0,0 +1,207 @@
+require 'json'
+require 'set'
+
+module Faye
+  class Redis
+    class PubSubCoordinator
+      attr_reader :connection, :options
+
+      def initialize(connection, options = {})
+        @connection = connection
+        @options = options
+        @subscribers = []
+        @redis_subscriber = nil
+        @subscribed_channels = Set.new
+        @subscriber_thread = nil
+        @stop_subscriber = false
+        @reconnect_attempts = 0
+        # Don't setup subscriber immediately - wait until first publish/subscribe
+      end
+
+      # Publish a message to a channel
+      def publish(channel, message, &callback)
+        # Ensure subscriber is setup
+        setup_subscriber unless @subscriber_thread
+
+        message_json = message.to_json
+
+        @connection.with_redis do |redis|
+          redis.publish(pubsub_channel(channel), message_json)
+        end
+
+        EventMachine.next_tick { callback.call(true) } if callback
+      rescue => e
+        log_error("Failed to publish message to #{channel}: #{e.message}")
+        EventMachine.next_tick { callback.call(false) } if callback
+      end
+
+      # Subscribe to messages from other servers
+      def on_message(&block)
+        @subscribers << block
+      end
+
+      # Subscribe to a Redis pub/sub channel
+      def subscribe_to_channel(channel)
+        return if @subscribed_channels.include?(channel)
+
+        @subscribed_channels.add(channel)
+
+        if @redis_subscriber
+          @redis_subscriber.subscribe(pubsub_channel(channel))
+        end
+      rescue => e
+        log_error("Failed to subscribe to channel #{channel}: #{e.message}")
+      end
+
+      # Unsubscribe from a Redis pub/sub channel
+      def unsubscribe_from_channel(channel)
+        return unless @subscribed_channels.include?(channel)
+
+        @subscribed_channels.delete(channel)
+
+        if @redis_subscriber
+          @redis_subscriber.unsubscribe(pubsub_channel(channel))
+        end
+      rescue => e
+        log_error("Failed to unsubscribe from channel #{channel}: #{e.message}")
+      end
+
+      # Disconnect the pub/sub connection
+      def disconnect
+        @stop_subscriber = true
+
+        if @subscriber_thread
+          @subscriber_thread.kill
+          @subscriber_thread = nil
+        end
+
+        if @redis_subscriber
+          begin
+            @redis_subscriber.quit
+          rescue => e
+            # Ignore errors during disconnect
+          end
+          @redis_subscriber = nil
+        end
+        @subscribed_channels.clear
+        @subscribers.clear
+      end
+
+      private
+
+      def setup_subscriber
+        return if @subscriber_thread&.alive?
+
+        @stop_subscriber = false
+        @subscriber_thread = Thread.new do
+          run_subscriber_loop
+        end
+      rescue => e
+        log_error("Failed to setup pub/sub subscriber: #{e.message}")
+      end
+
+      def run_subscriber_loop
+        max_reconnect_attempts = @options[:pubsub_max_reconnect_attempts] || 10
+        base_delay = @options[:pubsub_reconnect_delay] || 1
+
+        loop do
+          break if @stop_subscriber
+
+          begin
+            # Create a dedicated Redis connection for pub/sub
+            @redis_subscriber = @connection.create_pubsub_connection
+
+            # Subscribe to a wildcard pattern to catch all Faye messages
+            pattern = pubsub_channel('*')
+
+            log_info("Starting pub/sub subscriber (attempt #{@reconnect_attempts + 1})")
+
+            @redis_subscriber.psubscribe(pattern) do |on|
+              on.pmessage do |pattern_match, channel, message|
+                handle_message(channel, message)
+              end
+
+              on.psubscribe do |channel, subscriptions|
+                log_info("Subscribed to pattern: #{channel}")
+                @reconnect_attempts = 0 # Reset on successful subscription
+              end
+
+              on.punsubscribe do |channel, subscriptions|
+                log_info("Unsubscribed from pattern: #{channel}")
+              end
+            end
+          rescue => e
+            break if @stop_subscriber
+
+            @reconnect_attempts += 1
+            log_error("Pub/sub subscriber error: #{e.message} (attempt #{@reconnect_attempts})")
+
+            # Clean up failed connection
+            begin
+              @redis_subscriber&.quit
+            rescue
+              # Ignore cleanup errors
+            end
+            @redis_subscriber = nil
+
+            if @reconnect_attempts >= max_reconnect_attempts
+              log_error("Max reconnect attempts (#{max_reconnect_attempts}) reached, stopping pub/sub subscriber")
+              break
+            end
+
+            # Exponential backoff with jitter
+            delay = [base_delay * (2 ** (@reconnect_attempts - 1)), 60].min
+            jitter = rand * 0.3 * delay
+            sleep(delay + jitter)
+
+            log_info("Attempting to reconnect pub/sub subscriber...")
+          end
+        end
+      end
+
+      def handle_message(redis_channel, message_json)
+        # Extract the Faye channel from the Redis channel
+        channel = extract_channel(redis_channel)
+
+        begin
+          message = JSON.parse(message_json)
+
+          # Notify all subscribers
+          EventMachine.next_tick do
+            @subscribers.each do |subscriber|
+              subscriber.call(channel, message)
+            end
+          end
+        rescue JSON::ParserError => e
+          log_error("Failed to parse message from #{channel}: #{e.message}")
+        end
+      rescue => e
+        log_error("Failed to handle message from #{redis_channel}: #{e.message}")
+      end
+
+      def pubsub_channel(channel)
+        namespace_key("publish:#{channel}")
+      end
+
+      def extract_channel(redis_channel)
+        # Remove the namespace prefix and 'publish:' prefix
+        namespace = @options[:namespace] || 'faye'
+        prefix = "#{namespace}:publish:"
+        redis_channel.sub(/^#{Regexp.escape(prefix)}/, '')
+      end
+
+      def namespace_key(key)
+        namespace = @options[:namespace] || 'faye'
+        "#{namespace}:#{key}"
+      end
+
+      def log_error(message)
+        puts "[Faye::Redis::PubSubCoordinator] ERROR: #{message}" if @options[:log_level] != :silent
+      end
+
+      def log_info(message)
+        puts "[Faye::Redis::PubSubCoordinator] INFO: #{message}" if @options[:log_level] == :debug
+      end
+    end
+  end
+end

data/lib/faye/redis/subscription_manager.rb

@@ -0,0 +1,189 @@
+module Faye
+  class Redis
+    class SubscriptionManager
+      attr_reader :connection, :options
+
+      def initialize(connection, options = {})
+        @connection = connection
+        @options = options
+      end
+
+      # Subscribe a client to a channel
+      def subscribe(client_id, channel, &callback)
+        timestamp = Time.now.to_i
+
+        @connection.with_redis do |redis|
+          redis.multi do |multi|
+            # Add channel to client's subscriptions
+            multi.sadd(client_subscriptions_key(client_id), channel)
+
+            # Add client to channel's subscribers
+            multi.sadd(channel_subscribers_key(channel), client_id)
+
+            # Store subscription metadata
+            multi.hset(
+              subscription_key(client_id, channel),
+              'subscribed_at', timestamp,
+              'channel', channel,
+              'client_id', client_id
+            )
+
+            # Handle wildcard patterns
+            if channel.include?('*')
+              multi.sadd(patterns_key, channel)
+            end
+          end
+        end
+
+        EventMachine.next_tick { callback.call(true) } if callback
+      rescue => e
+        log_error("Failed to subscribe client #{client_id} to #{channel}: #{e.message}")
+        EventMachine.next_tick { callback.call(false) } if callback
+      end
+
+      # Unsubscribe a client from a channel
+      def unsubscribe(client_id, channel, &callback)
+        @connection.with_redis do |redis|
+          redis.multi do |multi|
+            # Remove channel from client's subscriptions
+            multi.srem(client_subscriptions_key(client_id), channel)
+
+            # Remove client from channel's subscribers
+            multi.srem(channel_subscribers_key(channel), client_id)
+
+            # Delete subscription metadata
+            multi.del(subscription_key(client_id, channel))
+          end
+        end
+
+        EventMachine.next_tick { callback.call(true) } if callback
+      rescue => e
+        log_error("Failed to unsubscribe client #{client_id} from #{channel}: #{e.message}")
+        EventMachine.next_tick { callback.call(false) } if callback
+      end
+
+      # Unsubscribe a client from all channels
+      def unsubscribe_all(client_id, &callback)
+        # Get all channels the client is subscribed to
+        get_client_subscriptions(client_id) do |channels|
+          if channels.empty?
+            callback.call(true) if callback
+          else
+            # Unsubscribe from each channel
+            remaining = channels.size
+            channels.each do |channel|
+              unsubscribe(client_id, channel) do
+                remaining -= 1
+                callback.call(true) if callback && remaining == 0
+              end
+            end
+          end
+        end
+      rescue => e
+        log_error("Failed to unsubscribe client #{client_id} from all channels: #{e.message}")
+        EventMachine.next_tick { callback.call(false) } if callback
+      end
+
+      # Get all channels a client is subscribed to
+      def get_client_subscriptions(client_id, &callback)
+        channels = @connection.with_redis do |redis|
+          redis.smembers(client_subscriptions_key(client_id))
+        end
+
+        EventMachine.next_tick { callback.call(channels) } if callback
+        channels
+      rescue => e
+        log_error("Failed to get subscriptions for client #{client_id}: #{e.message}")
+        EventMachine.next_tick { callback.call([]) } if callback
+        []
+      end
+
+      # Get all clients subscribed to a channel
+      def get_subscribers(channel, &callback)
+        # Get direct subscribers
+        direct_subscribers = @connection.with_redis do |redis|
+          redis.smembers(channel_subscribers_key(channel))
+        end
+
+        # Get pattern subscribers
+        pattern_subscribers = get_pattern_subscribers(channel)
+
+        all_subscribers = (direct_subscribers + pattern_subscribers).uniq
+
+        EventMachine.next_tick { callback.call(all_subscribers) } if callback
+        all_subscribers
+      rescue => e
+        log_error("Failed to get subscribers for channel #{channel}: #{e.message}")
+        EventMachine.next_tick { callback.call([]) } if callback
+        []
+      end
+
+      # Get subscribers matching wildcard patterns
+      def get_pattern_subscribers(channel)
+        patterns = @connection.with_redis do |redis|
+          redis.smembers(patterns_key)
+        end
+
+        matching_clients = []
+        patterns.each do |pattern|
+          if channel_matches_pattern?(channel, pattern)
+            clients = @connection.with_redis do |redis|
+              redis.smembers(channel_subscribers_key(pattern))
+            end
+            matching_clients.concat(clients)
+          end
+        end
+
+        matching_clients.uniq
+      rescue => e
+        log_error("Failed to get pattern subscribers for channel #{channel}: #{e.message}")
+        []
+      end
+
+      # Check if a channel matches a pattern
+      def channel_matches_pattern?(channel, pattern)
+        # Convert Faye wildcard pattern to regex
+        # * matches one segment, ** matches multiple segments
+        regex_pattern = pattern
+          .gsub('**', '__DOUBLE_STAR__')
+          .gsub('*', '[^/]+')
+          .gsub('__DOUBLE_STAR__', '.*')
+
+        regex = Regexp.new("^#{regex_pattern}$")
+        !!(channel =~ regex)
+      end
+
+      # Clean up subscriptions for a client
+      def cleanup_client_subscriptions(client_id)
+        unsubscribe_all(client_id)
+      end
+
+      private
+
+      def client_subscriptions_key(client_id)
+        namespace_key("subscriptions:#{client_id}")
+      end
+
+      def channel_subscribers_key(channel)
+        namespace_key("channels:#{channel}")
+      end
+
+      def subscription_key(client_id, channel)
+        namespace_key("subscription:#{client_id}:#{channel}")
+      end
+
+      def patterns_key
+        namespace_key('patterns')
+      end
+
+      def namespace_key(key)
+        namespace = @options[:namespace] || 'faye'
+        "#{namespace}:#{key}"
+      end
+
+      def log_error(message)
+        puts "[Faye::Redis::SubscriptionManager] ERROR: #{message}" if @options[:log_level] != :silent
+      end
+    end
+  end
+end

data/lib/faye/redis/version.rb

@@ -0,0 +1,5 @@
+module Faye
+  class Redis
+    VERSION = '1.0.0'
+  end
+end