cruiseface 1.0.1

data/Manifest

@@ -0,0 +1,12 @@
+Manifest
+README.rdoc
+TODO
+bin/cruiseface
+lib/cruise_face.rb
+lib/cruise_face/console.rb
+lib/cruise_face/pipeline.rb
+lib/cruise_face/resource.rb
+lib/cruise_face/stage.rb
+lib/cruiseface.rb
+rakefile
+Rakefile

data/README.rdoc

@@ -0,0 +1,72 @@
+
+= CruiseFace -- A ruby terminal Cruise dashboard
+
+CruiseFace shows you a developer oriented Cruise dashboard in terminal, making
+things simpler for monitoring Cruise pipelines.
+
+== How it works
+
+First time, you may try this, after installed the gem, type in 'cruiseface'
+
+Then it'll ask you cruise site url, for example:
+
+  https://cruise.domain.com/cruise
+
+Then your login user name and password
+
+Then it will fetch all pipelines on the server, and list them, you need type in
+the index number, e.g. 5,10
+
+Done.
+
+For myself, I open a terminal window using black background and change the font to 18pt.
+
+Then specifying some environment variables in my ~/.profile:
+
+  export CRUISE_SERVER_URL='https://cruise.domain.com/cruise'
+  export CRUISE_LOGIN_NAME="xli"
+  export CRUISE_PIPELINE_NAMES='xx_trunk--CentOS5,xx_trunk--Windows2003'
+
+Then type 'cruiseface' in the terminal, cruiseface will ask for the password.
+
+Done.
+
+== Why a new dashboard
+
+When working with 2 pipelines, each has 4+ stages and has a stage with 50+ jobs,
+the following information is enough and need for my daily work of checking build:
+
+* Build pass/failed status
+
+* How many jobs failed right now, even all jobs are building
+
+* Who has responsibility for failed jobs
+
+* Is failed job currently building? (When I committed a fix for the failed job, I really want to know whether the failed is fixed by my commit once the job is finished)
+
+* some time, I may want to know the failing job name, but most of time, I just need the number of how many jobs failing.
+
+* what's stage building, and who committed from last built stage (Cruise does not work in this way, so cruiseface also does not implement it yet, just display pipeline committers now)
+
+* how many jobs are building, and I don't care about build success jobs
+
+== Limitation
+
+It only works on Mac, it could be run on other platform, but the color stuff won't work.
+
+= Other stuff
+
+Author: Li Xiao <iam@li-xiao.com>
+
+Requires: Ruby 1.8.6 or later
+
+License: Copyright 2010 by Li Xiao.
+         Released under an MIT-LICENSE.  See the MIT-LICENSE.txt file
+         included in the distribution.
+
+== Warranty
+
+This software is provided "as is" and without any express or
+implied warranties, including, without limitation, the implied
+warranties of merchantibility and fitness for a particular
+purpose.

data/Rakefile

@@ -0,0 +1,60 @@
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/lib')
+require 'cruise_face'
+
+require 'logger'
+
+ActiveResource::Base.logger = Logger.new(STDOUT)
+ActiveResource::Base.logger.level = Logger::INFO
+
+namespace :dump do
+  task :pipeline_status do
+    CruiseFace.site('https://cruise01.thoughtworks.com/cruise').login('xli', Base64.decode64(ENV['LDAP_CODE']))
+    ps = CruiseFace::Resource.find_pipeline_status
+    File.open "./tast/data/ps.xml", 'w' do |f|
+      f.write ps.to_xml
+    end
+  end
+
+  task :pipeline_history do
+    CruiseFace.site('https://cruise01.thoughtworks.com/cruise').login('xli', Base64.decode64(ENV['LDAP_CODE']))
+    pipeline = CruiseFace.get(ENV['PN'])
+    File.open "./tast/data/#{pipeline.name}.xml", 'w' do |f|
+      f.write pipeline.resource.to_xml
+    end
+    pipeline.history.each do |history_pipeline|
+      history_pipeline.stages.each do |stage_name, stage|
+        begin
+          stage_status = history_pipeline.find_stage_status(stage)
+          File.open "./tast/data/#{history_pipeline.name}-#{history_pipeline.label}-#{stage.name}-#{stage.counter}.xml", 'w' do |f|
+            f.write stage_status.to_xml
+          end
+        rescue => e
+          #ignore cruise stage not exist problem when the pipeline is building
+        end
+      end
+    end
+    puts 'done'
+  end
+  task :stage_status do
+    CruiseFace.site('https://cruise01.thoughtworks.com/cruise').login('xli', Base64.decode64(ENV['LDAP_CODE']))
+    pipeline = CruiseFace::Resource.find_stage_status(ENV['PN'])
+    File.open "./tast/data/#{pipeline.name}.xml", 'w' do |f|
+      f.write pipeline.resource.to_xml
+    end
+    puts 'done'
+  end
+end
+
+require 'echoe'
+
+Echoe.new('cruiseface', '1.0.1') do |p|
+  p.description     = "CruiseFace arms to give a friendly Cruise Pipeline dashboard info for developers."
+  p.url             = "https://github.com/xli/cruiseface"
+  p.author          = "Li Xiao"
+  p.email           = "iam@li-xiao.com"
+  p.ignore_pattern  = "*.gemspec"
+  p.dependencies = ["activeresource", "highline"]
+  p.ignore_pattern = ['tast/*.rb', 'tast/**/*']
+  p.rdoc_options    = %w(--main README.rdoc --inline-source --line-numbers --charset UTF-8)
+end

data/TODO

@@ -0,0 +1,17 @@
+
+
+new
+
+# built a detail view instead of only show failing jobs name instead of count
+# guess how much time left for a stage
+# need a fancy UI
+# when some jobs failed on one stage, and rerun the stage, the failure info does not showup
+# committers of a stage should include all committers did commit after last time the stage built
+
+done
+
+# get all pipeline names for configuring monitor
+# committers
+# pipeline history parse
+## stage history
+## job history

data/bin/cruiseface

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+begin
+  require 'cruiseface'
+rescue LoadError
+  require 'rubygems'
+  require 'cruiseface'
+end
+
+begin
+  require "highline/import"
+rescue LoadError
+  require 'rubygems'
+  require "highline/import"
+end
+
+require 'optparse'
+
+opts = OptionParser.new do |opts|
+  opts.banner = "CruiseFace usage: #{$0} [options]"
+  opts.separator ""
+  opts.separator "Environment properties CruiseFace uses as input if exists:"
+  opts.separator "  CRUISE_SERVER_URL, CRUISE_LOGIN_NAME, CRUISE_PIPELINE_NAMES, CRUISE_LOGIN_PASSWORD"
+  opts.separator "Synopsis:"
+  opts.separator "cruiseface"
+  opts.separator "cruiseface -s 'http://domain.com/cruise' -u login_name -p pipeline1,pipeline2"
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("-s", "--server CRUISE_SERVER_URL",  "Cruise server URL, including server context path") do |site|
+    ENV['CRUISE_SERVER_URL'] = site
+  end
+  
+  opts.on("-u", "--user LOGIN_NAME",  "Login name for login cruise server") do |login_name|
+    ENV['CRUISE_LOGIN_NAME'] = login_name
+  end
+  
+  opts.on("-p pipeline1,pipeline2", Array, "Pipeline names to be monitored") do |names|
+    ENV['CRUISE_PIPELINE_NAMES'] = names.join(',')
+  end
+
+  opts.on("-w", "--password PASSWORD",  "Password for login cruise server") do |password|
+    ENV['CRUISE_LOGIN_PASSWORD'] = password
+  end
+
+  opts.on_tail("-o", "--output", "Output cruise pipeline status and then exit") do
+    $cruise_fetch_once = true
+  end
+  
+  opts.on_tail("-d", "--debug", "Open debug mode") do
+    ENV['CRUISE_FACE_DEBUG'] = 'true'
+  end
+
+  opts.on_tail("-v", "--version", "Show version") do
+    puts "cruiseface, version " + CruiseFace::VERSION
+    exit
+  end
+
+  opts.on_tail("-h", "--help", "Show this help doc") do 
+    puts opts
+    exit
+  end
+end
+
+opts.parse!
+
+if ENV['CRUISE_FACE_DEBUG']
+  ActiveResource::Base.logger = Logger.new(STDOUT)
+  ActiveResource::Base.logger.level = Logger::DEBUG
+end
+
+ENV['CRUISE_SERVER_URL']      ||= ask("Cruise server url (e.g. http://domain.com/cruise): ")
+ENV['CRUISE_LOGIN_NAME']      ||= ask("Cruise server login name: ")
+ENV['CRUISE_LOGIN_PASSWORD']  ||= ask("Cruise server login password: ") { |q| q.echo = false }
+
+CruiseFace.site(ENV['CRUISE_SERVER_URL'])
+CruiseFace.login(ENV['CRUISE_LOGIN_NAME'], ENV['CRUISE_LOGIN_PASSWORD'])
+
+unless ENV['CRUISE_PIPELINE_NAMES']
+  puts "Fetching pipeline names from cruise server..."
+  puts "You can specify an environment variable CRUISE_PIPELINE_NAMES with names of pipelines split by comma to avoid fetching pipeline names every time you start cruiseface"
+  all_pipelines = CruiseFace.pipelines
+  all_pipelines.each_with_index do |p, index|
+    puts "  #{index}. #{p}"
+  end
+  puts "Pipelines (type in indexes split by comma): "
+  pipelines = gets.strip.split(",").collect(&:strip)
+  if pipelines.all? {|p| p =~ /^\d+$/}
+    ENV['CRUISE_PIPELINE_NAMES'] = pipelines.collect {|p_index| all_pipelines[p_index.to_i]}.join(',')
+  else
+    ENV['CRUISE_PIPELINE_NAMES'] = pipelines.join(',')
+  end
+end
+
+begin
+  cruise_pipeline_names = ENV['CRUISE_PIPELINE_NAMES'].split(",").collect(&:strip)
+  if $cruise_fetch_once
+    cruise_pipeline_names.each do |name|
+      CruiseFace.output(name)
+    end
+  else
+    CruiseFace.console(cruise_pipeline_names)
+  end
+rescue Interrupt
+end

data/cruiseface.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cruiseface}
+  s.version = "1.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Li Xiao"]
+  s.date = %q{2010-03-12}
+  s.default_executable = %q{cruiseface}
+  s.description = %q{CruiseFace arms to give a friendly Cruise Pipeline dashboard info for developers.}
+  s.email = %q{iam@li-xiao.com}
+  s.executables = ["cruiseface"]
+  s.extra_rdoc_files = ["README.rdoc", "TODO", "bin/cruiseface", "lib/cruise_face.rb", "lib/cruise_face/console.rb", "lib/cruise_face/pipeline.rb", "lib/cruise_face/resource.rb", "lib/cruise_face/stage.rb", "lib/cruiseface.rb"]
+  s.files = ["Manifest", "README.rdoc", "TODO", "bin/cruiseface", "lib/cruise_face.rb", "lib/cruise_face/console.rb", "lib/cruise_face/pipeline.rb", "lib/cruise_face/resource.rb", "lib/cruise_face/stage.rb", "lib/cruiseface.rb", "rakefile", "Rakefile", "cruiseface.gemspec"]
+  s.homepage = %q{https://github.com/xli/cruiseface}
+  s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers", "--charset", "UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{cruiseface}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{CruiseFace arms to give a friendly Cruise Pipeline dashboard info for developers.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activeresource>, [">= 0"])
+      s.add_runtime_dependency(%q<highline>, [">= 0"])
+    else
+      s.add_dependency(%q<activeresource>, [">= 0"])
+      s.add_dependency(%q<highline>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activeresource>, [">= 0"])
+    s.add_dependency(%q<highline>, [">= 0"])
+  end
+end

data/lib/cruise_face.rb

@@ -0,0 +1,44 @@
+
+require 'cruise_face/resource'
+require 'cruise_face/pipeline'
+require 'cruise_face/console'
+
+module CruiseFace
+  VERSION = '1.0.1'
+  extend self
+
+  def site(site)
+    Resource.site = site
+    Resource.format = :json
+    # ignore the collection_name, we'll use action for find cruise resources,
+    # for cruise REST API does not fit with ActiveResource
+    Resource.collection_name = ''
+    self
+  end
+
+  def login(username, password)
+    Resource.user = username
+    Resource.password = password
+    self
+  end
+
+  def pipelines
+    Resource.find_pipeline_status.pipelines.collect(&:name)
+  end
+
+  def get(pipeline_name)
+    Model::Pipeline.new Resource.find_pipeline_history(pipeline_name)
+  end
+
+  def output(pipeline)
+    puts Console::UIBuilder.instance.fetch_pipeline_status(pipeline)
+  end
+
+  def output_text(pipeline)
+    puts Console::UIBuilder.instance.to_string(Console::UIBuilder.instance.fetch_pipeline_status(pipeline))
+  end
+
+  def console(pipeline_names)
+    Console.new(pipeline_names).start
+  end
+end

data/lib/cruise_face/console.rb

@@ -0,0 +1,187 @@
+require 'singleton'
+require 'cgi'
+
+module CruiseFace
+  class Console
+    class UIBuilder
+      include Singleton
+
+      def fetch_pipeline_status(pipeline)
+        xm = Builder::XmlMarkup.new
+        xm.instruct!
+        xm.pipeline(:name => pipeline) do
+          xm.stages(:type => 'array') do
+            CruiseFace.get(pipeline).stages.each do |stage|
+              stage.to_xml(xm)
+            end
+          end
+        end
+      rescue => e
+        xm = Builder::XmlMarkup.new
+        xm.instruct!
+        xm.errors(:pipeline_name => pipeline) { xm.error(e.message) }
+      end
+
+      def to_string(pipeline_status_xml)
+        if errors = Hash.from_xml(pipeline_status_xml)['errors']
+          return "Could not fetch pipeline #{errors['pipeline_name']} status, got error: #{errors['error']}\n"
+        end
+        pipeline = Resource.new(ActiveResource::Formats[:xml].decode(pipeline_status_xml))
+
+        status = "#{pipeline.name}:\n"
+        pipeline.stages.each do |stage|
+          status << " "
+          if stage.building_jobs.blank?
+            stage_info = "#{truncate(stage.name)}: [#{stage.latest.committers.collect(&:name).join(', ')}]"
+            if stage.latest.failed?
+              status << ' ' << failing_builds(stage_info)
+            else
+              status << ' ' << green_builds(stage_info)
+            end
+          else
+            status << spinner << build_running("#{truncate(stage.name)}: #{job_info(stage.building_jobs)} [#{stage.latest.committers.collect(&:name).join(', ')}]")
+          end
+
+          unless stage.failing_jobs.blank?
+            committers = stage.failing_jobs.collect(&:committers).flatten.collect(&:name).uniq.join(", ")
+            status << ', '
+            if stage.building_jobs.empty?
+              status << failing_builds("#{job_info(stage.failing_jobs)} [#{committers}]")
+            else
+              building_failed_jobs = stage.building_jobs.collect(&:name) & stage.failing_jobs.collect(&:name)
+              status << failing_builds(job_info(stage.failing_jobs))
+              status << build_running("(#{job_info(building_failed_jobs)})")
+              status << failing_builds(" [#{committers}]")
+            end
+          end
+          status << "\n"
+        end
+        status
+      rescue => e
+        status = "Unexpected error: #{e.message}" << "\n"
+        status << e.backtrace.join("\n") << "\n"
+        status << "\n"
+        status << "pipeline status xml:\n"
+        status << pipeline_status_xml << "\n"
+        status
+      end
+
+      def job_info(jobs)
+        return name_of(jobs.first) if jobs.size == 1
+        return "#{jobs.size} jobs" unless Console.show_details
+        return 0 if jobs.empty?
+        jobs.collect{|j| name_of(j)}.join(", ")
+      end
+
+      def name_of(job)
+        job.respond_to?(:name) ? job.name : job
+      end
+
+      def truncate(string, width=15)
+        if string.length <= width
+          string
+        else
+          string[0, width-3] + "..."
+        end
+      end
+
+      def spinner
+        colorize('5;33m', '*')
+      end
+      def build_running(text)
+        colorize('0;33m', text)
+      end
+      def failing_builds(text)
+        colorize('1;31m', text)
+      end
+      def green_builds(text)
+        colorize('0;32m', text)
+      end
+      def colorize(color, text)
+        "\e[#{color}#{text}\e[0m"
+      end
+
+    end
+
+    def self.show_details=(enable)
+      ENV['SHOW_CRUISE_DETAILS'] = enable.to_s
+    end
+
+    def self.show_details
+      ENV['SHOW_CRUISE_DETAILS'] == 'true'
+    end
+
+    def initialize(pipeline_names)
+      @pipeline_names = pipeline_names
+      @mutex = Mutex.new
+      @status = {}
+    end
+
+    def start
+      @pipeline_names.each do |name|
+        start_fetch(name)
+      end
+
+      puts "Initializing first report"
+      loop do
+        print '.'
+        STDOUT.flush
+        sleep 1
+        break unless @mutex.synchronize { @status.empty? }
+      end
+      puts "\nGot first report"
+      start_commander
+
+      loop do
+        refresh
+        sleep 5
+      end
+    end
+
+    def start_fetch(pipeline)
+      Thread.start do
+        loop do
+          pipeline_status = %x[#{$0} -o -p #{pipeline.inspect}]
+          @mutex.synchronize { @status[pipeline] = pipeline_status }
+          sleep 10
+        end
+      end
+    end
+
+    def refresh
+      status_dump = @mutex.synchronize { @status.dup }.collect do |pipeline, status|
+        UIBuilder.instance.to_string(status)
+      end.join("\n")
+      print %x{clear}
+      dashboard = "---- #{Time.now.strftime("%b %d %H:%M:%S")} ----\n"
+      dashboard << CGI.unescapeHTML(status_dump) << "\n"
+      dashboard << "Type 'open' to open Cruise dashboard" << "\n"
+      dashboard << "Type 'show/hide' to show/hide details" << "\n"
+      puts dashboard
+    end
+
+    def start_commander
+      Thread.start do
+        loop do
+          command = gets.strip
+          case command
+          when /^(open|start)$/
+            if Resource.site.nil?
+              puts "ERROR: cruise server url not found"
+            else
+              system "#{command} #{Resource.site.to_s.inspect}"
+            end
+          when /^hide$/
+            Console.show_details = false;
+            refresh
+          when /^show$/
+            Console.show_details = true;
+            refresh
+          else
+            puts "Unknown command"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cruise_face/pipeline.rb

@@ -0,0 +1,165 @@
+require 'cruise_face/stage'
+
+module CruiseFace::Model
+  class Pipeline
+    PASSED_STATUS = 'Passed'
+    FAILED_STATUS = 'Failed'
+    CANCELED_STATUS = 'Cancelled'
+    COMPLETED_STATUS = [PASSED_STATUS, FAILED_STATUS, CANCELED_STATUS]
+    BUILDING_STATUS = 'Building'
+    UNKNOWN_STATUS = 'Unknown'
+
+    class History
+      class Pipeline
+        attr_reader :resource, :name, :label
+        def initialize(name, resource)
+          @name = name
+          @resource = resource
+          @label = @resource.label
+        end
+
+        def stages
+          @stages || init_stages
+        end
+
+        def committers
+          @resource.materialRevisions.first.modifications.collect(&:user).uniq
+        end
+
+        def find_jobs(stage)
+          find_stage_status(stage).stage.builds.collect { |build| Job.new stage, build }
+        end
+
+        def find_stage_status(stage)
+          params = {:pipelineName => @name, :label => @label, :stageName => stage.name, :counter => stage.counter}
+          CruiseFace::Resource.find_stage_status(params)
+        end
+
+        def to_s
+          "pipeline[#{@name}<#{@label}>]"
+        end
+
+        private
+        def init_stages
+          @stages = {}
+          @resource.stages.each do |stage_resource|
+            stage = Stage.new(self, stage_resource)
+            @stages[stage.name] = stage
+          end
+          @stages
+        end
+      end
+
+      class Stage
+        attr_reader :resource
+        def initialize(pipeline, resource)
+          @pipeline = pipeline
+          @resource = resource
+        end
+
+        def committers
+          @pipeline.committers
+        end
+
+        def completed?
+          !building?
+        end
+
+        def unknown?
+          UNKNOWN_STATUS == @resource.stageStatus
+        end
+
+        # the stageStatus maybe 'Failed' when there is one job failed and others are still building
+        def building?
+          jobs.any? {|job| job.incompleted?}
+        end
+
+        def name
+          @resource.stageName
+        end
+
+        def counter
+          @resource.stageCounter
+        end
+
+        def to_s
+          "#{name}<#{counter}>[#{@pipeline}]"
+        end
+        
+        def jobs
+          @jobs ||= @pipeline.find_jobs(self)
+        end
+      end
+
+      class Job
+        attr_reader :stage
+
+        def initialize(stage, resource)
+          @stage = stage
+          @resource = resource
+        end
+
+        def name
+          @resource.name
+        end
+
+        def passed?
+          @resource.result == PASSED_STATUS
+        end
+
+        def failed?
+          [FAILED_STATUS, CANCELED_STATUS].include? @resource.result
+        end
+
+        def completed?
+          @resource.is_completed == 'true'
+        end
+
+        def incompleted?
+          !completed?
+        end
+
+        def last_build_duration
+          @resource.last_build_duration
+        end
+
+        def current_build_duration
+          @resource.current_build_duration
+        end
+
+        def to_s
+          "Job #{name}[#{@stage}] #{completed? ? 'completed' : ''} #{failed? ? "failed" : (passed? ? 'passed' : 'unknown')}"
+        end
+      end
+
+      def initialize(pipelines)
+        @pipelines = pipelines
+      end
+
+      def each(&block)
+        @pipelines.each(&block)
+      end
+
+      def collect(&block)
+        @pipelines.collect(&block)
+      end
+    end
+
+    attr_reader :name, :resource
+    def initialize(resource)
+      @resource = resource
+      @name = resource.pipelineName
+      @pipeline = resource.groups.first
+    end
+
+    def stages
+      @pipeline.config.stages.collect do |stage|
+        Stage.new(stage, history)
+      end
+    end
+
+    def history
+      History.new(@pipeline.history.collect { | pipeline | History::Pipeline.new(self.name, pipeline) })
+    end
+  end
+end

data/lib/cruise_face/resource.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'active_resource'
+
+module CruiseFace
+  class Resource < ActiveResource::Base
+    def self.find_pipeline_status
+      find(:pipelineStatus)
+    end
+    def self.find_pipeline_history(name)
+      find(:pipelineHistory, :params => {:pipelineName => name})
+    end
+    def self.find_stage_status(params)
+      find(:stageStatus, :params => params)
+    end
+  end
+end

data/lib/cruise_face/stage.rb

@@ -0,0 +1,166 @@
+require 'ostruct'
+require 'builder'
+
+module CruiseFace::Model
+  class Stage
+
+    # History of a Stage cares about completed jobs, which maybe inside a running Stage
+    class History
+      def initialize(stages)
+        @stages = stages
+      end
+
+      def first
+        @stages.first
+      end
+
+      def passed?
+        as_jobs.all?(&:passed?)
+      end
+      def failed?
+        !passed?
+      end
+
+      def status
+        passed? ? 'Passed' : 'Failed'
+      end
+
+      def failed_jobs_from_now_until_passed(job_name)
+        jobs = []
+        @stages.each do |stage|
+          if job = stage.jobs.select(&:completed?).detect {|job| job.name == job_name}
+            if job.failed?
+              jobs << job
+            else
+              break
+            end
+          end
+        end
+        jobs
+      end
+
+      # A History of Stage could transform to a group of jobs, which is containing latest
+      # completed status in a Job's history.
+      # In some cases, the job may not have completed status, then the running/canceled job
+      # would be included in the return jobs
+      def as_jobs
+        @jobs ||= find_latest_completed_jobs
+      end
+
+      private
+      def find_latest_completed_jobs
+        return [] if first.nil?
+
+        latest_completed_jobs = []
+        @stages.each do |stage|
+          latest_completed_jobs = stage.jobs.collect do |job|
+            latest_completed_jobs.select(&:completed?).detect{|j| j.name == job.name} || job
+          end
+          if latest_completed_jobs.all?(&:completed?)
+            break
+          end
+        end
+
+        latest_completed_jobs
+      end
+    end
+
+    attr_reader :history
+
+    def initialize(config, pipelines)
+      @config = config
+      @history = History.new(pipelines.collect { |pipeline| pipeline.stages[name] }.reject {|history_stage| history_stage.unknown? })
+    end
+
+    def name
+      @config.name
+    end
+
+    def manual?
+      @config.isAutoApproved == 'false'
+    end
+
+    def building?
+      return false if no_history?
+      @history.first.building?
+    end
+
+    def building_jobs
+      return [] if no_history?
+      @history.first.jobs.select(&:incompleted?)
+    end
+
+    def latest_committers
+      return ['Unknown'] if no_history?
+      @history.first.committers
+    end
+
+    def no_history?
+      @history.first.blank?
+    end
+
+    def to_xml(xm)
+      xm.stage(:name => self.name) do
+        xm.latest(:status => self.history.status) do
+          xm.failed(self.history.failed?, :type => 'boolean')
+          xm.committers(:type => 'array') do
+            self.latest_committers.each { |committer| xm.committer(:name => committer) }
+          end
+        end
+        xm.building_jobs(:type => 'array') do
+          self.building_jobs.each { |job| xm.job(:name => job.name) }
+        end
+        xm.failing_jobs(:type => 'array') do
+          self.history.as_jobs.select(&:failed?).each do |job|
+            xm.job(:name => job.name) do
+              xm.committers(:type => 'array') { find_broking_builds_committers(job).each { |committer| xm.committer(:name => committer) } }
+            end
+          end
+        end
+      end
+    end
+
+    def find_broking_builds_committers(failed_job)
+      broken_jobs = []
+      self.history.failed_jobs_from_now_until_passed(failed_job.name).each do |job|
+        if job.failed?
+          broken_jobs << job
+        else
+          break
+        end
+      end
+      broken_jobs.collect(&:stage).collect(&:committers).flatten.uniq
+    end
+
+    # from 0 to 100, as 0% to 100%
+    # when 1 building job
+    # => (building job current_build_duration/last_build_duration) * 100
+    # when 2 building job
+    #   time left = [(job2.last_build_duration - job2.current_build_duration), (job1.last_build_duration - job1.current_build_duration)].max
+    #   time built = [job2.current_build_duration, job1.current_build_duration].max
+    # => (time left / (time left + time built)) * 100
+    # when 1 building job1, 1 scheduled job2
+    #   time left = job2.last_build_duration + (job1.last_build_duration - job1.current_build_duration)
+    #   time built = job1.current_build_duration
+    # => (time left / (time left + time built)) * 100
+    # when 0 building job, 1 scheduled job
+    # => 0
+    # when 0 building job, 1 completed job1, 1 scheduled job2
+    #   time left = job2.last_build_duration
+    #   time built = job1.current_build_duration
+    # => (time left / (time left + time built)) * 100
+    # when 0 building job, 2 completed job1 & job2, 1 scheduled job3
+    #   time left = job3.last_build_duration
+    #   time built = job1.current_build_duration + job2.current_build_duration
+    # => (time left / (time left + time built)) * 100
+    # when 1 building job0, 2 completed job1 & job2, 1 scheduled job3
+    #   time left = job3.last_build_duration + (job0.last_build_duration - job0.current_build_duration)
+    #   time built = job1.current_build_duration + job2.current_build_duration + job0.current_build_duration
+    # => (time left / (time left + time built)) * 100
+    def progress
+      return 100 unless @history.first
+      completed_size = @history.first.jobs.select(&:completed?).size
+      completed_size * 100 / @history.first.jobs.size
+    end
+  end
+end

data/lib/cruiseface.rb

@@ -0,0 +1 @@
+require 'cruise_face'

data/rakefile

@@ -0,0 +1,60 @@
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/lib')
+require 'cruise_face'
+
+require 'logger'
+
+ActiveResource::Base.logger = Logger.new(STDOUT)
+ActiveResource::Base.logger.level = Logger::INFO
+
+namespace :dump do
+  task :pipeline_status do
+    CruiseFace.site('https://cruise01.thoughtworks.com/cruise').login('xli', Base64.decode64(ENV['LDAP_CODE']))
+    ps = CruiseFace::Resource.find_pipeline_status
+    File.open "./tast/data/ps.xml", 'w' do |f|
+      f.write ps.to_xml
+    end
+  end
+
+  task :pipeline_history do
+    CruiseFace.site('https://cruise01.thoughtworks.com/cruise').login('xli', Base64.decode64(ENV['LDAP_CODE']))
+    pipeline = CruiseFace.get(ENV['PN'])
+    File.open "./tast/data/#{pipeline.name}.xml", 'w' do |f|
+      f.write pipeline.resource.to_xml
+    end
+    pipeline.history.each do |history_pipeline|
+      history_pipeline.stages.each do |stage_name, stage|
+        begin
+          stage_status = history_pipeline.find_stage_status(stage)
+          File.open "./tast/data/#{history_pipeline.name}-#{history_pipeline.label}-#{stage.name}-#{stage.counter}.xml", 'w' do |f|
+            f.write stage_status.to_xml
+          end
+        rescue => e
+          #ignore cruise stage not exist problem when the pipeline is building
+        end
+      end
+    end
+    puts 'done'
+  end
+  task :stage_status do
+    CruiseFace.site('https://cruise01.thoughtworks.com/cruise').login('xli', Base64.decode64(ENV['LDAP_CODE']))
+    pipeline = CruiseFace::Resource.find_stage_status(ENV['PN'])
+    File.open "./tast/data/#{pipeline.name}.xml", 'w' do |f|
+      f.write pipeline.resource.to_xml
+    end
+    puts 'done'
+  end
+end
+
+require 'echoe'
+
+Echoe.new('cruiseface', '1.0.1') do |p|
+  p.description     = "CruiseFace arms to give a friendly Cruise Pipeline dashboard info for developers."
+  p.url             = "https://github.com/xli/cruiseface"
+  p.author          = "Li Xiao"
+  p.email           = "iam@li-xiao.com"
+  p.ignore_pattern  = "*.gemspec"
+  p.dependencies = ["activeresource", "highline"]
+  p.ignore_pattern = ['tast/*.rb', 'tast/**/*']
+  p.rdoc_options    = %w(--main README.rdoc --inline-source --line-numbers --charset UTF-8)
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: cruiseface
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- Li Xiao
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-12 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: highline
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: CruiseFace arms to give a friendly Cruise Pipeline dashboard info for developers.
+email: iam@li-xiao.com
+executables: 
+- cruiseface
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- TODO
+- bin/cruiseface
+- lib/cruise_face.rb
+- lib/cruise_face/console.rb
+- lib/cruise_face/pipeline.rb
+- lib/cruise_face/resource.rb
+- lib/cruise_face/stage.rb
+- lib/cruiseface.rb
+files: 
+- Manifest
+- README.rdoc
+- TODO
+- bin/cruiseface
+- lib/cruise_face.rb
+- lib/cruise_face/console.rb
+- lib/cruise_face/pipeline.rb
+- lib/cruise_face/resource.rb
+- lib/cruise_face/stage.rb
+- lib/cruiseface.rb
+- rakefile
+- Rakefile
+- cruiseface.gemspec
+has_rdoc: true
+homepage: https://github.com/xli/cruiseface
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --inline-source
+- --line-numbers
+- --charset
+- UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: cruiseface
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: CruiseFace arms to give a friendly Cruise Pipeline dashboard info for developers.
+test_files: []
+