xclarity_client 0.6.5 → 0.6.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a94d8c6370c78465f0607a7ea7d5dece6ac95d94
-  data.tar.gz: ce694e22536e0b68ee82ad13bc8e523a9e497b84
+SHA256:
+  metadata.gz: 97e51a6b89b3d94948e74936c80cca4a97599549aeb7723eb290062aef58e582
+  data.tar.gz: 16c23bc24b5a013f0b53c538cf3b212e8f4d8565e676ec73e66ee8a90fc380b3
 SHA512:
-  metadata.gz: '09cb4cfa48391846096107de5f4989d20246d8bd0edae3735264f304cf3d4df1b7d884ba0f9ad3f74f456aa971d83f5885e7fb8e503213f4356e1f5c607b503f'
-  data.tar.gz: dbb35e325ad671c58f5431bec6d40577f4655a569008afd33b2df25d4a9866d05bd809767c137e962c37ae558699068ebf25d50ef9c4f8a2f027b10fe030152d
+  metadata.gz: e2274fa28d68f861a3a4d5d918d71087bb412e0330f07ad61c748a33ac41abbd025c5ed2b2219d75f68405424ab668e0e25c86c45dd2e108461cbe7c3f510d17
+  data.tar.gz: 6c9eba7601d7b2fb4aadb184de99b74a63c7b11399d20e4435341d36c5b3c211e239e5cc6f2afca7cccc36caa10a74060821e7b49f39ab66ceea5417793f64e6

data/lib/xclarity_client/client.rb

@@ -35,6 +35,7 @@ module XClarityClient
     include XClarityClient::Mixins::UpdateRepoMixin
     include XClarityClient::Mixins::UpdateCompMixin
     include XClarityClient::Mixins::UserMixin
+    include XClarityClient::Mixins::ManagementServerMixin
 
     def initialize(config)
       @config = config

data/lib/xclarity_client/connection/connection.rb

@@ -3,6 +3,7 @@ require 'faraday-cookie_jar'
 require 'uri'
 require 'uri/https'
 require 'timeout'
+require 'net/http'
 
 module XClarityClient
   #
@@ -11,7 +12,6 @@ module XClarityClient
   #
   class Connection
     HEADER_MESSAGE = 'XClarityClient::Connection'.freeze
-    #
     # @param [Hash] configuration - the data to create a connection with the LXCA
     # @option configuration [String] :host             the LXCA host
     # @option configuration [String] :username         the LXCA username
@@ -24,20 +24,23 @@ module XClarityClient
     #
     def initialize(configuration)
       @connection = build(configuration)
-      @timeout    = configuration.timeout
+      @connection_multipart = build(configuration, true)
+      @connection_net_http = build(configuration, false, true)
+      @timeout = configuration.timeout
+      @configuration = configuration
     end
 
-    #
     # Does a GET request to an LXCA endpoint
     #
     # @param [String] uri - endpoint to do the request
     # @param [Hash] query - params to query the endpoint resources
     # @param [Hash] headers - add headers to the request
     #
-    def do_get(uri = "", query: {}, headers: {})
+    def do_get(uri = "", query: {}, headers: {}, n_http: false)
       url_query = query.size > 0 ? "?" + query.map {|k, v| "#{k}=#{v}"}.join("&") : ""
       Timeout.timeout(@timeout) do
-        @connection.get do |req|
+        con = n_http ? @connection_net_http : @connection
+        con.get do |req|
           req.url(uri + url_query)
           headers.map { |key, value| req.headers[key] = value }
         end
@@ -49,41 +52,61 @@ module XClarityClient
       Faraday::Response.new
     end
 
-    #
+    def do_get_file_download(url, file_path)
+      host = @configuration.host
+      username = @configuration.username
+      password = @configuration.password
+
+      uri = 'https://' + host + url unless host.include?('https')
+      uri = host + url if host.include?('https')
+
+      uri = URI(uri)
+      Net::HTTP.start(uri.host, uri.port,
+                      :use_ssl     => true,
+                      :verify_mode => 0) do |http|
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request.basic_auth(username, password)
+
+        http.request(request) do |response|
+          open file_path, 'wb' do |io|
+            response.read_body do |chunk|
+              io.write(chunk)
+            end
+          end
+        end
+      end
+    end
+
     # Does a POST request to an LXCA endpoint
     #
     # @param [String] uri - endpoint to do the request
     # @param [JSON] body  - json to be sent in request body
     #
-    def do_post(uri = '', body = '')
-      build_request(:post, uri, body)
+    def do_post(uri = '', body = '', multipart = false)
+      build_request(:post, uri, body, multipart)
     end
 
-    #
     # Does a PUT request to an LXCA endpoint
-    #
     # @param [String] uri - endpoint to do the request
     # @param [JSON] body  - json to be sent in request body
-    #
     def do_put(uri = '', body = '')
       build_request(:put, uri, body)
     end
 
-    #
     # Does a DELETE request to an LXCA endpoint
-    #
     # @param [String] uri - endpoint to do the request
-    #
     def do_delete(uri = '')
       build_request(:delete, uri)
     end
 
     private
 
-    def build_request(method, url, body = '')
-      @connection.send(method) do |request|
+    def build_request(method, url, body = '', multipart = false)
+      con = multipart ? @connection_multipart : @connection
+      con.send(method) do |request|
         request.url(url)
-        request.headers['Content-Type'] = 'application/json'
+        request.headers['Content-Type'] = 'application/json' unless multipart
         request.body = body
       end
     rescue Faraday::Error::ConnectionFailed => e
@@ -95,32 +118,47 @@ module XClarityClient
       Faraday::Response.new
     end
 
-    def build(configuration)
-      header = HEADER_MESSAGE + ' build'
-      $lxca_log.info(header, 'Building the connection')
-
-      hostname = URI.parse(configuration.host)
-
-      url = URI::HTTPS.build({ :host     => hostname.scheme ? hostname.host : hostname.path,
-                               :port     => configuration.port.to_i,
-                               :query    => hostname.query,
-                               :fragment => hostname.fragment }).to_s
-      $lxca_log.info(header, "Creating connection to #{url}")
+    def create_connection_obj(connection, configuration)
+      user_agent_label = configuration.user_agent_label
+      agent_label = user_agent_label.nil? ? "" : user_agent_label
+      header = "LXCA via Ruby Client/#{XClarityClient::VERSION}"
+      connection.headers[:user_agent] = header + agent_label
+      basic_auth = configuration.auth_type == 'basic_auth'
+      username = configuration.username
+      password = configuration.password
+      connection.basic_auth(username, password) if basic_auth
+      $lxca_log.info(header, 'Connection created Successfuly')
+      connection
+    end
 
-      connection = Faraday.new(url: url) do |faraday|
+    def create_faraday_obj(url, configuration, multipart, n_http)
+      Faraday.new(url: url) do |faraday|
+        faraday.request(:multipart) if multipart # multipart form data
         faraday.request(:url_encoded) # form-encode POST params
         faraday.response(:logger, $lxca_log.log) # log requests to log file
         faraday.use(:cookie_jar) if configuration.auth_type == 'token'
-        faraday.adapter(:httpclient) # make requests with HTTPClient
+        faraday.adapter(:httpclient) unless n_http || multipart
+        faraday.adapter(:net_http) if n_http || multipart # with net_http
         faraday.ssl[:verify] = configuration.verify_ssl == 'PEER'
       end
+    end
 
-      connection.headers[:user_agent] = "LXCA via Ruby Client/#{XClarityClient::VERSION}" + (configuration.user_agent_label.nil? ? "" : " (#{configuration.user_agent_label})")
-
-      connection.basic_auth(configuration.username, configuration.password) if configuration.auth_type == 'basic_auth'
-      $lxca_log.info(header, 'Connection created Successfuly')
+    def build_connection(url, configuration, multipart = false, n_http = false)
+      con_obj = create_faraday_obj(url, configuration, multipart, n_http)
+      create_connection_obj(con_obj, configuration)
+    end
 
-      connection
+    def build(configuration, multipart = false, n_http = false)
+      header = HEADER_MESSAGE + ' build'
+      $lxca_log.info(header, 'Building the connection')
+      hostname = URI.parse(configuration.host)
+      host = hostname.scheme ? hostname.host : hostname.path
+      url = URI::HTTPS.build(:host     => host,
+                             :port     => configuration.port.to_i,
+                             :query    => hostname.query,
+                             :fragment => hostname.fragment).to_s
+      $lxca_log.info(header, "Creating connection to #{url}")
+      build_connection(url, configuration, multipart, n_http)
     end
   end
 end

data/lib/xclarity_client/endpoints/endpoints.rb

@@ -36,3 +36,4 @@ require 'xclarity_client/endpoints/hostplatform'
 require 'xclarity_client/endpoints/osimage'
 require 'xclarity_client/endpoints/remotefileserver'
 require 'xclarity_client/endpoints/compliance_policy'
+require 'xclarity_client/endpoints/management_server'

data/lib/xclarity_client/endpoints/management_server.rb

@@ -0,0 +1,5 @@
+module XClarityClient
+  class ManagementServer < Endpoints::XclarityEndpoint
+    BASE_URI = '/managementServer/updates'.freeze
+  end
+end

data/lib/xclarity_client/mixins/job_mixin.rb

@@ -24,9 +24,5 @@ module XClarityClient
     def delete_job(id = '')
       JobManagement.new(@config).delete_job(id)
     end
-
-    def get_job(job_id = '')
-      JobManagement.new(@config).get_job(job_id)
-    end
   end
 end

data/lib/xclarity_client/mixins/management_server_mixin.rb

@@ -0,0 +1,40 @@
+module XClarityClient
+  #
+  # Exposes ManagementServerManagement features
+  #
+  module Mixins::ManagementServerMixin
+    def get_management_server_updates_info(key = nil)
+      obj = ManagementServerManagement.new(@config)
+      obj.get_management_server_updates_info(key)
+    end
+
+    def delete_management_server_updates(fixids)
+      return "parameter 'fixids' should be array" unless fixids.kind_of?(Array)
+      obj = ManagementServerManagement.new(@config)
+      obj.delete_management_server_updates(fixids)
+    end
+
+    def download_management_server_updates(fixids)
+      return "parameter 'fixids' should be array" unless fixids.kind_of?(Array)
+      obj = ManagementServerManagement.new(@config)
+      obj.download_management_server_updates(fixids)
+    end
+
+    def apply_management_server_updates(fixids)
+      return "parameter 'fixids' should be array" unless fixids.kind_of?(Array)
+      obj = ManagementServerManagement.new(@config)
+      obj.apply_management_server_updates(fixids)
+    end
+
+    def refresh_management_server_updates_catalog
+      obj = ManagementServerManagement.new(@config)
+      obj.refresh_management_server_updates_catalog
+    end
+
+    def import_management_server_updates(files)
+      return "parameter 'files' should be array" unless files.kind_of?(Array)
+      obj = ManagementServerManagement.new(@config)
+      obj.import_management_server_updates(files)
+    end
+  end
+end

data/lib/xclarity_client/mixins/mixins.rb

@@ -38,3 +38,4 @@ require 'xclarity_client/mixins/manage_request_mixin'
 require 'xclarity_client/mixins/update_repo_mixin'
 require 'xclarity_client/mixins/update_comp_mixin'
 require 'xclarity_client/mixins/user_mixin'
+require 'xclarity_client/mixins/management_server_mixin'

data/lib/xclarity_client/mixins/node_mixin.rb

@@ -57,8 +57,50 @@ module XClarityClient
       node_management.set_power_state(uuid, :bootToF1)
     end
 
+    def retrieve_mounted_media_details(uuid = '')
+      node_management.retrieve_mounted_media_details(uuid)
+    end
+
+    def enable_media_mount_support_thinkserver(uuid = '')
+      node_management.enable_media_mount_support(uuid)
+    end
+
+    def disable_media_mount_support_thinkserver(uuid = '')
+      node_management.disable_media_mount_support(uuid)
+    end
+
+    def remove_all_mounted_medias_thinksystem(uuid = '')
+      node_management.remove_all_mounted_medias(uuid)
+    end
+
+    def mount_media_thinkserver(uuid, opts)
+      validate_mount_media_params(opts, 'thinkserver')
+      node_management.mount_media(uuid, opts)
+    end
+
+    def mount_media_thinksystem(uuid, opts)
+      validate_mount_media_params(opts)
+      node_management.mount_media(uuid, opts)
+    end
+
+    def unmount_media_thinkserver(uuid, media_type = '')
+      node_management.unmount_media_thinkserver(uuid, media_type)
+    end
+
+    def unmount_media_thinksystem(uuid, media_uid = '')
+      node_management.unmount_media_thinksystem(uuid, media_uid)
+    end
+
     private
 
+    def validate_mount_media_params(opts, server_type = '')
+      msg = "parameter 'opts' should be of type hash"
+      raise(msg) unless opts.kind_of?(Hash)
+      err_msg = ':mediaType is mandatory field in input hash for thinkserver'
+      raise(err_msg) if server_type == 'thinkserver' &&
+                        !opts.keys.include?(:mediaType)
+    end
+
     def node_management
       NodeManagement.new(@config)
     end

data/lib/xclarity_client/mixins/update_repo_mixin.rb

@@ -11,23 +11,123 @@ module XClarityClient
       UpdateRepoManagement.new(@config).read_update_repo
     end
 
-    def refresh_update_repo(scope, mt, os)
-      UpdateRepoManagement.new(@config).refresh_update_repo(scope, mt, os)
+    def refresh_update_repo_catalog(scope, machine_types)
+      mt = machine_types
+      msg = 'Parameter machine_types should be of type Array'
+      raise msg unless mt.kind_of?(Array)
+      UpdateRepoManagement.new(@config).refresh_update_repo_catalog(scope, mt)
     end
 
-    def acquire_firmware_updates(scope, fixids, mt)
-      UpdateRepoManagement.new(@config).acquire_firmware_updates(scope,
-                                                                 fixids, mt)
+    def refresh_uxsp_update_repo_catalog(scope, machine_types)
+      mt = machine_types
+      msg = 'Parameter machine_types should be of type Array'
+      raise msg unless mt.kind_of?(Array)
+      UpdateRepoManagement.new(@config).refresh_uxsp_update_repo_catalog(scope,
+                                                                         mt)
     end
 
-    def delete_firmware_updates(file_types, fixids)
+    def updates_info_by_machine_types(machine_types)
+      mt = machine_types
+      msg = 'Parameter machine_types should be of type Array'
+      raise msg unless mt.kind_of?(Array)
+      UpdateRepoManagement.new(@config).updates_info_by_machine_types(mt)
+    end
+
+    def uxsp_updates_info_by_machine_types(machine_types)
+      mt = machine_types
+      msg = 'Parameter machine_types should be of type Array'
+      raise msg unless mt.kind_of?(Array)
+      UpdateRepoManagement.new(@config).uxsp_updates_info_by_machine_types(mt)
+    end
+
+    def acquire_firmware_updates(machine_types, fixids)
+      mt = machine_types
+      msg = 'Parameter machine_types & fixids should be of type Array'
+      raise msg unless mt.kind_of?(Array) || fixids.kind_of?(Array)
+      UpdateRepoManagement.new(@config).acquire_firmware_updates(mt, fixids)
+    end
+
+    def delete_firmware_updates(file_types, fixids = [])
+      validate_inputs(file_types, fixids)
       UpdateRepoManagement.new(@config).delete_firmware_updates(file_types,
                                                                 fixids)
     end
 
-    def export_firmware_updates(file_types, fixids)
+    def export_firmware_updates(file_types, fixids = [])
+      validate_inputs(file_types, fixids)
       UpdateRepoManagement.new(@config).export_firmware_updates(file_types,
                                                                 fixids)
     end
+
+    def download_exported_firmware_updates(file_name, dir_path_for_download)
+      dir = dir_path_for_download
+      validate_file_name_dir_path(file_name, dir)
+      UpdateRepoManagement.new(@config)
+                          .download_exported_firmware_updates(file_name, dir)
+    end
+
+    def validate_import_updates(file_path)
+      validate_file_path(file_path)
+      UpdateRepoManagement.new(@config).validate_import_updates(file_path)
+    end
+
+    def import_firmware_updates(file_path)
+      validate_file_path(file_path)
+      UpdateRepoManagement.new(@config).import_firmware_updates(file_path)
+    end
+
+    def track_task_status(taskid, tasktype)
+      UpdateRepoManagement.new(@config).track_task_status(taskid, tasktype)
+    end
+
+    def supported_machine_types_detail
+      UpdateRepoManagement.new(@config).supported_machine_types_detail
+    end
+
+    def retrieve_compliance_policy_list
+      UpdateRepoManagement.new(@config).retrieve_compliance_policy_list
+    end
+
+    def export_compliance_policies(policy_names)
+      msg = 'Parameter policy_names should be of type Array'
+      raise msg unless policy_names.kind_of?(Array)
+      UpdateRepoManagement.new(@config).export_compliance_policies(policy_names)
+    end
+
+    def download_exported_compliance_policies(file_name, dir_path_for_download)
+      dir = dir_path_for_download
+      validate_file_name_dir_path(file_name, dir)
+      UpdateRepoManagement.new(@config)\
+                          .download_exported_compliance_policies(file_name, dir)
+    end
+
+    def import_compliance_policies(file_path)
+      validate_file_path(file_path)
+      UpdateRepoManagement.new(@config).import_compliance_policies(file_path)
+    end
+
+    private
+
+    def validate_inputs(file_types, fixids)
+      msg = 'Invalid value for argument file_types. Allowed values are'\
+               + ' - all and payloads'
+      raise msg unless %w(payloads all).include?(file_types)
+      msg = 'Parameter fixids should be of type Array'
+      raise msg unless fixids.kind_of?(Array)
+      raise msg if file_types == 'payloads' && !fixids.any?
+    end
+
+    def validate_file_name_dir_path(file_name, dir_path_for_download)
+      msg = 'Parameter file_name and dir_path_for_download,'\
+             + 'should be of type String'
+      raise msg unless file_name.kind_of?(String)
+      dir = dir_path_for_download
+      msg = dir + ' directory doesnt exists'
+      raise msg unless File.directory?(dir)
+    end
+
+    def validate_file_path(file_path)
+      raise "file #{file_path} doesn't exists" unless File.file?(file_path)
+    end
   end
 end

data/lib/xclarity_client/services/job_management.rb

@@ -6,13 +6,11 @@ module XClarityClient
 
     def cancel_job(uuid='')
       cancelReq = JSON.generate(cancelRequest: 'true')
-      response = @connection.do_put(managed_resource::BASE_URI + '/' + uuid, cancelReq)
-      response
+      @connection.do_put(managed_resource::BASE_URI + '/' + uuid, cancelReq)
     end
 
     def delete_job(uuid='')
-      response = @connection.do_delete(managed_resource::BASE_URI + '/' + uuid)
-      response
+      @connection.do_delete(managed_resource::BASE_URI + '/' + uuid)
     end
   end
 end

data/lib/xclarity_client/services/management_server_management.rb

@@ -0,0 +1,86 @@
+require 'json'
+require 'pathname'
+
+module XClarityClient
+  # ManagementServerManagement class
+  class ManagementServerManagement < Services::XClarityService
+    manages_endpoint ManagementServer
+
+    private
+
+    def start_management_server_updates_import_job(file_type_dict, files, jobid)
+      url = "/files#{ManagementServer::BASE_URI}?action=import&jobid=#{jobid}"
+      index = 0
+      payload = {}
+      files.each do |file_name|
+        type = file_type_dict[File.extname(file_name)]
+        key = 'file_' + (index += 1).to_s
+        payload[key.to_sym] = Faraday::UploadIO.new(file_name, type)
+      end
+      @connection.do_post(url, payload, true)
+    end
+
+    def populate_payload_files(files, file_type_dict)
+      payload_files = []
+      index = 0
+      files.each do |file|
+        name = File.basename(file)
+        payload_file = { :index => index += 1, :name => name.strip,
+                         :type => file_type_dict[File.extname(name)].strip,
+                         :size => File.size?(file) }
+        payload_files.push(payload_file)
+      end
+      payload_files
+    end
+
+    public
+
+    def get_management_server_updates_info(key = nil)
+      base_url = ManagementServer::BASE_URI
+      url = key.nil? ? base_url : "#{base_url}?key=#{key}"
+      msg = "input key=#{key}"
+      $lxca_log.info(self.class.to_s + ' ' + __method__.to_s, msg)
+      @connection.do_get(url)
+    end
+
+    def download_management_server_updates(fixids)
+      url = "#{ManagementServer::BASE_URI}?action=acquire"
+      opts = { :fixids => fixids }
+      request_body = JSON.generate(opts)
+      @connection.do_post(url, request_body)
+    end
+
+    def import_management_server_updates(files)
+      url = "#{ManagementServer::BASE_URI}?action=import"
+      file_type_dict = { '.txt' => 'text/plain', '.xml' => 'text/xml',
+                         '.chg' => 'application/octet-stream',
+                         '.tgz' => 'application/x-compressed' }
+      payload_files = populate_payload_files(files, file_type_dict)
+      request_body = JSON.generate(:files => payload_files)
+      response = @connection.do_post(url, request_body)
+      jobid = JSON.parse(response.body)['jobid']
+      $lxca_log.info(self.class.to_s + ' ' + __method__.to_s, "jobid: #{jobid}")
+      start_management_server_updates_import_job(file_type_dict, files, jobid)
+    end
+
+    def apply_management_server_updates(fixids)
+      url = "#{ManagementServer::BASE_URI}?action=apply"
+      opts = { :fixids => fixids }
+      request_body = JSON.generate(opts)
+      @connection.do_put(url, request_body)
+    end
+
+    def delete_management_server_updates(fixids)
+      fixids = fixids.join(',')
+      url = "#{ManagementServer::BASE_URI}/#{fixids}"
+      @connection.do_delete(url)
+    end
+
+    def refresh_management_server_updates_catalog
+      url = "#{ManagementServer::BASE_URI}?action=refresh"
+      opts = { :mts => ['lxca'] }
+      request_body = JSON.generate(opts)
+      @connection.do_post(url, request_body)
+    end
+  end
+end

data/lib/xclarity_client/services/node_management.rb

@@ -20,5 +20,51 @@ module XClarityClient
 
       send_power_request(managed_resource::BASE_URI + '/' + uuid + '/bmc', requested_state)
     end
+
+    def retrieve_mounted_media_details(uuid)
+      uri = Node::BASE_URI + "/#{uuid}/" + 'mediaMount'
+      @connection.do_get(uri)
+    end
+
+    def enable_media_mount_support(uuid)
+      uri = Node::BASE_URI + "/#{uuid}/" + 'mediaMount'
+      req_body = JSON.generate(:action => 'enableMountMedia')
+      @connection.do_put(uri, req_body)
+    end
+
+    def disable_media_mount_support(uuid)
+      uri = Node::BASE_URI + "/#{uuid}/" + 'mediaMount'
+      req_body = JSON.generate(:action => 'disableMountMedia')
+      @connection.do_put(uri, req_body)
+    end
+
+    def remove_all_mounted_medias(uuid)
+      uri = Node::BASE_URI + "/#{uuid}/" + 'mediaMount'
+      req_body = JSON.generate(:action => 'reset')
+      @connection.do_put(uri, req_body)
+    end
+
+    def mount_media(uuid, opts)
+      uri = Node::BASE_URI + "/#{uuid}/" + 'mediaMount'
+      opts[:action] = 'mount'
+      req_body = JSON.generate(opts)
+      @connection.do_put(uri, req_body)
+    end
+
+    def unmount_media_thinkserver(uuid, media_type)
+      uri = Node::BASE_URI + "/#{uuid}/" + 'mediaMount'
+      opts = { :action    => 'unmount',
+               :mediaType => media_type }
+      req_body = JSON.generate(opts)
+      @connection.do_put(uri, req_body)
+    end
+
+    def unmount_media_thinksystem(uuid, media_uid)
+      uri = Node::BASE_URI + "/#{uuid}/" + 'mediaMount'
+      opts = { :action => 'unmount',
+               :UID    => media_uid }
+      req_body = JSON.generate(opts)
+      @connection.do_put(uri, req_body)
+    end
   end
 end

data/lib/xclarity_client/services/osimage_management.rb

@@ -18,8 +18,9 @@ module XClarityClient
       request_body = JSON.generate(opts)
       image_name = path.split(File::SEPARATOR).last
       begin
-        response = @connection.do_post("#{OsImage::BASE_URI}?jobId=#{job_id}"\
-                                       "&imageType=OS&imageName=#{image_name}",
+        response = @connection.do_post('/files'\
+                                       + '#{OsImage::BASE_URI}?jobId=#{job_id}'\
+                                       '&imageType=OS&imageName=' + image_name,
                                        request_body)
         response
       rescue Faraday::TimeoutError => e

data/lib/xclarity_client/services/remote_access_management.rb

@@ -1,15 +1,17 @@
 require 'json'
 
 module XClarityClient
-  class RemoteAccessManagement < XClarityBase
+  class RemoteAccessManagement
 
     def initialize(conf)
-      super(conf, RemoteAccess::BASE_URI)
+      @connection = XClarityClient::Connection.new(conf)
     end
 
     def remote_control(uuid)
       raise 'UUID must not be blank' if uuid.nil? || uuid.empty?
-      con = connection("#{RemoteAccess::BASE_URI}/remoteControl" , {:uuid => uuid})
+      con = @connection.do_get(
+        "#{RemoteAccess::BASE_URI}/remoteControl", :query => { :uuid => uuid }
+      )
 
       unless con.success?
         $lxca_log.error "XClarityClient::RemoteAccessManagement remote_control", "Request failed"
@@ -54,4 +56,4 @@ module XClarityClient
       })
     end
   end
-end
+end

data/lib/xclarity_client/services/services.rb

@@ -39,3 +39,4 @@ require 'xclarity_client/services/update_repo_management'
 require 'xclarity_client/services/update_comp_management'
 require 'xclarity_client/services/user_management'
 require 'xclarity_client/services/virtual_appliance_management'
+require 'xclarity_client/services/management_server_management'

data/lib/xclarity_client/services/update_repo_management.rb

@@ -13,11 +13,8 @@ module XClarityClient
       err_missing_key = 'Option key must be provided for update_repo resource'
       err_wrong_key = 'The value for option key should be one of these : '\
         "#{allowed_keys.join(', ')}"
-
       raise err_missing_key if opts.empty? || !(opts[:key] || opts['key'])
-
       repo_key = opts[:key] || opts['key']
-
       raise err_wrong_key unless allowed_keys.include?(repo_key)
     end
 
@@ -36,60 +33,116 @@ module XClarityClient
 
     public
 
-    def check_file_types(file_types)
-      x = 'Invalid value for argument file_types. Allowed values are'\
-               + ' - all and payloads'
-      raise x unless file_types.casecmp('payloads').zero? ||
-                     file_types.casecmp('all').zero?
+    def track_task_status(taskid, tasktype)
+      uri = UpdateRepo::BASE_URI + '/status' + '?tasktype=' + tasktype\
+              + '&taskid=' + taskid.to_s
+      @connection.do_get(uri)
+    end
+
+    def download_exported_firmware_updates(fname, dir_path_to_download)
+      uri = UpdateRepo::BASE_URI + '?action=export&exportRepoFilename=' + fname
+      file_path = File.join(dir_path_to_download, fname)
+      @connection.do_get_file_download(uri, file_path)
     end
 
     def read_update_repo
-      response = @connection.do_put(UpdateRepo::BASE_URI + '?action=read')
-      response.body
+      @connection.do_put(UpdateRepo::BASE_URI + '?action=read')
     end
 
-    def refresh_update_repo(scope, mt, os)
-      if scope.casecmp('all') != 0 && scope.casecmp('latest') != 0
+    def refresh_update_repo_catalog(scope, mt, uxsp = false)
+      unless %w(all latest).include?(scope)
         raise 'Invalid argument combination of action and scope. Action'\
                + ' refresh can have scope as either all or latest'
       end
-      refresh_req = JSON.generate(:mt => mt, :os => os, :type => 'catalog')
-      response = @connection.do_put(UpdateRepo::BASE_URI\
-                                    + '?action=refresh&with='\
-                                    + scope.downcase, refresh_req)
-      response.body
+      req_body = JSON.generate(:mt => mt, :os => '', :type => 'catalog')
+      uri = UpdateRepo::BASE_URI
+      uri += '/uxsps' if uxsp
+      uri += '?action=refresh&with=' + scope
+      @connection.do_put(uri, req_body)
     end
 
-    def acquire_firmware_updates(scope, fixids, mt)
-      if scope.casecmp('payloads') != 0
-        raise 'Invalid argument combination of action and scope. Action'\
-               + ' acquire can have scope as payloads'
-      end
-      acquire_req = JSON.generate(:mt => mt, :fixids => fixids,
-                                  :type => 'latest')
-      response = @connection.do_put(UpdateRepo::BASE_URI\
-                                    + '?action=acquire&with='\
-                                    + scope.downcase, acquire_req)
-      response.body
-    end
-
-    def delete_firmware_updates(file_types, fixids)
-      check_file_types(file_types)
-      delete_req = JSON.generate(:fixids => fixids)
-      response = @connection.do_put(UpdateRepo::BASE_URI + '?action='\
-                                    + 'delete&filetypes=' + file_types.downcase,
-                                    delete_req)
-      response.body
-    end
-
-    def export_firmware_updates(file_types, fixids)
-      check_file_types(file_types)
-
-      export_req = JSON.generate(:fixids => fixids)
-      response = @connection.do_put(UpdateRepo::BASE_URI\
-                                    + '?action=export&filetypes='\
-                                    + file_types.downcase, export_req)
-      response.body
+    def refresh_uxsp_update_repo_catalog(scope, mt)
+      refresh_update_repo_catalog(scope, mt, true)
+    end
+
+    def updates_info_by_machine_types(mt, uxsp = false)
+      mt = mt.join(',').to_str
+      uri = UpdateRepo::BASE_URI
+      uri += '/uxsps' if uxsp
+      key = 'uxspsByMt' if uxsp
+      key = 'updatesByMt' unless uxsp
+      uri += '?key=' + key + '&with=all&payload&mt=' + mt
+      @connection.do_get(uri)
+    end
+
+    def uxsp_updates_info_by_machine_types(mt)
+      updates_info_by_machine_types(mt, true)
+    end
+
+    def supported_machine_types_detail
+      @connection.do_get(UpdateRepo::BASE_URI + '?key=supportedMts')
+    end
+
+    def acquire_firmware_updates(mt, fixids)
+      req_body = JSON.generate(:mt => mt, :fixids => fixids, :type => 'latest')
+      @connection.do_put(UpdateRepo::BASE_URI\
+               + '?action=acquire&with=payloads', req_body)
+    end
+
+    def delete_firmware_updates(file_types, fixids = [])
+      req_body = JSON.generate(:fixids => fixids)
+      @connection.do_put(UpdateRepo::BASE_URI + '?action='\
+                         + 'delete&filetypes=' + file_types.downcase,
+                         req_body)
+    end
+
+    def export_firmware_updates(file_types, fixids = [])
+      req_body = JSON.generate(:fixids => fixids)
+      @connection.do_put(UpdateRepo::BASE_URI\
+                         + '?action=export&filetypes='\
+                         + file_types.downcase, req_body)
+    end
+
+    def validate_import_updates(file_path)
+      type = 'application/x-zip-compressed'
+      fname = File.basename(file_path)
+      opts = { :index => 0, :name => fname,
+               :type  => type,
+               :size  => File.size?(file_path) }
+      req_body = JSON.generate(opts)
+      uri = '/files/updateRepositories/firmware/import/validate'
+      @connection.do_post(uri, req_body)
+    end
+
+    def import_firmware_updates(file_path)
+      uri = '/files/updateRepositories/firmware/import'
+      type = 'application/x-zip-compressed'
+      opts = { :upload_file => Faraday::UploadIO.new(file_path, type) }
+      @connection.do_post(uri, opts, true)
+    end
+
+    def retrieve_compliance_policy_list
+      uri = '/compliancePolicies'
+      @connection.do_get(uri)
+    end
+
+    def export_compliance_policies(policy_names)
+      uri = '/compliancePolicies?action=export'
+      req_body = JSON.generate(:export => policy_names)
+      @connection.do_put(uri, req_body)
+    end
+
+    def download_exported_compliance_policies(fname, dir_path_for_download)
+      uri = '/compliancePolicies?exportDownload=' + fname
+      file_path = File.join(dir_path_for_download, fname)
+      @connection.do_get_file_download(uri, file_path)
+    end
+
+    def import_compliance_policies(file_path)
+      uri = '/files/compliancePolicies?action=import'
+      type = 'application/x-zip-compressed'
+      opts = { :upload_file => Faraday::UploadIO.new(file_path, type) }
+      @connection.do_post(uri, opts, true)
     end
   end
 end

data/lib/xclarity_client/services/virtual_appliance_management.rb

@@ -1,5 +1,5 @@
 module XClarityClient
-  class VirtualApplianceManagement < XClarityBase
+  class VirtualApplianceManagement
 
     BASE_URI          = '/aicc'.freeze
     NETWORK_URI       = '/network'.freeze
@@ -10,12 +10,11 @@ module XClarityClient
     SUBSCRIPTIONS_URI = '/subscriptions'.freeze
 
     def initialize(conf)
-      super(conf, BASE_URI)
+      @connection = XClarityClient::Connection.new(conf)
     end
 
     def configuration_settings
-      response = connection
-      response
+      @connection.do_get(BASE_URI)
     end
 
     def configuration_settings=()
@@ -24,8 +23,8 @@ module XClarityClient
     def ip_enablement_state
       uri = BASE_URI+NETWORK_URI+IPDISABLE_URI
       $lxca_log.info "XclarityClient::VirtualApplianceManagement ip_enablement_state", "Action has been sent to #{uri}"
-      response = connection(uri)
-      response
+
+      @connection.do_get(uri)
     end
 
     def ip_enablement_state=()
@@ -35,8 +34,8 @@ module XClarityClient
     def host_settings
       uri = BASE_URI+NETWORK_URI+IPDISABLE_URI
       $lxca_log.info "XclarityClient::VirtualApplianceManagement host_settings", "Action has been sent to #{uri}"
-      response = connection(uri)
-      response
+
+      @connection.do_get(uri)
     end
 
     def host_settings=()
@@ -46,8 +45,8 @@ module XClarityClient
     def network_interface_settings(interface)
       uri = BASE_URI+NETWORK_URI+INTERFACES_URI+"/#{interface}"
       $lxca_log.info "XclarityClient::VirtualApplianceManagement network_interface_settings", "Action has been sent to #{uri}"
-      response = connection(uri)
-      response
+
+      @connection.do_get(uri)
     end
 
     def host_settings=()
@@ -57,8 +56,8 @@ module XClarityClient
     def route_settings
       uri = BASE_URI+NETWORK_URI+ROUTES_URI
       $lxca_log.info "XclarityClient::VirtualApplianceManagement route_settings", "Action has been sent to #{uri}"
-      response = connection(uri)
-      response
+
+      @connection.do_get(uri)
     end
 
     def route_settings=()
@@ -68,14 +67,12 @@ module XClarityClient
     def subscriptions
       uri = BASE_URI+SUBSCRIPTIONS_URI
       $lxca_log.info "XclarityClient::VirtualApplianceManagement subscriptions", "Action has been sent to #{uri}"
-      response = connection(uri)
-      response
+
+      @connection.do_get(uri)
     end
 
     def subscriptions=()
 
     end
-
-
   end
 end

data/lib/xclarity_client/version.rb

@@ -1,3 +1,3 @@
 module XClarityClient
-  VERSION = "0.6.5"
+  VERSION = '0.6.9'.freeze
 end

data/lib/xclarity_client/xclarity_credentials_validator.rb

@@ -1,11 +1,11 @@
 require 'json'
 
 module XClarityClient
-  class XClarityCredentialsValidator < XClarityBase
+  class XClarityCredentialsValidator
     BASE_URI = '/sessions'.freeze
 
     def initialize(conf)
-      super(conf, BASE_URI)
+      @connection = XClarityClient::Connection.new(conf)
       @configuration = conf
     end
 
@@ -33,19 +33,16 @@ module XClarityClient
     end
 
     def build_session(conf)
-      @response = @conn.post do |request|
-      request.headers['Content-Type'] = 'application/json'
-      request.body = { :UserId => conf.username,
-                       :password => conf.password }.to_json
-      end
+      @response = @connection.do_post(BASE_URI, {
+        :UserId => conf.username,
+        :password => conf.password
+      }.to_json)
+
       raise Faraday::Error::ConnectionFailed unless @response.success?
     end
 
     def close_session(id_session)
-      @conn.delete do |request|
-        request.url "#{BASE_URI}/#{id_session}"
-        request.headers['Content-Type'] = 'application/json'
-      end
+      @connection.do_delete("#{BASE_URI}/#{id_session}")
     end
   end
 end

data/lib/xclarity_client.rb

@@ -8,7 +8,6 @@ end
 require 'xclarity_client/errors/errors'
 
 require 'xclarity_client/configuration'
-require 'xclarity_client/xclarity_base'
 require 'xclarity_client/xclarity_credentials_validator'
 require 'xclarity_client/discover'
 require 'xclarity_client/endpoints/endpoints'

data/xclarity_client.gemspec

@@ -17,15 +17,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency('bundler', '>= 1.11.2')
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "apib-mock_server", "~> 1.0.3"
   spec.add_development_dependency "webmock", "~> 2.1.0"
-  spec.add_dependency             "faraday", "~> 0.9"
+  spec.add_development_dependency "faker", "~> 1.8.3"
+  spec.add_dependency             "faraday", '>= 0.9', '< 2.0.0'
   spec.add_dependency             "faraday-cookie_jar", "~> 0.0.6"
   spec.add_dependency             "httpclient", "~>2.8.3"
   spec.add_dependency             "uuid", "~> 2.3.8"
-  spec.add_dependency             "faker", "~> 1.8.3"
   spec.add_dependency             "json-schema", "~> 2.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xclarity_client
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.6.9
 platform: ruby
 authors:
 - Manasa Rao
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-22 00:00:00.000000000 Z
+date: 2022-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: 1.11.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: 1.11.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -82,19 +82,39 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.1.0
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: faker
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: faraday-cookie_jar
   requirement: !ruby/object:Gem::Requirement
@@ -137,20 +157,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.3.8
-- !ruby/object:Gem::Dependency
-  name: faker
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.8.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.8.3
 - !ruby/object:Gem::Dependency
   name: json-schema
   requirement: !ruby/object:Gem::Requirement
@@ -245,6 +251,7 @@ files:
 - lib/xclarity_client/endpoints/hostplatform.rb
 - lib/xclarity_client/endpoints/job.rb
 - lib/xclarity_client/endpoints/manage_request.rb
+- lib/xclarity_client/endpoints/management_server.rb
 - lib/xclarity_client/endpoints/node.rb
 - lib/xclarity_client/endpoints/osimage.rb
 - lib/xclarity_client/endpoints/persisted_result.rb
@@ -284,6 +291,7 @@ files:
 - lib/xclarity_client/mixins/host_platform_mixin.rb
 - lib/xclarity_client/mixins/job_mixin.rb
 - lib/xclarity_client/mixins/manage_request_mixin.rb
+- lib/xclarity_client/mixins/management_server_mixin.rb
 - lib/xclarity_client/mixins/mixins.rb
 - lib/xclarity_client/mixins/node_mixin.rb
 - lib/xclarity_client/mixins/os_image_mixin.rb
@@ -318,6 +326,7 @@ files:
 - lib/xclarity_client/services/hostplatform_management.rb
 - lib/xclarity_client/services/job_management.rb
 - lib/xclarity_client/services/manage_request_management.rb
+- lib/xclarity_client/services/management_server_management.rb
 - lib/xclarity_client/services/mixins/endpoint_manager_mixin.rb
 - lib/xclarity_client/services/mixins/list_name_interpreter_mixin.rb
 - lib/xclarity_client/services/mixins/power_action_sender_mixin.rb
@@ -340,7 +349,6 @@ files:
 - lib/xclarity_client/services/xclarity_management_mixin.rb
 - lib/xclarity_client/services/xclarity_service.rb
 - lib/xclarity_client/version.rb
-- lib/xclarity_client/xclarity_base.rb
 - lib/xclarity_client/xclarity_credentials_validator.rb
 - xclarity_client.gemspec
 homepage: https://github.com/lenovo/xclarity_client
@@ -361,8 +369,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Lenovo XClarity API Client

data/lib/xclarity_client/xclarity_base.rb

@@ -1,88 +0,0 @@
-require 'faraday'
-require 'faraday-cookie_jar'
-require 'uri'
-require 'uri/https'
-
-module XClarityClient
-  class XClarityBase
-
-    attr_reader :conn
-
-    def initialize(conf, uri)
-      connection_builder(conf, uri)
-    end
-
-    def connection_builder(conf, uri)
-      $lxca_log.info "XClarityClient::XClarityBase connection_builder", "Building the url"
-      #Building configuration
-      hostname = URI.parse(conf.host)
-      url = URI::HTTPS.build({ :host     => hostname.scheme ? hostname.host : hostname.path,
-                               :port     => conf.port.to_i,
-                               :path     => uri,
-                               :query    => hostname.query,
-                               :fragment => hostname.fragment }).to_s
-
-      $lxca_log.info "XClarityClient::XClarityBase connection_builder", "Creating connection to #{url}"
-
-      @conn = Faraday.new(url: url) do |faraday|
-        faraday.request  :url_encoded             # form-encode POST params
-        faraday.response :logger, $lxca_log.log   # log requests to STDOUT -- This line, should be uncommented if you wanna inspect the URL Request
-        faraday.use :cookie_jar if conf.auth_type == 'token'
-        faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
-        faraday.ssl[:verify] = conf.verify_ssl == 'PEER'
-      end
-
-      @conn.headers[:user_agent] = "LXCA via Ruby Client/#{XClarityClient::VERSION}" + (conf.user_agent_label.nil? ? "" : " (#{conf.user_agent_label})")
-      @conn.basic_auth(conf.username, conf.password) if conf.auth_type == 'basic_auth'
-      $lxca_log.info "XClarityClient::XclarityBase connection_builder", "Connection created Successfuly"
-      @conn
-    end
-
-    private
-
-    def connection(uri = "", opts = {})
-      query = opts.size > 0 ? "?" + opts.map {|k, v| "#{k}=#{v}"}.join(",") : ""
-      begin
-        @conn.get(uri + query)
-      rescue Faraday::Error::ConnectionFailed => e
-        $lxca_log.error "XClarityClient::XclarityBase connection", "Error trying to send a GET to #{uri + query}"
-        Faraday::Response.new
-      end
-    end
-
-    def do_post(uri="", request = {})
-      begin
-        @conn.post do |req|
-          req.url uri
-          req.headers['Content-Type'] = 'application/json'
-          req.body = request
-        end
-      rescue Faraday::Error::ConnectionFailed => e
-        $lxca_log.error "XClarityClient::XclarityBase do_post", "Error trying to send a POST to #{uri}"
-        $lxca_log.error "XClarityClient::XclarityBase do_post", "Request sent: #{request}"
-        Faraday::Response.new
-      end
-    end
-
-    def do_put (uri="", request = {})
-      begin
-        @conn.put do |req|
-          req.url uri
-          req.headers['Content-Type'] = 'application/json'
-          req.body = request
-        end
-      rescue Faraday::Error::ConnectionFailed => e
-        $lxca_log.error "XClarityClient::XclarityBase do_put", "Error trying to send a PUT to #{uri}"
-        $lxca_log.error "XClarityClient::XclarityBase do_put", "Request sent: #{request}"
-        Faraday::Response.new
-      end
-    end
-
-    def do_delete (uri="")
-      @conn.delete do |req|
-        req.url uri
-        req.headers['Content-Type'] = 'application/json'
-      end
-    end
-  end
-end