tengine_job 0.6.9

data/lib/tengine/job/jobnet/builder.rb

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+require 'tsort'
+
+class Tengine::Job::Jobnet::Builder
+  include TSort
+
+  def initialize(client, boot_job_names, redirections)
+    @client, @boot_job_names, @redirections = client, boot_job_names, redirections.dup
+    @graph = Hash.new do |h, k| h[k] = Array.new end
+    @redirections.each do |(x, y)|
+      @graph[x] << y
+    end
+  end
+
+  def children; @client.children; end
+  def child_by_name(*args); @client.child_by_name(*args); end
+  def new_edge(*args); @client.new_edge(*args); end
+  def prepare_end(*args, &block); @client.prepare_end(*args, &block); end
+
+  def process
+    tsort
+  rescue TSort::Cyclic
+    raise Tengine::Job::DslError, "circular dependency found in jobnet ``#{@client.name}''"
+  else
+    build_start_edges
+    build_edge_by_redirections
+    prepare_end do |_end|
+      build_end_edges(_end, @boot_job_names.map{|jn| [:start, jn]} + @redirections)
+    end
+  end
+
+  private
+
+  def tsort_each_child node, &block
+    @graph.fetch(node, Array.new).each(&block)
+  end
+
+  def tsort_each_node(&block)
+    @graph.each_key(&block)
+  end
+
+  def build_start_edges
+    start = children.first
+    case @boot_job_names.length
+    when 0 then raise "Must be a bug!!!"
+    when 1 then
+      new_edge(start, child_by_name(@boot_job_names.first))
+    else
+      fork = Tengine::Job::Fork.new
+      children << fork
+      new_edge(start, fork)
+      @boot_job_names.each do |boot_job_name|
+        new_edge(fork, child_by_name(boot_job_name))
+      end
+    end
+  end
+
+  def build_edge_by_redirections
+    prepare_to_build_edge_by_redirections # 処理の準備
+    build_forks_and_edges      # Forkを生成して特異edge以外を繋ぐ
+    build_joins_and_edges      # Joinを生成して特異edge以外を繋ぐ
+    build_fork_to_join_edges   # 特異edgeの両端になるforkとjoinは生成されているのでそれらを繋ぐ
+    build_normal_edges         # Fork、Join、特異edgeなどに関係しなかった普通のedgeを繋ぐ
+  end
+
+  def prepare_to_build_edge_by_redirections
+    # 各vertexがstartあるいはendとしてそれぞれ何回使われているのかを集計
+    start_vertex_counts = @redirections.inject({}){|d, (_start, _)| d[_start] ||= 0; d[_start] += 1; d}
+    end_vertex_counts   = @redirections.inject({}){|d, (_, _end)| d[_end  ] ||= 0; d[_end  ] += 1; d}
+    # ２回以上startに使われているやつはforkの元、２回以上endに使われているやつはjoinの先になる
+    @fork_origins = start_vertex_counts.delete_if{|_,v| v < 2}.keys
+    @join_destinations = end_vertex_counts.delete_if{|_,v| v < 2}.keys
+    # ForkからJoinへedgeで結ばれる箇所を「特異edge」と呼び、特別扱いする
+    @fork_to_join = []
+    @redirections.each do |(_start, _end)|
+      if @fork_origins.include?(_start) && @join_destinations.include?(_end)
+        @fork_to_join << [_start, _end]
+      end
+    end
+    # puts "=" * 100
+    # puts "fork origins     : " << @fork_origins.inspect
+    # puts "join_destinations: " << @join_destinations.inspect
+    # puts "fork_to_join     : " << @fork_to_join.inspect
+    @no_edge_redirections = @redirections.dup
+  end
+
+  def build_forks_and_edges
+    @fork_origin_to_fork = {}
+    @fork_origins.each do |fork_origin|
+      children << fork = Tengine::Job::Fork.new
+      @fork_origin_to_fork[fork_origin] = fork
+      new_edge(child_by_name(fork_origin), fork)
+      @redirections.dup.
+        delete_if{|r| @fork_to_join.include?(r)}.
+        select{|(_start,_)| _start == fork_origin}.
+        each{|(_, _end)| new_edge(fork, child_by_name(_end))}
+      @no_edge_redirections.delete_if{|_start, _| _start == fork_origin}
+    end
+  end
+
+  def build_joins_and_edges
+    @join_destination_to_join = {}
+    @join_destinations.each do |join_destination|
+      children << join = Tengine::Job::Join.new
+      @join_destination_to_join[join_destination] = join
+      @redirections.dup.
+        delete_if{|r| @fork_to_join.include?(r)}.
+        select{|(_, _end)| _end == join_destination}.
+        each{|(_start, _)| new_edge(child_by_name(_start), join)}
+      new_edge(join, child_by_name(join_destination))
+      @no_edge_redirections.delete_if{|_, _end| _end == join_destination}
+    end
+  end
+
+  def build_fork_to_join_edges
+    @fork_to_join.each do |fork_origin, join_destination|
+      new_edge(
+        @fork_origin_to_fork[fork_origin],
+        @join_destination_to_join[join_destination])
+    end
+  end
+
+  def build_normal_edges
+    @no_edge_redirections.each do |(_start, _end)|
+      new_edge(child_by_name(_start), child_by_name(_end))
+    end
+  end
+
+  def build_end_edges(_end, redirections)
+    end_points = select_end_points(redirections)
+    case end_points.length
+    when 0 then raise "Must be a bug!!!"
+    when 1 then new_edge(child_by_name(end_points.first), _end)
+    else
+      join = Tengine::Job::Join.new
+      children << join
+      end_points.each{|point| new_edge(child_by_name(point), join)}
+      new_edge(join, _end)
+    end
+  end
+
+  def select_end_points(redirections)
+    vertexes = redirections.flatten.uniq
+    redirections.each do |(_start, _end)|
+      vertexes.delete(_start)
+    end
+    vertexes
+  end
+
+end

data/lib/tengine/job/jobnet/job_state_transition.rb

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+require 'tengine/job/jobnet'
+
+module Tengine::Job::Jobnet::JobStateTransition
+  include Tengine::Job::Jobnet::StateTransition
+
+  # ハンドリングするドライバ: ジョブネット制御ドライバ
+  def job_transmit(signal)
+    self.phase_key = :ready
+    self.started_at = signal.event.occurred_at
+    signal.fire(self, :"start.job.job.tengine", {
+        :target_jobnet_id => parent.id,
+        :target_jobnet_name_path => parent.name_path,
+        :target_job_id => self.id,
+        :target_job_name_path => self.name_path,
+      })
+  end
+  available(:job_transmit, :on => :initialized,
+    :ignored => [:ready, :starting, :running, :dying, :success, :error, :stuck])
+
+  # ハンドリングするドライバ: ジョブ制御ドライバ
+  def job_activate(signal)
+    case phase_key
+    when :initialized then
+      # 特別ルール「starting直前stop」
+      # initializedに戻されたジョブに対して、:readyになる際にtransmitで送信されたイベントを受け取って、
+      # activateしようとすると状態は遷移しないが、後続のエッジを実行する。
+      # (エッジを実行しようとした際、エッジがclosedならばそのジョブネットのEndに遷移する。)
+      next_edges.first.transmit(signal)
+    when :ready then
+      complete_origin_edge(signal)
+      self.phase_key = :starting
+      self.started_at = signal.event.occurred_at
+      execution = signal.execution
+      if execution.retry
+        if execution.target_actual_ids.include?(self.id.to_s)
+          execution.ack(signal)
+        elsif execution.target_actuals.map{|t| t.parent.id.to_s if t.parent }.include?(self.parent.id.to_s)
+          # 自身とTengine::Job::Execution#target_actual_idsに含まれるジョブ／ジョブネットと親が同じならば、ackしない
+        else
+          parent.ack(signal)
+        end
+      else
+        parent.ack(signal) # 再実行でない場合
+      end
+      # このコールバックはjob_control_driverでupdate_with_lockの外側から
+      # 再度呼び出してもらうためにcallbackを設定しています
+      signal.callback = lambda{ root.vertex(self.id).activate(signal) }
+    when :starting then
+      # 実際にSSHでスクリプトを実行
+      execution = signal.execution
+      execution.signal = signal # ackを呼び返してもらうための苦肉の策
+      begin
+        run(execution)
+      rescue Tengine::Job::ScriptExecutable::Error => e
+        signal.callback = lambda do
+          job_fail(signal, :message => e.message)
+        end
+      end
+    end
+  end
+  available(:job_activate, :on => [:initialized, :ready, :starting],
+    :ignored => [:running, :dying, :success, :error, :stuck])
+
+  # ハンドリングするドライバ: ジョブ制御ドライバ
+  # スクリプトのプロセスのPIDを取得できたときに実行されます
+  def job_ack(signal)
+    self.executing_pid = (signal.data || {})[:executing_pid]
+    self.phase_key = :running
+  end
+  available(:job_ack, :on => :starting,
+    :ignored => [:running, :dying, :success, :error, :stuck])
+
+  def job_finish(signal)
+    self.exit_status = signal.event[:exit_status]
+    self.finished_at = signal.event.occurred_at
+    (self.exit_status.to_s == '0') ?
+    job_succeed(signal) :
+      job_fail(signal)
+  end
+
+  # ハンドリングするドライバ: ジョブ制御ドライバ
+  def job_succeed(signal)
+    self.phase_key = :success
+    self.finished_at = signal.event.occurred_at
+    signal.fire(self, :"success.job.job.tengine", {
+        :exit_status => self.exit_status,
+        :target_jobnet_id => parent.id,
+        :target_jobnet_name_path => parent.name_path,
+        :target_job_id => self.id,
+        :target_job_name_path => self.name_path,
+      })
+  end
+  available :job_succeed, :on => [:starting, :running, :dying, :stuck], :ignored => [:success]
+
+  # ハンドリングするドライバ: ジョブ制御ドライバ
+  def job_fail(signal, options = nil)
+    self.phase_key = :error
+    if msg = signal.event[:message]
+      self.error_messages ||= []
+      self.error_messages += [msg]
+    end
+    if options && (msg = options[:message])
+      self.error_messages ||= []
+      self.error_messages += [msg]
+    end
+    self.finished_at = signal.event.occurred_at
+    event_options = {
+      :exit_status => self.exit_status,
+      :target_jobnet_id => parent.id,
+      :target_jobnet_name_path => parent.name_path,
+      :target_job_id => self.id,
+      :target_job_name_path => self.name_path,
+    }
+    event_options.update(options) if options
+    signal.fire(self, :"error.job.job.tengine", event_options)
+  end
+  available :job_fail, :on => [:starting, :running, :dying, :stuck], :ignored => [:error]
+
+  def job_fire_stop(signal)
+    signal.fire(self, :"stop.job.job.tengine", {
+        :stop_reason => signal.event[:stop_reason],
+        :target_jobnet_id => parent.id,
+        :target_jobnet_name_path => parent.name_path,
+        :target_job_id => self.id,
+        :target_job_name_path => self.name_path,
+      })
+  end
+  available :job_fire_stop, :on => [:ready, :starting, :running], :ignored => [:initialized, :dying, :success, :error, :stuck]
+
+  def job_stop(signal, &block)
+    case phase_key
+    when :ready then
+      self.phase_key = :initialized
+      self.stopped_at = signal.event.occurred_at
+      self.stop_reason = signal.event[:stop_reason]
+      next_edges.first.transmit(signal)
+    when :starting then
+      job = nil
+      loop do
+        root = self.root.reload # class.find(self.root.id)
+        job = root.find_descendant(self.id)
+        break unless job.phase_key == :starting
+        yield if block_given? # テストの為にyieldしています
+        sleep(0.1)
+      end
+      job.stop(signal, &block)
+    when :running then
+      self.phase_key = :dying
+      self.stopped_at = signal.event.occurred_at
+      self.stop_reason = signal.event[:stop_reason]
+      signal.callback = lambda do
+        kill(signal.execution)
+      end
+    end
+  end
+  available :job_stop, :on => [:ready, :starting, :running], :ignored => [:initialized, :dying, :success, :error, :stuck]
+
+  def job_reset(signal, &block)
+    self.phase_key = :initialized
+    if signal.execution.in_scope?(self)
+      next_edges.first.reset(signal)
+    end
+  end
+  available :job_reset, :on => [:initialized, :success, :error, :stuck]
+
+end

data/lib/tengine/job/jobnet/jobnet_state_transition.rb

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+require 'tengine/job/jobnet'
+
+module Tengine::Job::Jobnet::JobnetStateTransition
+  include Tengine::Job::Jobnet::StateTransition
+
+  # ハンドリングするドライバ: ジョブネット制御ドライバ or ジョブ起動ドライバ
+  def jobnet_transmit(signal)
+    self.phase_key = :ready
+    signal.fire(self, :"start.jobnet.job.tengine", {
+        :target_jobnet_id => self.id,
+        :target_jobnet_name_path => self.name_path,
+      })
+  end
+  available(:jobnet_transmit, :on => :initialized,
+    :ignored => [:ready, :starting, :running, :dying, :success, :error, :stuck])
+
+  # ハンドリングするドライバ: ジョブネット制御ドライバ
+  def jobnet_activate(signal)
+    self.phase_key = :starting
+    self.started_at = signal.event.occurred_at
+    complete_origin_edge(signal) if prev_edges && !prev_edges.empty?
+    (parent || signal.execution).ack(signal)
+    signal.paths << self
+    self.start_vertex.transmit(signal)
+  end
+  available(:jobnet_activate, :on => :ready,
+    :ignored => [:starting, :running, :dying, :success, :error, :stuck])
+
+  # ハンドリングするドライバ: ジョブネット制御ドライバ
+  # このackは、子要素のTengine::Job::Start#activateから呼ばれます
+  def jobnet_ack(signal)
+    self.phase_key = :running
+  end
+  available(:jobnet_ack, :on => [:initialized, :ready, :starting],
+    :ignored => [:running, :dying, :success, :error, :stuck])
+
+  # ハンドリングするドライバ: ジョブネット制御ドライバ
+  # このackは、子要素のTengine::Job::End#activateから呼ばれます
+  def jobnet_finish(signal)
+    edge = end_vertex.prev_edges.first
+    edge.closed? ?
+    jobnet_fail(signal) :
+      jobnet_succeed(signal)
+  end
+
+  # ハンドリングするドライバ: ジョブネット制御ドライバ
+  def jobnet_succeed(signal)
+    self.phase_key = :success
+    self.finished_at = signal.event.occurred_at
+    signal.fire(self, :"success.jobnet.job.tengine", {
+        :target_jobnet_id => self.id,
+        :target_jobnet_name_path => self.name_path,
+      })
+  end
+  available :jobnet_succeed, :on => [:starting, :running, :dying, :stuck, :error], :ignored => [:success]
+
+  # ハンドリングするドライバ: ジョブネット制御ドライバ
+  def jobnet_fail(signal)
+    return if self.edges.any?(&:alive?)
+    self.phase_key = :error
+    self.finished_at = signal.event.occurred_at
+    signal.fire(self, :"error.jobnet.job.tengine", {
+        :target_jobnet_id => self.id,
+        :target_jobnet_name_path => self.name_path,
+      })
+  end
+  available :jobnet_fail, :on => [:starting, :running, :dying, :stuck, :success], :ignored => [:error]
+
+  def jobnet_fire_stop(signal)
+    return if self.phase_key == :initialized
+    signal.fire(self, :"stop.jobnet.job.tengine", {
+        :target_jobnet_id => self.id,
+        :target_jobnet_name_path => self.name_path,
+        :stop_reason => signal.event[:stop_reason]
+      })
+  end
+
+  def jobnet_stop(signal)
+    self.phase_key = :dying
+    self.stopped_at = signal.event.occurred_at
+    self.stop_reason = signal.event[:stop_reason]
+    close(signal)
+    children.each do |child|
+      child.fire_stop(signal) if child.respond_to?(:fire_stop)
+    end
+  end
+  available :jobnet_stop, :on => [:initialized, :ready, :starting, :running], :ignored => [:dying, :success, :error, :stuck]
+
+  def close(signal)
+    self.edges.each{|edge| edge.close(signal)}
+  end
+
+
+  def jobnet_reset(signal, &block)
+    # children.each{|c| c.reset(signal) }
+    self.phase_key = :initialized
+    if s = start_vertex
+      s.reset(signal)
+    end
+    if edge = (next_edges || []).first
+      edge.reset(signal)
+    end
+  rescue Exception => e
+    puts "#{self.name_path} [#{e.class}] #{e.message}"
+    raise
+  end
+  available :jobnet_reset, :on => [:initialized, :success, :error, :stuck]
+
+end

data/lib/tengine/job/jobnet/state_transition.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+require 'tengine/job/jobnet'
+
+module Tengine::Job::Jobnet::StateTransition
+
+  def self.included(mod)
+    mod.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def available(method_name, options = {})
+      original_method = :"__#{method_name}_without_ignore_and_na"
+      available_phase_keys = Array(options[:on])
+      ignored_phase_keys = Array(options[:ignored])
+      ignore_case = ignored_phase_keys.empty? ? "" :
+        "when #{ignored_phase_keys.map(&:inspect).join(', ')} then return"
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        if method_defined?(:#{original_method})
+          raise "Already available_on #{method_name}"
+        end
+        alias #{original_method} #{method_name}
+
+        def #{method_name}(*args, &block)
+          case self.phase_key
+          when #{available_phase_keys.map(&:inspect).join(', ')} then
+            #{original_method}(*args, &block)
+          #{ignore_case}
+          else
+            raise Tengine::Job::Executable::PhaseError, "\#{name_path} \#{self.class.name}##{method_name} not available when the phase_key of \#{self.name_path.inspect} is \#{self.phase_key.inspect}"
+          end
+        end
+      EOS
+
+    end
+  end
+
+end