celluloid_pubsub 0.2.0 → 0.3.0

data/lib/celluloid_pubsub/reactor.rb

@@ -1,6 +1,6 @@
 require_relative './registry'
+require_relative './helper'
 module CelluloidPubsub
-  # rubocop:disable ClassLength
   # The reactor handles new connections. Based on what the client sends it either subscribes to a channel
   # or will publish to a channel or just dispatch to the server if command is neither subscribe, publish or unsubscribe
   #
@@ -16,6 +16,7 @@ module CelluloidPubsub
     include Celluloid
     include Celluloid::IO
     include Celluloid::Logger
+    include CelluloidPubsub::Helper
 
     attr_accessor :websocket, :server, :channels
     finalizer :shutdown
@@ -31,10 +32,14 @@ module CelluloidPubsub
       @server = server
       @channels = []
       @websocket = websocket
-      info "#{self.class} Streaming changes for #{websocket.url}" if @server.debug_enabled?
+      log_debug "#{self.class} Streaming changes for #{websocket.url}"
       async.run
     end
 
+    def debug_enabled?
+      @server.debug_enabled?
+    end
+
     # reads from the socket the message
     # and dispatches it to the handle_websocket_message method
     # @see #handle_websocket_message
@@ -45,8 +50,10 @@ module CelluloidPubsub
     #
     # :nocov:
     def run
-      while Actor.current.alive? && !@websocket.closed? && message = try_read_websocket
-        handle_websocket_message(message)
+      loop do
+        break if !Actor.current.alive? || @websocket.closed? || !@server.alive?
+        message = try_read_websocket
+        handle_websocket_message(message) if message.present?
       end
     end
 
@@ -59,13 +66,13 @@ module CelluloidPubsub
     #
     # :nocov:
     def try_read_websocket
-      message = nil
-      begin
-        message = @websocket.read
-      rescue => e
-        debug(e)
-      end
-      message
+      @websocket.closed? ? nil : @websocket.read
+    rescue Reel::SocketError
+      nil
+    end
+
+    def reactor_class
+      self.class
     end
 
     # :nocov:
@@ -78,16 +85,10 @@ module CelluloidPubsub
     #
     # @api public
     def parse_json_data(message)
-      debug "#{self.class} read message  #{message}" if @server.debug_enabled?
-      json_data = nil
-      begin
-        json_data = JSON.parse(message)
-      rescue => e
-        debug "#{self.class} could not parse #{message} because of #{e.inspect}" if @server.debug_enabled?
-        # do nothing
-      end
-      json_data = message if json_data.nil?
-      json_data
+      JSON.parse(message)
+    rescue => exception
+      log_debug "#{reactor_class} could not parse #{message} because of #{exception.inspect}"
+      message
     end
 
     # method that handles the message received from the websocket connection
@@ -104,6 +105,7 @@ module CelluloidPubsub
     #
     # @api public
     def handle_websocket_message(message)
+      log_debug "#{reactor_class} read message  #{message}"
       json_data = parse_json_data(message)
       handle_parsed_websocket_message(json_data)
     end
@@ -124,7 +126,7 @@ module CelluloidPubsub
     def handle_parsed_websocket_message(json_data)
       if json_data.is_a?(Hash)
         json_data = json_data.stringify_keys
-        debug "#{self.class} finds actions for  #{json_data}" if @server.debug_enabled?
+        log_debug "#{self.class} finds actions for  #{json_data}"
         delegate_action(json_data) if json_data['client_action'].present?
       else
         handle_unknown_action(json_data)
@@ -153,17 +155,18 @@ module CelluloidPubsub
     #
     # @api public
     def delegate_action(json_data)
+      channel = json_data.fetch('channel', nil)
       case json_data['client_action']
       when 'unsubscribe_all'
         unsubscribe_all
       when 'unsubscribe_clients'
-        async.unsubscribe_clients(json_data['channel'])
+        async.unsubscribe_clients(channel)
       when 'unsubscribe'
-        async.unsubscribe(json_data['channel'])
+        async.unsubscribe(channel)
       when 'subscribe'
-        async.start_subscriber(json_data['channel'], json_data)
+        async.start_subscriber(channel, json_data)
       when 'publish'
-        @server.publish_event(json_data['channel'], json_data['data'].to_json)
+        @server.publish_event(channel, json_data['data'].to_json)
       else
         handle_unknown_action(json_data)
       end
@@ -178,10 +181,17 @@ module CelluloidPubsub
     #
     # @api public
     def handle_unknown_action(json_data)
-      debug "Trying to dispatch   to server  #{json_data}" if @server.debug_enabled?
+      log_debug "Trying to dispatch   to server  #{json_data}"
       @server.async.handle_dispatched_message(Actor.current, json_data)
     end
 
+    def forget_channel
+      if @channels.blank?
+        @websocket.close
+      else
+        @channels.delete(channel)
+      end
+    end
     # the method will unsubscribe a client by closing the websocket connection if has unscribed from all channels
     # and deleting the reactor from the channel list on the server
     #
@@ -191,13 +201,12 @@ module CelluloidPubsub
     #
     # @api public
     def unsubscribe(channel)
-      debug "#{self.class} runs 'unsubscribe' method with  #{channel}" if @server.debug_enabled?
+      log_debug "#{self.class} runs 'unsubscribe' method with  #{channel}"
       return unless channel.present?
-      @channels.delete(channel) unless @channels.blank?
-      @websocket.close if @channels.blank?
-      @server.subscribers[channel].delete_if do |hash|
+      forget_channel
+      (@server.subscribers[channel] || []).delete_if do |hash|
         hash[:reactor] == Actor.current
-      end if @server.subscribers[channel].present?
+      end
     end
 
     # the method will unsubscribe all  clients subscribed to a channel by closing the
@@ -208,8 +217,8 @@ module CelluloidPubsub
     #
     # @api public
     def unsubscribe_clients(channel)
-      debug "#{self.class} runs 'unsubscribe_clients' method with  #{channel}" if @server.debug_enabled?
-      return if channel.blank? || @server.subscribers[channel].blank?
+      log_debug "#{self.class} runs 'unsubscribe_clients' method with  #{channel}"
+      return if channel.blank?
       unsubscribe_from_channel(channel)
       @server.subscribers[channel] = []
     end
@@ -222,6 +231,7 @@ module CelluloidPubsub
     # @api public
     def shutdown
       debug "#{self.class} tries to 'shudown'"
+      @websocket.close if @websocket.present? && !@websocket.closed?
       terminate
     end
 
@@ -239,10 +249,14 @@ module CelluloidPubsub
     def start_subscriber(channel, message)
       return unless channel.present?
       add_subscriber_to_channel(channel, message)
-      debug "#{self.class} subscribed to #{channel} with #{message}" if @server.debug_enabled?
+      log_debug "#{self.class} subscribed to #{channel} with #{message}"
       @websocket << message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json unless @server.redis_enabled?
     end
 
+    def channel_subscribers(channel)
+       @server.subscribers[channel] || []
+     end
+
     # adds the curent actor the list of the subscribers for a particular channel
     # and registers the new channel
     #
@@ -253,11 +267,10 @@ module CelluloidPubsub
     #
     # @api public
     def add_subscriber_to_channel(channel, message)
+      registry_channels = CelluloidPubsub::Registry.channels
       @channels << channel
-      CelluloidPubsub::Registry.channels << channel unless CelluloidPubsub::Registry.channels.include?(channel)
-      @server.subscribers[channel] ||= []
-      @server.subscribers[channel] << { reactor: Actor.current, message: message }
-
+      registry_channels << channel unless registry_channels.include?(channel)
+      @server.subscribers[channel] = channel_subscribers(channel).push(reactor: Actor.current, message: message)
     end
 
     # unsubscribes all actors from all channels and terminates the curent actor
@@ -266,13 +279,11 @@ module CelluloidPubsub
     #
     # @api public
     def unsubscribe_all
-      debug "#{self.class} runs 'unsubscribe_all' method" if @server.debug_enabled?
+      log_debug "#{self.class} runs 'unsubscribe_all' method"
       CelluloidPubsub::Registry.channels.map do |channel|
-        unsubscribe_from_channel(channel)
-        @server.subscribers[channel] = []
+        unsubscribe_clients(channel)
       end
-
-      info 'clearing connections' if @server.debug_enabled?
+      log_debug 'clearing connections'
       shutdown
     end
 
@@ -283,11 +294,11 @@ module CelluloidPubsub
     #
     # @api public
     def unsubscribe_from_channel(channel)
-      debug "#{self.class} runs 'unsubscribe_from_channel' method with #{channel}" if @server.debug_enabled?
-      return if @server.subscribers[channel].blank?
-      @server.subscribers[channel].each do |hash|
-        hash[:reactor].websocket.close
-        Celluloid::Actor.kill(hash[:reactor])
+      log_debug "#{self.class} runs 'unsubscribe_from_channel' method with #{channel}"
+      (@server.subscribers[channel] || []).each do |hash|
+        reactor = hash[:reactor]
+        reactor.websocket.close
+        Celluloid::Actor.kill(reactor)
       end
     end
   end

data/lib/celluloid_pubsub/redis/redis.rb

@@ -0,0 +1,38 @@
+require_relative '../helper'
+module CelluloidPubsub
+  # class that handles redis connection
+  class Redis
+    class << self
+      include Celluloid::Logger
+      include CelluloidPubsub::Helper
+
+      @connected ||= false
+      attr_accessor :connected, :connection
+
+      alias_method :connected?, :connected
+
+      def connect(&block)
+        require 'eventmachine'
+        require 'em-hiredis'
+        run_the_eventmachine(&block)
+        setup_em_exception_handler
+      end
+
+    private
+
+      def run_the_eventmachine(&block)
+        EM.run do
+          @connection = EM::Hiredis.connect
+          @connected = true
+          block.call @connection
+        end
+      end
+
+      def setup_em_exception_handler
+        EM.error_handler do |error|
+          debug error unless filtered_error?(error)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid_pubsub/redis/redis_reactor.rb

@@ -0,0 +1,97 @@
+require_relative '../reactor'
+module CelluloidPubsub
+  # reactor used for redis pubsub
+  class RedisReactor < CelluloidPubsub::Reactor
+    include Celluloid
+    include Celluloid::IO
+    include Celluloid::Logger
+
+    def unsubscribe(channel)
+      super
+      async.redis_action('unsubscribe', channel)
+    end
+
+    def add_subscriber_to_channel(channel, message)
+      super
+      async.redis_action('subscribe', channel, message)
+    end
+
+    def unsubscribe_from_channel(channel)
+      super
+      async.redis_action('unsubscribe', channel)
+    end
+
+    def unsubscribe_all
+      CelluloidPubsub::Registry.channels.map do |channel|
+        async.redis_action('unsubscribe', channel)
+      end
+      info 'clearing connections'
+      shutdown
+    end
+
+    def shutdown
+      @channels.each do |channel|
+        redis_action('unsubscribe', channel)
+      end if @channels.present?
+      super
+    end
+
+  private
+
+    def fetch_pubsub
+      CelluloidPubsub::Redis.connect do |connection|
+        yield connection.pubsub
+      end
+    end
+
+    def action_subscribe?(action)
+      action == 'subscribe'
+    end
+
+    def action_success(action, channel, message)
+      action_subscribe?(action) ? message.merge('client_action' => 'successful_subscription', 'channel' => channel) : nil
+    end
+
+    def redis_action(action, channel = nil, message = {})
+      fetch_pubsub do |pubsub|
+        callback = prepare_redis_action(action)
+        success_message = action_success(action, channel, message)
+        subscription = pubsub.send(action, channel, callback)
+        handle_redis_action(subscription, action, success_message)
+      end
+    end
+
+
+    def prepare_redis_action(action)
+      log_unsubscriptions(pubsub)
+      proc do |subscribed_message|
+        action_subscribe?(action) ? (@websocket << subscribed_message) : log_debug(message)
+      end
+    end
+
+    def log_unsubscriptions(pubsub)
+      pubsub.on(:unsubscribe) do |subscribed_channel, remaining_subscriptions|
+        log_debug [:unsubscribe_happened, subscribed_channel, remaining_subscriptions].inspect
+      end
+    end
+
+    def handle_redis_action(subscription, action, sucess_message = nil)
+      register_redis_callback(subscription, sucess_message)
+      register_redis_error_callback(subscription, action)
+    end
+
+    def register_redis_callback(subscription, sucess_message = nil)
+      subscription.callback do |subscriptions_ids|
+        if sucess_message.present?
+          @websocket << sucess_message.merge('subscriptions' => subscriptions_ids).to_json
+        else
+          log_debug "#{action} success #{success_response.inspect}"
+        end
+      end
+    end
+
+    def register_redis_error_callback(subscription, action)
+      subscription.errback { |reply| log_debug "#{action} error #{reply.inspect}" }
+    end
+  end
+end

data/lib/celluloid_pubsub/version.rb

@@ -15,7 +15,7 @@ module CelluloidPubsub
     # major release version
     MAJOR = 0
     # minor release version
-    MINOR = 2
+    MINOR = 3
     # tiny release version
     TINY = 0
     # prelease version ( set this only if it is a prelease)

data/lib/celluloid_pubsub/web_server.rb

@@ -1,4 +1,5 @@
 require_relative './reactor'
+require_relative './helper'
 module CelluloidPubsub
   # webserver to which socket connects should connect to .
   # the server will dispatch each request into a new Reactor
@@ -30,6 +31,7 @@ module CelluloidPubsub
   #   @return [Boolean] Enable this only if you want to enable debugging for the webserver
   class WebServer < Reel::Server::HTTP
     include Celluloid::Logger
+    include CelluloidPubsub::Helper
 
     # The hostname on which the webserver runs on by default
     HOST = '0.0.0.0'
@@ -54,11 +56,21 @@ module CelluloidPubsub
     #
     # :nocov:
     def initialize(options = {})
-      options = options.is_a?(Array) ? options.first : options
-      parse_options(options)
+      Celluloid.boot unless Celluloid.running?
+      @options = parse_options(options)
       @subscribers = {}
-      info "CelluloidPubsub::WebServer example starting on #{@hostname}:#{@port}" if debug_enabled?
-      super(@hostname, @port, { spy: @spy, backlog: @backlog }, &method(:on_connection))
+      setup_celluloid_logger
+      log_debug "CelluloidPubsub::WebServer example starting on #{hostname}:#{port}"
+      super(hostname, port, { spy: spy, backlog: backlog }, &method(:on_connection))
+    end
+
+    def use_redis
+      @use_redis ||= @options.fetch('use_redis', false)
+    end
+
+    def debug_enabled?
+      @debug_enabled = @options.fetch('enable_debug', false)
+      @debug_enabled == true
     end
 
     # the method will terminate the current actor
@@ -72,44 +84,34 @@ module CelluloidPubsub
       terminate
     end
 
-    # :nocov:
+    def log_file_path
+      @log_file_path ||= @options.fetch('log_file_path', nil)
+    end
 
-    #  receives a list of options that are used to configure the webserver
-    #
-    # @param  [Hash]  options the options that can be used to connect to webser and send additional data
-    # @option options [String]:hostname The hostname on which the webserver runs on
-    # @option options [Integer] :port The port on which the webserver runs on
-    # @option options [String] :path The request path that the webserver accepts
-    # @option options [Boolean] :spy Enable this only if you want to enable debugging for the webserver
-    # @option options [Integer]:backlog How many connections the server accepts
-    #
-    # @return [void]
-    #
-    # @api public
-    def parse_options(options)
-      options = options.is_a?(Hash) ? options : {}
-      @options = options.stringify_keys
-      debug @options if debug_enabled?
-      @backlog = @options.fetch('backlog', 1024)
-      @hostname = @options.fetch('hostname', CelluloidPubsub::WebServer::HOST)
-      @port = @options.fetch('port', CelluloidPubsub::WebServer::PORT)
-      @path = @options.fetch('path', CelluloidPubsub::WebServer::PATH)
-      @spy = @options.fetch('spy', false)
-      @use_redis = @options.fetch('use_redis', false)
-      @debug_enabled = @options.fetch('enable_debug', false)
+    def hostname
+      @hostname ||= @options.fetch('hostname', CelluloidPubsub::WebServer::HOST)
     end
 
-    #  checks if debug is enabled
-    #
-    # @return [boolean]
-    #
-    # @api public
-    def debug_enabled?
-      @debug_enabled.to_s == 'true'
+    def port
+      @port ||= @options.fetch('port', CelluloidPubsub::WebServer::PORT)
+    end
+
+    def path
+      @path ||= @options.fetch('path', CelluloidPubsub::WebServer::PATH)
+    end
+
+    def spy
+      @spy ||= @options.fetch('spy', false)
+    end
+
+    def backlog
+      @backlog = @options.fetch('backlog', 1024)
     end
 
+    # :nocov:
+
     def redis_enabled?
-      @use_redis.to_s.downcase == 'true'
+      use_redis.to_s.downcase == 'true'
     end
 
     #  method for publishing data to a channel
@@ -121,16 +123,27 @@ module CelluloidPubsub
     #
     # @api public
     def publish_event(current_topic, message)
-      return if current_topic.blank? || message.blank?
       if redis_enabled?
-        CelluloidPubsub::Redis.connection.publish(current_topic, message)
-      elsif @subscribers[current_topic].present?
-        @subscribers[current_topic].each do |hash|
-          hash[:reactor].websocket << message
-        end
+        publish_redis_event(current_topic, message)
+      else
+        publish_clasic_event(current_topic, message)
+      end
+    rescue => exception
+      log_debug("could not publish message #{message} into topic #{current_topic} because of #{exception.inspect}")
+    end
+
+    def publish_redis_event(topic, data)
+      return if !redis_enabled? || topic.blank? || data.blank?
+      CelluloidPubsub::Redis.connect do |connection|
+        connection.publish(topic, data)
+      end
+    end
+
+    def publish_clasic_event(channel, data)
+      return if channel.blank? || data.blank?
+      (@subscribers[channel] || []).each do |hash|
+        hash[:reactor].websocket << data
       end
-    rescue => e
-      debug("could not publish message #{message} into topic #{current_topic} because of #{e.inspect}") if debug_enabled?
     end
 
     #  callback that will execute when receiving new conections
@@ -149,7 +162,7 @@ module CelluloidPubsub
     def on_connection(connection)
       while request = connection.request
         if request.websocket?
-          info "#{self.class} Received a WebSocket connection" if debug_enabled?
+          log_debug "#{self.class} Received a WebSocket connection"
 
           # We're going to hand off this connection to another actor (Writer/Reader)
           # However, initially Reel::Connections are "attached" to the
@@ -159,7 +172,7 @@ module CelluloidPubsub
           # If we want to hand this connection off to another actor, we first
           # need to detach it from the Reel::Server (in this case, Reel::Server::HTTP)
           connection.detach
-          route_websocket(request.websocket)
+          dispatch_websocket_request(request)
           return
         else
           route_request connection, request
@@ -167,6 +180,16 @@ module CelluloidPubsub
       end
     end
 
+    def reactor_class
+      redis_enabled? ? CelluloidPubsub::RedisReactor : CelluloidPubsub::Reactor
+    end
+
+    def dispatch_websocket_request(request)
+      reactor = reactor_class.new
+      Actor.current.link reactor
+      route_websocket(reactor, request.websocket)
+    end
+
     #  HTTP connections are not accepted so this method will show 404 message "Not Found"
     #
     # @param [Reel::WebSocket] connection The HTTP connection that was received
@@ -176,7 +199,7 @@ module CelluloidPubsub
     #
     # @api public
     def route_request(connection, request)
-      info "404 Not Found: #{request.path}" if debug_enabled?
+      log_debug "404 Not Found: #{request.path}"
       connection.respond :not_found, 'Not found'
     end
 
@@ -190,14 +213,12 @@ module CelluloidPubsub
     # @return [void]
     #
     # @api public
-    def route_websocket(socket)
-      if socket.url == @path
-        reactor = redis_enabled? ? CelluloidPubsub::RedisReactor.new : CelluloidPubsub::Reactor.new
-        info "#{reactor.class} handles new socket connection" if debug_enabled?
-        Actor.current.link reactor
+    def route_websocket(reactor, socket)
+      url = socket.url
+      if url == path
         reactor.async.work(socket, Actor.current)
       else
-        info "Received invalid WebSocket request for: #{socket.url}" if debug_enabled?
+        log_debug "Received invalid WebSocket request for: #{url}"
         socket.close
       end
     end
@@ -212,14 +233,14 @@ module CelluloidPubsub
     #
     # @api public
     def handle_dispatched_message(reactor, data)
-      debug "#{self.class} trying to dispatch message  #{data.inspect}" if debug_enabled?
+      log_debug "#{self.class} trying to dispatch message  #{data.inspect}"
       message = reactor.parse_json_data(data)
       if message.present? && message.is_a?(Hash)
-        reactor.websocket << message.to_json
+        final_data = message.to_json
       else
-        reactor.websocket << data.to_json
+        final_data data.to_json
       end
+      reactor.websocket << final_data
     end
-
   end
 end

data/spec/lib/celluloid_pubsub/client_pubsub_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe CelluloidPubsub::Client do
   let(:blk) { proc { |a| puts a } }
   let(:options) { {} }
-  let(:socket) { mock }
   let(:actor) { mock }
   let(:connection) { mock }
   let(:channel) { 'some_channel' }
 
   before(:each) do
-    Celluloid::WebSocket::Client.stubs(:new).returns(connection)
-    @worker = CelluloidPubsub::Client.new({ 'actor' => actor, channel: channel, enable_debug: true }, &blk)
-    @worker.stubs(:client).returns(socket)
+    CelluloidPubsub::Client.any_instance.stubs(:supervise_actors).returns(true)
+    CelluloidPubsub::Client.any_instance.stubs(:connection).returns(connection)
+    @worker = CelluloidPubsub::Client.new(actor: actor, channel: channel, enable_debug: false)
     @worker.stubs(:debug).returns(true)
     @worker.stubs(:async).returns(@worker)
     actor.stubs(:async).returns(actor)
-    socket.stubs(:terminate).returns(true)
+    actor.stubs(:respond_to?).returns(false)
+    actor.stubs(:terminate).returns(true)
     connection.stubs(:terminate).returns(true)
     connection.stubs(:text).returns(true)
   end
@@ -56,7 +56,7 @@ describe CelluloidPubsub::Client do
   describe '#debug_enabled?' do
     it 'checks if debug is enabled' do
       act = @worker.debug_enabled?
-      expect(act).to eq(true)
+      expect(act).to eq(false)
     end
   end
 

data/spec/lib/celluloid_pubsub/reactor_spec.rb

@@ -12,7 +12,9 @@ describe CelluloidPubsub::Reactor do
     server.stubs(:async).returns(server)
     server.stubs(:handle_dispatched_message)
     server.stubs(:subscribers).returns({})
+    server.stubs(:redis_enabled?).returns(false)
     websocket.stubs(:read)
+    websocket.stubs(:url)
     subject.stubs(:inspect).returns(subject)
     subject.stubs(:run)
     subject.work(websocket, server)

data/spec/spec_helper.rb

@@ -44,11 +44,3 @@ RSpec.configure do |config|
     end
   end
 end
-
-# class used for testing actions
-class TestActor
-  include Celluloid
-  include Celluloid::Logger
-end
-
-TestActor.supervise_as(:test_actor)