resque-bus 0.2.3

data/lib/resque_bus/matcher.rb

@@ -0,0 +1,81 @@
+module ResqueBus
+  class Matcher
+    SPECIAL_PREPEND = "bus_special_value_"
+    attr_reader :filters
+    def initialize(hash)
+      @filters = encode(hash)
+    end
+    
+    def to_redis
+      @filters
+    end
+    
+    def match?(attribute_name, attributes)
+      mine = filters[attribute_name].to_s
+      return false if mine.size == 0
+      
+      given = attributes[attribute_name]
+      case mine
+      when "#{SPECIAL_PREPEND}key"
+        return true if attributes.has_key?(attribute_name)
+        return false
+      when "#{SPECIAL_PREPEND}blank"
+        return true if given.to_s.strip.size == 0
+        return false
+      when "#{SPECIAL_PREPEND}empty"
+        return false if given == nil
+        return true if given.to_s.size == 0
+        return false
+      when "#{SPECIAL_PREPEND}nil"
+        return true if given == nil
+        return false
+      when "#{SPECIAL_PREPEND}value"
+        return false if given == nil
+        return true
+      when "#{SPECIAL_PREPEND}present"
+        return true if given.to_s.strip.size > 0
+        return false
+      end
+      
+      given = given.to_s
+      
+      return true if mine == given
+      begin
+        # if it's already a regex, don't mess with it
+        # otherwise, it should have start and end line situation
+        if mine[0..6] == "(?-mix:"
+          regex = Regexp.new(mine)
+        else
+          regex = Regexp.new("^#{mine}$")
+        end
+        return !!regex.match(given)
+      rescue
+        return false
+      end
+    end
+    
+    def matches?(attributes)
+      return false if filters.empty?
+      return false if attributes == nil
+      
+      filters.keys.each do |key|
+        return false unless match?(key, attributes)
+      end
+      
+      true
+    end
+    
+    def encode(hash)
+      out = {}
+      hash.each do |key, value|
+        case value
+        when :key, :blank, :nil, :present, :empty, :value
+          value = "#{SPECIAL_PREPEND}#{value}"
+        end
+        out[key.to_s] = value.to_s
+      end      
+      out
+    end
+  end
+end
+

data/lib/resque_bus/publisher.rb

@@ -0,0 +1,9 @@
+module ResqueBus
+  # publishes on a delay
+  class Publisher
+    def self.perform(event_type, attributes = {})
+      ResqueBus.log_worker("Publisher running: #{event_type} - #{attributes.inspect}")
+      ResqueBus.publish(event_type, attributes)
+    end
+  end
+end

data/lib/resque_bus/rider.rb

@@ -0,0 +1,52 @@
+require 'resque-retry'
+
+module ResqueBus
+  # queue'd in each
+  class Rider
+    extend Resque::Plugins::ExponentialBackoff
+    
+    def self.perform(attributes = {})
+      sub_key = attributes["bus_rider_sub_key"]
+      app_key = attributes["bus_rider_app_key"]
+      raise "No application key passed" if app_key.to_s == ""
+      raise "No subcription key passed" if sub_key.to_s == ""
+      
+      attributes ||= {}
+      
+      ResqueBus.log_worker("Rider received: #{app_key} #{sub_key} #{attributes.inspect}")
+      
+      # attributes that should be available
+      # attributes["bus_event_type"]
+      # attributes["bus_app_key"]
+      # attributes["bus_published_at"]
+      # attributes["bus_driven_at"]
+      
+      # allow the real Reqsue to be used inside the callback while in a worker
+      Resque.redis = ResqueBus.original_redis if ResqueBus.original_redis
+      
+      # (now running with the real app that subscribed)
+      ResqueBus.dispatcher_execute(app_key, sub_key, attributes.merge("bus_executed_at" => Time.now.to_i))
+    ensure
+      # put this back if running in the thread
+      Resque.redis = ResqueBus.redis if ResqueBus.original_redis
+    end
+    
+    # @failure_hooks_already_ran on https://github.com/defunkt/resque/tree/1-x-stable
+    # to prevent running twice
+    def self.queue
+      @my_queue
+    end
+    
+    def self.on_failure_aaa(exception, *args)
+      # note: sorted alphabetically
+      # queue needs to be set for rety to work (know what queue in Requeue.class_to_queue)
+      @my_queue = args[0]["bus_rider_queue"]
+    end
+    
+    def self.on_failure_zzz(exception, *args)
+      # note: sorted alphabetically
+      @my_queue = nil
+    end
+    
+  end
+end

data/lib/resque_bus/server/views/bus.erb

@@ -0,0 +1,101 @@
+
+<script LANGUAGE="JavaScript">
+<!--
+function confirmSubmit()
+{
+var agree=confirm("Are you sure you wish to continue?");
+if (agree)
+	return true ;
+else
+	return false ;
+}
+// -->
+</script>
+
+<%
+  app_hash = {}
+  event_hash = {}
+  
+  # collect each differently
+  ResqueBus::Application.all.each do |app|
+    app_key = app.app_key
+    
+    app_hash[app_key] ||= []
+    app.event_display_tuples.each do |tuple|
+      event, queue = tuple
+      app_hash[app_key] << [event, queue]
+      
+      event_hash[event] ||= []
+      event_hash[event] << [app_key, queue]
+    end
+  end
+  
+  # sort each list item by secondary label
+  event_hash.each do |_, array|
+    array.sort!{ |a,b| a.first <=> b.first }
+  end
+  event_hash.each do |_, array|
+    array.sort!{ |a,b| a.first <=> b.first }
+  end
+  
+  # helper to display either
+  def display_row(name, val, button=nil, first=false)
+    form = ""
+    if button
+      text, url = button
+      form = "<form method='POST' action='#{u url}' style='float:left; padding:0 5px 0 0;margin:0;'><input type='submit' name='' value='#{text}' style='padding:0;margin:0;' onclick=\"return confirmSubmit();\"/><input type='hidden' name='name' value='#{h(name)}' /></form>"
+    end
+    
+    if !val
+      out = "<td>&nbsp;</td><td>&nbsp;</td>"
+    else
+      detail, queue = val
+      out = "<td>#{h(detail)}</td><td><a href='#{u("queues/#{queue}")}'>#{h(queue)}</a></td>"
+    end
+    
+    if first
+      "<tr><td>#{h(name)}#{form}</td>#{out}</tr>\n"
+    else
+      "<tr><td>&nbsp;</td>#{out}</tr>\n"
+    end
+  end
+  
+  def output_hash(hash, action=nil)
+    out = ""
+    hash.keys.sort.each do |item|
+      display = hash[item]
+      first = display.shift
+      out << display_row(item, first, action, true)
+      display.each do |val|
+        out << display_row(item, val, action)
+      end
+    end
+    out
+  end
+%>
+
+
+
+<h1 class='wi'>Applications</h1>
+<p class='intro'>The apps below have registered the given event types and queues.</p>
+<table class='queues'>
+  <tr>
+    <th>App Key</th>
+    <th>Event Type</th>
+    <th>Queue</th>
+  </tr>
+  <%= output_hash(app_hash, ["Unsubscribe", "bus/unsubscribe"]) %>
+</table>
+
+<p>&nbsp;</p>
+  
+<h1 class='wi'>Events</h1>
+<p class='intro'>The event types below have been registered by the given applications and queues.</p>
+<table class='queues'>
+  <tr>
+    <th>Event Type</th>
+    <th>App Key</th>
+    <th>Queue</th>
+  </tr>
+  <%= output_hash(event_hash, false) %>
+</table>

data/lib/resque_bus/server.rb

@@ -0,0 +1,29 @@
+require 'resque-bus'
+require 'resque/server'
+
+# Extend Resque::Server to add tabs.
+module ResqueBus
+  module Server
+
+    def self.included(base)
+      base.class_eval {
+
+        get "/bus" do
+          erb File.read(File.join(File.dirname(__FILE__), "server/views/bus.erb"))
+        end
+        
+        
+        post '/bus/unsubscribe' do
+          app = Application.new(params[:name]).unsubscribe
+          redirect u('bus')
+        end
+        
+      }
+    end
+  end
+end
+
+Resque::Server.tabs << 'Bus'
+Resque::Server.class_eval do
+  include ResqueBus::Server
+end

data/lib/resque_bus/subscriber.rb

@@ -0,0 +1,60 @@
+module ResqueBus
+  module Subscriber
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+
+      def application(app_key)
+        @app_key = ::ResqueBus::Application.normalize(app_key)
+      end
+      
+      def app_key
+        return @app_key if @app_key
+        @app_key = ::ResqueBus.default_app_key
+        return @app_key if @app_key
+        # module or class_name
+        val = self.name.to_s.split("::").first
+        @app_key = ::ResqueBus::Util.underscore(val)
+      end
+      
+      def subscribe(method_name, matcher_hash = nil)
+        queue_name   = ::Resque.queue_from_class(self)
+        queue_name ||= ::ResqueBus.default_queue
+        queue_name ||= "#{app_key}_default"
+        subscribe_queue(queue_name, method_name, matcher_hash)
+      end
+      
+      def subscribe_queue(queue_name, method_name, matcher_hash = nil)
+        klass = self
+        matcher_hash ||= {"bus_event_type" => method_name}
+        sub_key = "#{self.name}.#{method_name}"
+        dispatcher = ::ResqueBus.dispatcher_by_key(app_key)
+        dispatcher.add_subscription(queue_name, sub_key, klass.name.to_s, matcher_hash, lambda{ |att| klass.perform(att) })
+      end
+      
+      def transform(method_name)
+        @transform = method_name
+      end
+      def perform(attributes)
+        sub_key = attributes["bus_rider_sub_key"]
+        meth_key = sub_key.split(".").last
+        resque_bus_execute(meth_key, attributes)
+      end
+      
+      def resque_bus_execute(key, attributes)
+        args = attributes
+        args = send(@transform, attributes) if @transform
+        args = [args] unless args.is_a?(Array)
+        if self.respond_to?(:subscriber_with_attributes)
+          me = self.subscriber_with_attributes(attributes)
+        else
+          me = self.new
+        end
+        me.send(key, *args)
+      end
+    end
+  end
+end

data/lib/resque_bus/subscription.rb

@@ -0,0 +1,50 @@
+module ResqueBus
+  class Subscription
+    def self.register(queue, key, class_name, matcher, block)
+      Subscription.new(queue, key, class_name, matcher, block)
+    end
+    
+    def self.from_redis(hash)
+      queue_name = hash["queue_name"].to_s
+      key        = hash["key"].to_s
+      class_name = hash["class"].to_s
+      matcher    = hash["matcher"]
+      return nil if key.length == 0 || queue_name.length == 0
+      Subscription.new(queue_name, key, class_name, matcher, nil)
+    end
+    
+    def to_redis
+      out = {}
+      out["queue_name"] = queue_name
+      out["key"]        = key
+      out["class"]      = class_name
+      out["matcher"]    = matcher.to_redis
+      out
+    end
+
+    attr_reader :matcher, :executor, :queue_name, :key, :class_name
+    attr_accessor :app_key  # dyanmically set on return from subscription_matches
+    def initialize(queue_name, key, class_name, filters, executor=nil)
+      @queue_name = self.class.normalize(queue_name)
+      @key        = key.to_s
+      @class_name = class_name.to_s
+      @matcher    = Matcher.new(filters)
+      @executor   = executor
+    end
+    
+    def execute!(attributes)
+      attributes = attributes.with_indifferent_access if attributes.respond_to?(:with_indifferent_access)
+      executor.call(attributes)
+    end
+    
+    def matches?(attributes)
+      @matcher.matches?(attributes)
+    end
+    
+    protected
+    
+    def self.normalize(val)
+      val.to_s.gsub(/\W/, "_").downcase
+    end
+  end
+end

data/lib/resque_bus/subscription_list.rb

@@ -0,0 +1,49 @@
+module ResqueBus
+  class SubscriptionList
+    def self.from_redis(redis_hash)
+      out = SubscriptionList.new
+      
+      redis_hash.each do |key, value|
+        sub = Subscription.from_redis(value)
+        out.add(sub) if sub
+      end
+      out
+    end
+    
+    def to_redis
+      out = {}
+      @subscriptions.values.each do |sub|
+        out[sub.key] = sub.to_redis
+      end
+      out
+    end
+    
+    def initialize
+      @subscriptions = {}
+    end
+    
+    def add(sub)
+      @subscriptions[sub.key] = sub
+    end
+    
+    def size
+      @subscriptions.size
+    end
+    
+    def key(key)
+      @subscriptions[key.to_s]
+    end
+    
+    def all
+      @subscriptions.values
+    end
+    
+    def matches(attributes)
+      out = []
+      all.each do |sub|
+        out << sub if sub.matches?(attributes)
+      end
+      out
+    end
+  end
+end

data/lib/resque_bus/task_manager.rb

@@ -0,0 +1,50 @@
+module ResqueBus
+  class TaskManager
+    attr_reader :logging
+    def initialize(logging)
+      @logging = logging
+    end
+    
+    def subscribe!
+      count = 0
+      ResqueBus.dispatchers.each do |dispatcher|
+        subscriptions = dispatcher.subscriptions
+        if subscriptions.size > 0
+          count += subscriptions.size
+          log "Subscribing #{dispatcher.app_key} to #{subscriptions.size} subscriptions"
+          app = ResqueBus::Application.new(dispatcher.app_key)
+          app.subscribe(subscriptions, logging)
+          log "  ...done"
+        end
+      end
+      count
+    end
+    
+    def unsubscribe!
+      count = 0
+      ResqueBus.dispatchers.each do |dispatcher|
+        log "Unsubcribing from #{dispatcher.app_key}"
+        app = ResqueBus::Application.new(dispatcher.app_key)
+        app.unsubscribe
+        count += 1
+        log "  ...done"
+      end
+    end
+    
+    def queue_names
+      # let's not talk to redis in here. Seems to screw things up
+      queues = []
+      ResqueBus.dispatchers.each do |dispatcher|
+        dispatcher.subscriptions.all.each do |sub|
+          queues << sub.queue_name
+        end
+      end
+      
+      queues.uniq
+    end
+    
+    def log(message)
+      puts(message) if logging
+    end
+  end
+end

data/lib/resque_bus/tasks.rb

@@ -0,0 +1,105 @@
+# require 'resquebus/tasks'
+# will give you the resquebus tasks
+
+
+require "resque/tasks"
+namespace :resquebus do
+
+  desc "Setup will configure a resque task to run before resque:work"
+  task :setup => [ :preload ] do
+    
+    if ENV['QUEUES'].nil?
+      manager = ::ResqueBus::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 ResqueBus events"
+  task :subscribe => [ :preload ] do
+    manager = ::ResqueBus::TaskManager.new(true)
+    count = manager.subscribe!
+    raise "No subscriptions created" if count == 0
+  end
+  
+  desc "Unsubscribes this application from ResqueBus events"
+  task :unsubscribe => [ :preload ] do
+    require 'resque-bus'
+    manager = ::ResqueBus::TaskManager.new(true)
+    count = manager.unsubscribe!
+    puts "No subscriptions unsubscribed" if count == 0
+  end
+  
+  desc "Sets the queue to work the driver  Use: `rake resquebus:driver resque:work`"
+  task :driver => [ :preload ] do
+    ENV['QUEUES'] = "resquebus_incoming"
+  end
+
+  # Preload app files if this is Rails
+  task :preload do
+    require "resque"
+    require "resque-bus"
+    require "resque/failure/redis"
+
+    # change the namespace to be the ones used by ResqueBus
+    # save the old one for handling later
+    ResqueBus.original_redis = Resque.redis
+    Resque.redis = ResqueBus.redis
+    
+    Resque::Failure::MultipleWithRetrySuppression.classes = [Resque::Failure::Redis]
+    Resque::Failure.backend = Resque::Failure::MultipleWithRetrySuppression
+    
+    Rake::Task["resque:setup"].invoke # loads the environment and such if defined
+  end
+  
+  
+  # examples to test out the system
+  namespace :example do
+    desc "Publishes events to example applications"
+    task :publish => [ "resquebus:preload", "resquebus:setup" ] do
+      which = ["one", "two", "three", "other"][rand(4)]
+      ResqueBus.publish("event_#{which}", { "rand" => rand(99999)})
+      ResqueBus.publish("event_all", { "rand" => rand(99999)})
+      ResqueBus.publish("none_subscribed", { "rand" => rand(99999)})
+      puts "published event_#{which}, event_all, none_subscribed"
+    end
+    
+    desc "Sets up an example config"
+    task :register => [ "resquebus:preload"] do      
+      ResqueBus.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 ResqueBus example events"
+    task :subscribe => [ :register, "resquebus:subscribe" ]
+    
+    desc "Start a ResqueBus example worker"
+    task :work => [ :register, "resquebus:setup", "resque:work" ]
+    
+    desc "Start a ResqueBus example worker"
+    task :driver => [ :register, "resquebus:driver", "resque:work" ]
+  end
+end

data/lib/resque_bus/util.rb

@@ -0,0 +1,42 @@
+module ResqueBus
+  module Util
+    extend self
+    
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!('::', '/')
+      # word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+    
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check it it's owned
+          # directly before we reach Object or the end of ancestors.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+  end
+end

data/lib/resque_bus/version.rb

@@ -0,0 +1,5 @@
+module Resque
+  module Bus
+    VERSION = "0.2.3"
+  end
+end

data/lib/tasks/resquebus.rake

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+require 'resque_bus/tasks'

data/resque-bus.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "resque_bus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "resque-bus"
+  s.version     = Resque::Bus::VERSION
+  s.authors     = ["Brian Leonard"]
+  s.email       = ["brian@bleonard.com"]
+  s.homepage    = ""
+  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.rubyforge_project = "resque-bus"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.add_dependency('resque', ['>= 1.10.0', '< 2.0'])
+  s.add_dependency('resque-scheduler', '>= 2.0.1')
+  s.add_dependency('resque-retry')
+  s.add_dependency("redis-namespace")
+  s.add_dependency("redis")
+  
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("timecop")
+  s.add_development_dependency("json_pure")
+end