Class: JenkinsApi::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/jenkins_api_client/client.rb,
lib/jenkins_api_client/job.rb,
lib/jenkins_api_client/node.rb,
lib/jenkins_api_client/user.rb,
lib/jenkins_api_client/view.rb,
lib/jenkins_api_client/system.rb,
lib/jenkins_api_client/version.rb,
lib/jenkins_api_client/build_queue.rb,
lib/jenkins_api_client/plugin_manager.rb

Overview

This is the client class that acts as the bridge between the subclasses and Jnekins. This class contains methods that performs GET and POST requests for various operations.

Defined Under Namespace

Classes: BuildQueue, Job, Node, PluginManager, System, User, View

Constant Summary

DEFAULT_SERVER_PORT =

Default port to be used to connect to Jenkins

8080
DEFAULT_TIMEOUT =

Default timeout in seconds to be used while performing operations

120
VALID_PARAMS =

Parameters that are permitted as options while initializing the client

[
  "server_url",
  "server_ip",
  "server_port",
  "proxy_ip",
  "proxy_port",
  "jenkins_path",
  "username",
  "password",
  "password_base64",
  "log_location",
  "log_level",
  "timeout",
  "ssl",
  "follow_redirects",
  "identity_file",
  "cookies"
].freeze
MAJOR =

Major version of the gem

1
MINOR =

Minor version of the gem

0
TINY =

Tiny version of the gem used for patches

0
PRE =

Used for pre-releases

'beta.5'
VERSION =

Version String of Jenkins API Client.

[MAJOR, MINOR, TINY, PRE].compact.join('.')

Instance Attribute Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (JenkinsApi::Client) initialize(args)

Initialize a Client object with Jenkins CI server credentials

Parameters:

  • args (Hash) —

    Arguments to connect to Jenkins server

Options Hash (args):

  • :server_ip (String) —

    the IP address of the Jenkins CI server

  • :server_port (String) —

    the port on which the Jenkins listens

  • :server_url (String) —

    the full URL address of the Jenkins CI server (http/https). This can include username/password. :username/:password options will override any user/pass value in the URL

  • :username (String) —

    the username used for connecting to the server (optional)

  • :password (String) —

    the password or API Key for connecting to the CI server (optional)

  • :password_base64 (String) —

    the password with base64 encoded format for connecting to the CI server (optional)

  • :identity_file (String) —

    the priviate key file for Jenkins CLI authentication, it is used only for executing CLI commands. Also remember to upload the public key to <Server IP>:<Server Port>/user/<Username>/configure

  • :proxy_ip (String) —

    the proxy IP address

  • :proxy_port (String) —

    the proxy port

  • :jenkins_path (String) — default: "/" —

    the optional context path for Jenkins

  • :ssl (Boolean) — default: false —

    indicates if Jenkins is accessible over HTTPS

  • :follow_redirects (Boolean) —

    this argument causes the client to follow a redirect (jenkins can return a 30x when starting a build)

  • :timeout (Fixnum) — default: 120 —

    This argument sets the timeout for operations that take longer (in seconds)

  • :log_location (String) — default: STDOUT —

    the location for the log file

  • :log_level (Fixnum) — default: Logger::INFO —

    The level for messages to be logged. Should be one of: Logger::DEBUG (0), Logger::INFO (1), Logger::WARN (2), Logger::ERROR (2), Logger::FATAL (3)

  • :cookies (String) —

    Cookies to be sent with all requests in the format: name=value; name2=value2

Raises:

  • (ArgumentError) —

    when required options are not provided.



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/jenkins_api_client/client.rb', line 97

def initialize(args)
  args.each do |key, value|
    if value && VALID_PARAMS.include?(key.to_s)
      instance_variable_set("@#{key}", value)
    end
  end if args.is_a? Hash

  # Server IP or Server URL must be specifiec
  unless @server_ip || @server_url
    raise ArgumentError, "Server IP or Server URL is required to connect" +
      " to Jenkins"
  end

  # Get info from the server_url, if we got one
  if @server_url
    server_uri = URI.parse(@server_url)
    @server_ip = server_uri.host
    @server_port = server_uri.port
    @ssl = server_uri.scheme == "https"
    @jenkins_path = server_uri.path

    # read username and password from the URL
    # only set if @username and @password are not already set via explicit options
    @username ||= server_uri.user
    @password ||= server_uri.password
  end

  # Username/password are optional as some jenkins servers do not require
  # authentication
  if @username && !(@password || @password_base64)
    raise ArgumentError, "If username is provided, password is required"
  end
  if @proxy_ip.nil? ^ @proxy_port.nil?
    raise ArgumentError, "Proxy IP and port must both be specified or" +
      " both left nil"
  end

  @jenkins_path ||= ""
  @jenkins_path.gsub!(/\/$/,"") # remove trailing slash if there is one
  @server_port = DEFAULT_SERVER_PORT unless @server_port
  @timeout = DEFAULT_TIMEOUT unless @timeout
  @ssl ||= false

  # Setting log options
  @log_location = STDOUT unless @log_location
  @log_level = Logger::INFO unless @log_level
  @logger = Logger.new(@log_location)
  @logger.level = @log_level


  # Base64 decode inserts a newline character at the end. As a workaround
  # added chomp to remove newline characters. I hope nobody uses newline
  # characters at the end of their passwords :)
  @password = Base64.decode64(@password_base64).chomp if @password_base64

  # No connections are made to the Jenkins server during initialize to
  # allow the unit tests to behave normally as mocking is simpler this way.
  # If this variable is nil, the first POST request will query the API and
  # populate this variable.
  @crumbs_enabled = nil
  # The crumbs hash. Store it so that we don't have to obtain the crumb for
  # every POST request. It appears that the crumb doesn't change often.
  @crumb = {}
  # This is the number of times to refetch the crumb if it ever expires.
  @crumb_max_retries = 3
end

Instance Attribute Details

- (Object) logger

Returns the value of attribute logger



42
43
44
 
# File 'lib/jenkins_api_client/client.rb', line 42

def logger
  @logger
end

- (Object) timeout

Returns the value of attribute timeout



42
43
44
 
# File 'lib/jenkins_api_client/client.rb', line 42

def timeout
  @timeout
end

Instance Method Details

- (String, Hash) api_get_request(url_prefix, tree = nil, url_suffix = "/api/json", raw_response = false)

Sends a GET request to the Jenkins CI server with the specified URL

Parameters:

  • url_prefix (String) —

    The prefix to use in the URL

  • tree (String) (defaults to: nil) —

    A specific JSON tree to optimize the API call

  • url_suffix (String) (defaults to: "/api/json") —

    The suffix to be used in the URL

  • raw_response (Boolean) (defaults to: false) —

    Return complete Response object instead of JSON body of response

Returns:

  • (String, Hash) —

    JSON response from Jenkins



310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/jenkins_api_client/client.rb', line 310

def api_get_request(url_prefix, tree = nil, url_suffix ="/api/json",
                    raw_response = false)
  url_prefix = "#{@jenkins_path}#{url_prefix}"
  to_get = ""
  if tree
    to_get = "#{url_prefix}#{url_suffix}?#{tree}"
  else
    to_get = "#{url_prefix}#{url_suffix}"
  end
  request = Net::HTTP::Get.new(to_get)
  @logger.info "GET #{to_get}"
  response = make_http_request(request)
  if raw_response
    handle_exception(response, "raw")
  else
    handle_exception(response, "body", url_suffix =~ /json/)
  end
end

- (String) api_post_request(url_prefix, form_data = {}, raw_response = false)

Sends a POST message to the Jenkins CI server with the specified URL

Parameters:

  • url_prefix (String) —

    The prefix to be used in the URL

  • form_data (Hash) (defaults to: {}) —

    Form data to send with POST request

Returns:

  • (String) —

    Response code form Jenkins Response



336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
 
# File 'lib/jenkins_api_client/client.rb', line 336

def api_post_request(url_prefix, form_data = {}, raw_response = false)
  retries = @crumb_max_retries
  begin
    refresh_crumbs

    # Added form_data default {} instead of nil to help with proxies
    # that barf with empty post
    request = Net::HTTP::Post.new("#{@jenkins_path}#{url_prefix}")
    @logger.info "POST #{url_prefix}"
    if @crumbs_enabled
      request[@crumb["crumbRequestField"]] = @crumb["crumb"]
    end
    request.set_form_data(form_data)
    response = make_http_request(request)
    if raw_response
      handle_exception(response, "raw")
    else
      handle_exception(response)
    end
  rescue Exceptions::ForbiddenException => e
    refresh_crumbs(true)

    if @crumbs_enabled
      @logger.info "Retrying: #{@crumb_max_retries - retries + 1} out of" +
        " #{@crumb_max_retries} times..."
      retries -= 1

      if retries > 0
        retry
      else
        raise Exceptions::ForbiddenWithCrumb.new(@logger, e.message)
      end
    else
      raise
    end
  end
end

- (Object) compare_versions(version_a, version_b)

Compare two version strings (A and B) if A == B, returns 0 if A > B, returns 1 if A < B, returns -1



516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
 
# File 'lib/jenkins_api_client/client.rb', line 516

def compare_versions(version_a, version_b)
  if version_a == version_b
    return 0
  else
    version_a_d = deconstruct_version_string(version_a)
    version_b_d = deconstruct_version_string(version_b)

    if version_a_d[0] > version_b_d[0] ||
      (version_a_d[0] == version_b_d[0] && version_a_d[1] > version_b_d[1]) ||
      (version_a_d[0] == version_b_d[0] && version_a_d[1] == version_b_d[1] && version_a_d[2] > version_b_d[2])
      return 1
    else
      return -1
    end
  end
end

- (Object) deconstruct_version_string(version)

Converts a version string to a list of integers This makes it easier to compare versions since in 'version-speak', v 1.2 is a lot older than v 1.102 - and simple < > on version strings doesn't work so well



500
501
502
503
504
505
506
507
508
509
510
 
# File 'lib/jenkins_api_client/client.rb', line 500

def deconstruct_version_string(version)
  match = version.match(/^(\d+)\.(\d+)(?:\.(\d+))?$/)

  # Match should have 4 parts [0] = input string, [1] = major
  # [2] = minor, [3] = patch (possibly blank)
  if match && match.size == 4
    return [match[1].to_i, match[2].to_i, match[3].to_i || 0]
  else
    return nil
  end
end

- (String) exec_cli(command, args = [])

Execute the Jenkins CLI

Parameters:

  • command (String) —

    command name

  • args (Array) (defaults to: []) —

    the arguments for the command

Returns:

  • (String) —

    command output from the CLI

Raises:



563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
 
# File 'lib/jenkins_api_client/client.rb', line 563

def exec_cli(command, args = [])
  base_dir = File.dirname(__FILE__)
  server_url = "http://#{@server_ip}:#{@server_port}/#{@jenkins_path}"
  cmd = "java -jar #{base_dir}/../../java_deps/jenkins-cli.jar -s #{server_url}"
  cmd << " -i #{@identity_file}" if @identity_file && !@identity_file.empty?
  cmd << " #{command}"
  cmd << " --username #{@username} --password #{@password}" if @identity_file.nil? || @identity_file.empty?
  cmd << ' '
  cmd << args.join(' ')
  java_cmd = Mixlib::ShellOut.new(cmd)

  # Run the command
  java_cmd.run_command
  if java_cmd.stderr.empty?
    java_cmd.stdout.chomp
  else
    # The stderr has a stack trace of the Java program. We'll already have
    # a stack trace for Ruby. So just display a descriptive message for the
    # error thrown by the CLI.
    raise Exceptions::CLIException.new(
      @logger,
      java_cmd.stderr.split("\n").first
    )
  end
end

- (String) exec_script(script_text)

Executes the provided groovy script on the Jenkins CI server

Parameters:

  • script_text (String) —

    The text of the groovy script to execute

Returns:

  • (String) —

    The output of the executed groovy script



548
549
550
551
 
# File 'lib/jenkins_api_client/client.rb', line 548

def exec_script(script_text)
  response = api_post_request('/scriptText', {'script' => script_text}, true)
  response.body
end

- (String) get_config(url_prefix)

Obtains the configuration of a component from the Jenkins CI server

Parameters:

  • url_prefix (String) —

    The prefix to be used in the URL

Returns:

  • (String) —

    XML configuration obtained from Jenkins



380
381
382
383
384
385
 
# File 'lib/jenkins_api_client/client.rb', line 380

def get_config(url_prefix)
  request = Net::HTTP::Get.new("#{@jenkins_path}#{url_prefix}/config.xml")
  @logger.info "GET #{url_prefix}/config.xml"
  response = make_http_request(request)
  handle_exception(response, "body")
end

- (String) get_hudson_version

Obtain the Hudson version of the CI server Only queries Hudson/Jenkins if the version is not already stored. Note that the version is auto-updated after every request made to Jenkins since it is returned as a header in every response

Returns:

  • (String) —

    Version of Hudson on Jenkins server



491
492
493
494
 
# File 'lib/jenkins_api_client/client.rb', line 491

def get_hudson_version
  get_root if @hudson_version.nil?
  @hudson_version
end

- (String) get_jenkins_version

Obtains the jenkins version from the API Only queries Jenkins if the version is not already stored. Note that the version is auto-updated after every request made to Jenkins since it is returned as a header in every response

Returns:

  • (String) —

    Jenkins version



479
480
481
482
 
# File 'lib/jenkins_api_client/client.rb', line 479

def get_jenkins_version
  get_root if @jenkins_version.nil?
  @jenkins_version
end

- (Net::HTTP::Response) get_root

Obtains the root of Jenkins server. This function is used to see if Jenkins is running

Returns:

  • (Net::HTTP::Response) —

    Response from Jenkins for “/”



294
295
296
297
298
 
# File 'lib/jenkins_api_client/client.rb', line 294

def get_root
  @logger.info "GET #{@jenkins_path}/"
  request = Net::HTTP::Get.new("#{@jenkins_path}/")
  make_http_request(request)
end

- (String) get_server_date

Obtain the date of the Jenkins server

Returns:

  • (String) —

    Server date



537
538
539
540
 
# File 'lib/jenkins_api_client/client.rb', line 537

def get_server_date
  response = get_root
  response["Date"]
end

- (Object) init_update_center 



435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
 
# File 'lib/jenkins_api_client/client.rb', line 435

def init_update_center
  @logger.info "Initializing Jenkins Update Center..."
  @logger.debug "Obtaining the JSON data for Update Center..."
  # TODO: Clean me up
  update_center_data = open("http://updates.jenkins-ci.org/update-center.json").read
  # The Jenkins mirror returns the data in the following format
  #   updateCenter.post(
  #     {.. JSON data...}
  #   );
  # which is used by the Javascript used by the Jenkins UI to send to Jenkins.
  #
  update_center_data.gsub!("updateCenter.post(\n", "")
  update_center_data.gsub!("\n);", "")

  @logger.debug "Posting the obtained JSON to Jenkins Update Center..."
  post_json("/updateCenter/byId/default/postBack", update_center_data)
end

- (Object) inspect

Overrides the inspect method to get rid of the credentials being shown in the in interactive IRB sessions and also when the `inspect` method is called. Just print the important variables.



233
234
235
236
237
238
239
240
241
242
 
# File 'lib/jenkins_api_client/client.rb', line 233

def inspect
  "#<JenkinsApi::Client:0x#{(self.__id__ * 2).to_s(16)}" +
    " @ssl=#{@ssl.inspect}," +
    " @log_location=#{@log_location.inspect}," +
    " @log_level=#{@log_level.inspect}," +
    " @crumbs_enabled=#{@crumbs_enabled.inspect}," +
    " @follow_redirects=#{@follow_redirects.inspect}," +
    " @jenkins_path=#{@jenkins_path.inspect}," +
    " @timeout=#{@timeout.inspect}>"
end

- (JenkinsApi::Client::Job) job

Creates an instance to the Job class by passing a reference to self

Returns:



168
169
170
 
# File 'lib/jenkins_api_client/client.rb', line 168

def job
  JenkinsApi::Client::Job.new(self)
end

- (JenkinsApi::Client::Node) node

Creates an instance to the Node class by passing a reference to self

Returns:



184
185
186
 
# File 'lib/jenkins_api_client/client.rb', line 184

def node
  JenkinsApi::Client::Node.new(self)
end

- (JenkinsApi::Client::PluginManager) plugin

Creates an instance to the PluginManager by passing a reference to self

Returns:



209
210
211
 
# File 'lib/jenkins_api_client/client.rb', line 209

def plugin
  JenkinsApi::Client::PluginManager.new(self)
end

- (String) post_config(url_prefix, xml)

Posts the given xml configuration to the url given

Parameters:

  • url_prefix (String) —

    The prefix to be used in the URL

  • xml (String) —

    The XML configuration to be sent to Jenkins

Returns:

  • (String) —

    Response code returned from Jenkins



394
395
396
 
# File 'lib/jenkins_api_client/client.rb', line 394

def post_config(url_prefix, xml)
  post_data(url_prefix, xml, 'application/xml')
end

- (Object) post_data(url_prefix, data, content_type) 



402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
 
# File 'lib/jenkins_api_client/client.rb', line 402

def post_data(url_prefix, data, content_type)
  retries = @crumb_max_retries
  begin
    refresh_crumbs

    request = Net::HTTP::Post.new("#{@jenkins_path}#{url_prefix}")
    @logger.info "POST #{url_prefix}"
    request.body = data
    request.content_type = content_type
    if @crumbs_enabled
      request[@crumb["crumbRequestField"]] = @crumb["crumb"]
    end
    response = make_http_request(request)
    handle_exception(response)
  rescue Exceptions::ForbiddenException => e
    refresh_crumbs(true)

    if @crumbs_enabled
      @logger.info "Retrying: #{@crumb_max_retries - retries + 1} out of" +
        " #{@crumb_max_retries} times..."
      retries -= 1

      if retries > 0
        retry
      else
        raise Exceptions::ForbiddenWithCrumb.new(@logger, e.message)
      end
    else
      raise
    end
  end
end

- (Object) post_json(url_prefix, json) 



398
399
400
 
# File 'lib/jenkins_api_client/client.rb', line 398

def post_json(url_prefix, json)
  post_data(url_prefix, json, 'application/json')
end

- (JenkinsApi::Client::BuildQueue) queue

Creates an instance to the BuildQueue by passing a reference to self

Returns:



200
201
202
 
# File 'lib/jenkins_api_client/client.rb', line 200

def queue
  JenkinsApi::Client::BuildQueue.new(self)
end

- (JenkinsApi::Client::System) system

Creates an instance to the System class by passing a reference to self

Returns:



176
177
178
 
# File 'lib/jenkins_api_client/client.rb', line 176

def system
  JenkinsApi::Client::System.new(self)
end

- (String) to_s

Returns a string representing the class name

Returns:

  • (String) —

    string representation of class name



225
226
227
 
# File 'lib/jenkins_api_client/client.rb', line 225

def to_s
  "#<JenkinsApi::Client>"
end

- (Boolean) use_crumbs?

Checks if Jenkins uses crumbs (i.e) the XSS disable option is checked in Jenkins' security settings

Returns:

  • (Boolean) —

    whether Jenkins uses crumbs or not



458
459
460
461
 
# File 'lib/jenkins_api_client/client.rb', line 458

def use_crumbs?
  response = api_get_request("")
  response["useCrumbs"]
end

- (Boolean) use_security?

Checks if Jenkins uses security

Returns:

  • (Boolean) —

    whether Jenkins uses security or not



467
468
469
470
 
# File 'lib/jenkins_api_client/client.rb', line 467

def use_security?
  response = api_get_request("")
  response["useSecurity"]
end

- (JenkinsApi::Client::User) user

Creates an instance of the User class by passing a reference to self

Returns:



217
218
219
 
# File 'lib/jenkins_api_client/client.rb', line 217

def user
  JenkinsApi::Client::User.new(self)
end

- (JenkinsApi::Client::View) view

Creates an instance to the View class by passing a reference to self

Returns:



192
193
194
 
# File 'lib/jenkins_api_client/client.rb', line 192

def view
  JenkinsApi::Client::View.new(self)
end