omg-monkeyjob 0.1.6

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Igor Gunko
+
+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.rdoc

@@ -0,0 +1,22 @@
+=== Introduction
+
+
+=== Installation
+  gem install omg-monkeyjob --source http://gems.github.com
+
+=== Usage
+
+=== More info in docs
+http://rdoc.info/projects/omg/monkeyjob
+
+=== Bugs & such
+Please report via Github issue tracking.
+
+=== See also
+* http://github.com/omg/threadpool -- Thread pool implementation
+* http://github.com/omg/xmlnuts -- Ruby <-> XML mapping
+* http://github.com/omg/statelogic -- A simple state machine for ActiveRecord
+
+
+Free hint: If you liek mudkipz^W^Wfeel like generous today you can tip me at http://tipjoy.com/u/pisuka
+

data/Rakefile

@@ -0,0 +1,27 @@
+$KCODE = 'u'
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+Rake::GemPackageTask.new(Gem::Specification.load('threadpool.gemspec')) do |p|
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.rdoc" # page to start on
+  rdoc.title = "XmlNuts Documentation"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers' << '--inline-source'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end
+

data/lib/monkeyjob/broker/active_record/job_model.rb

@@ -0,0 +1,15 @@
+module Monkey
+  class Broker
+    class ActiveRecord
+      class JobModel < ::ActiveRecord::Base
+        set_table_name 'monkey_jobs'
+        serialize :handler
+
+        named_scope :candidates, proc {|queues|
+          {:conditions => ["#{queues.blank? ? 'queue IS NULL' : 'queue IN (:queues)'} AND run_at <= :now",
+          {:now => Time.now, :queues => queues}], :order => 'run_at, id'}
+        }
+      end
+    end
+  end
+end

data/lib/monkeyjob/broker/active_record.rb

@@ -0,0 +1,86 @@
+require 'monitor'
+
+begin
+  require 'activerecord'
+rescue MissingSourceFile => e
+  raise $!.exception('missing activerecord!')
+end
+
+module Monkey
+  class Broker
+    class ActiveRecord < Broker
+      class Cookie < Job::Cookie::Impl
+        attr_reader :queue, :id
+      
+        def initialize(broker, jm)
+          super(jm.handler)
+          @broker, @queue, @id = broker, jm.queue, jm.id
+        end
+        
+        def client
+          @broker.client
+        end
+        
+        def to_s
+          "#{id}#{queue && '@' + queue} #{job}"
+        end
+        
+        private
+        def on_state_changed(was)
+          super
+          @broker.send(:on_finish, self) if finished?
+        end
+      end
+    
+      attr_reader :client
+    
+      def initialize(options = {})
+        extend MonitorMixin
+        @queues = Array(options[:queue] || options[:queues])
+        @client = Client::ActiveRecord.new
+      end
+
+      def start(&callback)
+        @jobs = Set.new
+        loop do
+          synchronize do
+            JobModel.logger.hush do |old_logger_level|
+              JobModel.transaction do
+                for jm in JobModel.candidates(@queues).all(:lock => true)
+                  JobModel.logger.with_level(old_logger_level) do
+                    if @jobs.add?(jm.id) && !callback.call(Cookie.new(self, jm))
+                      @jobs.delete(jm.id)
+                      break
+                    end
+                  end
+                end
+                JobModel.update_all({:run_at => 5.minutes.from_now}, :id => @jobs.to_a)
+              end
+            end
+          end
+          sleep(5)
+        end
+      end
+      
+      def close
+        self
+      end
+
+      private
+      def on_finish(cookie)
+        synchronize do
+          @jobs.delete(cookie.id)
+          if cookie.success?
+            Monkey.logger.hush { JobModel.delete(cookie.id) }
+            Monkey.logger.debug "Deleted job #{cookie}"
+          end
+        end
+      rescue
+        Monkey.logger.error $!
+      end
+    end
+  end
+end
+
+require 'monkeyjob/broker/active_record/job_model'
+

data/lib/monkeyjob/broker.rb

@@ -0,0 +1,6 @@
+module Monkey
+  class Broker
+    autoload :ActiveRecord, 'monkeyjob/broker/active_record'
+  end
+end
+

data/lib/monkeyjob/client/active_record.rb

@@ -0,0 +1,22 @@
+module Monkey
+  class Client
+    class ActiveRecord < Client
+      def initialize(options = {})
+        @queue = options[:queue]
+      end
+    
+      def submit(job, options = {})
+        jm = Broker::ActiveRecord::JobModel.silence do
+          Broker::ActiveRecord::JobModel.new {|m|
+            m.run_at = options[:run_at] || Time.now
+            m.handler = job
+            m.queue = options.fetch(:queue, @queue)
+          }.tap {|jm| jm.save! }
+        end
+        Monkey.logger.info { "Submitted #{job} to #{jm.queue}:#{jm.id}" }
+        self
+      end
+    end
+  end
+end
+

data/lib/monkeyjob/client.rb

@@ -0,0 +1,8 @@
+module Monkey
+  class Client
+    autoload :ActiveRecord, 'monkeyjob/client/active_record'
+    
+    cattr_accessor :default
+  end
+end
+

data/lib/monkeyjob/job.rb

@@ -0,0 +1,103 @@
+module Monkey
+  class Job
+    def to_proc
+      method(:run).to_proc
+    end
+    
+    def to_s
+      self.class.name
+    end
+    
+    def submit(options = {})
+      self.class.submit(self, options)
+    end
+
+    def submit_to(client, options = {})
+      client.submit(self, options)
+    end
+
+    def self.submit(handler, options = {})
+      Client.default.submit(handler, options)
+    end
+
+    class Cookie
+      attr_reader :state, :result, :exception, :started_at, :finished_at
+
+      def running?
+        state == :running
+      end
+
+      def success?
+        state == :success
+      end
+
+      def error?
+        state == :error
+      end
+      
+      def finished?
+        success? || error?
+      end
+
+      private
+      def start!
+        Monkey.logger.info "Running #{self}"
+        @result, @exception, @started_at, @finished_at, self.state = nil, nil, Time.now, nil, :running
+      end
+
+      def unstart!
+        @result, @exception, @started_at, @finished_at, self.state = nil, nil, nil, nil, nil
+      end
+
+      def success!(result = nil)
+        @result, @exception, @finished_at, self.state = result, nil, Time.now, :success
+        Monkey.logger.info "Job #{self} succeeded after #{finished_at - started_at} sec."
+      end
+
+      def error!(exception = nil)
+        @result, @exception, @finished_at, self.state = nil, exception, Time.now, :error
+        Monkey.logger.error(exception) if exception
+        Monkey.logger.error "Job #{self} failed after #{finished_at - started_at} sec."
+      end
+      
+      attr_writer :state
+
+      class Impl < Cookie
+        attr_reader :job
+        
+        def initialize(job)
+          @job = job
+        end
+        
+        def to_s
+          job.to_s
+        end
+
+        def to_proc
+          method(:run).to_proc
+        end
+        
+        def submit(job, options = {})
+          client.submit(job, {:queue => queue}.update(options))
+        end
+        
+        private
+        def state=(v)
+          was = state
+          super.tap { on_state_changed(was) }
+        end
+
+        def on_state_changed(was)
+        end
+
+        def run
+          start!
+          success!(job.to_proc.call(self))
+        rescue
+          error!($!)
+        end
+      end
+    end
+  end
+end
+

data/lib/monkeyjob/juggler.rb

@@ -0,0 +1,26 @@
+module Monkey
+  class Juggler
+    def initialize(options = {})
+      @broker = options[:broker] || raise(ArgumentError, ':broker is mandatory')
+      @runner = options[:runner] || raise(ArgumentError, ':runner is mandatory')
+    end
+    
+    def start
+      @broker.start {|cookie| @runner.run?(cookie) }
+      self
+    end
+    
+    def run
+      start
+    ensure
+      close
+    end
+    
+    def close
+      @broker.close
+      @runner.close
+      self
+    end
+  end
+end
+

data/lib/monkeyjob/logger.rb

@@ -0,0 +1,33 @@
+module Monkey
+  module LoggerPatch
+#    def included?(other)
+#      other.send :alias_method, :global_level, :level
+#      other.send :alias_method, :global_level=, :level=
+#    end
+
+#    def level
+#      Thread.current["logger[#{object_id}].level"] || global_level
+#    end
+
+#    def level=(level)
+#      Thread.current["logger[#{object_id}].level"]
+#    end
+    
+    def with_level(temp_level)
+      return yield(old_level) unless silencer
+      begin
+        old_level, self.level = self.level, temp_level
+        yield old_level
+      ensure
+        self.level = old_level
+      end
+    end
+
+    def hush(temp_level = Logger::ERROR, &block)
+      with_level(temp_level, &block)
+    end
+  end
+  
+  [Logger, ActiveSupport::BufferedLogger].each {|m| m.send :include, LoggerPatch }
+end
+

data/lib/monkeyjob/runner/fork/rails.rb

@@ -0,0 +1,28 @@
+module Monkey
+  class Runner
+    class Fork
+      class Rails < Fork
+        def run_local(*args)
+          super(*args) do
+            begin
+              ::ActiveRecord::Base.dirty_reconnect!
+              yield(*args)
+            ensure
+              ::ActiveRecord::Base.connection_handler.clear_all_connections!
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base
+
+class ActiveRecord::Base
+  def self.dirty_reconnect!
+    @@connection_handler = ::ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    establish_connection
+  end
+end
+

data/lib/monkeyjob/runner/fork.rb

@@ -0,0 +1,88 @@
+require 'monitor'
+
+module Monkey
+  class Runner
+    class Fork < Runner
+      autoload :Rails, 'monkeyjob/runner/fork/rails'
+
+      def initialize(options = {})
+        extend MonitorMixin
+        @max = options[:max] || 4
+        @workers = Set.new
+      end
+      
+      def run(cookie)
+        run_core(:run_local, cookie)
+      end
+      
+      def run?(cookie)
+        run_core(:run_local?, cookie)
+      end
+
+      def run_local(*args)
+        raise ArgumentError, 'block must be provided' unless block_given?
+        pid = fork do
+          trap('TERM') do
+            Monkey.logger.warn "Process #{Process.pid} received SIGTERM, will exit!(2)"
+            exit!(2)
+          end
+          begin
+            Monkey.logger.debug "Process #{Process.pid} running"
+            yield(*args)
+            Monkey.logger.debug "Process #{Process.pid} will exit!"
+            exit!(0)
+          rescue
+            Monkey.logger.error $!
+            Monkey.logger.error "Process #{Process.pid} failed, will exit!(1)"
+            exit!(1)
+          end
+        end
+        (spid = Process.detach(pid))[:pid] = pid
+        Monkey.logger.debug "Forked #{pid}"
+        spid
+      end
+
+      def run_local?(*args, &block)
+        synchronize do
+          return nil unless @workers.size < @max
+          @sweeper ||= Thread.new { loop { sleep(1); synchronize { sweep } } }
+          run_local(*args, &block).tap {|spid| @workers << spid }
+        end
+      end
+
+      def close
+        synchronize do
+          @sweeper.try :kill
+          @workers.each do |spid|
+            begin
+              Monkey.logger.warn { "Killing process #{spid[:pid]}" }
+              Process.kill('TERM', spid[:pid])
+            rescue
+              Monkey.logger.debug $!
+            end
+          end
+        end
+      end
+      
+      private
+      def run_core(method, cookie)
+        synchronize do
+          send(method, cookie, &cookie.job).tap do |spid|
+            (spid[:cookie] = cookie).send(:start!) if spid
+          end
+        end
+      end
+      
+      def sweep
+        @workers.delete_if {|spid| finish!(spid) }
+      rescue
+        Monkey.logger.error($!)
+      end
+      
+      def finish!(spid)
+        !spid.alive?.tap {|alive| spid[:cookie].try(spid.value.success? ? :success! : :error!) unless alive }
+      end
+    end
+  end
+end
+

data/lib/monkeyjob/runner/thread_pool.rb

@@ -0,0 +1,34 @@
+require 'threadpool'
+
+module Monkey
+  class Runner
+    class ThreadPool < Runner
+      def initialize(options = {})
+        @pool = ::ThreadPool.new(options)
+      end
+      
+      def run(cookie)
+        run_local(&cookie)
+      end
+
+      def run?(cookie)
+        run_local?(&cookie)
+      end
+
+      def run_local?(*args, &block)
+        @pool.run(*args, &block)
+        self
+      end
+
+      def run_local?(*args, &block)
+        @pool.run?(*args, &block) && self
+      end
+
+      def close
+        @pool.close
+        self
+      end
+    end
+  end
+end
+

data/lib/monkeyjob/runner.rb

@@ -0,0 +1,10 @@
+module Monkey
+  class Runner
+    autoload :Fork, 'monkeyjob/runner/fork'
+    autoload :ThreadPool, 'monkeyjob/runner/thread_pool'
+    
+    def close
+    end
+  end
+end
+

data/lib/monkeyjob.rb

@@ -0,0 +1,15 @@
+require 'activesupport'
+
+module Monkey
+  mattr_accessor :logger
+  @@logger = Logger.new(STDERR)
+
+  autoload :Client, 'monkeyjob/client'
+  autoload :Broker, 'monkeyjob/broker'
+  autoload :Runner, 'monkeyjob/runner'
+  autoload :Juggler, 'monkeyjob/juggler'
+end
+
+require 'monkeyjob/logger'
+require 'monkeyjob/job'
+

data/lib/omg-monkeyjob.rb

@@ -0,0 +1 @@
+require 'monkeyjob'

data/rails/init.rb

@@ -0,0 +1,2 @@
+Monkey.logger = RAILS_DEFAULT_LOGGER
+

data/test/monkeyjob_test.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'lib/monkeyjob'
+
+
+class MonkeyJobTest < Test::Unit::TestCase
+  def setup
+  end
+
+  def test_me
+  end
+end
+

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: omg-monkeyjob
+version: !ruby/object:Gem::Version 
+  version: 0.1.6
+platform: ruby
+authors: 
+- Igor Gunko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-21 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.6
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.4
+    version: 
+description: 
+email: tekmon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- README.rdoc
+- MIT-LICENSE
+- Rakefile
+- lib/monkeyjob.rb
+- lib/omg-monkeyjob.rb
+- lib/monkeyjob/logger.rb
+- lib/monkeyjob/job.rb
+- lib/monkeyjob/juggler.rb
+- lib/monkeyjob/client.rb
+- lib/monkeyjob/broker.rb
+- lib/monkeyjob/runner.rb
+- lib/monkeyjob/client/active_record.rb
+- lib/monkeyjob/broker/active_record.rb
+- lib/monkeyjob/broker/active_record/job_model.rb
+- lib/monkeyjob/runner/thread_pool.rb
+- lib/monkeyjob/runner/fork.rb
+- lib/monkeyjob/runner/fork/rails.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/omg/monkeyjob
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Like Delayed Job on steroids
+test_files: 
+- test/monkeyjob_test.rb