q 0.0.0 → 0.0.1

data/lib/q/methods/delayed_job.rb

@@ -0,0 +1,76 @@
+module Q::Methods::DelayedJob
+  include Q::Methods::Base
+  class NotSetupError < StandardError
+    def initialize
+      msg =  "Delayed job not setup, please run:\n"
+      msg << "  $ bundle exec rails generate delayed_job:active_record\n"
+      msg << "  $ bundle exec rake db:migrate\n"
+      super msg
+    end
+  end
+
+  class QueueConfig
+    def self.call
+      ::Delayed::Job
+    end
+  end
+
+
+  class QueueTask
+    def self.call(*rake_args)
+      Rake::Task["jobs:work"].invoke(rake_args)
+    end
+  end
+
+  # class NewsletterJob < Struct.new(:text, :emails)
+  #   def perform
+  #     emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
+  #   end
+  # end
+  class QueueBuild
+    def self.call(options={}, &job)
+      base             = options[:base]
+      queue_name       = options[:queue_name]
+      queue_klass_name = options[:queue_klass_name]
+
+      raise NotSetupError unless ActiveRecord::Base.connection.table_exists? 'delayed_jobs'
+      raise Q::DuplicateQueueClassError.new(base, queue_klass_name) if Q.const_defined_on?(base, queue_klass_name)
+
+      queue_klass = Class.new do
+        def self.perform(*args)
+          @job.call(*args)
+        end
+
+        def self.job=(job)
+          @job = job
+        end
+
+        def self.queue=(queue)
+          @queue = queue
+        end
+      end
+
+      queue_klass.job   = job
+      queue_klass.queue = queue_name
+
+      queue_klass       = base.const_set(queue_klass_name, queue_klass)
+      return true
+    end
+  end
+
+  # Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...', Customers.find(:all).collect(&:email))
+  class QueueMethod
+    def self.call(options = {})
+      base             = options[:base]
+      queue_name       = options[:queue_name]
+      queue_klass_name = options[:queue_klass_name]
+      queue_klass      = base.const_get(queue_klass_name)
+
+      raise Q::DuplicateQueueMethodError.new(base, queue_name) if base.queue.respond_to?(queue_name)
+
+      base.queue.define_singleton_method(queue_name) do |*args|
+        ::Delayed::Job.enqueue(queue_klass, *args)
+      end
+    end
+  end
+end

data/lib/q/methods/resque.rb

@@ -0,0 +1,73 @@
+module Q::Methods::Resque
+  include Q::Methods::Base
+
+  class QueueConfig
+    def self.call
+      ::Resque
+    end
+  end
+
+  class QueueTask
+    def self.call(*rake_args)
+      Resque.logger.level ||= Integer(ENV['VVERBOSE'] || 1)
+      ENV['QUEUE']        ||= "*"
+      ENV['VERBOSE']      ||= "1"
+      ENV['TERM_CHILD']   ||= '1'
+      ENV['VVERBOSE']     = nil
+      define_setup!
+      Rake::Task["resque:work"].invoke(rake_args)
+    end
+
+    def self.define_setup!
+      return true unless Rake::Task.task_defined?("resque:setup")
+      Rake::Task.define_task("resque:setup" => :environment) do
+        Resque.before_fork = Proc.new { ActiveRecord::Base.establish_connection } if defined?(ActiveRecord)
+      end
+    end
+  end
+
+  class QueueBuild
+    def self.call(options={}, &job)
+      base             = options[:base]
+      queue_name       = options[:queue_name]
+      queue_klass_name = options[:queue_klass_name]
+
+      raise Q::DuplicateQueueClassError.new(base, queue_klass_name) if Q.const_defined_on?(base, queue_klass_name)
+
+      queue_klass = Class.new do
+        def self.perform(*args)
+          @job.call(*args)
+        end
+
+        def self.job=(job)
+          @job = job
+        end
+
+        def self.queue=(queue)
+          @queue = queue
+        end
+      end
+
+      queue_klass.job   = job
+      queue_klass.queue = queue_name
+
+      queue_klass       = base.const_set(queue_klass_name, queue_klass)
+      return true
+    end
+  end
+
+  class QueueMethod
+    def self.call(options = {})
+      base             = options[:base]
+      queue_name       = options[:queue_name]
+      queue_klass_name = options[:queue_klass_name]
+      queue_klass      = base.const_get(queue_klass_name)
+
+      raise Q::DuplicateQueueMethodError.new(base, queue_name) if base.queue.respond_to?(queue_name)
+
+      base.queue.define_singleton_method(queue_name) do |*args|
+        ::Resque.enqueue(queue_klass, *args)
+      end
+    end
+  end
+end

data/lib/q/methods/sidekiq.rb

@@ -0,0 +1,123 @@
+module Q::Methods::Sidekiq
+  include Q::Methods::Base
+
+  class QueueConfig
+    def self.call
+      setup_inline!
+      ::Sidekiq
+    end
+
+    def self.setup_inline!
+      return if @regular_client
+      @regular_client = ::Sidekiq::Client
+
+      ::Sidekiq.define_singleton_method(:inline) do
+        ::Sidekiq::Client == @inline_client
+      end
+
+      ::Sidekiq.define_singleton_method(:inline=) do |val|
+        @regular_client ||= ::Sidekiq::Client
+
+        if val
+          require 'sidekiq/testing/inline'
+          @inline_client  ||= ::Sidekiq::Client
+          Sidekiq.const_set("Client", @inline_client)
+        else
+          Sidekiq.const_set("Client", @regular_client)
+        end
+      end
+    end
+  end
+
+  class QueueTask
+
+    # -c, --concurrency INT            processor threads to use
+    # -d, --daemon                     Daemonize process
+    # -e, --environment ENV            Application environment
+    # -g, --tag TAG                    Process tag for procline
+    # -i, --index INT                  unique process index on this machine
+    # -p, --profile                    Profile all code run by Sidekiq
+    # -q, --queue QUEUE[,WEIGHT]...    Queues to process with optional weights
+    # -r, --require [PATH|DIR]         Location of Rails application with workers or file to require
+    # -t, --timeout NUM                Shutdown timeout
+    # -v, --verbose                    Print more verbose output
+    # -C, --config PATH                path to YAML config file
+    # -L, --logfile PATH               path to writable logfile
+    # -P, --pidfile PATH               path to pidfile
+    # -V, --version                    Print version and exit
+    # -h, --help                       Show help
+    def self.call(*args)
+      setup!
+      cmd = "bundle exec sidekiq "
+      cmd << ENV["QUEUE"]   if ENV["QUEUE"]
+      cmd << args.join(" ") if args.any?
+      puts cmd.inspect
+      exec cmd
+    end
+
+    def self.setup!
+      return unless database_url = ENV['DATABASE_URL']
+      Sidekiq.configure_server do |config|
+        ENV['DATABASE_URL'] = "#{database_url}?pool=25"
+        ActiveRecord::Base.establish_connection
+      end
+    end
+  end
+
+  # example
+  # class SinatraWorker
+  #   include Sidekiq::Worker
+  #
+  #   def perform(msg="lulz you forgot a msg!")
+  #     $redis.lpush("sinkiq-example-messages", msg)
+  #   end
+  # end
+  class QueueBuild
+    def self.call(options={}, &job)
+      base             = options[:base]
+      queue_name       = options[:queue_name]
+      queue_klass_name = options[:queue_klass_name]
+
+      raise Q::DuplicateQueueClassError.new(base, queue_klass_name) if Q.const_defined_on?(base, queue_klass_name)
+
+      queue_klass = Class.new do
+        include ::Sidekiq::Worker
+
+        def perform(*args)
+          @job.call(*args)
+        end
+
+        def self.job=(job)
+          @job = job
+        end
+
+        def self.queue=(queue)
+          @queue = queue
+        end
+      end
+
+      queue_klass.job   = job
+      queue_klass.queue = queue_name
+
+      queue_klass       = base.const_set(queue_klass_name, queue_klass)
+      return true
+    end
+  end
+
+  # Example
+  # SinatraWorker.perform_async params[:msg]
+  class QueueMethod
+    def self.call(options = {})
+      base             = options[:base]
+      queue_name       = options[:queue_name]
+      queue_klass_name = options[:queue_klass_name]
+      queue_klass      = base.const_get(queue_klass_name)
+
+      raise Q::DuplicateQueueMethodError.new(base, queue_name) if base.queue.respond_to?(queue_name)
+
+      base.queue.define_singleton_method(queue_name) do |*args|
+        queue_klass.perform_async(*args)
+      end
+    end
+  end
+end

data/lib/q/methods/threaded_in_memory_queue.rb

@@ -0,0 +1,66 @@
+module Q::Methods::ThreadedInMemoryQueue
+  def self.included(base)
+    require 'threaded_in_memory_queue'
+    at_exit do
+      ThreadedInMemoryQueue.stop  unless ::ThreadedInMemoryQueue.stopped?
+    end
+    super base
+  end
+
+  include Q::Methods::Base
+
+  class QueueConfig
+    def self.call
+      ::ThreadedInMemoryQueue
+    end
+  end
+
+  class QueueTask
+    def self.call(*rake_args)
+      raise "Threaded In Memory Queue runs in web process, no need to start"
+    end
+  end
+
+  class QueueBuild
+    def self.call(options={}, &job)
+      base             = options[:base]
+      queue_name       = options[:queue_name]
+      queue_klass_name = options[:queue_klass_name]
+
+      raise Q::DuplicateQueueClassError.new(base, queue_klass_name) if Q.const_defined_on?(base, queue_klass_name)
+
+      queue_klass = Class.new do
+        def self.call(*args)
+          @job.call(*args)
+        end
+
+        def self.job=(job)
+          @job = job
+        end
+      end
+
+      queue_klass.job = job
+      base.const_set(queue_klass_name, queue_klass)
+      return true
+    end
+  end
+
+  class QueueMethod
+    def self.call(options = {})
+      base             = options[:base]
+      queue_name       = options[:queue_name]
+      queue_klass_name = options[:queue_klass_name]
+      queue_klass      = base.const_get(queue_klass_name)
+
+      raise Q::DuplicateQueueMethodError.new(base, queue_name) if base.queue.respond_to?(queue_name)
+      base.queue.define_singleton_method(queue_name) do |*args|
+        ::ThreadedInMemoryQueue.start unless ::ThreadedInMemoryQueue.started?
+        ::ThreadedInMemoryQueue.enqueue(queue_klass, *args)
+      end
+    end
+  end
+end
+
+# alias
+Q::Methods::Threaded = Q::Methods::ThreadedInMemoryQueue
+Q.queue_lookup[:threaded] = Proc.new {Q::Methods::Threaded}

data/lib/q/tasks.rb

@@ -0,0 +1,14 @@
+module Q
+  module QueueTask
+    def self.call(*args)
+      Q.queue::QueueTask.call(args)
+    end
+  end
+end
+
+if defined?(Rake)
+  task = Rake::Task.define_task("q:work" => :environment) do |t, args|
+    Q::QueueTask.call(args)
+  end
+  task.add_description "Processes background work using the Q library"
+end

data/lib/q/version.rb

@@ -1,3 +1,3 @@
 module Q
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

data/q.gemspec

@@ -1,24 +1,30 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "q/version"
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'q/version'
 
-Gem::Specification.new do |s|
-  s.name        = "q"
-  s.version     = Q::VERSION
-  s.authors     = ["Christopher M. Hobbs"]
-  s.email       = ["chris@altbit.org"]
-  s.homepage    = "http://github.com/hooobs/q"
-  s.summary     = %q{q is for Journal}
-  s.description = %q{q is a command line activity logger/time tracker.}
+Gem::Specification.new do |gem|
+  gem.name          = "q"
+  gem.version       = Q::VERSION
+  gem.authors       = ["Richard Schneeman"]
+  gem.email         = ["richard.schneeman+rubygems@gmail.com"]
+  gem.description   = %q{ A universal interface for Ruby queueing backends. }
+  gem.summary       = %q{ Use Q to switch betwen queue backends as you please. Simplifies creating and calling background jobs }
+  gem.homepage      = "https://github.com/schneems/q"
+  gem.license       = "MIT"
 
-  s.add_dependency("i18n")
-  s.add_dependency("trollop")
-  s.add_dependency("chronic")
-  s.add_dependency("dm-core")
-  s.add_dependency("dm-migrations")
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
 
-  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"]
+  gem.add_dependency "proc_to_lambda"
+  gem.add_dependency "threaded_in_memory_queue"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "mocha"
+  gem.add_development_dependency "resque"
+  gem.add_development_dependency "sidekiq"
+  gem.add_development_dependency "delayed_job_active_record"
+  gem.add_development_dependency "sqlite3"
 end

data/test/methods/base_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+module FakeQueueKlass
+  include Q::Methods::Base
+
+  class QueueMethod; end
+  class QueueBuild;  end
+  class QueueTask;   end
+  class QueueConfig; end
+end
+
+class FakeUserKlass
+  include FakeQueueKlass
+end
+
+module FakeIncludesKlass
+  def self.bar(val)
+  end
+
+  def self.included(klass)
+    self.bar
+    super
+  end
+
+  include FakeQueueKlass
+end
+
+class QMethodsBaseTest < Test::Unit::TestCase
+
+  def test_includes_propper_things
+    assert_includes   FakeQueueKlass,    Q::Methods::Base
+    assert_respond_to FakeUserKlass,     :queue
+    assert_respond_to FakeUserKlass.new, :queue
+  end
+
+  def test_queue_klass
+    assert_equal FakeQueueKlass, FakeUserKlass.class_variable_get("@@_q_klass")
+  end
+
+  def test_includes_gets_called
+    FakeIncludesKlass.expects(:bar).once
+    Class.new do
+      include FakeIncludesKlass
+    end
+    assert_includes   FakeIncludesKlass,    Q::Methods::Base
+  end
+
+  def test_raises_error_missing_klasses
+    # assert no raise
+    foo = Module.new do
+      include Q::Methods::Base
+    end
+    foo.const_set(:QueueMethod, "")
+    foo.const_set(:QueueBuild,  "")
+    foo.const_set(:QueueTask,   "")
+    foo.const_set(:QueueConfig, "")
+    Class.new { include foo }
+
+    error = assert_raise(Q::MissingClassError) do
+      foo = Module.new do
+        include Q::Methods::Base
+      end
+      foo.const_set(:QueueBuild,  "")
+      foo.const_set(:QueueTask,   "")
+      foo.const_set(:QueueConfig, "")
+      Class.new { include foo }
+    end
+    assert_match "QueueMethod", error.message
+
+    error = assert_raise(Q::MissingClassError) do
+      foo = Module.new do
+        include Q::Methods::Base
+      end
+      foo.const_set(:QueueMethod, "")
+      foo.const_set(:QueueTask,   "")
+      foo.const_set(:QueueConfig, "")
+      Class.new { include foo }
+    end
+    assert_match "QueueBuild", error.message
+
+    error = assert_raise(Q::MissingClassError) do
+      foo = Module.new do
+        include Q::Methods::Base
+      end
+      foo.const_set(:QueueMethod, "")
+      foo.const_set(:QueueBuild,  "")
+      foo.const_set(:QueueConfig, "")
+      Class.new { include foo }
+    end
+    assert_match "QueueTask", error.message
+
+    error = assert_raise(Q::MissingClassError) do
+      foo = Module.new do
+        include Q::Methods::Base
+      end
+      foo.const_set(:QueueMethod, "")
+      foo.const_set(:QueueBuild,  "")
+      foo.const_set(:QueueTask,   "")
+      Class.new { include foo }
+    end
+    assert_match "QueueConfig", error.message
+  end
+end