jenkins 0.6.0

data/lib/jenkins/cli.rb

@@ -0,0 +1,249 @@
+require 'thor'
+require 'jenkins/core_ext/object/blank'
+require 'jenkins/core_ext/hash'
+require 'jenkins/cli/formatting'
+require 'jenkins/remote'
+
+module Jenkins
+  class CLI < Thor
+    include CLI::Formatting
+
+    map "-v" => :version, "--version" => :version, "-h" => :help, "--help" => :help
+
+    def self.common_options
+      method_option :host, :desc => 'connect to jenkins server on this host'
+      method_option :port, :desc => 'connect to jenkins server on this port'
+    end
+
+    desc "server [options]", "run a jenkins server"
+    method_option :home, :desc    => "use this directory to store server data", :type => :string, :default => File.join(ENV['HOME'], ".jenkins", "server"), :banner => "PATH"
+    method_option :port, :desc    => "run jenkins server on this port", :type => :numeric, :default => 3001, :aliases => "-p"
+    method_option :control, :desc => "set the shutdown/control port", :type => :numeric, :default => 3002, :aliases => "-c"
+    method_option :daemon, :desc  => "fork into background and run as a daemon", :type => :boolean, :default => false
+    method_option :kill, :desc    => "send shutdown signal to control port", :type => :boolean, :aliases => "-k"
+    method_option :logfile, :desc => "redirect log messages to this file", :type => :string, :banner => "PATH"
+    def server
+      begin
+        require 'jenkins/war'
+        Jenkins::War::server(options)
+      rescue LoadError
+        puts "To run a jenkins server, you need to install the jenkins-war gem. try:"
+        puts "gem install jenkins-war"
+      end
+    end
+
+    desc "create project_path [options]", "create a build for your project"
+    common_options
+    method_option :rubies, :desc          => "run tests against multiple explicit rubies via RVM", :type => :string
+    method_option :"node-labels", :desc   => "run tests against multiple slave nodes by their label (comma separated)"
+    method_option :"assigned-node", :desc => "only use slave nodes with this label (similar to --node-labels)"
+    method_option :"no-build", :desc      => "create job without initial build", :type => :boolean, :default => false
+    method_option :override, :desc        => "override if job exists", :type => :boolean, :default => false
+    method_option :"scm", :desc           => "specific SCM URI", :type => :string
+    method_option :"scm-branches", :desc  => "list of branches to build from (comma separated)", :type => :string, :default => "master"
+    method_option :"public-scm", :desc    => "use public scm URL", :type => :boolean, :default => false
+    method_option :template, :desc        => "template of job steps (available: #{JobConfigBuilder::VALID_JOB_TEMPLATES.join ','})", :default => 'ruby'
+    method_option :"no-template", :desc   => "do not use a template of default steps; avoids Gemfile requirement", :type => :boolean, :default => false
+    def create(project_path)
+      select_jenkins_server(options)
+      FileUtils.chdir(project_path) do
+        unless scm = Jenkins::ProjectScm.discover(options[:scm])
+          error "Cannot determine project SCM. Currently supported: #{Jenkins::ProjectScm.supported}"
+        end
+        unless (options[:template] == "none" || options[:"no-template"]) || File.exists?("Gemfile")
+          error "Ruby/Rails projects without a Gemfile are currently unsupported."
+        end
+        begin
+          template = options[:"no-template"] ? 'none' : options[:template]
+          job_config = Jenkins::JobConfigBuilder.new(template) do |c|
+            c.rubies        = options[:rubies].split(/\s*,\s*/) if options[:rubies]
+            c.node_labels   = options[:"node-labels"].split(/\s*,\s*/) if options[:"node-labels"]
+            c.scm           = scm.url
+            c.scm_branches  = options[:"scm-branches"].split(/\s*,\s*/)
+            c.assigned_node = options[:"assigned-node"] if options[:"assigned-node"]
+            c.public_scm    = options[:"public-scm"]
+          end
+          name = File.basename(FileUtils.pwd)
+          if Jenkins::Api.create_job(name, job_config, options)
+            build_url = "#{@uri}/job/#{name.gsub(/\s/,'%20')}/build"
+            shell.say "Added#{' ' + template unless template == 'none'} project '#{name}' to Jenkins.", :green
+            unless options[:"no-build"]
+              shell.say "Triggering initial build..."
+              Jenkins::Api.build_job(name)
+              shell.say "Trigger additional builds via:"
+            else
+              shell.say "Trigger builds via:"
+            end
+            shell.say "  URL: "; shell.say "#{build_url}", :yellow
+            shell.say "  CLI: "; shell.say "#{cmd} build #{name}", :yellow
+          else
+            error "Failed to create project '#{name}'"
+          end
+        rescue Jenkins::JobConfigBuilder::InvalidTemplate
+          error "Invalid job template '#{template}'."
+        rescue Jenkins::Api::JobAlreadyExistsError
+          error "Job '#{name}' already exists."
+        end
+      end
+    end
+    
+    desc "build [PROJECT_PATH]", "trigger build of this project's build job"
+    common_options
+    def build(project_path = ".")
+      select_jenkins_server(options)
+      FileUtils.chdir(project_path) do
+        name = File.basename(FileUtils.pwd)
+        if Jenkins::Api.build_job(name)
+          shell.say "Build for '#{name}' running now..."
+        else
+          error "No job '#{name}' on server."
+        end
+      end
+    end
+    
+    desc "remove PROJECT_PATH", "remove this project's build job from Jenkins"
+    common_options
+    def remove(project_path)
+      select_jenkins_server(options)
+      FileUtils.chdir(project_path) do
+        name = File.basename(FileUtils.pwd)
+        if Jenkins::Api.delete_job(name)
+          shell.say "Removed project '#{name}' from Jenkins."
+        else
+          error "Failed to delete project '#{name}'."
+        end
+      end
+    end
+    
+    desc "job NAME", "Display job details"
+    method_option :hash, :desc => 'Dump as formatted Ruby hash format'
+    method_option :json, :desc => 'Dump as JSON format'
+    method_option :yaml, :desc => 'Dump as YAML format'
+    common_options
+    def job(name)
+      select_jenkins_server(options)
+      if job = Jenkins::Api.job(name)
+        if options[:hash]
+          require "ap"
+          ap job.parsed_response
+        elsif options[:json]
+          puts job.parsed_response.to_json
+        elsif options[:yaml]
+          require "yaml"
+          puts job.parsed_response.to_yaml
+        else
+          error "Select an output format: --json, --xml, --yaml, --hash"
+        end
+      else
+        error "Cannot find project '#{name}'."
+      end
+    end
+
+    desc "list [options]", "list jobs on a jenkins server"
+    common_options
+    def list
+      select_jenkins_server(options)
+      summary = Jenkins::Api.summary
+      unless summary["jobs"].blank?
+        shell.say "#{@uri}:", :bold
+        summary["jobs"].each do |job|
+          bold  = job['color'] =~ /anime/
+          color = 'red' if job['color'] =~ /red/
+          color = 'green' if job['color'] =~ /(blue|green)/
+          color ||= 'yellow' # if color =~ /grey/ || color == 'disabled'
+          shell.say "* "; shell.say(shell.set_color(job['name'], color.to_sym, bold), nil, true)
+        end
+        shell.say ""
+      else
+        shell.say "#{@uri}: "; shell.say "no jobs", :yellow
+      end
+    end
+
+    desc "nodes", "list jenkins server nodes"
+    common_options
+    def nodes
+      select_jenkins_server(options)
+      nodes = Jenkins::Api.nodes
+      nodes["computer"].each do |node|
+        color = node["offline"] ? :red : :green
+        shell.say node["displayName"], color
+      end
+    end
+    
+    desc "add_node SLAVE_HOST", "add a URI (user@host:port) server as a slave node"
+    method_option :labels, :desc       => 'Labels for a job --assigned_node to match against to select a slave (comma separated)'
+    method_option :"slave-user", :desc => 'SSH user for Jenkins to connect to slave node (default: deploy)'
+    method_option :"slave-port", :desc => 'SSH port for Jenkins to connect to slave node (default: 22)'
+    method_option :"master-key", :desc => 'Location of master public key or identity file'
+    method_option :"slave-fs", :desc   => 'Location of file system on slave for Jenkins to use'
+    method_option :name, :desc         => 'Name of slave node (default SLAVE_HOST)'
+    method_option :vagrant, :desc      => 'Use settings for a Vagrant VM', :type => :boolean, :default => false
+    common_options
+    def add_node(slave_host)
+      select_jenkins_server(options)
+      if results = Jenkins::Api.add_node({:slave_host => slave_host}.merge(options))
+        shell.say "Added slave node '#{results[:name]}' to #{results[:slave_host]}", :green
+      else
+        error "Failed to add slave node #{slave_host}"
+      end
+    end
+    
+    desc "default_host", "display current default host:port URI"
+    def default_host
+      if select_jenkins_server({})
+        display Jenkins::Api.base_uri
+      else
+        display "No default host yet. Use '--host host --port port' on your first request."
+      end
+    end
+
+    desc "help [command]", "show help for jenkins or for a specific command"
+    def help(*args)
+      super(*args)
+    end
+
+    desc "version", "show version information"
+    def version
+      shell.say "#{Jenkins::VERSION}"
+    end
+
+    def self.help(shell, *)
+      list = printable_tasks
+      shell.say <<-USEAGE
+Jenkins.rb is a smart set of utilities for making
+continuous integration as simple as possible
+
+Usage: jenkins command [arguments] [options]
+
+USEAGE
+
+      shell.say "Commands:"
+      shell.print_table(list, :ident => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    private
+
+    def select_jenkins_server(options)
+      unless @uri = Jenkins::Api.setup_base_url(options)
+        error "Either use --host or add remote servers."
+      end
+      @uri
+    end
+
+    def display(text)
+      shell.say text
+      exit
+    end
+
+    def error(text)
+      shell.say "ERROR: #{text}", :red
+      exit
+    end
+    
+    def cmd
+      ENV['CUCUMBER_RUNNING'] ? 'jenkins' : $0
+    end
+  end
+end

data/lib/jenkins/cli/formatting.rb

@@ -0,0 +1,53 @@
+require 'term/ansicolor'
+
+module Jenkins
+  class CLI < Thor
+    module Formatting
+      module ClassMethods
+        def task_help(shell, task_name)
+          meth = normalize_task_name(task_name)
+          task = all_tasks[meth]
+          handle_no_task_error(meth) unless task
+
+          shell.say "usage: #{banner(task)}"
+          shell.say
+          class_options_help(shell, nil => task.options.map { |_, o| o })
+          # shell.say task.description
+          # shell.say
+        end
+
+
+        def print_options(shell, options, grp = nil)
+          return if options.empty?
+          table = options.map do |option|
+            prototype = if option.default
+              " [#{option.default}]"
+            elsif option.boolean?
+              ""
+            elsif option.required?
+              " #{option.banner}"
+            else
+              " [#{option.banner}]"
+            end
+            aliases = option.aliases.empty? ? "" : option.aliases.join(" ") + ","
+            [aliases, "--#{option.name}#{prototype}", "\t",option.description]
+          end
+          shell.print_table(table, :ident => 2)
+          shell.say
+        end
+      end
+
+      module InstanceMethods
+        def c
+          Term::ANSIColor
+        end
+      end
+
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+  end
+end
+

data/lib/jenkins/config.rb

@@ -0,0 +1,27 @@
+module Jenkins
+  module Config
+    extend self
+    
+    def [](key)
+      config[key]
+    end
+    
+    def config
+      @config ||= if File.exist?(config_file)
+        JSON.parse(File.read(config_file))
+      else
+        {}
+      end
+    end
+    
+    def store!
+      @config ||= {}
+      FileUtils.mkdir_p(File.dirname(config_file))
+      File.open(config_file, "w") { |file| file << @config.to_json }
+    end
+    
+    def config_file
+      @config_file ||= "#{ENV['HOME']}/.jenkins/jenkinsrb-config.json"
+    end
+  end
+end

data/lib/jenkins/core_ext/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def with_clean_keys
+    self.inject({}) do |mem, (key, value)|
+      clean_key = key.to_s.gsub(/-/,"_").to_sym
+      mem[clean_key] = value
+      mem
+    end
+  end
+end

data/lib/jenkins/core_ext/object/blank.rb

@@ -0,0 +1,77 @@
+# Vendored from activesupport 3.0.1
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies:
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # ...to:
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+
+  # Returns object if it's #present? otherwise returns nil.
+  # object.presence is equivalent to object.present? ? object : nil.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all.  For example, this simplifies a common check for
+  # HTTP POST/query parameters:
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # ...becomes:
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  def presence
+    self if present?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/jenkins/job_config_builder.rb

@@ -0,0 +1,287 @@
+require "builder"
+
+module Jenkins
+  class JobConfigBuilder
+    attr_accessor :job_type
+    attr_accessor :steps, :rubies
+    attr_accessor :scm, :public_scm, :scm_branches
+    attr_accessor :scm, :public_scm, :git_branches
+    attr_accessor :assigned_node, :node_labels # TODO just one of these
+    attr_accessor :envfile
+    
+    InvalidTemplate = Class.new(StandardError)
+    
+    VALID_JOB_TEMPLATES = %w[none rails rails3 ruby rubygem]
+    
+    # +job_type+ - template of default steps to create with the job
+    # +steps+ - array of [:method, cmd], e.g. [:build_shell_step, "bundle initial"]
+    #   - Default is based on +job_type+.
+    # +scm+           - URL to the repository. Currently only support git URLs.
+    # +public_scm+    - convert the +scm+ URL to a publicly accessible URL for the Jenkins job config.
+    # +scm_branches+  - array of branches to run builds. Default: ['master']
+    # +rubies+        - list of RVM rubies to run tests (via Jenkins Axes).
+    # +assigned_node+ - restrict this job to running on slaves with these labels (space separated)
+    def initialize(job_type = :ruby, &block)
+      self.job_type = job_type.to_s if job_type
+      
+      yield self
+
+      self.scm_branches ||= ["master"]
+      raise InvalidTemplate unless VALID_JOB_TEMPLATES.include?(job_type.to_s)
+    end
+  
+    def builder
+      b = Builder::XmlMarkup.new :indent => 2
+      b.instruct!
+      b.tag!(matrix_project? ? "matrix-project" : "project") do
+        b.actions
+        b.description
+        b.keepDependencies false
+        b.properties
+        build_scm b
+        b.assignedNode assigned_node if assigned_node
+        b.canRoam !assigned_node
+        b.disabled false
+        b.blockBuildWhenUpstreamBuilding false
+        b.triggers :class => "vector"
+        b.concurrentBuild false
+        build_axes b if matrix_project?
+        build_steps b
+        b.publishers
+        build_wrappers b
+        b.runSequentially false if matrix_project?
+      end
+    end
+  
+    def to_xml
+      builder.to_s
+    end
+  
+    protected
+    
+    # <scm class="hudson.plugins.git.GitSCM"> ... </scm>
+    def build_scm(b)
+      if scm && scm =~ /git/
+        scm_url = public_scm ? public_only_git_scm(scm) : scm
+        b.scm :class => "hudson.plugins.git.GitSCM" do
+          b.configVersion 1
+          b.remoteRepositories do
+            b.tag! "org.spearce.jgit.transport.RemoteConfig" do
+              b.string "origin"
+              b.int 5
+              b.string "fetch"
+              b.string "+refs/heads/*:refs/remotes/origin/*"
+              b.string "receivepack"
+              b.string "git-upload-pack"
+              b.string "uploadpack"
+              b.string "git-upload-pack"
+              b.string "url"
+              b.string scm_url
+              b.string "tagopt"
+              b.string
+            end
+          end
+        
+          if scm_branches
+            b.branches do
+              scm_branches.each do |branch|
+                b.tag! "hudson.plugins.git.BranchSpec" do
+                  b.name branch
+                end
+              end
+            end
+          end
+        
+          b.localBranch
+          b.mergeOptions
+          b.recursiveSubmodules false
+          b.doGenerateSubmoduleConfigurations false
+          b.authorOrCommitter false
+          b.clean false
+          b.wipeOutWorkspace false
+          b.buildChooser :class => "hudson.plugins.git.util.DefaultBuildChooser"
+          b.gitTool "Default"
+          b.submoduleCfg :class => "list"
+          b.relativeTargetDir
+          b.excludedRegions
+          b.excludedUsers
+        end
+      end
+    end
+
+    def matrix_project?
+      !(rubies.blank? && node_labels.blank?)
+    end
+  
+    # <hudson.matrix.TextAxis>
+    #   <name>RUBY_VERSION</name>
+    #   <values>
+    #     <string>1.8.7</string>
+    #     <string>1.9.2</string>
+    #     <string>rbx-head</string>
+    #     <string>jruby</string>
+    #   </values>
+    # </hudson.matrix.TextAxis>
+    # <hudson.matrix.LabelAxis>
+    #   <name>label</name>
+    #   <values>
+    #     <string>1.8.7</string>
+    #     <string>ubuntu</string>
+    #   </values>
+    # </hudson.matrix.LabelAxis>
+    def build_axes(b)
+      b.axes do
+        unless rubies.blank?
+          b.tag! "hudson.matrix.TextAxis" do
+            b.name "RUBY_VERSION"
+            b.values do
+              rubies.each do |rvm_name|
+                b.string rvm_name
+              end
+            end
+          end
+        end
+        unless node_labels.blank?
+          b.tag! "hudson.matrix.LabelAxis" do
+            b.name "label"
+            b.values do
+              node_labels.each do |label|
+                b.string label
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    # Example:
+    # <buildWrappers>
+    #   <hudson.plugins.envfile.EnvFileBuildWrapper>
+    #     <filePath>/path/to/env/file</filePath>
+    #   </hudson.plugins.envfile.EnvFileBuildWrapper>
+    # </buildWrappers>
+    def build_wrappers(b)
+      if envfile
+        b.buildWrappers do
+          self.envfile = [envfile] unless envfile.is_a?(Array)
+          b.tag! "hudson.plugins.envfile.EnvFileBuildWrapper" do
+            envfile.each do |file|
+              b.filePath file
+            end
+          end
+        end
+      else
+        b.buildWrappers
+      end
+    end
+    
+    # The important sequence of steps that are run to process a job build.
+    # Can be defaulted by the +job_type+ using +default_steps(job_type)+,
+    # or customized via +steps+ array.
+    def build_steps(b)
+      b.builders do
+        self.steps ||= default_steps(job_type)
+        steps.each do |step|
+          method, cmd = step
+          send(method.to_sym, b, cmd) # e.g. build_shell_step(b, "bundle install")
+        end
+      end
+    end
+    
+    def default_steps(job_type)
+      steps = case job_type.to_sym
+      when :rails, :rails3
+        [
+          [:build_shell_step, "bundle install"],
+          [:build_ruby_step, <<-RUBY.gsub(/^            /, '')],
+            unless File.exist?("config/database.yml")
+              require 'fileutils'
+              example = Dir["config/database*"].first
+              puts "Using \#{example} for config/database.yml"
+              FileUtils.cp example, "config/database.yml"
+            end
+            RUBY
+          [:build_shell_step, "bundle exec rake db:create:all"],
+          [:build_shell_step, <<-RUBY.gsub(/^            /, '')],
+            if [ -f db/schema.rb ]; then
+              bundle exec rake db:schema:load
+            else
+              bundle exec rake db:migrate
+            fi
+            RUBY
+          [:build_shell_step, "bundle exec rake"]
+        ]
+      when :ruby, :rubygems
+        [
+          [:build_shell_step, "bundle install"],
+          [:build_shell_step, "bundle exec rake"]
+        ]
+      else
+        [ [:build_shell_step, 'echo "THERE ARE NO STEPS! Except this one..."'] ]
+      end
+      rubies.blank? ? steps : default_rvm_steps + steps
+    end
+    
+    def default_rvm_steps
+      [
+        [:build_shell_step, "rvm $RUBY_VERSION"],
+        [:build_shell_step, "rvm gemset create ruby-$RUBY_VERSION && rvm gemset use ruby-$RUBY_VERSION"]
+      ]
+    end
+    
+    # <hudson.tasks.Shell>
+    #   <command>echo &apos;THERE ARE NO STEPS! Except this one...&apos;</command>
+    # </hudson.tasks.Shell>
+    def build_shell_step(b, command)
+      b.tag! "hudson.tasks.Shell" do
+        b.command command.to_xs.gsub("&amp;", '&') #.gsub(%r{"}, '&quot;').gsub(%r{'}, '&apos;')
+      end
+    end
+
+    # <hudson.plugins.ruby.Ruby>
+    #   <command>unless File.exist?(&quot;config/database.yml&quot;)
+    #   require &apos;fileutils&apos;
+    #   example = Dir[&quot;config/database*&quot;].first
+    #   puts &quot;Using #{example} for config/database.yml&quot;
+    #   FileUtils.cp example, &quot;config/database.yml&quot;
+    # end</command>
+    # </hudson.plugins.ruby.Ruby>
+    def build_ruby_step(b, command)
+      b.tag! "hudson.plugins.ruby.Ruby" do
+        b.command do
+          b << command.to_xs.gsub(%r{"}, '&quot;').gsub(%r{'}, '&apos;')
+        end
+      end
+    end
+  
+    # Usage: build_ruby_step b, "db:schema:load"
+    #
+    # <hudson.plugins.rake.Rake>
+    #   <rakeInstallation>(Default)</rakeInstallation>
+    #   <rakeFile></rakeFile>
+    #   <rakeLibDir></rakeLibDir>
+    #   <rakeWorkingDir></rakeWorkingDir>
+    #   <tasks>db:schema:load</tasks>
+    #   <silent>false</silent>
+    # </hudson.plugins.rake.Rake>
+    def build_rake_step(b, tasks)
+      b.tag! "hudson.plugins.rake.Rake" do
+        b.rakeInstallation "(Default)"
+        b.rakeFile
+        b.rakeLibDir
+        b.rakeWorkingDir
+        b.tasks tasks
+        b.silent false
+      end
+    end
+    
+    # Converts git@github.com:drnic/newgem.git into git://github.com/drnic/newgem.git
+    def public_only_git_scm(scm_url)
+      if scm_url =~ /git@([\w\-_.]+):(.+)\.git/
+        "git://#{$1}/#{$2}.git"
+      else
+        scm_url
+      end
+    end
+  end
+end