rest-client-wrapper 3.0.1

data/lib/rest_client_wrapper/paginators/echo_paginator.rb

@@ -0,0 +1,67 @@
+# Copyright (C) 2019 The University of Adelaide
+#
+# This file is part of Rest-Client-Wrapper.
+#
+# Rest-Client-Wrapper is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Rest-Client-Wrapper is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rest-Client-Wrapper. If not, see <http://www.gnu.org/licenses/>.
+#
+
+require_relative "paginate"
+require_relative "../exceptions"
+
+module RestClientWrapper
+
+  # Paginator
+  module Paginator
+
+    include Paginate
+
+    # Echo
+    class Echo
+
+      attr_accessor :rest_client
+
+      def initialize(limit: Paginate::DEFAULT_PAGINATION_PAGE_SIZE)
+        @rest_client = nil
+        @config = { limit: limit }
+      end
+
+      def paginate(http_method:, uri:, query_params: {}, headers: {}, data: false)
+        raise RestClientError.new("Client not set, unable to make API call", nil, nil) unless @rest_client
+
+        query_params.reverse_merge!(@config)
+        responses = []
+        loop do
+          response = @rest_client.make_request({ http_method: http_method, uri: uri, query_params: query_params, headers: headers })
+          block_given? ? yield(response) : (responses << response)
+          links = _pagination_links(response)
+          break unless links.key?(:offset)
+
+          query_params[:offset] = links[:offset]
+        end
+        return data ? responses.map(&:body).pluck(:data).flatten : responses
+      end
+
+      private
+
+      def _pagination_links(response)
+        next_l = response&.body&.[](:next) || ""
+        next_h = Rack::Utils.parse_query(URI.parse(next_l)&.query)
+        return next_h.symbolize_keys!
+      end
+
+    end
+
+  end
+
+end

data/lib/rest_client_wrapper/paginators/header_link.rb

@@ -0,0 +1,78 @@
+# Copyright (C) 2019 The University of Adelaide
+#
+# This file is part of Rest-Client-Wrapper.
+#
+# Rest-Client-Wrapper is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Rest-Client-Wrapper is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rest-Client-Wrapper. If not, see <http://www.gnu.org/licenses/>.
+#
+
+require_relative "paginate"
+require_relative "../exceptions"
+
+module RestClientWrapper
+
+  # Paginator
+  module Paginator
+
+    include Paginate
+
+    # HeaderLink
+    class HeaderLink
+
+      attr_accessor :rest_client
+
+      def initialize(per_page: Paginate::DEFAULT_PAGINATION_PAGE_SIZE)
+        @rest_client = nil
+        @config = { page: nil, per_page: per_page }
+      end
+
+      def paginate(http_method:, uri:, query_params: {}, headers: {}, data: false)
+        raise RestClientError.new("Client not set, unable to make API call", nil, nil) unless @rest_client
+
+        query_params.reverse_merge!(@config)
+        responses = []
+        loop.with_index(1) do |_, page|
+          query_params[:page] = page
+          response = @rest_client.make_request({ http_method: http_method, uri: uri, query_params: query_params, headers: headers })
+          block_given? ? yield(response) : (responses << response)
+          links = _pagination_links(response)
+          break unless links.key?(:next)
+        end
+        return data ? responses.map(&:body).flatten : responses
+      end
+
+      private
+
+      def _pagination_links(response)
+        re_uri = "\<(.*?)\>".freeze
+        re_rel = "current|next|first|last".freeze
+        links_a = response&.headers&.[](:link)&.split(",") || []
+        links_h = {}
+        links_a.each do |rel_link|
+          link_parts = rel_link.split(";")
+          next unless link_parts.length == 2
+
+          uri_match = link_parts[0].match(re_uri)
+          rel_match = link_parts[1].match(re_rel)
+          next if (uri_match.nil? || rel_match.nil?) || (uri_match.captures.length != 1 || rel_match.length != 1)
+
+          links_h[rel_match[0]] = uri_match.captures[0]
+        end
+        return links_h.symbolize_keys!
+      end
+
+    end
+
+  end
+
+end

data/lib/rest_client_wrapper/paginators/header_link_paginator.rb

@@ -0,0 +1,78 @@
+# Copyright (C) 2019 The University of Adelaide
+#
+# This file is part of Rest-Client-Wrapper.
+#
+# Rest-Client-Wrapper is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Rest-Client-Wrapper is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rest-Client-Wrapper. If not, see <http://www.gnu.org/licenses/>.
+#
+
+require_relative "paginate"
+require_relative "../exceptions"
+
+module RestClientWrapper
+
+  # Paginator
+  module Paginator
+
+    include Paginate
+
+    # HeaderLink
+    class HeaderLink
+
+      attr_accessor :rest_client
+
+      def initialize(per_page: Paginate::DEFAULT_PAGINATION_PAGE_SIZE)
+        @rest_client = nil
+        @config = { page: nil, per_page: per_page }
+      end
+
+      def paginate(http_method:, uri:, query_params: {}, headers: {}, data: false)
+        raise RestClientError.new("Client not set, unable to make API call", nil, nil) unless @rest_client
+
+        query_params.reverse_merge!(@config)
+        responses = []
+        loop.with_index(1) do |_, page|
+          query_params[:page] = page
+          response = @rest_client.make_request({ http_method: http_method, uri: uri, query_params: query_params, headers: headers })
+          block_given? ? yield(response) : (responses << response)
+          links = _pagination_links(response)
+          break unless links.key?(:next)
+        end
+        return data ? responses.map(&:body).flatten : responses
+      end
+
+      private
+
+      def _pagination_links(response)
+        re_uri = "\<(.*?)\>".freeze
+        re_rel = "current|next|first|last".freeze
+        links_a = response&.headers&.[](:link)&.split(",") || []
+        links_h = {}
+        links_a.each do |rel_link|
+          link_parts = rel_link.split(";")
+          next unless link_parts.length == 2
+
+          uri_match = link_parts[0].match(re_uri)
+          rel_match = link_parts[1].match(re_rel)
+          next if (uri_match.nil? || rel_match.nil?) || (uri_match.captures.length != 1 || rel_match.length != 1)
+
+          links_h[rel_match[0]] = uri_match.captures[0]
+        end
+        return links_h.symbolize_keys!
+      end
+
+    end
+
+  end
+
+end

data/lib/rest_client_wrapper/paginators/paginate.rb

@@ -0,0 +1,32 @@
+# Copyright (C) 2019 The University of Adelaide
+#
+# This file is part of Rest-Client-Wrapper.
+#
+# Rest-Client-Wrapper is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Rest-Client-Wrapper is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rest-Client-Wrapper. If not, see <http://www.gnu.org/licenses/>.
+#
+
+module RestClientWrapper
+
+  # Interface for paginators to implement
+  module Paginate
+
+    DEFAULT_PAGINATION_PAGE_SIZE = 1000
+
+    def paginate(_http_method:, _uri:, _payload:, _headers:, _data:)
+      raise NotImplementedError
+    end
+
+  end
+
+end

data/lib/rest_client_wrapper/request.rb

@@ -0,0 +1,75 @@
+# Copyright (C) 2019 The University of Adelaide
+#
+# This file is part of Rest-Client-Wrapper.
+#
+# Rest-Client-Wrapper is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Rest-Client-Wrapper is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rest-Client-Wrapper. If not, see <http://www.gnu.org/licenses/>.
+#
+
+module RestClientWrapper
+
+  # Request
+  class Request
+
+    attr_reader :uri, :headers, :http_method, :payload, :segment_params, :query_params
+    attr_writer :uri
+
+    DEFAULT_CONTENT_TYPE = { content_type: :json, accept: :json }.freeze # default content type for post and put requests
+    VALID_HTTP_METHODS = %i[get post put patch delete connect options trace].freeze
+    HTTP_METHOD_FOR_JSON = %i[post put patch].freeze
+
+    def initialize(http_method:, uri:, segment_params: {}, payload: {}, query_params: {}, headers: {}) # rubocop:disable Metrics/ParameterLists
+      @uri = uri
+      self.headers = headers
+      self.segment_params = segment_params
+      self.payload = payload
+      self.query_params = query_params
+      self.http_method = http_method
+    end
+
+    def http_method=(http_method)
+      raise TypeError, "Request http_method parameters is not a symbol" unless http_method.is_a?(Symbol)
+      raise ArgumentError, "Not a valid http method" unless VALID_HTTP_METHODS.include?(http_method)
+
+      headers[:content_type] = DEFAULT_CONTENT_TYPE[:content_type] unless headers.key?(:content_type) || !HTTP_METHOD_FOR_JSON.include?(http_method)
+      headers[:accept] = DEFAULT_CONTENT_TYPE[:accept] unless headers.key?(:accept) || !HTTP_METHOD_FOR_JSON.include?(http_method)
+      @http_method = http_method
+    end
+
+    def payload=(payload)
+      raise TypeError, "Request payload parameters is not a hash" unless payload.is_a?(Hash)
+
+      @payload = payload
+    end
+
+    def segment_params=(segment_params)
+      raise TypeError, "Request segment parameters is not a hash" unless segment_params.is_a?(Hash)
+
+      @segment_params = segment_params
+    end
+
+    def query_params=(query_params)
+      raise TypeError, "Request query parameters is not a hash" unless query_params.is_a?(Hash)
+
+      @query_params = query_params
+    end
+
+    def headers=(headers)
+      raise TypeError, "Request headers parameters is not a hash" unless headers.is_a?(Hash)
+
+      @headers.nil? ? @headers = headers : @headers.merge!(headers)
+    end
+
+  end
+
+end

data/lib/rest_client_wrapper/response.rb

@@ -0,0 +1,34 @@
+# Copyright (C) 2019 The University of Adelaide
+#
+# This file is part of Rest-Client-Wrapper.
+#
+# Rest-Client-Wrapper is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Rest-Client-Wrapper is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rest-Client-Wrapper. If not, see <http://www.gnu.org/licenses/>.
+#
+
+module RestClientWrapper
+
+  # Response
+  class Response
+
+    attr_reader :headers, :body, :code
+
+    def initialize(headers, body, code)
+      @headers = headers
+      @body = body
+      @code = code
+    end
+
+  end
+
+end

data/lib/rest_client_wrapper/rest_client.rb

@@ -0,0 +1,178 @@
+# Copyright (C) 2019 The University of Adelaide
+#
+# This file is part of Rest-Client-Wrapper.
+#
+# Rest-Client-Wrapper is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Rest-Client-Wrapper is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rest-Client-Wrapper. If not, see <http://www.gnu.org/licenses/>.
+#
+
+require "active_support"
+require "active_support/core_ext"
+require "json"
+require "rack"
+require "rest_client"
+require_relative "exceptions"
+require_relative "http"
+
+module RestClientWrapper
+
+  # RestClient
+  class RestClient
+
+    include Http
+
+    attr_accessor :authenticator, :paginator
+
+    DEFAULT_RETRY  = { max_retry: 0, wait: 0 }.freeze
+    DEFAULT_CONFIG = {
+      retries: {
+        401 => { max_retry: 1, wait: 0 }, # unauthorized
+        429 => { max_retry: 3, wait: 3 }  # too many requests
+      }
+    }.freeze
+
+    def initialize(host:, config: {})
+      @host          = host
+      @config        = config
+      @retry_configs = {}.reverse_merge(DEFAULT_CONFIG[:retries])
+
+      @config[:retries]&.each do |k, v|
+        next unless Rack::Utils::HTTP_STATUS_CODES[k.to_i] # skip invalid codes
+
+        @retry_configs[k.to_i] = v.reverse_merge(DEFAULT_RETRY)
+      end
+
+      _reset_retries
+    end
+
+    def execute(request:)
+      _reset_retries
+      _validate_request(request)
+      _set_auth(request)
+      url = _build_uri(request)
+
+      loop do
+        access_token = @authenticator.is_a?(Authenticator::Oauth) ? @authenticator.access_token : nil
+        response_code = nil
+
+        begin
+          payload = Request::HTTP_METHOD_FOR_JSON.include?(request.http_method) ? request.payload.to_json : request.payload
+          request.headers[:params] = request.query_params
+          response = ::RestClient::Request.execute({ method: request.http_method, url: url, payload: payload, headers: request.headers })
+          response_code = response&.code
+        rescue StandardError => e
+          response_code = e.response&.code
+          # Any response that doesn't have a status of 200...207 will be raised as an exception from Rest-Client
+          raise RestClientError.new("API request encountered an unhandled exception", e.response, e) unless _retry?(response_code)
+        end
+
+        return Response.new(response.headers, _parse_response(response), response.code) if Http.success?(response_code)
+        raise RestClientNotSuccessful.new("API request was not successful", response) unless _retry?(response_code)
+
+        _wait_and_retry(response_code, access_token)
+        next
+      end
+    end
+
+    def make_request(http_method:, uri:, payload: {}, query_params: {}, headers: {})
+      parsed_uri = URI.parse(uri)
+
+      raise ArgumentError, "URL host does not match config host of instance, unable to make API call" if parsed_uri.absolute? && @host.casecmp("#{ parsed_uri.scheme }://#{ parsed_uri.host }").nonzero?
+
+      uri = parsed_uri.absolute? ? parsed_uri.path : uri
+      request = Request.new({ http_method: http_method, uri: uri, payload: payload, query_params: query_params })
+      request.headers = headers
+      return self.execute({ request: request })
+    end
+
+    def make_request_for_pages(http_method:, uri:, query_params: {}, headers: {}, data: false)
+      raise RestClientError.new("Paginator not set, unable to make API call", nil, nil) unless @paginator
+
+      @paginator.rest_client ||= self
+      return @paginator.paginate({ http_method: http_method, uri: uri, query_params: query_params, headers: headers, data: data })
+    end
+
+    private
+
+    def _set_auth(request)
+      return if @authenticator.nil?
+
+      auth = @authenticator.respond_to?(:generate_auth) ? @authenticator.generate_auth : {}
+      if @authenticator.is_a?(Authenticator::Custom)
+        case @authenticator.type
+        when :query_param
+          request.query_params.merge!(auth)
+        when :header
+          request.headers.merge!(auth)
+        end
+      else
+        request.headers.merge!(auth)
+      end
+    end
+
+    def _build_uri(request)
+      return format("#{ @host }#{ request.uri }", request.segment_params)
+    end
+
+    def _validate_request(request)
+      # Regex to find segments in uri with the pattern <segment_param>
+      url_segments = request.uri.scan(/\<(.*?)\>/).flatten
+      url_segments.each do |url_segment|
+        raise ArgumentError, "Segment parameter not provided for #{ url_segment }. URI #{ request.uri }" unless request.segment_params.include? url_segment.to_sym
+      end
+      return true
+    end
+
+    def _parse_response(response)
+      return nil unless response.respond_to?(:body)
+
+      parsed_body =
+        case MIME::Types[response&.headers&.[](:content_type)].first
+        when "application/json"
+          _parse_json(response)
+        else
+          response.body
+        end
+
+      return parsed_body
+    rescue StandardError => e
+      raise RestClientError.new("Response could not be parsed", response, e)
+    end
+
+    def _parse_json(response)
+      return { ok: true } if response.body == "ok".to_json # Handle special case for Echo delete responses
+
+      return JSON.parse(response.body, { object_class: Hash, symbolize_names: true })
+    rescue StandardError => e
+      raise RestClientError.new("Response could not be parsed as JSON", response, e)
+    end
+
+    def _reset_retries
+      @retry_configs.each_value { |v| v[:retry] = 0 }
+    end
+
+    def _retry?(response_code)
+      return true if @retry_configs.key?(response_code) && @retry_configs[response_code][:retry] < @retry_configs[response_code][:max_retry]
+
+      return false
+    end
+
+    def _wait_and_retry(response_code, access_token)
+      sleep(@retry_configs[response_code][:wait].to_f)
+      Authenticator::Oauth.authenticate({ client_id: @authenticator&.client_id, access_token: access_token }) if Http.unauthorized?(response_code) && @authenticator.is_a?(Authenticator::Oauth)
+      @retry_configs[response_code][:retry] += 1
+    end
+
+  end
+
+end