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

data/lib/abid/environment.rb

@@ -0,0 +1,48 @@
+require 'monitor'
+
+module Abid
+  class Environment
+    def initialize
+      @mon = Monitor.new
+    end
+
+    def application
+      @application ||= Abid::Application.new(self)
+    end
+    attr_writer :application
+
+    def options
+      application.options
+    end
+
+    def config
+      @mon.synchronize do
+        @cofig ||= Config.new
+      end
+    end
+
+    def job_manager
+      @mon.synchronize do
+        @job_manager ||= JobManager.new(self)
+      end
+    end
+
+    def process_manager
+      @mon.synchronize do
+        @process_manager ||= Engine::ProcessManager.new(self)
+      end
+    end
+
+    def worker_manager
+      @mon.synchronize do
+        @worker_manager ||= Engine::WorkerManager.new(self)
+      end
+    end
+
+    def db
+      @mon.synchronize do
+        @db ||= StateManager::Database.new(self)
+      end
+    end
+  end
+end

data/lib/abid/job.rb

@@ -1,13 +1,27 @@
+require 'forwardable'
+require 'monitor'
+
 module Abid
-  # Job instance that is consists of a task name and params.
+  # Job is an aggregation object of components around the task.
   class Job
-    attr_reader :name, :params
+    attr_reader :name, :params, :env
+
+    class << self
+      extend Forwardable
+      def_delegators 'Abid.global.job_manager', :[], :find_by_task
+    end
 
-    # @param name [String] task name
-    # @param params [Hash] task params
-    def initialize(name, params)
+    # @!visibility private
+    def initialize(env, name, params)
+      @env = env
       @name = name
       @params = params.sort.to_h.freeze
+      @mon = Monitor.new
+    end
+
+    def invoke(*args)
+      Engine::Scheduler.invoke(self, *args)
+      process.wait
     end
 
     def params_str
@@ -18,8 +32,36 @@ module Abid
       @digest ||= Digest::MD5.hexdigest(name + "\n" + params_str)
     end
 
-    def assume(force: false)
-      State.assume(self, force: force)
+    def task
+      @task ||= Abid.application[name, nil, params]
+    end
+
+    def state
+      @state ||= StateManager::StateProxy.new(self)
+    end
+
+    def prerequisites
+      task.prerequisite_tasks.map do |preq_task|
+        env.job_manager.find_by_task(preq_task)
+      end
+    end
+
+    def process
+      @mon.synchronize do
+        @process ||= env.process_manager.create
+      end
+    end
+
+    def worker
+      env.worker_manager[task.worker]
+    end
+
+    def volatile?
+      task.volatile? || env.options.disable_state
+    end
+
+    def dryrun?
+      env.options.dryrun || env.options.preview
     end
   end
 end

data/lib/abid/job_manager.rb

@@ -0,0 +1,22 @@
+require 'monitor'
+
+module Abid
+  class JobManager
+    def initialize(env)
+      @env = env
+      @cache = {}
+      @mon = Monitor.new
+    end
+
+    def [](name, params = {})
+      @mon.synchronize do
+        key = [name, params.sort.freeze].freeze
+        @cache[key] ||= Job.new(@env, name, params)
+      end
+    end
+
+    def find_by_task(task)
+      self[task.name, task.params]
+    end
+  end
+end

data/lib/abid/mixin_task.rb

@@ -17,12 +17,12 @@ module Abid
     end
 
     def execute(_args = nil)
-      fail 'mixin is not executable'
+      raise 'mixin is not executable'
     end
 
     class <<self
       def define_mixin(*args, &block) # :nodoc:
-        Rake.application.define_mixin(self, *args, &block)
+        Abid.application.define_mixin(self, *args, &block)
       end
     end
   end

data/lib/abid/rake_extensions.rb

@@ -1,6 +1,14 @@
-module Abid
-  module RakeExtensions
-    require 'abid/rake_extensions/task'
-    Rake::Task.include Task
+require 'abid/rake_extensions/task'
+
+# Delegate Rake.application to Abid.global.application
+class << Rake
+  def application
+    Abid.global.application
+  end
+
+  def application=(app)
+    Abid.global.application = app
   end
 end
+
+Rake::Task.include Abid::RakeExtensions::Task

data/lib/abid/rake_extensions/task.rb

@@ -9,18 +9,12 @@ module Abid
         :default
       end
 
-      def session
-        @session ||= Session.new(self).tap do |session|
-          session.add_observer do |_, _, reason|
-            if session.successed? || session.failed?
-              call_hooks(:after_invoke, reason)
-            end
-          end
-        end
+      def job
+        Job[name, defined?(params) ? params : {}]
       end
 
-      def state
-        State.find(self)
+      def params
+        {}
       end
 
       def name_with_params
@@ -42,113 +36,6 @@ module Abid
       def call_hooks(tag, *args)
         hooks[tag].each { |h| h.call(*args) }
       end
-
-      def async_invoke(*args)
-        task_args = Rake::TaskArguments.new(arg_names, args)
-        async_invoke_with_call_chain(task_args, Rake::InvocationChain::EMPTY)
-      end
-
-      def async_invoke_with_call_chain(task_args, invocation_chain)
-        session.enter do
-          session.capture_exception do
-            new_chain = Rake::InvocationChain.append(self, invocation_chain)
-
-            unless concerned?
-              session.skip
-              break
-            end
-
-            call_hooks(:before_invoke)
-
-            async_invoke_prerequisites(task_args, new_chain)
-
-            async_execute_after_prerequisites(task_args)
-          end
-        end
-      end
-
-      def async_invoke_prerequisites(task_args, invocation_chain)
-        prerequisite_tasks.each do |t|
-          args = task_args.new_scope(t.arg_names)
-          t.async_invoke_with_call_chain(args, invocation_chain)
-        end
-      end
-
-      def async_execute_after_prerequisites(task_args)
-        if prerequisite_tasks.empty?
-          async_execute(task_args)
-        else
-          counter = Concurrent::DependencyCounter.new(prerequisite_tasks.size) do
-            session.capture_exception do
-              async_execute(task_args)
-            end
-          end
-          prerequisite_tasks.each { |t| t.session.add_observer counter }
-        end
-      end
-
-      def async_execute(task_args)
-        failed_task = prerequisite_tasks.find do |t|
-          t.session.failed? || t.session.canceled?
-        end
-        if failed_task
-          session.cancel(failed_task.session.error)
-          return
-        end
-
-        async_post(worker) do
-          if !needed?
-            session.skip
-          elsif session.lock
-            call_hooks(:before_execute)
-
-            execute(task_args)
-
-            session.success
-          else
-            async_wait_external
-          end
-        end
-      end
-
-      def async_wait_external
-        unless application.options.wait_external_task
-          fail "task #{name_with_params} already running"
-        end
-
-        application.trace "** Wait #{name_with_params}" if application.options.trace
-
-        async_post(:waiter) do
-          interval = application.options.wait_external_task_interval || 10
-          timeout = application.options.wait_external_task_timeout || 3600
-          timeout_tm = Time.now.to_f + timeout
-
-          loop do
-            state.reload
-            if !state.running?
-              session.success
-              break
-            elsif Time.now.to_f >= timeout_tm
-              fail "#{name} -- timeout exceeded"
-            else
-              sleep interval
-            end
-          end
-        end
-      end
-
-      def async_post(worker_name, &block)
-        application.worker[worker_name].post do
-          session.capture_exception do
-            begin
-              block.call
-              finished = true
-            ensure
-              fail 'thread killed' if $ERROR_INFO.nil? && !finished
-            end
-          end
-        end
-      end
     end
   end
 end

data/lib/abid/state_manager/database.rb

@@ -1,35 +1,39 @@
 require 'sequel/plugins/serialization'
+require 'abid/state_manager/state'
+require 'abid/state_manager/state_proxy'
 
 module Abid
   module StateManager
-    module Database
+    class Database
       Sequel.extension :migration
 
-      # Create a new database object.
-      #
-      # Abid.config['database'] is used Sequel.connect params.
+      MIGRATIONS_PATH = File.expand_path('../../../../migrations', __FILE__)
+
+      # Creates a new database object and checks schema version.
       #
       # @return [Sequel::Database] database object
-      def self.connect
-        db = connect!
-        Sequel::Migrator.check_current(db, migrations_path)
+      # @see Sequel.connect
+      def self.connect(*args)
+        db = Sequel.connect(*args)
+        Sequel::Migrator.check_current(db, MIGRATIONS_PATH)
         db
       rescue Sequel::Migrator::NotCurrentError
         raise Error, 'current schema is out of date'
       end
 
-      # Connect to database without schema version check
-      #
-      # @return [Sequel::Database] database object
-      def self.connect!
-        # symbolize keys
-        params = {}
-        Abid.config.database.each { |k, v| params[k.to_sym] = v }
-        Sequel.connect(**params)
+      def initialize(env)
+        @env = env
+        @mon = Monitor.new
+      end
+
+      def connection
+        @connection ||= self.class.connect(@env.config.database)
       end
 
-      def self.migrations_path
-        File.expand_path('../../../../migrations', __FILE__)
+      def states
+        @mon.synchronize do
+          @states ||= Class.new(State.Model(connection[:states]))
+        end
       end
     end
   end

data/lib/abid/state_manager/state.rb

@@ -1,7 +1,11 @@
 module Abid
   module StateManager
+    State = Class.new(Sequel::Model)
+
     # O/R Mapper for `states` table.
-    class State < Sequel::Model(StateManager.database)
+    #
+    # Use #init_by_job to initialize a state object.
+    class State
       RUNNING = 1
       SUCCESSED = 2
       FAILED = 3
@@ -42,9 +46,55 @@ module Abid
         ).first
       end
 
-      def self.find_or_initialize_by_job(job)
-        find_by_job(job) || \
-          new(name: job.name, params: job.params_str, digest: job.digest)
+      # Initialize a state by a job.
+      #
+      # @param job [Job] job
+      # @return [State] state object
+      def self.init_by_job(job)
+        new(
+          name: job.name,
+          params: job.params_str,
+          digest: job.digest
+        )
+      end
+
+      # Find or initialize a state by a job.
+      #
+      # @param job [Job] job
+      # @return [State] state object
+      def self.find_or_init_by_job(job)
+        find_by_job(job) || init_by_job(job)
+      end
+
+      # Update the state to RUNNING.
+      #
+      # @param job [Job] job
+      def self.start(job)
+        db.transaction do
+          state = find_or_init_by_job(job)
+          state.check_running!
+          state.state = RUNNING
+          state.start_time = Time.now
+          state.end_time = nil
+          state.save
+        end
+      end
+
+      # Update the state to SUCCESSED or FAILED.
+      #
+      # If error is given, the state will be FAILED.
+      #
+      # @param job [Job] job
+      # @param error [Error] error object
+      def self.finish(job, error = nil)
+        db.transaction do
+          state = find_or_init_by_job(job)
+          return unless state.running?
+
+          state.state = error ? FAILED : SUCCESSED
+          state.end_time = Time.now
+          state.save
+        end
       end
 
       # Assume the job to be successed
@@ -54,11 +104,10 @@ module Abid
       #
       # @param job [Job] job
       # @param force [Boolean] force update the state
-      # @return [State] state object
+      # @return [void]
       def self.assume(job, force: false)
-        StateManager.database.transaction do
-          state = find_or_initialize_by_job(job)
-
+        db.transaction do
+          state = find_or_init_by_job(job)
           return state if state.successed?
           state.check_running! unless force
 
@@ -72,15 +121,16 @@ module Abid
 
       # Delete the state.
       #
+      # @param state_id [Integer] State ID
       # @param force [Boolean] If true, delete the state even if running
       # @return [void]
-      def revoke(force: false)
-        StateManager.database.transaction do
-          unless force
-            refresh
-            check_running!
-          end
-          delete
+      def self.revoke(state_id, force: false)
+        db.transaction do
+          state = self[state_id]
+          return false if state.nil?
+          state.check_running! unless force
+          state.delete
+          true
         end
       end