xclarity_client 0.6.3 → 0.6.8

data/lib/xclarity_client/mixins/mixins.rb

@@ -34,5 +34,8 @@ require 'xclarity_client/mixins/scalable_complex_mixin'
 require 'xclarity_client/mixins/storage_mixin'
 require 'xclarity_client/mixins/switch_mixin'
 require 'xclarity_client/mixins/unmanage_request_mixin'
+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_comp_mixin.rb

@@ -0,0 +1,37 @@
+module XClarityClient
+  #
+  # Exposes UpdateCompManagement features
+  #
+  module Mixins::UpdateCompMixin
+    def discover_firmware_update_status
+      UpdateCompManagement.new(@config).fetch_all
+    end
+
+    def discover_updatable_device_comp
+      UpdateCompManagement.new(@config).updatable_device_comp
+    end
+
+    def apply_firmware_update(opts, activation_mode = nil,
+                              force_update_mode = nil, onerror_mode = nil)
+      UpdateCompManagement.new(@config).apply_firmware_update(opts,
+                                                              activation_mode,
+                                                              force_update_mode,
+                                                              onerror_mode)
+    end
+
+    def cancel_firmware_update(server = nil, switch = nil, storage = nil,
+                               cmm = nil)
+      UpdateCompManagement.new(@config).cancel_firmware_update(server,
+                                                               switch,
+                                                               storage,
+                                                               cmm)
+    end
+
+    def modify_power_state(server = nil, switch = nil, storage = nil, cmm = nil)
+      UpdateCompManagement.new(@config).modify_power_state(server,
+                                                           switch,
+                                                           storage,
+                                                           cmm)
+    end
+  end
+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/manage_request_management.rb

@@ -0,0 +1,62 @@
+require 'json'
+
+module XClarityClient
+  # manage request management class
+  class ManageRequestManagement < Services::XClarityService
+    manages_endpoint ManageRequest
+
+    def manage_discovered_devices(manage_request)
+      @connection.do_post(ManageRequest::BASE_URI,
+                          JSON.generate([manage_request]))
+    end
+
+    def populate_manage_req_with_security_descriptor(manage_request, val)
+      security_descriptor = {}
+      val = val['securityDescriptor']
+      security_descriptor[:managedAuthEnabled] = val['managedAuthSupported']
+      security_descriptor[:managedAuthSupported] = val['managedAuthSupported']
+      res = security_descriptor[:managedAuthEnabled]
+      security_descriptor[:storedCredentials] = val['storedCredentials'] if res
+      manage_request[:securityDescriptor] = security_descriptor
+    end
+
+    def parse_manage_request(manage_request, val)
+      return false unless val.kind_of?(Array) && !val.empty?
+      manage_request[:managementPorts] = val[0]['managementPorts']
+      manage_request[:type] = val[0]['type']
+      manage_request[:uuid] = val[0]['uuid']
+      discovery_ip_addr = val[0]['ipAddresses'][0]
+      manage_request[:ipAddresses] = [discovery_ip_addr]
+      manage_request[:os] = val[0]['os'] if val[0]['type'] == 'Rackswitch'
+      populate_manage_req_with_security_descriptor(manage_request, val[0])
+    end
+
+    def populate_manage_request_with_discovery_res(discovery_result,
+                                                   manage_request)
+      discovery_result.map do |req|
+        req.instance_variables.each do |attr|
+          val = req.instance_variable_get(attr)
+          parse_manage_request(manage_request, val)
+        end
+      end
+    end
+
+    def update_manage_request(manage_request, force, discovery_result)
+      populate_manage_request_with_discovery_res(discovery_result,
+                                                 manage_request)
+      manage_request[:forceManage] = true if force.casecmp('true')
+    end
+
+    def fetch_manage_request(job_id)
+      response = @connection.do_get(ManageRequest::BASE_URI + '/jobs/' + job_id)
+      return [] unless response.success?
+      body = JSON.parse(response.body)
+      body = { ManageRequest::LIST_NAME => body } if body.kind_of?(Array)
+      mrql = ManageRequest::LIST_NAME
+      body = { ManageRequest::LIST_NAME => [body] } unless body.key?(mrql)
+      body[ManageRequest::LIST_NAME].map do |resource_params|
+        ManageRequest.new(resource_params)
+      end
+    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