akqa-jenkins 0.6.4.1

data/fixtures/projects/rails-3/public/javascripts/rails.js

@@ -0,0 +1,175 @@
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
+    }
+
+    form.submit();
+  }
+
+
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
+  });
+})();

data/fixtures/projects/rails-3/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/fixtures/projects/rails-3/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/fixtures/projects/rails-3/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionDispatch::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/fixtures/projects/rails-3/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/fixtures/projects/ruby/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gem "rack"

data/fixtures/projects/ruby/Gemfile.lock

@@ -0,0 +1,10 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rack (1.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rack

data/fixtures/projects/ruby/Rakefile

@@ -0,0 +1,4 @@
+desc "Default task runs tests"
+task :default do
+  puts "Tests ran successfully!"
+end

data/jenkins.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jenkins/version"
+
+Gem::Specification.new do |s|
+  s.name        = "akqa-jenkins"
+  s.version     = Jenkins::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Charles Lowell", "Nic Williams"]
+  s.email       = ["cowboyd@thefrontside.net", "drnicwilliams@gmail.com"]
+  s.homepage    = "http://github.com/cowboyd/jenkins.rb"
+  s.summary     = %q{Painless Continuous Integration with Jenkins Server}
+  s.description = %q{A suite of utilities for bringing continous integration to your projects (not the other way around) with jenkins CI}
+
+  s.rubyforge_project = "akqa-jenkins"
+
+  s.files         = `git ls-files`.split("\n")
+
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("term-ansicolor", [">= 1.0.4"])
+  s.add_dependency("httparty", ["~> 0.6.1"])
+  s.add_dependency("builder", ["~> 2.1.2"])
+  s.add_dependency("thor", ["~> 0.14.2"])
+  s.add_dependency("hpricot")
+  s.add_dependency("json_pure", ">= 1.5.1")
+  s.add_development_dependency("jenkins-war", ">= 1.396")
+  s.add_development_dependency("rake", ["~> 0.8.7"])
+  s.add_development_dependency("cucumber", ["~> 0.10.0"])
+  s.add_development_dependency("rspec", ["~> 2.0.0"])
+  s.add_development_dependency("awesome_print")
+end

data/lib/jenkins.rb

@@ -0,0 +1,6 @@
+module Jenkins
+  require 'jenkins/version'
+  require 'jenkins/api'
+  require 'jenkins/job_config_builder'
+  require 'jenkins/project_scm'
+end

data/lib/jenkins/api.rb

@@ -0,0 +1,250 @@
+require 'httparty'
+require 'cgi'
+require 'uri'
+require 'json'
+
+require 'jenkins/core_ext/hash'
+require 'jenkins/config'
+
+module Jenkins
+  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 = setup_authentication(options)
+      options[:host] ||= ENV['JENKINS_HOST']
+      options[:port] ||= ENV['JENKINS_PORT']
+      options[:port] &&= options[:port].to_i
+      return false unless options[:host] || Jenkins::Config.config["base_uri"]
+      uri_class = options.delete(:ssl) ? URI::HTTPS : URI::HTTP
+      uri = options[:host] ? uri_class.build(options) : Jenkins::Config.config["base_uri"]
+      base_uri uri.to_s
+      uri
+    end
+
+    # returns true if successfully create a new job on Jenkins
+    # +job_config+ is a Jenkins::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_configuration!
+          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_configuration!
+      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_configuration!
+        json
+      rescue Crack::ParseError
+        false
+      end
+    end
+
+    # Return a hash of information about a build.
+    def self.build_details(job_name, build_number)
+      begin
+        json = get "/job/#{job_name}/#{build_number}/api/json"
+        cache_configuration!
+        json
+      rescue Crack::ParseError
+        false
+      end
+    end
+
+    def self.nodes
+      json = get "/computer/api/json"
+      cache_configuration!
+      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/jenkins-slave/",
+          :description => "Automatically created by Jenkins.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/jenkins-slave/",
+          :description => "Automatically created by Jenkins.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 Jenkins's crappy API responses
+    def self.post_plain(path, data = "", options = {})
+      options = options.with_clean_keys
+      uri = URI.parse base_uri
+      res = Net::HTTP.start(uri.host, uri.port) do |http|
+        if RUBY_VERSION =~ /1.8/
+          http.post(path, options)
+        else
+          http.post(path, data, options)
+        end
+      end
+    end
+
+    # Helper for GET that don't barf at Jenkins'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
+
+    def self.cache_configuration!
+      Jenkins::Config.config["base_uri"] = base_uri
+      Jenkins::Config.config["basic_auth"] = default_options[:basic_auth]
+      Jenkins::Config.store!
+    end
+
+    private
+    def self.setup_authentication(options)
+      username, password = options.delete(:username), options.delete(:password)
+      if username && password
+        basic_auth username, password
+      elsif Jenkins::Config.config["basic_auth"]
+        basic_auth Jenkins::Config.config["basic_auth"]["username"],
+                   Jenkins::Config.config["basic_auth"]["password"]
+      end
+      options
+    end
+
+    def self.job_url(name)
+      "#{base_uri}/job/#{name}"
+    end
+  end
+end