abid 0.1.1 → 0.2.0

data/lib/abid/application.rb

@@ -4,12 +4,10 @@ module Abid
 
     attr_reader :worker
     attr_reader :config
-    attr_reader :futures
 
     def initialize
       super
       @rakefiles = %w(abidfile Abidfile abidfile.rb Abidfile.rb) << abidfile
-      @futures = {}
       @worker = Worker.new(self)
     end
 
@@ -21,26 +19,39 @@ module Abid
     def init(app_name = 'abid')
       standard_exception_handling do
         @config = IniFile.new(content: default_config)
-        @config.merge!(IniFile.load('config/abid.cfg'))
+        @config.merge!(IniFile.load('config/abid.conf'))
       end
 
       super(app_name)
     end
 
-    # allows the `abid db:migrate` task to load without a abidfile
+    # allows the built-in tasks to load without a abidfile
     def abidfile
       File.expand_path(File.join(File.dirname(__FILE__), '..', 'Abidfile.rb'))
     end
 
+    # load built-in tasks
+    def load_rakefile
+      standard_exception_handling do
+        glob(File.expand_path('../tasks/*.rake', __FILE__)) do |name|
+          Rake.load_rakefile name
+        end
+      end
+      super
+    end
+
     def run_with_threads
       yield
-    ensure
+    rescue Exception => err
+      worker.kill
+      raise err
+    else
       worker.shutdown
     end
 
     def invoke_task(task_string) # :nodoc:
       name, args = parse_task_string(task_string)
-      self[name].async_invoke(*args).value!
+      self[name].async_invoke(*args).wait!
     end
 
     def default_config
@@ -61,12 +72,6 @@ module Abid
         when '--execute-print'
           # disable short option
           opt.delete_at(1)
-        when '--dry-run'
-          h = opt.last
-          opt[-1] = lambda do |value|
-            h.call(value)
-            options.disable_state = true
-          end
         when '--version'
           opt[-1] = lambda do |_value|
             puts "Abid Version: #{Abid::VERSION} (Rake Version: #{RAKEVERSION})"
@@ -79,14 +84,13 @@ module Abid
     def abid_options # :nodoc:
       sort_options(
         [
-          ['--check-parents', '-c',
-           'Run the task if the parents was updated.',
-           proc { options.check_prerequisites = true }
+          ['--repair',
+           'Run the task in repair mode.',
+           proc { options.repair = true }
           ],
           ['--preview', '-p',
            'Run tasks in preview mode.',
            proc do
-             options.disable_state = true
              options.preview = true
            end
           ],
@@ -101,7 +105,7 @@ module Abid
     end
 
     def handle_options
-      options.rakelib = ['rakelib']
+      options.rakelib = %w(rakelib tasks)
       options.trace_output = $stderr
 
       OptionParser.new do |opts|

data/lib/abid/concurrent_extention.rb

@@ -0,0 +1,6 @@
+module Abid
+  module ConcurrentExtention
+    require 'abid/concurrent_extention/ivar'
+    Concurrent::IVar.include IVar
+  end
+end

data/lib/abid/concurrent_extention/ivar.rb

@@ -0,0 +1,12 @@
+module Abid
+  module ConcurrentExtention
+    module IVar
+      def try_fail(reason = StandardError.new)
+        self.fail(reason)
+        true
+      rescue Concurrent::MultipleAssignmentError
+        false
+      end
+    end
+  end
+end

data/lib/abid/dsl_definition.rb

@@ -8,8 +8,8 @@ module Abid
       Rake.application.worker.define(name, thread_count)
     end
 
-    def default_play_class(&block)
-      Rake.application.default_play_class(&block)
+    def play_base(&block)
+      Rake.application.play_base(&block)
     end
 
     def helpers(*extensions, &block)

data/lib/abid/params_parser.rb

@@ -19,7 +19,7 @@ module Abid
 
       def type_cast(value, type)
         case type
-        when :boolean then value == 'true'
+        when :boolean then value == true || value == 'true'
         when :int then value.to_i
         when :float then value.to_f
         when :string then value.to_s

data/lib/abid/play.rb

@@ -17,11 +17,17 @@ module Abid
       def param(name, **param_spec)
         params_spec[name] = { significant: true }.merge(param_spec)
 
-        define_method(name) { params[name] }
+        define_method(name) { task.params[name] }
+      end
+
+      def undef_param(name)
+        params_spec.delete(name)
+        undef_method(name) if method_defined?(name)
       end
 
       def hooks
         @hooks ||= {
+          setup: [],
           before: [],
           after: [],
           around: []
@@ -47,43 +53,30 @@ module Abid
         include(*extensions) if extensions.any?
       end
 
+      def setup(&block)
+        hooks[:setup] << block
+      end
+
       def before(&block)
-        (hooks[:before] ||= []) << block
+        hooks[:before] << block
       end
 
       def after(&block)
-        (hooks[:after] ||= []) << block
+        hooks[:after] << block
       end
 
       def around(&block)
-        (hooks[:around] ||= []) << block
+        hooks[:around] << block
       end
     end
 
     set :worker, :default
     set :volatile, false
 
-    extend Forwardable
-    def_delegators :task, :application, :name, :scope
-    def_delegators 'self.class', :params_spec
-
-    attr_reader :prerequisites
-    attr_reader :params
-
-    def initialize(params)
-      @prerequisites = []
+    attr_reader :task
 
-      @params = ParamsParser.parse(params, params_spec)
-      @params = @params.sort.to_h # avoid ambiguity of keys order
-      @params.freeze
-    end
-
-    def task
-      self.class.task
-    end
-
-    def setup
-      # noop
+    def initialize(task)
+      @task = task
     end
 
     def run
@@ -91,23 +84,7 @@ module Abid
     end
 
     def needs(task_name, **params)
-      @prerequisites |= [[task_name, params]]
-    end
-
-    def significant_params
-      [
-        name,
-        params.select { |p, _| params_spec[p][:significant] }
-      ]
-    end
-
-    def hash
-      significant_params.hash
-    end
-
-    def eql?(other)
-      other.is_a?(Abid::Play) && \
-        significant_params.eql?(other.significant_params)
+      task.enhance([[task_name, params]])
     end
 
     def volatile?
@@ -115,25 +92,7 @@ module Abid
     end
 
     def preview?
-      application.options.preview
-    end
-
-    def invoke
-      self.class.hooks[:before].each { |blk| instance_eval(&blk) }
-
-      call_around_hooks(self.class.hooks[:around]) { run }
-
-      self.class.hooks[:after].each { |blk| instance_eval(&blk) }
-    end
-
-    def call_around_hooks(hooks, &body)
-      if hooks.empty?
-        body.call
-      else
-        h, *rest = hooks
-        instance_exec(-> { call_around_hooks(rest, &body) }, &h)
-      end
+      task.application.options.preview
     end
-    private :call_around_hooks
   end
 end

data/lib/abid/rake_extensions/task.rb

@@ -10,7 +10,11 @@ module Abid
       end
 
       def state
-        @state ||= State.find(self)
+        State.find(self)
+      end
+
+      def name_with_params
+        name
       end
 
       def async_invoke(*args)
@@ -20,114 +24,121 @@ module Abid
 
       def async_invoke_with_call_chain(task_args, invocation_chain)
         state.reload
-        new_chain = Rake::InvocationChain.append(self, invocation_chain)
-        @lock.synchronize do
-          if application.futures.include?(object_id)
-            return application.futures[object_id]
-          end
-
-          application.trace "** Invoke #{name}" if application.options.trace
 
-          preq_futures = async_invoke_prerequisites(task_args, new_chain)
-
-          future = async_invoke_after_prerequisites(task_args, preq_futures)
+        new_chain = Rake::InvocationChain.append(self, invocation_chain)
 
-          application.futures[object_id] = future
+        state.only_once do
+          if !application.options.repair && state.successed?
+            # skip if successed
+            state.ivar.try_set(false)
+          elsif !application.options.repair && state.failed? && !invocation_chain.empty?
+            # fail if not top level
+            fail "#{name} -- task has been failed" rescue state.ivar.try_fail($ERROR_INFO)
+          else
+            async_invoke_with_prerequisites(task_args, new_chain)
+          end
         end
+        state.ivar
+      ensure
+        state.ivar.try_fail($ERROR_INFO) if $ERROR_INFO
       end
 
-      def async_invoke_prerequisites(task_args, invocation_chain)
-        # skip if successed
-        if state.successed?
-          if !application.options.check_prerequisites
-            preqs = []
+      def async_invoke_with_prerequisites(task_args, invocation_chain)
+        application.trace "** Invoke #{name_with_params}" if application.options.trace
+
+        volatiles, non_volatiles = prerequisite_tasks.partition(&:volatile?)
+
+        async_invoke_tasks(non_volatiles, task_args, invocation_chain) do |updated|
+          if state.successed? && !updated
+            application.trace "** Skip #{name_with_params}" if application.options.trace
+            state.ivar.try_set(false)
           else
-            preqs = prerequisite_tasks.reject(&:volatile?)
+            async_invoke_tasks(volatiles, task_args, invocation_chain) do
+              async_execute_with_session(task_args)
+            end
           end
-        else
-          preqs = prerequisite_tasks
         end
+      end
 
-        preqs.map do |p|
-          preq_args = task_args.new_scope(p.arg_names)
-          p.async_invoke_with_call_chain(preq_args, invocation_chain)
+      def async_invoke_tasks(tasks, task_args, invocation_chain, &block)
+        ivars = tasks.map do |t|
+          args = task_args.new_scope(t.arg_names)
+          t.async_invoke_with_call_chain(args, invocation_chain)
         end
-      end
 
-      def async_invoke_after_prerequisites(task_args, preq_futures)
-        if preq_futures.empty?
-          async_execute_with_session(task_args, false)
+        if ivars.empty?
+          block.call(false)
         else
-          result = Concurrent::IVar.new
-          counter = Concurrent::DependencyCounter.new(preq_futures.size) do
+          counter = Concurrent::DependencyCounter.new(ivars.size) do
             begin
-              failed_preq = preq_futures.find(&:rejected?)
-              next result.fail(failed_preq.reason) if failed_preq
-
-              preq_updated = preq_futures.map(&:value!).any?
-
-              future = async_execute_with_session(task_args, preq_updated)
-
-              future.add_observer do |_time, value, reason|
-                reason.nil? ? result.set(value) : result.fail(reason)
+              if ivars.any?(&:rejected?)
+                state.ivar.try_fail(ivars.find(&:rejected?).reason)
+              else
+                updated = ivars.map(&:value).any?
+                block.call(updated)
               end
             rescue Exception => err
-              result.fail(err)
+              state.ivar.try_fail(err)
             end
           end
-          preq_futures.each { |p| p.add_observer counter }
-          result
+          ivars.each { |i| i.add_observer counter }
         end
       end
 
-      def async_execute_with_session(task_args, prerequisites_updated = false)
-        if (state.successed? && !prerequisites_updated) || !needed?
-          application.trace "** Skip #{name}" if application.options.trace
-          return Concurrent::IVar.new(false)
-        end
-
-        session_started = state.start_session
-
-        return async_wait_complete unless session_started
-
-        pool = application.worker[worker]
-        future = Concurrent::Future.execute(executor: pool) do
+      def async_execute_with_session(task_args)
+        async_execute_in_worker do
           begin
-            execute(task_args)
-            true
-          ensure
-            state.close_session($ERROR_INFO)
+            state.session do
+              begin
+                execute(task_args) if needed?
+                finished = true
+              ensure
+                fail "#{name} -- thread killed" if $ERROR_INFO.nil? && !finished
+              end
+            end
+
+            state.ivar.try_set(true)
+          rescue AbidErrorTaskAlreadyRunning
+            async_wait_complete
           end
         end
-      ensure
-        # close session if error occurred outside the future
-        if session_started && future.nil? && $ERROR_INFO
-          state.close_session($ERROR_INFO)
-        end
       end
 
       def async_wait_complete
         unless application.options.wait_external_task
-          err = RuntimeError.new("task #{name} already running")
-          return Concurrent::IVar.new.fail(err)
+          err = RuntimeError.new("task #{name_with_params} already running")
+          return state.ivar.try_fail(err)
         end
 
-        application.trace "** Wait #{name}" if application.options.trace
+        application.trace "** Wait #{name_with_params}" if application.options.trace
 
-        pool = application.worker[:waiter]
-        Concurrent::Future.execute(executor: pool) do
+        async_execute_in_worker(: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
-            break unless state.running?
+            if !state.running?
+              state.ivar.try_set(true)
+              break
+            elsif Time.now.to_f >= timeout_tm
+              fail "#{name} -- timeout exceeded" rescue state.ivar.try_fail($ERROR_INFO)
+              break
+            else
+              sleep interval
+            end
+          end
+        end
+      end
 
-            sleep interval
-            break if Time.now.to_f >= timeout_tm
+      def async_execute_in_worker(worker = nil, &block)
+        application.worker[worker || self.worker].post do
+          begin
+            block.call
+          rescue Exception => err
+            state.ivar.try_fail(err)
           end
-          true
         end
       end
     end