xclarity_client 0.5.9 → 0.6.0

data/lib/xclarity_client/services/config_pattern_management.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module XClarityClient
+  class ConfigPatternManagement < Services::XClarityService
+    manages_endpoint ConfigPattern
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+
+    def export(id)
+      response = @connection.do_get(managed_resource::BASE_URI + "/" + id + "/includeSettings" )
+      return [] unless response.success?
+
+      body = JSON.parse(response.body)
+
+      body = {managed_resource::LIST_NAME => body} if body.is_a? Array
+      body = {managed_resource::LIST_NAME => [body]} unless body.has_key? managed_resource::LIST_NAME
+      body[managed_resource::LIST_NAME].map do |resource_params|
+        managed_resource.new resource_params
+      end
+    end
+
+    def deploy_config_pattern(id,endpoints,restart,etype)
+      if etype.eql? 'node'
+        deployHash = {:uuid => endpoints}
+      elsif etype.eql? 'rack' or etype.eql? 'tower'
+        deployHash = {:endpointIds => endpoints}
+      end
+      deployHash.merge!({:restart => restart})
+      response = @connection.do_post(managed_resource::BASE_URI + '/' +id, JSON.generate(deployHash))
+      response
+
+    end
+
+    def import_config_pattern(config_pattern)
+      response = @connection.do_post(managed_resource::BASE_URI, config_pattern)
+      response
+    end
+  end
+end

data/lib/xclarity_client/{config_profile_management.rb → services/config_profile_management.rb}

@@ -1,41 +1,35 @@
 require 'json'
 
 module XClarityClient
-  class ConfigProfileManagement < XClarityBase
+  class ConfigProfileManagement < Services::XClarityService
+    manages_endpoint ConfigProfile
 
-    include XClarityClient::ManagementMixin
-
-    def initialize(conf)
-      super(conf, ConfigProfile::BASE_URI)
-    end
-
-    def population()
-      get_all_resources(ConfigProfile)
+    def population(opts = {})
+      fetch_all(opts)
     end
 
     def rename_config_profile(id='', name='')
       renameReq = JSON.generate(profileName: name)
-      response = do_put(ConfigProfile::BASE_URI + '/' +id, renameReq)
+      response = @connection.do_put(managed_resource::BASE_URI + '/' +id, renameReq)
       response
     end
 
     def activate_config_profile(id='', endpoint_uuid='', restart='')
       postReq = JSON.generate(restart: restart, uuid: endpoint_uuid)
-      response = do_post(ConfigProfile::BASE_URI + '/' +id, postReq)
+      response = @connection.do_post(managed_resource::BASE_URI + '/' +id, postReq)
       response
     end
 
     def unassign_config_profile(id='', force='',powerDown='',resetImm='')
       unassignReq = JSON.generate(force: force, powerDownITE: powerDown, resetIMM: resetImm)
-      response = do_post(ConfigProfile::BASE_URI + '/unassign/' +id, unassignReq)
+      response = @connection.do_post(managed_resource::BASE_URI + '/unassign/' +id, unassignReq)
       response
     end
 
     def delete_config_profile(id='')
-      response = do_delete(ConfigProfile::BASE_URI + '/' + id)
+      response = @connection.do_delete(managed_resource::BASE_URI + '/' + id)
       response
     end
-
   end
 end
 

data/lib/xclarity_client/services/config_target_management.rb

@@ -0,0 +1,9 @@
+module XClarityClient
+  class ConfigTargetManagement < Services::XClarityService
+    manages_endpoint ConfigTarget
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end

data/lib/xclarity_client/services/discover_request_management.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module XClarityClient
+  class DiscoverRequestManagement < Services::XClarityService
+    manages_endpoint DiscoverRequest
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+
+    def discover_manageable_devices(ip_addresses)
+      post_req = JSON.generate([ipAddresses: ip_addresses])
+      response = @connection.do_post(managed_resource::BASE_URI, post_req)
+      response
+    end
+
+    def monitor_discover_request(job_id)
+      response = @connection.do_get(managed_resource::BASE_URI + "/jobs/" + job_id)
+      return [] unless response.success?
+
+      body = JSON.parse(response.body)
+
+      body = {managed_resource::LIST_NAME => body} if body.is_a? Array
+      body = {managed_resource::LIST_NAME => [body]} unless body.has_key? managed_resource::LIST_NAME
+      body[managed_resource::LIST_NAME].map do |resource_params|
+        managed_resource.new resource_params
+      end
+    end
+  end
+end

data/lib/xclarity_client/services/discovery_management.rb

@@ -0,0 +1,9 @@
+module XClarityClient
+  class DiscoveryManagement  < Services::XClarityService
+    manages_endpoint Discovery
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end

data/lib/xclarity_client/services/event_management.rb

@@ -0,0 +1,9 @@
+module XClarityClient
+  class EventManagement < Services::XClarityService
+    manages_endpoint Event
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end

data/lib/xclarity_client/services/fan_management.rb

@@ -0,0 +1,9 @@
+module XClarityClient
+  class FanManagement < Services::XClarityService
+    manages_endpoint Fan
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end

data/lib/xclarity_client/services/fan_mux_management.rb

@@ -0,0 +1,9 @@
+module XClarityClient
+  class FanMuxManagement < Services::XClarityService
+    manages_endpoint FanMux
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end

data/lib/xclarity_client/services/ffdc_management.rb

@@ -0,0 +1,9 @@
+module XClarityClient
+  class FfdcManagement  < Services::XClarityService
+    manages_endpoint Ffdc
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end

data/lib/xclarity_client/services/globalsettings_management.rb

@@ -0,0 +1,26 @@
+require 'json'
+require 'pathname'
+
+module XClarityClient
+  class GlobalSettingManagement < XClarityBase
+
+    include XClarityClient::ManagementMixin
+
+    def initialize(conf)
+      super(conf, GlobalSetting::BASE_URI)
+    end
+
+    def population
+      response = connection("#{GlobalSetting::BASE_URI}")
+      response = JSON.parse(response.body)
+    end
+
+    def set_globalsettings(opts={})
+        request_body = JSON.generate(opts)
+        if Schemas.validate_input("set_globalsettings", request_body)
+          response = do_put("#{GlobalSetting::BASE_URI}", request_body)
+          response = JSON.parse(response.body)
+        end
+    end
+  end
+end

data/lib/xclarity_client/services/hostplatform_management.rb

@@ -0,0 +1,32 @@
+require 'json'
+require 'pathname'
+
+module XClarityClient
+  class HostPlatformManagement < XClarityBase
+
+    include XClarityClient::ManagementMixin
+
+    def initialize(conf)
+        super(conf, HostPlatform::BASE_URI)
+    end
+
+    def population
+        get_all_resources(HostPlatform)
+    end
+
+    def get_osimage_deployment_status(uuid)
+        if Schemas.validate_input_parameter("uuid", uuid, String)
+          response = connection("#{HostPlatform::BASE_URI}/#{uuid}")
+          response = JSON.parse(response.body)
+        end
+    end
+
+    def deploy_osimage(opts=[])
+        request_body = JSON.generate(opts)
+        if Schemas.validate_input("deploy_osimage", request_body)
+          response = do_put("#{HostPlatform::BASE_URI}", request_body)
+          response = JSON.parse(response.body)
+        end
+    end
+  end
+end

data/lib/xclarity_client/services/job_management.rb

@@ -0,0 +1,27 @@
+require 'json'
+
+module XClarityClient
+  class JobManagement < Services::XClarityService
+    manages_endpoint Job
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+
+    def cancel_job(uuid='')
+      cancelReq = JSON.generate(cancelRequest: 'true')
+      response = @connection.do_put(managed_resource::BASE_URI + '/' + uuid, cancelReq)
+      response
+    end
+
+    def delete_job(uuid='')
+      response = @connection.do_delete(managed_resource::BASE_URI + '/' + uuid)
+      response
+    end
+
+    def get_job(job_id = "")
+      response = connection(Job::BASE_URI + '/' + job_id)
+      response = JSON.parse(response.body)
+    end
+  end
+end

data/lib/xclarity_client/services/mixins/endpoint_manager_mixin.rb

@@ -0,0 +1,30 @@
+require 'xclarity_client/endpoints/xclarity_endpoint'
+
+module XClarityClient
+  module Services
+    #
+    # An Endpoint Manager must regist what endpoint it is managing
+    # to do that, just need to call #manages_endpoint method and
+    # pass as param the class that represents the endpoint (must be
+    # a subclass of XClarityEndpoint).
+    #
+    # @see XClarityClient::Endpoints::XClarityEndpoint
+    #
+    module EndpointManagerMixin
+
+      private
+
+      #
+      # Sets which endpoint is managed by the service
+      #
+      # @param [Class] - Class that represents some endpoind
+      # @see XClarityClient::Endpoints::XClarityEndpoint
+      #
+      def manages_endpoint(endpoint_class)
+        raise ArgumentError, "The class #{endpoint_class.name} isn't a subclass of XClarityEndpoint" unless endpoint_class < Endpoints::XclarityEndpoint
+
+        define_method(:managed_resource) { endpoint_class }
+      end
+    end
+  end
+end

data/lib/xclarity_client/services/mixins/list_name_interpreter_mixin.rb

@@ -0,0 +1,61 @@
+module XClarityClient
+  module Services
+    #
+    # A list name interpreter knows how to get the correct
+    # list name present on endpoint response, and, if the list
+    # doesn't exist, add the list property to the reponse with
+    # the right name.
+    #
+    module ListNameInterpreterMixin
+      #
+      # Process the response body to make sure that its contains the list name defined on resource
+      #
+      # @return the list name present on body and the body itself
+      #
+      def add_listname_on_body(endpoint_class, body)
+        body.kind_of?(Array) ? process_body_as_array(endpoint_class, body) : process_body_as_hash(endpoint_class, body)
+      end
+
+      private
+
+      #
+      # @return any listname described on resource
+      #
+      def any_listname_of(endpoint_class)
+        if endpoint_class::LIST_NAME.kind_of?(Array)
+          endpoint_class::LIST_NAME.first # If is an array, any listname can be use
+        else
+          endpoint_class::LIST_NAME # If is not an array, just return the listname of resource
+        end
+      end
+
+      #
+      # @return the body value assigned to the list name defined on resource
+      #
+      def process_body_as_array(endpoint_class, body)
+        list_name = any_listname_of(endpoint_class)
+
+        return list_name, { list_name => body } # assign the list name to the body
+      end
+
+      #
+      # Discover what list name defined on resource is present on body
+      # If none of then is find assume that the body is a single resource
+      # and add it value into array and assing to any list name
+      #
+      # @return the list name present on body and the body itself
+      #
+      def process_body_as_hash(endpoint_class, body)
+        result = body
+
+        if endpoint_class::LIST_NAME.kind_of? Array # search which list name is present on body
+          list_name = endpoint_class::LIST_NAME.find { |name| body.keys.include?(name) && body[name].kind_of?(Array) }
+        else
+          list_name = any_listname_of(endpoint_class)
+        end
+        result = {list_name => [body]} unless body.has_key? list_name # for the cases where body represents a single resource
+        return list_name, result
+      end
+    end
+  end
+end

data/lib/xclarity_client/services/mixins/response_builder_mixin.rb

@@ -0,0 +1,38 @@
+require 'xclarity_client/services/mixins/list_name_interpreter_mixin'
+
+module XClarityClient
+  module Services
+    #
+    # A response builder knows how to treat a response from LXCA
+    # and create a ruby response
+    #
+    module ResponseBuilderMixin
+      include ListNameInterpreterMixin
+
+      #
+      # Builds an array from an LXCA response that contains
+      # a list of resources.
+      #
+      # @param response       - the LXCA response
+      # @param endpoint_class - the class that represents the endpoint that generates the response
+      #
+      # @return [Array] containing the resources of the LXCA response
+      #
+      def build_response_with_resource_list(response, endpoint_class)
+        return [] unless response.success?
+
+        body = JSON.parse(response.body)
+
+        if endpoint_class == XClarityClient::User
+          body = body['response']
+        end
+
+        list_name, body = add_listname_on_body(endpoint_class, body)
+
+        body[list_name].map do |resource_params|
+          endpoint_class.new resource_params
+        end
+      end
+    end
+  end
+end

data/lib/xclarity_client/{node_management.rb → services/node_management.rb}

@@ -4,15 +4,11 @@ require 'uuid'
 # XClarityClient module/namespace
 module XClarityClient
   # Node Management class
-  class NodeManagement < XClarityBase
-    include XClarityClient::ManagementMixin
-
-    def initialize(conf)
-      super(conf, Node::BASE_URI)
-    end
+  class NodeManagement < Services::XClarityService
+    manages_endpoint Node
 
     def population(opts = {})
-      get_all_resources(Node, opts)
+      fetch_all(opts)
     end
 
     def set_node_power_state(uuid, requested_state = nil)
@@ -23,7 +19,7 @@ module XClarityClient
         raise ArgumentError, error
       end
 
-      send_power_request(Node::BASE_URI + '/' + uuid, requested_state)
+      send_power_request(managed_resource::BASE_URI + '/' + uuid, requested_state)
     end
 
     def set_bmc_power_state(uuid, requested_state = nil)
@@ -34,7 +30,7 @@ module XClarityClient
         raise ArgumentError, error
       end
 
-      send_power_request(Node::BASE_URI + '/' + uuid + '/bmc', requested_state)
+      send_power_request(managed_resource::BASE_URI + '/' + uuid + '/bmc', requested_state)
     end
 
     def set_loc_led_state(uuid, state, name = 'Identify')
@@ -42,14 +38,14 @@ module XClarityClient
 
       $lxca_log.info "XclarityClient::ManagementMixin set_loc_led_state", "Loc led state action has been sent"
 
-      do_put("#{Node::BASE_URI}/#{uuid}", request)
+      @connection.do_put("#{managed_resource::BASE_URI}/#{uuid}", request)
     end
 
     private
 
     def send_power_request(uri, requested_state = nil)
       power_request = JSON.generate(powerState: requested_state)
-      response = do_put(uri, power_request)
+      response = @connection.do_put(uri, power_request)
       msg = "Power state action has been sent with request #{power_request}"
 
       $lxca_log.info 'XclarityClient::NodeManagement set_node_power_state', msg

data/lib/xclarity_client/services/osimage_management.rb

@@ -0,0 +1,47 @@
+require 'json'
+require 'pathname'
+
+module XClarityClient
+  class OsImageManagement < XClarityBase
+
+    include XClarityClient::ManagementMixin
+
+    def initialize(conf)
+      super(conf, OsImage::BASE_URI)
+    end
+
+    def population
+      get_all_resources(OsImage)
+    end
+
+    def import_osimage(serverId, path)
+        if not Schemas.validate_input_parameter("serverId", serverId, String)
+           return
+        end
+
+        if not Schemas.validate_input_parameter("path", path, String)
+           return
+        end
+ 
+        msg="inputs serverId=#{serverId},path=#{path}"
+        $lxca_log.info self.class.to_s+" "+__method__.to_s, msg
+        opts = { "Action": "Init" }
+        request_body = JSON.generate(opts)
+        response = do_post("#{OsImage::BASE_URI}?imageType=OS", request_body)
+        response = JSON.load(response.body).to_hash
+        jobId = response["jobId"]
+        puts jobId
+        opts = { "serverId": serverId, "path": path }
+        request_body = JSON.generate(opts)
+        imageName = path.split(File::SEPARATOR).last
+        begin
+           response = do_post("#{OsImage::BASE_URI}/?jobId=#{jobId}"\
+                              "&imageType=OS&imageName=#{imageName}", request_body)
+           response = JSON.parse(response.body)
+        rescue Faraday::TimeoutError => e
+           result = JSON.generate({"result": " Job for importing image is in progress with jobId #{jobId}"})
+           response = JSON.parse(result) 
+        end
+    end
+  end
+end

data/lib/xclarity_client/services/persisted_result_management.rb

@@ -0,0 +1,11 @@
+require 'json'
+
+module XClarityClient
+  class PersistedResultManagement < Services::XClarityService
+    manages_endpoint PersistedResult
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end

data/lib/xclarity_client/services/power_supply_management.rb

@@ -0,0 +1,9 @@
+module XClarityClient
+  class PowerSupplyManagement< Services::XClarityService
+    manages_endpoint PowerSupply
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end

data/lib/xclarity_client/services/remote_access_management.rb

@@ -0,0 +1,57 @@
+require 'json'
+
+module XClarityClient
+  class RemoteAccessManagement < XClarityBase
+
+    def initialize(conf)
+      super(conf, RemoteAccess::BASE_URI)
+    end
+
+    def remote_control(uuid)
+      raise 'UUID must not be blank' if uuid.nil? || uuid.empty?
+      con = connection("#{RemoteAccess::BASE_URI}/remoteControl" , {:uuid => uuid})
+
+      unless con.success?
+        $lxca_log.error "XClarityClient::RemoteAccessManagement remote_control", "Request failed"
+        raise 'Request failed'
+      end
+
+      build_remote_access_object(con)
+    end
+
+    private
+
+    SUPPORTED_MIME_TYPES = ['application/*json', 'application/x-java-jnlp-file']
+
+    def build_remote_access_object(connection)
+      content_type = connection.headers['Content-Type']
+      case content_type
+      when /application\/.*json/
+        build_json_remote_access_object(connection.body)
+      when /application\/x-java-jnlp-file/
+        build_jnlp_remote_access_object(connection.body)
+      else
+        $lxca_log.error(
+          "XClarityClient::RemoteAccessManagement build_remote_access_object",
+          "Unexpected server response. Expected Content-Type header to be one of these: #{SUPPORTED_MIME_TYPES}."
+        )
+        raise 'Unexpected Content-Type header'
+      end
+    end
+
+    def build_json_remote_access_object(resp_body)
+      parsed_response = JSON.parse(resp_body)
+      RemoteAccess.new({
+        :type => :url,
+        :resource => parsed_response['url']
+      })
+    end
+
+    def build_jnlp_remote_access_object(resp_body)
+      RemoteAccess.new({
+        :type => :java_jnlp_file,
+        :resource => resp_body
+      })
+    end
+  end
+end

data/lib/xclarity_client/services/remotefileserver_management.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module XClarityClient
+  class RemoteFileServerManagement < XClarityBase
+
+    include XClarityClient::ManagementMixin
+
+    def initialize(conf)
+      super(conf, RemoteFileServer::BASE_URI)
+    end
+
+    def population
+      get_all_resources(RemoteFileServer)
+    end
+
+    def create_remotefileserver_profile(opts) 
+      request_body = JSON.generate(opts)
+      if Schemas.validate_input("create_remotefileserver_profile", request_body)
+        response = do_post(RemoteFileServer::BASE_URI, request_body)
+        msg = "remote file server profile created #{response.body}"
+        $lxca_log.info self.class.to_s+" "+__method__.to_s, msg
+        response = JSON.parse(response.body)
+      end
+    end
+
+    def delete_remotefileserver_profile(serverId)
+      if not Schemas.validate_input_parameter("serverId", serverId, String)
+         return
+      end
+      response = do_delete("#{RemoteFileServer::BASE_URI}/#{serverId}")
+      response = JSON.parse(response.body)
+    end
+
+    def get_remotefileserver_profile(serverId)
+      if Schemas.validate_input_parameter("serverId", serverId, String)
+        response = connection("#{RemoteFileServer::BASE_URI}/#{serverId}")
+        response = JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/xclarity_client/services/scalable_complex_management.rb

@@ -0,0 +1,9 @@
+module XClarityClient
+  class ScalableComplexManagement< Services::XClarityService
+    manages_endpoint ScalableComplex
+
+    def population(opts = {})
+      fetch_all(opts)
+    end
+  end
+end