crazy_ivan 0.3.3 → 1.0.0

data/README.rdoc

@@ -7,11 +7,11 @@ Crazy Ivan (CI) is simplest possible continuous integration tool.
   Create a directory where your projects will live
     $ mkdir /var/continuous-integration
   
-  Setup a project or two in that directory
+  Place some project(s) in that directory
     $ cd /var/continuous-integration
     $ git clone git://github.com/edward/active_merchant.git
   
-  Setup continuous-integration for each project
+  Set up continuous integration for each project
     $ crazy_ivan setup  # creates example ci scripts in 
                         # each project (see How this works)
     
@@ -48,7 +48,7 @@ Crazy Ivan (CI) is simplest possible continuous integration tool.
         of these dirs    /active_merchant
              ========>   /active_shipping
 
-    => within each directory, it expects three executable scripts
+    => within each directory, it expects four executable scripts
        to execute at the /:
        
           /shopify
@@ -56,6 +56,7 @@ Crazy Ivan (CI) is simplest possible continuous integration tool.
               update
               version
               test
+              conclusion
 
   * crazy_ivan first executes `update` and captures the output:
   
@@ -85,6 +86,9 @@ Crazy Ivan (CI) is simplest possible continuous integration tool.
   * At each of these three steps, the output is repackaged
     into a .json file to be consumed in the directory holding
     the static html.
+  
+  * crazy_ivan then executes `conclusion`, passing it the same results packaged
+    in the .json file used in the static html view.
 
 
 == Copyright and Credits

data/Rakefile

@@ -11,12 +11,16 @@ begin
     By keeping test reports in json, per-project CI configuration in 3 probably-one-line scripts, things are kept simple, quick, and super extensible.
 
     Want to use git, svn, or hg? No problem.
-    Need to fire off results to Twitter or Campfire? It's one line away.
+    Need to fire off results to Campfire? It's built-in.
 
     CI depends on cron."
     gem.email = "edward@edwardog.net"
     gem.homepage = "http://github.com/edward/crazy_ivan"
     gem.authors = ["Edward Ocampo-Gooding"]
+    gem.executables = ["crazy_ivan", "test_report2campfire"]
+    gem.default_executable = "crazy_ivan"
+    gem.files = FileList['.gitignore', '*.gemspec', 'lib/**/*', 'bin/*', 'templates/**/*', '[A-Z]*', 'test/**/*'].to_a
+    
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   

data/TODO

@@ -30,4 +30,10 @@
 
 * Use datejs to parse the timestamp to easily produce deltas (i.e. "Last test ran 2 days ago")
 
-* Do something like use a file-lock to prevent overlapping runs and notify in the index.html that it's happening
+* Do something like use a file-lock to prevent overlapping runs and notify in the index.html that it's happening
+
+* Write a man page with Ron: http://github.com/rtomayko/ron
+
+* Refactor and document Syslog to have method names that actually match the syslog levels (like #error instead of #err )
+
+* Don't overwrite existing config files and warn when skipping

data/VERSION

@@ -1 +1 @@
-0.3.3
+1.0.0

data/bin/test_report2campfire

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+# This code nabbed from http://developer.37signals.com/campfire/ [http://developer.37signals.com/campfire/campfire.rb]
+
+require 'rubygems'
+require 'uri'
+require 'httparty'
+require 'json'
+
+class Campfire
+  include HTTParty
+
+  base_uri   'https://37s.campfirenow.com'
+  basic_auth 'find_your_auth_key_on_member_slash_edit', 'x'
+  headers    'Content-Type' => 'application/json'
+
+  def self.rooms
+    Campfire.get('/rooms.json')["rooms"]
+  end
+
+  def self.room(room_id)
+    Room.new(room_id)
+  end
+
+  def self.user(id)
+    Campfire.get("/users/#{id}.json")["user"]
+  end
+end
+
+class Room
+  attr_reader :room_id
+
+  def initialize(room_id)
+    @room_id = room_id
+  end
+
+  def join
+    post 'join'
+  end
+
+  def leave
+    post 'leave'
+  end
+
+  def lock
+    post 'lock'
+  end
+
+  def unlock
+    post 'unlock'
+  end
+
+  def message(message)
+    send_message message
+  end
+
+  def paste(paste)
+    send_message paste, 'PasteMessage'
+  end
+
+  def play_sound(sound)
+    send_message sound, 'SoundMessage'
+  end
+
+  def transcript
+    get('transcript')['messages']
+  end
+
+  private
+
+  def send_message(message, type = 'Textmessage')
+    post 'speak', :body => {:message => {:body => message, :type => type}}.to_json
+  end
+
+  def get(action, options = {})
+    Campfire.get room_url_for(action), options
+  end
+
+  def post(action, options = {})
+    Campfire.post room_url_for(action), options
+  end
+
+  def room_url_for(action)
+    "/room/#{room_id}/#{action}.json"
+  end
+end
+
+report = JSON.parse(STDIN.read)
+
+campfire_url = URI.parse(ARGV[0])
+Campfire.base_uri campfire_url.scheme + '://' + campfire_url.host
+Campfire.basic_auth ARGV[1], 'x'
+
+campfire_room_id = campfire_url.path[/\d+/]
+campfire_room = Campfire.room(campfire_room_id)
+campfire_room.message "#{report['project_name']} broke. Please take a look at #{ARGV[2]}"

data/crazy_ivan.gemspec

@@ -5,22 +5,22 @@
 
 Gem::Specification.new do |s|
   s.name = %q{crazy_ivan}
-  s.version = "0.3.3"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Edward Ocampo-Gooding"]
-  s.date = %q{2009-11-30}
+  s.date = %q{2010-01-10}
   s.default_executable = %q{crazy_ivan}
   s.description = %q{Continuous integration should really just be a script that captures the output of running your project update & test commands and presents recent results in a static html page.
 
     By keeping test reports in json, per-project CI configuration in 3 probably-one-line scripts, things are kept simple, quick, and super extensible.
 
     Want to use git, svn, or hg? No problem.
-    Need to fire off results to Twitter or Campfire? It's one line away.
+    Need to fire off results to Campfire? It's built-in.
 
     CI depends on cron.}
   s.email = %q{edward@edwardog.net}
-  s.executables = ["crazy_ivan"]
+  s.executables = ["crazy_ivan", "test_report2campfire"]
   s.extra_rdoc_files = [
     "LICENSE",
      "README.rdoc",
@@ -34,6 +34,7 @@ Gem::Specification.new do |s|
      "TODO",
      "VERSION",
      "bin/crazy_ivan",
+     "bin/test_report2campfire",
      "crazy_ivan.gemspec",
      "lib/crazy_ivan.rb",
      "lib/crazy_ivan/html_asset_crush.rb",
@@ -154,6 +155,20 @@ Gem::Specification.new do |s|
      "lib/crazy_ivan/vendor/json-1.1.7/tools/fuzz.rb",
      "lib/crazy_ivan/vendor/json-1.1.7/tools/server.rb",
      "lib/crazy_ivan/vendor/json.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/README",
+     "lib/crazy_ivan/vendor/open4-1.0.1/README.erb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/Rakefile",
+     "lib/crazy_ivan/vendor/open4-1.0.1/lib/open4.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/open4.gemspec",
+     "lib/crazy_ivan/vendor/open4-1.0.1/samples/bg.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/samples/block.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/samples/exception.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/samples/simple.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/samples/spawn.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/samples/stdin_timeout.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/samples/timeout.rb",
+     "lib/crazy_ivan/vendor/open4-1.0.1/white_box/leak.rb",
+     "lib/crazy_ivan/vendor/open4.rb",
      "lib/crazy_ivan/version.rb",
      "templates/css/ci.css",
      "templates/index.html",

data/lib/crazy_ivan/report_assembler.rb

@@ -3,21 +3,46 @@ class ReportAssembler
   ROOT_PATH = File.expand_path(File.dirname(__FILE__))
   TEMPLATES_PATH = File.join(ROOT_PATH, *%w[.. .. templates])
   
-  attr_accessor :test_results
+  attr_accessor :runners
   
-  def initialize(output_directory)
-    @test_results = []
+  def initialize(projects_directory, output_directory)
+    @runners = []
+    @projects_directory = projects_directory
     @output_directory = output_directory
   end
   
   def generate
-    Dir.chdir(@output_directory) do
-      @test_results.each do |result|
-        update_project(result)
+    Dir.chdir(@projects_directory) do
+      Dir['*'].each do |dir|
+        if File.directory?(dir)
+          runners << TestRunner.new(File.join(@projects_directory, dir))
+        end
       end
-      
-      update_projects
+    end
+    
+    Dir.chdir(@output_directory) do
       update_index
+      update_projects
+      
+      runners.each do |runner|
+        # REFACTOR to run this block in multiple threads to have multi-project testing
+      
+        # Write the first version of the report with just the start time to currently_building.json
+        runner.start!
+        update_project(runner)
+
+        # Update the report in currently_building.json with the update output and error
+        runner.update!
+        update_project(runner)
+
+        # Update the report in currently_building.json with the version output and error
+        runner.version!
+        update_project(runner)
+
+        # Empty the currently_building.json and add to recents.json this new report with the test output and error
+        runner.test!
+        update_project(runner)
+      end
     end
   end
   
@@ -28,30 +53,55 @@ class ReportAssembler
       s += "-#{Dir["#{s}*.json"].size}"
     end
     
-    s
+    return s
+  end
+  
+  def nullify_successful_exit_status_for_json_templates(results)
+    filtered_results = YAML.load(results.to_yaml)
+    
+    filtered_results[:version][:exit_status] = nil if filtered_results[:version][:exit_status] == '0'
+    filtered_results[:update][:exit_status] = nil if filtered_results[:update][:exit_status] == '0'
+    filtered_results[:test][:exit_status] = nil if filtered_results[:test][:exit_status] == '0'
+    
+    return filtered_results
+  end
+  
+  def flush_build_progress
+    File.open("currently_building.json", 'w+') do |f|
+      f.puts({}.to_json)
+    end
   end
   
-  def update_project(result)
-    FileUtils.mkdir_p(result.project_name)
-    Dir.chdir(result.project_name) do
-      filename = filename_from_version(result.version_output)
+  def update_project(runner)
+    FileUtils.mkdir_p(runner.project_name)
+    Dir.chdir(runner.project_name) do
+      
+      filename = ''
+      
+      if runner.still_building?
+        filename = 'currently_building'
+      else
+        if runner.results[:version][:exit_status] == '0'
+          filename = filename_from_version(runner.results[:version][:output])
+        else
+          filename = filename_from_version(runner.results[:version][:error])
+        end
+      end
+      
       File.open("#{filename}.json", 'w+') do |f|
-        f.puts({
-                 "version" => [result.version_error, result.version_output].join,
-                 "timestamp" => result.timestamp,
-                 "update" => result.update_output,
-                 "update_error" => result.update_error,
-                 "test" => result.test_output,
-                 "test_error" => result.test_error
-               }.to_json)
+        f.puts(nullify_successful_exit_status_for_json_templates(runner.results).to_json)
       end
       
-      update_recent(result, filename)
+      if runner.finished?
+        Syslog.debug "Runner is FINISHED"
+        flush_build_progress
+        update_recent(runner.results, filename)
+      end
     end
   end
   
   def update_recent(result, filename)
-    recent_versions_json = File.open('recent.json', File::RDWR|File::CREAT).read
+    recent_versions_json = File.open('recent.json', File::RDWR | File::CREAT).read
     
     recent_versions = []
     
@@ -68,7 +118,7 @@ class ReportAssembler
   end
   
   def update_projects
-    projects = @test_results.map {|r| "#{r.project_name}"}
+    projects = @runners.map {|r| r.project_name }
     
     File.open('projects.json', 'w+') do |f|
       f.print({"projects" => projects}.to_json)

data/lib/crazy_ivan/test_runner.rb

@@ -1,19 +1,26 @@
 require 'open3'
 
 class TestRunner
-
-  class Result < Struct.new(:project_name, :version_output, :update_output, :test_output, :version_error, :update_error, :test_error, :timestamp)
-  end
-  
   def initialize(project_path)
     @project_path = project_path
+    @results = {:project_name => File.basename(@project_path),
+                :version => {:output => '', :error => '', :exit_status => ''},
+                :update  => {:output => '', :error => '', :exit_status => ''},
+                :test    => {:output => '', :error => '', :exit_status => ''},
+                :timestamp => {:start => nil, :finish => nil}}
+  end
+  
+  attr_reader :results
+  
+  def project_name
+    @results[:project_name]
   end
 
-  def valid?
+  def check_for_valid_scripts
     check_script('update')
     check_script('version')
     check_script('test')
-    return true
+    check_script('conclusion')
   end
   
   def script_path(name)
@@ -39,40 +46,79 @@ class TestRunner
   def run_script(name)
     output = ''
     error = ''
+    exit_status = ''
     
     Dir.chdir(@project_path) do
-      Open3.popen3(script_path(name)) do |stdin, stdout, stderr|
+      status = Open4::popen4(script_path(name)) do |pid, stdin, stdout, stderr|
         stdin.close  # Close to prevent hanging if the script wants input
         output = stdout.read
         error = stderr.read
       end
+      
+      exit_status = status.exitstatus
     end
     
-    return output.chomp, error.chomp
+    return output.chomp, error.chomp, exit_status.to_s
   end
   
-  def invoke
-    if valid?
-      project_name = File.basename(@project_path)
-      results = Result.new(project_name)
-      
-      results.version_output, results.version_error = run_script('version')
-      
-      if results.version_error.empty?
-        results.update_output, results.update_error = run_script('update')
-      else
-        results.update_output, results.update_error = '', ''
-      end
-      
-      if results.update_error.empty?
-        results.test_output, results.test_error = run_script('test')
-      else
-        results.test_output, results.test_error = '', ''
+  def run_conclusion_script
+    
+    # REFACTOR do this asynchronously so the next tests don't wait on running the conclusion
+    
+    Dir.chdir(@project_path) do
+      Syslog.debug "Passing report to conclusion script at #{script_path('conclusion')}"
+      errors = ''
+      status = Open4.popen4(script_path('conclusion')) do |pid, stdin, stdout, stderr|
+        stdin.puts @results.to_json
+        stdin.close
+        errors = stderr.read
       end
       
-      results.timestamp = Time.now
-      
-      return results
+      Syslog.err(errors) if status.exitstatus != '0'
+      Syslog.debug "Finished executing conclusion script"
     end
+    
+  rescue Errno::EPIPE
+    Syslog.err "Unknown issue in writing to conclusion script."
+  end
+  
+  def start!
+    # REFACTOR to just report whichever scripts are invalid
+    check_for_valid_scripts
+    
+    @results[:timestamp][:start] = Time.now
+    Syslog.info "Starting CI for #{project_name}"
+  end
+    
+  def update!
+    Syslog.debug "Updating #{project_name}"
+    @results[:update][:output], @results[:update][:error], @results[:update][:exit_status] = run_script('update')
+  end
+  
+  def version!
+    if @results[:update][:exit_status] == '0'
+      Syslog.debug "Acquiring build version for #{project_name}"
+      @results[:version][:output], @results[:version][:error], @results[:version][:exit_status] = run_script('version')
+    end
+  end
+  
+  def test!
+    if @results[:version][:exit_status] == '0'
+      Syslog.debug "Testing #{@results[:project_name]} build #{@results[:version][:output]}"
+      @results[:test][:output], @results[:test][:error], @results[:test][:exit_status] = run_script('test')
+    else
+      Syslog.debug "Failed to test #{project_name}; version exit status was #{@results[:version][:exit_status]}"
+    end
+    
+    @results[:timestamp][:finish] = Time.now
+    run_conclusion_script
+  end
+  
+  def finished?
+    @results[:timestamp][:finish]
+  end
+  
+  def still_building?
+    !finished?
   end
 end