drake 0.8.2.1.0.3 → 0.8.2.1.0.4

data/CHANGES.drake

@@ -1,6 +1,11 @@
 
 = Drake Changelog
 
+== Version 0.8.2.1.0.4
+
+* Fix 21922: prereqs were not namespace-qualified
+* Removed subpackager: no more generated files
+
 == Version 0.8.11.0.1
 
 * Initial release.

data/README

@@ -33,10 +33,11 @@ dependency tree has not been properly defined.  Consider
    task :a => [:x, :y, :z]
 
 With single-threaded Rake, _x_,_y_,_z_ will be invoked <em>in that
-order</em> before _a_ is invoked.  However with
-<code>drake --threads=N</code> (for N > 1), one should not expect any
-particular order of execution.  Since there is no dependency specified
-between _x_,_y_,_z_ above, Drake is free to run them in any order.
+order</em> before _a_ is invoked (assuming there are no other rules
+involving these tasks).  However with <code>drake --threads=N</code>
+(for N > 1), one should not expect any particular order of execution.
+Since there is no dependency specified between _x_,_y_,_z_ above,
+Drake is free to run them in any order.
 
 If you wish _x_,_y_,_z_ to be invoked sequentially, then write
 

data/Rakefile.drake

@@ -5,38 +5,6 @@ require 'quix/subpackager'
 require 'quix/fileutils'
 require 'fileutils'
 
-######################################################################
-# repackage files from contrib/
-
-task :generate_rb do
-  packages = {
-    :rake => {
-      :name_in_ruby => "Rake",
-      :lib_dir => "./lib",
-      :subpackages => {
-        :comp_tree => {
-          :name_in_ruby => "CompTree",
-          :sources => [
-            "driver",
-            "node",
-            "task_node",
-            "error",
-            "bucket_ipc",
-            "algorithm",
-            "retriable_fork",
-            "quix/diagnostic",
-            "quix/kernel",
-            "quix/builtin/kernel/tap",
-          ],
-          :lib_dir => "./contrib/comp_tree/lib",
-          :ignore_root_rb => true,
-        },
-      },
-    },
-  }
-  Quix::Subpackager.run(packages)
-end
-
 ######################################################################
 # git
 
@@ -67,7 +35,7 @@ task :pull_mainline do
           refs/heads/master:refs/heads/origin!)
 end
 
-task :pull_contrib => [ :init_contrib, :run_pull_contrib, :generate_rb ]
+task :pull_contrib => [ :init_contrib, :run_pull_contrib ]
 
 ######################################################################
 # drake_release
@@ -88,7 +56,7 @@ end
 
 def rubyforge(command, file)
   sh("rubyforge",
-     "add_release", 
+     command,
      SPEC.rubyforge_project,
      SPEC.rubyforge_project,
      SPEC.version.to_s,
@@ -96,6 +64,7 @@ def rubyforge(command, file)
 end
 
 task :drake_finish_release do
+  sh("rubyforge", "login")
   Dir.chdir("pkg") {
     gem = "#{SPEC.name}-#{SPEC.version}.gem"
     md5 = "#{gem}.md5"

data/lib/rake.rb

@@ -29,7 +29,7 @@
 # as a library via a require statement, but it can be distributed
 # independently as an application.
 
-RAKEVERSION = '0.8.2.1.0.3'
+RAKEVERSION = '0.8.2.1.0.4'
 
 require 'rbconfig'
 require 'getoptlong'
@@ -595,13 +595,14 @@ module Rake
         end
         return if @already_invoked
         @already_invoked = true
-        invoke_prerequisites(task_args, new_chain)
+        prereqs = application.num_threads == 1 ? nil : Array.new
+        invoke_prerequisites(task_args, new_chain, prereqs)
         if needed?
           if application.num_threads == 1
             execute(task_args) 
           else
             # gather tasks for batch execution
-            application.parallel_tasks[name] = task_args
+            application.parallel_tasks[name] = [task_args, prereqs]
           end
         end
       end
@@ -609,11 +610,12 @@ module Rake
     protected :invoke_with_call_chain
 
     # Invoke all the prerequisites of a task.
-    def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
+    def invoke_prerequisites(task_args, invocation_chain, accum=nil) #:nodoc:
       @prerequisites.each { |n|
         prereq = application[n, @scope]
         prereq_args = task_args.new_scope(prereq.arg_names)
         prereq.invoke_with_call_chain(prereq_args, invocation_chain)
+        accum << prereq if accum
       }
     end
 

data/lib/rake/parallel.rb

@@ -25,14 +25,11 @@ module Rake
         #
         # build the rest of the computation tree from task prereqs
         #
-        parallel_tasks.each_pair { |task_name, task_args|
+        parallel_tasks.each_pair { |task_name, cache|
           task = self[task_name]
-          children_names = task.prerequisites.map { |child|
-            if child_task = (lookup(child) or lookup(child, task.scope))
-              child_task.name.to_sym
-            else
-              raise "couldn't resolve #{task_name} prereq: #{child_name}"
-            end
+          task_args, prereqs = cache
+          children_names = prereqs.map { |child|
+            child.name.to_sym
           }
           driver.define(task_name.to_sym, *children_names) {
             task.execute(task_args)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: drake
 version: !ruby/object:Gem::Version 
-  version: 0.8.2.1.0.3
+  version: 0.8.2.1.0.4
 platform: ruby
 authors: 
 - James M. Lawrence
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-11 00:00:00 -04:00
+date: 2008-09-13 00:00:00 -04:00
 default_executable: drake
 dependencies: []
 
@@ -52,16 +52,6 @@ files:
 - bin/drake
 - lib/rake/classic_namespace.rb
 - lib/rake/clean.rb
-- lib/rake/comp_tree/algorithm.rb
-- lib/rake/comp_tree/bucket_ipc.rb
-- lib/rake/comp_tree/driver.rb
-- lib/rake/comp_tree/error.rb
-- lib/rake/comp_tree/node.rb
-- lib/rake/comp_tree/quix/builtin/kernel/tap.rb
-- lib/rake/comp_tree/quix/diagnostic.rb
-- lib/rake/comp_tree/quix/kernel.rb
-- lib/rake/comp_tree/retriable_fork.rb
-- lib/rake/comp_tree/task_node.rb
 - lib/rake/contrib/compositepublisher.rb
 - lib/rake/contrib/ftptools.rb
 - lib/rake/contrib/publisher.rb

data/lib/rake/comp_tree/algorithm.rb

@@ -1,234 +0,0 @@
-
-
-
-######################################################
-# 
-# **** DO NOT EDIT ****
-# 
-# **** THIS IS A GENERATED FILE *****
-# 
-######################################################
-
-
-
-require 'rake/comp_tree/quix/diagnostic'
-require 'rake/comp_tree/retriable_fork'
-
-module Rake::CompTree
-  module Algorithm
-    include Quix::Diagnostic
-
-    def compute_multithreaded(root, num_threads, use_fork, buckets)
-      trace "Computing #{root.name} with #{num_threads} threads"
-      result = nil
-      mutex = Mutex.new
-      node_finished_condition = ConditionVariable.new
-      thread_wake_condition = ConditionVariable.new
-      threads = []
-      
-      # workaround: jruby gives "run" status for waiting on
-      # condition variable
-      num_threads_ready = 0
-
-      num_threads.times { |thread_index|
-        threads << Thread.new {
-          #
-          # wait for main thread
-          #
-          mutex.synchronize {
-            trace "Thread #{thread_index} waiting to start"
-            num_threads_ready += 1
-            thread_wake_condition.wait(mutex)
-          }
-
-          while true
-            trace "Thread #{thread_index} node search"
-
-            #
-            # Done! Thread will exit.
-            #
-            break if mutex.synchronize {
-              result
-            }
-
-            #
-            # Lock the tree and find a node.  The node we
-            # obtain, if any, is already locked.
-            #
-            node = mutex.synchronize {
-              find_node(root)
-            }
-
-            if node
-              trace "Thread #{thread_index} found node #{node.name}"
-
-              node_result =
-                compute_node(
-                  node,
-                  use_fork,
-                  buckets ? buckets[thread_index] : nil)
-              
-              mutex.synchronize {
-                node.result = node_result
-              }
-
-              #
-              # remove locks for this node (shared lock and own lock)
-              #
-              mutex.synchronize {
-                node.unlock
-                if node == root
-                  #
-                  # Root node was computed; we are done.
-                  #
-                  trace "Thread #{thread_index} got final answer"
-                  result = root.result
-                end
-                node_finished_condition.signal
-              }
-            else
-              trace "Thread #{thread_index}: no node found; sleeping."
-              mutex.synchronize {
-                thread_wake_condition.wait(mutex)
-              }
-            end
-          end
-          trace "Thread #{thread_index} exiting"
-        }
-      }
-
-      trace "Main: waiting for threads to launch and block."
-      while true
-        break if mutex.synchronize {
-          num_threads_ready == num_threads
-        }
-        Thread.pass
-      end
-      
-      trace "Main: entering main loop"
-      mutex.synchronize {
-        while true
-          trace "Main: waking threads"
-          thread_wake_condition.broadcast
-
-          if result
-            trace "Main: detected finish."
-            break
-          end
-
-          trace "Main: waiting for a node"
-          node_finished_condition.wait(mutex)
-          trace "Main: got a node"
-        end
-      }
-
-      trace "Main: waiting for threads to finish."
-      catch(:done) {
-        while true
-          mutex.synchronize {
-            throw :done if threads.all? { |thread|
-              thread.status == false
-            }
-            thread_wake_condition.broadcast
-          }
-          Thread.pass
-        end
-      }
-
-      trace "Main: computation done."
-      result
-    end
-
-    def find_node(node)
-      # --- only called inside mutex
-      trace "Looking for a node, starting with #{node.name}"
-      if node.result
-        #
-        # already computed
-        #
-        trace "#{node.name} has been computed"
-        nil
-      elsif node.children_results and node.try_lock
-        #
-        # Node is not computed and its children are computed;
-        # and we have the lock.  Ready to compute.
-        #
-        node
-      else
-        #
-        # locked or children not computed; recurse to children
-        #
-        trace "Checking #{node.name}'s children"
-        node.each_child { |child|
-          if next_node = find_node(child)
-            return next_node
-          end
-        }
-        nil
-      end
-    end
-
-    def compute_node(node, use_fork, bucket)
-      if use_fork
-        trace "About to fork for node #{node.name}"
-        if bucket
-          #
-          # Use our assigned bucket to transfer the result.
-          #
-          fork_node(node) {
-            node.trace_compute
-            bucket.contents = node.compute
-          }
-          bucket.contents
-        else
-          #
-          # No bucket -- discarding result
-          #
-          fork_node(node) {
-            node.trace_compute
-            node.compute
-          }
-          true
-        end
-      else
-        #
-        # No fork
-        #
-        node.trace_compute
-        node.compute
-      end
-    end
-
-    def fork_node(node)
-      trace "About to fork for node #{node.name}"
-      process_id = RetriableFork.fork {
-        trace "Fork: process #{Process.pid}"
-        node.trace_compute
-        yield
-        trace "Fork: computation done"
-      }
-      trace "Waiting for process #{process_id}"
-      Process.wait(process_id)
-      trace "Process #{process_id} finished"
-      exitstatus = $?.exitstatus
-      if exitstatus != 0
-        trace "Process #{process_id} returned #{exitstatus}; exiting."
-        exit(1)
-      end
-    end
-    
-    extend self
-  end
-end
-
-
-
-######################################################
-# 
-# **** DO NOT EDIT ****
-# 
-# **** THIS IS A GENERATED FILE *****
-# 
-######################################################
-
-

data/lib/rake/comp_tree/bucket_ipc.rb

@@ -1,175 +0,0 @@
-
-
-
-######################################################
-# 
-# **** DO NOT EDIT ****
-# 
-# **** THIS IS A GENERATED FILE *****
-# 
-######################################################
-
-
-
-require 'drb'
-require 'thread'
-
-require 'rake/comp_tree/retriable_fork'
-require 'rake/comp_tree/quix/diagnostic'
-require 'rake/comp_tree/quix/builtin/kernel/tap'
-
-module Rake::CompTree
-  module BucketIPC
-    class Bucket
-      include Quix::Diagnostic
-      include RetriableFork
-
-      def initialize(address, timeout, wait_interval)
-        trace "Making bucket with address #{address}"
-        
-        @remote_pid = fork {
-          own_object = Class.new {
-            attr_accessor(:contents)
-          }.new
-          server = DRb.start_service(address, own_object)
-          debug {
-            server.verbose = true
-          }
-          DRb.thread.join
-        }
-
-        @remote_object = DRbObject.new_with_uri(address)
-        @address = address
-        @timeout = timeout
-        @wait_interval = wait_interval
-      end
-      
-      attr_accessor(:timeout, :wait_interval)
-      attr_reader(:address)
-      
-      def contents=(new_contents)
-        connect {
-          @remote_object.contents = new_contents
-        }
-      end
-      
-      def contents
-        connect {
-          @remote_object.contents
-        }
-      end
-      
-      def stop
-        Process.kill("TERM", @remote_pid)
-      end
-      
-      private
-      
-      def connect
-        begin
-          return yield
-        rescue DRb::DRbConnError
-          start = Time.now
-          begin
-            Kernel.sleep(@wait_interval)
-            return yield
-          rescue DRb::DRbConnError
-            if Time.now - start > @timeout
-              raise
-            end
-            retry
-          end
-        end
-      end
-    end
-
-    class DriverBase
-      def initialize(addresses, timeout, wait_interval)
-        begin
-          @buckets = addresses.map { |address|
-            Bucket.new(address, timeout, wait_interval)
-          }
-          if block_given?
-            yield @buckets
-          end
-        ensure
-          if block_given?
-            stop
-          end
-        end
-      end
-      
-      def stop
-        if defined?(@buckets)
-          @buckets.each { |bucket|
-            bucket.stop
-          }
-        end
-      end
-    end
-
-    class Driver < DriverBase
-      DEFAULTS = {
-        :timeout => 0.5,
-        :wait_interval => 0.05,
-        :port_start => 18181,
-      }
-
-      module BucketCounter
-        @mutex = Mutex.new
-        @count = 0
-        class << self
-          def increment_count
-            @mutex.synchronize {
-              @count += 1
-            }
-          end
-
-          def map_indexes(num_buckets)
-            Array.new.tap { |result|
-              num_buckets.times {
-                result << yield(increment_count)
-              }
-            }
-          end
-        end
-      end
-
-      def initialize(num_buckets, opts_in = {})
-        opts = DEFAULTS.merge(opts_in)
-
-        addresses = 
-          if RetriableFork::HAVE_FORK
-            #
-            # Assume the existence of fork implies a unix machine.
-            #
-            require 'drb/unix'
-            basename = "drbunix://#{Dir.tmpdir}/bucket.#{Process.pid}.#{rand}"
-            BucketCounter.map_indexes(num_buckets) { |index|
-              "#{basename}.#{index}"
-            }
-          else
-            #
-            # Fallback: use the default socket.
-            #
-            BucketCounter.map_indexes(num_buckets) { |index|
-              "druby://localhost:#{opts[:port_start] + index}"
-            }
-          end
-        super(addresses, opts[:timeout], opts[:wait_interval])
-      end
-    end
-  end
-end
-
-
-
-######################################################
-# 
-# **** DO NOT EDIT ****
-# 
-# **** THIS IS A GENERATED FILE *****
-# 
-######################################################
-
-