sidekiq-bus 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c073296475ba07b08f7f92b019d091b38b4038e
-  data.tar.gz: cb95f95a5ec099cc471dcd8695cbf2ec478a9b6a
+  metadata.gz: d7fe08a16a8b8372bba7ddbfcfe8c59172d1f8d0
+  data.tar.gz: 73b19c7ef93c76e6fc35af205f9161a736177e44
 SHA512:
-  metadata.gz: 846ac47ae7600da4249d89e55e81e9e16f4de85e768697017f343b5f3952683232b29975055feddf2dcea83dc15a48e25c1e2f6d4ceee452b94f9bf32d4d590f
-  data.tar.gz: a5a9156736395bf84e9acbebbd533ce27a71436d74bc10923c893e06cf07c734e9756ddc2e42bfd64822823e322491a57b5cdb4facacbb71a7c09b17135f1715
+  metadata.gz: 672c3b9b603611b05d910fc913f4378d08995639e90706a15596fc509428bb631943341a5d3531b981ca698843c1d517166d65b1a948b87178c5973fb9d66f57
+  data.tar.gz: 83cb7199def75ffebf8d649dfea44b9773aa70c13999a078c361bebfa6e2a3368809dbe54cd878d15bd0f89fa98335d475353f98dfe1835edab6b54d11221522

data/.ruby-gemset

@@ -0,0 +1,2 @@
+sidekiq-bus
+

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/README.mdown

@@ -1,38 +1,40 @@
-## Resque Bus
+## Sidekiq Bus
 
-This gem uses Redis and Resque to allow simple asynchronous communication between apps.
+This gem provides an adapter for Sidekiq for use in the [queue-bus](https://github.com/queue-bus/queue-bus) system.
+It uses Redis and the Sidekiq that you are already using to allow simple asynchronous communication between apps.
 
 ### Install
 
-To install, include the 'resque-bus' gem and add the following to your Rakefile:
+To install, include the 'sidekiq-bus' gem and add the following to your Rakefile:
 
 ```ruby
 require "sidekiq_bus/tasks"
 ```
 
+
 ### Example
 
 Application A can publish an event
 
 ```ruby
-# config
-Resque.redis = "192.168.1.1:6379"
+# pick an adapter
+require 'sidekiq-bus' # (or other adapter)
 
 # business logic
-ResqueBus.publish("user_created", "id" => 42, "first_name" => "John", "last_name" => "Smith")
+QueueBus.publish("user_created", "id" => 42, "first_name" => "John", "last_name" => "Smith")
 
 # or do it later
-ResqueBus.publish_at(1.hour.from_now, "user_created", "id" => 42, "first_name" => "John", "last_name" => "Smith")
+QueueBus.publish_at(1.hour.from_now, "user_created", "id" => 42, "first_name" => "John", "last_name" => "Smith")
 ```
 
 Application B is subscribed to events
 
 ```ruby
-# config
-Resque.redis = "192.168.1.1:6379"
+# pick an adapter
+require 'sidekiq-bus' # (or other adapter)
 
 # initializer
-ResqueBus.dispatch("app_b") do
+QueueBus.dispatch("app_b") do
   # processes event on app_b_default queue
   # subscribe is short-hand to subscribe to your 'default' queue and this block with process events with the name "user_created"
   subscribe "user_created" do |attributes|
@@ -65,7 +67,7 @@ Applications can also subscribe within classes using the provided `Subscriber` m
 
 ```ruby
 class SimpleSubscriber
-  include ResqueBus::Subscriber
+  include QueueBus::Subscriber
   subscribe :my_method
 
   def my_method(attributes)
@@ -78,7 +80,7 @@ The following is equivalent to the original initializer and shows more options:
 
 ```ruby
 class OtherSubscriber
-  include ResqueBus::Subscriber
+  include QueueBus::Subscriber
   application :app_b
 
   subscribe :user_created
@@ -110,122 +112,11 @@ Note: This subscribes when this class is loaded, so it needs to be in your load
 
 Each app needs to tell Redis about its subscriptions:
 
-    $ rake resquebus:subscribe
-
-The subscription block is run inside a Resque worker which needs to be started for each app.
-
-    $ rake resquebus:setup resque:work
-
-The incoming queue also needs to be processed on a dedicated or all the app servers.
-
-    $ rake resquebus:driver resque:work
-
-If you want retry to work for subscribing apps, you should run resque-scheduler
-
-    $ rake resque:scheduler
-
-### Adapters
-
-ResqueBus now supports multiple adapters! By default ResqueBus uses Resque but you can now configure your application to use Sidekiq to drive and subscribe the bus.
-
-First be sure to configure ResqueBus to use Sidekiq early in your applications' initialization cycle:
-```
-ResqueBus.adapter = 'Sidekiq'
-```
-You will be responsible for setting up the queues for your Sidekiq clients however you can get the appropriate queue names with the following tasks:
-For driving applications:
-```
-$ rake resquebus:driver:sidekiq
-```
-For subscribing applications:
-```
-$ rake resquebus:setup:sidekiq
-```
-These tasks will provide the queue_names and some minimal suggestions for starting the client.
-
-Your subscribing applications will still need to also use the appropriate rake task:
-```
-$ rake resquebus:subscribe:sidekiq
-```
-
-At the moment you are expected to include the Sidekiq gem in your own applications.
-
-And yes we are planning on renaming and restructuring the project! Please contact the maintainer if you would like to add a different adapter.
+    $ rake queuebus:subscribe
 
-### Heartbeat
+You'll then need to run Sidekiq. Make sure the bus_incoming queues and the ones you are using are included.
 
-We've found it useful to have the bus act like `cron`, triggering timed jobs throughout the system. Resque Bus calls this a heartbeat.
-It uses resque-scheduler to trigger the events. You can enable it in your Rakefile.
-
-```ruby
-# resque.rake
-namespace :resque do
-  task :setup => [:environment] do
-    ResqueBus.heartbeat!
-  end
-end
-```
-
-Or add it to your `schedule.yml` directly
-
-```yaml
-resquebus_heartbeat:
-  cron: "* * * * *"
-  class: "::ResqueBus::Heartbeat"
-  queue: resquebus_incoming
-  description: "I publish a heartbeat_minutes event every minute"
-```
-
-It is the equivalent of doing this every minute
-
-```ruby
-seconds = minutes * (60)
-hours   = minutes / (60)
-days    = minutes / (60*24)
-
-now     = Time.at(seconds)
-
-attributes = {}
-
-now = Time.now
-seconds = now.to_i
-ResqueBus.publish("hearbeat_minutes", {
-  "epoch_seconds" => seconds,
-  "epoch_minutes" => seconds / 1.minute,
-  "epoch_hours"   => seconds / 1.hour,
-  "epoch_days"    => seconds / 1.day,
-  "minute"        => now.min
-  "hour"          => now.hour
-  "day"           => now.day
-  "month"         => now.month
-  "year"          => now.year
-  "yday"          => now.yday
-  "wday"          => now.wday
-})
-```
-
-This allows you do something like this:
-
-```ruby
-ResqueBus.dispatch("app_c") do
-  # runs at 10:20, 11:20, etc
-  subscribe "once_an_hour", 'bus_event_type' => 'heartbeat_minutes', 'minute' => 20 do |attributes|
-    Sitemap.generate!
-  end
-
-  # runs every five minutes
-  subscribe "every_five_minutes", 'bus_event_type' => 'heartbeat_minutes' do |attributes|
-    next unless attributes["epoch_minutes"] % 5 == 0
-    HealthCheck.run!
-  end
-
-  # runs at 8am on the first of every month
-  subscribe "new_month_morning", 'bus_event_type' => 'heartbeat_minutes', 'day' => 1, hour' => 8, 'minute' => 0,  do |attributes|
-    next unless attributes["epoch_minutes"] % 5 == 0
-    Token.old.expire!
-  end
-end
-```
+    $ bundle exec sidekiq -q default -q app_b_default -q bus_incoming
 
 ### Local Mode
 
@@ -233,32 +124,24 @@ For development, a local mode is provided and is specified in the configuration.
 
 ```ruby
 # config
-ResqueBus.local_mode = :standalone
+QueueBus.local_mode = :standalone
 or
-ResqueBus.local_mode = :inline
+QueueBus.local_mode = :inline
 ```
 
-Standalone mode does not require a separate resquebus:driver task to be running to process the
+Standalone mode does not require a separate queuebus:driver task to be running to process the
 incoming queue. Simply publishing to the bus will distribute the incoming events
-to the appropriate application specific queue.  A separate resquebus:work task does
+to the appropriate application specific queue.  A separate queuebus:work task does
 still need to be run to process these events
 
 Inline mode skips queue processing entirely and directly dispatches the
 event to the appropriate code block.
 
-You can also say `ResqueBus.local_mode = :suppress` to turn off publishing altogether.
+You can also say `QueueBus.local_mode = :suppress` to turn off publishing altogether.
 This can be helpful inside some sort of migration, for example.
 
 ### TODO
 
-* Sidekiq adapter
-* Refactor rake tasks for resque/sidekiq
-* Refactor to a storage adapter for Redis, so we can store subscription info in MySQL or something else
 * Replace local modes with adapters
-* There are a few spots in the code with TODO notes
-* Make this not freak out in development without Redis or when Redis is down
 * We might not actually need to publish in tests
 * Add some rspec helpers for the apps to use: should_ post an event_publish or something along those lines
-* Allow calling resquebus:setup and resquebus:driver together (append to ENV['QUEUES'], don't replace it)
-
-Copyright (c) 2011 Brian Leonard, released under the MIT license

data/lib/sidekiq-bus.rb

@@ -2,8 +2,4 @@ require "queue-bus"
 require "sidekiq_bus/adapter"
 require "sidekiq_bus/version"
 
-module ResqueBus
-
-end
-
 QueueBus.adapter = QueueBus::Adapters::Sidekiq.new

data/lib/sidekiq_bus/tasks.rb

@@ -1,93 +1,13 @@
 # require 'sidekiq_bus/tasks'
 # will give you these tasks
 
+require "queue_bus/tasks"
 
-require "resque/tasks"
-namespace :sidekiqbus do
-
-  desc "Setup will configure a resque task to run before resque:work"
-  task :setup => [ :preload ] do
-
-    if ENV['QUEUES'].nil?
-      manager = ::QueueBus::TaskManager.new(true)
-      queues = manager.queue_names
-      ENV['QUEUES'] = queues.join(",")
-    else
-      queues = ENV['QUEUES'].split(",")
-    end
-
-    if queues.size == 1
-      puts "  >>  Working Queue : #{queues.first}"
-    else
-      puts "  >>  Working Queues: #{queues.join(", ")}"
-    end
-  end
-
-  desc "Subscribes this application to QueueBus events"
-  task :subscribe => [ :preload ] do
-    manager = ::QueueBus::TaskManager.new(true)
-    count = manager.subscribe!
-    raise "No subscriptions created" if count == 0
-  end
-
-  desc "Unsubscribes this application from QueueBus events"
-  task :unsubscribe => [ :preload ] do
-    require 'resque-bus'
-    manager = ::QueueBus::TaskManager.new(true)
-    count = manager.unsubscribe!
-    puts "No subscriptions unsubscribed" if count == 0
-  end
-
-  desc "Sets the queue to work the driver  Use: `rake sidekiqbus:driver resque:work`"
-  task :driver => [ :preload ] do
-    ENV['QUEUES'] = ::QueueBus.incoming_queue
-  end
+namespace :queuebus do
 
   # Preload app files if this is Rails
   task :preload do
     require "sidekiq"
   end
 
-
-  # examples to test out the system
-  namespace :example do
-    desc "Publishes events to example applications"
-    task :publish => [ "sidekiqbus:preload", "sidekiqbus:setup" ] do
-      which = ["one", "two", "three", "other"][rand(4)]
-      QueueBus.publish("event_#{which}", { "rand" => rand(99999)})
-      QueueBus.publish("event_all", { "rand" => rand(99999)})
-      QueueBus.publish("none_subscribed", { "rand" => rand(99999)})
-      puts "published event_#{which}, event_all, none_subscribed"
-    end
-
-    desc "Sets up an example config"
-    task :register => [ "sidekiqbus:preload"] do
-      QueueBus.dispatch("example") do
-        subscribe "event_one" do
-          puts "event1 happened"
-        end
-
-        subscribe "event_two" do
-          puts "event2 happened"
-        end
-
-        high "event_three" do
-          puts "event3 happened (high)"
-        end
-
-        low "event_.*" do |attributes|
-          puts "LOG ALL: #{attributes.inspect}"
-        end
-      end
-    end
-
-    desc "Subscribes this application to QueueBus example events"
-    task :subscribe => [ :register, "sidekiqbus:subscribe" ]
-
-    desc "Start a QueueBus example worker"
-    task :work => [ :register, "sidekiqbus:setup", "resque:work" ]
-
-    desc "Start a QueueBus example worker"
-    task :driver => [ :register, "sidekiqbus:driver", "resque:work" ]
-  end
 end

data/lib/sidekiq_bus/version.rb

@@ -1,3 +1,3 @@
 module SidekiqBus
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

data/sidekiq-bus.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Brian Leonard"]
   s.email       = ["brian@bleonard.com"]
   s.homepage    = "https://github.com/queue-bus/sidekiq-bus"
-  s.summary     = %q{A simple event bus on top of Resque}
-  s.description = %q{A simple event bus on top of Resque. Publish and subscribe to events as they occur through a queue.}
+  s.summary     = %q{A simple event bus on top of Sidekiq}
+  s.description = %q{A simple event bus on top of Sidekiq. Publish and subscribe to events as they occur through a queue.}
 
   s.rubyforge_project = "sidekiq-bus"
 
@@ -18,10 +18,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency('queue-bus', '0.5.2')
+  s.add_dependency('queue-bus', '0.5.4')
   s.add_dependency('sidekiq', ['>= 3.0.0', '< 4.0'])
 
   s.add_development_dependency("rspec")
+  s.add_development_dependency("fakeredis")
+  s.add_development_dependency("redis-namespace")
+  s.add_development_dependency("pry")
   s.add_development_dependency("timecop")
   s.add_development_dependency("json_pure")
 end

data/spec/adapter/integration_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'celluloid'
+require 'sidekiq/scheduled'
+
+describe "Sidekiq Integration" do
+  describe "Happy Path" do
+    before(:each) do
+      Sidekiq::Testing.fake!
+      QueueBus.dispatch("r1") do
+        subscribe "event_name" do |attributes|
+          QueueBus::Runner1.run(attributes)
+        end
+      end
+
+      QueueBus::TaskManager.new(false).subscribe!
+    end
+
+    it "should publish and receive" do
+      Sidekiq::Testing.fake!
+      QueueBus::Runner1.value.should == 0
+
+      QueueBus.publish("event_name", "ok" => true)
+      QueueBus::Runner1.value.should == 0
+
+      QueueBus::Worker.perform_one
+
+      QueueBus::Runner1.value.should == 0
+
+      QueueBus::Worker.perform_one
+
+      QueueBus::Runner1.value.should == 1
+    end
+
+    it "should publish and receive" do
+      Sidekiq::Testing.inline!
+      QueueBus::Runner1.value.should == 0
+
+      QueueBus.publish("event_name", "ok" => true)
+      QueueBus::Runner1.value.should == 1
+    end
+
+  end
+
+  describe "Delayed Publishing" do
+    before(:each) do
+      Timecop.freeze(now)
+      QueueBus.stub(:generate_uuid).and_return("idfhlkj")
+    end
+    after(:each) do
+      Timecop.return
+    end
+    let(:delayed_attrs) { {"bus_delayed_until" => future.to_i,
+                       "bus_id" => "#{now.to_i}-idfhlkj",
+                       "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+
+    let(:bus_attrs) { delayed_attrs.merge({"bus_published_at" => worktime.to_i})}
+    let(:now)    { Time.parse("01/01/2013 5:00")}
+    let(:future) { Time.at(now.to_i + 60) }
+    let(:worktime) {Time.at(future.to_i + 1)}
+
+    it "should add it to Redis" do
+      hash = {:one => 1, "two" => "here", "id" => 12 }
+      event_name = "event_name"
+      QueueBus.publish_at(future, event_name, hash)
+
+      val = QueueBus.redis { |redis| redis.zrange("schedule", 0, 1) }.first
+
+      hash = JSON.parse(val)
+
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
+      hash["queue"].should == "bus_incoming"
+    end
+
+    it "should move it to the real queue when processing" do
+      hash = {:one => 1, "two" => "here", "id" => 12 }
+      event_name = "event_name"
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil
+
+      QueueBus.publish_at(future, event_name, hash)
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil # nothing really added
+
+      Sidekiq::Scheduled::Poller.new.poll
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil # nothing added yet
+
+      # process scheduler in future
+      Timecop.freeze(worktime) do
+        Sidekiq::Scheduled::Poller.new.poll
+        val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+        hash = JSON.parse(val)
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
+
+       QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
+
+       val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+       hash = JSON.parse(val)
+       hash["class"].should == "QueueBus::Worker"
+       hash["args"].size.should == 1
+       JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Driver", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs)
+      end
+    end
+
+  end
+end

data/spec/driver_spec.rb

@@ -35,7 +35,7 @@ module QueueBus
     end
 
     describe ".perform" do
-      let(:attributes) { {"x" => "y", "bus_class_proxy" => "ResqueBus::Driver"} }
+      let(:attributes) { {"x" => "y"} }
 
       before(:each) do
         QueueBus.redis { |redis| redis.smembers("queues") }.should == []

data/spec/spec_helper.rb

@@ -1,9 +1,15 @@
 require 'timecop'
 require 'queue-bus'
 require 'adapter/support'
+require 'pry'
 
 reset_test_adapter
 
+require 'fakeredis'
+Sidekiq.redis = ConnectionPool.new { Redis.new(driver: Redis::Connection::Memory) }
+
+require 'sidekiq/testing'
+
 module QueueBus
   class Runner
     def self.value
@@ -47,6 +53,11 @@ def test_list(*args)
 end
 
 RSpec.configure do |config|
+
+  config.run_all_when_everything_filtered = true
+  config.filter_run focus: true
+  config.alias_example_to :fit, focus: true
+
   config.mock_with :rspec do |c|
     c.syntax = :should
   end
@@ -56,6 +67,7 @@ RSpec.configure do |config|
 
   config.before(:each) do
     reset_test_adapter
+    Sidekiq::Testing.disable!
   end
   config.after(:each) do
     begin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-bus
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Brian Leonard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-21 00:00:00.000000000 Z
+date: 2015-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: queue-bus
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.5.4
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +58,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -86,7 +128,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A simple event bus on top of Resque. Publish and subscribe to events
+description: A simple event bus on top of Sidekiq. Publish and subscribe to events
   as they occur through a queue.
 email:
 - brian@bleonard.com
@@ -97,6 +139,8 @@ files:
 - ".gitignore"
 - ".rbenv-version"
 - ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
 - Gemfile
 - MIT-LICENSE
 - README.mdown
@@ -106,6 +150,7 @@ files:
 - lib/sidekiq_bus/tasks.rb
 - lib/sidekiq_bus/version.rb
 - sidekiq-bus.gemspec
+- spec/adapter/integration_spec.rb
 - spec/adapter/support.rb
 - spec/adapter_spec.rb
 - spec/application_spec.rb
@@ -145,8 +190,9 @@ rubyforge_project: sidekiq-bus
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: A simple event bus on top of Resque
+summary: A simple event bus on top of Sidekiq
 test_files:
+- spec/adapter/integration_spec.rb
 - spec/adapter/support.rb
 - spec/adapter_spec.rb
 - spec/application_spec.rb