Module: Pwrake::TaskAlgorithm

Defined in:
lib/pwrake/task/task_algorithm.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#arguments ⇒ Object (readonly)

Returns the value of attribute arguments.



10
11
12
 
# File 'lib/pwrake/task/task_algorithm.rb', line 10

def arguments
  @arguments
end

#property ⇒ Object (readonly)

Returns the value of attribute property.



11
12
13
 
# File 'lib/pwrake/task/task_algorithm.rb', line 11

def property
  @property
end

#subsequents ⇒ Object (readonly)

Returns the value of attribute subsequents.



9
10
11
 
# File 'lib/pwrake/task/task_algorithm.rb', line 9

def subsequents
  @subsequents
end

#unfinished_prereq ⇒ Object (readonly)

Returns the value of attribute unfinished_prereq.



12
13
14
 
# File 'lib/pwrake/task/task_algorithm.rb', line 12

def unfinished_prereq
  @unfinished_prereq
end

#wrapper ⇒ Object (readonly)

Returns the value of attribute wrapper.



8
9
10
 
# File 'lib/pwrake/task/task_algorithm.rb', line 8

def wrapper
  @wrapper
end

Instance Method Details

#check_prereq_finished(preq_name = nil) ⇒ Object 



99
100
101
102
 
# File 'lib/pwrake/task/task_algorithm.rb', line 99

def check_prereq_finished(preq_name=nil)
  @unfinished_prereq.delete(preq_name)
  @unfinished_prereq.empty?
end

#pw_enq_subsequents ⇒ Object 



84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/pwrake/task/task_algorithm.rb', line 84

def pw_enq_subsequents
  #t = Time.now
  #h = application.pwrake_options['HALT_QUEUE_WHILE_SEARCH']
  #application.task_queue.synchronize(h) do
    @subsequents.each do |t|        # <<--- competition !!!
      #u = t.unfinished_prereq.keys
      #Log.debug "enq_subseq: self=#{self.name} subseq=#{t.name} @unfin_preq=#{u.inspect}"
      if t && t.check_prereq_finished(self.name)
        application.task_queue.enq(t.wrapper)
      end
    end
  #end
  @already_finished = true        # <<--- competition !!!
end

#pw_search_tasks(args) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/pwrake/task/task_algorithm.rb', line 14

def pw_search_tasks(args)
  Log.debug "#{self.class}#pw_search_tasks start, args=#{args.inspect}"
  tm = Time.now
  task_args = TaskArguments.new(arg_names, args)
  #timer = Timer.new("search_task")
  #h = application.pwrake_options['HALT_QUEUE_WHILE_SEARCH']
  #application.task_queue.synchronize(h) do
	search_with_call_chain(nil, task_args, InvocationChain::EMPTY)
  #end
  #timer.finish
  Log.debug "#{self.class}#pw_search_tasks end #{Time.now-tm}"
end

#pw_set_property(property) ⇒ Object 



104
105
106
107
 
# File 'lib/pwrake/task/task_algorithm.rb', line 104

def pw_set_property(property)
  @property = property
  self
end

#search_prerequisites(task_args, invocation_chain) ⇒ Object

Search all the prerequisites of a task.



63
64
65
66
67
68
69
70
71
72
 
# File 'lib/pwrake/task/task_algorithm.rb', line 63

def search_prerequisites(task_args, invocation_chain) # :nodoc:
  @unfinished_prereq = {}
  @prerequisites.each{|t| @unfinished_prereq[t]=true}
  prerequisite_tasks.each { |prereq|
    prereq_args = task_args.new_scope(prereq.arg_names)
    if prereq.search_with_call_chain(self, prereq_args, invocation_chain)
      @unfinished_prereq.delete(prereq.name)
    end
  }
end

#search_with_call_chain(subseq, task_args, invocation_chain) ⇒ Object

Same as search, but explicitly pass a call chain to detect circular dependencies.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/pwrake/task/task_algorithm.rb', line 29

def search_with_call_chain(subseq, task_args, invocation_chain) # :nodoc:
  new_chain = InvocationChain.append(self, invocation_chain)
  @lock.synchronize do
    if application.options.trace
      #Log.info "** Search #{name} #{format_search_flags}"
      application.trace "** Search #{name} #{format_search_flags}"
    end

    return true if @already_finished # <<--- competition !!!
    @subsequents ||= []
    @subsequents << subseq if subseq # <<--- competition !!!

    if ! @already_searched
      @already_searched = true
      @arguments = task_args
      @wrapper = TaskWrapper.new(self,task_args)
      if @prerequisites.empty?
        @unfinished_prereq = {}
      else
        search_prerequisites(task_args, new_chain)
      end
      #check_and_enq
      if @unfinished_prereq.empty?
        application.task_queue.enq(@wrapper)
      end
    end
    return false
  end
rescue Exception => ex
  add_chain_to(ex, new_chain)
  raise ex
end