hudkins 0.0.1

data/lib/hudkins/jobs.rb

@@ -0,0 +1,86 @@
+class Hudkins
+  # this class is just a convenience wrapper around an array of jobs.
+  # _FIX_ consider that Enumerable methods returns a Hudkins::Jobs obj instead of an array..
+  class Jobs
+    include Hudkins::Common
+    include Enumerable
+
+    def initialize(hudkins)
+      @hudkins = hudkins
+      data = @hudkins.get_parsed( "/api/json", :accept => "application/json" )
+      @jobs = Array.new
+      data["jobs"].each do |job|
+        @jobs << Hudkins::Job.new( @hudkins, job )
+      end
+    end
+
+    def inspect
+      super
+    end
+
+    # Enumerable
+    # This returns @jobs if no block_given.. so in effect we can use array
+    # methods like this: jobs.each.last
+    # is this hacky? Normal?
+    def each
+      @jobs.each do |job|
+        yield job if block_given?
+      end
+    end
+
+    def size
+      @jobs.size
+    end
+
+    ##
+    # === Description
+    # convenience method for returning all (or part) of just the names of jobs
+    def names name = ""
+      find_all_by_name( name ).map(&:name)
+    end
+
+    ##
+    # :method: find_by_
+    # === Description
+    # Implements find_by_ and find_all_by_ methods according to any method to
+    # which that job responds.
+    #
+    # === Examples
+    #   jobs.find_by_name "job_name"
+    #
+    #   jobs.find_all_by_url /svn/x
+
+    ##
+    # nodoc
+    def method_missing sym, *args, &block # :nodoc:
+      meth, name = missing_method_name( sym )
+      if name
+        self.send(meth) do |job|
+          # I can't remember why I'm using union... :/
+          # job.send(name).to_s.gsub(/-/, "_") =~ Regexp.union( args.map(&:to_s) )
+          # args is an array because of method_missing. but find(_all)_by only
+          # takes one parameter (for now..)
+          # to_s for symbols, also removes warnings if given a regexp with options.
+          arg = args.first.to_s #.gsub(/-/, "_")
+          regex = Regexp.new(arg, Regexp::IGNORECASE)
+          # gsub used so I can pass in symbols as names (which don't allow dashes
+          # to_s as job.url returns a URI
+          job.send(name).to_s.gsub(/-/, "_") =~ regex
+        end
+      else
+        super sym, *args, &block
+      end
+    end
+
+    def respond_to? sym
+      missing_method_name sym or super sym
+    end
+
+    private
+      def missing_method_name sym # :nodoc:
+        # (find|find_all)_by_(name|url|...)
+        [$1, $2] if sym.to_s =~ /^(.*)_by_(.*)$/ and Hudkins::Job.method_defined? $2
+      end
+
+  end
+end

data/lib/hudkins/mixin.rb

@@ -0,0 +1,103 @@
+#--
+##
+# attr_accessor_from_config :method_name, "search_path"[, type]
+# attr_reader_from_config :method_name, "search_path"[, type]
+# attr_writer_from_config :method_name, "search_path"[, type]
+#++
+
+class Hudkins
+  ##
+  # extend Hudkins::Mixin to include DSL style methods
+  module Mixin
+    ##
+    # === Description
+    # Similar to attr_reader but takes additional parameters
+    #
+    # :bool type addes a method_name? alias
+    #
+    # === Examples:
+    #   class MyObj
+    #     attr_reader_from_config :disabled, "//project//disabled", :bool
+    #   end
+    #
+    #   MyObj.new.disabled? # => true
+    #
+    # === Parameters:
+    #
+    # +method_name+::   attr_reader method name
+    # +search_path+::   Nokogiri.at search path
+    # +type+::          :fixnum   # => converts config content to integer
+    #
+    #                   :bool     # => creates a boolean reader method. useful
+    #                                 when the config returns string "true" but True class is
+    #                                 desirable
+    #                   Class     # => ie. a value of `Integer' will result in
+    #                                 typecasting via Integer(value)
+    def attr_reader_from_config method_name, search_path, type = :default
+      # could we do something like inspect el.children.size? for arrays?
+      define_method method_name do
+        el = config.at(search_path)
+        if el
+          case type
+          when :bool then
+            /true/i === el.content
+          when :fixnum, :int then
+            el.content.to_i
+          when :array then
+            warn ":array not implemented yet"
+            #value = []
+            #el.children
+          when Class then
+            # Integer(value)
+            Kernel.send(type.name, el.content)
+          else
+            el.content
+          end
+        else
+          warn "`#{search_path}' was not found in config."
+        end
+      end
+      # use alias_method instead of explicitely defining the method so I can
+      # call the method_name without the ? in internal methods.
+      alias_method "#{method_name}?".to_sym, method_name if :bool === type
+    end
+
+    ##
+    # === Description
+    # see attr_reader_from_config
+    #
+    # update config node
+    def attr_writer_from_config method_name, search_path, type = :default
+      define_method "#{method_name}=".to_sym do |arg|
+        config.at(search_path).content = arg
+        arg
+      end
+    end
+
+    ##
+    # === Description
+    # see attr_reader_from_config
+    #
+    # (optionally) update config node and immediately post back the config then
+    # return the updated value
+    #
+    # `!' is added to end of method_name to signify post call
+    def attr_post_from_config method_name, search_path, type = :default
+      attr_reader_from_config method_name, search_path, type unless self.respond_to? method_name
+      define_method "#{method_name}!".to_sym do |arg|
+        # complains if arg isn't given..
+        send("#{method_name}=", arg) if arg
+        post_config!
+        self.send(method_name)
+      end
+    end
+
+    ##
+    # combines attr_{reader,writer,post}_from_config
+    def attr_accessor_from_config *args
+      attr_reader_from_config *args
+      attr_writer_from_config *args
+      attr_post_from_config *args
+    end
+  end
+end

data/lib/hudkins/rake.rb

@@ -0,0 +1,20 @@
+require "rubygems"
+require "rest_client"
+require "json"
+#require "active_record"
+require "nokogiri"
+
+$: << File.join( File.dirname( __FILE__ ), ".." )
+require 'hudkins'
+
+# Load our rakefile extensions
+Dir["#{File.dirname(__FILE__)}/../tasks/**/*.rake"].sort.each { |ext| load ext }
+
+##
+# rake hudkins:update job=rservices-m
+#
+# rake hudkins:update_main
+# rake hudkins:update_release_candidate
+# rake hudkins:update_in_production
+#
+# rake hudkins:update:rservices_main

data/lib/hudkins/restclient.rb

@@ -0,0 +1,130 @@
+class Hudkins
+  ##
+  # === Description
+  # Convenience class for RestClient responses
+  #
+  # RestClient.get returns (configurable via &block parameter to Hudkins#get)
+  # [#response, #request, #result]. I wanted to have all these available but
+  # not as an array :/
+  #
+  # === Example
+  #   # get response headers
+  #   hud.get( "/path" ).response.headers
+  #
+  #   # do something based on response success
+  #   response = hud.get "/path"
+  #   raise response.message unless response.success?
+  class Response
+    attr_accessor :response, :request, :result
+    ##
+    # === Example
+    # hud.get("/path") do |*args|
+    #   Hudkins::Response.new( *args )
+    # end
+    # # => returns Hudkins::Response object
+    def initialize response, request, result
+      @response = response
+      @request = request
+      @result = result
+    end
+
+    ##
+    # === Description
+    # response = get "/path"
+    # JSON.pasre response.body
+    def body
+      response.body
+    end
+
+    ##
+    # === Description
+    # response status code
+    def code
+      result.code.to_i
+    end
+
+    ##
+    # === Description
+    # RestClient response error
+    def errors
+      RestClient::Exceptions::EXCEPTIONS_MAP[response.code].new response
+    end
+
+    ##
+    # === Description
+    # #errors message
+    def message
+      errors.message
+    end
+
+    ##
+    # === Description
+    # was the response successful?
+    # does a simple test if the response code was 2xx
+    def success?
+      # I think RestClient::Response doesn't use Net::HTTP... any more, but I
+      # couldn't figure out how they want you to do this without doing case
+      # format or something like RestClient::Ok.. etc. (There is no equivalent
+      # RestClient::Success, although there is a RestClient::Redirect
+      case result
+      when Net::HTTPSuccess, Net::HTTPRedirection then
+        true
+      else
+        false
+      end
+      #case code
+      #when (200..299)
+        #true
+      #when (302) 
+        ## Found. seems to be status code for successful posts.. :/
+        #true
+      #else
+        #false
+      #end
+    end
+    # http_body.match(/<h1>Error<\/h1><p>([^<]*)<\/p>/)[0]
+
+    ##
+    # Hudson returns type :javascript for get "/api/json" even if I explicietly set the :accept header
+    # and :html for config.xml
+    # so I'm going to use the request headers to get the returned content type... blah
+
+    def response_type
+      # unbelievable hudson!
+      # this probably isn't the best way, but MIME::Types returns an array...
+      MIME::Type.new request.headers[:accept]
+    end
+
+    def type
+      response_type.sub_type.to_sym
+    end
+  end
+
+  # the idea behind this is that if the hudson server isn't available,
+  # getaddrinfo has a really long timeout.. like over 20 seconds! This is
+  # really a DNS issue, but I still don't want to wait that long and I couldn't
+  # figure out how to set a better timeout.
+  module HostLookup
+    # defaults to 2
+    TIMEOUT = 2
+    ##
+    # timeout Socket.getaddrinfo after TIMEOUT seconds
+    #
+    # returns true/false
+    def self.available? uri, timeout = nil
+      timeout ||= TIMEOUT
+      pid = fork do
+        Socket.getaddrinfo( uri.host, uri.scheme )
+      end
+      begin
+        Timeout::timeout(timeout) do 
+          Process.wait(pid)
+        end
+        true
+      rescue Timeout::Error
+        Process.kill(9, pid)
+        false
+      end
+    end
+  end
+end

data/lib/hudkins/sysinfo.rb

@@ -0,0 +1,11 @@
+
+
+def find_svn_url host_name
+  url = "http://example.com/_priv/sysinfo"
+  uri = URI.parse url
+  uri.host = host_name
+  body = RestClient.get uri.to_s
+  # is there a better way to do this? Rservices and Syndication differ in where
+  # they put this info
+  svn_url = body.scan(/repository":"([^ ]*) r\d*",/).first
+end

data/test/fixtures/config.erb

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?><project>
+<actions/>
+<description/>
+<keepDependencies>false</keepDependencies>
+<properties/>
+<scm class="hudson.scm.SubversionSCM">
+<locations>
+<hudson.scm.SubversionSCM_-ModuleLocation>
+<remote>https://subversion/project_name/branches/current_branch</remote>
+<local>.</local>
+</hudson.scm.SubversionSCM_-ModuleLocation>
+</locations>
+<useUpdate>true</useUpdate>
+<doRevert>false</doRevert>
+<excludedRegions/>
+<includedRegions/>
+<excludedUsers/>
+<excludedRevprop/>
+<excludedCommitMessages/>
+</scm>
+<canRoam>true</canRoam>
+<disabled>true</disabled>
+<blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+<triggers class="vector"/>
+<concurrentBuild>false</concurrentBuild>
+<builders/>
+<publishers/>
+<buildWrappers/>
+</project>
+

data/test/fixtures/jobs.erb

@@ -0,0 +1,22 @@
+{"assignedLabels":[{}],
+"mode":"NORMAL",
+"nodeDescription":"the master Hudson node",
+"nodeName":"",
+"numExecutors":2,
+"description":null,
+"jobs":[
+{"name":"project_name",
+"url":"http://example.com/job/project_name/",
+"color":"blue"},
+{"name":"project_name2",
+"url":"http://example.com/job/project_name2/",
+"color":"blue"}],
+"overallLoad":{},
+"primaryView":{"name":"All",
+"url":"http://example.com/"},
+"slaveAgentPort":0,
+"useCrumbs":false,
+"useSecurity":false,
+"views":[{"name":"All",
+"url":"http://example.com/"}]}
+

data/test/fixtures/new_project_config.erb

@@ -0,0 +1,14 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project>
+  <keepDependencies>false</keepDependencies>
+  <properties/>
+  <scm class="hudson.scm.NullSCM"/>
+  <canRoam>true</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+  <triggers class="vector"/>
+  <concurrentBuild>false</concurrentBuild>
+  <builders/>
+  <publishers/>
+  <buildWrappers/>
+</project>

data/test/test_helper.rb

@@ -0,0 +1,50 @@
+require "rubygems"
+require 'minitest/unit'
+require "mocha"
+require "ostruct"
+require "erb"
+MiniTest::Unit.autorun
+
+
+class MiniTest::Unit::TestCase
+
+  # minitest probably already has a fixtures something. but I don't have access
+  # to the docs currently.
+  # mock_files.config # => test/fixtures/config.erb
+  def mock_files
+    @mock_files ||= begin
+      obj = OpenStruct.new
+      glob = File.join( File.dirname(__FILE__), "fixtures", "*.erb")
+      files = Dir.glob( glob )
+      files.each do |file|
+        name = File.basename( file, ".erb" ).gsub(/\.-/, "_")
+        result = File.read( file )
+        content = ERB.new(result, 0, "%<>").result(binding)
+        obj.send "#{name}=", content # ruby is pretty amazing!
+      end
+      obj
+    end
+  end # mock_files
+
+  def hudkins_setup
+    @host = "http://example.com"
+    @hud = Hudkins.new @host
+    @mock_response = mock("response").responds_like(Hudkins::Response.new 1,2,3)
+    @mock_response.stubs(:success?).returns(true)
+    mock_rc_resource(:get, mock_files.jobs, :json)
+    @hud.jobs
+  end
+
+  def mock_rc_resource method, body = nil, type = nil
+    @mock_response.stubs(:body).returns(body) if body
+    @mock_response.stubs(:type).returns(type) if type
+    rc_request = RestClient::Request.expects(:execute).with(has_entry(:method => method))
+    if block_given?
+      yield(rc_request)
+    else
+      rc_request.returns( @mock_response )
+    end
+  end
+
+
+end # MiniTest::Unit::TestCase