jenkins2 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 755ca5e600a8dcf27d558a859feb3dcea22cf14c
+  data.tar.gz: 6bd09c8366e2e0069a6139d25ba51bb6c87ceb4d
+SHA512:
+  metadata.gz: dfce468bca6cf11efdc4cbaee51a7ae142bd0a7cb0d8e3e24827f3facbdf71085f816e162df80c035749c8ccad0b16cec736c6f789841cb55c0d5fc012af47d7
+  data.tar.gz: e9af7dca064ea182b7e8d3bd6ca66de161438d1a7ceb89ab231588ff72a7d630515ffee33f9bedba8fe723ac1b4aa12f2bbc490d466847aa8b705ce60370e64d

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Change Log
+
+## [v0.0.2](https://bitbucket.org/DracoAter/jenkins2/commits/tag/v0.0.2) (2016-10-25)
+### Enhancements
+- Hopefully this gem is now usable
+- Get Jenkins version
+- Prepare for / cancel Jenkins shutdown
+- Wait for all nodes to be idle
+- Set node temporarily offline / online
+- Connect / Disconnect node
+- Wait for node to become idle, check if node is idle
+- Get node definition as XML
+- Update node definition from XML
+- Run [parameterized] build
+- List installed plugins
+- Install / uninstall a plugin by short name (i.e. ssh-credentials)
+- Create username with password credential ( Requires credentials plugin on Jenkins )
+- Create ssh username with private key credential ( Requires ssh-credentials plugin on Jenkins )
+- Create secret string credential ( Requires plain-credentials plugin on Jenkins )
+- Create secret file credential ( Requires plain-credentials plugin on Jenkins )
+- Get credential by id
+- List credentials

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (C) 2016 by Juri Timošin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# Jenkins2
+
+Jenkins2 gem is a command line interface and API client for Jenkins 2 CI Server. This gem has been
+tested with Jenkins 2.19.1 LTS.
+
+# Features available
+## Global
+- Get Jenkins version
+- Prepare for shutdown
+- Cancel shutdown
+- Wait for all nodes to be idle
+
+## Node
+- Set node temporarily offline / online
+- Connect / Disconnect node
+- Wait for node to become idle
+- Get node definition as XML
+- Update node definition from XML
+
+## Job
+- Run [parameterized] build
+
+## Plugin
+- List installed plugins
+- Install / uninstall a plugin by short name (i.e. ssh-credentials)
+
+
+## Credentials
+- Create username with password credential ( Requires credentials plugin on Jenkins )
+- Create ssh username with private key credential ( Requires ssh-credentials plugin on Jenkins )
+- Create secret string credential ( Requires plain-credentials plugin on Jenkins )
+- Create secret file credential ( Requires plain-credentials plugin on Jenkins )
+- Get credential by id
+- List credentials
+
+# Installation
+
+    gem install jenkins2
+
+# Configuration
+
+The gem does not require any configuration. However, if your Jenkins is secured you will have to
+provide credentials with every CLI call.
+
+    jenkins2 -s http://jenkins.example.com -u admin -k mysecretkey offline-node -n mynode
+
+This can be avoided by creating a json configuration file like this
+
+    {
+      "server": "http://jenkins.example.com",
+      "user": "admin",
+      "key": "mysecretkey"
+    }
+
+By default Jenkins2 expects this file to be at ~/.jenkins2.json, but you can provide your own path
+with --config-file switch. This way the above mentioned command will be much shorter.
+
+    jenkins2 -c offline-node -n mynode # => -c switch tells Jenkins2 to read configuration file
+
+# Usage
+
+Either run it from command line:
+
+    jenkins2 -s http://jenkins.example.com offline-node -n mynode
+    jenkins2 --help # => for help and list of available commands
+    jenkins2 --help <command> # => for help on particular command
+
+Or use it in your ruby code:
+
+    require 'jenkins2'
+    jc = Jenkins2::Client.new( server: 'http://jenkins.example.com' )
+    jc.version
+    jc.offline_node( node: 'mynode' )
+
+# License
+
+MIT - see the accompanying [LICENSE](LICENSE) file for details.
+
+# Changelog
+
+To see what has changed in recent versions see the [CHANGELOG](CHANGELOG.md).
+Jenkins2 gem follows the [Semantic Versioning Policy](http://guides.rubygems.org/patterns).
+
+# Contributing
+
+Additional commands and bugfixes are welcome! Please fork and submit a pull request on an
+individual branch per change. The project follows GitHub Script
+["Scripts To Rule Them All"] (https://github.com/github/scripts-to-rule-them-all) pattern.
+
+## Bootstrap
+
+After cloning the project, run:
+
+    script/bootstrap
+
+to download gem and other dependencies (currently tested only on ubuntu xenial).
+
+## Tests
+
+The project is expected to be heavily tested :) with unit and integratin tests. To run unit tests,
+you will need to have some gems installed (see jenkins2.gemspec -> development\_dependencies or
+run bootstrap script). To run unit tests run
+
+    script/unit_test
+
+Integration tests are run against a Jenkins server. Currently they require an lxd to setup it.
+To run integration tests type
+
+    script/integration_test
+
+This will start Jenkins in lxd container, run the tests and then kill the container.
+
+## Continuous Integration
+
+If you would like to automate test runs the progect already has [Jenkinsfile](Jenkinsfile) for
+quick and easy integration with Jenkins Pipelines. If you are using another CI server, just make
+sure it runs
+
+    script/cibuild
+
+and then collects the data from the generated reports.

data/bin/jenkins2

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/jenkins2'
+Jenkins2::CommandLine.new( ARGV ).run

data/lib/jenkins2.rb

@@ -0,0 +1,5 @@
+require_relative 'jenkins2/command_line'
+require_relative 'jenkins2/version'
+require_relative 'jenkins2/log'
+require_relative 'jenkins2/try'
+require_relative 'jenkins2/wait'

data/lib/jenkins2/client.rb

@@ -0,0 +1,105 @@
+require 'net/http'
+require 'json'
+
+require_relative 'log'
+require_relative 'uri'
+require_relative 'wait'
+require_relative 'client/credential_commands'
+require_relative 'client/node_commands'
+require_relative 'client/plugin_commands'
+
+module Jenkins2
+	# The entrance point for your Jenkins remote management.
+	class Client
+		include CredentialCommands
+		include PluginCommands
+		include NodeCommands
+		# Creates a "connection" to Jenkins.
+		# Keyword parameters:
+		# +server+:: Jenkins Server URL.
+		# +user+:: Jenkins API user. Can be omitted, if no authentication required.
+		# +key+:: Jenkins API key. Can be omitted, if no authentication required.
+		def initialize( **args )
+			@server = args[:server]
+			@user = args[:user]
+			@key = args[:key]
+		end
+
+		# Returns Jenkins version
+		def version
+			api_request( :get, '/', :raw )['X-Jenkins']
+		end
+
+		# Stops executing new builds, so that the system can be eventually shut down safely.
+		# Parameters are ignored
+		def prepare_for_shutdown( **args )
+			api_request( :post, '/quietDown' )
+		end
+
+		# Cancels the effect of +prepare-for-shutdown+ command.
+		# Parameters are ignored
+		def cancel_shutdown( **args )
+			api_request( :post, '/cancelQuietDown' )
+		end
+
+		# Waits for all the nodes to become idle or until +max_wait_minutes+ pass. Is expected to be
+		# called after +prepare_for_shutdown+, otherwise new builds will still be run.
+		# +max_wait_minutes+:: Maximum wait time in minutes. Default 60.
+		def wait_nodes_idle( max_wait_minutes: 60 )
+			Wait.wait( max_wait_minutes: max_wait_minutes ) do
+				api_request( :get, '/computer/api/json' )['busyExecutors'].zero?
+			end
+		end
+
+		# Job Commands
+
+		# Starts a build
+		# +job_name+:: Name of the job to build
+		# +build_params+:: Build parameters as hash, where keys are names of variables.
+		def build( **args )
+			job, params = args[:job], args[:params]
+			if params.nil? or params.empty?
+				api_request( :post, "/job/#{job}/build" )
+			else
+				api_request( :post, "/job/#{job}/buildWithParameters" ) do |req|
+					req.form_data = params
+				end
+			end
+		end
+
+		private
+		def api_request( method, path, reply_with=:json )
+			req = case method
+				when :get then Net::HTTP::Get
+				when :post then Net::HTTP::Post
+			end.new( URI File.join( @server, URI.escape( path ) ) )
+			Log.debug { "Request: #{method} #{req.uri}" }
+			req.basic_auth @user, @key
+			yield req if block_given?
+			req.content_type ||= 'application/x-www-form-urlencoded'
+			Log.debug { "Request content_type: #{req.content_type}, body: #{req.body}" }
+			response = Net::HTTP.start( req.uri.hostname, req.uri.port ){ |http| http.request req }
+			handle_response( response, reply_with )
+		end
+
+		def handle_response( response, reply_with )
+			Log.debug { "Response: #{response.code}, #{response.body}" }
+			case response
+			when Net::HTTPSuccess
+				case reply_with
+				when :json then JSON.parse response.body
+				when :body then response.body
+				when :raw then response
+				end
+			when Net::HTTPRedirection
+				response['location']
+			when Net::HTTPClientError, Net::HTTPServerError
+				Log.error { "Response: #{response.code}, #{response.body}" }
+				response.value
+			else
+				Log.error { "Response: #{response.code}, #{response.body}" }
+				response.value
+			end
+		end
+	end
+end

data/lib/jenkins2/client/credential_commands.rb

@@ -0,0 +1,134 @@
+module Jenkins2
+	class Client
+		module CredentialCommands
+			BOUNDARY = '----Jenkins2RubyMultipartClient' + rand(1000000).to_s
+
+			# Creates credentials based on provided arguments. Calls either:
+			# - +create_credential_username_password+
+			# - +create_credential_ssh+
+			# - +create_credential_secret_text+
+			# - +create_credential_secret_file+
+			# See those functions' documentation for the exact parameters required
+			def create_credential( **args )
+				return create_credential_username_password( args ) if args[:password]
+				return create_credential_ssh( args ) if args[:private_key]
+				return create_credential_secret_text( args ) if args[:secret]
+				return create_credential_secret_file( args ) if args[:content]
+			end
+
+			# Creates username and password credential. Accepts hash with the following parameters.
+			# +scope+:: Scope of the credential. GLOBAL or SYSTEM
+			# +id+:: Id of the credential. Will be Generated by Jenkins, if not provided.
+			# +description+:: Human readable text, what this credential is used for.
+			# +username+:: Username.
+			# +password+:: Password in plain text.
+			def create_credential_username_password( **args )
+				json_body = { "" => "0",
+					credentials: args.merge(
+						'$class' => 'com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl'
+					)
+				}.to_json
+				api_request( :post, '/credentials/store/system/domain/_/createCredentials' ) do |req|
+					req.body = "json=#{CGI::escape json_body}"
+					req.content_type = 'application/x-www-form-urlencoded'
+				end
+			end
+
+			# Creates ssh username with private key credential. Jenkins must have ssh-credentials plugin
+			# installed, to use this functionality. Accepts hash with the following parameters.
+			# +scope+:: Scope of the credential. GLOBAL or SYSTEM
+			# +id+:: Id of the credential. Will be Generated by Jenkins, if not provided.
+			# +description+:: Human readable text, what this credential is used for.
+			# +username+:: Ssh username.
+			# +private_key+:: Ssh private key, with new lines replaced by <tt>\n</tt> sequence.
+			# +passphrase+:: Passphrase for the private key. Empty string, if not provided.
+			def create_credential_ssh( **args )
+				json_body = { "" => "1",
+					credentials: {
+						scope: args[:scope],
+						username: args[:username],
+						privateKeySource: {
+							value: "0",
+							privateKey: args[:private_key],
+							'stapler-class' => 'com.cloudbees.jenkins.plugins.sshcredentials.impl.BasicSSHUserPrivateKey$DirectEntryPrivateKeySource'
+						},
+						passphrase: args[:passphrase],
+						id: args[:id],
+						description: args[:description],
+						'$class' => 'com.cloudbees.jenkins.plugins.sshcredentials.impl.BasicSSHUserPrivateKey'
+					}
+				}.to_json
+				api_request( :post, '/credentials/store/system/domain/_/createCredentials' ) do |req|
+					req.body = "json=#{CGI::escape json_body}"
+					req.content_type = 'application/x-www-form-urlencoded'
+				end
+			end
+			# Creates a secret text credential. Jenkins must have plain-credentials plugin
+			# installed, to use this functionality. Accepts hash with the following parameters.
+			# +scope+:: Scope of the credential. GLOBAL or SYSTEM
+			# +id+:: Id of the credential. Will be Generated by Jenkins, if not provided.
+			# +description+:: Human readable text, what this credential is used for.
+			# +secret+:: Some secret text.
+			def create_credential_secret_text( **args )
+				json_body = { "" => "3",
+					credentials: args.merge(
+						'$class' => 'org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl'
+					)
+				}.to_json
+				api_request( :post, '/credentials/store/system/domain/_/createCredentials' ) do |req|
+					req.body = "json=#{CGI::escape json_body}"
+					req.content_type = 'application/x-www-form-urlencoded'
+				end
+			end
+
+			# Creates a secret file credential. Jenkins must have plain-credentials plugin
+			# installed, to use this functionality. Accepts hash with the following parameters.
+			# +scope+:: Scope of the credential. GLOBAL or SYSTEM
+			# +id+:: Id of the credential. Will be Generated by Jenkins, if not provided.
+			# +description+:: Human readable text, what this credential is used for.
+			# +filename+:: Name of the file.
+			# +content+:: File content.
+			def create_credential_secret_file( **args )
+				filename = args.delete :filename
+				content = args.delete :content
+				body = "--#{BOUNDARY}\r\n"
+				body << "Content-Disposition: form-data; name=\"file0\"; filename=\"#{filename}\"\r\n"
+				body << "Content-Type: application/octet-stream\r\n\r\n"
+				body << content
+				body << "\r\n"
+				body << "--#{BOUNDARY}\r\n"
+				body << "Content-Disposition: form-data; name=\"json\"\r\n\r\n"
+				body << { "" => "2",
+					credentials: args.merge(
+						'$class' => 'org.jenkinsci.plugins.plaincredentials.impl.FileCredentialsImpl',
+						'file' => 'file0'
+					)
+				}.to_json
+				body << "\r\n\r\n--#{BOUNDARY}--\r\n"
+				api_request( :post, '/credentials/store/system/domain/_/createCredentials' ) do |req|
+					req.add_field 'Content-Type', "multipart/form-data, boundary=#{BOUNDARY}"
+					req.body = body
+				end
+			end
+
+			# Deletes credential
+			# +id+:: Credential's id
+			def delete_credential( id )
+				api_request( :post, "/credentials/store/system/domain/_/credential/#{id}/doDelete" ) do |req|
+					req.content_type = 'application/x-www-form-urlencoded'
+				end
+			end
+
+			# Returns credential as json. Raises Net::HTTPNotFound, if no such credential
+			# +id+:: Credential's id
+			def get_credential( id )
+				api_request( :get, "/credentials/store/system/domain/_/credential/#{id}/api/json" )
+			end
+
+			# Lists all credentials
+			def list_credentials( store: 'system', domain: '_' )
+				api_request( :get, "/credentials/store/#{store}/domain/#{domain}/api/json?depth=1" )['credentials']
+			end
+		end
+	end
+end

data/lib/jenkins2/client/node_commands.rb

@@ -0,0 +1,105 @@
+require 'cgi'
+
+module Jenkins2
+	class Client
+		module NodeCommands
+			# Connects a node.
+			# +node+:: Node name, <tt>(master)</tt> for master.
+			def connect_node( node: '(master)' )
+				api_request( :post, "/computer/#{node}/launchSlaveAgent" )
+			end
+
+			# Creates a new node, by providing node definition XML.
+			# Keyword parameters:
+			# +node+:: Node name.
+			# +xml_config+:: New configuration in xml format.
+			def create_node( node: nil, xml_config: nil )
+				xml_config = STDIN.read if xml_config.nil?
+				api_request( :post, "/computer/doCreateItem", :raw ) do |req|
+					req.form_data = { 'name' => node, type: "hudson.slaves.DumbSlave$DescriptorImpl",
+						json: {}.to_json }
+				end
+				update_node( node: node, xml_config: xml_config )
+			end
+			
+			# Deletes a node
+			# +node+:: Node name. Master cannot be deleted.
+			def delete_node( node: nil )
+				raise ArgumentError, 'node must be provided' if node.nil?
+				api_request( :post, "/computer/#{node}/doDelete" )
+			end
+
+			# Disconnects a node.
+			# +node+:: Node name, <tt>(master)</tt> for master.
+			# +message+:: Reason why the node is being disconnected.
+			def disconnect_node( node: '(master)', message: nil )
+				api_request( :post, "/computer/#{node}/doDisconnect" ) do |req|
+					req.body = "offlineMessage=#{CGI::escape message}" unless message.nil?
+				end
+			end
+
+			# Returns the node definition XML.
+			# +node+:: Node name, <tt>(master)</tt> for master.
+			def get_node_xml( node: '(master)' )
+				api_request( :get, "/computer/#{node}/config.xml", :body )
+			end
+			
+			# Returns the node state
+			# +node+:: Node name, <tt>(master)</tt> for master.
+			def get_node( node: '(master)' )
+				api_request( :get, "/computer/#{node}/api/json" )
+			end
+
+			# Sets node temporarily offline. Does nothing, if node is already offline.
+			# +node+:: Node name, or <tt>(master)</tt> for master.
+			# +message+:: Record the note about this node is being disconnected.
+			def offline_node( node: '(master)', message: nil )
+				if node_online?( node: node )
+					api_request( :post, "/computer/#{node}/toggleOffline" ) do |req|
+						req.body = "offlineMessage=#{CGI::escape message}" unless message.nil?
+					end
+				end
+			end
+
+			# Sets node back online, if node is temporarily offline.
+			# +node+:: Node name, <tt>(master)</tt> for master.
+			def online_node( node: '(master)' )
+				api_request( :post, "/computer/#{node}/toggleOffline" ) unless node_online?( node: node )
+			end
+
+			# Updates the node definition XML
+			# Keyword parameters:
+			# +node+:: Node name, <tt>(master)</tt> for master.
+			# +xml_config+:: New configuration in xml format.
+			def update_node( node: '(master)', xml_config: nil )
+				xml_config = STDIN.read if xml_config.nil?
+				api_request( :post, "/computer/#{node}/config.xml", :body ) do |req|
+					req.body = xml_config
+				end
+			end
+
+			# Waits for node to become idle or until +max_wait_minutes+ pass.
+			# +node+:: Node name, <tt>(master)</tt> for master.
+			# +max_wait_minutes+:: Maximum wait time in minutes. Default 60.
+			def wait_node_idle( node: '(master)', max_wait_minutes: 60 )
+				Jenkins2::Wait.wait( max_wait_minutes: max_wait_minutes ){ node_idle? node: node }
+			end
+
+			def node_idle?( node: '(master)' )
+				get_node( node: node )['idle']
+			end
+
+			# Checks if node is online (= not temporarily offline )
+			# +node+:: Node name. Use <tt>(master)</tt> for master.
+			def node_online?( node: '(master)' )
+				!get_node( node: node )['temporarilyOffline']
+			end
+
+			# Checks if node is connected, i.e. Master connected and launched client on it.
+			# +node+:: Node name. Use <tt>(master)</tt> for master.
+			def node_connected?( node: '(master)' )
+				!get_node( node: node )['offline']
+			end
+		end
+	end
+end

data/lib/jenkins2/client/plugin_commands.rb

@@ -0,0 +1,53 @@
+module Jenkins2
+	class Client
+		module PluginCommands
+			# Installs plugins by short name (like +thinBackup+).
+			# +names+:: List of short names.
+			def install_plugins( *names )
+				api_request( :post, '/pluginManager/install' ) do |req|
+					req.form_data = names.flatten.inject({}) do |memo,obj|
+						memo.merge "plugin.#{obj}.default" => 'on'
+					end.merge( 'dynamicLoad' => 'Install without restart' )
+				end
+			end
+
+			# Installs a plugin by uploading *.hpi or *.jpi file.
+			# +plugin_file+:: A *.hpi or *.jpi file itself ( not some path )
+			def upload_plugin( plugin_file )
+				api_request( :post, '/pluginManager/uploadPlugin' ) do |req|
+					req.body = plugin_file
+					req.content_type = 'multipart/form-data'
+				end
+			end
+
+			# Lists installed plugins
+			def list_plugins
+				api_request( :get, '/pluginManager/api/json?depth=1' )['plugins']
+			end
+
+			# Checks, if all of the plugins from the passed list are installed
+			# +names+:: List of short names of plugins (like +thinBackup+).
+			def plugins_installed?( *names )
+				plugins = list_plugins
+				return false if plugins.nil?
+				names.flatten.all? do |name|
+					plugins.detect{|p| p['shortName'] == name and !p['deleted'] }
+				end
+			end
+
+			# Uninstalls a plugin
+			# +name+:: Plugin short name
+			def uninstall_plugin( name )
+				api_request( :post, "/pluginManager/plugin/#{name}/doUninstall" ) do |req|
+					req.form_data = { 'Submit' => 'Yes', 'json' => '{}' }
+				end
+			end
+
+			def wait_plugins_installed( *names, max_wait_minutes: 2 )
+				Wait.wait( max_wait_minutes: max_wait_minutes ) do
+					plugins_installed? names
+				end
+			end
+		end
+	end
+end

data/lib/jenkins2/cmdparse.rb

@@ -0,0 +1,51 @@
+require 'optparse'
+
+module Jenkins2
+	class CommandParser < OptionParser
+		attr_reader :command_name
+
+		def command( key, desc, &block )
+			sw = OptionParser::Switch::NoArgument.new( key, nil, [key], nil, nil, [desc],
+				Proc.new{ OptionParser.new( &block ) } ), [], [key]
+			commands[key.to_s] = sw[0]
+		end
+
+		def parse!( argv=default_argv )
+			@command_name = argv.detect{|c| commands.has_key? c }
+			if command_name
+				#create temporary parser with option definitions from both: globalparse and subparse
+				OptionParser.new do |parser|
+					parser.instance_variable_set(:@stack,
+						commands[command_name.to_s].block.call.instance_variable_get(:@stack) + @stack)
+				end.parse! argv
+			else
+				super( argv )
+			end
+		end
+
+		def commands
+			@commands ||= {}
+		end
+
+		private
+		def summarize(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk)
+			super(to, width, max, indent, &blk)
+			if command_name and commands.has_key?( command_name )
+				to << "Command:\n"
+				commands[command_name].summarize( {}, {}, width, max, indent ) do |l|
+					to << (l.index($/, -1) ? l : l + $/)
+				end
+				to << "Command options:\n"
+				commands[command_name].block.call.summarize( to, width, max, indent, &blk )
+			else
+				to << "Commands:\n"
+				commands.each do |name, command|
+					command.summarize( {}, {}, width, max, indent ) do |l|
+						to << (l.index($/, -1) ? l : l + $/)
+					end
+				end
+			end
+			to
+		end
+	end
+end

data/lib/jenkins2/command_line.rb

@@ -0,0 +1,221 @@
+require 'optparse/uri'
+require_relative 'cmdparse'
+require_relative 'client'
+require_relative 'log'
+
+module Jenkins2
+	class CommandLine
+		attr_accessor :global_options
+		attr_accessor :command_options
+		
+		def initialize( args )
+			@global_options = OptionParser::OptionMap.new
+			@log_options = { verbose: 0, log: STDOUT }
+			@command_options = OptionParser::OptionMap.new
+			global = CommandParser.new 'Usage: jenkins [global-options] <command> [options]' do |opts|
+				opts.separator ''
+				opts.separator "Global options (accepted by all commands):"
+				opts.on '-s', '--server URL', ::URI, 'Jenkins Server Url' do |opt|
+					@global_options[:server] = opt
+				end
+				opts.on '-u', '--user USER', 'Jenkins API user' do |opt|
+					@global_options[:user] = opt
+				end
+				opts.on '-k', '--key KEY', 'Jenkins API key' do |opt|
+					@global_options[:key] = opt
+				end
+				opts.on '-c', '--config [PATH]', 'Use configuration file. Instead of providing '\
+					'server, user and key through command line, you can do that with configuration file. '\
+					'File format is json: { "server": "http://jenkins.example.com", "user": "admin", '\
+					'"key": "123456" }. Options provided in command line will overwrite ones from '\
+					'configuration file. Program looks for ~/.jenkins2.json if no PATH is provided.' do |opt|
+					@global_options[:config] = opt || ::File.join( ENV['HOME'], '.jenkins2.json' )
+				end
+				opts.on '-l', '--log FILE', 'Log file. Prints to standard out, if not provided' do |opt|
+					@log_options[:log] = opt
+				end
+				opts.on '-v', '--verbose', 'Print more info. Up to -vvv. Prints only errors by default.' do
+					@log_options[:verbose] += 1
+				end
+				opts.on '-h', '--help', 'Show help' do
+					@global_options[:help] = true
+				end
+				opts.on '-V', '--version', 'Show version' do
+					puts VERSION
+					exit
+				end
+
+				opts.separator ''
+				opts.separator 'For command specific options run: jenkins2 --help <command>'
+				opts.separator ''
+				opts.command 'version', 'Outputs the current version of Jenkins'
+				opts.command 'prepare-for-shutdown', 'Stop executing new builds, so that the system can '\
+					'be eventually shut down safely.'
+				opts.command 'cancel-shutdown', 'Cancel the effect of "prepare-for-shutshow" command.'
+				opts.command 'wait-nodes-idle', 'Wait for all nodes to become idle. Is expected to be '\
+					'called after "prepare_for_shutdown", otherwise new builds will still be run.' do |cmd|
+					cmd.on '-m', '--max-wait-minutes INT', Integer, 'Wait for INT minutes at most. '\
+						'Default 60' do |opt|
+						@command_options[:max_wait_minutes] = opt
+					end
+				end
+				opts.command 'offline-node', 'Stop using a node for performing builds temporarily, until '\
+					'the next "online-node" command.' do |cmd|
+					cmd.on '-n', '--node NAME', 'Name of the node or empty for master' do |opt|
+						@command_options[:node] = opt
+					end
+					cmd.on '-m', '--message MESSAGE', 'Record the note about why you are '\
+						'disconnecting this node' do |opt|
+						@command_options[:message] = opt
+					end
+				end
+				opts.command 'online-node', 'Resume using a node for performing builds, to cancel out '\
+					'the earlier "offline-node" command.' do |cmd|
+					cmd.on '-n', '--node [NAME]', 'Name of the node or empty for master' do |opt|
+						@command_options[:node] = opt
+					end
+				end
+				opts.command 'connect-node', 'Connects a node, i.e. starts Jenkins slave on a node.' do |cmd|
+					cmd.on '-n', '--node [NAME]', 'Name of the node or empty for master' do |opt|
+						@command_options[:node] = opt
+					end
+				end
+				opts.command 'create-node', 'Creates a new node from XML' do |cmd|
+					cmd.on '-n', '--node NAME', 'Name of the new node' do |opt|
+						@command_options[:node] = opt
+					end
+					cmd.on '-x', '--xml FILE', 'Path to XML configuration file' do |opt|
+						@command_options[:xml] = IO.read opt
+					end
+				end
+				opts.command 'delete-node', 'Deletes a node' do |cmd|
+					cmd.on '-n', '--node NAME', 'Node name' do |opt|
+						@command_options[:node] = opt
+					end
+				end
+				opts.command 'create-credential', 'Creates credential.' do |cmd|
+					cmd.on '-S', '--scope SCOPE', 'GLOBAL or SYSTEM scope' do |opt|
+						@command_options[:scope] = opt
+					end
+					cmd.on '-i', '--id ID', 'Unique Id of credential. Will be generated automactically, if '\
+						'not provided' do |opt|
+						@command_options[:id] = opt
+					end
+					cmd.on '-d', '--description DESC', 'Human readable text, what this credential is used for.' do |opt|
+						@command_options[:description] = opt
+					end
+					cmd.on '-n', '--username NAME', 'Username for Username-Password or SSH credential' do |opt|
+						@command_options[:username] = opt
+					end
+					cmd.on '-p', '--password PASS', 'Password in plain text for Username-Password credential' do |opt|
+						@command_options[:password] = opt
+					end
+					cmd.on '-f', '--private-key FILE', 'Path to private key file for SSH credential' do |opt|
+						@command_options[:private_key] = IO.read( opt ).gsub( "\n", "\\n" )
+					end
+					cmd.on '-P', '--passphrase PHRASE', 'Passphrase for the private key for SSH credential' do |opt|
+						@command_options[:passphrase] = opt
+					end
+					cmd.on '-e', '--secret SECRET', 'Some secret text for Secret credential' do |opt|
+						@command_options[:secret] = opt
+					end
+					cmd.on '-F', '--secret-file FILE', 'Path to secret file for Secret File credential' do |opt|
+						@command_options[:filename] = File.basename opt
+						@command_options[:content] = IO.read opt
+					end
+				end
+				opts.command 'delete-credential', 'Deletes credential.' do |cmd|
+					cmd.on '-i', '--id ID', 'Credential id' do |opt|
+						@command_options[:id] = opt
+					end
+				end
+				opts.command 'get-credential', 'Returns credential as json.' do |cmd|
+					cmd.on '-i', '--id ID', 'Credential id' do |opt|
+						@command_options[:id] = opt
+					end
+				end
+				opts.command 'list-credentials', 'Lists all credentials.'
+				opts.command 'disconnect-node', 'Disconnects a node.' do |cmd|
+					cmd.on '-n', '--node [NAME]', 'Name of the node or empty for master' do |opt|
+						@command_options[:node] = opt
+					end
+					cmd.on '-m', '--message MESSAGE', 'Reason, why the node is being disconnected.' do |opt|
+						@command_options[:message] = opt
+					end
+				end
+				opts.command 'wait-node-idle', 'Wait for the node to become idle. Make sure you run '\
+					'"offline-node" first.' do |cmd|
+					cmd.on '-n', '--node [NAME]', 'Name of the node or empty for master' do |opt|
+						@command_options[:node] = opt
+					end
+					cmd.on '-m', '--max-wait-minutes INT', Integer, 'Wait for INT minutes at most. '\
+						'Default 60' do |opt|
+						@command_options[:max_wait_minutes] = opt
+					end
+				end
+				opts.command 'get-node-xml', 'Returns the node definition XML.' do |cmd|
+					cmd.on '-n', '--node [NAME]', 'Name of the node or empty for master' do |opt|
+						@command_options[:node] = opt
+					end
+				end
+				opts.command 'get-node', 'Returns the node state.' do |cmd|
+					cmd.on '-n', '--node [NAME]', 'Name of the node or empty for master' do |opt|
+						@command_options[:node] = opt
+					end
+				end
+				opts.command 'update-node', 'Updates the node definition XML from stdin or file.' do |cmd|
+					cmd.on '-n', '--node [NAME]', 'Name of the node or empty for master' do |opt|
+						@command_options[:node] = opt
+					end
+					cmd.on '-x', '--xml-config FILE', 'File to read definition from. Omit this to read from stdin' do |opt|
+						@command_options[:xml_config] = IO.read( opt )
+					end
+				end
+				opts.command 'build', 'Starts a build.' do |cmd|
+					cmd.on '-j', '--job NAME', 'Name of the job' do |opt|
+						@command_options[:job] = opt
+					end
+					cmd.on '-p', '--params KEY=VALUE[,KEY=VALUE...]', Array, 'Build parameters, where keys are'\
+						' names of variables' do |opt|
+						@command_options[:params] = opt.collect{|i| i.split( '=', 2 ) }.to_h
+					end
+				end
+				opts.command 'install-plugin', 'Installs a plugin from url or by short name. '\
+					'Provide either --url or --name.' do |cmd|
+					cmd.on '-u', '--uri URI', ::URI, 'Uri to install plugin from.' do |opt|
+						@command_options[:uri] = opt
+					end
+					cmd.on '-n', '--name SHORTNAME', 'Plugin short name (like thinBackup).' do |opt|
+						@command_options[:name] = opt
+					end
+				end
+				opts.command 'list-plugins', 'Lists installed plugins'
+			end
+			begin
+				global.parse!( args )
+				@global_options[:command] = global.command_name
+				if @global_options[:config]
+					from_file = JSON.parse( IO.read( @global_options[:config] ), symbolize_names: true )
+					@global_options = from_file.merge( @global_options )
+				end
+				Log.init @log_options
+				if @global_options[:help]
+					Log.unknown { global.help }
+					exit
+				end
+				raise OptionParser::MissingArgument, :command unless @global_options[:command]
+			rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+				Log.fatal { e.message }
+				Log.fatal { global.help }
+				exit 1
+			end
+			Log.debug { "Options: #{@global_options}\nUnparsed args: #{ARGV}" }
+		end
+
+		def run
+			jc = Client.new( @global_options )
+			jc.send( @global_options[:command].gsub( '-', '_' ), @command_options )
+		end
+	end
+end
+

data/lib/jenkins2/log.rb

@@ -0,0 +1,29 @@
+require 'forwardable'
+require 'logger'
+
+module Jenkins2
+	class Log
+		extend SingleForwardable
+
+		def self.init( log: $stdout, verbose: 0 )
+			@logger = Logger.new log
+			@logger.level = Logger::ERROR - verbose
+			@logger.formatter = proc do |severity, datetime, progname, msg|
+				if log == $stdout
+					"#{msg}\n"
+				else
+					"[#{datetime.strftime '%FT%T%:z'}] #{severity} #{msg}\n"
+				end
+			end
+			@logger
+		end
+
+		def_delegators :logger, :debug, :info, :warn, :error, :fatal, :unknown, :level
+
+		private
+
+		def self.logger
+			@logger ||= self.init
+		end
+	end
+end

data/lib/jenkins2/try.rb

@@ -0,0 +1,36 @@
+require 'net/http'
+
+require_relative 'log'
+
+module Jenkins2
+	module Try
+		# Tries a block several times, if raised exception is <tt>Net::HTTPFatalError</tt>,
+		# <tt>Errno::ECONNREFUSED</tt> or <tt>Net::ReadTimeout</tt>.
+		# +retries+:: Number of retries.
+		# +retry_delay+:: Seconds to sleep, before attempting next retry.
+		# +&block+:: Code to run inside <tt>retry</tt> loop.
+		#
+		# Returns the result of a block, if it eventually succeeded or throws the exception, thown by
+		# the block on last try.
+		#
+		# Note that this is both a method of module Try, so you can <tt>include Jenkins::Try</tt>
+		# into your classes so they have a #try method, as well as a module method, so you can call it
+		# directly as ::try().
+		def try( retries: 3, retry_delay: 5, &block )
+			yield
+		rescue Errno::ECONNREFUSED, Net::HTTPFatalError, Net::ReadTimeout => e
+			i ||= 0
+			unless ( i += 1 ) == retries
+				Log.warn { "Received error: #{e}." }
+				Log.warn { "Retry request in #{retry_delay} seconds." }
+				sleep retry_delay
+				retry
+			end
+			Log.error { "Received error: #{e}." }
+			Log.error { "Reached maximum number of retries (#{retries}). Give up." }
+			raise e
+		end
+
+		module_function :try
+	end
+end

data/lib/jenkins2/uri.rb

@@ -0,0 +1,10 @@
+module Jenkins2
+	module URI
+		PATH = "a-zA-Z0-9\\-\\.\\_\\~\\!\\?\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=\\:\\@\\/"
+		def self.escape( s )
+			s.gsub( /[^#{PATH}]/ ) do |char|
+				char.unpack( 'C*' ).map{|c| ("%%%02x" % c).upcase }.join
+			end
+		end
+	end
+end

data/lib/jenkins2/version.rb

@@ -0,0 +1,3 @@
+module Jenkins2
+	VERSION = '0.0.2'
+end

data/lib/jenkins2/wait.rb

@@ -0,0 +1,29 @@
+require 'net/http'
+
+require_relative 'log'
+
+module Jenkins2
+	module Wait
+		# Waits for a block to return +truthful+ value. Useful, for example, when you set a node tenporarily
+		# offline, and then wait for it to become idle.
+		# +max_wait_minutes+:: Maximum wait time in minutes.
+		# +&block+:: Run this block until it returs true, max_wait_minutes pass or block throws some
+		# kind of exception.
+		#
+		# Returns the result of a block, if it eventually succeeded or nil in case of timeout.
+		#
+		# Note that this is both a method of module Wait, so you can <tt>include Jenkins::Wait</tt>
+		# into your classes so they have a #wait method, as well as a module method, so you can call it
+		# directly as ::wait().
+		def wait( max_wait_minutes: 60, &block )
+			[3, 5, 7, 15, 30, [60] * (max_wait_minutes - 1)].flatten.each do |sec|
+				result = yield
+				return result if result
+				sleep sec
+			end
+			nil
+		end
+
+		module_function :wait
+	end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: jenkins2
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Juri Timošin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: ci_reporter_minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Command line interface and API client for Jenkins 2. Allows manipulating
+  nodes, jobs, plugins, credentials. See README.md for details.
+email: draco.ater@gmail.com
+executables:
+- jenkins2
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/jenkins2
+- lib/jenkins2.rb
+- lib/jenkins2/client.rb
+- lib/jenkins2/client/credential_commands.rb
+- lib/jenkins2/client/node_commands.rb
+- lib/jenkins2/client/plugin_commands.rb
+- lib/jenkins2/cmdparse.rb
+- lib/jenkins2/command_line.rb
+- lib/jenkins2/log.rb
+- lib/jenkins2/try.rb
+- lib/jenkins2/uri.rb
+- lib/jenkins2/version.rb
+- lib/jenkins2/wait.rb
+homepage: https://bitbucket.org/DracoAter/jenkins2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Command line interface and API client for Jenkins 2.
+test_files: []