abid 0.1.1 → 0.2.0

data/lib/abid/state.rb

@@ -1,6 +1,9 @@
 module Abid
+  class AbidErrorTaskAlreadyRunning < StandardError; end
+
   class State
     extend Forwardable
+    extend MonitorMixin
 
     RUNNING = 1
     SUCCESSED = 2
@@ -8,9 +11,10 @@ module Abid
 
     STATES = constants.map { |c| [const_get(c), c] }.to_h
 
+    @cache = {}
     class <<self
       def find(task)
-        new(task)
+        synchronize { @cache[task.object_id] ||= new(task) }
       end
 
       def list(pattern: nil, started_before: nil, started_after: nil)
@@ -33,6 +37,15 @@ module Abid
         end.compact
       end
 
+      def revoke(id)
+        db = Rake.application.database
+        db.transaction do
+          running = db[:states].where(id: id, state: RUNNING).count > 0
+          fail 'task is now running' if running
+          db[:states].where(id: id).delete
+        end
+      end
+
       def serialize(params)
         YAML.dump(params)
       end
@@ -43,12 +56,24 @@ module Abid
     end
 
     def_delegators 'self.class', :serialize, :deserialize
+    attr_reader :ivar
 
     def initialize(task)
       @task = task
+      @record = nil
+      @ivar = Concurrent::IVar.new
+      @already_invoked = false
       reload
     end
 
+    def only_once(&block)
+      self.class.synchronize do
+        return if @already_invoked
+        @already_invoked = true
+      end
+      block.call
+    end
+
     def database
       Rake.application.database
     end
@@ -61,6 +86,10 @@ module Abid
       @task.volatile? || Rake.application.options.disable_state
     end
 
+    def preview?
+      Rake.application.options.dryrun || Rake.application.options.preview
+    end
+
     def reload
       return if disabled?
 
@@ -94,26 +123,52 @@ module Abid
       state == FAILED
     end
 
-    def revoke
+    def not_found?
+      !disabled? && @record.nil?
+    end
+
+    def assume
       fail 'cannot revoke volatile task' if disabled?
 
       database.transaction do
         reload
-        fail 'task is not executed yet' if id.nil?
         fail 'task is now running' if running?
-        dataset.where(id: id).delete
+
+        new_state = {
+          state: SUCCESSED,
+          start_time: Time.now,
+          end_time: Time.now
+        }
+
+        if @record
+          dataset.where(id: @record[:id]).update(new_state)
+          @record = @record.merge(new_state)
+        else
+          id = dataset.insert(
+            digest: digest,
+            name: @task.name,
+            params: serialize(@task.params),
+            **new_state
+          )
+          @record = { id: id, **new_state }
+        end
       end
+    end
 
-      @record = nil
+    def session(&block)
+      started = start_session
+      block.call
+    ensure
+      close_session($ERROR_INFO) if started
     end
 
     def start_session
-      return true if disabled?
+      return true if disabled? || preview?
 
       database.transaction do
         reload
 
-        return false if running?
+        fail AbidErrorTaskAlreadyRunning if running?
 
         new_state = {
           state: RUNNING,
@@ -139,7 +194,7 @@ module Abid
     end
 
     def close_session(error = nil)
-      return if disabled?
+      return if disabled? || preview?
       return unless @record
       state = error ? FAILED : SUCCESSED
       dataset.where(id: @record[:id]).update(state: state, end_time: Time.now)

data/lib/abid/task.rb

@@ -2,24 +2,117 @@ module Abid
   class Task < Rake::Task
     extend Forwardable
 
-    attr_accessor :play_class
-    attr_accessor :play
+    attr_accessor :play_class_definition, :extends
+    attr_reader :play, :params
 
-    def_delegators :play, :params, :worker, :volatile?
+    def_delegators :play, :worker, :volatile?
 
     def initialize(task_name, app)
       super(task_name, app)
-      @actions << proc { |t| t.play.invoke }
-      @actions.freeze
+      @siblings = {}
+    end
+
+    def play_class
+      return @play_class if @play_class
+
+      klass = application.lookup_play_class(extends, scope)
+      @play_class = Class.new(klass, &play_class_definition).tap do |c|
+        c.task = self
+      end
+    end
+
+    def bound?
+      !@play.nil?
+    end
+
+    def bind(**params)
+      fail 'already bound' if bound?
+
+      parsed_params = ParamsParser.parse(params, play_class.params_spec)
+      return @siblings[parsed_params] if @siblings.include?(parsed_params)
+
+      sorted_params = parsed_params.sort.to_h
+      sorted_params.freeze
+
+      @siblings[sorted_params] = dup.tap do |t|
+        t.instance_eval do
+          @prerequisites = []
+          @params = sorted_params
+          @play = play_class.new(t)
+        end
+        play_class.hooks[:setup].each { |blk| t.play.instance_eval(&blk) }
+      end
     end
 
     def prerequisite_tasks
-      fail 'no play is bound yet' if @play.nil?
+      fail 'no play is bound yet' unless bound?
+
+      prerequisites.map do |pre, params|
+        application[pre, @scope, **self.params.merge(params)]
+      end
+    end
+
+    # Name of task with argument list description.
+    def name_with_args # :nodoc:
+      if params_description
+        "#{super} #{params_description}"
+      else
+        super
+      end
+    end
+
+    # Name of task with params
+    def name_with_params # :nodoc:
+      if params_description
+        "#{name} #{params_description}"
+      else
+        super
+      end
+    end
+
+    def params_description
+      sig_params = play_class.params_spec.select do |_, spec|
+        spec[:significant]
+      end
+      return if sig_params.empty?
+
+      if bound? # unbound
+        p = sig_params.map { |name, _| "#{name}=#{params[name]}" }
+      else
+        p = sig_params.map { |name, spec| "#{name}:#{spec[:type]}" }
+      end
+
+      p.join(' ')
+    end
+
+    # Execute the play associated with this task.
+    def execute(_args = nil)
+      fail 'no play is bound yet' unless bound?
+
+      if application.options.dryrun
+        application.trace "** Execute (dry run) #{name_with_params}"
+        return
+      end
+      if application.options.trace
+        application.trace "** Execute #{name_with_params}"
+      end
+
+      play_class.hooks[:before].each { |blk| play.instance_eval(&blk) }
+
+      call_around_hooks(play_class.hooks[:around]) { play.run }
+
+      play_class.hooks[:after].each { |blk| play.instance_eval(&blk) }
+    end
 
-      play.prerequisites.map do |pre, params|
-        application[pre, @scope, **params]
+    def call_around_hooks(hooks, &body)
+      if hooks.empty?
+        body.call
+      else
+        h, *rest = hooks
+        play.instance_exec(-> { call_around_hooks(rest, &body) }, &h)
       end
     end
+    private :call_around_hooks
 
     class <<self
       def define_play(*args, &block) # :nodoc:

data/lib/abid/task_manager.rb

@@ -2,50 +2,40 @@ module Abid
   module TaskManager
     def initialize
       super
-      @plays = {}
     end
 
     def define_play(task_class, play_name, extends: nil, &block)
-      task = define_task(task_class, play_name)
-
-      klass = lookup_play_class(extends)
-      task.play_class = Class.new(klass, &block).tap { |c| c.task = task }
-      task
+      define_task(task_class, play_name).tap do |task|
+        task.extends = extends
+        task.play_class_definition = block
+      end
     end
 
     def [](task_name, scopes = nil, **params)
       task = super(task_name, scopes)
 
-      if task.respond_to? :play_class
-        intern_play(task, **params)
+      if task.respond_to? :bind
+        task.bind(**params)
       else
         task
       end
     end
 
-    def intern_play(task, **params)
-      play = task.play_class.new(**params)
-
-      return @plays[play] if @plays.include?(play)
-
-      play.setup
-      @plays[play] = task.dup.tap { |t| t.play = play }
-    end
-
-    def default_play_class(&block)
+    def play_base(&block)
       if block_given?
-        @default_play_class = Class.new(Abid::Play, &block)
+        @play_base = Class.new(Abid::Play, &block)
       else
-        @default_play_class ||= Abid::Play
+        @play_base ||= Abid::Play
       end
     end
 
     def lookup_play_class(task_name, scope = nil)
       if task_name.nil?
-        default_play_class
+        play_base
+      elsif task_name.is_a? Class
+        task_name
       else
-        task_name = task_name.to_s
-        t = lookup(task_name, scope)
+        t = lookup(task_name.to_s, scope)
         if t.respond_to? :play_class
           t.play_class
         elsif t.nil?

data/lib/abid/tasks/core.rake

@@ -0,0 +1,85 @@
+namespace :state do
+  task default: :list
+
+  desc 'Show play histories'
+  play :list, extends: Abid::Play do
+    set :volatile, true
+
+    param :started_after, type: :time, default: nil
+    param :started_before, type: :time, default: nil
+
+    def run
+      states = Abid::State.list(
+        started_after: started_after,
+        started_before: started_before
+      )
+
+      table = states.map do |state|
+        params = state[:params].map do |k, v|
+          v.to_s =~ /\s/ ? "#{k}='#{v}'" : "#{k}=#{v}"
+        end.join(' ')
+        [
+          state[:id].to_s,
+          state[:state].to_s,
+          state[:name],
+          params,
+          state[:start_time].to_s,
+          state[:end_time].to_s
+        ]
+      end
+
+      header = %w(id state name params start_time end_time)
+
+      tab_width = header.each_with_index.map do |c, i|
+        [c.length, table.map { |row| row[i].length }.max || 0].max
+      end
+
+      header.each_with_index do |c, i|
+        print c.ljust(tab_width[i] + 2)
+      end
+      puts
+
+      header.each_with_index do |_, i|
+        print '-' * (tab_width[i] + 2)
+      end
+      puts
+
+      table.map do |row|
+        row.each_with_index do |v, i|
+          print v.ljust(tab_width[i] + 2)
+        end
+        puts
+      end
+    end
+  end
+
+  desc 'Insert play history'
+  task :assume, [:task] do |_t, args|
+    task = Rake.application[args[:task]]
+    state = Abid::State.find(task)
+    state.assume
+  end
+
+  desc 'Delete play history'
+  task :revoke do |_t, args|
+    args.extras.each { |id| Abid::State.revoke(id) }
+  end
+end
+
+namespace :db do
+  desc 'Run migrations'
+  task :migrate, [:version] do |_t, args|
+    migrations_path = File.expand_path('../../../../migrations', __FILE__)
+
+    require 'sequel'
+    Sequel.extension :migration
+    db = Rake.application.database
+    if args[:version]
+      puts "Migrating to version #{args[:version]}"
+      Sequel::Migrator.run(db, migrations_path, target: args[:version].to_i)
+    else
+      puts 'Migrating to latest'
+      Sequel::Migrator.run(db, migrations_path)
+    end
+  end
+end

data/lib/abid/version.rb

@@ -1,3 +1,3 @@
 module Abid
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/abid/worker.rb

@@ -3,37 +3,47 @@ module Abid
     def initialize(application)
       @application = application
       @pools = {}
+      @pool_definitions = {}
 
-      default_thread_num = @application.options.thread_pool_size || \
-                           Rake.suggested_thread_count - 1
-      @pools[:default] = Concurrent::FixedThreadPool.new(
-        default_thread_num,
-        idletime: FIXNUM_MAX
-      )
-
+      @pool_definitions[:waiter] = nil
       @pools[:waiter] = Concurrent::SimpleExecutorService.new
+
+      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)
     end
 
     def define(name, thread_count)
       name = name.to_sym
-      fail "worker #{name} already defined" if @pools.include?(name)
-      @pools[name] = Concurrent::FixedThreadPool.new(
-        thread_count,
-        idletime: FIXNUM_MAX
-      )
+      fail "worker #{name} already defined" if @pool_definitions.include?(name)
+      @pool_definitions[name] = thread_count
     end
 
     def [](name)
-      name = (name || :default).to_sym
-      fail "worker #{name} is not defined" unless @pools.include?(name)
-      @pools[name]
-    end
+      unless @pool_definitions.include?(name)
+        fail "worker #{name} is not defined"
+      end
 
+      @pools[name] ||= Concurrent::FixedThreadPool.new(
+        @pool_definitions[name],
+        idletime: FIXNUM_MAX
+      )
+    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