jenkins-remote-api_1 1.0.3

data/jenkins-remote-api_1.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jenkins-remote-api_1/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jenkins-remote-api_1"
+  s.version     = Hudson::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dru Ibarra", "Armen"]
+  s.email       = ["Druwerd@gmail.com", "armen0089@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Connect to Jenkins's remote web API}
+  s.description = %q{Connect to Jenkins's remote web API}
+  
+  #s.add_development_dependency "rspec"
+
+  s.rubyforge_project = "jenkins-remote-api_1"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/jenkins-remote-api_1.rb

@@ -0,0 +1,5 @@
+require 'uri'
+require 'net/http'
+require_relative './jenkins-remote-api_1/client.rb'
+
+Dir[File.dirname(__FILE__) + '/jenkins-remote-api_1/**/*.rb'].each {|file| require file }

data/lib/jenkins-remote-api_1/build.rb

@@ -0,0 +1,24 @@
+module Hudson
+  class Build
+    attr_reader :number, :job, :revisions, :result, :culprit
+
+    def initialize(job, build_number=nil)
+      @job = Job.new(job) if job.kind_of?(String)
+      @job = job if job.kind_of?(Hudson::Job)
+      @number =  build_number || @job.last_build
+      @revisions = {}
+      load_build_info
+    end
+
+    private
+    def load_build_info
+      build_info_xml    = Hudson.client.job_build_info(self.job.name, self.number)
+      build_info_parser = Hudson::Parser::BuildInfo.new(build_info_xml)
+
+      @result    = build_info_parser.result
+      @revisions = build_info_parser.revisions
+      @culprit   = build_info_parser.culprit
+    end
+
+  end
+end

data/lib/jenkins-remote-api_1/build_queue.rb

@@ -0,0 +1,16 @@
+module Hudson
+  # This class provides an interface to Hudson's build queue
+  class BuildQueue
+    
+    class << self
+      def list
+        xml = Hudson.client.build_queue_info
+        build_queue_info_parser = Hudson::Parser::BuildQueueInfo.new(xml)
+
+        build_queue_info_parser.items
+      end
+    end
+
+  end
+
+end

data/lib/jenkins-remote-api_1/client.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/multicast.rb'
+
+module Hudson
+
+  class << self
+    def client(config_settings={})
+      @client ||= Client.new(config_settings)
+    end
+  end
+
+  class Client
+    attr_reader :configuration, :xml_api
+
+    def initialize(config_settings={})
+      @configuration = ::Hudson::Settings.new(config_settings).configuration
+      @xml_api = ::Hudson::XmlApi.new(self.configuration)
+      #fetch_crumb
+    end
+
+    def auto_configure
+      xml_response = ::Hudson.discover
+      if xml_response
+        mulitcast_parser = ::Hudson::Parser::Multicast.new(xml_response)
+        self.configuration.host = mulitcast_parser.url || self.configuration.host
+        self.configuration.version = mulitcast_parser.version || self.configuration.version
+        puts "found Hudson version #{mulitcast_parser.version} @ #{mulitcast_parser.url}"
+        return !mulitcast_parser.url.nil?
+      end
+    end
+
+    def job_build_info(job_name, build_number)
+      get_xml(self.xml_api.build_info_url(job_name, build_number))
+    end
+
+    def build_queue_info
+      get_xml(self.xml_api.build_queue_info_url)
+    end
+
+    def build_job!(job_name, delay=0)
+      send_post_request(self.xml_api.build_url(job_name), {:delay => "#{delay}sec"})
+    end
+
+    def build_job_with_parameters!(job_name, params, delay=0)
+      send_post_request(self.xml_api.build_with_parameters_url(job_name), {:delay => "#{delay}sec"}.merge(params) )
+    end
+
+    def job_config_info(job_name)
+      get_xml(self.xml_api.job_config_url(job_name))
+    end
+
+    def create_item!(params)
+      send_post_request(self.xml_api.create_item_url, params)
+    end
+
+    def delete_job!(job_name)
+      send_post_request(self.xml_api.delete_url(job_name))
+    end
+
+    def disable_job!(job_name)
+      send_post_request(self.xml_api.disable_url(job_name))
+    end
+
+    def enable_job!(job_name)
+      send_post_request(self.xml_api.enable_url(job_name))
+    end
+
+    def job_info(job_name)
+      get_xml(self.xml_api.job_info_url(job_name))
+    end
+
+    def server_info
+      get_xml(self.xml_api.server_info_url)
+    end
+
+    def update_job_config!(job_name, config)
+      send_xml_post_request(self.xml_api.job_config_url(job_name), config)
+    end
+
+    def wipeout_job_workspace!(job_name)
+      send_post_request(self.xml_api.wipeout_workspace_url(job_name))
+    end
+
+    private
+    def patch_bad_git_xml(xml)
+      xml.gsub(/<(\/?)origin\/([_a-zA-Z0-9\-\.]+)>/, '<\1origin-\2>')
+    end
+
+    def http_class
+      if self.configuration.proxy_host && self.configuration.proxy_port
+        ::Net::HTTP::Proxy(self.configuration.proxy_host, self.configuration.proxy_port)
+      else
+        ::Net::HTTP
+      end
+    end
+
+    def hudson_request(uri,request)
+      http_class.start(uri.host, uri.port) do |http|
+        http = http_class.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          http.use_ssl = true
+          http.verify_mode = ::OpenSSL::SSL::VERIFY_NONE
+        end
+        http.request(request)
+      end
+    end
+
+    def get_xml(url)
+      uri = ::URI.parse(URI.encode(url))
+      request = http_class::Get.new(uri.path).tap do |r|
+        r.basic_auth(self.configuration.user, self.configuration.password) if self.configuration.user && self.configuration.password
+        r['Content-Type'] = "text/xml"
+      end
+      
+      response = hudson_request(uri,request)
+
+      if response.is_a?(::Net::HTTPSuccess) or response.is_a?(::Net::HTTPRedirection)
+        encoding = response.get_fields("Content-Encoding")
+        if encoding and encoding.include?("gzip")
+          return ::Zlib::GzipReader.new(::StringIO.new(response.body)).read
+        else
+          return response.body
+        end
+      else
+        $stderr.puts response.body
+        raise APIError, "Error retrieving #{uri.path}"
+      end
+    end
+
+    def send_post_request(url, data={})
+      uri = ::URI.parse(::URI.encode(url))
+      request = http_class::Post.new(uri.path).tap do |r|
+        r.basic_auth(self.configuration.user, self.configuration.password) if self.configuration.user && self.configuration.password
+        r.set_form_data(data)
+        r.add_field(crumb.name, crumb.value) if crumb
+      end
+      
+      hudson_request(uri,request)
+    end
+
+    def send_xml_post_request(url, xml, data=nil)
+      uri = ::URI.parse(URI.encode(url))
+      path = uri.query ? "#{uri.path}?#{uri.query}" : uri.path
+      request = http_class::Post.new(path).tap do |r|
+        r.basic_auth(self.configuration.user, self.configuration.password) if self.configuration.user && self.configuration.password
+        r.set_form_data(data) if data
+        r.add_field(crumb.name, crumb.value) if crumb
+        r.body = xml
+      end
+      
+      hudson_request(uri,request)
+    end
+
+    def crumb
+      @@apiCrumb ||= nil
+    end
+
+    def fetch_crumb
+      if self.configuration.crumb
+        body = get_xml(self.xml_api.crumb_url)
+        doc  = ::REXML::Document.new(body)
+
+        crumbValue = doc.elements['/defaultCrumbIssuer/crumb'] or begin
+          $stderr.puts "Failure fetching crumb value from server"
+          return
+        end
+
+        crumbName = doc.elements['/defaultCrumbIssuer/crumbRequestField'] or begin
+          $stderr.puts "Failure fetching crumb field name from server"
+          return
+        end
+
+        @@apiCrumb = ::Struct.new(:name,:value).new(crumbName.text,crumbValue.text)
+      end
+    rescue
+      $stderr.puts "Failure fetching crumb xml"
+    end
+
+  end
+end

data/lib/jenkins-remote-api_1/errors.rb

@@ -0,0 +1,3 @@
+module Hudson
+    class APIError < StandardError; end
+end

data/lib/jenkins-remote-api_1/hudson_xml_api.rb

@@ -0,0 +1,61 @@
+module Hudson
+  class XmlApi
+    attr_accessor :host
+
+    def initialize(configuration)
+      self.host = configuration.host
+    end
+
+    def build_url(job_name)
+      File.join(self.host, "job/#{job_name}/build")
+    end
+
+    def build_info_url(job_name, build_number)
+      File.join(self.host, "job/#{job_name}/#{build_number}/api/xml")
+    end
+
+    def build_queue_info_url
+      File.join(self.host, "queue/api/xml")
+    end
+
+    def build_with_parameters_url(job_name)
+      File.join(self.host, "job/#{job_name}/buildWithParameters")
+    end
+
+    def create_item_url
+      File.join(self.host, "createItem")
+    end
+
+    def crumb_url
+      File.join(self.host, "/crumbIssuer/api/xml")
+    end
+
+    def delete_url(job_name)
+      File.join(self.host, "job/#{job_name}/doDelete")
+    end
+
+    def disable_url(job_name)
+      File.join(self.host, "job/#{job_name}/disable")
+    end
+
+    def enable_url(job_name)
+      File.join(self.host, "job/#{job_name}/enable")
+    end
+
+    def job_info_url(job_name)
+      File.join(self.host, "job/#{job_name}/api/xml")
+    end
+
+    def job_config_url(job_name)
+      File.join(self.host, "job/#{job_name}/config.xml")
+    end
+
+    def server_info_url
+      File.join(self.host, "api/xml")
+    end
+
+    def wipeout_workspace_url(job_name)
+      File.join(self.host, "job/#{job_name}/doWipeOutWorkspace")
+    end 
+  end
+end

data/lib/jenkins-remote-api_1/job.rb

@@ -0,0 +1,212 @@
+module Hudson
+  # This class provides an interface to Hudson jobs
+  class Job
+    attr_accessor :name, :config, :repository_url, :repository_urls, :repository_browser_location, :description, :parameterized_job
+
+    # Class methods
+    class <<self
+      # List all Hudson jobs
+      def list()
+        xml = Hudson.client.server_info
+        server_info_parser = Hudson::Parser::ServerInfo.new(xml)
+
+        server_info_parser.jobs
+      end
+
+      # List all jobs in active execution
+      def list_active
+        xml = Hudson.client.server_info
+        server_info_parser = Hudson::Parser::ServerInfo.new(xml)
+
+        server_info_parser.active_jobs
+      end
+
+      def get(job_name)
+        job_name.strip!
+        list.include?(job_name) ? Job.new(job_name) : nil
+      end
+
+      def create(name, config=nil)
+        config ||= File.open(File.dirname(__FILE__) + '/new_job_config.xml').read
+        response = Hudson.client.create_item!({:name=>name, :mode=>"hudson.model.FreeStyleProject", :config=>config})
+        raise(APIError, "Error creating job #{name}: #{response.body}") if response.class != Net::HTTPFound
+        Job.get(name)
+      end
+
+    end
+
+    # Instance methods
+    def initialize(name, config=nil)
+      name.strip!
+      # Creates the job in Hudson if it doesn't already exist
+      @name = Job.list.include?(name) ? name : Job.create(name, config).name
+      load_config
+      self
+    end
+
+    # Load data from Hudson's Job configuration settings into class variables
+    def load_config
+      @config = Hudson.client.job_config_info(self.name)
+      @config_info_parser = Hudson::Parser::JobConfigInfo.new(@config)
+      @config_writer = Hudson::XmlWriter::JobConfigInfo.new(self.name, @config)
+
+      @info = Hudson.client.job_info(self.name)
+      @job_info_parser = Hudson::Parser::JobInfo.new(@info)
+
+      @description = @config_info_parser.description
+      @parameterized_job = @config_info_parser.parameterized?
+      @git = @config_info_parser.git_repo?
+      @repository_url = @git ? @config_info_parser.git_repository : @config_info_parser.svn_repository
+      @repostory_urls = @config_info_parser.svn_repository_urls
+      @repository_browser_location = @config_info_parser.scm_broswer_location
+    end
+    alias :reload_config :load_config
+
+    def free_style_project?
+      @free_style_project ||= @job_info_parser.free_style_project?
+    end
+
+    def color
+      @color ||= @job_info_parser.color
+    end
+
+    def last_build
+      @job_info_parser.last_build
+    end
+
+    def last_completed_build
+      @job_info_parser.last_completed_build
+    end
+
+    def last_failed_build
+      @job_info_parser.last_failed_build
+    end
+
+    def last_stable_build
+      @job_info_parser.last_stable_build
+    end
+
+    def last_successful_build
+      @job_info_parser.last_successful_build
+    end
+
+    def last_unsuccessful_build
+      @job_info_parser.last_unsuccessful_build
+    end
+
+    def next_build_number
+      @job_info_parser.next_build_number
+    end
+
+    def builds_list
+      @job_info_parser.builds
+    end
+
+    def active?
+      Job.list_active.include?(self.name)
+    end
+
+    def wait_for_build_to_finish(poll_freq=10)
+      loop do
+        puts "waiting for all #{@name} builds to finish"
+        sleep poll_freq # wait
+        break if !active? and !BuildQueue.list.include?(@name)
+      end
+    end
+
+    # Create a new job on Hudson server based on the current job object
+    def copy(new_job=nil)
+      new_job = "copy_of_#{@name}" if new_job.nil?
+      response = Hudson.client.create_item!({:name=>new_job, :mode=>"copy", :from=>@name})
+      raise(APIError, "Error copying job #{@name}: #{response.body}") if response.class != Net::HTTPFound
+      Job.new(new_job)
+    end
+
+    # Set the repository url and update on Hudson server
+    def repository_url=(repository_url)
+      #return false if @repository_url.nil?
+      if @git
+        @config_writer.git_repository_url = repository_url
+      else
+        @config_writer.svn_repository_url = repository_url
+      end
+      reload_config
+    end
+
+    def repository_urls=(repository_urls)
+      @config_writer.repository_urls = repository_urls
+      reload_config
+    end
+
+    # Set the repository browser location and update on Hudson server
+    def repository_browser_location=(repository_browser_location)
+      if @git
+        @config_writer.git_repository_browser_location = repository_browser_location
+      else
+        @config_writer.svn_repository_browser_location = repository_browser_location
+      end
+      reload_config
+    end
+
+    # Set the job description and update on Hudson server
+    def description=(description)
+      @config_writer.description = description
+      reload_config
+    end
+
+    def triggers= opts={}
+      @config_writer.triggers = opts
+      reload_config
+    end
+
+    def triggers
+      @config_info_parser.triggers
+    end
+
+    #def url
+    #  File.join( Hudson[:url], 'job', self.name) + '/'
+    #end
+
+    # Start building this job on Hudson server
+    def build(params={})
+      if @parameterized_job
+        response = Hudson.client.build_job_with_parameters!(self.name, params)
+      else
+        response = Hudson.client.build_job!(self.name)
+      end
+      
+      yield(response) if block_given?
+      response.is_a?(Net::HTTPSuccess) or response.is_a?(Net::HTTPRedirection)
+    end
+
+    def disable()
+      response = Hudson.client.disable_job!(self.name)
+      response.is_a?(Net::HTTPSuccess) or response.is_a?(Net::HTTPRedirection)
+    end
+
+    def enable()
+      response = Hudson.client.enable_job!(self.name)
+      response.is_a?(Net::HTTPSuccess) or response.is_a?(Net::HTTPRedirection)
+    end
+
+    # Delete this job from Hudson server
+    def delete()
+      response = Hudson.client.delete_job!(self.name)
+      response.is_a?(Net::HTTPSuccess) or response.is_a?(Net::HTTPRedirection)
+    end
+
+    def wipe_out_workspace()
+      wait_for_build_to_finish
+
+      if !active?
+        response = Hudson.client.wipeout_job_workspace!(self.name)
+      else
+        response = false
+      end
+      response.is_a?(Net::HTTPSuccess) or response.is_a?(Net::HTTPRedirection)
+    end
+
+    
+
+  end
+end