redhat_access_lib 1.0.6

data/lib/brokers/comment.rb

@@ -0,0 +1,69 @@
+module RedHatSupportLib
+  module Brokers
+    class Comment < Broker
+      def initialize(connection)
+        super
+      end
+
+      def get(case_number, comment_id)
+        #TODO check params
+        params =[];
+        result = @connection.get("/rs/cases/#{case_number}/comments/#{comment_id}",
+                                 {:accept => :json})
+      end
+
+      def list(case_number, start_date, end_date, filter=[])
+
+        uri = "/rs/cases/#{case_number}/comments"
+        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 add(text, case_number, is_draft, is_public=true)
+        headers = {:content_type => 'application/xml'}
+        data = create_comment(text, case_number, is_draft, is_public)
+        result = @connection.post("/rs/cases/#{case_number}/comments", data, headers) do |code, headers|
+          if code == 201
+            location = headers[:location]
+            return get_id(location)
+          end
+        end
+      end
+
+      def create_comment(comment, case_number, is_draft, is_public=true)
+        #for now use xml version
+        filter = StringIO.new
+        filter << '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        filter << '<tns:comment xmlns:tns="http://www.redhat.com/gss/strata"' << " caseNumber=\"#{case_number}\">"
+        filter << "<tns:text>#{comment}</tns:text>"
+        if is_public
+          filter << "<tns:public>true</tns:public>"
+        else
+          filter << "<tns:public>false</tns:public>"
+        end
+        if is_draft
+          filter << "<tns:draft>true</tns:draft>"
+        else
+          filter << "<tns:draft>false</tns:draft>"
+        end
+        filter << "</tns:comment>"
+        filter.string
+      end
+
+      def get_id(uri)
+        parts = uri.split("/")
+        parts.pop
+      end
+    end
+  end
+end

data/lib/brokers/entitlement.rb

@@ -0,0 +1,15 @@
+module RedHatSupportLib
+  module Brokers
+    class Entitlement < Broker
+      def initialize(connection)
+        super
+      end
+
+      def list
+        result = @connection.get("/rs/entitlements", {:accept => :json})
+        result['entitlement']
+      end
+
+    end
+  end
+end

data/lib/brokers/group.rb

@@ -0,0 +1,15 @@
+module RedHatSupportLib
+  module Brokers
+    class Group < Broker
+      def initialize(connection)
+        super
+      end
+
+      def list
+        result = @connection.get("/rs/groups", {:accept => :json})
+        result['group']
+      end
+
+    end
+  end
+end

data/lib/brokers/problem.rb

@@ -0,0 +1,51 @@
+module RedHatSupportLib
+  module Brokers
+    class Problem < Broker
+      def initialize(connection)
+        super
+      end
+
+      def diagnose_string(input)
+        #rs/problems
+        #TODO encode input and error handling
+        #payload = input
+        #headers = {"Content-Type" => "application/json",'Accept' => 'application/vnd.redhat.json.suggestions'}
+        headers = {:content_type => 'text/plain', :accept => :json}
+        result = @connection.post("/rs/problems", input, headers)
+        response = result['source_or_link_or_problem'][2]['source_or_link']
+        if response
+          response.each do |resp|
+            id = {:solution_id => get_solution_id(resp)}
+            resp.merge! id
+          end
+        end
+      end
+
+
+      def diagnose_file(file_path)
+
+        File.open(file_path) do |file|
+          headers = {:content_type => 'application/octet-stream', :accept => :json}
+          result = @connection.post("/rs/problems", file, headers)
+          response = result['source_or_link_or_problem'][2]['source_or_link']
+          if response
+            response.each do |resp|
+              id = {:solution_id => get_solution_id(resp)}
+              resp.merge! id
+            end
+          end
+        end
+
+      end
+
+
+      private
+      def get_solution_id(problem)
+        uri = problem["uri"]
+        parts = uri.split("/")
+        parts.pop
+      end
+
+    end
+  end
+end

data/lib/brokers/product.rb

@@ -0,0 +1,15 @@
+module RedHatSupportLib
+  module Brokers
+    class Product < Broker
+      def initialize(connection)
+        super
+      end
+
+      def list
+        result = @connection.get("/rs/products", {:accept => :json})
+        result['product']
+      end
+
+    end
+  end
+end

data/lib/brokers/solution.rb

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

data/lib/brokers/symptom.rb

@@ -0,0 +1,19 @@
+module RedHatSupportLib
+  module Brokers
+    class Symptom < Broker
+      def initialize(connection)
+        super
+      end
+
+      def diagnose_file(file_path)
+
+        File.open(file_path) do |file|
+          headers = {:content_type => 'text/plain', :accept => :json}
+          result = @connection.post("/rs/symptoms/extractor", file, headers)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/network/ftp_connection.rb

@@ -0,0 +1,19 @@
+require 'net/ftp'
+module RedHatSupportLib
+  module Network
+    class FtpConnection
+      def initialize(host)
+        @host = host
+      end
+
+      def upload(file_name, remote_directory)
+        Net::FTP.open(@host) do |ftp|
+          ftp.login
+          files = ftp.chdir(remote_directory)
+          ftp.putbinaryfile(file_name)
+        end
+      end
+
+    end
+  end
+end

data/lib/network/http_connection.rb

@@ -0,0 +1,109 @@
+require 'rest_client'
+require 'json'
+require "base64"
+require_relative './http_request'
+require_relative './http_resource'
+
+
+module RedHatSupportLib
+  module Network
+    class HttpConnection
+      USER_AGENT = "ruby-rest-client"
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+        user_agent = USER_AGENT
+        unless config.user_agent.nil?
+          user_agent = config.user_agent
+        end
+        @additional_headers = {:user_agent => user_agent}
+        #unless config.proxy_host.nil? || config.proxy_host.strip.empty?
+        #  RestClient.proxy = "http://#{config.proxy_user}:#{config.proxy_password}@#{config.proxy_host}:#{config.proxy_port}"
+        #end
+        unless config.log_location.nil?
+          RestClient.log = config.log_location
+        end
+      end
+
+      def get(relative_uri, headers={}, &block)
+
+        hdr = @additional_headers.merge!(headers)
+        result = get_resource(relative_uri).get hdr
+        parse_response(result.body, headers[:accept])
+
+      end
+
+      def post(relative_uri, data, headers={}, &block)
+
+        hdr = @additional_headers.merge!(headers)
+        result = get_resource(relative_uri).post data, hdr
+        if block
+          yield result.code, result.headers
+        end
+        parse_response(result.body, headers[:accept])
+      end
+
+      def put(relative_uri, data, headers={}, &block)
+
+        hdr = @additional_headers.merge!(headers)
+        result = get_resource(relative_uri).put data, hdr
+        if block
+          yield result.code, result.headers
+        end
+        parse_response(result.body, headers[:accept])
+      end
+
+      def delete(relative_uri, headers={}, &block)
+
+        hdr = @additional_headers.merge!(headers)
+        result = get_resource(relative_uri).delete hdr
+        if block
+          yield result.code, result.headers
+        end
+      end
+
+      #upload a file as multipart
+      def upload(relative_uri, file, headers={}, &block)
+        request = RedHatSupportLib::Network::HttpRequest.new(
+            :headers => headers,
+            :method => :post,
+            :url => "#{@config.base_uri}#{relative_uri}",
+            :user => @config.username,
+            :password => @config.password,
+            :payload => {
+                :multipart => true,
+                :file => file
+            },
+            :proxy => config.proxy
+        )
+
+        result = request.execute
+        if block
+          yield result.code, result.headers
+        end
+      end
+
+      private
+      def get_resource(relative_uri)
+        resource = RedHatSupportLib::Network::HttpResource.new("#{@config.base_uri}#{relative_uri}",
+                                                               {:user => @config.username,
+                                                                :password => @config.password,
+                                                                :proxy => config.proxy})
+      end
+
+      def parse_response(body, format)
+        return nil if body.nil? || body.strip.empty? || body == "null"
+        if (format == :json)
+          return JSON.parse(body)
+        end
+        body # for now do nothing for other formats
+      end
+    end
+
+    class Config
+      attr_accessor :username, :password, :base_uri, :user_agent,
+                    :proxy, :log_location
+    end
+  end
+end

data/lib/network/http_request.rb

@@ -0,0 +1,55 @@
+require 'rest_client'
+
+module RedHatSupportLib
+  module Network
+    #
+    # This HACK class allows us to set proxy on per connection basis
+    # when using RestClient libraries 1.6.x and below
+    # THINGS MAY BREAK when we upgrade RestClient.....
+    #
+    class HttpRequest < RestClient::Request
+
+      def initialize (args={})
+        if args[:proxy]
+          @proxy = args[:proxy]
+        end
+        super(args)
+      end
+
+      def self.execute(args, & block)
+        new(args).execute(& block)
+      end
+
+      # The proxy URI for this request. If `:proxy` was provided on this request,
+      # use it over `RestClient.proxy`.
+      #
+      # @return [URI, nil]
+      #
+      def proxy_uri
+        if defined?(@proxy)
+          if @proxy
+            URI.parse(@proxy)
+          else
+            nil
+          end
+        elsif RestClient.proxy
+          URI.parse(RestClient.proxy)
+        else
+          nil
+        end
+      end
+
+      def net_http_class
+        p = proxy_uri
+        if p
+          host = URI.decode(p.hostname) if p.hostname
+          user = URI.decode(p.user) if p.user
+          password = URI.decode(p.password) if p.password
+          Net::HTTP::Proxy(host,p.port, user, password)
+        else
+          Net::HTTP
+        end
+      end
+    end
+  end
+end

data/lib/network/http_resource.rb

@@ -0,0 +1,175 @@
+require_relative './http_request'
+
+module RedHatSupportLib
+  module Network
+    # A class that can be instantiated for access to a RESTful resource,
+    # including authentication.
+    #
+    # Example:
+    #
+    #   resource = RestClient::Resource.new('http://some/resource')
+    #   jpg = resource.get(:accept => 'image/jpg')
+    #
+    # With HTTP basic authentication:
+    #
+    #   resource = RestClient::Resource.new('http://protected/resource', :user => 'user', :password => 'password')
+    #   resource.delete
+    #
+    # With a timeout (seconds):
+    #
+    #   RestClient::Resource.new('http://slow', :timeout => 10)
+    #
+    # With an open timeout (seconds):
+    #
+    #   RestClient::Resource.new('http://behindfirewall', :open_timeout => 10)
+    #
+    # You can also use resources to share common headers. For headers keys,
+    # symbols are converted to strings. Example:
+    #
+    #   resource = RestClient::Resource.new('http://some/resource', :headers => { :client_version => 1 })
+    #
+    # This header will be transported as X-Client-Version (notice the X prefix,
+    # capitalization and hyphens)
+    #
+    # Use the [] syntax to allocate subresources:
+    #
+    #   site = RestClient::Resource.new('http://example.com', :user => 'adam', :password => 'mypasswd')
+    #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+    #
+    class HttpResource
+      attr_reader :url, :options, :block
+
+      def initialize(url, options={}, backwards_compatibility=nil, &block)
+        @url = url
+        @block = block
+        if options.class == Hash
+          @options = options
+        else # compatibility with previous versions
+          @options = {:user => options, :password => backwards_compatibility}
+        end
+      end
+
+      def get(additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        HttpRequest.execute(options.merge(
+            :method => :get,
+            :url => url,
+            :headers => headers), &(block || @block))
+      end
+
+      def head(additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        HttpRequest.execute(options.merge(
+            :method => :head,
+            :url => url,
+            :headers => headers), &(block || @block))
+      end
+
+      def post(payload, additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        HttpRequest.execute(options.merge(
+            :method => :post,
+            :url => url,
+            :payload => payload,
+            :headers => headers), &(block || @block))
+      end
+
+      def put(payload, additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        HttpRequest.execute(options.merge(
+            :method => :put,
+            :url => url,
+            :payload => payload,
+            :headers => headers), &(block || @block))
+      end
+
+      def patch(payload, additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        HttpRequest.execute(options.merge(
+            :method => :patch,
+            :url => url,
+            :payload => payload,
+            :headers => headers), &(block || @block))
+      end
+
+      def delete(additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        HttpRequest.execute(options.merge(
+            :method => :delete,
+            :url => url,
+            :headers => headers), &(block || @block))
+      end
+
+      def to_s
+        url
+      end
+
+      def user
+        options[:user]
+      end
+
+      def password
+        options[:password]
+      end
+
+      def headers
+        options[:headers] || {}
+      end
+
+      def timeout
+        options[:timeout]
+      end
+
+      def open_timeout
+        options[:open_timeout]
+      end
+
+      # Construct a subresource, preserving authentication.
+      #
+      # Example:
+      #
+      #   site = RestClient::Resource.new('http://example.com', 'adam', 'mypasswd')
+      #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+      #
+      # This is especially useful if you wish to define your site in one place and
+      # call it in multiple locations:
+      #
+      #   def orders
+      #     RestClient::Resource.new('http://example.com/orders', 'admin', 'mypasswd')
+      #   end
+      #
+      #   orders.get                     # GET http://example.com/orders
+      #   orders['1'].get                # GET http://example.com/orders/1
+      #   orders['1/items'].delete       # DELETE http://example.com/orders/1/items
+      #
+      # Nest resources as far as you want:
+      #
+      #   site = RestClient::Resource.new('http://example.com')
+      #   posts = site['posts']
+      #   first_post = posts['1']
+      #   comments = first_post['comments']
+      #   comments.post 'Hello', :content_type => 'text/plain'
+      #
+      def [](suburl, &new_block)
+        case
+          when block_given? then
+            self.class.new(concat_urls(url, suburl), options, &new_block)
+          when block then
+            self.class.new(concat_urls(url, suburl), options, &block)
+          else
+            self.class.new(concat_urls(url, suburl), options)
+        end
+      end
+
+      def concat_urls(url, suburl) # :nodoc:
+        url = url.to_s
+        suburl = suburl.to_s
+        if url.slice(-1, 1) == '/' or suburl.slice(0, 1) == '/'
+          url + suburl
+        else
+          "#{url}/#{suburl}"
+        end
+      end
+    end
+  end
+end