sidekiq_strategies 0.0.1

data/lib/sidekiq_strategies/beanstalkd_handler.rb

@@ -0,0 +1,32 @@
+module SidekiqStrategies
+
+  class BeanstalkdHandler
+    attr_accessor :connection
+    
+    TIME_TO_RUN = 600
+
+    def initialize(connection=nil)
+      @connection = connection
+    end
+
+    def obtain_tube(name)
+      conn.tubes[name]
+    end
+
+    def find_job(id)
+      conn.jobs.find_all(id).shift
+    end
+
+    private
+
+    def conn
+      @connection ||= Beaneater::Pool.new(host)
+    end
+
+    def host
+      @host ||= 'localhost:11300'
+    end
+
+  end
+
+end

data/lib/sidekiq_strategies/helper.rb

@@ -0,0 +1,50 @@
+module SidekiqStrategies
+
+  class Helper
+    attr_accessor :acc_handler
+
+    def initialize(acc_handler, url_helper)
+      @acc_handler = acc_handler
+      self.class.send(:include, url_helper)
+    end
+
+    def reply_tube_name
+      "#{@acc_handler.account.country.code}-#{@acc_handler.account.id}"
+    end
+
+    def request_tube_name
+      @acc_handler.transaction.provider.queue
+    end
+
+    def queue_message
+      @acc_handler.transaction.provider.queue_options.merge(
+        {
+          action:       @acc_handler.action_name,
+          account:      @acc_handler.account.id,
+          number:       @acc_handler.account.number,
+          service:      @acc_handler.account.service.slug,
+          fields:       @acc_handler.transaction.fields,
+          retry_count:  @acc_handler.transaction.retry_count,
+          request_tube: @acc_handler.transaction.provider.queue,
+          reply_tube:   reply_tube_name,
+          account_url:  account_url(@acc_handler.account)
+        }
+      )
+    end
+
+    def try_again?(exception)
+      return false if @acc_handler.transaction.retry_count >= 2
+      return exception[:retry_action] if exception.kind_of?(Hash)
+      return exception.retry_action if exception.respond_to?(:retry_action)
+      false
+    end
+
+    private
+
+    def account_url(account)
+      v1_account_url cc: account.country_code, slug: account.service.slug, id: account.id
+    end
+
+  end
+
+end

data/lib/sidekiq_strategies/polling_strategy.rb

@@ -0,0 +1,252 @@
+module SidekiqStrategies
+
+  class PollingStrategy < Base
+
+    attr_accessor :poll_interval, :poll_max_tries, :poll_tries_before_airbrake
+
+    def initialize(acc_handler, bns_handler, logger, airbrake_notifier, helper)
+      @acc_handler = acc_handler
+      @bns_handler = bns_handler
+      @helper = helper
+
+      @poll_interval = 1 # seconds
+      @poll_max_tries = 600
+      @poll_tries_before_airbrake = 180
+
+      @logger = logger
+      @airbrake_notifier = airbrake_notifier
+    end
+
+    def retries_exhausted(msg)
+      @logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"
+      @acc_handler.save_exception(XBP::Error::ApiInternalError.new( msg['error_class'] + ': ' + msg['error_message'] ))
+      @acc_handler.error
+    end
+
+    def perform(sidekiq_jid)
+    
+      @logger.info "processing transaction #{@acc_handler.transaction.id}"
+
+      begin
+        request_tube = @bns_handler.obtain_tube(@helper.request_tube_name)
+        reply_tube = @bns_handler.obtain_tube(@helper.reply_tube_name)
+
+        # There are previous data?
+        beanstalkd_jid = @acc_handler.transaction.beanstalkd_jid
+        if beanstalkd_jid != nil
+          reply_job = reserve_existing_reply_job(reply_tube)
+          request_job = @bns_handler.find_job(beanstalkd_jid)
+
+          if reply_job != nil
+            # do nothing: there was already a reply job for me
+          else
+            kick_existing_buried_job(beanstalkd_jid)
+          end
+        end
+
+        # Save sidekiq job id
+        @acc_handler.save_sidekiq_jid(sidekiq_jid)
+
+        if ( ['reserved', 'awaiting_retry', 'waiting_at_worker'].include?(@acc_handler.account.state) || request_job!=nil || reply_job!=nil )
+        
+          if reply_job == nil
+
+            # There are available watchers?
+            validate_available_watchers(request_tube)
+
+            # Is the provider available to process requests?
+            validate_provider_status
+
+          end
+
+          if ( request_job==nil && reply_job==nil )
+            @logger.info "putting job in #{@helper.request_tube_name} tube"
+            @logger.info "expect response in #{@helper.reply_tube_name} tube"
+            request_job_data = request_tube.put(Oj.dump(@helper.queue_message), pri: @acc_handler.priority, ttr: BeanstalkdHandler::TIME_TO_RUN)
+            request_job = @bns_handler.find_job(request_job_data[:id])
+            @acc_handler.save_beanstalkd_jid(request_job_data[:id])
+          end
+
+          if reply_job == nil
+            reply_job = reserve_reply_job(reply_tube, request_tube, request_job)
+          end
+
+          # At this point all should be ok
+          @logger.info "reply job obtained: #{reply_job}"
+
+          if reply_job != nil
+            process_job_response(reply_job, request_job)
+          elsif reply_job==nil && @acc_handler.account.state!='error'
+            mark_account_with_invalid_state
+          end
+
+        else
+          mark_account_with_invalid_state
+        end
+
+      rescue Beaneater::NotConnected => exception
+        @logger.info "beanstalkd service was unavailable"
+        exception = XBP::Error::MessageQueueNotReachable.new("Beanstalk queue is not reachable")
+        @acc_handler.queue_for_retry
+        raise exception
+      end
+
+    end
+
+    private
+
+    def mark_account_with_invalid_state
+      @logger.info "account was in an invalid state: #{@acc_handler.account.state}"
+      exception = XBP::Error::AccountInvalidState.new("The account was in an invalid state: #{@acc_handler.account.state}.")
+      @acc_handler.save_exception(exception)
+      @acc_handler.error
+    end
+
+    def validate_available_watchers(tube)
+      if tube.stats.current_watching == 0
+        exception = XBP::Error::WorkersUnavailable.new("No workers available for queue #{tube.name}.")
+        @acc_handler.queue_for_retry
+        raise exception
+      end
+    end
+
+    def validate_provider_status
+      # TODO: status == obtain_status
+      # TODO: if status != 'ok'
+      # TODO:   exception = XBP::Error::??
+      # TODO:   @acc_handler.save_sidekiq_exception(exception)
+      # TODO:   @acc_handler.error
+      # TODO: else
+      # TODO:   true
+      # TODO: end
+    end
+
+    def reserve_existing_reply_job(reply_tube)
+      reply_job = nil
+
+      if reply_job_data = reply_tube.peek(:ready)
+        reply_job = reply_tube.reserve
+
+        if ( ['reserved', 'awaiting_retry', 'waiting_at_worker'].include?(@acc_handler.account.state) )
+          @acc_handler.start_action
+        end
+      end
+
+      reply_job
+    end
+
+    def kick_existing_buried_job(job_id)
+      request_job = @bns_handler.find_job(job_id)
+      if request_job != nil
+        if request_job.stats.state == 'buried'
+          request_job.kick
+        elsif request_job.stats == 'ready'
+          # Do nothing: soon some worker will process this job
+        elsif request_job.stats == 'reserved'
+          # Do nothing: some worker should be processing this job
+        elsif request_job.stats == 'delayed'
+          # Do nothing: this job suddenly will be back on 'ready' queue
+        end
+      else
+        # Do nothing: if request_job doesn't exist it will be created
+      end
+
+      request_job
+    end
+
+    def process_job_response(reply_job, request_job)
+      if @acc_handler.account.state == 'waiting_at_worker'
+        @acc_handler.start_action
+      end
+
+      body = Oj.load(reply_job.body.to_s)
+
+      if exception = body[:exception]
+        if @helper.try_again?(exception)
+          @acc_handler.queue_for_retry
+
+          # Raise exception for retry
+          if exception[:type]
+            if exception[:type].kind_of?(String)
+              raise Kernel.const_get(exception[:type]), exception[:message]
+            else
+              raise exception[:type], exception[:message]
+            end
+          else
+            raise exception, exception[:message]
+          end
+        else
+          @acc_handler.save_exception(exception)
+          @acc_handler.error
+        end
+      else
+        @acc_handler.save_success_response(body)
+        @acc_handler.success
+      end
+
+      reply_job.delete
+      ## request_job.delete
+    end
+
+    def reserve_reply_job(reply_tube, request_tube, request_job)
+      job = nil
+      poll_count = 0
+      poll_done = false
+
+      if request_tube.stats.current_waiting == 0
+        @acc_handler.queue_for_wait_at_worker
+      else
+        @acc_handler.start_action
+      end
+
+      while !poll_done
+
+        begin
+          job = reply_tube.reserve(@poll_interval)
+          poll_done = true
+        rescue Beaneater::TimedOutError => ex
+
+          begin
+            if request_job.stats.state == 'ready'
+              # Do nothing: wait another second or less
+            elsif request_job.stats.state == 'reserved'
+              if @acc_handler.account.state == 'waiting_at_worker'
+                @acc_handler.start_action
+              else
+                # Do nothing: wait another second or less
+              end
+            elsif request_job.stats.state == 'buried'
+              # Do nothing: reply tube should contain the response
+            end
+          rescue Beaneater::NotFoundError => ex
+            # Request_job has been deleted, it is ok!
+            # Reply tube should be ready
+          end
+
+        end
+
+        poll_count += 1
+        if poll_count >= @poll_max_tries
+          poll_done = true
+        elsif poll_count == @poll_tries_before_airbrake
+          @airbrake_notifier.notify(:error_message => "Polling is taking more than #{@poll_tries_before_airbrake} seconds.")
+        end
+
+      end # polling
+
+      if job == nil
+        error_message = "Queue #{@helper.reply_tube_name} time out. Waited #{@poll_max_tries} seconds."
+        exception = XBP::Error::MessageQueueTimeout.new(error_message)
+        
+        @logger.info error_message
+        @acc_handler.save_exception(exception)
+        @acc_handler.error
+        @airbrake_notifier.notify(:error_message => error_message)
+      end
+
+      job
+    end
+
+  end
+
+end

data/lib/sidekiq_strategies/version.rb

@@ -0,0 +1,3 @@
+module SidekiqStrategies
+  VERSION = "0.0.1"
+end

data/lib/spool/publisher.rb

@@ -0,0 +1,15 @@
+module Spool
+  module Publisher
+    def add_subscriber(object)
+      @subscribers ||= []
+      @subscribers << object
+    end
+
+    def publish(message, *args)
+      return if !(@subscribers && @subscribers.any?)
+      @subscribers.each do |subscriber|
+        subscriber.send(message, *args) if subscriber.respond_to?(message)
+      end
+    end
+  end
+end

data/lib/spool/subscribers/events_agent_subscriber.rb

@@ -0,0 +1,11 @@
+module Spool
+	module Subscribers
+		class EventsAgentSubscriber
+
+			def state_changed(account, from, to)
+				puts "Spool::Subscribers::EventsAgentSubscriber: [state_changed] - account: #{account}, from: #{from}, to: #{to}"
+			end
+
+		end
+	end
+end

data/lib/spool/subscribers/redis_pubsub_subscriber.rb

@@ -0,0 +1,11 @@
+module Spool
+  module Subscribers
+    class RedisPubSubSubscriber
+
+      def state_changed(account, from, to)
+        puts "Spool::Subscribers::RedisPubSubSubscriber: [state_changed] - account: #{account}, from: #{from}, to: #{to}"
+      end
+
+    end
+  end
+end

data/lib/strategy_runner.rb

@@ -0,0 +1,26 @@
+# Load to simulate a rails environment
+require './lib/dependencies'
+
+module SidekiqStrategies
+Rails.application.routes.url_helpers
+	
+	# Initialize helpers
+	acc_handler = AccountHandler.new(2, 4, :query, 10, Spool::Publisher)
+	bns_handler = BeanstalkdHandler.new
+	helper = Helper.new(acc_handler, Rails.application.routes.url_helpers)
+
+	# Assign watchers
+	acc_handler.add_subscriber(Spool::Subscribers::RedisPubSubSubscriber.new)
+	acc_handler.add_subscriber(Spool::Subscribers::EventsAgentSubscriber.new)
+
+	# Define external dependencies
+	logger = Sidekiq.logger
+	airbrake_notifier = Airbrake
+
+	# Initiailze strategy executor
+	strategy = PollingStrategy.new(acc_handler, bns_handler, logger, airbrake_notifier, helper)
+
+	# Run strategy
+	strategy.perform('56dg4df68g')
+
+end

data/sidekiq_strategies.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sidekiq_strategies/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sidekiq_strategies"
+  spec.version       = SidekiqStrategies::VERSION
+  spec.authors       = ["abrahamb"]
+  spec.email         = ["abraham.ordonez@xoom.com"]
+  spec.summary       = %q{Sidekiq strategies to manage accounts processing actions.}
+  spec.description   = %q{Sidekiq strategies to manage accounts processing actions.}
+  spec.homepage      = "https://github.com/blue-kite/sidekiq_strategies"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_dependency 'beaneater', '~> 0.3.2'
+  spec.add_dependency 'oj', '~> 2.9.0'
+  spec.add_dependency 'money'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+# Load to simulate a rails environment
+require './lib/dependencies'
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f}
+
+RSpec.configure do |config|
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+end