abid 0.3.0.pre.alpha.3 → 0.3.0.pre.alpha.4

data/lib/abid/engine/process_manager.rb

@@ -1,55 +1,99 @@
-require 'monitor'
+require 'concurrent/atomic/atomic_reference'
 
 module Abid
-  module Engine
+  class Engine
+    # ProcessManager is a processes repositry and tracks each process progress.
     class ProcessManager
-      attr_reader :active_processes
-
-      # @param env [Environment] abid environment
-      def initialize(env)
-        @env = env
-        @active_processes = {}.compare_by_identity
+      def initialize(engine)
+        @engine = engine
+        @all = {}.compare_by_identity
+        @actives = {}.compare_by_identity
+        @top_levels = {}.compare_by_identity
+        @summary = Hash.new { |h, k| h[k] = 0 }
+        @errors = []
         @mon = Monitor.new
+        @status = Concurrent::AtomicReference.new(:running)
       end
+      attr_reader :summary, :errors
+
+      def [](job)
+        return @all[job] if @all.include?(job)
 
-      # @return [Process] new process
-      def create
-        Process.new(self)
+        @mon.synchronize do
+          @all[job] ||= Process.new(@engine, job).tap do |process|
+            process.on_update { update(process) }
+          end
+        end
       end
 
-      # Update active process set.
-      # @param process [Process]
+      # @param job [DSL::Job]
+      # @param args [Array<Object>]
+      # @return [Process]
+      def invoke(job, args)
+        raise Error, 'ProcessManager is not running now' unless running?
+
+        process = self[job]
+        @top_levels[process] = process
+        Scheduler.invoke(process, *args)
+        process.tap(&:wait)
+      end
+
+      # Update active processes list
       def update(process)
-        case process.status
-        when :pending, :running
-          add_active(process)
-        when :complete
-          delete_active(process)
-        end
+        update_actives(process)
+        update_summary(process)
+      end
+
+      def shutdown
+        return unless @status.compare_and_set(:running, :shuttingdown)
+        actives.each(&:wait)
+        @status.set(:shutdown)
       end
 
       # Kill all active processes
       # @param error [Exception] error reason
       def kill(error)
-        each_active { |p| p.quit(error) }
+        return if shutdown?
+        @status.set(:shutdown)
+        @errors << error
+        actives.each { |process| process.quit(error) }
+      end
+
+      def actives
+        @actives.values
       end
 
       def active?(process)
-        @mon.synchronize { @active_processes.include? process }
+        @actives.include?(process)
       end
 
-      private
+      def root?(process)
+        @top_levels.include?(process)
+      end
 
-      def add_active(process)
-        @mon.synchronize { @active_processes[process] ||= process }
+      %w(running shuttingdown shutdown).each do |meth|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{meth}?
+          @status.get == :#{meth}
+        end
+        RUBY
       end
 
-      def delete_active(process)
-        @mon.synchronize { @active_processes.delete(process) }
+      private
+
+      def update_actives(process)
+        if process.complete?
+          @actives.delete(process)
+        else
+          @actives[process] = process
+        end
       end
 
-      def each_active(&block)
-        @mon.synchronize { @active_processes.values.each(&block) }
+      def update_summary(process)
+        return unless process.complete?
+        return if process.job.dryrun?
+        @mon.synchronize { @summary[process.status] += 1 }
+        @errors << process.error if process.error
       end
     end
   end

data/lib/abid/engine/scheduler.rb

@@ -1,16 +1,16 @@
 require 'concurrent/atomic/atomic_fixnum'
 
 module Abid
-  module Engine
+  class 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)
+      def self.invoke(process, *args, invocation_chain: nil)
+        task_args = Rake::TaskArguments.new(process.job.arg_names, args)
         invocation_chain ||= Rake::InvocationChain::EMPTY
 
-        detect_circular_dependency(job, invocation_chain)
-        new(job, task_args, invocation_chain).invoke
+        detect_circular_dependency(process, invocation_chain)
+        new(process, task_args, invocation_chain).invoke
       end
 
       # @!visibility private
@@ -29,30 +29,30 @@ module Abid
         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)
+      def self.detect_circular_dependency(process, chain)
+        # raise error if process.job is a member of the chain
+        new_chain = Rake::InvocationChain.append(process.job, chain)
 
-        job.prerequisites.each do |preq_job|
-          detect_circular_dependency(preq_job, new_chain)
+        process.prerequisites.each do |preq_process|
+          detect_circular_dependency(preq_process, new_chain)
         end
       end
 
-      def initialize(job, args, invocation_chain)
-        @job = job
+      def initialize(process, args, invocation_chain)
+        @process = process
         @args = args
-        @chain = invocation_chain.conj(@job.task)
-        @executor = Executor.new(job, args)
+        @chain = invocation_chain.conj(@process.job)
+        @executor = Executor.new(process, args)
       end
 
       def invoke
         return unless @executor.prepare
 
-        trace_invoke
+        @process.job.trace_invoke
         attach_chain
         invoke_prerequisites
         after_prerequisites do
-          @executor.capture_exception do
+          @process.capture_exception do
             @executor.start
           end
         end
@@ -60,15 +60,9 @@ module Abid
 
       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
+        @process.on_complete do
+          error = @process.error
           next if error.nil?
           next if @chain.nil?
 
@@ -79,16 +73,16 @@ module Abid
       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
+        @process.prerequisites.each do |preq|
+          preq_args = @args.new_scope(@process.job.arg_names)
+          Scheduler.new(preq, 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
+        counter = DependencyCounter.new(@process.prerequisites.size, &block)
+        @process.prerequisites.each do |preq|
+          preq.on_complete { counter.update }
         end
       end
     end

data/lib/abid/engine/waiter.rb

@@ -1,51 +1,50 @@
+require 'concurrent/utility/monotonic_time'
+
 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.
+  class Engine
+    # Waits for a process to be finished which is running in external
+    # application, and completes the process in its own application.
     #
-    #     Waiter.new(job).wait
+    #     Waiter.new(process).wait
     #
-    # The `job` result gets :successed or :failed when external application
-    # finished the job execution.
+    # The `process` result gets :successed or :failed when external application
+    # finished the process execution.
     class Waiter
       DEFAULT_WAIT_INTERVAL = 10
       DEFAULT_WAIT_TIMEOUT = 3600
 
-      def initialize(job)
-        @job = job
-        @process = job.process
+      def initialize(process)
+        @process = process
+        @job = process.job
         @wait_limit = Concurrent.monotonic_time + wait_timeout
       end
 
       def wait
-        unless @job.env.options.wait_external_task
-          @process.finish(AlreadyRunningError.new('job already running'))
+        unless @job.options.wait_external_task
+          @process.finish(AlreadyRunningError.new('process already running'))
           return
         end
 
+        @process.logger.info('waiting')
         wait_iter
       end
 
       private
 
       def wait_interval
-        @job.env.options.wait_external_task_interval ||
-          DEFAULT_WAIT_INTERVAL
+        @job.options.wait_external_task_interval || DEFAULT_WAIT_INTERVAL
       end
 
       def wait_timeout
-        @job.env.options.wait_external_task_timeout ||
-          DEFAULT_WAIT_TIMEOUT
+        @job.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
+        @process.engine.worker_manager[:timer_set].post(wait_interval) do
+          @process.capture_exception do
+            state = @process.state_service.find
 
-            check_finished(state) ||
-              check_timeout ||
-              wait_iter
+            check_finished(state) || check_timeout || wait_iter
           end
         end
       end
@@ -69,15 +68,6 @@ module Abid
         @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

@@ -1,10 +1,11 @@
-require 'forwardable'
-require 'monitor'
-
-require 'concurrent/delay'
+require 'concurrent/configuration'
+require 'concurrent/executor/cached_thread_pool'
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/executor/safe_task_executor'
+require 'concurrent/executor/timer_set'
 
 module Abid
-  module Engine
+  class Engine
     # WorkerManager manges thread pools definition, creation and termination.
     #
     #     worker_manager = Abid.global.worker_manager
@@ -14,32 +15,21 @@ module Abid
     #     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
+        if @workers.include?(name)
+          raise Error, "worker #{name} is already defined"
         end
+
+        @workers[name] = create_worker(num_threads: num_threads)
       end
 
       # Find or create worker
@@ -47,46 +37,35 @@ module Abid
       # @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!
+        unless @workers.include?(name)
+          raise Error, "worker #{name} is not defined"
         end
+
+        @workers[name]
       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
+        each_worker(&:shutdown)
+        each_worker { |worker| worker.wait_for_termination(timeout) }
+        each_worker.all?(&:shutdown?)
       end
 
       def kill
-        @mon.synchronize do
-          check_alive!
-          @alive = false
-          each_active(&:kill)
-        end
+        each_worker(&:kill)
         true
       end
 
+      def each_worker(&block)
+        @workers.values.each(&block)
+      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
+        @workers[:default] = create_worker(num_threads: default_num_threads)
+        @workers[:waiter] = Concurrent.new_io_executor
+        @workers[:timer_set] =
+          Concurrent::TimerSet.new(executor: @workers[:waiter])
       end
 
       def create_worker(definition)
@@ -97,10 +76,6 @@ module Abid
         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 ||
@@ -109,15 +84,6 @@ module Abid
           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