autojenkins 0.1

data/bin/mjenk

@@ -0,0 +1,160 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'optparse'
+require 'autojenkins'
+
+URL=''
+AUTH={}
+TOKEN=""
+
+mJENK = AutoJenkins::Jenkins.new(URL, AUTH)
+###
+# Commands
+#
+module AutoJenkins
+    class Command
+        attr_accessor :jenk,
+                      :error,
+                      :errmsg
+    
+        def initialize(jenk)
+            @jenk = jenk
+            @error = 0
+            @errmsg = ""
+        end
+
+    end
+
+    class JobCommand < Command
+        def exec(hash)
+
+             jobs = @jenk.all_jobs()
+             
+             if not hash.key?(:jobname)
+
+                jobs.each do |n|
+                    puts "Name: #{n.name} -> Descr: #{n.get_description} -> URL: #{n.get_url}"
+                end
+
+             else
+                jobs.each do |n|
+                    if n.name == hash[:jobname]
+
+                        if hash.key?(:delete)
+                            n.delete()
+                        elsif hash.key?(:build)
+                            out = n.launch(hash[:token])
+                            if out
+                                puts "Lauch successful"
+                            else
+                                puts "Could not launch"
+                            end
+
+                            puts n.get_url
+                        else 
+                            puts n.get_config()
+                        end
+
+                        return
+                    end
+                end
+
+                @error = 2
+                @errmsg = "Job #{hash[:jobname]} not found"
+             end 
+        end
+    end
+end
+
+cCommands = {
+    "job" => AutoJenkins::JobCommand
+}
+
+# End Commands
+options = {:verbose => false,
+           :build => true,
+           :emails => "",
+           :auth => nil,
+           :token => ""}
+
+p = OptionParser.new do |opts|
+    opts.banner = "Usage: mjenk CMD [options]"
+
+    opts.on("-n", "--dont-run", "Do not run after creating the job") do
+        options[:build] = false
+    end
+
+    opts.on("-v", "--verbose", "Be verbose") do
+        options[:verbose] = true
+    end
+
+    opts.on("-h", "--url URL", String, "Jenkins URL") do |u|
+        URL = u
+    end
+
+    opts.on("-c", "--config-file URL", String, "Jenkins Configuration File") do |cf|
+        options[:auth] = cf
+    end
+
+    opts.on("-j", "--jobname JOBNAME", String, "Name of the job to retrieve") do |n|
+        options[:jobname] = n
+    end
+
+    opts.on("-d", "--delete", String, "Job: If -j is given, delete the job") do |d|
+        options[:delete] = true
+    end
+
+    opts.on("-B", "--build-job", String, "Job: Launches a new build on the given job") do |tst|
+        options[:tests] = tst
+    end
+
+end
+
+p.parse!(ARGV)
+
+if options[:auth] == nil
+    config = File.expand_path("~/.mjenk")
+else
+    config = options[:auth]
+end
+
+auth = AutoJenkins::Helpers.parseConfig(config)
+vCreds = [auth['USER'], auth['PASSWD']]
+vURL = auth['URL']
+
+if options[:token] == nil
+    # Wasn't overriden..
+
+    if auth.has_key?('TOKEN')
+        options[:token] = auth['TOKEN']
+    end
+end
+
+cCMD = nil
+mJENK = AutoJenkins::Jenkins.new(vURL, vCreds)
+
+# Lets process the CMD
+cCMD = "job"
+if ARGV.length > 0
+    cCMD = ARGV[0]
+end
+
+if cCommands.key?(cCMD)
+    cmd = cCommands[cCMD].new(mJENK)
+
+    begin
+        cmd.exec(options)
+    rescue AutoJenkins::ExUnauthorized => e1
+        puts e1.message
+        puts "Got an Unathorized error. Check your credentials."
+    rescue AutoJenkins::ExUndefined => e2
+        puts "Got an Undefined error. Maybe trying to build a disabled job?"
+        puts e2.message
+    end
+
+    if cmd.error != 0
+        puts cmd.errmsg
+        exit cmd.error
+    end
+end

data/lib/autojenkins.rb

@@ -0,0 +1,294 @@
+#Module autojenkins
+#Ruby module to talk with Jenkins using JSON API
+#
+
+require 'pp'
+require 'uri'
+require 'json'
+require 'yaml'
+require 'net/http'
+require 'nokogiri'
+
+module AutoJenkins
+
+    LOGIN = 'LOGIN'
+    PASSWD = 'PASSWD'
+    BASE_URL = "/api/json"
+
+    URLs = {
+        'LIST' => "#{BASE_URL}",
+        'JOBINFO' => "/job/%s#{BASE_URL}",
+        'CONFIG' => "/job/%s/config.xml",
+        '_ABLE' => "/job/%s/%s",
+        'DELETE' => "/job/%s/doDelete",
+        'NEWJOB' => "/createItem?name=%s",
+        'LAUNCH' => "/job/%s/build/api/json",
+        'BUILD' => "/job/%s/%i#{BASE_URL}",
+    }
+
+    class JenkinsException < Exception
+    end
+
+    class ExUnauthorized < Exception
+    end
+
+    class ExUndefined < Exception
+    end
+
+    class Helpers
+
+        def self.parseConfig(config)
+            tree = {}
+
+            begin
+                tree = YAML::parse(File.open(config)).transform
+            rescue 
+                raise IOError, "Config file not found"
+            end
+
+            ['URL', 'USER', 'PASSWD'].each do |k|
+                if not tree.has_key?(k)
+                    raise IndexError.new("Key %s not found in config file" % k)
+                end
+            end
+
+            return tree
+        end
+
+        def self._get_request(jurl, command, args, auth, 
+                              post_args=nil, content_type=nil)
+
+            url = Helpers._build_url(jurl, command, args)
+
+            url_str = (url.query == nil) ? url.path : "#{url.path}?#{url.query}"
+
+            if post_args.nil?:
+                req = Net::HTTP::Get.new(url_str)
+            else
+                req = Net::HTTP::Post.new(url_str)
+                req.body = post_args
+            end
+
+            req.basic_auth auth[LOGIN], auth[PASSWD] 
+
+            res = Net::HTTP.start(url.host, url.port) {|http|
+
+                if content_type
+                    req["Content-Type"] = content_type
+                end
+
+                ret = http.request(req)
+
+                if not [Net::HTTPOK, Net::HTTPFound, Net::HTTPNotFound].include? ret.class 
+                    if ret.instance_of? Net::HTTPUnauthorized
+                        raise ExUnauthorized, "Unauthorized, check your credentials" 
+                    else
+                        raise ExUndefined, "Http request failed!"
+                    end
+                end
+
+                ret
+            }
+
+            #Some requests do not return JSON. Such as config.xml
+            ct = res.get_fields('Content-type')
+
+            if ct.nil?
+                ct = "text/plain"
+            else
+                ct = ct[0] 
+            end
+
+            ctype = ct.split(';')[0]
+
+            if ctype == 'application/javascript' or
+                    ctype == 'application/json'
+                #handle JSON
+                begin
+                    return JSON.parse(res.body)
+                rescue JSON::ParserError
+                    return "{}"
+                end
+            end
+
+            unless res.body.nil?
+                return res.body
+            end
+
+            return "{}"
+        end
+
+        def self._build_url(jurl, command, args)
+            return URI.parse("#{jurl}" + (URLs[command] % args))
+        end
+    
+    end
+
+    class Build
+        attr_accessor :name, 
+                      :url,
+                      :revision, 
+                      :branch, 
+                      :revision, 
+                      :status,
+                      :building,
+                      :node,
+                      :duration
+        def ppretty()
+            print "Name: #{name}\n"
+            print "\tBranch: #{branch}\n"
+            print "\tRevision: #{revision}\n"
+            print "\tStatus: #{status}\n"
+            print "\tDuration: #{duration}\n"
+            print "\tNode: #{node}\n"
+            print "\tBuilding: #{building}\n"
+        end
+    end 
+
+    class Job
+        attr_accessor :info, :name, :jurl, :auth, :is_set
+
+        def initialize(name, jurl, auth, token=nil)
+            @name = name
+            @jurl = jurl
+            @auth = auth
+            @info = false
+
+            if name
+                @e_name = URI.escape(@name)
+                @info = Helpers._get_request(@jurl, 'JOBINFO', URI.escape(name), auth)
+            end
+
+            @is_set = @info ? true : false
+        end
+        
+        def launch(token)
+            res = Helpers._get_request(@jurl, 'LAUNCH',
+                  [@e_name, token], @auth)
+            return true
+        end
+
+        def delete()
+            res = Helpers._get_request(@jurl, 'DELETE',
+                  [@e_name], @auth, post_args="delete=true")
+            return true
+        end
+
+        def get_build(buildnum)
+            res = Helpers._get_request(@jurl, 'BUILD', 
+                [@e_name, buildnum], @auth)
+
+            build = Build.new()
+            begin
+                build.branch = res['actions'][1]['lastBuiltRevision']['branch'][0]['name']
+                build.revision = res['actions'][1]['lastBuiltRevision']['branch'][0]['SHA1']
+            rescue
+            end
+
+            build.status = res['result']
+            build.name = res['fullDisplayName']
+            build.duration = res['duration']
+            build.building = res['building']
+            build.url = res['url']
+            build.node = res['builtOn']
+
+            return build
+        end
+
+        def info_items()
+            return @info.keys
+        end
+
+        def _able_job(action)
+            res = Helpers._get_request(@jurl, '_ABLE', [@e_name, action], @auth, post_args={'data' => ""})
+            return true
+        end 
+
+        def disable()
+            return _able_job('disable')
+        end
+
+        def enable()
+            return _able_job('enable')
+        end
+
+        def copy(jobname, enable=false)
+            config = get_config()
+            return create_job(jobname, config, enable)
+        end
+
+        def create_job(jobname, config, enable=false)
+            sts = Helpers._get_request(@jurl, 'NEWJOB', [URI.escape(jobname)],
+                    @auth, post_args=config, content_type="application/xml")
+
+            newjob = Job.new(jobname, @jurl, @auth)
+
+            unless enable
+                newjob.disable()
+            end
+
+            return newjob
+        end
+
+        def get_config()
+            if @is_set
+                config_xml = Helpers._get_request(@jurl, 'CONFIG', [URI.escape(@name)], @auth)
+                return config_xml
+            end
+            return ""
+        end
+
+        def is_set?()
+            return @is_set
+        end
+
+        def method_missing(name)
+
+            name.to_s =~ /^get_(.*)$/
+            match = $1
+
+            unless match.nil?
+                if @info.has_key? $1
+                    return @info[$1]
+                end
+            end
+
+            return nil
+        end
+    end
+
+    class Jenkins
+        def initialize(s_uri, auth_info, debug=false)
+            @debug = debug
+            @jurl = s_uri
+            @auth = {LOGIN => auth_info[0], PASSWD => auth_info[1]}
+        end
+
+        def get_job(jobname)
+            return Job.new(jobname, @jurl, @auth)
+        end
+
+        def delete_job(jobname)
+            j = get_job(jobname)
+            res = j.delete()
+            return res
+        end
+
+        def create_from_xml(jobname, config_xml)
+            newjob = Job.new(jobname, @jurl, @auth)
+            newjob = newjob.create_job(jobname, config_xml, enable='true') 
+            return newjob
+        end
+
+        def all_jobs()
+            ob_jobs = []
+            jobs = Helpers._get_request(@jurl, 'LIST', [], @auth)
+
+            jobs['jobs'].each do |j|
+                ob_jobs << Job.new(j['name'], @jurl, @auth)
+            end
+
+            return ob_jobs
+        end
+    end
+end

data/lib/test.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'autojenkins'
+
+URL='http://jenkins.ng.com:8080'
+AUTH=["neurogeek", "123qwe4r!!"]
+#TOKEN=""
+
+if URL == ''
+    puts "To use this functions, please configure URL and AUTH"
+end
+JENK = AutoJenkins::Jenkins.new(URL, AUTH)
+
+def ListAll() 
+    jobs = JENK.all_jobs()
+    if jobs
+        jobs.each do |jb|
+            print "#{jb.name} --> #{jb.get_url}\n"
+            print "DisplayName: #{jb.get_displayName}\n"
+            jb.info_items.each do |i|
+                puts i
+            end
+        end
+    end
+end
+
+def CreateFromJob(jobname, newjobname)
+    job = JENK.get_job(jobname)
+    job2 = job.copy(newjobname)
+    print "#{job2.name}\n"
+end
+
+def GetBuildInfo(jobname, buildnum)
+    job = JENK.get_job(jobname)
+    bld = job.get_build(buildnum)
+    return bld
+end
+
+def GetConfig(jobname)
+    job = JENK.get_job(jobname)
+    return job.get_config()
+end
+
+def GetJob(jobname)
+    return  JENK.get_job(jobname)
+end
+
+def GetInfo(jobname)
+    def pretty_print(entry, tab=1)
+
+        if entry.kind_of? Hash 
+            entry.keys.each do |k|
+                print " " * tab * 2
+                print "#{k} ----> \n"
+                pretty_print(entry[k], tab=tab+1)
+            end
+        elsif entry == nil
+            print " " * tab * 2
+            print "[NONE]\n"
+        elsif entry.kind_of? Array
+            entry.each do |v|
+                pretty_print(v, tab+1)
+            end
+        else
+            print "\t" * tab
+            print "#{entry}\n"
+
+        end
+    end
+    job = JENK.get_job(jobname)
+    job.info.keys.each do |k|
+        print "#{k} ----> \n"
+        pretty_print job.info[k]
+    end
+end
+
+# Uncomment to test functions
+#ListAll()
+CreateFromJob("TestJOb", "NewJob")
+#puts GetBuildInfo("TestJOb", 1)
+#puts GetConfig("TestJOb")
+#puts GetInfo("TestJOb")

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: autojenkins
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Jesus Rivero
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-01 00:00:00 Z
+dependencies: []
+
+description: Library to remotely control Jenkins CI. Autojenkins can fetch, create, enable/disable and launch jobs in Jenkins
+email: jesus.riveroa@gmail.com
+executables: 
+- mjenk
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/autojenkins.rb
+- lib/test.rb
+- bin/mjenk
+homepage: https://github.com/neurogeek/autojenkins-rb
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- nokogiri
+- json
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Library to remotely control Jenkins CI
+test_files: []
+