damagecontrol 0.5.0 → 0.5.0.1391

data/config/environments/development.rb

@@ -1,3 +1,4 @@
-Dependencies.mechanism                             = :load
-ActionController::Base.consider_all_requests_local = true
+Dependencies.mechanism                             = :load
+ActionController::Base.consider_all_requests_local = true
+ActionController::Base.perform_caching             = false
 BREAKPOINT_SERVER_PORT = 42531

data/config/environments/production.rb

@@ -1,2 +1,3 @@
-Dependencies.mechanism                             = :require
-ActionController::Base.consider_all_requests_local = false
+Dependencies.mechanism                             = :require
+ActionController::Base.consider_all_requests_local = false
+ActionController::Base.perform_caching             = true

data/config/environments/test.rb

@@ -1,3 +1,4 @@
-Dependencies.mechanism                             = :require
-ActionController::Base.consider_all_requests_local = true
+Dependencies.mechanism                             = :require
+ActionController::Base.consider_all_requests_local = true
+ActionController::Base.perform_caching             = false
 ActionMailer::Base.delivery_method                 = :test

data/config/routes.rb

@@ -0,0 +1,15 @@
+ActionController::Routing::Routes.draw do |map|
+  # Add your own custom routes here.
+  # The priority is based upon order of creation: first created -> highest priority.
+  
+  # Here's a sample route:
+  # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Allow downloading Web Service WSDL as a file with an extension
+  # instead of a file named 'wsdl'
+  map.connect ':controller/service.wsdl', :action => 'wsdl'
+  
+  # Install the default route as the lowest priority.
+  map.connect ':controller/:action/:id'
+end

data/lib/damagecontrol/app.rb

@@ -1,9 +1,9 @@
-require 'drb'
 require 'rubygems'
 require 'needle'
-require_gem 'rscm'
+require 'rscm'
 require 'damagecontrol/poller'
 require 'damagecontrol/standard_persister'
+require 'damagecontrol/publisher/base'
 
 # Wire up the whole DamageControl app with Needle's nice block based DI framework.
 # I wonder - is BDI (Block Dependency Injection) a new flavour of DI?
@@ -15,59 +15,30 @@ REGISTRY = Needle::Registry.define do |b|
   b.poller do 
     DamageControl::Poller.new do |project, changesets|
       b.persister.save_changesets(project, changesets)
-      b.persister.save_diffs(project, changesets)
       b.persister.save_rss(project)
       changeset = changesets.latest
-      project.build(changeset.identifier) do |build|
+      project.execute_build(changeset.identifier, "Detected changes by polling #{project.scm.name}") do |build|
+        # TODO: we want to reuse this in other places (Execute publisher)
         env = {
           'PKG_BUILD' => changeset.identifier.to_s, # Rake standard
-          'DAMAGECONTROL_BUILD_LABEL' => changeset.identifier.to_s # For others
+          'DAMAGECONTROL_BUILD_LABEL' => changeset.identifier.to_s, # For others
+          'DAMAGECONTROL_CHANGED_FILES' => changeset.changes.collect{|change| change.path}.join(",")
         }
         build.execute(project.build_command, env)
+        project.publish(build)
       end
+      # TODO: do this in a publisher that can be turned off if an other SCMWeb is used.
+      # This may take a while, so we do it after the build.
+      b.persister.save_diffs(project, changesets)
     end
   end
-
-  b.drb_server do 
-    DamageControl::DrbServer.new('druby://localhost:9000')
-  end
 end
   
 module DamageControl
 
   class App
     def run
-      REGISTRY.poller.start
-      REGISTRY.drb_server.start
-  
-      DRb.thread.join # Block forever
-    end
-  end
-
-  # Drb top-level object that can be accessed by the web app.
-  # The webapp should use this for any operations that are
-  # lengthy.
-  #
-  class DrbServer
-    def initialize(drb_url)
-      @drb_url = drb_url
-    end
-    
-    def start
-      DRb.start_service(@drb_url, self)  
-      Log.info "DamageControl server running on #{@drb_url}"
-    end
-  
-    def save_project(project)
-      project.save
-    end
-
-    def delete_project(project)
-      project.delete
-    end
-
-    def checkout_project(project)
-      project.checkout
+      REGISTRY.poller.start.join
     end
   end
   

data/lib/damagecontrol/build.rb

@@ -1,8 +1,11 @@
 require 'rscm/path_converter'
 require 'damagecontrol/directories'
+require 'damagecontrol/project'
 
 module DamageControl
-  # File structure
+  # Represents build-related data organised in the following file structure:
+  #
+  # File structure:
   #
   #   .damagecontrol/
   #     SomeProject/
@@ -19,16 +22,32 @@ module DamageControl
   #               artifacts/
   #
   class Build
+
+    # TODO: we want to store the following additional info for a build (time related)
+    #  * Total Duration
+    #  * Duration of checkpoints (compile, test, javadocs...) - should be configurable in project.
+    #  * 
+
     attr_reader :time
   
     # Creates a new Build for a +project+'s +changeset+, created at +time+.
-    def initialize(project_name, changeset_identifier, time)
-      @project_name, @changeset_identifier, @time = project_name, changeset_identifier, time
+    def initialize(project_name, changeset_identifier, time, build_reason)
+      @project_name, @changeset_identifier, @time, @build_reason = project_name, changeset_identifier, time, build_reason
+    end
+
+    # Our unique id within the changeset
+    def identifier
+      time.ymdHMS
     end
 
-    # The changeset we belong to
+    # Our associated project
+    def project
+      Project.load(@project_name)
+    end
+    
+    # Our associated changeset
     def changeset
-      Directories.changeset
+      project.changeset(@changeset_identifier)
     end
     
     # Executes +command+ with the environment variables +env+ and persists the command for future reference.
@@ -40,20 +59,22 @@ module DamageControl
       File.open(command_file, "w") do |io|
         io.write(command)
       end
-      stderr = Directories.stderr(@project_name, @changeset_identifier, @time)
-      stdout = Directories.stdout(@project_name, @changeset_identifier, @time)
       command_line = "#{command} > #{stdout} 2> #{stderr}"
 
       begin
         with_working_dir(checkout_dir) do
           env.each {|k,v| ENV[k]=v}
+          Log.info "Executing '#{command_line}'"
+          Log.info "Execution environment:"
+          ENV.each {|k,v| Log.info("#{k}=#{v}")}
           IO.popen(command_line) do |io|
             File.open(pid_file, "w") do |pid_io|
               pid_io.write(pid)
             end
             
             # there is nothing to read, since we're redirecting to file,
-            # but we still need to read in order to block till process id done.
+            # but we still need to read in order to block until the process is done.
+            # TODO: don't redirect stdout - we want to intercept checkpoints
             io.read
           end
         end
@@ -73,6 +94,14 @@ module DamageControl
         nil
       end
     end
+    
+    def successful?
+      exit_code == 0
+    end
+    
+    def status_message
+      successful? ? "Successful" : "Failed"
+    end
 
     # Returns the pid of the build process
     def pid
@@ -82,7 +111,20 @@ module DamageControl
     def kill
       Process.kill("SIGHUP", pid)
     end
+
+    def stdout
+      Directories.stdout(@project_name, @changeset_identifier, @time)
+    end
+
+    def stderr
+      Directories.stderr(@project_name, @changeset_identifier, @time)
+    end
     
+    # The directory of the build
+    def dir
+      Directories.build_dir(@project_name, @changeset_identifier, @time)
+    end
+
   private
   
     def checkout_dir

data/lib/damagecontrol/directories.rb

@@ -6,17 +6,23 @@ module DamageControl
 
   # This class knows about locations of various files and directories.
   #
+  # TODO: Add templates, logs(global)
   module Directories
     include FileUtils
 
     def project_names
-      result = Dir["#{basedir}/*/project.yaml"].collect do |f| 
+      result = Dir["#{basedir}/projects/*/project.yaml"].collect do |f| 
         File.basename(File.dirname(f))
       end
       result.sort
     end
     module_function :project_names
     
+    def project_dir(project_name)
+      "#{basedir}/projects/#{project_name}"
+    end
+    module_function :project_dir
+
     def checkout_dir(project_name)
       "#{project_dir(project_name)}/checkout"
     end
@@ -105,11 +111,6 @@ module DamageControl
     end
     module_function :project_config_file
 
-    def project_dir(project_name)
-      "#{basedir}/#{project_name}"
-    end
-    module_function :project_dir
-
     def basedir
       if(ENV['DAMAGECONTROL_HOME'])
         ENV['DAMAGECONTROL_HOME']

data/lib/damagecontrol/poller.rb

@@ -1,6 +1,7 @@
 require 'rscm/logging'
 require 'rscm/time_ext'
 require 'damagecontrol/project'
+require 'damagecontrol/publisher/base'
 
 module DamageControl
   # Polls all projects in intervals.
@@ -11,25 +12,20 @@ module DamageControl
     # receive |project, changesets| each time new
     # +changesets+ are found in a polled +project+
     def initialize(sleeptime=60, &proc)
-      @projects = []
       @sleeptime = sleeptime
       @proc = proc
     end
 
-    # Adds a project to poll. If the project is already added it is replaced
-    # with then new one, otherwise appended to the end.
-    def add_project(project)
-      index = @projects.index(project) || @projects.length
-      @projects[index] = project
-    end
-    
     # Polls all registered projects and persists RSS, changesets and diffs to disk.
     # If a block is passed, the project and the changesets will be yielded to the block
     # for each new changesets object.
     def poll
-      @projects.each do |project|
+      Log.info "Starting polling cycle"
+      Project.find_all.each do |project|
+        Log.info "Polling #{project.name}"
         begin
           if(project.scm_exists?)
+            Log.info "Polling #{project.name}"
             project.poll do |changesets|
               if(changesets.empty?)
                 Log.info "No changesets for #{project.name}"
@@ -37,36 +33,31 @@ module DamageControl
                 @proc.call(project, changesets)
               end
             end
+          else
+            Log.info "Not polling #{project.name} since its scm doesn't exist"
           end
         rescue => e
-          $stderr.puts "Error polling #{project.name}"
-          $stderr.puts e.message
-          $stderr.puts "  " + e.backtrace.join("  \n")
+          Log.error "Error polling #{project.name}"
+          Log.error  e.message
+          Log.error "  " + e.backtrace.join("  \n")
         end
       end
     end
     
     # Runs +poll+ in a separate thread.
     def start
-      add_all_projects
       @t = Thread.new do
         while(true)
           poll
           sleep(@sleeptime)
         end
       end
+      @t
     end
     
     # Stops thread after a +start+.
     def stop
       @t.kill if @t && @t.alive?
     end
-
-    # Adds all projects
-    def add_all_projects
-      Project.find_all.each do |project|
-        add_project(project)
-      end
-    end    
   end
 end

data/lib/damagecontrol/project.rb

@@ -10,14 +10,29 @@ require 'damagecontrol/tracker'
 require 'damagecontrol/visitor/yaml_persister'
 require 'damagecontrol/visitor/diff_persister'
 require 'damagecontrol/visitor/rss_writer'
+require 'damagecontrol/publisher/base'
+
+module ObjectTemplate
+  def dupe(variables)
+    template_yaml = YAML::dump(self)
+    b = binding
+    variables.each { |key, value| eval "#{key} = variables[\"#{key}\"]", b }
+    new_yaml = eval(template_yaml.dump.gsub(/\\#/, "#"), b)
+    YAML::load(new_yaml)
+  end
+end
 
 module DamageControl
   # Represents a project with associated SCM, Tracker and SCMWeb
   class Project
+    include ObjectTemplate
+  
+    # TODO: move to scms? not sure....
+    DEFAULT_QUIET_PERIOD = 10 unless defined? DEFAULT_QUIET_PERIOD
 
     attr_accessor :name
-    attr_accessor :description
     attr_accessor :home_page
+    attr_accessor :start_time
 
     attr_accessor :scm
     attr_accessor :tracker
@@ -27,14 +42,26 @@ module DamageControl
     attr_accessor :quiet_period
 
     attr_accessor :build_command
+    attr_accessor :publishers
 
     # Loads the project with the given +name+.
     def Project.load(name)
       config_file = Directories.project_config_file(name)
       Log.info "Loading project from #{config_file}"
-      File.open(config_file) do |io|
+      project = File.open(config_file) do |io|
         YAML::load(io)
       end
+
+      # Add new publishers that may have be defined after the project was YAMLed.
+      project.publishers = [] if project.publishers.nil?
+      Publisher::Base.classes.collect{|cls| cls.new}.each do |publisher|
+        publisher_of_same_type = project.publishers.find do |p|
+          p.class == publisher.class
+        end
+        project.publishers << publisher unless publisher_of_same_type
+      end
+
+      project
     end
 
     # Loads all projects
@@ -43,12 +70,39 @@ module DamageControl
         Project.load(name)
       end
     end
-  
-    def initialize(name=nil)
+    
+    def start_time=(t)
+      t = Time.parse_ymdHMS(t) if t.is_a? String
+      @start_time = t
+    end
+    
+    def initialize(name="")
       @name = name
+      @publishers = Publisher::Base.classes.collect{|cls| cls.new}
       @scm = nil
       @tracker = Tracker::Null.new
-      @scm_web = SCMWeb::Null.new
+      @scm_web = SCMWeb::Null.new
+      # Default start time is 2 weeks ago
+      @start_time = Time.now.utc - (3600*24*14)
+      @quiet_period = DEFAULT_QUIET_PERIOD
+    end
+    
+    # Tells all publishers to publish a build
+    def publish(build)
+      @publishers.each do |publisher| 
+        begin
+          if(publisher.enabled)
+            Log.info("Publishing #{publisher.name} for #{@name}")
+            publisher.publish(build) 
+          else
+            Log.info("Skipping disabled publisher #{publisher.name} for #{@name}")
+          end
+        rescue => e
+          Log.error "Error running publisher #{publisher.name} for project #{name}"
+          Log.error  e.message
+          Log.error "  " + e.backtrace.join("  \n")
+        end
+      end
     end
     
     # Saves the state of this project to persistent store (YAML)
@@ -58,8 +112,6 @@ module DamageControl
       File.open(f, "w") do |io|
         YAML::dump(self, io)
       end
-      
-      REGISTRY.poller.add_project(self) if REGISTRY
     end
     
     # Path to file containing pathnames of latest checked out files.
@@ -81,9 +133,9 @@ module DamageControl
     end
 
     # Polls SCM for new changesets and yields them to the given block.
-    def poll(from_if_first_poll=Time.epoch)
+    def poll
       start = Time.now
-      from = next_changeset_identifier || from_if_first_poll
+      from = next_changeset_identifier || @start_time
       
       Log.info "Getting changesets for #{name} from #{from} (retrieved from #{checkout_dir})"
       changesets = @scm.changesets(checkout_dir, from)
@@ -93,10 +145,11 @@ module DamageControl
         # When the changesets are not changing, we can consider the last commit done
         # and the quiet period elapsed. This is not 100% failsafe, but will work
         # under most circumstances. In the worst case, we'll miss some files in
-        # the changesets, but they will be part of the next changeset (on next poll).
+        # the changesets for really slow commits, but they will be part of the next 
+        # changeset (on next poll).
         commit_in_progress = true
         while(commit_in_progress)
-          @quiet_period ||= 5
+          @quiet_period ||= DEFAULT_QUIET_PERIOD
           Log.info "Sleeping for #{@quiet_period} seconds since #{name}'s SCM (#{@scm.name}) is not transactional."
           sleep @quiet_period
           next_changesets = @scm.changesets(checkout_dir, from)
@@ -156,6 +209,12 @@ module DamageControl
       changesets_persister.load_upto(changeset_identifier, prior)
     end
 
+    def changeset(changeset_identifier)
+      result = changesets(changeset_identifier, 1)[0]
+      raise "No changeset with id '#{changeset_identifier}' for project '#{name}'" unless result
+      result
+     end
+
     def changeset_identifiers
       changesets_persister.identifiers
     end
@@ -177,23 +236,28 @@ module DamageControl
       DamageControl::Visitor::YamlPersister.new(changesets_dir)
     end
     
-    # Creates, persists and executes a build for the changeset with the given 
+    # Creates, persists and executes a Build for the changeset with the given 
     # +changeset_identifier+.
     # Should be called with a block of arity 1 that will receive the build.
-    def build(changeset_identifier)
+    def execute_build(changeset_identifier, build_reason)
       scm.checkout(checkout_dir, changeset_identifier)
-      build = Build.new(name, changeset_identifier, Time.now.utc)
+      build = Build.new(name, changeset_identifier, Time.now.utc, build_reason)
       yield build
     end
 
-    # Returns an array of existing builds for the given +changeset+.
+    # Returns an array of existing Build s for the given +changeset_identifier+.
     def builds(changeset_identifier)
       Directories.build_dirs(name, changeset_identifier).collect do |dir|
         # The dir's basename will always be a Time
-        Build.new(name, changeset_identifier, File.basename(dir).to_identifier)
+        Build.new(name, changeset_identifier, File.basename(dir).to_identifier, "TODO: get from file")
       end
     end
 
+    # Returns the Build for the given +changeset_identifier+ and +build_time+
+    def build(changeset_identifier, build_time)
+      Build.new(name, changeset_identifier, build_time, "FIXME")
+    end
+
     # Returns the latest build.
     def latest_build
       changeset_identifiers.reverse.each do |changeset_identifier|
@@ -202,6 +266,9 @@ module DamageControl
       end
       nil
     end
+    
+    # Creates a duplicate of ourself, applying simple standard #{blah}
+    # transformations of all key,value pairs in +local_assigns+.
 
   private