resque-pubsub 0.1.2 → 0.2.0

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 [name of plugin creator]
+Copyright (c) 2011 Monica McArthur
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -11,26 +11,26 @@ Usage / Examples
 
 A simple class that can publish a message:
 
-  class TestPublisher
-    require 'resque-pubsub'
+    class TestPublisher
+      include Resque::Plugins::Pubsub::Publisher
     
-    def some_method
-      self.publish(topic, message)
+      def some_method
+        self.publish(topic, message)
+      end
     end
-  end
 
 
 A simple class that subscribes to messages on a particular topic:
 
-  class TestSubscriber
-    require 'resque-pubsub'
+    class TestSubscriber
+      include Resque::Plugins::Pubsub::Subscriber
   
-    subscribe 'test_topic'
+      subscribe 'test_topic'
     
-    def self.read_test_topic_message(message)
-      # Do something with the message
+      def self.read_test_topic_message(message)
+        # Do something with the message
+      end
     end
-  end
 
 
 Customize & Extend
@@ -63,13 +63,13 @@ Running Resque
 A sample config file is provided in examples/resque-pubsub.rb. If you put this in config/initializers for a Rails app,
 then Resque will default to the app namespace but will take an override on namespace from the environment variable RESQUE_NAMESPACE. Thus
 
-  QUEUE=* RESQUE_NAMESPACE="resque:pubsub" rake environment resque:work
+    QUEUE=* RESQUE_NAMESPACE="resque:pubsub" rake environment resque:work
 
 will run resque jobs against the default pubsub namespace (i.e., will be the pubsub server)
 
 while 
 
-  QUEUE=* rake environment resque:work
+    QUEUE=* rake environment resque:work
 
 will run resque in an app as normal.
 

data/examples/resque-pubsub.rb

@@ -4,7 +4,7 @@ rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../../../..'
 rails_env = ENV['RAILS_ENV'] || 'development'
 
 REDIS_CONFIG = YAML.load_file(rails_root + '/config/redis.yml')[rails_env]
-Resque.redis = REDIS_CONFIG["host"] + ':' + REDIS_CONFIG["port"].to_s
+Resque.redis = REDIS_CONFIG['host'] + ':' + REDIS_CONFIG["port"].to_s
 
 namespace = ENV['RESQUE_NAMESPACE'] || 'mynamespace' # Edit this to use a different namespace for Resque in the app
 Resque.redis.namespace = namespace

data/lib/resque-pubsub.rb

@@ -1,6 +1,2 @@
-require 'resque/plugins/pubsub/subscriber'
-require 'resque/plugins/pubsub/publisher'
-require 'resque/plugins/pubsub/broker'
-self.send(:include, Resque::Plugins::Pubsub::Subscriber)
-self.send(:include, Resque::Plugins::Pubsub::Publisher)
-
+require 'resque'
+Dir.glob(File.expand_path('resque/plugins/pubsub/*', File.dirname(__FILE__))).each { |filename| require filename }

data/lib/resque/plugins/pubsub/broker.rb

@@ -1,31 +1,34 @@
 module Resque
   module Plugins
-    #
-    # pubsub broker
-    #
     module Pubsub
       class Broker
+
         @queue = :messages
         # Returns a top-level Redis connection so that the broker can distribute messages
         # across namespaces. If none has been created, will
         # create a new one using information from the Resque connection.
-        def self.redis
-          return @redis if @redis
-          client_to_copy = Resque.redis.client
-          @redis = Redis.new(:host => client_to_copy.host, :port => client_to_copy.port,
-            :thread_safe => true, :db => client_to_copy.db)
-        end
-        
-        def self.perform(topic, message)
-          subscribers = Exchange.redis.smembers("#{topic}_subscribers")
-          subscribers.each {|s|
-            sinfo = JSON.parse(s)
-            puts "distributing to #{sinfo.inspect}"
-            Broker.redis.sadd("#{sinfo['namespace']}:queues", "fanout:#{topic}")
-            Broker.redis.rpush("#{sinfo['namespace']}:queue:fanout:#{topic}", {:class=> sinfo["class"], :args=>[message]}.to_json)
-          }
+
+        class << self
+
+          def redis
+            return @redis if @redis
+            client_to_copy = Resque.redis.client
+            @redis = Redis.new(:host => client_to_copy.host, :port => client_to_copy.port, :thread_safe => true, :db => client_to_copy.db)
+          end
+
+          def perform(topic, message)
+            subscribers = Exchange.redis.smembers("#{topic}_subscribers")
+            subscribers.each do |s|
+              sinfo = JSON.parse(s)
+              puts "[Broker] distributing to #{sinfo.inspect}"
+              Broker.redis.sadd("#{sinfo['namespace']}:queues", "fanout:#{topic}")
+              Broker.redis.rpush("#{sinfo['namespace']}:queue:fanout:#{topic}", { :class => sinfo['class'], :args => [message] }.to_json)
+            end
+          end
+
         end
+
       end
     end
   end
-end
+end

data/lib/resque/plugins/pubsub/exchange.rb

@@ -1,42 +1,39 @@
-require 'resque'
 module Resque
   module Plugins
-    #
-    # pubsub exchange manager
-    #
     module Pubsub
       class Exchange
-        @@pubsub_namespace = nil
-        # Returns the current Redis connection. If none has been created, will
-        # create a new one using information from the Resque connection and our config.
-        def self.redis
-          return @redis if @redis
-          client_to_copy = Resque.redis.client
-          redis_new = Redis.new(:host => client_to_copy.host, :port => client_to_copy.port,
-            :thread_safe => true, :db => client_to_copy.db)
-          puts "making a redis in exchange, namespace will be #{@@pubsub_namespace}"
-          @redis = Redis::Namespace.new(@@pubsub_namespace || "resque:pubsub", :redis => redis_new)
-        end
         
         @queue = :subscription_requests
-        
-        def self.perform(subscription_info)
-          puts "handling a subscription on the exchange"
-          puts "requested subscription is #{subscription_info.inspect}"
-          puts "namespace is #{Exchange.redis.namespace}"
-          redis = Exchange.redis
-          redis.sadd("#{subscription_info["topic"]}_subscribers", {:class=>subscription_info["class"], :namespace=>subscription_info["namespace"]}.to_json)
-        end
-        
-        def self.pubsub_namespace
-          @@pubsub_namespace
-        end
-        
-        def self.pubsub_namespace=(n)
-          @@pubsub_namespace = n
-          @redis.client.disconnect
-          @redis = nil
+
+        class << self
+
+          def redis
+            return @redis if @redis
+            client_to_copy = Resque.redis.client
+            redis_new = Redis.new(:host => client_to_copy.host, :port => client_to_copy.port, :thread_safe => true, :db => client_to_copy.db)
+            puts "[Exchange] making a redis in exchange, namespace will be #{@pubsub_namespace}"
+            @redis = Redis::Namespace.new(@pubsub_namespace || 'resque:pubsub', :redis => redis_new)
+          end
+
+          def perform(subscription_info)
+            puts '[Exchange] handling a subscription on the exchange'
+            puts "[Exchange] requested subscription is #{subscription_info.inspect}"
+            puts "[Exchange] namespace is #{Exchange.redis.namespace}"
+            Exchange.redis.sadd("#{subscription_info["topic"]}_subscribers", { :class => subscription_info['class'], :namespace => subscription_info['namespace'] }.to_json)
+          end
+
+          def pubsub_namespace
+            @pubsub_namespace
+          end
+
+          def pubsub_namespace=(namespace)
+            @pubsub_namespace = namespace
+            @redis.client.disconnect if @redis
+            @redis = nil
+          end
+
         end
+
       end
     end
   end

data/lib/resque/plugins/pubsub/publisher.rb

@@ -1,23 +1,22 @@
-require 'resque/plugins/pubsub/exchange'
 module Resque
   module Plugins
-    #
-    # pubsub publisher
-    #
     module Pubsub
       module Publisher
-      	def self.included(base)
-      	  puts 'including publisher'
+
+        def self.included(base)
           base.send(:include, InstanceMethods)
         end
 
         module InstanceMethods
+          
           def publish(topic, message)
-            puts "Publisher publishing #{message} in #{topic}"
-            Exchange.redis.sadd(:queues, "messages")
-            Exchange.redis.rpush("queue:messages", {:class=>'Resque::Plugins::Pubsub::Broker', :args=>[topic, message]}.to_json)
+            puts "[#{self.class.to_s}] publishing #{message} in #{topic}"
+            Exchange.redis.sadd(:queues, 'messages')
+            Exchange.redis.rpush('queue:messages', { :class => 'Resque::Plugins::Pubsub::Broker', :args => [topic, message] }.to_json)
           end
+          
         end
+
       end
     end
   end

data/lib/resque/plugins/pubsub/subscriber.rb

@@ -1,33 +1,32 @@
-require 'resque/plugins/pubsub/exchange'
 module Resque
   module Plugins
-    #
-    # pubsub subscriber
-    #
     module Pubsub
       module Subscriber
-      	def self.included(base)
-          base.extend ClassMethods
+
+        def self.included(base)
+          base.send(:extend, ClassMethods)
         end
-      
+
         module ClassMethods
+          
           def subscribe(topic, options={})
             @queue = "fanout:#{topic}"
             reader_method = options[:reader_method] || "read_#{topic}_message"
             module_eval <<-"end_eval"
               def self.perform(message)
-                self.send("#{reader_method}", message)
-      				end
+                self.send("#{reader_method.to_s}", message)
+              end
             end_eval
             options[:namespace] = Resque.redis.namespace
             options[:topic] = topic
             options[:class] = self.to_s
-            puts "Subscriber subscribing with #{options.inspect}"
+            puts "[#{self.to_s}] subscribing with #{options.inspect}"
             Exchange.redis.sadd(:queues, :subscription_requests)
-            Exchange.redis.rpush("queue:subscription_requests", {:class=>'Resque::Plugins::Pubsub::Exchange', :args=>[options]}.to_json)      
+            Exchange.redis.rpush("queue:subscription_requests", { :class => 'Resque::Plugins::Pubsub::Exchange', :args => [options] }.to_json)      
           end
           
         end
+
       end
     end
   end

data/test/fixtures/test_custom_subscriber.rb

@@ -0,0 +1,19 @@
+class TestCustomSubscriber
+  include Resque::Plugins::Pubsub::Subscriber
+
+  subscribe 'test_custom_topic', :reader_method => :simple
+
+  class << self
+
+    def simple(message)
+      puts "[#{self.to_s}] got test custom topic message: #{message.inspect}"
+      @last_message = message
+    end
+
+    def last_message
+      @last_message
+    end
+
+  end
+
+end

data/test/fixtures/test_publisher.rb

@@ -0,0 +1,3 @@
+class TestPublisher
+  include Resque::Plugins::Pubsub::Publisher
+end

data/test/fixtures/test_subscriber.rb

@@ -0,0 +1,19 @@
+class TestSubscriber
+  include Resque::Plugins::Pubsub::Subscriber
+
+  subscribe 'test_topic'
+
+  class << self
+
+    def read_test_topic_message(message)
+      puts "[#{self.to_s}] got test topic message: #{message.inspect}"
+      @last_message = message
+    end
+
+    def last_message
+      @last_message
+    end
+
+  end
+
+end

data/test/pubsub_test.rb

@@ -1,8 +1,10 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 
 class PubsubTest < Test::Unit::TestCase
+
   def setup
     $success = $lock_failed = $lock_expired = 0
+    Resque.redis.namespace = nil
     Resque.redis.flushall
     Resque.redis.namespace = 'test_pubsub'
   end
@@ -12,72 +14,63 @@ class PubsubTest < Test::Unit::TestCase
       Resque::Plugin.lint(Resque::Plugins::Pubsub)
     end
   end
-  
+
   def test_all
-    # Just loading the "TestSubscriber" class is enough to subscribe
-    require 'test_publisher'
-    require 'test_subscriber'
+    TestSubscriber.subscribe('test_topic')
     # Now process the subscription
     Resque.redis.namespace = 'resque:pubsub'
-    @worker = Resque::Worker.new(:subscription_requests)
-    @worker.process
+    Resque::Worker.new(:subscription_requests).process
     # Check that the subscription is in the subscribers list
-    assert check_subscription(Resque.redis.smembers("test_topic_subscribers"), "TestSubscriber", "test_pubsub")
+    assert subscription_exists(Resque.redis.smembers('test_topic_subscribers'), 'TestSubscriber', 'test_pubsub')
+  
     p = TestPublisher.new
-    p.publish("test_topic", "Test message")
+    p.publish('test_topic', 'Test message')
     # Run Resque for the broker
     Resque.redis.namespace = 'resque:pubsub'
-    @worker = Resque::Worker.new(:messages)
-    @worker.process
+    Resque::Worker.new(:messages).process
     # Check that the message queue has been populated
     Resque.redis.namespace = 'test_pubsub'
     assert Resque.redis.keys.include?('queue:fanout:test_topic')
-    assert Resque.redis.llen('queue:fanout:test_topic')==1
+    assert_equal 1, Resque.redis.llen('queue:fanout:test_topic')
+    
     # Now run the subscriber Resque
-    @worker = Resque::Worker.new('fanout:test_topic')
-    @worker.process
-    assert Resque.redis.llen('fanout:test_topic')==0
-    assert TestSubscriber.last_message=='Test message'
+    Resque::Worker.new('fanout:test_topic').process
+    assert_equal 0, Resque.redis.llen('queue:fanout:test_topic')
+    assert_equal 'Test message', TestSubscriber.last_message
   end
-  
+
   def test_configuration_options
-    # Configure the pubsub namespace
-    require 'resque-pubsub'
     Resque::Plugins::Pubsub::Exchange.pubsub_namespace = 'resque:custom_space'
-    puts "namespace is set to #{Resque::Plugins::Pubsub::Exchange.pubsub_namespace}"
-    require 'test_publisher'
-    require 'test_subscriber'
-    require 'test_subscriber_custom'
+    TestCustomSubscriber.subscribe('test_custom_topic', :reader_method => :simple)
     # Now process the subscription
     Resque.redis.namespace = 'resque:custom_space'
-    @worker = Resque::Worker.new(:subscription_requests)
-    @worker.process
+    Resque::Worker.new(:subscription_requests).process
     # Check that the subscription is in the subscribers list
-    assert check_subscription(Resque.redis.smembers("test_custom_topic_subscribers"), "TestSubscriberCustom", "test_pubsub")
-    p = TestPublisher.new
-    p.publish("test_custom_topic", "Test custom message")
+    assert subscription_exists(Resque.redis.smembers('test_custom_topic_subscribers'), 'TestCustomSubscriber', 'test_pubsub')
+    
+    TestPublisher.new.publish('test_custom_topic', 'Test custom message')
     # Run Resque for the broker
     Resque.redis.namespace = 'resque:custom_space'
-    @worker = Resque::Worker.new(:messages)
-    @worker.process
+    Resque::Worker.new(:messages).process
     # Check that the message queue has been populated
     Resque.redis.namespace = 'test_pubsub'
     assert Resque.redis.keys.include?('queue:fanout:test_custom_topic')
-    assert Resque.redis.llen('queue:fanout:test_custom_topic')==1
+    assert_equal 1, Resque.redis.llen('queue:fanout:test_custom_topic')
+    
     # Now run the subscriber Resque
-    @worker = Resque::Worker.new('fanout:test_custom_topic')
-    @worker.process
-    assert Resque.redis.llen('fanout:test_custom_topic')==0
-    assert TestSubscriberCustom.last_message=='Test custom message'
-    # Also make sure TestSubscriber DIDN'T get the message
-    assert TestSubscriber.last_message!='Test custom message'
+    Resque::Worker.new('fanout:test_custom_topic').process
+    assert_equal 0, Resque.redis.llen('queue:fanout:test_custom_topic')
+    assert_equal 'Test custom message', TestCustomSubscriber.last_message
+    assert_not_equal 'Test custom message', TestSubscriber.last_message
   end
+
+  private
   
-  def check_subscription(subscribers, klass, namespace)
-    subscribers.inject(false) {|result, s|
+  def subscription_exists(subscribers, klass, namespace)
+    subscribers.inject(false) do |result, s|
       sinfo = JSON.parse(s)
-      result = result || (sinfo["class"]==klass && sinfo['namespace']==namespace)
-    }
+      result = result || (sinfo['class'] == klass && sinfo['namespace'] == namespace)
+    end
   end
 
-end
+end

data/test/test_helper.rb

@@ -10,15 +10,13 @@ require 'active_support/test_case'
 
 require 'resque-pubsub'
 
-##
 # make sure we can run redis
-if !system("which redis-server")
+if !system('which redis-server')
   puts '', "** can't find `redis-server` in your path"
   puts "** try running `sudo rake install`"
   abort ''
 end
 
-##
 # start our own redis when the tests start,
 # kill it when they end
 at_exit do
@@ -31,12 +29,15 @@ at_exit do
   end
 
   pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
-  puts "Killing test redis server..."
+  puts 'Killing test redis server...'
   `rm -f #{dir}/dump.rdb`
-  Process.kill("KILL", pid.to_i)
+  Process.kill('KILL', pid.to_i)
   exit exit_code
 end
 
-puts "Starting redis for testing at localhost:9736..."
+puts 'Starting redis for testing at localhost:9736...'
 `redis-server #{dir}/redis-test.conf`
-Resque.redis = '127.0.0.1:9736'
+Resque.redis = '127.0.0.1:9736'
+Resque.redis.namespace = 'test_pubsub'
+
+Dir.glob(File.expand_path(dir + '/fixtures/*')).each { |filename| require filename }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: resque-pubsub
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Monica McArthur
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-08 00:00:00 -07:00
+date: 2011-04-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,7 +34,7 @@ dependencies:
         version: 1.9.10
   type: :runtime
   version_requirements: *id001
-description: "  A Resque plugin. Provides a lightweight publish/subscribe messaging system, with message persistence when clients are down.\n"
+description: "    A Resque plugin. Provides a lightweight publish/subscribe messaging system, with message persistence when clients are down.\n"
 email: mechaferret@gmail.com
 executables: []
 
@@ -53,13 +53,12 @@ files:
 - lib/resque/plugins/pubsub/publisher.rb
 - lib/resque/plugins/pubsub/subscriber.rb
 - lib/resque-pubsub.rb
-- test/debug.log
+- test/fixtures/test_custom_subscriber.rb
+- test/fixtures/test_publisher.rb
+- test/fixtures/test_subscriber.rb
 - test/pubsub_test.rb
 - test/redis-test.conf
 - test/test_helper.rb
-- test/test_publisher.rb
-- test/test_subscriber.rb
-- test/test_subscriber_custom.rb
 has_rdoc: true
 homepage: http://github.com/mechaferret/resque-pubsub
 licenses: []

data/test/debug.log

@@ -1,16 +0,0 @@
-# Logfile created on Thu Jan 20 18:20:02 -0800 2011 by logger.rb/22285
-  SQL (0.2ms)   SET SQL_AUTO_IS_NULL=0
-  SQL (0.3ms)   SHOW TABLES
-  SQL (430.6ms)   CREATE TABLE `transactionals` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY, `name` varchar(255), `description` varchar(255), `other_id` int(11)) ENGINE=InnoDB
-  SQL (0.4ms)   SHOW TABLES
-  SQL (114.4ms)   CREATE TABLE `transactional_facts` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY, `name` varchar(255), `description` varchar(255), `other_id` int(11)) ENGINE=InnoDB
-  SQL (0.4ms)   SHOW TABLES
-  SQL (102.1ms)   CREATE TABLE `schema_migrations` (`version` varchar(255) NOT NULL) ENGINE=InnoDB
-  SQL (172.5ms)   CREATE UNIQUE INDEX `unique_schema_migrations` ON `schema_migrations` (`version`)
-  SQL (0.4ms)   SHOW TABLES
-  SQL (0.1ms)   SELECT version FROM `schema_migrations`
-  SQL (0.4ms)   INSERT INTO `schema_migrations` (version) VALUES ('3')
-  Transactional Columns (38.0ms)   SHOW FIELDS FROM `transactionals`
-  SQL (0.3ms)   BEGIN
-  Transactional Create (0.3ms)   INSERT INTO `transactionals` (`name`, `other_id`, `description`) VALUES(NULL, NULL, NULL)
-  SQL (0.7ms)   COMMIT

data/test/test_publisher.rb

@@ -1,4 +0,0 @@
-class TestPublisher
-  require 'resque-pubsub'
-  
-end

data/test/test_subscriber.rb

@@ -1,17 +0,0 @@
-class TestSubscriber
-  require 'resque-pubsub'
-  
-  subscribe 'test_topic'
-  
-  @@last_message = nil
-  
-  def self.read_test_topic_message(message)
-    puts "got test topic message: #{message.inspect}"
-    @@last_message = message
-  end
-  
-  def self.last_message
-    @@last_message
-  end
-  
-end

data/test/test_subscriber_custom.rb

@@ -1,17 +0,0 @@
-class TestSubscriberCustom
-  require 'resque-pubsub'
-  
-  subscribe 'test_custom_topic', :reader_method => 'simple'
-  
-  @@last_message = nil
-  
-  def self.simple(message)
-    puts "in simple, got test custom topic message: #{message.inspect}"
-    @@last_message = message
-  end
-  
-  def self.last_message
-    @@last_message
-  end
-  
-end