hudson 0.5.0 → 0.6.0

data/features/step_definitions/fixture_project_steps.rb

@@ -1,8 +0,0 @@
-Given /^I am in the "([^\"]*)" project folder$/ do |project|
-  project_folder = File.expand_path(File.dirname(__FILE__) + "/../../fixtures/projects/#{project}")
-  in_tmp_folder do
-    FileUtils.cp_r(project_folder, project)
-    setup_active_project_folder(project)
-  end
-end
-

data/features/step_definitions/hudson_steps.rb

@@ -1,104 +0,0 @@
-Given /^I have a Hudson server running$/ do
-  unless @hudson_port
-    port = 3010
-    begin
-      res = Net::HTTP.start("localhost", port) { |http| http.get('/api/json') }
-      Hudson::Api.base_uri "http://localhost:#{port}"
-    rescue Errno::ECONNREFUSED => e
-      raise Exception, "To run tests, launch hudson in test mode: 'rake hudson:server:test'"
-    end
-    @hudson_port = port.to_s
-    @hudson_host = 'localhost'
-  end
-end
-
-Given /^the Hudson server has no current jobs$/ do
-  if port = @hudson_port
-    Hudson::Api.summary['jobs'].each do |job|
-      Hudson::Api.delete_job(job['name'])
-    end
-    Hudson::Api.summary['jobs'].should == []
-  else
-    puts "WARNING: Run 'I have a Hudson server running' step first."
-  end
-end
-
-Given /^the Hudson server has no slaves$/ do
-  if port = @hudson_port
-    Hudson::Api.summary['jobs'].each do |job|
-      Hudson::Api.delete_job(job['name'])
-    end
-    Hudson::Api.summary['jobs'].should == []
-
-    Hudson::Api.nodes['computer'].each do |node|
-      name = node['displayName']
-      Hudson::Api.delete_node(name) unless name == "master"
-    end
-    Hudson::Api.nodes['computer'].size.should == 1
-  else
-    puts "WARNING: Run 'I have a Hudson server running' step first."
-  end
-end
-
-Given /^there is nothing listening on port (\d+)$/ do |port|
-  lambda {
-    TCPSocket.open("localhost", port) {}
-  }.should raise_error
-end
-
-Given /^I cleanup any hudson processes with control port (\d+)$/ do |port|
-  @hudson_cleanup << port
-end
-
-def try(times, interval = 1)
-  begin
-    times -= 1
-    return yield
-  rescue Exception => e
-    if times >= 0
-      sleep(interval)
-      retry
-    end
-    raise e
-  end
-end
-
-When /^I run hudson server with arguments "(.*)"/ do |arguments|
-  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
-  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin","hudson"))
-  in_project_folder do
-    system "ruby #{executable.inspect} server #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
-  end
-end
-
-
-Then /^I should see a hudson server on port (\d+)$/ do |port|
-  require 'json'
-  try(15, 2) do
-    Hudson::Api.base_uri "http://localhost:#{port}"
-    Hudson::Api.summary['nodeDescription'].should == "the master Hudson node"
-  end
-end
-
-When /^I (re|)create a job$/ do |override|
-  override = override.blank? ? "" : " --override"
-  steps <<-CUCUMBER
-    When the project uses "git" scm
-    When I run local executable "hudson" with arguments "create . --host localhost --port 3010#{override}"
-  CUCUMBER
-end
-
-Then /^the job "([^"]*)" config "([^"]*)" should be:$/ do |job_name, xpath, string|
-  raise "Cannot yet fetch XML config from non-localhost Hudson" unless Hudson::Api.base_uri =~ /localhost/
-  require "hpricot"
-  config = Hpricot.XML(File.read("#{test_hudson_path}/jobs/#{job_name}/config.xml"))
-  config.search(xpath).to_s.should == string
-end
-
-Then /^the Hudson config "([^"]*)" should be:$/ do |xpath, string|
-  raise "Cannot yet fetch XML config from non-localhost Hudson" unless Hudson::Api.base_uri =~ /localhost/
-  require "hpricot"
-  config = Hpricot.XML(File.read("#{test_hudson_path}/config.xml"))
-  config.search(xpath).to_s.should == string
-end
-

data/features/step_definitions/scm_steps.rb

@@ -1,12 +0,0 @@
-Given /^the project uses "git" scm$/ do
-  repo = "git://some.host/drnic/ruby.git"
-  in_project_folder do
-    unless File.exist?(".git")
-      %x[ git init ]
-      %x[ git add . ]
-      %x[ git commit -m "initial commit" ]
-      %x[ git remote add origin #{repo} ]
-    end
-  end
-end
-

data/features/support/common.rb

@@ -1,37 +0,0 @@
-module CommonHelpers
-  def get_command_output
-    strip_color_codes(File.read(@stdout)).chomp
-  end
-
-  def strip_color_codes(text)
-    text.gsub(/\e\[\d+m/, '')
-  end
-
-  def in_tmp_folder(&block)
-    FileUtils.chdir(@tmp_root, &block)
-  end
-
-  def in_project_folder(&block)
-    project_folder = @active_project_folder || @tmp_root
-    FileUtils.chdir(project_folder, &block)
-  end
-
-  def in_home_folder(&block)
-    FileUtils.chdir(@home_path, &block)
-  end
-
-  def force_local_lib_override(project_name = @project_name)
-    rakefile = File.read(File.join(project_name, 'Rakefile'))
-    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
-      f << "$:.unshift('#{@lib_path}')\n"
-      f << rakefile
-    end
-  end
-
-  def setup_active_project_folder project_name
-    @active_project_folder = File.join(@tmp_root, project_name)
-    @project_name = project_name
-  end
-end
-
-World(CommonHelpers)

data/features/support/env.rb

@@ -1,14 +0,0 @@
-$:.unshift(File.expand_path(File.dirname(__FILE__) + "/../../lib"))
-require 'hudson.rb'
-require 'bundler/setup'
-require 'ap'
-
-Before do
-  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
-  @home_path = File.expand_path(File.join(@tmp_root, "home"))
-  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
-  FileUtils.rm_rf   @tmp_root
-  FileUtils.mkdir_p @home_path
-  ENV['HOME'] = @home_path
-  ENV['CUCUMBER_RUNNING'] = 'oooh yes'
-end

data/features/support/hooks.rb

@@ -1,16 +0,0 @@
-require 'socket'
-
-Before do
-  @hudson_cleanup = []
-end
-
-After do
-  for port in @hudson_cleanup do
-    begin
-      TCPSocket.open("localhost", port) do |sock|
-        sock.write("0")
-      end
-    rescue
-    end
-  end
-end

data/features/support/hudson_helpers.rb

@@ -1,6 +0,0 @@
-module HudsonHelper
-  def test_hudson_path
-    "/tmp/test_hudson"
-  end
-end
-World(HudsonHelper)

data/features/support/matchers.rb

@@ -1,10 +0,0 @@
-
-module Matchers
-  RSpec::Matchers.define :contain do |expected_text|
-    match do |text|
-      text.index expected_text
-    end
-  end
-end
-
-World(Matchers)

data/lib/hudson/api.rb

@@ -1,219 +0,0 @@
-require 'httparty'
-require 'cgi'
-require 'uri'
-require 'json'
-
-require 'hudson/core_ext/hash'
-require 'hudson/config'
-
-module Hudson
-  module Api
-    include HTTParty
-
-    headers 'content-type' => 'application/json'
-    format :json
-    # http_proxy 'localhost', '8888'
-    
-    JobAlreadyExistsError = Class.new(Exception)
-
-    def self.setup_base_url(options)
-      options = options.with_clean_keys
-      # Thor's HashWithIndifferentAccess is based on string keys which URI::HTTP.build ignores
-      options = options.inject({}) { |mem, (key, val)| mem[key.to_sym] = val; mem }
-      options[:host] ||= ENV['HUDSON_HOST']
-      options[:port] ||= ENV['HUDSON_PORT']
-      options[:port] &&= options[:port].to_i
-      return false unless options[:host] || Hudson::Config.config["base_uri"]
-      uri = options[:host] ? URI::HTTP.build(options) : Hudson::Config.config["base_uri"]
-      base_uri uri.to_s
-      uri
-    end
-
-    # returns true if successfully create a new job on Hudson
-    # +job_config+ is a Hudson::JobConfigBuilder instance
-    # +options+ are:
-    #   :override - true, will delete any existing job with same name, else error
-    #
-    # returns true if successful, else false
-    #
-    # TODO Exceptions?
-    def self.create_job(name, job_config, options = {})
-      options = options.with_clean_keys
-      delete_job(name) if options[:override]
-      begin
-        res = post "/createItem/api/xml?name=#{CGI.escape(name)}", {
-          :body => job_config.to_xml, :format => :xml, :headers => { 'content-type' => 'application/xml' }
-        }
-        if res.code.to_i == 200
-          cache_base_uri
-          true
-        else
-          require "hpricot"
-          doc = Hpricot(res.body)
-          error_msg = doc.search("td#main-panel p")
-          unless error_msg.inner_text.blank?
-            $stderr.puts error_msg.inner_text
-          else
-            # TODO - what are the errors we get?
-            puts "Server error:"
-            p res.code
-            puts res.body
-          end
-          false
-        end
-      rescue REXML::ParseException => e
-        # For some reason, if the job exists we get back half a page of HTML
-        raise JobAlreadyExistsError.new(name)
-      end
-    end
-    
-    # Attempts to delete a job +name+
-    def self.delete_job(name)
-      res = post_plain "#{job_url name}/doDelete"
-      res.code.to_i == 302
-    end
-    
-    def self.build_job(name)
-      res = get_plain "/job/#{name}/build"
-      res.code.to_i == 302
-    end
-
-    def self.summary
-      json = get "/api/json"
-      cache_base_uri
-      json
-    end
-    
-    def self.job_names
-      summary["jobs"].map {|job| job["name"]}
-    end
-
-    # Return hash of job statuses
-    def self.job(name)
-      begin
-        json = get "/job/#{name}/api/json"
-        cache_base_uri
-        json
-      rescue Crack::ParseError
-        false
-      end
-    end
-
-    def self.nodes
-      json = get "/computer/api/json"
-      cache_base_uri
-      json
-    end
-
-    # Adds SSH nodes only, for now
-    def self.add_node(options = {})
-      options = options.with_clean_keys
-      default_options = Hash.new
-      if options[:vagrant]
-        default_options.merge!(
-          :slave_port  => 2222,
-          :slave_user  => 'vagrant',
-          :master_key  => "/Library/Ruby/Gems/1.8/gems/vagrant-0.6.7/keys/vagrant", # FIXME - hardcoded master username assumption
-          :slave_fs    => "/vagrant/tmp/hudson-slave/",
-          :description => "Automatically created by Hudson.rb",
-          :executors   => 2,
-          :exclusive   => true
-        )
-      else
-        default_options.merge!(
-          :slave_port  => 22,
-          :slave_user  => 'deploy',
-          :master_key  => "/home/deploy/.ssh/id_rsa", # FIXME - hardcoded master username assumption
-          :slave_fs    => "/data/hudson-slave/",
-          :description => "Automatically created by Hudson.rb",
-          :executors   => 2,
-          :exclusive   => true
-        )
-      end
-      options    = default_options.merge(options)
-      
-      slave_host = options[:slave_host]
-      name       = options[:name] || slave_host
-      labels     = options[:labels].split(/\s*,\s*/).join(' ') if options[:labels]
-
-      type = "hudson.slaves.DumbSlave$DescriptorImpl"
-
-      fields = {
-        "name" => name,
-        "type" => type,
-
-        "json"                => {
-          "name"              => name,
-          "nodeDescription"   => options[:description],
-          "numExecutors"      => options[:executors],
-          "remoteFS"          => options[:slave_fs],
-          "labelString"       => labels,
-          "mode"              => options[:exclusive] ? "EXCLUSIVE" : "NORMAL",
-          "type"              => type,
-          "retentionStrategy" => { "stapler-class"  => "hudson.slaves.RetentionStrategy$Always" },
-          "nodeProperties"    => { "stapler-class-bag" => "true" },
-          "launcher"          => {
-            "stapler-class" => "hudson.plugins.sshslaves.SSHLauncher",
-            "host"          => slave_host,
-            "port"          => options[:slave_port],
-            "username"      => options[:slave_user],
-            "privatekey"    => options[:master_key],
-          }
-        }.to_json
-      }
-
-      url = URI.parse("#{base_uri}/computer/doCreateItem")
-
-      req = Net::HTTP::Post.new(url.path)
-      req.set_form_data(fields)
-
-      http = Net::HTTP.new(url.host, url.port)
-
-      response = http.request(req)
-      case response
-      when Net::HTTPFound
-        { :name => name, :slave_host => slave_host }
-      else
-        # error message looks like:
-        # <td id="main-panel">
-        # <h1>Error</h1><p>Slave called 'localhost' already exists</p>
-        require "hpricot"
-        error = Hpricot(response.body).search("td#main-panel p").text
-        unless error.blank?
-          puts error
-        else
-          puts response.body # so we can find other errors
-        end
-        false
-      end
-    end
-    
-    def self.delete_node(name)
-      post_plain("#{base_uri}/computer/#{CGI::escape(name).gsub('+', '%20')}/doDelete/api/json")
-    end
-
-    # Helper for POST that don't barf at Hudson's crappy API responses
-    def self.post_plain(path, options = {})
-      options = options.with_clean_keys
-      uri = URI.parse base_uri
-      res = Net::HTTP.start(uri.host, uri.port) { |http| http.post(path, options) }
-    end
-    
-    # Helper for GET that don't barf at Hudson's crappy API responses
-    def self.get_plain(path, options = {})
-      options = options.with_clean_keys
-      uri = URI.parse base_uri
-      res = Net::HTTP.start(uri.host, uri.port) { |http| http.get(path, options) }
-    end
-    
-    private
-    def self.cache_base_uri
-      Hudson::Config.config["base_uri"] = base_uri
-      Hudson::Config.store!
-    end
-    
-    def self.job_url(name)
-      "#{base_uri}/job/#{name}"
-    end
-  end
-end

data/lib/hudson/cli.rb

@@ -1,253 +0,0 @@
-require 'thor'
-require 'hudson/core_ext/object/blank'
-require 'hudson/core_ext/hash'
-require 'hudson/cli/formatting'
-require 'hudson/remote'
-
-module Hudson
-  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 hudson server on this host'
-      method_option :port, :desc => 'connect to hudson server on this port'
-    end
-
-    desc "server [options]", "run a hudson server"
-    method_option :home, :desc    => "use this directory to store server data", :type => :string, :default => File.join(ENV['HOME'], ".hudson", "server"), :banner => "PATH"
-    method_option :port, :desc    => "run hudson 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"
-    method_option :upgrade, :desc => "upgrade hudson server and plugins to latest version", :type => :boolean
-    def server
-      installation = Hudson::Installation.new(shell, options)
-      if options[:kill]
-        installation.kill!
-        exit(0)
-      elsif options[:upgrade]
-        installation.upgrade!
-        exit(0)
-      else
-        installation.launch!
-      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_hudson_server(options)
-      FileUtils.chdir(project_path) do
-        unless scm = Hudson::ProjectScm.discover(options[:scm])
-          error "Cannot determine project SCM. Currently supported: #{Hudson::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 = Hudson::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 Hudson::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 Hudson.", :green
-            unless options[:"no-build"]
-              shell.say "Triggering initial build..."
-              Hudson::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 Hudson::JobConfigBuilder::InvalidTemplate
-          error "Invalid job template '#{template}'."
-        rescue Hudson::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_hudson_server(options)
-      FileUtils.chdir(project_path) do
-        name = File.basename(FileUtils.pwd)
-        if Hudson::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 Hudson"
-    common_options
-    def remove(project_path)
-      select_hudson_server(options)
-      FileUtils.chdir(project_path) do
-        name = File.basename(FileUtils.pwd)
-        if Hudson::Api.delete_job(name)
-          shell.say "Removed project '#{name}' from Hudson."
-        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_hudson_server(options)
-      if job = Hudson::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 hudson server"
-    common_options
-    def list
-      select_hudson_server(options)
-      summary = Hudson::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 hudson server nodes"
-    common_options
-    def nodes
-      select_hudson_server(options)
-      nodes = Hudson::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 Hudson to connect to slave node (default: deploy)'
-    method_option :"slave-port", :desc => 'SSH port for Hudson 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 Hudson 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_hudson_server(options)
-      if results = Hudson::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_hudson_server({})
-        display Hudson::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 hudson or for a specific command"
-    def help(*args)
-      super(*args)
-    end
-
-    desc "version", "show version information"
-    def version
-      shell.say "#{Hudson::VERSION}"
-    end
-
-    def self.help(shell, *)
-      list = printable_tasks
-      shell.say <<-USEAGE
-Hudson.rb is a smart set of utilities for making
-continuous integration as simple as possible
-
-Usage: hudson 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_hudson_server(options)
-      unless @uri = Hudson::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'] ? 'hudson' : $0
-    end
-  end
-end