redhat_access_lib 1.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28ee4071dfdcde44888e21d564c2671f9f7bdbdb
+  data.tar.gz: 69c2bb2e6c5edd63b7fb74ce6a6cf0ed83e8acb7
+SHA512:
+  metadata.gz: f0c37cd7508267505894f68fad37445640b95ba8e0d1d4882a953d849255a02135aad1d236c50c1f6adf32ca2ca3d0eb3310e7d85bfa500365c51996afb2c745
+  data.tar.gz: 22ab3cc62253c9645e5133787b47f7a2d41762c17232fadeb08abc9cafe80a2676f7d0727d1334def3aa1abf93ee378596e5a3a41bcfafaf0c27e34599b76565

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/**/*_spec.rb']
+end

data/lib/api/api.rb

@@ -0,0 +1,43 @@
+require_relative '../brokers/broker'
+require_relative '../brokers/article'
+require_relative '../brokers/case'
+require_relative '../brokers/solution'
+require_relative '../brokers/symptom'
+require_relative '../brokers/problem'
+require_relative '../brokers/attachment'
+require_relative '../brokers/product'
+require_relative '../brokers/entitlement'
+require_relative '../brokers/comment'
+require_relative '../brokers/group'
+
+require_relative '../network/http_connection'
+
+module RedHatSupportLib
+  module Api
+    class API
+      attr_reader :article_broker, :case_broker, :solution_broker
+      attr_reader :symptom_broker, :problem_broker, :attachment_broker
+      attr_reader :product_broker, :group_broker, :entitlement_broker, :comment_broker
+
+      def initialize(network_config, attachments_config)
+        @connection = Network::HttpConnection.new(network_config)
+        @article_broker = Brokers::Article.new(@connection)
+        @case_broker = Brokers::Case.new(@connection)
+        @solution_broker = Brokers::Solution.new(@connection)
+        @symptom_broker = Brokers::Symptom.new(@connection)
+        @problem_broker = Brokers::Problem.new(@connection)
+        @comment_broker = Brokers::Comment.new(@connection)
+        @attachment_broker = Brokers::Attachment.new(@connection, @comment_broker, attachments_config)
+        @product_broker = Brokers::Product.new(@connection)
+        @group_broker = Brokers::Group.new(@connection)
+        @entitlement_broker = Brokers::Entitlement.new(@connection)
+
+      end
+
+      def self.log_location(path)
+
+      end
+    end
+
+  end
+end

data/lib/api/telemetry_api.rb

@@ -0,0 +1,230 @@
+require_relative '../network/http_request'
+
+module RedHatSupportLib::TelemetryApi
+
+  SUBSET_LIST_TYPE_KEY = :subset_list_type
+  SUBSET_LIST_TYPE_MACHINE_ID = :machine_ids
+  SUBSET_LIST_TYPE_LEAF_ID = :leaf_ids
+  SUBSET_ROUTE_REGEX = [/^(v[0-9]|latest)\/systems\/status$/,
+                        /^systems\/status$/,
+                        /^(v[0-9]|latest)\/systems$/,
+                        /^systems$/,
+                        /^(v[0-9]|latest)\/rules$/,
+                        /^rules$/,
+                        /^(v[0-9]|latest)\/reports$/,
+                        /^reports$/,
+                        /^(v[0-9]|latest)\/messaging\/data\/weeklyinfo$/].freeze
+
+
+  class Client
+    RestClient.log =Object.new.tap do |proxy|
+      def proxy.<<(message)
+        Rails.logger.debug message
+      end
+    end
+
+    #
+    #  Creates and returns the subset route corresponding to 'path' if 'path' is a subset resource, otherwise
+    #  returns 'nil'
+    #
+    def create_subset_route(path)
+      SUBSET_ROUTE_REGEX.each do |regex|
+        if regex.match(path)
+          subset_id = get_hash(get_machines)
+          path.gsub(regex) do |s|
+            api_version = Regexp.last_match[1]
+            if api_version
+              path = s.sub(api_version, "#{api_version}/subsets/#{subset_id}")
+            else
+              path = "subsets/#{subset_id}/#{s}"
+            end
+          end
+          return path
+        end
+      end
+      nil
+    end
+
+
+    def initialize(upload_url,
+                   api_url,
+                   creds,
+                   optional)
+
+      @creds = creds
+      @upload_url = upload_url
+      @api_url = api_url
+      @subset_url = "#{@api_url}/subsets"
+      @subset_list_type = SUBSET_LIST_TYPE_LEAF_ID
+
+      if optional
+        @logger = optional[:logger]
+        @http_proxy = optional[:http_proxy] if optional[:http_proxy]
+        @user_agent = optional[:user_agent] if optional[:user_agent]
+        @http_headers = optional[:headers] if optional[:headers]
+        @subset_list_type = optional[SUBSET_LIST_TYPE_KEY] if optional[SUBSET_LIST_TYPE_KEY]
+      end
+      ldebug ("HTTP proxy is set to #{@http_proxy}")
+    end
+
+    def post_upload(original_params,
+                    original_payload)
+
+      call_tapi('POST',
+                '/',
+                original_params,
+                original_payload,
+                do_upload: true)
+    end
+
+    def call_tapi_no_subset(original_method,
+                            resource,
+                            original_params,
+                            original_payload,
+                            extra)
+
+      ldebug ('Called no subset proxy')
+      call_tapi(original_method, resource, original_params, original_payload, extra, false)
+    end
+
+    def call_tapi(original_method,
+                  resource,
+                  original_params,
+                  original_payload,
+                  extra, use_subsets = true)
+
+      if (use_subsets && subset_resource = create_subset_route(resource))
+        ldebug "Doing subset call to #{subset_resource} (was : #{resource})"
+        response = do_subset_call("#{@api_url}/#{subset_resource}", params: original_params, method: original_method, payload: original_payload)
+        return {data: response, code: response.code}
+      else
+        if extra && extra[:do_upload]
+          url = @upload_url
+        else
+          url = "#{@api_url}/#{resource}"
+        end
+        client = default_rest_client(url, params: original_params, method: original_method, payload: original_payload)
+        response = client.execute
+        return {data: response, code: response.code}
+      end
+    rescue RestClient::ExceptionWithResponse => e
+      lerror nil, "Caught HTTP error when proxying call to tapi: #{e}"
+      return {data: e.response, error: e, code: e.response.code}
+    rescue Exception => e
+      lerror e, "Caught unexpected error when proxying call to tapi: #{e}"
+      return {data: e, error: e, code: 500}
+    end
+
+    def call_strata(original_method,
+                    resource,
+                    original_params,
+                    original_payload,
+                    _extra)
+
+      url = "#{@api_url}/#{resource}"
+      client = default_rest_client(url, params: original_params, method: original_method, payload: original_payload)
+      response = client.execute
+      return {data: response, code: response.code}
+    rescue RestClient::ExceptionWithResponse => e
+      lerror nil, "Caught HTTP error when proxying call to tapi: #{e}"
+      return {data: e.response, error: e, code: e.response.code}
+    rescue Exception => e
+      lerror e, "Caught unexpected error when proxying call to tapi: #{e}"
+      return {data: e, error: e, code: 500}
+    end
+
+    def get_machines
+      throw NotImplementedError
+    end
+
+    def get_branch_id
+      throw NotImplementedError
+    end
+
+    # Returns the machines hash used for /subset/$hash/
+    def get_hash(machines)
+      branch = get_branch_id
+      hash = Digest::SHA1.hexdigest(machines.join)
+      "#{branch}__#{hash}"
+    end
+
+    private
+
+    def ldebug(message)
+      @logger.debug "#{self.class.name}: #{message}" if @logger
+    end
+
+    def lerror(e, message)
+      if @logger
+        @logger.error ("#{self.class.name}: #{message}")
+        @logger.error (e.backtrace.join("\n")) if e
+      end
+    end
+
+    def do_subset_call(resource,
+                       conf)
+      ldebug 'Doing subset call'
+      # Try subset
+      begin
+        ldebug "url: #{resource}"
+        client = default_rest_client resource, conf
+        response = client.execute
+        ldebug 'First subset call passed, CACHE_HIT'
+        ldebug(response.headers)
+        return response
+      rescue RestClient::ExceptionWithResponse => e
+
+        if e.response && e.response.code == 412
+          create_subset
+
+          # retry the original request
+          ldebug 'Subset creation passed calling newly created subset'
+          response = client.execute
+          return response
+        else
+          raise e
+        end
+      end
+    end
+
+
+    def create_subset
+      ldebug 'First subset call failed, CACHE_MISS'
+      subset_client = default_rest_client(@subset_url,
+                                          method: :post,
+                                          payload: {
+                                              hash: get_hash(get_machines),
+                                              branch_id: get_branch_id,
+                                              @subset_list_type => get_machines
+                                          }.to_json)
+      subset_client.execute
+    end
+
+
+    def default_rest_client(url, override_options)
+      opts = {
+          method: :get,
+          url: url
+      }
+      opts[:proxy] = @http_proxy unless @http_proxy.nil? || @http_proxy == ''
+      opts = opts.merge(get_auth_opts(@creds))
+      opts = opts.merge(override_options)
+      opts[:headers] = @http_headers if @http_headers
+      if override_options[:params]
+        opts[:url] = "#{url}?#{override_options[:params].to_query}"
+        override_options.delete(:params)
+      end
+      opts[:headers] = {} unless opts[:headers]
+      if opts[:headers]['content-type'].nil?
+        opts[:headers] = opts[:headers].merge('content-type' => 'application/json')
+      end
+      if opts[:headers]['accept'].nil?
+        opts[:headers] = opts[:headers].merge('accept' => 'application/json')
+      end
+      if @user_agent
+        opts[:headers] = opts[:headers].merge(user_agent: @user_agent)
+      end
+      RedHatSupportLib::Network::HttpRequest.new(opts)
+    end
+  end
+end

data/lib/brokers/article.rb

@@ -0,0 +1,24 @@
+require 'open-uri'
+module RedHatSupportLib
+  module Brokers
+    class Article < Broker
+      def initialize(connection)
+        super
+      end
+
+      def search(text, limit=10)
+        #TODO encode input and error handling
+        text = URI::encode(text)
+        result = @connection.get("/rs/articles?keyword=#{text}&limit=#{limit}", {:accept => :json})
+        result['article']
+      end
+
+      def get_article(id)
+        #TODO encode input and error handling
+        result = @connection.get("/rs/articles/#{id}", {:accept => :json})
+        #result.parsed_response
+      end
+
+    end
+  end
+end

data/lib/brokers/attachment.rb

@@ -0,0 +1,81 @@
+require 'pathname'
+require_relative '../network/ftp_connection'
+
+module RedHatSupportLib
+  module Brokers
+    class Attachment < Broker
+
+      def initialize(connection, comments_broker, attachments_config)
+        super(connection)
+        @comments_broker = comments_broker
+        @attachments_config = attachments_config
+      end
+
+      def list(case_number, start_date, end_date, filter=[])
+
+        uri = "/rs/cases/#{case_number}/attachments"
+        param = ''
+        if start_date
+          param = "?startDate=#{start_date}"
+        end
+        if end_date
+          if start_date
+            param = param + "&endDate=#{end_date}"
+          else
+            param = param + "?endDate=#{end_date}"
+          end
+        end
+        result = @connection.get(uri+param, {:accept => :json})
+      end
+
+
+      def get(case_number, attachment_uuid, file_name, dest_dir)
+        #TODO
+
+      end
+
+      def delete(case_number, attachment_uuid)
+
+        uri = "/rs/cases/#{case_number}/attachments/#{attachment_uuid}";
+        result = @connection.delete(uri)
+      end
+
+      def add(case_number, is_public, file_name, description)
+        #puts "Sending attachment for case "+ case_number
+        attachment_id = nil
+        File.open(file_name) do |file|
+          if file.size < @attachments_config[:max_http_size]
+            headers = {:description => description}
+            @connection.upload("/rs/cases/#{case_number}/attachments",
+                               file, headers) do |code, headers|
+              if code == 201
+                location = headers[:location]
+                attachment_id = get_id(location)
+              else
+                #What to return here?
+                raise "Attachment failed " + code
+              end
+            end
+          else
+            ftp_connection = RedHatSupportLib::Network::FtpConnection.new(@attachments_config[:ftp_host])
+            ftp_connection.upload(file_name,
+                                  @attachments_config[:ftp_remote_dir])
+            comment = StringIO.new
+            comment << "The file #{file_name} exceeds the byte limit to attach a file to a case;"
+            comment << " Therefore, the file was uploaded to"
+            comment << " #{@attachments_config[:ftp_host]} as #{File.basename(file_name)}"
+            @comments_broker.add(comment.string, case_number, false, is_public)
+            #TODO what to return here?
+          end
+        end
+        attachment_id
+      end
+
+      def get_id(uri)
+        parts = uri.split("/")
+        parts.pop
+      end
+
+    end
+  end
+end

data/lib/brokers/broker.rb

@@ -0,0 +1,16 @@
+module RedHatSupportLib
+  module Brokers
+    class Broker
+      attr_accessor :connection
+
+      def initialize (connection)
+        @connection = connection
+      end
+
+      def get_id(uri)
+        parts = uri.split("/")
+        parts.pop
+      end
+    end
+  end
+end

data/lib/brokers/case.rb

@@ -0,0 +1,145 @@
+module RedHatSupportLib
+  module Brokers
+    class Case < Broker
+      def initialize(connection)
+        super
+      end
+
+      def list(keywords, include_closed, detail, group, start_date, end_date,
+               count, start, kwargs)
+        headers = {:content_type => 'application/xml', :accept => :json}
+        param =""
+        if detail
+          param = "?detail=true"
+        end
+        filter = self.create_filter(keywords, include_closed,
+                                    group, start_date,
+                                    end_date, count, start,
+                                    @connection.config.username)
+        result = @connection.post("/rs/cases/filter#{param}", filter, headers)
+
+      end
+
+      def list_severities
+        result = @connection.get("/rs/values/case/severity", {:accept => :json})
+        list = result["value"].map do |item|
+          item["name"]
+        end
+      end
+
+      def list_case_types
+        result = @connection.get("/rs/values/case/types", {:accept => :json})
+        list = result["value"].map do |item|
+          item["name"]
+        end
+      end
+
+
+      def get(id)
+        result = @connection.get("/rs/cases/#{id}", {:accept => :json})
+      end
+
+      def create(product, version, summary, description, severity, folder_number=nil)
+
+        headers = {:content_type => 'application/xml'}
+        data = StringIO.new
+        data << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+        data << "<tns:case xmlns:tns=\"http://www.redhat.com/gss/strata\"> "
+        data << "<tns:summary>#{summary}</tns:summary>"
+        data << "<tns:description>#{description}</tns:description>"
+        data << "<tns:product>#{product}</tns:product>"
+        data << "<tns:version>#{version}</tns:version>"
+        data << "<tns:severity>#{severity}</tns:severity>"
+        if folder_number
+          data << "<tns:folderNumber>#{folder_number}</tns:folderNumber>"
+        end
+        data << "</tns:case>"
+        result = @connection.post("/rs/cases", data.string, headers) do |code, headers|
+          if code == 201
+            return get_id(headers[:location])
+          end
+        end
+      end
+
+      def update(case_number, product, version, alternate_id, status, severity, type)
+        headers = {:content_type => 'application/xml'}
+        data = create_update_data(product, version, alternate_id, status, severity, type)
+        result = @connection.put("/rs/cases/#{case_number}", data, headers) do |code, headers|
+          if code == 202
+            return get case_number
+          end
+        end
+      end
+
+      def create_update_data(product, version, alternate_id, status, severity, type)
+        #for now use xml version
+        data = StringIO.new
+        data << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+        if alternate_id
+          data << "<case  xmlns=\"http://www.redhat.com/gss/strata\" alternateId=\"#{alternate_id}\">"
+        else
+          data << "<case  xmlns=\"http://www.redhat.com/gss/strata\">"
+        end
+        if product
+          data << "<product>#{product}</product>"
+        end
+        if version
+          data << "<version>#{version}</version>"
+        end
+        if status
+          data << "<status>#{status}</status>"
+        end
+        if severity
+          data << "<severity>#{severity}</severity>"
+        end
+        if type
+          data << "<type>#{type}</type>"
+        end
+        data << "</case>"
+        return data.string
+      end
+
+      def create_filter(keywords, include_closed, group, start_date, end_date,
+                        count, start, owner_sso_name)
+        #for now use xml version
+        filter = StringIO.new
+        filter << '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        filter << '<caseFilter xmlns="http://www.redhat.com/gss/strata">'
+        if keywords
+          keywords.each do |keyword|
+            filter << "<keyword>#{keyword}</keyword>"
+          end
+        end
+        if include_closed
+          filter << "<includeClosed>true</includeClosed>"
+        end
+        if group.nil?
+          filter << "<onlyUngrouped>false</onlyUngrouped>"
+        else
+          filter << "<groupNumber>#{group}</groupNumber>"
+        end
+        if start_date
+          filter << "<startDate>#{start_date}</startDate>"
+        end
+        if end_date
+          filter << "<endDate>#{end_date}</endDate>"
+        end
+        if count
+          filter << "<count>#{count}</count>"
+        end
+        if start
+          filter << "<start>#{start}</start>"
+        end
+        filter << "<ownerSSOName>#{owner_sso_name}</ownerSSOName>"
+        filter << "</caseFilter>"
+        filter.string
+      end
+
+
+    end
+    # class CaseFilter
+    #   attr_accessor :keywords, :include_closed, :detail,
+    #     :group, :start_date, :end_date, :count, :start, :kwargs
+    # end
+  end
+end