hudson-remote-api 0.7.0 → 1.0.0

data/hudson-remote-api.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hudson-remote-api/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hudson-remote-api"
+  s.version     = Hudson::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dru Ibarra"]
+  s.email       = ["Druwerd@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Connect to Hudson's remote web API}
+  s.description = %q{Connect to Hudson's remote web API}
+  
+  #s.add_development_dependency "rspec"
+
+  s.rubyforge_project = "hudson-remote-api"
+
+  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/hudson-remote-api.rb

@@ -1,130 +1,5 @@
-# This set of classes provides a Ruby interface to Hudson's web xml API
-# 
-# Author:: Dru Ibarra
-
-require 'net/http'
-require "net/https"
 require 'uri'
-require 'rexml/document'
-require 'cgi'
-require 'yaml'
-require 'zlib'
-require File.dirname(__FILE__) + '/hudson-remote-api/config.rb'
-
-module Hudson
-  # Base class for all Hudson objects
-  class HudsonObject
-    
-    def self.hudson_request(uri,request)
-       Net::HTTP.start(uri.host, uri.port) do |http| 
-        http = Net::HTTP.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 self.load_xml_api
-      @@hudson_xml_api_path = File.join(Hudson[:url], "api/xml")
-      @@xml_api_create_item_path = File.join(Hudson[:url], "createItem")
-    end
-    
-    load_xml_api
-
-    def self.url_for(path)
-      File.join Hudson[:url], path
-    end
-
-    def self.get_xml(url)
-      uri = URI.parse(URI.encode(url))
-      host = uri.host
-      port = uri.port
-      path = uri.path
-      request = Net::HTTP::Get.new(path)
-      request.basic_auth(Hudson[:user], Hudson[:password]) if Hudson[:user] and Hudson[:password]
-      request['Content-Type'] = "text/xml"
-      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 #{path}"
-      end
-    end
-
-    def get_xml(path)
-      self.class.get_xml(path)
-    end
-
-    def self.send_post_request(url, data={})
-      uri = URI.parse(URI.encode(url))
-      host = uri.host
-      port = uri.port
-      path = uri.path
-      request = Net::HTTP::Post.new(path)
-      request.basic_auth(Hudson[:user], Hudson[:password]) if Hudson[:user] and Hudson[:password]
-      request.set_form_data(data)
-      request.add_field(crumb.name, crumb.value) if crumb
-      hudson_request(uri,request)
-    end
-    
-    def send_post_request(url, data={})
-      self.class.send_post_request(url, data)
-    end
-
-    def self.send_xml_post_request(url, xml, data=nil)
-      uri = URI.parse(URI.encode(url))
-      host = uri.host
-      port = uri.port
-      path = uri.path
-      path = path+"?"+uri.query if uri.query
-      request = Net::HTTP::Post.new(path)
-      request.basic_auth(Hudson[:user], Hudson[:password]) if Hudson[:user] and Hudson[:password]
-      request.set_form_data(data) if data
-      request.add_field(crumb.name, crumb.value) if crumb
-      request.body = xml
-      hudson_request(uri,request)
-    end
-    
-    def send_xml_post_request(url, xml, data=nil)
-      self.class.send_xml_post_request(url, xml, data)
-    end
-    
-    
-    
-    def self.crumb
-      @@apiCrumb ||= nil
-    end
-    
-    def self.fetch_crumb
-      if Hudson[:crumb]
-        body = get_xml(url_for '/crumbIssuer/api/xml')
-        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
+require 'net/http'
+require './lib/hudson-remote-api/client.rb'
 
-Dir[File.dirname(__FILE__) + '/hudson-remote-api/*.rb'].each {|file| require file }
+Dir[File.dirname(__FILE__) + '/hudson-remote-api/**/*.rb'].each {|file| require file }

data/lib/hudson-remote-api/build.rb

@@ -1,41 +1,24 @@
 module Hudson
-	class Build < HudsonObject
-		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)
-			if build_number
-				@number = build_number
-			else
-				@number = @job.last_build
-			end
-			@revisions = {}
-			@xml_api_build_info_path = File.join(Hudson[:url], "job/#{@job.name}/#{@number}/api/xml")
-			load_build_info
-		end
-		
-		private
-		def load_build_info
-			
-			build_info_xml = patch_bad_git_xml(get_xml(@xml_api_build_info_path))
-      build_info_doc = REXML::Document.new(build_info_xml)
-      
-      if build_info_doc.elements["/freeStyleBuild/result"]
-        @result = build_info_doc.elements["/freeStyleBuild/result"].text
-      end
-      if !build_info_doc.elements["/freeStyleBuild/changeSet"].nil?
-          build_info_doc.elements.each("/freeStyleBuild/changeSet/revision"){|e| @revisions[e.elements["module"].text] = e.elements["revision"].text }
-      end
+  class Build
+    attr_reader :number, :job, :revisions, :result, :culprit
 
-      if build_info_doc.elements['/freeStyleBuild/culprit/fullName']
-        @culprit = build_info_doc.elements['/freeStyleBuild/culprit/fullName'].text
-      end
+    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
 
-		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)
 
-    def patch_bad_git_xml(xml)
-      xml.gsub(/<(\/?)origin\/([_a-zA-Z0-9\-\.]+)>/, '<\1origin-\2>')
+      @result    = build_info_parser.result
+      @revisions = build_info_parser.revisions
+      @culprit   = build_info_parser.culprit
     end
-	end
+
+  end
 end

data/lib/hudson-remote-api/build_queue.rb

@@ -1,23 +1,16 @@
 module Hudson
-    # This class provides an interface to Hudson's build queue
-    class BuildQueue < HudsonObject
-        
-        def self.load_xml_api
-          @@xml_api_build_queue_info_path = File.join(Hudson[:url], "queue/api/xml")
-        end
-        
-        load_xml_api 
-      
-        # List the jobs in the queue
-        def self.list()
-            xml = get_xml(@@xml_api_build_queue_info_path)
-            queue = []
-            queue_doc = REXML::Document.new(xml)
-            return queue if queue_doc.elements["/queue/item"].nil?
-            queue_doc.each_element("/queue/item/task") do |job|
-                queue << job.elements["name"].text
-            end
-            queue
-        end
+  # 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/hudson-remote-api/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/hudson-remote-api/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