celluloid_pubsub 1.0.2 → 2.0.0

data/lib/celluloid_pubsub/initializers/reel_colors.rb

@@ -1,17 +1,22 @@
 # encoding: utf-8
 # frozen_string_literal: true
+
 require 'reel/spy'
 Reel::Spy::Colors.class_eval do
   alias_method :original_colorize, :colorize
 
-  def colorize(_n, str)
+  # :nocov:
+  def colorize(_var, str)
     force_utf8_encoding(str)
   end
+  # :nocov:
 
   # Returns utf8 encoding of the msg
   # @param [String] msg
   # @return [String] ReturnsReturns utf8 encoding of the msg
+  # :nocov:
   def force_utf8_encoding(msg)
     msg.respond_to?(:force_encoding) && msg.encoding.name != 'UTF-8' ? msg.force_encoding('UTF-8') : msg
   end
+  # :nocov:
 end

data/lib/celluloid_pubsub/reactor.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
+
 require_relative './registry'
 require_relative './helper'
 module CelluloidPubsub
@@ -18,7 +19,7 @@ module CelluloidPubsub
     include CelluloidPubsub::BaseActor
 
     # available actions that can be delegated
-    AVAILABLE_ACTIONS = %w(unsubscribe_clients unsubscribe subscribe publish unsubscribe_all).freeze
+    AVAILABLE_ACTIONS = %w[unsubscribe_clients unsubscribe subscribe publish unsubscribe_all].freeze
 
     # The websocket connection received from the server
     # @return [Reel::WebSocket] websocket connection
@@ -32,7 +33,13 @@ module CelluloidPubsub
     # @return [Array] array of channels to which the current reactor has subscribed to
     attr_accessor :channels
 
+    # The same options passed to the server are available on the reactor too
+    # @return [Hash] Hash with all the options passed to the server
+    attr_reader :options
+
     finalizer :shutdown
+    trap_exit :actor_died
+
     #  rececives a new socket connection from the server
     #  and listens for messages
     #
@@ -42,11 +49,68 @@ module CelluloidPubsub
     #
     # @api public
     def work(websocket, server)
+      initialize_data(websocket, server)
+      server.reactors << Actor.current
+      async.run
+    end
+
+    # initializes the actor
+    #
+    # @param  [Reel::WebSocket] websocket
+    # @param  [CelluloidPubsub::WebServer] server
+    #
+    # @return [Celluloid::Actor] returns the actor
+    #
+    # @api public
+    def initialize_data(websocket, server)
+      @websocket = websocket
       @server = server
+      @options = @server.server_options
       @channels = []
-      @websocket = websocket
-      log_debug "#{self.class} Streaming changes for #{websocket.url}"
-      async.run
+      @shutting_down = false
+      setup_celluloid_logger
+      log_debug "#{self.class} Streaming changes for #{websocket.url} #{websocket.class.name}"
+      yield(websocket, server) if block_given?
+      cell_actor
+    end
+
+    # the method will return the file path of the log file where debug messages will be printed
+    #
+    #
+    # @return [String] returns the file path of the log file where debug messages will be printed
+    #
+    # @api public
+    def log_file_path
+      @log_file_path ||= options.fetch('log_file_path', nil)
+    end
+
+    # the method will return the log level of the logger
+    #
+    # @return [Integer, nil] return the log level used by the logger ( default is 1 - info)
+    #
+    # @api public
+    def log_level
+      @log_level ||= options['log_level'] || ::Logger::Severity::INFO
+    end
+
+    # the method will return options needed when configuring an adapter
+    # @see celluloid_pubsub_redis_adapter for more information
+    #
+    # @return [Hash] returns options needed by the adapter
+    #
+    # @api public
+    def adapter_options
+      @adapter_options ||= options['adapter_options'] || {}
+    end
+
+    # the method will return true if the actor is shutting down
+    #
+    #
+    # @return [Boolean] returns true if the actor is shutting down
+    #
+    # @api public
+    def shutting_down?
+      @shutting_down == true
     end
 
     # the method will return true if debug is enabled
@@ -56,7 +120,8 @@ module CelluloidPubsub
     #
     # @api public
     def debug_enabled?
-      !@server.dead? && @server.debug_enabled?
+      @debug_enabled = options.fetch('enable_debug', false)
+      @debug_enabled == true
     end
 
     # reads from the socket the message
@@ -70,11 +135,12 @@ module CelluloidPubsub
     # :nocov:
     def run
       loop do
-        break if Actor.current.dead? || @websocket.closed? || @server.dead?
+        break if shutting_down? || actor_dead?(Actor.current) || @websocket.closed? || actor_dead?(@server)
         message = try_read_websocket
         handle_websocket_message(message) if message.present?
       end
     end
+    # :nocov:
 
     # will try to read the message from the websocket
     # and if it fails will log the exception if debug is enabled
@@ -83,10 +149,9 @@ module CelluloidPubsub
     #
     # @api public
     #
-    # :nocov:
     def try_read_websocket
       @websocket.closed? ? nil : @websocket.read
-    rescue
+    rescue StandardError
       nil
     end
 
@@ -108,9 +173,10 @@ module CelluloidPubsub
     #
     # @api public
     def parse_json_data(message)
+      log_debug "#{reactor_class} received #{message}"
       JSON.parse(message)
-    rescue => exception
-      log_debug "#{reactor_class} could not parse #{message} because of #{exception.inspect}"
+    rescue StandardError => e
+      log_debug "#{reactor_class} could not parse #{message} because of #{e.inspect}"
       message
     end
 
@@ -147,7 +213,7 @@ module CelluloidPubsub
     #
     # @api public
     def handle_parsed_websocket_message(json_data)
-      data =  json_data.is_a?(Hash) ? json_data.stringify_keys : {}
+      data = json_data.is_a?(Hash) ? json_data.stringify_keys : {}
       if CelluloidPubsub::Reactor::AVAILABLE_ACTIONS.include?(data['client_action'].to_s)
         log_debug "#{self.class} finds actions for  #{json_data}"
         delegate_action(data) if data['client_action'].present?
@@ -183,7 +249,7 @@ module CelluloidPubsub
     end
 
     # the method will delegate the message to the server in an asyncronous way by sending the current actor and the message
-    # @see {CelluloidPubsub::WebServer#handle_dispatched_message}
+    # @see CelluloidPubsub::WebServer#handle_dispatched_message
     #
     # @param [Hash] json_data
     #
@@ -262,7 +328,8 @@ module CelluloidPubsub
     #
     # @api public
     def shutdown
-      debug "#{self.class} tries to 'shudown'"
+      @shutting_down = true
+      log_debug "#{self.class} tries to 'shutdown'"
       @websocket.close if @websocket.present? && !@websocket.closed?
       terminate
     end
@@ -285,6 +352,42 @@ module CelluloidPubsub
       @websocket << message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json if @server.adapter == CelluloidPubsub::WebServer::CLASSIC_ADAPTER
     end
 
+    # this method will write to the socket all messages that were published
+    # to that channel before the actor subscribed
+    #
+    # @param [String] channel
+    # @return [void]
+    #
+    # @api public
+    def send_unpublished(channel)
+      return if (messages = unpublished_messages(channel)).blank?
+      messages.each do |msg|
+        @websocket << msg.to_json
+      end
+    end
+
+    # the method clears all the messages left unpublished in a channel
+    #
+    # @param [String] channel
+    #
+    # @return [void]
+    #
+    # @api public
+    def clear_unpublished_messages(channel)
+      CelluloidPubsub::Registry.messages[channel] = []
+    end
+
+    # the method will return a list of all unpublished messages in a channel
+    #
+    # @param [String] channel
+    #
+    # @return [Array] the list of messages that were not published
+    #
+    # @api public
+    def unpublished_messages(channel)
+      (messages = CelluloidPubsub::Registry.messages[channel]).present? ? messages : []
+    end
+
     # this method will return a list of all subscribers to a particular channel or a empty array
     #
     #
@@ -326,9 +429,9 @@ module CelluloidPubsub
     def publish(current_topic, json_data)
       message = json_data['data'].to_json
       return if current_topic.blank? || message.blank?
-      server_pusblish_event(current_topic, message)
-    rescue => exception
-      log_debug("could not publish message #{message} into topic #{current_topic} because of #{exception.inspect}")
+      server_publish_event(current_topic, message)
+    rescue StandardError => e
+      log_debug("could not publish message #{message} into topic #{current_topic} because of #{e.inspect}")
     end
 
     # the method will publish to all subsribers of a channel a message
@@ -339,18 +442,34 @@ module CelluloidPubsub
     # @return [void]
     #
     # @api public
-    def server_pusblish_event(current_topic, message)
-      @server.mutex.synchronize do
-        (@server.subscribers[current_topic].dup || []).pmap do |hash|
+    def server_publish_event(current_topic, message)
+      if (subscribers = @server.subscribers[current_topic]).present?
+        subscribers.dup.pmap do |hash|
           hash[:reactor].websocket << message
         end
+      else
+        save_unpublished_message(current_topic, message)
+      end
+    end
+
+    # the method save the message for a specific channel if there are no subscribers
+    #
+    # @param [String] current_topic
+    # @param [#to_s] message
+    #
+    # @return [void]
+    #
+    # @api public
+    def save_unpublished_message(current_topic, message)
+      @server.timers_mutex.synchronize do
+        (CelluloidPubsub::Registry.messages[current_topic] ||= []) << message
       end
     end
 
-    # unsubscribes all actors from all channels and terminates the curent actor
+    # unsubscribes all actors from all channels and terminates the current actor
     #
     # @param [String] _channel NOT USED - needed to maintain compatibility with the other methods
-    # @param [Object] _json_data NOT USED - needed to maintain compatibility with the other methods
+    # @param [Object] json_data NOT USED - needed to maintain compatibility with the other methods
     #
     # @return [void]
     #
@@ -383,12 +502,25 @@ module CelluloidPubsub
     # @api public
     def server_kill_reactors(channel)
       @server.mutex.synchronize do
-        (@server.subscribers[channel].dup || []).pmap do |hash|
+        (@server.subscribers[channel] || []).dup.pmap do |hash|
           reactor = hash[:reactor]
           reactor.websocket.close
           Celluloid::Actor.kill(reactor)
         end
       end
     end
+
+    # method called when the actor is exiting
+    #
+    # @param [actor] actor - the current actor
+    # @param [Hash] reason - the reason it crashed
+    #
+    # @return [void]
+    #
+    # @api public
+    def actor_died(actor, reason)
+      @shutting_down = true
+      log_debug "Oh no! #{actor.inspect} has died because of a #{reason.class}"
+    end
   end
 end

data/lib/celluloid_pubsub/registry.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
+
 module CelluloidPubsub
   # class used to register new channels and save them in memory
   # @attr  channels
@@ -8,8 +9,33 @@ module CelluloidPubsub
     class << self
       # The channels that the server can handle
       # @return [Array] array of channels to which actors have subscribed to
-      attr_accessor :channels
+      attr_writer :channels
+
+      # Messages that are published before any clients being subscribed to those channels
+      # will be kept here until a client subscribes to that channel
+      # @return [Hash] key-value pairs containing the channel and the messages that were published
+      attr_writer :messages
+
+      # holds a list of all messages sent by clients that were not published
+      # to a channel because there were no subscribers at that time
+      #
+      # The keys are the channel names and the values are arrays of messages
+      #
+      # @return [Hash<String, Array<Hash>>]
+      #
+      # @api private
+      def messages
+        @messages ||= {}
+      end
+
+      #  holds a list of all known channels
+      #
+      # @return [Array<String>]
+      #
+      # @api private
+      def channels
+        @channels ||= []
+      end
     end
-    @channels = []
   end
 end

data/lib/celluloid_pubsub/version.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
+
 # Returns the version of the gem  as a <tt>Gem::Version</tt>
 module CelluloidPubsub
   #  it prints the gem version as a string
@@ -7,23 +8,40 @@ module CelluloidPubsub
   # @return [String]
   #
   # @api public
+  # :nocov:
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
+  # :nocov:
 
   # module used to generate the version string
   # provides a easy way of getting the major, minor and tiny
+  # :nocov:
   module VERSION
     # major release version
-    MAJOR = 1
+    # :nocov:
+    MAJOR = 2
+    # :nocov:
+
     # minor release version
+    # :nocov:
     MINOR = 0
+    # :nocov:
+
     # tiny release version
-    TINY = 2
+    # :nocov:
+    TINY = 0
+    # :nocov:
+
     # prelease version ( set this only if it is a prelease)
+    # :nocov:
     PRE = nil
+    # :nocov:
 
     # generates the version string
+    # :nocov:
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+    # :nocov:
   end
+  # :nocov:
 end

data/lib/celluloid_pubsub/web_server.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
+
 require_relative './reactor'
 require_relative './helper'
 module CelluloidPubsub
@@ -17,6 +18,8 @@ module CelluloidPubsub
   #   @return [Hash] The hostname on which the webserver runs on
   # @attr  mutex
   #   @return [Mutex] The mutex that will synchronize actions on subscribers
+  # @attr  timers_mutex
+  #   @return [Mutex] The mutex that will synchronize actions on registry messages
   class WebServer < Reel::Server::HTTP
     include CelluloidPubsub::BaseActor
 
@@ -27,8 +30,12 @@ module CelluloidPubsub
     # The name of the default adapter
     CLASSIC_ADAPTER = 'classic'
 
-    attr_accessor :server_options, :subscribers, :mutex
+    attr_accessor :server_options, :subscribers, :mutex, :timers_mutex
+
+    attr_reader :reactors
+
     finalizer :shutdown
+    trap_exit :actor_died
     #  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
@@ -47,8 +54,11 @@ module CelluloidPubsub
       @server_options = parse_options(options)
       @subscribers = {}
       @mutex = Mutex.new
+      @timers_mutex = Mutex.new
+      @shutting_down = false
+      @reactors = []
       setup_celluloid_logger
-      debug "CelluloidPubsub::WebServer example starting on #{hostname}:#{port}"
+      log_debug "CelluloidPubsub::WebServer example starting on #{hostname}:#{port}"
       super(hostname, port, { spy: spy, backlog: backlog }, &method(:on_connection))
     end
 
@@ -80,7 +90,7 @@ module CelluloidPubsub
     # @return [Hash]  return the socket families available as keys in the hash
     #
     # @api public
-    # rubocop:disable ClassVars
+    # rubocop:disable Style/ClassVars
     def self.socket_families
       @@socket_families ||= Hash[*socket_infos.map { |af, *_| af }.uniq.zip([]).flatten]
     end
@@ -99,7 +109,7 @@ module CelluloidPubsub
         port
       end
     end
-    # rubocop:enable ClassVars
+    # rubocop:enable Style/ClassVars
 
     # this method is overriden from the Reel::Server::HTTP in order to set the spy to the celluloid logger
     # before the connection is accepted.
@@ -107,9 +117,24 @@ module CelluloidPubsub
     # @api public
     def run
       @spy = Celluloid.logger if spy
+      async.bind_timers
       loop { async.handle_connection @server.accept }
     end
 
+    # the method will run indefinitely and will check if are there
+    # any unpublished messages that can be send to new subscribers
+    #
+    # @param [Boolean] run FLag to control if the server should try checking
+    #   if there are any unpublished messages that need to be sent
+    #
+    # @return [void]
+    #
+    # @api public
+    def bind_timers(run = false)
+      try_sending_unpublished if run
+      after(0.1) { bind_timers(true) }
+    end
+
     # the method will  return true if redis can be used otherwise false
     #
     #
@@ -121,6 +146,16 @@ module CelluloidPubsub
       @adapter.present? ? @adapter : CelluloidPubsub::WebServer::CLASSIC_ADAPTER
     end
 
+    # the method will return true if the actor is shutting down
+    #
+    #
+    # @return [Boolean] returns true if the actor is shutting down
+    #
+    # @api public
+    def shutting_down?
+      @shutting_down == true
+    end
+
     # the method will return true if debug is enabled otherwise false
     #
     #
@@ -139,7 +174,11 @@ module CelluloidPubsub
     #
     # @api public
     def shutdown
-      debug "#{self.class} tries to 'shudown'"
+      @shutting_down = true
+      log_debug "#{self.class} tries to 'shutdown'"
+      reactors.each do |reactor|
+        reactor.terminate unless actor_dead?(reactor)
+      end
       terminate
     end
 
@@ -153,6 +192,15 @@ module CelluloidPubsub
       @log_file_path = @server_options.fetch('log_file_path', nil)
     end
 
+    # the method will return the log level of the logger
+    #
+    # @return [Integer, nil] return the log level used by the logger ( default is 1 - info)
+    #
+    # @api public
+    def log_level
+      @log_level ||= @server_options['log_level'] || ::Logger::Severity::INFO
+    end
+
     # the method will return the hostname on which the server is running on
     #
     #
@@ -219,7 +267,7 @@ module CelluloidPubsub
     def on_connection(connection)
       while request = connection.request
         if request.websocket?
-          log_debug "#{self.class} Received a WebSocket connection"
+          log_debug "#{self.class} Received a WebSocket connection #{request.websocket.url}"
 
           # We're going to hand off this connection to another actor (Writer/Reader)
           # However, initially Reel::Connections are "attached" to the
@@ -294,6 +342,23 @@ module CelluloidPubsub
       end
     end
 
+    # this method will know when a client has successfully registered
+    # and will write to the socket all messages that were published
+    # to that channel before the actor subscribed
+    #
+    # @return [void]
+    #
+    # @api publicsCelluloidPubsub::Registry.messages
+    def try_sending_unpublished
+      CelluloidPubsub::Registry.messages.each_key do |channel|
+        next if (clients = subscribers[channel]).blank?
+        clients.dup.pmap do |hash|
+          hash[:reactor].send_unpublished(channel)
+        end
+        clients.last[:reactor].clear_unpublished_messages(channel)
+      end
+    end
+
     # If the message can be parsed into a Hash it will respond to the reactor's websocket connection with the same message in JSON format
     # otherwise will try send the message how it is and escaped into JSON format
     #
@@ -309,5 +374,18 @@ module CelluloidPubsub
       final_data = message.present? && message.is_a?(Hash) ? message.to_json : data.to_json
       reactor.websocket << final_data
     end
+
+    # method called when the actor is exiting
+    #
+    # @param [actor] actor - the current actor
+    # @param [Hash] reason - the reason it crashed
+    #
+    # @return [void]
+    #
+    # @api public
+    def actor_died(actor, reason)
+      @shutting_down = true
+      log_debug "Oh no! #{actor.inspect} has died because of a #{reason.class}"
+    end
   end
 end