resque-bus 0.3.2 → 0.7.0

data/lib/resque_bus/dispatch.rb

@@ -1,61 +0,0 @@
-# Creates a DSL for apps to define their blocks to run for event_types
-
-module ResqueBus
-  class Dispatch
-
-    attr_reader :app_key, :subscriptions
-    
-    def initialize(app_key)
-      @app_key = Application.normalize(app_key)
-      @subscriptions = SubscriptionList.new
-    end
-    
-    def size
-      @subscriptions.size
-    end
-    
-    def subscribe(key, matcher_hash = nil, &block)
-      dispatch_event("default", key, matcher_hash, block)
-    end
-    
-    # allows definitions of other queues
-    def method_missing(method_name, *args, &block)
-      if args.size == 1 && block
-        dispatch_event(method_name, args[0], nil, block)
-      elsif args.size == 2 && block
-        dispatch_event(method_name, args[0], args[1], block)
-      else
-        super
-      end
-    end
-    
-    def execute(key, attributes)
-      sub = subscriptions.key(key)
-      if sub
-        sub.execute!(attributes)
-      else
-        # TODO: log that it's not there
-      end
-    end
-
-    def subscription_matches(attributes)
-      out = subscriptions.matches(attributes)
-      out.each do |sub|
-        sub.app_key = self.app_key
-      end
-      out
-    end
-    
-    def dispatch_event(queue, key, matcher_hash, block)
-      # if not matcher_hash, assume key is a event_type regex
-      matcher_hash ||= { "bus_event_type" => key }
-      add_subscription("#{app_key}_#{queue}", key, "::ResqueBus::Rider", matcher_hash, block)
-    end
-    
-    def add_subscription(queue_name, key, class_name, matcher_hash = nil, block)
-      sub = Subscription.register(queue_name, key, class_name, matcher_hash, block)
-      subscriptions.add(sub)
-      sub
-    end
-  end
-end

data/lib/resque_bus/driver.rb

@@ -1,30 +0,0 @@
-module ResqueBus
-  # fans out an event to multiple queues
-  class Driver
-
-    class << self
-      def subscription_matches(attributes)
-        out = []
-        Application.all.each do |app|
-          subs = app.subscription_matches(attributes)
-          out.concat(subs)
-        end
-        out
-      end
-
-      def perform(attributes={})
-        raise "No attributes passed" if attributes.empty?
-
-        ResqueBus.log_worker("Driver running: #{attributes.inspect}")
-
-        subscription_matches(attributes).each do |sub|
-          ResqueBus.log_worker("  ...sending to #{sub.queue_name} queue with class #{sub.class_name} for app #{sub.app_key} because of subscription: #{sub.key}")
-          
-          bus_attr = {"bus_driven_at" => Time.now.to_i, "bus_rider_queue" => sub.queue_name, "bus_rider_app_key" => sub.app_key, "bus_rider_sub_key" => sub.key, "bus_rider_class_name" => sub.class_name}
-          ResqueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
-        end
-      end
-    end
-
-  end
-end

data/lib/resque_bus/heartbeat.rb

@@ -1,106 +0,0 @@
-module ResqueBus
-  # publishes event about the current time
-  class Heartbeat
-
-    class << self
-      
-      def lock_key
-        "resquebus:heartbeat:lock"
-      end
-      
-      def lock_seconds
-        60
-      end
-      
-      def lock!
-        now = Time.now.to_i
-        timeout = now + lock_seconds + 2
-
-        # return true if we successfully acquired the lock
-        return timeout if Resque.redis.setnx(lock_key, timeout)
-
-        # see if the existing timeout is still valid and return false if it is
-        # (we cannot acquire the lock during the timeout period)
-        return 0 if now <= Resque.redis.get(lock_key).to_i
-
-        # otherwise set the timeout and ensure that no other worker has
-        # acquired the lock
-        if now > Resque.redis.getset(lock_key, timeout).to_i
-          return timeout
-        else
-          return 0
-        end
-      end
-      
-      def unlock!
-        Resque.redis.del(lock_key)
-      end
-      
-      
-      def redis_key
-        "resquebus:heartbeat:timestamp"
-      end
-
-      def environment_name
-        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["RESQUEBUS_ENV"]
-      end
-      
-      def get_saved_minute!
-        key = ResqueBus.redis.get(redis_key)
-        return nil if key.nil?
-        case environment_name
-        when 'development', 'test'
-          # only 3 minutes in development; otherwise, TONS of events if not run in a while
-          three_ago = Time.now.to_i - 3*60*60
-          key = three_ago if key.to_i < three_ago
-        end
-        return key.to_i
-      end
-
-      def set_saved_minute!(epoch_minute)
-        ResqueBus.redis.set(redis_key, epoch_minute)
-      end
-      
-      def perform
-        real_now = Time.now.to_i
-        run_until = lock! - 2
-        return if run_until < real_now
-        
-        while((real_now = Time.now.to_i) < run_until)
-          minutes = real_now.to_i / 60
-          last = get_saved_minute!
-          if last
-            break if minutes <= last
-            minutes = last + 1
-          end
-
-          seconds = minutes * (60)
-          hours   = minutes / (60)
-          days    = minutes / (60*24)
-
-          now     = Time.at(seconds)
-
-          attributes = {}
-          attributes["epoch_seconds"] = seconds
-          attributes["epoch_minutes"] = minutes
-          attributes["epoch_hours"]   = hours
-          attributes["epoch_days"]    = days
-
-          attributes["minute"] = now.min
-          attributes["hour"]   = now.hour
-          attributes["day"]    = now.day
-          attributes["month"]  = now.month
-          attributes["year"]   = now.year
-          attributes["yday"]   = now.yday
-          attributes["wday"]   = now.wday
-
-          ResqueBus.publish("heartbeat_minutes", attributes)
-          set_saved_minute!(minutes)
-        end
-
-        unlock!
-      end
-    end
-
-  end
-end

data/lib/resque_bus/local.rb

@@ -1,34 +0,0 @@
-module ResqueBus
-  # only process local queues
-  class Local
-
-    class << self
-      def perform(attributes = {})
-        ResqueBus.log_worker("Local running: #{attributes.inspect}")
-
-        # looking for subscriptions, not queues
-        subscription_matches(attributes).each do |sub|
-           bus_attr = {"bus_driven_at" => Time.now.to_i, "bus_rider_queue" => sub.queue_name, "bus_rider_app_key" => sub.app_key, "bus_rider_sub_key" => sub.key, "bus_rider_class_name" => sub.class_name}
-          to_publish = bus_attr.merge(attributes || {})
-          if ResqueBus.local_mode == :standalone
-            ResqueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
-          # defaults to inline mode
-          else ResqueBus.local_mode == :inline
-            sub.execute!(to_publish)
-          end
-        end
-      end
-
-      # looking directly at subscriptions loaded into dispatcher
-      # so we don't need redis server up
-      def subscription_matches(attributes)
-        out = []
-        ResqueBus.dispatchers.each do |dispatcher|
-          out.concat(dispatcher.subscription_matches(attributes))
-        end
-        out
-      end
-    end
-
-  end
-end

data/lib/resque_bus/matcher.rb

@@ -1,81 +0,0 @@
-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

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

data/lib/resque_bus/rider.rb

@@ -1,54 +0,0 @@
-require 'resque-retry'
-
-module ResqueBus
-  # queue'd in each
-  class Rider
-    extend Resque::Plugins::ExponentialBackoff
-    
-    class << self
-      def 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 queue
-        @my_queue
-      end
-      
-      def 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 on_failure_zzz(exception, *args)
-        # note: sorted alphabetically
-        @my_queue = nil
-      end
-
-    end
-  end
-end

data/lib/resque_bus/subscriber.rb

@@ -1,63 +0,0 @@
-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)
-        ResqueBus.with_global_attributes(attributes) do
-          sub_key = attributes["bus_rider_sub_key"]
-          meth_key = sub_key.split(".").last
-          resque_bus_execute(meth_key, attributes)
-        end
-      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