abid 0.3.0.pre.alpha.2 → 0.3.0.pre.alpha.3

data/lib/abid/state_manager.rb

@@ -1,17 +0,0 @@
-require 'abid/state_manager/database'
-
-module Abid
-  # StateManager manages jobs execution status and history.
-  #
-  # It ensures that same task is not executed simultaneously.
-  # Further more, it remembers all jobs history and prevents successed jobs to
-  # be executed again.
-  module StateManager
-    # @return [Sequel::Database] database object
-    def self.database
-      @database ||= Database.connect
-    end
-
-    autoload :State, 'abid/state_manager/state'
-  end
-end

data/lib/abid/waiter.rb

@@ -1,110 +0,0 @@
-module Abid
-  # non-block waiter
-  class Waiter
-    Entry = Struct.new(:ivar, :start_time, :next_time,
-                       :interval, :timeout, :block)
-
-    def initialize
-      @cv = ConditionVariable.new
-      @mutex = Mutex.new
-      @queue = MultiRBTree.new
-      @thread = nil
-      @error = nil
-    end
-
-    def wait(interval: 5, timeout: 60, &block)
-      run_thread
-
-      ivar = Concurrent::IVar.new
-      now = Time.now.to_f
-      next_time = now + interval
-      push(Entry.new(ivar, now, next_time, interval, timeout, block))
-      ivar
-    end
-
-    def shutdown(error = nil)
-      error ||= RuntimeError.new('waiter is shutting down')
-      @mutex.synchronize do
-        @error = error
-        @queue.each { |_, e| e.ivar.fail(error) }
-        @queue.clear
-      end
-    end
-
-    def empty?
-      @queue.empty?
-    end
-
-    def alive?
-      @thread.alive?
-    end
-
-    private
-
-    def push(entry)
-      @mutex.synchronize do
-        fail @error if @error
-
-        @queue[entry.next_time] = entry
-        @cv.signal
-      end
-    end
-
-    def shift
-      _, e = @mutex.synchronize do
-        @cv.wait(@mutex) while @queue.empty?
-        @queue.shift
-      end
-      e
-    end
-
-    def sleep_until_next_time(entry)
-      sleep_time = entry.next_time - Time.now.to_f
-      return true if sleep_time <= 0
-
-      @mutex.synchronize { @cv.wait(@mutex, sleep_time) }
-
-      entry.next_time <= Time.now.to_f
-    end
-
-    def proc_entry(entry)
-      unless sleep_until_next_time(entry)
-        # failed to wait. retry.
-        push(entry)
-        return
-      end
-
-      return if entry.ivar.complete? # canceled
-
-      now = Time.now.to_f
-      elapsed = now - entry.start_time
-      ret = entry.block.call(elapsed)
-      if ret
-        entry.ivar.try_set(ret)
-      elsif entry.timeout > 0 && entry.timeout < elapsed
-        fail 'timeout exceeded'
-      else
-        entry.next_time = now + entry.interval
-        push(entry)
-      end
-    rescue Exception => err
-      begin
-        entry.ivar.fail(err)
-      rescue Concurrent::MultipleAssignmentError
-        nil
-      end
-    end
-
-    def run_thread
-      return if @thread
-
-      @thread = Thread.new do
-        begin
-          proc_entry(shift) while @error.nil?
-        ensure
-          shutdown($ERROR_INFO) if $ERROR_INFO
-        end
-      end
-    end
-  end
-end

data/lib/abid/worker.rb

@@ -1,56 +0,0 @@
-module Abid
-  class Worker
-    def initialize(application)
-      @application = application
-      @pools = {}
-      @pool_definitions = {}
-
-      if application.options.always_multitask
-        default_thread_num = @application.options.thread_pool_size || \
-                             Rake.suggested_thread_count - 1
-      else
-        default_thread_num = 1
-      end
-      define(:default, default_thread_num)
-
-      define(:fresh, -1)
-    end
-
-    def define(name, thread_count)
-      name = name.to_sym
-      fail "worker #{name} already defined" if @pool_definitions.include?(name)
-      @pool_definitions[name] = thread_count
-    end
-
-    def [](name)
-      return @pools[name] if @pools.include?(name)
-      return self[:fresh] if name == :waiter # alias
-
-      unless @pool_definitions.include?(name)
-        fail "worker #{name} is not defined"
-      end
-
-      if @pool_definitions[name] > 0
-        @pools[name] = Concurrent::FixedThreadPool.new(
-          @pool_definitions[name],
-          idletime: FIXNUM_MAX
-        )
-      else
-        @pools[name] = Concurrent::SimpleExecutorService.new
-      end
-    end
-
-    def shutdown
-      @pools.each do |_, pool|
-        pool.shutdown
-        pool.wait_for_termination
-      end
-    end
-
-    def kill
-      @pools.each do |_, pool|
-        pool.kill
-      end
-    end
-  end
-end