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

data/lib/abid/engine/process.rb

@@ -0,0 +1,137 @@
+require 'concurrent/ivar'
+require 'forwardable'
+require 'monitor'
+
+module Abid
+  module Engine
+    # @!visibility private
+
+    # Process object manages the task execution status.
+    #
+    # You should retrive a process object via Job#process.
+    # Do not create a process object by Process.new constructor.
+    #
+    # A process object has an internal status of the task execution and
+    # the task result (Process#result).
+    #
+    # An initial status is :unscheduled.
+    # When Process#prepare is called, the status gets :pending.
+    # When Process#execute is called and the task is posted to a thread pool,
+    # the status gets :running. When the task is finished, the status gets
+    # :complete and the result is assigned to :successed or :failed.
+    #
+    #     process = Job['task_name'].process
+    #     process.prepare
+    #     process.start
+    #     process.wait
+    #     process.result #=> :successed or :failed
+    #
+    # Possible status are:
+    #
+    # <dl>
+    #   <dt>:unscheduled</dt>
+    #   <dd>The task is not invoked yet.</dd>
+    #   <dt>:pending</dt>
+    #   <dd>The task is waiting for prerequisites complete.</dd>
+    #   <dt>:running</dt>
+    #   <dd>The task is running.</dd>
+    #   <dt>:complete</dt>
+    #   <dd>The task is finished.</dd>
+    # </dl>
+    #
+    # Possible results are:
+    #
+    # <dl>
+    #   <dt>:successed</dt>
+    #   <dd>The task is successed.</dd>
+    #   <dt>:failed</dt>
+    #   <dd>The task is failed.</dd>
+    #   <dt>:cancelled</dt>
+    #   <dd>The task is not executed because of some problems.</dd>
+    #   <dt>:skipped</dt>
+    #   <dd>The task is not executed because already successed.</dd>
+    # </dl>
+    class Process
+      extend Forwardable
+
+      attr_reader :status, :error
+
+      def_delegators :@result_ivar, :add_observer, :wait, :complete?
+
+      def initialize(process_manager)
+        @process_manager = process_manager
+        @result_ivar = Concurrent::IVar.new
+        @status = :unscheduled
+        @error = nil
+        @mon = Monitor.new
+      end
+
+      %w(successed failed cancelled skipped).each do |meth|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{meth}?
+          result == :#{meth}
+        end
+        RUBY
+      end
+
+      def result
+        @result_ivar.value if @result_ivar.complete?
+      end
+
+      def prepare
+        compare_and_set_status(:pending, :unscheduled)
+      end
+
+      def start
+        compare_and_set_status(:running, :pending)
+      end
+
+      def finish(error = nil)
+        return unless compare_and_set_status(:complete, :running)
+        @error = error if error
+        @result_ivar.set(error.nil? ? :successed : :failed)
+        true
+      end
+
+      def cancel(error = nil)
+        return false unless compare_and_set_status(:complete, :pending)
+        @error = error if error
+        @result_ivar.set :cancelled
+        true
+      end
+
+      def skip
+        return false unless compare_and_set_status(:complete, :pending)
+        @result_ivar.set :skipped
+        true
+      end
+
+      # Force fail the task.
+      # @return [void]
+      def quit(error)
+        @status = :complete
+        @error = error
+        @result_ivar.try_set(:failed)
+      end
+
+      private
+
+      # Atomic compare and set operation.
+      # State is set to `next_state` only if
+      # `current state == expected_current`.
+      #
+      # @param [Symbol] next_state
+      # @param [Symbol] expected_current
+      #
+      # @return [Boolean] true if state is changed, false otherwise
+      def compare_and_set_status(next_state, *expected_current)
+        @mon.synchronize do
+          return unless expected_current.include? @status
+          @status = next_state
+          @process_manager.update(self)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/abid/engine/process_manager.rb

@@ -0,0 +1,56 @@
+require 'monitor'
+
+module Abid
+  module Engine
+    class ProcessManager
+      attr_reader :active_processes
+
+      # @param env [Environment] abid environment
+      def initialize(env)
+        @env = env
+        @active_processes = {}.compare_by_identity
+        @mon = Monitor.new
+      end
+
+      # @return [Process] new process
+      def create
+        Process.new(self)
+      end
+
+      # Update active process set.
+      # @param process [Process]
+      def update(process)
+        case process.status
+        when :pending, :running
+          add_active(process)
+        when :complete
+          delete_active(process)
+        end
+      end
+
+      # Kill all active processes
+      # @param error [Exception] error reason
+      def kill(error)
+        each_active { |p| p.quit(error) }
+      end
+
+      def active?(process)
+        @mon.synchronize { @active_processes.include? process }
+      end
+
+      private
+
+      def add_active(process)
+        @mon.synchronize { @active_processes[process] ||= process }
+      end
+
+      def delete_active(process)
+        @mon.synchronize { @active_processes.delete(process) }
+      end
+
+      def each_active(&block)
+        @mon.synchronize { @active_processes.values.each(&block) }
+      end
+    end
+  end
+end

data/lib/abid/engine/scheduler.rb

@@ -0,0 +1,96 @@
+require 'concurrent/atomic/atomic_fixnum'
+
+module Abid
+  module Engine
+    # Scheduler operates whole job flow execution.
+    class Scheduler
+      # @return [void]
+      def self.invoke(job, *args, invocation_chain: nil)
+        task_args = Rake::TaskArguments.new(job.task.arg_names, args)
+        invocation_chain ||= Rake::InvocationChain::EMPTY
+
+        detect_circular_dependency(job, invocation_chain)
+        new(job, task_args, invocation_chain).invoke
+      end
+
+      # @!visibility private
+
+      # Execute given block when DependencyCounter#update is called `count`
+      # times.
+      class DependencyCounter
+        def initialize(count, &block)
+          @counter = Concurrent::AtomicFixnum.new(count)
+          @block = block
+          yield if count <= 0
+        end
+
+        def update(*_)
+          @block.call if @counter.decrement.zero?
+        end
+      end
+
+      def self.detect_circular_dependency(job, chain)
+        # raise error if job.task is a member of the chain
+        new_chain = Rake::InvocationChain.append(job.task, chain)
+
+        job.prerequisites.each do |preq_job|
+          detect_circular_dependency(preq_job, new_chain)
+        end
+      end
+
+      def initialize(job, args, invocation_chain)
+        @job = job
+        @args = args
+        @chain = invocation_chain.conj(@job.task)
+        @executor = Executor.new(job, args)
+      end
+
+      def invoke
+        return unless @executor.prepare
+
+        trace_invoke
+        attach_chain
+        invoke_prerequisites
+        after_prerequisites do
+          @executor.capture_exception do
+            @executor.start
+          end
+        end
+      end
+
+      private
+
+      def trace_invoke
+        return unless @job.env.options.trace
+        @job.env.application.trace \
+          "** Invoke #{@job.task.name} #{@job.task.format_trace_flags}"
+      end
+
+      def attach_chain
+        @job.process.add_observer do
+          error = @job.process.error
+          next if error.nil?
+          next if @chain.nil?
+
+          error.extend(Rake::InvocationExceptionMixin) unless
+            error.respond_to?(:chain)
+          error.chain ||= @chain
+        end
+      end
+
+      def invoke_prerequisites
+        @job.prerequisites.each do |preq_job|
+          preq_args = @args.new_scope(@job.task.arg_names)
+          Scheduler.new(preq_job, preq_args, @chain).invoke
+        end
+      end
+
+      def after_prerequisites(&block)
+        counter = DependencyCounter.new(@job.prerequisites.size, &block)
+        @job.prerequisites.each do |preq_job|
+          preq_job.process.add_observer counter
+        end
+      end
+    end
+  end
+end

data/lib/abid/engine/waiter.rb

@@ -0,0 +1,83 @@
+module Abid
+  module Engine
+    # Waits for a job to be finished which is running in external application,
+    # and completes the job in its own application.
+    #
+    #     Waiter.new(job).wait
+    #
+    # The `job` result gets :successed or :failed when external application
+    # finished the job execution.
+    class Waiter
+      DEFAULT_WAIT_INTERVAL = 10
+      DEFAULT_WAIT_TIMEOUT = 3600
+
+      def initialize(job)
+        @job = job
+        @process = job.process
+        @wait_limit = Concurrent.monotonic_time + wait_timeout
+      end
+
+      def wait
+        unless @job.env.options.wait_external_task
+          @process.finish(AlreadyRunningError.new('job already running'))
+          return
+        end
+
+        wait_iter
+      end
+
+      private
+
+      def wait_interval
+        @job.env.options.wait_external_task_interval ||
+          DEFAULT_WAIT_INTERVAL
+      end
+
+      def wait_timeout
+        @job.env.options.wait_external_task_timeout ||
+          DEFAULT_WAIT_TIMEOUT
+      end
+
+      def wait_iter
+        @job.env.worker_manager[:timer_set].post(wait_interval) do
+          capture_exception do
+            state = @job.state.find
+
+            check_finished(state) ||
+              check_timeout ||
+              wait_iter
+          end
+        end
+      end
+
+      def check_finished(state)
+        return false if state.running?
+
+        if state.successed?
+          @process.finish
+        elsif state.failed?
+          @process.finish RuntimeError.new('task failed while waiting')
+        else
+          @process.finish RuntimeError.new('unexpected task state')
+        end
+        true
+      end
+
+      def check_timeout
+        return false if Concurrent.monotonic_time < @wait_limit
+
+        @process.finish RuntimeError.new('timeout')
+        true
+      end
+
+      def capture_exception
+        yield
+      rescue StandardError, ScriptError => error
+        @process.quit(error)
+      rescue Exception => exception
+        # TODO: exit immediately when fatal error occurs.
+        @process.quit(exception)
+      end
+    end
+  end
+end

data/lib/abid/engine/worker_manager.rb

@@ -0,0 +1,123 @@
+require 'forwardable'
+require 'monitor'
+
+require 'concurrent/delay'
+
+module Abid
+  module Engine
+    # WorkerManager manges thread pools definition, creation and termination.
+    #
+    #     worker_manager = Abid.global.worker_manager
+    #
+    #     worker_manager.define(:main, 2)
+    #
+    #     worker_manager[:main].post { :do_something }
+    #
+    #     worker_manager.shutdown
+    #
+    class WorkerManager
+      def initialize(env)
+        @env = env
+        @workers = {}
+        @alive = true
+        @mon = Monitor.new
+
+        initialize_builtin_workers
+      end
+
+      # Define new worker.
+      #
+      # An actual worker is created when needed.
+      def define(name, num_threads)
+        @mon.synchronize do
+          check_alive!
+
+          if @workers.include?(name)
+            raise Error, "worker #{name} is already defined"
+          end
+
+          @workers[name] = Concurrent::Delay.new do
+            create_worker(num_threads: num_threads)
+          end
+        end
+      end
+
+      # Find or create worker
+      #
+      # @param name [String, Symbol] worker name
+      # @return [Concurrent::ExecutorService]
+      def [](name)
+        @mon.synchronize do
+          check_alive!
+
+          unless @workers.include?(name)
+            raise Error, "worker #{name} is not defined"
+          end
+
+          @workers[name].value!
+        end
+      end
+
+      def shutdown(timeout = nil)
+        @mon.synchronize do
+          check_alive!
+          each_active(&:shutdown)
+          each_active { |worker| worker.wait_for_termination(timeout) }
+
+          result = each_active.all?(&:shutdown?)
+          @alive = false if result
+          result
+        end
+      end
+
+      def kill
+        @mon.synchronize do
+          check_alive!
+          @alive = false
+          each_active(&:kill)
+        end
+        true
+      end
+
+      private
+
+      def initialize_builtin_workers
+        @workers[:default] = Concurrent::Delay.new { create_default_worker }
+        @workers[:waiter] = Concurrent::Delay.new { Concurrent.new_io_executor }
+        @workers[:timer_set] = Concurrent::Delay.new do
+          Concurrent::TimerSet.new(executor: self[:waiter])
+        end
+      end
+
+      def create_worker(definition)
+        if definition[:num_threads] > 0
+          Concurrent::FixedThreadPool.new(definition[:num_threads])
+        else
+          Concurrent::CachedThreadPool.new
+        end
+      end
+
+      def create_default_worker
+        create_worker(num_threads: default_num_threads)
+      end
+
+      def default_num_threads
+        if @env.options.always_multitask
+          @env.options.thread_pool_size ||
+            Rake.suggested_num_threads - 1
+        else
+          1
+        end
+      end
+
+      def check_alive!
+        raise Error, 'already terminated' unless @alive
+      end
+
+      # Iterate on active workers
+      def each_active(&block)
+        @workers.values.select(&:fulfilled?).map(&:value).each(&block)
+      end
+    end
+  end
+end