bob 0.1 → 0.4.0

data/README.rdoc

@@ -1,51 +1,6 @@
 = Bob the Builder
 
-Given a Buildable object with the following public API:
-
-* <tt>buildable.kind</tt>
-
-  Should return a Symbol with whatever kind of repository the buildable's code is
-  in (:git, :svn, etc).
-
-* <tt>buildable.uri</tt>
-
-  Returns a string like "git://github.com/integrity/bob.git", pointing to the code
-  repository.
-
-* <tt>buildable.branch</tt>
-
-  What branch of the repository should we build?
-
-* <tt>buildable.build_script</tt>
-
-  Returns a string containing the build script to be run when "building".
-
-* <tt>buildable.start_building(commit_id)</tt>
-
-  `commit_id` is a String that contains whatever is appropriate for the repo type,
-  so it would be a SHA1 hash for git repos, or a numeric id for svn, etc. This is a
-  callback so the buildable can determine how long it takes to build. It doesn't
-  need to return anything.
-
-* <tt>buildable.finish_building(commit_id, build_status, build_output)</tt>
-
-  Callback for when the build finishes. It doesn't need to return anything. It will
-  receive a string with the commit identifier, a boolean for the build exit status
-  (true for successful builds, false fore failed ones) and a string with the build
-  output (both STDOUT and STDERR).
-
-  A successful build is one where the build script returns a zero status code.
-
-Bob will, when called like:
-
-    Bob.build(buildable, commit_id)
-
-1. Checkout the buildable on the specified commit
-2. Call <tt>buildable.start_building</tt>
-3. Run the script provided in <tt>build_script</tt> in the buildable.
-4. When the build process finishes, it will call <tt>finish_building</tt> with
-   the commit_id, the build status (true if the script returns a status code
-   of 0, false otherwise), and a string with the build output (both STDOUT and STDERR).
+Bob builds your code.
 
 == Do I need this?
 
@@ -54,5 +9,6 @@ automated CI server, which is what most people need.
 
 == Credits
 
+Thanks a lot to raggi[http://github.com/raggi] for the threaded engine.
 Authors:: Nicolas Sanguinetti (foca[http://github.com/foca]) and Simon Rozet (sr[http://github.com/sr])
 License:: MIT (Check LICENSE for details)

data/Rakefile

@@ -1,13 +1,14 @@
 require "rake/testtask"
 
+rdoc_sources = %w(hanna/rdoctask rdoc/task rake/rdoctask)
 begin
-  require "hanna/rdoctask"
+  require rdoc_sources.shift
 rescue LoadError
-  require "rake/rdoctask"
+  retry
 end
 
 begin
-  require "metric_fu"
+  require "metric_fu" if RUBY_VERSION < "1.9"
 rescue LoadError
 end
 
@@ -20,23 +21,14 @@ end
 desc "Default: run all tests"
 task :default => :test
 
-SCMs = %w[git svn]
-
-desc "Run unit tests"
-task :test => SCMs.map { |scm| "test:#{scm}" } do
-  ruby "test/bob_test.rb"
-  ruby "test/background_engine/threaded_test.rb"
+desc "Run tests"
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList["test/*_test.rb"]
+  t.libs << "test"
 end
 
-SCMs.each { |scm|
-  desc "Run unit tests with #{scm}"
-  task "test:#{scm}" do
-    ruby "test/scm/#{scm}_test.rb"
-  end
-}
-
-Rake::RDocTask.new do |rd|
-  rd.main = "README"
+(defined?(RDoc::Task) ? RDoc::Task : Rake::RDocTask).new do |rd|
+  rd.main = "README.rdoc"
   rd.title = "Documentation for Bob the Builder"
   rd.rdoc_files.include("README.rdoc", "LICENSE", "lib/**/*.rb")
   rd.rdoc_dir = "doc"

data/bob.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name    = "bob"
-  s.version = "0.1"
-  s.date    = "2009-04-12"
+  s.version = "0.4.0"
+  s.date    = "2009-10-10"
 
   s.description = "Bob the Builder will build your code. Simple."
   s.summary     = "Bob builds!"
@@ -17,30 +17,31 @@ Gem::Specification.new do |s|
 
   s.add_dependency "addressable"
 
-  if s.respond_to?(:add_development_dependency)
-    s.add_development_dependency "sr-mg"
-    s.add_development_dependency "contest"
-    s.add_development_dependency "redgreen"
-    s.add_development_dependency "ruby-debug"
-  end
-
   s.files = %w[
 .gitignore
 LICENSE
 README.rdoc
 Rakefile
 bob.gemspec
+deps.rip
 lib/bob.rb
-lib/bob/background_engines.rb
-lib/bob/background_engines/foreground.rb
 lib/bob/builder.rb
+lib/bob/engine.rb
+lib/bob/engine/threaded.rb
 lib/bob/scm.rb
 lib/bob/scm/abstract.rb
 lib/bob/scm/git.rb
-lib/core_ext/object.rb
+lib/bob/scm/svn.rb
+lib/bob/test.rb
+lib/bob/test/builder_stub.rb
+lib/bob/test/repo.rb
 test/bob_test.rb
+test/deps.rip
+test/engine/threaded_test.rb
+test/git_test.rb
 test/helper.rb
-test/helper/git_helper.rb
-test/helper/buildable_stub.rb
+test/mixin/scm.rb
+test/svn_test.rb
+test/test_test.rb
 ]
 end

data/deps.rip

@@ -0,0 +1 @@
+addressable 2.1.0

data/lib/bob.rb

@@ -1,4 +1,5 @@
 require "fileutils"
+require "pathname"
 require "yaml"
 require "logger"
 require "time"
@@ -6,31 +7,28 @@ require "addressable/uri"
 
 require "bob/builder"
 require "bob/scm"
-require "bob/background_engines"
+require "bob/engine"
 
 module Bob
-  # Builds the specified <tt>buildable</tt>. This object must understand
-  # the API described in the README.
-  def self.build(buildable, commit_ids)
-    Array(commit_ids).each do |commit_id|
-      Builder.new(buildable, commit_id).build
-    end
+  def self.build(buildable)
+    Builder.new(buildable).build
   end
 
-  # Directory where the code for the different buildables will be checked out. Make sure
-  # the user running Bob is allowed to write to this directory.
+  # Directory where the code for the different buildables will be checked out.
+  # Make sure the user running Bob is allowed to write to this directory.
   def self.directory
-    @directory || "/tmp"
+    Pathname(@directory || "/tmp")
   end
 
-  # What will you use to build in background. Must respond to <tt>call</tt> and take a block
-  # which will be run "in background". The default is to run in foreground.
+  # What will you use to build in background. Must respond to <tt>call</tt> and
+  # take a block which will be run "in background". The default is to run in
+  # foreground.
   def self.engine
-    @engine || BackgroundEngines::Foreground
+    @engine || Engine::Foreground
   end
 
-  # What to log with (must implement ruby's Logger interface). Logs to STDOUT by
-  # default.
+  # What to log with (must implement ruby's Logger interface). Logs to STDOUT
+  # by default.
   def self.logger
     @logger || Logger.new(STDOUT)
   end

data/lib/bob/builder.rb

@@ -1,53 +1,42 @@
 module Bob
-  # A Builder will take care of building a buildable (wow, you didn't see that coming,
-  # right?).
   class Builder
-    attr_reader :buildable, :commit_id
+    attr_reader :buildable
 
-    def initialize(buildable, commit_id)
+    def initialize(buildable)
       @buildable = buildable
-      @commit_id = commit_id
     end
 
-    # This is where the magic happens:
-    #
-    # 1. Check out the repo to the appropriate commit.
-    # 2. Notify the buildable that the build is starting.
-    # 3. Run the build script on it in the background.
-    # 4. Reports the build back to the buildable.
     def build
-      Bob.logger.info "Building #{commit_id} of the #{buildable.kind} repo at #{buildable.uri}"
-      in_background do
-        scm.with_commit(commit_id) do
-          buildable.start_building(commit_id, scm.info(commit_id))
-          build_status, build_output = run_build_script
-          buildable.finish_building(commit_id, build_status, build_output)
-        end
-      end
+      scm.with_commit(buildable["commit"]) { |commit|
+        started(scm.info(commit))
+        completed(*run)
+      }
     end
 
-    private
+    protected
+      def started(commit_info)
+      end
 
-    def run_build_script
-      build_output = nil
+      def completed(status, output)
+      end
 
-      Bob.logger.debug "Running the build script for #{buildable.uri}"
-      IO.popen(build_script, "r") { |output| build_output = output.read }
-      Bob.logger.debug("Ran build script `#{build_script}` and got:\n#{build_output}")
+    private
+      def run
+        output = ""
+        status = false
 
-      [$?.success?, build_output]
-    end
+        IO.popen(script, "r") { |io| output = io.read }
+        status = $?.success?
 
-    def build_script
-      "(cd #{scm.working_dir} && #{buildable.build_script} 2>&1)"
-    end
+        [status, output]
+      end
 
-    def scm
-      @scm ||= SCM.new(buildable.kind, buildable.uri, buildable.branch)
-    end
+      def script
+        "(cd #{scm.dir_for(buildable["commit"])} && #{buildable["command"]} 2>&1)"
+      end
 
-    def in_background(&block)
-      Bob.engine.call(block)
-    end
+      def scm
+        @scm ||= SCM.new(buildable["scm"], buildable["uri"], buildable["branch"])
+      end
   end
 end

data/lib/bob/{background_engines.rb → engine.rb}

@@ -2,8 +2,8 @@ module Bob
   # Different engines to run code in background. An engine is any object
   # that responds to #call and takes a Proc object, which should be executed
   # "in the background". The different engines are:
-  module BackgroundEngines
-    autoload :Foreground, "bob/background_engines/foreground"
-    autoload :Threaded, "bob/background_engines/threaded"
+  module Engine
+    autoload :Threaded, "bob/engine/threaded"
+    Foreground = lambda {|b| b.call }
   end
 end

data/lib/bob/engine/threaded.rb

@@ -0,0 +1,145 @@
+require "thread"
+
+module Bob
+  module Engine
+    # A thread pool based build engine. This engine simply adds jobs to an
+    # in-memory queue, and processes them as soon as possible.
+    class Threaded
+      # The optional pool size controls how many threads will be created.
+      def initialize(pool_size = 2, logger = Bob.logger)
+        @pool   = ThreadPool.new(pool_size, logger)
+        @logger = logger
+      end
+
+      # Adds a job to the queue.
+      def call(job)
+        @pool << job
+      end
+
+      # The number of jobs currently in the queue.
+      def njobs
+        @pool.njobs
+      end
+
+      # This method will not return until #njobs returns 0.
+      def wait!
+        Thread.pass until @pool.njobs == 0
+      end
+
+      # Manage a pool of threads, allowing for spin up / spin down of the
+      # contained threads.
+      # Simply processes work added to it's queue via #push.
+      # The default size for the pool is 2 threads.
+      class ThreadPool
+        # A thread safe single value for use as a counter.
+        class Incrementor
+          # The value passed in will be the initial value.
+          def initialize(v = 0)
+            @m = Mutex.new
+            @v = v
+          end
+
+          # Add the given value to self, default 1.
+          def inc(v = 1)
+            sync { @v += v }
+          end
+
+          # Subtract the given value to self, default 1.
+          def dec(v = 1)
+            sync { @v -= v }
+          end
+
+          # Simply shows the value inspect for convenience.
+          def inspect
+            @v.inspect
+          end
+
+          # Extract the value.
+          def to_i
+            @v
+          end
+
+          private
+
+          # Wrap the given block in a mutex.
+          def sync(&b)
+            @m.synchronize &b
+          end
+        end
+
+        # The number of threads in the pool.
+        attr_reader :size
+
+        # The job queue.
+        attr_reader :jobs
+
+        # Set the size of the thread pool. Asynchronously run down threads
+        # that are no longer required, and synchronously spawn new required
+        # threads.
+        def size=(other)
+          @size = other
+
+          if @workers.size > @size
+            (@workers.size - @size).times do
+              @workers.shift[:run] = false
+            end
+          else
+            (@size - @workers.size).times do
+              @workers << spawn
+            end
+          end
+        end
+
+        # Default pool size is 2 threads.
+        def initialize(size = nil, logger = Bob.logger)
+          size ||= 2
+          @jobs    = Queue.new
+          @njobs   = Incrementor.new
+          @workers = Array.new(size) { spawn }
+          @logger  = logger
+        end
+
+        # Adds a job to the queue, the job can be any number of objects
+        # responding to call, and/or a block.
+        def add(*jobs, &blk)
+          jobs = jobs + Array(blk)
+
+          jobs.each do |job|
+            @jobs << job
+            @njobs.inc
+          end
+        end
+
+        alias_method :push, :add
+        alias_method :<<,   :add
+
+        # A peak at the number of jobs in the queue. N.B. May differ, but
+        # should be more accurate than +jobs.size+.
+        def njobs
+          @njobs.to_i
+        end
+
+        private
+
+        # Create a new thread and return it. The thread will run until the
+        # thread-local value +:run+ is changed to false or nil.
+        def spawn
+          Thread.new do
+            c = Thread.current
+            c[:run] = true
+
+            while c[:run]
+              job = @jobs.pop
+              begin
+                job.call
+              rescue Exception => e
+                @logger.error("Exception occured during build: #{e.message}")
+              end
+              @njobs.dec
+            end
+          end
+        end
+      end
+    end
+  end
+end