ctt-background-jobs 0.8.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+background-jobs.sublime-*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.ruby-gemset

@@ -0,0 +1 @@
+ctt-background-jobs

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p194

data/CTT-Background-Jobs.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ctt-background-jobs"
+  spec.version       = BackgroundJobs::VERSION
+  spec.authors       = ["CTT Innovations"]
+  spec.email         = ["info@cttinnovations.com"]
+  spec.description   = 'Common CTT caching tools.'
+  spec.summary       = 'CTT Caching.'
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency 'ctt-notifications', "~> 0.1"
+  spec.add_dependency 'require_relative', '1.0.2'  
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency 'delayed_job_active_record', '0.4.2'
+  spec.add_development_dependency 'imitate', '0.2.0'
+  spec.add_development_dependency 'mocha', '0.13.3'
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec', '2.13.0'
+  spec.add_development_dependency 'shoulda', '3.4.0'
+  spec.add_development_dependency 'sidekiq'
+  spec.add_development_dependency 'timecop', '0.6.1'
+
+  if RUBY_ENGINE == 'jruby'
+    spec.add_development_dependency 'torquebox', '2.3.0'
+  end
+end

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+source 'http://gems.github.com'
+source 'http://gemfile:NLjoiningcare2013@gems.cttinnovations.net'
+
+# Specify your gem's dependencies in ctt-background-jobs.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Petr Janda
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,25 @@
+# CTT::BackgroundJobs
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ctt-background-jobs'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ctt-background-jobs
+
+## Usage
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,29 @@
+require "bundler/gem_tasks"
+
+task :release_private do
+  require 'version'
+
+  version = BackgroundJobs::VERSION
+
+  puts '** Commiting the VERSION file'
+  system 'git add lib/version.rb'
+  system "git commit -m 'v#{version}'"
+
+  puts '** Tagging the git version'
+  system "git tag v#{version}"
+
+  puts '** Pushing tag to remote'
+  system "git push origin v#{version}"
+
+
+  puts '** Pushing to remote'
+  system 'git push origin master'
+
+  puts '** Building the gem'
+  system 'gem build ctt-background-jobs.gemspec'
+
+  puts '** Publishing the gem'
+  system "gem inabox ctt-background-jobs-#{version}.gem"
+
+  puts '** Relax. All done.'
+end

data/lib/background_jobs/configuration.rb

@@ -0,0 +1,27 @@
+require 'singleton'
+
+module BackgroundJobs
+  def self.configure
+    yield Configuration.instance
+
+    strategy = BackgroundJobs.config.strategy
+
+    case strategy
+    when 'sidekiq'
+      options = BackgroundJobs.config.strategy_options
+
+      require 'background_jobs/strategies/sidekiq/setup'
+      BackgroundJobs::Sidekiq.setup options
+    end
+  end
+
+  def self.config
+    Configuration.instance
+  end
+
+  class Configuration
+    include Singleton
+
+    attr_accessor :strategy, :strategy_options
+  end
+end

data/lib/background_jobs/job.rb

@@ -0,0 +1,17 @@
+module BackgroundJobs
+  class Job
+    attr_writer :id
+
+    def perform
+      execute
+    end
+
+    def execute
+      raise NotImplementedError
+    end
+
+    def error(job, exception)
+      Airbrake.notify exception
+    end
+  end
+end

data/lib/background_jobs/job_factory.rb

@@ -0,0 +1,9 @@
+require 'background_jobs/job_registry'
+
+module BackgroundJobs
+  class JobFactory
+    def self.build(job_name, attributes = [])
+      JobRegistry.instance.get_class!(job_name).new(*attributes)
+    end
+  end
+end

data/lib/background_jobs/job_id_generator.rb

@@ -0,0 +1,15 @@
+require 'digest'
+
+module BackgroundJobs
+  module JobIdGenerator
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def generate_job_id
+        Digest::SHA256.hexdigest("#{Time.now.to_f}-#{rand(0)}")
+      end
+    end
+  end
+end

data/lib/background_jobs/job_notifier.rb

@@ -0,0 +1,31 @@
+require 'i18n'
+require 'notification/notifier_service'
+require 'notification/channel_name_service'
+
+module BackgroundJobs
+  module JobNotifier
+    def error(job, exception)
+      super(job, exception)
+
+      notify_error(:message => I18n.t(:flash_background_error))
+    end
+
+    private
+
+    def notify_error(data)
+      notify('error', data)
+    end
+
+    def notify_success(data)
+      notify('success', data)
+    end
+
+    def notify(event, data)
+      Notification::NotifierService.notify(channel_name, event, data)
+    end
+
+    def channel_name
+      @channel_name ||= Notification::ChannelNameService.private_channel_name(@id)
+    end
+  end
+end

data/lib/background_jobs/job_queue_factory.rb

@@ -0,0 +1,36 @@
+require_relative 'configuration'
+
+module BackgroundJobs
+  class UnknownBackgroundJobsQueueStrategy < RuntimeError
+    def initialize(strategy_name)
+      @strategy_name = strategy_name
+    end
+
+    def to_s
+      "Unknown strategy '#{@strategy_name}' doesnt exist!"
+    end
+  end
+
+  class JobQueueFactory
+    def self.build
+      to_class(Configuration.instance.strategy)
+    end
+
+    private
+
+    def self.to_class(strategy_name)
+      case strategy_name
+      when 'sidekiq'
+        require 'background_jobs/strategies/sidekiq/job_queue'
+        Sidekiq::JobQueue.new
+
+      when 'direct_call'
+        require 'background_jobs/strategies/direct_call/job_queue'
+        DirectCall::JobQueue.new
+
+      else
+        raise UnknownBackgroundJobsQueueStrategy.new(strategy_name)
+      end 
+    end
+  end
+end

data/lib/background_jobs/job_registry.rb

@@ -0,0 +1,65 @@
+require 'singleton'
+
+module BackgroundJobs
+  class UnknownJob < RuntimeError
+    def initialize(job_name)
+      @job_name = job_name
+    end
+
+    def to_s
+      "Unknown job '#{@job_name}'!"
+    end
+  end
+
+  class JobMetadata
+    attr_reader :name, :type, :clazz, :options
+
+    def initialize(name, type, clazz, options = nil)
+      @name, @type, @clazz, @options = name, type, clazz, options
+    end
+  end
+
+  class JobRegistry
+    include Singleton
+
+    attr_writer :register_callback
+
+    def register_job(job_metadata)
+      jobs[job_metadata.name] = job_metadata
+      
+      @register_callback.call(job_metadata) if @register_callback
+    end
+
+    def get_class!(job_name)
+      raise UnknownJob.new(job_name) unless job_metadata = get(job_name)
+
+      job_metadata.clazz
+    end
+
+    def get_type(job_name)
+      raise UnknownJob.new(job_name) unless job_metadata = get(job_name)
+
+      job_metadata.type
+    end
+
+    private
+
+    def get(job_name)
+      jobs[job_name]
+    end
+
+    def jobs
+      @jobs ||= {}
+    end
+  end
+
+  def self.register_job(job_name, job_type, job_class, options = {})
+    job_registry.register_job JobMetadata.new(job_name, job_type, job_class, options)
+  end
+
+  private
+
+  def self.job_registry
+    JobRegistry.instance
+  end
+end

data/lib/background_jobs/queue_service.rb

@@ -0,0 +1,17 @@
+require 'background_jobs/job_id_generator'
+require 'background_jobs/job_queue_factory'
+
+module BackgroundJobs
+  class QueueService
+    include JobIdGenerator
+
+    def self.enqueue(job_type, attributes = [], options = {})
+      job_id = generate_job_id
+
+      job_queue = JobQueueFactory.build
+      job_queue.enqueue(job_type, job_id, attributes, options)
+
+      job_id
+    end
+  end
+end

data/lib/background_jobs/strategies/direct_call/job_queue.rb

@@ -0,0 +1,11 @@
+require 'background_jobs/job_factory'
+
+module BackgroundJobs
+  module DirectCall
+    class JobQueue
+      def enqueue(job_type, job_id, attrs, options = {})
+        JobFactory.build(job_type, attrs).execute
+      end
+    end
+  end
+end

data/lib/background_jobs/strategies/sidekiq/job_adapter.rb

@@ -0,0 +1,21 @@
+require 'sidekiq'
+require 'background_jobs/job_factory'
+require 'background_jobs/strategies/sidekiq/job_attributes_adapter'
+
+module BackgroundJobs
+  module Sidekiq
+    class JobAdapter
+      include ::Sidekiq::Worker
+
+      def perform(*attrs)
+        job_type = attrs.shift
+        job_id = attrs.shift
+        attrs = JobAttributesAdapter.new(attrs).decode
+
+        job = JobFactory.build(job_type.to_sym, attrs)
+        job.id = job_id.to_i
+        job.execute
+      end
+    end
+  end
+end

data/lib/background_jobs/strategies/sidekiq/job_attributes_adapter.rb

@@ -0,0 +1,141 @@
+module BackgroundJobs
+  module Sidekiq
+    class JobAttributesAdapter
+      def initialize(attributes)
+        @attributes = Attributes.new(attributes)
+      end
+
+      def encode
+        @attributes.encode
+      end
+
+      def decode
+        @attributes.decode
+      end
+    end
+
+    class Attributes < Array
+      def initialize(array)
+        super array.map {|attr| create_attribute(attr) }
+      end
+
+      def encode
+        map(&:encode)
+      end
+
+      def decode
+        map(&:decode)
+      end
+
+      private
+
+      def create_attribute(attr)
+        AttributeFactory.build(attr)
+      end
+    end
+
+    class AttributeFactory
+      def self.build(value)
+        return HashAttribute.new(value) if value.kind_of?(Hash)
+        return ArrayAttribute.new(value) if value.kind_of?(Array)
+        return Attribute.new(value) unless value.kind_of?(String)
+        StringAttribute.new(value)
+      end
+    end
+
+    class Attribute
+      def initialize(value)
+        @value = value
+      end
+
+      def decode
+        @value
+      end
+
+      def encode
+        case @value.class.name
+          when 'Date'
+            "date:#{@value.to_s}"
+
+          when 'Hash'
+            HashAttribute.new(@value).encode
+
+          when 'Array'
+            ArrayAttribute.new(@value).encode
+
+          when 'Range'
+            "range:[#{Attribute.new(@value.first).encode},#{Attribute.new(@value.last).encode}]"
+
+          else
+            @value
+        end
+      end
+    end
+
+    class HashAttribute < Hash
+      def initialize(value)
+        @value = value
+      end
+
+      def encode
+        @value.keys.each do |key|
+          value = @value.delete(key)
+          @value[key.to_s] = AttributeFactory.build(value).encode
+        end
+        
+        @value
+      end
+
+      def decode
+        @value.keys.each do |key|
+          @value[key.to_sym] = AttributeFactory.build(@value.delete(key)).decode
+        end
+
+        @value
+      end
+    end
+
+    class ArrayAttribute < Array
+      def decode
+        map {|i| AttributeFactory.build(i).decode }
+      end
+
+      def encode
+        map {|i| AttributeFactory.build(i).encode }
+      end
+    end
+
+    class StringAttribute < String
+      def decode
+        if number?
+          return to_i
+        end
+
+        if date?
+          return Date.parse(gsub('date:', ''))
+        end
+
+        if range?
+          matches = match(/range:\[(.*),(.*)\]/)
+          return AttributeFactory.build(matches[1]).decode..AttributeFactory.build(matches[2]).decode
+        end
+
+        self
+      end
+
+      private
+
+      def number?
+        match(/^\d*$/)
+      end      
+
+      def date?
+        match(/^date:.*$/)
+      end
+
+      def range?
+        match(/^range:\[(.*),(.*)\]$/)
+      end
+    end
+  end
+end