xclarity_client 0.6.3 → 0.6.8

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

@@ -34,6 +34,9 @@ require 'xclarity_client/services/scalable_complex_management'
 require 'xclarity_client/services/switch_management'
 require 'xclarity_client/services/storage_management'
 require 'xclarity_client/services/unmanage_request_management'
+require 'xclarity_client/services/manage_request_management'
 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_comp_management.rb

@@ -0,0 +1,111 @@
+require 'json'
+
+module XClarityClient
+  # update component management class
+  class UpdateCompManagement < Services::XClarityService
+    manages_endpoint UpdateComp
+
+    def updatable_device_comp
+      response = @connection.do_get(UpdateComp::BASE_URI\
+                                    + '?action=getComponents')
+      return [] unless response.success?
+      body = JSON.parse(response.body)
+      body = { UpdateComp::LIST_NAME => body } if body.kind_of?(Array)
+      j = body.key?(UpdateComp::LIST_NAME)
+      body = { UpdateComp::LIST_NAME => [body] } unless j
+      body[UpdateComp::LIST_NAME].map do |resource_params|
+        UpdateComp.new(resource_params)
+      end
+    end
+
+    def apply_firmware_update(opts, activation_mode, force_update_mode,
+                              onerror_mode)
+      validate_arguments(activation_mode, force_update_mode, onerror_mode)
+
+      uri = create_uri(activation_mode, force_update_mode, onerror_mode)
+
+      apply_req = create_req_json(opts['server'], opts['switch'],
+                                  opts['storage'], opts['cmm'])
+      response = @connection.do_put(UpdateComp::BASE_URI + '?action=apply'\
+                                    + uri, apply_req)
+      response.body
+    end
+
+    def cancel_firmware_update(server, switch, storage, cmm)
+      cancel_req = create_req_json(server, switch, storage, cmm)
+      response = @connection.do_put(UpdateComp::BASE_URI\
+                                    + '?action=cancelApply',
+                                    cancel_req)
+      response.body
+    end
+
+    def modify_power_state(server, switch, storage, cmm)
+      power_state_req = create_req_json(server, switch, storage, cmm)
+      response = @connection.do_put(UpdateComp::BASE_URI + '?action=powerState',
+                                    power_state_req)
+      response.body
+    end
+
+    def validate_activation_mode(activation_mode)
+      if !activation_mode.nil? && !activation_mode.casecmp('immediate').zero? &&
+         !activation_mode.casecmp('delayed').zero?
+
+        raise 'Invalid argument specified. Operation apply_firmware_update'\
+               + ' can have activationMode as either immediare or delayed.'
+      end
+    end
+
+    def validate_forceupdate_mode(forceupdate_mode)
+      if !forceupdate_mode.nil? && !forceupdate_mode.casecmp('true').zero? &&
+         !forceupdate_mode.casecmp('false').zero?
+
+        raise 'Invalid argument specified. Value for forceUpdateMode on'\
+              + ' operation apply_firmware_update should have a value'\
+              + ' of either true or false'
+      end
+    end
+
+    def validate_onerror_mode(onerror_mode)
+      if !onerror_mode.nil? && !onerror_mode.eql?('stopOnError') &&
+         !onerror_mode.eql?('stopdeviceOnError') &&
+         !onerror_mode.eql?('continueOnError')
+
+        raise 'Invalid argument specified. Operation apply_firmware_update'\
+              + " should have onErrorMode as : 'stopOnError' or"\
+              + " 'stopdeviceOnError' or 'continueOnError'"
+      end
+    end
+
+    def validate_arguments(activation_mode, forceupdate_mode, onerror_mode)
+      validate_activation_mode(activation_mode)
+      validate_forceupdate_mode(forceupdate_mode)
+      validate_onerror_mode(onerror_mode)
+    end
+
+    # splitted create_uri just to fix codeclimate error
+    def add_uri(force_update_mode, onerror_mode, uri)
+      fmode = force_update_mode.nil?
+      uri += '&forceUpdateMode=' + force_update_mode unless fmode
+      uri += '&onErrorMode=' + onerror_mode unless onerror_mode.nil?
+      uri
+    end
+
+    def create_uri(activation_mode, force_update_mode, onerror_mode)
+      uri = ''
+      amode = activation_mode.nil?
+      uri += '&activationMode=' + activation_mode unless amode
+      add_uri(force_update_mode, onerror_mode, uri)
+    end
+
+    def create_req_json(server, switch, storage, cmm)
+      server_json = JSON.generate(:ServerList => server)
+      switch_json = JSON.generate(:SwitchList => switch)
+      storage_json = JSON.generate(:StorageList => storage)
+      cmm_json = JSON.generate(:CMMList => cmm)
+
+      req_json = "{\"DeviceList\": [#{server_json},#{switch_json},"\
+                 + "#{storage_json},#{cmm_json}]}"
+      req_json
+    end
+  end
+end

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/services/xclarity_service.rb

@@ -85,9 +85,8 @@ module XClarityClient
       end
 
       def do_request_with_opts(uri, opts)
-        allowed_query_keys = %w(type sort)
-        query = opts.select { |key| allowed_query_keys.include?(key) }
-        headers = opts['headers'] || Hash.new(0)
+        query = opts.reject { |key| 'headers'.eql?(key) }
+        headers = opts['headers'] || {}
 
         @connection.do_get(uri, :query => query, :headers => headers)
       end

data/lib/xclarity_client/version.rb

@@ -1,3 +1,3 @@
 module XClarityClient
-  VERSION = "0.6.3"
+  VERSION = '0.6.8'.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