xclarity_client 0.6.6 → 0.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3de68cc1b07f9953dbefe5fda0b8b8e74df98f0a
-  data.tar.gz: 39e2effba3ca1815ec833c2a63ea36a1e8e03a3d
+  metadata.gz: 35f2443209d986e5608952ffd73ff6136d41793c
+  data.tar.gz: 0c0d9593884792ad1e9be4b718c7d0951e86a99a
 SHA512:
-  metadata.gz: fd9cdbe853931062976eb4ab76af736b258b5b2ce68900a131c1a93d95d1cc9c30bd8e4e333fbf6b2e0ff354ef45b01ca10b10334eb4e6dd537d45689c030195
-  data.tar.gz: 930d73b66b1e7548274b83101bfe44611327948bae00df63f413bde98d3025f6da70da8132e4d07b63bb5175011e83d8c8b835d35340346650dea13b749d649f
+  metadata.gz: cc76fc06ce1c471841b8c5868419aa7ff418bda70557199fe4cf024f2212ebd18254baa40ac7f3e00fdfffa98550b050d631dd6767d153ed003ca3f250bc19d6
+  data.tar.gz: ba3dffa723f8eebbdcef91ed75000f8ed534929ff0c62ce16335bd40d3f0a954286156faa163e82328b66035e675a1838d6a1eb23b8ddaec25984128c7ebaa74

data/lib/xclarity_client/connection/connection.rb

@@ -3,7 +3,7 @@ require 'faraday-cookie_jar'
 require 'uri'
 require 'uri/https'
 require 'timeout'
-require 'pp'
+require 'net/http'
 
 module XClarityClient
   #
@@ -25,7 +25,9 @@ module XClarityClient
     def initialize(configuration)
       @connection = build(configuration)
       @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
@@ -34,10 +36,11 @@ module XClarityClient
     # @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,6 +52,32 @@ 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
@@ -74,17 +103,11 @@ module XClarityClient
     private
 
     def build_request(method, url, body = '', multipart = false)
-      if multipart == true
-        @connection_multipart.send(method) do |request|
-          request.url(url)
-          request.body = body
-        end
-      else
-        @connection.send(method) do |request|
-          request.url(url)
-          request.headers['Content-Type'] = 'application/json'
-          request.body = body
-        end
+      con = multipart ? @connection_multipart : @connection
+      con.send(method) do |request|
+        request.url(url)
+        request.headers['Content-Type'] = 'application/json' unless multipart
+        request.body = body
       end
     rescue Faraday::Error::ConnectionFailed => e
       header = HEADER_MESSAGE + " do_#{method}"
@@ -95,7 +118,7 @@ module XClarityClient
       Faraday::Response.new
     end
 
-    def create_connection(connection, configuration)
+    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}"
@@ -108,34 +131,24 @@ module XClarityClient
       connection
     end
 
-    def create_faraday_multipart_obj(url, configuration)
-      Faraday.new(url: url) do |faraday|
-        faraday.request(: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(:net_http) # make requests with net_http
-        faraday.ssl[:verify] = configuration.verify_ssl == 'PEER'
-      end
-    end
-
-    def create_faraday_obj(url, configuration)
+    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 request 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
 
-    def build_connection(url, configuration, multipart = false)
-      con_obj = create_faraday_multipart_obj(url, configuration) if multipart
-      con_obj = create_faraday_obj(url, configuration) unless multipart
-      create_connection(con_obj, configuration)
+    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
 
-    def build(configuration, multipart = false)
+    def build(configuration, multipart = false, n_http = false)
       header = HEADER_MESSAGE + ' build'
       $lxca_log.info(header, 'Building the connection')
       hostname = URI.parse(configuration.host)
@@ -145,7 +158,7 @@ module XClarityClient
                              :query    => hostname.query,
                              :fragment => hostname.fragment).to_s
       $lxca_log.info(header, "Creating connection to #{url}")
-      build_connection(url, configuration, multipart)
+      build_connection(url, configuration, multipart, n_http)
     end
   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/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

@@ -1,6 +1,5 @@
 require 'json'
 require 'pathname'
-require 'pp'
 
 module XClarityClient
   # ManagementServerManagement class
@@ -10,7 +9,7 @@ module XClarityClient
     private
 
     def start_management_server_updates_import_job(file_type_dict, files, jobid)
-      url = "/files/#{ManagementServer::BASE_URI}?action=import&jobid=#{jobid}"
+      url = "/files#{ManagementServer::BASE_URI}?action=import&jobid=#{jobid}"
       index = 0
       payload = {}
       files.each do |file_name|
@@ -59,7 +58,7 @@ module XClarityClient
       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).to_hash['jobid']
+      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

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/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/version.rb

@@ -1,3 +1,3 @@
 module XClarityClient
-  VERSION = "0.6.6"
+  VERSION = '0.6.7'.freeze
 end

data/xclarity_client.gemspec

@@ -17,7 +17,7 @@ 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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xclarity_client
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.6.7
 platform: ruby
 authors:
 - Manasa Rao
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-07 00:00:00.000000000 Z
+date: 2019-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -17,14 +17,14 @@ dependencies:
     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