celluloid_pubsub_redis_adapter 0.0.1

data/examples/shared_classes.rb

@@ -0,0 +1,73 @@
+require 'bundler/setup'
+require 'celluloid_pubsub'
+require 'celluloid_pubsub_redis_adapter'
+require 'logger'
+
+debug_enabled = ENV['DEBUG'].present? && ENV['DEBUG'].to_s == 'true'
+use_redis = ENV['USE_REDIS'].to_s == 'true' ? 'redis': ''
+log_file_path = File.join(File.expand_path(File.dirname(__FILE__)), 'log', 'celluloid_pubsub.log')
+
+# actor that subscribes to a channel
+class Subscriber
+  include Celluloid
+  include Celluloid::Logger
+
+  def initialize(options = {})
+    @client = CelluloidPubsub::Client.new({ actor: Actor.current, channel: 'test_channel' }.merge(options))
+  end
+
+  def on_message(message)
+    if @client.succesfull_subscription?(message)
+      puts "subscriber got successful subscription #{message.inspect}"
+      @client.publish('test_channel2', 'data' => ' subscriber got successfull subscription') # the message needs to be a Hash
+    else
+      puts "subscriber got message #{message.inspect}"
+    end
+  end
+
+  def on_close(code, reason)
+    puts "websocket connection closed: #{code.inspect}, #{reason.inspect}"
+    terminate
+  end
+
+
+end
+
+# actor that publishes a message in a channel
+class Publisher
+  include Celluloid
+  include Celluloid::Logger
+
+  def initialize(options = {})
+    @client = CelluloidPubsub::Client.new({ actor: Actor.current, channel: 'test_channel2' }.merge(options))
+  end
+
+  def on_message(message)
+    if @client.succesfull_subscription?(message)
+      puts "publisher got successful subscription #{message.inspect}"
+      @client.publish('test_channel', 'data' => ' my_message') # the message needs to be a Hash
+    else
+      puts "publisher got message #{message.inspect}"
+    end
+  end
+
+  def on_close(code, reason)
+    puts "websocket connection closed: #{code.inspect}, #{reason.inspect}"
+    terminate
+  end
+
+end
+
+
+CelluloidPubsub::WebServer.supervise_as(:web_server, enable_debug: debug_enabled, adapter: use_redis,log_file_path: log_file_path )
+Subscriber.supervise_as(:subscriber, enable_debug: debug_enabled)
+Publisher.supervise_as(:publisher, enable_debug: debug_enabled)
+signal_received = false
+
+Signal.trap('INT') do
+  puts "\nAn interrupt signal has been triggered!"
+  signal_received = true
+end
+
+sleep 0.1 until signal_received
+puts 'Exited succesfully! =)'

data/examples/simple_test.rb

@@ -0,0 +1,2 @@
+ENV['USE_REDIS'] = 'false'
+require_relative './shared_classes'

data/init.rb

@@ -0,0 +1 @@
+require 'celluloid_pubsub_redis_adapter'

data/lib/celluloid_pubsub_redis_adapter/redis_reactor.rb

@@ -0,0 +1,282 @@
+require 'celluloid_pubsub/reactor'
+require 'celluloid_pubsub/helper'
+module CelluloidPubsub
+  # reactor used for redis pubsub
+  # @!attribute connected
+  #   @return [Boolean] returns true if already connected to redis
+  # @!attribute connection
+  #   @return [EM::Hiredis] The connection used for redis
+  class RedisReactor < CelluloidPubsub::Reactor
+    include Celluloid
+    include Celluloid::IO
+    include Celluloid::Logger
+    include CelluloidPubsub::Helper
+
+    attr_accessor :connected, :connection
+
+    alias_method :connected?, :connected
+
+    # returns true if already connected to redis otherwise false
+    #
+    # @return [Boolean] returns true if already connected to redis otherwise false
+    #
+    # @api public
+    def connected
+      @connected ||= false
+    end
+
+    # method used to unsubscribe from a channel
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe(channel)
+      super
+      async.redis_action('unsubscribe', channel)
+    end
+
+    # method used to subscribe to a channel
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def add_subscriber_to_channel(channel, message)
+      super
+      async.redis_action('subscribe', channel, message)
+    end
+
+    # method used to unsubscribe from a channel
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_from_channel(channel)
+      super
+      async.redis_action('unsubscribe', channel)
+    end
+
+    # method used to unsubscribe  from all channels
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_all
+      info 'clearing connections'
+      shutdown
+    end
+
+    # method used to shutdown the reactor and unsubscribe from all channels
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def shutdown
+      @channels.dup.each do |channel|
+        redis_action('unsubscribe', channel)
+      end if @channels.present?
+      super
+    end
+
+    # method used to publish event using redis
+    #
+    # @return [void]
+    #
+    # @api public
+    def publish_event(topic, data)
+      return if topic.blank? || data.blank?
+      connect_to_redis do |connection|
+        connection.publish(topic, data)
+      end
+    rescue => exception
+      log_debug("could not publish message #{message} into topic #{current_topic} because of #{exception.inspect}")
+    end
+
+  private
+
+    # method used to run the enventmachine and setup the exception handler
+    # @see #run_the_eventmachine
+    # @see #setup_em_exception_handler
+    #
+    # @param [Proc] block the block that will use the connection
+    #
+    # @return [void]
+    #
+    # @api private
+    def connect_to_redis(&block)
+      require 'eventmachine'
+      require 'em-hiredis'
+      run_the_eventmachine(&block)
+      setup_em_exception_handler
+    end
+
+    # method used to connect to redis and yield the connection
+    #
+    # @param [Proc] block the block that will use the connection
+    #
+    # @return [void]
+    #
+    # @api private
+    def run_the_eventmachine(&block)
+      EM.run do
+        @connection ||= EM::Hiredis.connect
+        @connected = true
+        block.call @connection
+      end
+    end
+
+    # method used to setup the eventmachine exception handler
+    #
+    # @return [void]
+    #
+    # @api private
+    def setup_em_exception_handler
+      EM.error_handler do |error|
+        debug error unless filtered_error?(error)
+      end
+    end
+
+    # method used to fetch the pubsub client from the connection and yield it
+    #
+    # @return [void]
+    #
+    # @api private
+    def fetch_pubsub
+      connect_to_redis do |connection|
+        @pubsub ||= connection.pubsub
+        yield @pubsub if block_given?
+      end
+    end
+
+    # method used to fetch the pubsub client from the connection and yield it
+    # @see #action_subscribe
+    #
+    # @param [string] action The action that will be checked
+    # @param [string] channel The channel that reactor has subscribed to
+    # @param [string] message The initial message used to subscribe
+    #
+    # @return [void]
+    #
+    # @api private
+    def action_success(action, channel, message)
+      action_subscribe?(action) ? message.merge('client_action' => 'successful_subscription', 'channel' => channel) : nil
+    end
+
+    # method used execute an action (subscribe or unsubscribe ) to redis
+    # @see #prepare_redis_action
+    # @see #action_success
+    # @see #register_subscription_callbacks
+    #
+    # @param [string] action The action that will be checked
+    # @param [string] channel The channel that reactor has subscribed to
+    # @param [string] message The initial message used to subscribe
+    #
+    # @return [void]
+    #
+    # @api private
+    def redis_action(action, channel = nil, message = {})
+      fetch_pubsub do |pubsub|
+        callback = prepare_redis_action(pubsub, action)
+        success_message = action_success(action, channel, message)
+        args = action_subscribe?(action) ? [channel, callback] : [channel]
+        subscription = pubsub.send(action, *args)
+        register_subscription_callbacks(subscription, action, success_message)
+      end
+    end
+
+    # method used check if the action is subscribe and write the incoming message to be websocket or log the message otherwise
+    # @see #log_unsubscriptions
+    # @see #action_subscribe
+    #
+    # @param [String] action The action that will be checked if it is subscribed
+    #
+    # @return [void]
+    #
+    # @api private
+    def prepare_redis_action(pubsub, action)
+      log_unsubscriptions(pubsub)
+      proc do |subscribed_message|
+        action_subscribe?(action) ? (@websocket << subscribed_message) : log_debug(message)
+      end
+    end
+
+    # method used to listen to unsubscriptions and log them to log file
+    # @see #register_redis_callback
+    # @see #register_redis_error_callback
+    #
+    # @param [EM::Hiredis::PubsubClient] pubsub The pubsub client that will be used to listen to unsubscriptions
+    #
+    # @return [void]
+    #
+    # @api private
+    def log_unsubscriptions(pubsub)
+      pubsub.on(:unsubscribe) do |subscribed_channel, remaining_subscriptions|
+        log_debug [:unsubscribe_happened, subscribed_channel, remaining_subscriptions].inspect
+      end
+    end
+
+    # method used registers the sucess and error callabacks
+    # @see #register_redis_callback
+    # @see #register_redis_error_callback
+    #
+    # @param [EM::DefaultDeferrable] subscription The subscription object
+    # @param [string] action The action that will be checked
+    # @param [string] sucess_message The initial message used to subscribe
+    #
+    # @return [void]
+    #
+    # @api private
+    def register_subscription_callbacks(subscription, action, sucess_message = nil)
+      register_redis_callback(subscription, action, sucess_message)
+      register_redis_error_callback(subscription, action)
+    end
+
+    # the method will return true if debug is enabled
+    #
+    #
+    # @return [Boolean] returns true if debug is enabled otherwise false
+    #
+    # @api public
+    def debug_enabled?
+      @server.debug_enabled?
+    end
+
+    # method used to register a success callback  and if action is subscribe will write
+    # back to the websocket a message that will say it is a successful_subscription
+    # If action is something else, will log the incoming message
+    # @see #log_debug
+    #
+    # @param [EM::DefaultDeferrable] subscription The subscription object
+    # @param [string] sucess_message The initial message used to subscribe
+    #
+    # @return [void]
+    #
+    # @api private
+    def register_redis_callback(subscription, action, 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 #{sucess_message.inspect}"
+        end
+      end
+    end
+
+    # Register an error callback on the deferrable object and logs to file the incoming message
+    # @see #log_debug
+    #
+    # @param [EM::DefaultDeferrable] subscription The subscription object
+    # @param [string] action The action that will be checked
+    #
+    # @return [void]
+    #
+    # @api private
+    def register_redis_error_callback(subscription, action)
+      subscription.errback { |reply| log_debug "#{action} error #{reply.inspect}" }
+    end
+  end
+end

data/lib/celluloid_pubsub_redis_adapter/version.rb

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

data/lib/celluloid_pubsub_redis_adapter.rb

@@ -0,0 +1,2 @@
+require 'celluloid_pubsub'
+Gem.find_files('celluloid_pubsub_redis_adapter/**/*.rb').each { |path| require path }

data/spec/lib/celluloid_pubsub/reactor_spec.rb

@@ -0,0 +1,221 @@
+# encoding:utf-8
+
+require 'spec_helper'
+
+describe CelluloidPubsub::RedisReactor do
+  let(:websocket) { mock }
+  let(:server) { mock }
+
+  before(:each) do
+    subject.stubs(:async).returns(subject)
+    server.stubs(:debug_enabled?).returns(false)
+    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)
+    websocket.stubs(:close)
+    websocket.stubs(:closed?).returns(false)
+    server.stubs(:alive?).returns(true)
+    subject.stubs(:inspect).returns(subject)
+    subject.stubs(:run)
+    subject.work(websocket, server)
+    subject.stubs(:unsubscribe_from_channel).returns(true)
+    Celluloid::Actor.stubs(:kill).returns(true)
+  end
+
+  describe '#work' do
+    it 'works ' do
+      subject.expects(:run)
+      subject.work(websocket, server)
+      expect(subject.websocket).to eq websocket
+      expect(subject.server).to eq server
+      expect(subject.channels).to eq []
+    end
+  end
+
+  #  describe '#rub' do
+  #    let(:data) { 'some message' }
+  #
+  #    it 'works ' do
+  #      subject.unstub(:run)
+  #      websocket.stubs(:read).returns(data)
+  #        subject.expects(:handle_websocket_message).with(data)
+  #      subject.run
+  #    end
+  #  end
+
+  describe '#parse_json_data' do
+    let(:data) { 'some message' }
+    let(:expected) { data.to_json }
+
+    it 'works with hash ' do
+      JSON.expects(:parse).with(data).returns(expected)
+      actual = subject.parse_json_data(data)
+      expect(actual).to eq expected
+    end
+
+    it 'works with exception parsing  ' do
+      JSON.expects(:parse).with(data).raises(StandardError)
+      actual = subject.parse_json_data(data)
+      expect(actual).to eq data
+    end
+  end
+
+  describe '#handle_websocket_message' do
+    let(:data) { 'some message' }
+    let(:json_data) { { a: 'b' } }
+
+    it 'handle_websocket_message' do
+      subject.expects(:parse_json_data).with(data).returns(json_data)
+      subject.expects(:handle_parsed_websocket_message).with(json_data)
+      subject.handle_websocket_message(data)
+    end
+  end
+
+  describe '#handle_parsed_websocket_message' do
+    it 'handle_websocket_message with a hash' do
+      data = { 'client_action' => 'b' }
+      data.expects(:stringify_keys).returns(data)
+      subject.expects(:delegate_action).with(data)
+      subject.handle_parsed_websocket_message(data)
+    end
+
+    it 'handle_websocket_message with something else than a hash' do
+      data = 'some message'
+      subject.expects(:handle_unknown_action).with(data)
+      subject.handle_parsed_websocket_message(data)
+    end
+  end
+
+  describe '#delegate_action' do
+    it 'unsubscribes all' do
+      data = { 'client_action' => 'unsubscribe_all' }
+      subject.expects(:unsubscribe_all).returns('bla')
+      subject.delegate_action(data)
+    end
+
+    it 'unsubscribes all' do
+      data = { 'client_action' => 'unsubscribe', 'channel' => 'some channel' }
+      subject.expects(:unsubscribe).with(data['channel'])
+      subject.delegate_action(data)
+    end
+
+    it 'subscribes to channell' do
+      data = { 'client_action' => 'subscribe', 'channel' => 'some channel' }
+      subject.expects(:start_subscriber).with(data['channel'], data)
+      subject.delegate_action(data)
+    end
+
+    it 'publish' do
+      data = { 'client_action' => 'publish', 'channel' => 'some channel', 'data' => 'some data' }
+      subject.expects(:publish_event).with(data['channel'], data['data'].to_json)
+      subject.delegate_action(data)
+    end
+
+    it 'handles unknown' do
+      data = { 'client_action' => 'some action', 'channel' => 'some channel' }
+      subject.expects(:handle_unknown_action).with(data)
+      subject.delegate_action(data)
+    end
+  end
+
+  describe '#handle_unknown_action' do
+    it 'handles unknown' do
+      data = 'some data'
+      server.expects(:handle_dispatched_message)
+      subject.handle_unknown_action(data)
+    end
+  end
+
+  describe '#unsubscribe_client' do
+    let(:channel) { 'some channel' }
+    it 'returns nil' do
+      act = subject.unsubscribe('')
+      expect(act).to eq(nil)
+    end
+
+    it 'unsubscribes' do
+      subject.channels.stubs(:blank?).returns(false)
+      subject.channels.expects(:delete).with(channel)
+      act = subject.unsubscribe(channel)
+      expect(act).to eq([])
+    end
+
+    it 'unsubscribes' do
+      subject.channels.stubs(:blank?).returns(true)
+      subject.websocket.expects(:close)
+      act = subject.unsubscribe(channel)
+      expect(act).to eq([])
+    end
+
+    it 'unsubscribes' do
+      subject.channels.stubs(:blank?).returns(false)
+      subject.channels.stubs(:delete)
+      server.stubs(:subscribers).returns("#{channel}" => [{ reactor: subject }])
+      subject.unsubscribe(channel)
+      expect(server.subscribers[channel]).to eq([])
+    end
+  end
+
+  describe '#shutdown' do
+    it 'shutdowns' do
+      subject.expects(:terminate)
+      subject.shutdown
+    end
+  end
+
+  describe '#start_subscriber' do
+    let(:channel) { 'some channel' }
+    let(:message) { { a: 'b' } }
+
+    it 'subscribes ' do
+      act = subject.start_subscriber('', message)
+      expect(act).to eq(nil)
+    end
+
+    it 'subscribes ' do
+      subject.stubs(:add_subscriber_to_channel).with(channel, message)
+      server.stubs(:redis_enabled?).returns(false)
+      subject.websocket.expects(:<<).with(message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json)
+      subject.start_subscriber(channel, message)
+    end
+
+    #    it 'raises error' do
+    #      subject.stubs(:add_subscriber_to_channel).raises(StandardError)
+    #
+    #      expect do
+    #        subject.start_subscriber(channel, message)
+    #      end.to raise_error(StandardError) { |e|
+    #        expect(e.message).to include(channel)
+    #      }
+    #    end
+  end
+
+  describe '#add_subscriber_to_channel' do
+    let(:channel) { 'some channel' }
+    let(:message) { { a: 'b' } }
+    let(:subscribers) { mock }
+
+    it 'adds subscribed' do
+      CelluloidPubsub::Registry.channels.stubs(:include?).with(channel).returns(false)
+      CelluloidPubsub::Registry.channels.expects(:<<).with(channel)
+      subject.expects(:channel_subscribers).with(channel).returns(subscribers)
+      subscribers.expects(:push).with(reactor: subject, message: message)
+      subject.add_subscriber_to_channel(channel, message)
+      expect(subject.channels).to include(channel)
+    end
+  end
+
+  describe '#unsubscribe_all' do
+    let(:channel) { 'some channel' }
+    let(:message) { { a: 'b' } }
+
+    it 'adds subscribed' do
+      CelluloidPubsub::Registry.stubs(:channels).returns([channel])
+      subject.expects(:unsubscribe_from_channel).with(channel)
+      subject.unsubscribe_all
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# Configure Rails Envinronment
+ENV['RAILS_ENV'] = 'test'
+
+require 'simplecov'
+require 'simplecov-summary'
+require 'coveralls'
+
+# require "codeclimate-test-reporter"
+formatters = [SimpleCov::Formatter::HTMLFormatter]
+
+formatters << Coveralls::SimpleCov::Formatter # if ENV['TRAVIS']
+# formatters << CodeClimate::TestReporter::Formatter # if ENV['CODECLIMATE_REPO_TOKEN'] && ENV['TRAVIS']
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[*formatters]
+
+Coveralls.wear!
+SimpleCov.start 'rails' do
+  add_filter 'spec'
+
+  at_exit {}
+end
+
+# CodeClimate::TestReporter.configure do |config|
+#  config.logger.level = Logger::WARN
+# end
+# CodeClimate::TestReporter.start
+
+require 'bundler/setup'
+require 'celluloid_pubsub'
+require 'celluloid_pubsub_redis_adapter'
+
+RSpec.configure do |config|
+  require 'rspec/expectations'
+  config.include RSpec::Matchers
+
+  config.mock_with :mocha
+
+  config.after(:suite) do
+    if SimpleCov.running
+      silence_stream(STDOUT) do
+        SimpleCov::Formatter::HTMLFormatter.new.format(SimpleCov.result)
+      end
+
+      SimpleCov::Formatter::SummaryFormatter.new.format(SimpleCov.result)
+    end
+  end
+end