kpm 0.7.1 → 0.9.0

data/lib/kpm/kaui_artifact.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 require 'rexml/document'
 require 'set'
 
 module KPM
   class KauiArtifact < BaseArtifact
     class << self
-      def versions(overrides={}, ssl_verify=true)
-
-        coordinate_map = {:group_id => KPM::BaseArtifact::KAUI_GROUP_ID, :artifact_id => KPM::BaseArtifact::KAUI_ARTIFACT_ID, :packaging => KPM::BaseArtifact::KAUI_PACKAGING, :classifier => KPM::BaseArtifact::KAUI_CLASSIFIER}
+      def versions(overrides = {}, ssl_verify = true)
+        coordinate_map = { group_id: KPM::BaseArtifact::KAUI_GROUP_ID, artifact_id: KPM::BaseArtifact::KAUI_ARTIFACT_ID, packaging: KPM::BaseArtifact::KAUI_PACKAGING, classifier: KPM::BaseArtifact::KAUI_CLASSIFIER }
 
         coordinates = KPM::Coordinates.build_coordinates(coordinate_map)
         response    = REXML::Document.new nexus_remote(overrides, ssl_verify).search_for_artifacts(coordinates)

data/lib/kpm/killbill_plugin_artifact.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 require 'rexml/document'
 require 'set'
 
 module KPM
   class KillbillPluginArtifact < BaseArtifact
     class << self
-      def pull(logger, group_id, artifact_id, packaging='jar', classifier=nil, version='LATEST', plugin_name=nil, destination_path=nil, sha1_file=nil, force_download=false, verify_sha1=true, overrides={}, ssl_verify=true)
-        coordinate_map = {:group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier, :version => version}
-        pull_and_put_in_place(logger, coordinate_map, plugin_name, destination_path, is_ruby_plugin_and_should_skip_top_dir(group_id, artifact_id), sha1_file, force_download, verify_sha1, overrides, ssl_verify)
+      def pull(logger, group_id, artifact_id, packaging = 'jar', classifier = nil, version = 'LATEST', plugin_name = nil, destination_path = nil, sha1_file = nil, force_download = false, verify_sha1 = true, overrides = {}, ssl_verify = true)
+        coordinate_map = { group_id: group_id, artifact_id: artifact_id, packaging: packaging, classifier: classifier, version: version }
+        pull_and_put_in_place(logger, coordinate_map, plugin_name, destination_path, ruby_plugin_and_should_skip_top_dir?(group_id, artifact_id), sha1_file, force_download, verify_sha1, overrides, ssl_verify)
       end
 
-      def versions(overrides={}, ssl_verify=true)
-        plugins = {:java => {}, :ruby => {}}
+      def versions(overrides = {}, ssl_verify = true)
+        plugins = { java: {}, ruby: {} }
 
         nexus = nexus_remote(overrides, ssl_verify)
 
         [[:java, KPM::BaseArtifact::KILLBILL_JAVA_PLUGIN_GROUP_ID], [:ruby, KPM::BaseArtifact::KILLBILL_RUBY_PLUGIN_GROUP_ID]].each do |type_and_group_id|
           response = REXML::Document.new nexus.search_for_artifacts(type_and_group_id[1])
           response.elements.each('searchNGResponse/data/artifact') do |element|
-            artifact_id                                = element.elements['artifactId'].text
+            artifact_id = element.elements['artifactId'].text
             plugins[type_and_group_id[0]][artifact_id] ||= SortedSet.new
             plugins[type_and_group_id[0]][artifact_id] << element.elements['version'].text
           end
@@ -27,9 +29,10 @@ module KPM
       end
 
       protected
+
       # Magic methods...
 
-      def is_ruby_plugin_and_should_skip_top_dir(group_id, artifact_id)
+      def ruby_plugin_and_should_skip_top_dir?(group_id, artifact_id)
         # The second check is for custom ruby plugins
         group_id == KPM::BaseArtifact::KILLBILL_RUBY_PLUGIN_GROUP_ID || artifact_id.include?('plugin')
       end

data/lib/kpm/killbill_server_artifact.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'rexml/document'
 require 'set'
 
 module KPM
   class KillbillServerArtifact < BaseArtifact
     class << self
-      def versions(artifact_id, packaging=KPM::BaseArtifact::KILLBILL_PACKAGING, classifier=KPM::BaseArtifact::KILLBILL_CLASSIFIER, overrides={}, ssl_verify=true)
-        coordinate_map = {:group_id => KPM::BaseArtifact::KILLBILL_GROUP_ID, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier}
+      def versions(artifact_id, packaging = KPM::BaseArtifact::KILLBILL_PACKAGING, classifier = KPM::BaseArtifact::KILLBILL_CLASSIFIER, overrides = {}, ssl_verify = true)
+        coordinate_map = { group_id: KPM::BaseArtifact::KILLBILL_GROUP_ID, artifact_id: artifact_id, packaging: packaging, classifier: classifier }
         coordinates = KPM::Coordinates.build_coordinates(coordinate_map)
         response    = REXML::Document.new nexus_remote(overrides, ssl_verify).search_for_artifacts(coordinates)
         versions    = SortedSet.new
@@ -13,10 +15,13 @@ module KPM
         versions
       end
 
-      def info(version='LATEST', overrides={}, ssl_verify=true)
+      def info(version = 'LATEST', sha1_file = nil, force_download = false, verify_sha1 = true, overrides = {}, ssl_verify = true)
         logger = Logger.new(STDOUT)
         logger.level = Logger::ERROR
 
+        # Initialize as early as possible (used in rescue block below)
+        sha1_checker = sha1_file ? Sha1Checker.from_file(sha1_file) : nil
+
         version = KPM::Installer.get_kb_latest_stable_version if version == 'LATEST'
 
         versions = {}
@@ -29,9 +34,9 @@ module KPM
                              nil,
                              version,
                              dir,
-                             nil,
-                             false,
-                             true,
+                             sha1_file,
+                             force_download,
+                             verify_sha1,
                              overrides,
                              ssl_verify)
 
@@ -51,19 +56,28 @@ module KPM
                               nil,
                               oss_parent_version,
                               dir,
-                              nil,
-                              false,
-                              true,
+                              sha1_file,
+                              force_download,
+                              verify_sha1,
                               overrides,
                               ssl_verify)
 
           pom = REXML::Document.new(File.new(oss_pom_info[:file_path]))
           properties_element = pom.root.elements['properties']
-          %w(killbill-api killbill-plugin-api killbill-commons killbill-platform).each do |property|
+          %w[killbill-api killbill-plugin-api killbill-commons killbill-platform].each do |property|
             versions[property] = properties_element.elements["#{property}.version"].text
           end
+
+          sha1_checker.cache_killbill_info(version, versions) if sha1_checker
         end
         versions
+      rescue StandardError => e
+        # Network down? Hopefully, we have something in the cache
+        cached_version = sha1_checker ? sha1_checker.killbill_info(version) : nil
+        raise e if force_download || !cached_version
+
+        # Use the cache
+        cached_version
       end
     end
   end

data/lib/kpm/migrations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'base64'
 require 'json'
 require 'logger'
@@ -6,10 +8,9 @@ require 'pathname'
 
 module KPM
   class Migrations
-
-    KILLBILL_MIGRATION_PATH = /src\/main\/resources\/org\/killbill\/billing\/[a-z]+\/migration\/(V[0-9a-zA-Z_]+.sql)/
-    JAVA_PLUGIN_MIGRATION_PATH = /src\/main\/resources\/migration\/(V[0-9a-zA-Z_]+.sql)/
-    RUBY_PLUGIN_MIGRATION_PATH = /db\/migrate\/([0-9a-zA-Z_]+.rb)/
+    KILLBILL_MIGRATION_PATH = %r{src/main/resources/org/killbill/billing/[a-z]+/migration/(V[0-9a-zA-Z_]+.sql)}.freeze
+    JAVA_PLUGIN_MIGRATION_PATH = %r{src/main/resources/migration/(V[0-9a-zA-Z_]+.sql)}.freeze
+    RUBY_PLUGIN_MIGRATION_PATH = %r{db/migrate/([0-9a-zA-Z_]+.rb)}.freeze
 
     # Go to https://github.com/settings/tokens to generate a token
     def initialize(from_version, to_version = nil, repository = 'killbill/killbill', oauth_token = nil, logger = Logger.new(STDOUT))
@@ -34,7 +35,7 @@ module KPM
     end
 
     def save(dir = nil)
-      return nil if migrations.size == 0
+      return nil if migrations.empty?
 
       dir ||= Dir.mktmpdir
       @logger.debug("Storing migrations to #{dir}")
@@ -53,7 +54,7 @@ module KPM
 
     def for_version(version = @from_version, name_only = false, migrations_to_skip = Set.new)
       @logger.info("Looking for migrations repository=#{@repository}, version=#{version}")
-      metadata = get_as_json("https://api.github.com/repos/#{@repository}/git/trees/#{version}?recursive=1&access_token=#{@oauth_token}")
+      metadata = get_as_json("https://api.github.com/repos/#{@repository}/git/trees/#{version}?recursive=1")
 
       migrations = []
       metadata['tree'].each do |entry|
@@ -66,13 +67,13 @@ module KPM
 
         sql = nil
         unless name_only
-          blob_metadata = get_as_json("#{entry['url']}?access_token=#{@oauth_token}")
+          blob_metadata = get_as_json((entry['url']).to_s)
           sql = decode(blob_metadata['content'], blob_metadata['encoding'])
         end
 
         migrations << {
-            :name => migration_name,
-            :sql => sql
+          name: migration_name,
+          sql: sql
         }
       end
 
@@ -80,8 +81,22 @@ module KPM
     end
 
     def get_as_json(url)
-      raw = URI.parse(url).read
-      JSON.parse(raw)
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+
+      path = uri.path || '/'
+      path = "#{path}?#{uri.query}" unless uri.query.nil?
+      request = Net::HTTP::Get.new(path)
+      request['Authorization'] = "token #{@oauth_token}" unless @oauth_token.nil?
+
+      response = http.request(request)
+      case response.code
+      when '200'
+        JSON.parse(response.body)
+      else
+        raise "Unable to download #{url}: #{response.code}"
+      end
     end
 
     def decode(content, encoding)

data/lib/kpm/nexus_helper/actions.rb

@@ -1,9 +1,25 @@
+# frozen_string_literal: true
+
 require_relative 'nexus_api_calls_v2'
-#require_relative 'nexus_api_calls_v3'
+require_relative 'github_api_calls'
 
 module KPM
   module NexusFacade
     class Actions
+      DEFAULT_RETRIES = 3
+      DEFAULT_CONNECTION_ERRORS = {
+        EOFError => 'The remote server dropped the connection',
+        Errno::ECONNREFUSED => 'The remote server refused the connection',
+        Errno::ECONNRESET => 'The remote server reset the connection',
+        Timeout::Error => 'The connection to the remote server timed out',
+        Errno::ETIMEDOUT => 'The connection to the remote server timed out',
+        SocketError => 'The connection to the remote server could not be established',
+        OpenSSL::X509::CertificateError => 'The remote server did not accept the provided SSL certificate',
+        OpenSSL::SSL::SSLError => 'The SSL connection to the remote server could not be established',
+        Zlib::BufError => 'The remote server replied with an invalid response',
+        KPM::NexusFacade::UnexpectedStatusCodeException => nil
+      }.freeze
+
       attr_reader :nexus_api_call
 
       def initialize(overrides, ssl_verify, logger)
@@ -11,24 +27,44 @@ module KPM
         overrides[:url] ||= 'https://oss.sonatype.org'
         overrides[:repository] ||= 'releases'
 
-        #this is where the version is verified
-        #example if
-        #@nexus_api_call = overrides['version'] == '3' ? NexusApiCallsV3.new(overrides, ssl_verify) : NexusApiCallsV2.new(overrides, ssl_verify)
-        @nexus_api_call = NexusApiCallsV2.new(overrides, ssl_verify, logger)
+        @logger = logger
+
+        @nexus_api_call = overrides[:url].start_with?('https://maven.pkg.github.com') ? GithubApiCalls.new(overrides, ssl_verify, logger) : NexusApiCallsV2.new(overrides, ssl_verify, logger)
       end
 
-      def pull_artifact(coordinates, destination=nil)
-        nexus_api_call.pull_artifact(coordinates, destination)
+      def pull_artifact(coordinates, destination = nil)
+        retry_exceptions("pull_artifact #{coordinates}") { nexus_api_call.pull_artifact(coordinates, destination) }
       end
 
       def get_artifact_info(coordinates)
-        nexus_api_call.get_artifact_info(coordinates)
+        retry_exceptions("get_artifact_info #{coordinates}") { nexus_api_call.get_artifact_info(coordinates) }
       end
 
       def search_for_artifacts(coordinates)
-        nexus_api_call.search_for_artifacts(coordinates)
+        retry_exceptions("search_for_artifacts #{coordinates}") { nexus_api_call.search_for_artifacts(coordinates) }
+      end
+
+      private
+
+      def retry_exceptions(tag)
+        retries = DEFAULT_RETRIES
+
+        begin
+          yield
+        rescue *DEFAULT_CONNECTION_ERRORS.keys => e
+          retries -= 1
+
+          @logger.warn(format('Transient error during %<tag>s, retrying (attempt=%<attempt>d): %<msg>s', tag: tag, attempt: DEFAULT_RETRIES - retries, msg: derived_error_message(DEFAULT_CONNECTION_ERRORS, e)))
+          retry unless retries.zero?
+
+          raise
+        end
       end
 
+      def derived_error_message(errors, exception)
+        key = (errors.keys & exception.class.ancestors).first
+        (key ? errors[key] : nil) || exception.message
+      end
     end
   end
 end

data/lib/kpm/nexus_helper/github_api_calls.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'rexml/document'
+require 'openssl'
+
+module KPM
+  module NexusFacade
+    class GithubApiCalls < NexusApiCallsV2
+      def pull_artifact_endpoint(coordinates)
+        base_path, versioned_artifact, = build_base_path_and_coords(coordinates)
+        "#{base_path}/#{versioned_artifact}"
+      end
+
+      def get_artifact_info(coordinates)
+        super
+
+        _, versioned_artifact, coords = build_base_path_and_coords(coordinates)
+        sha1 = get_sha1(coordinates)
+        "<artifact-resolution>
+  <data>
+    <presentLocally>true</presentLocally>
+    <groupId>#{coords[:group_id]}</groupId>
+    <artifactId>#{coords[:artifact_id]}</artifactId>
+    <version>#{coords[:version]}</version>
+    <extension>#{coords[:packaging]}</extension>
+    <snapshot>#{!(coords[:version] =~ /-SNAPSHOT$/).nil?}</snapshot>
+    <sha1>#{sha1}</sha1>
+    <repositoryPath>/#{coords[:group_id].gsub('.', '/')}/#{versioned_artifact}</repositoryPath>
+  </data>
+</artifact-resolution>"
+      end
+
+      def get_artifact_info_endpoint(coordinates)
+        base_path, = build_base_path_and_coords(coordinates)
+        "#{base_path}/maven-metadata.xml"
+      end
+
+      def search_for_artifact_endpoint(_coordinates)
+        raise NoMethodError, 'GitHub Packages has no search support'
+      end
+
+      def build_query_params(_coordinates, _what_parameters = nil)
+        ''
+      end
+
+      private
+
+      def get_sha1(coordinates)
+        base_path, versioned_artifact, = build_base_path_and_coords(coordinates)
+        endpoint = "#{base_path}/#{versioned_artifact}.sha1"
+        get_response_with_retries(coordinates, endpoint, nil)
+      end
+
+      def build_base_path_and_coords(coordinates)
+        coords = parse_coordinates(coordinates)
+
+        # The url may contain the org and repo, e.g. 'https://maven.pkg.github.com/killbill/qualpay-java-client'
+        org_and_repo = URI.parse(configuration[:url]).path
+
+        [
+          "#{org_and_repo}/#{coords[:group_id].gsub('.', '/')}/#{coords[:artifact_id]}",
+          "#{coords[:version]}/#{coords[:artifact_id]}-#{coords[:version]}.#{coords[:extension]}",
+          coords
+        ]
+      end
+    end
+  end
+end

data/lib/kpm/nexus_helper/nexus_api_calls_v2.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'net/http'
 require 'uri'
 require 'rexml/document'
@@ -5,13 +7,12 @@ require 'openssl'
 
 module KPM
   module NexusFacade
-
     class UnexpectedStatusCodeException < StandardError
       def initialize(code)
         @code = code
       end
 
-      def  message
+      def message
         "The server responded with a #{@code} status code which is unexpected."
       end
     end
@@ -26,19 +27,13 @@ module KPM
 
     # This is an extract and slim down of functions needed from nexus_cli to maintain the response expected by the base_artifact.
     class NexusApiCallsV2
-      PULL_ARTIFACT_ENDPOINT = '/service/local/artifact/maven/redirect'
-      GET_ARTIFACT_INFO_ENDPOINT = '/service/local/artifact/maven/resolve'
-      SEARCH_FOR_ARTIFACT_ENDPOINT = '/service/local/lucene/search'
-
       READ_TIMEOUT_DEFAULT = 60
       OPEN_TIMEOUT_DEFAULT = 60
 
       ERROR_MESSAGE_404 = 'The artifact you requested information for could not be found. Please ensure it exists inside the Nexus.'
-      ERROR_MESSAGE_503 = 'Could not connect to Nexus. Please ensure the url you are using is reachable.'
 
-      attr_reader :version
-      attr_reader :configuration
-      attr_reader :ssl_verify
+      attr_reader :version, :configuration, :ssl_verify
+
       attr_accessor :logger
 
       def initialize(configuration, ssl_verify, logger)
@@ -49,141 +44,168 @@ module KPM
 
       def search_for_artifacts(coordinates)
         logger.debug "Entered - Search for artifact, coordinates: #{coordinates}"
-        response = get_response(coordinates, SEARCH_FOR_ARTIFACT_ENDPOINT, [:g, :a])
+        response = get_response(coordinates, search_for_artifact_endpoint(coordinates), %i[g a])
 
         case response.code
-          when '200'
-            logger.debug "response body: #{response.body}"
-            return response.body
-          else
-            raise UnexpectedStatusCodeException.new(response.code)
+        when '200'
+          logger.debug "response body: #{response.body}"
+          response.body
+        when '404'
+          raise StandardError, ERROR_MESSAGE_404
+        else
+          raise UnexpectedStatusCodeException, response.code
         end
       end
 
       def get_artifact_info(coordinates)
-        logger.debug "Entered - Get artifact info, coordinates: #{coordinates}"
-        response = get_response(coordinates, GET_ARTIFACT_INFO_ENDPOINT, nil)
-
-        case response.code
-          when '200'
-            logger.debug "response body: #{response.body}"
-            return response.body
-          when '404'
-            raise StandardError.new(ERROR_MESSAGE_404)
-          when '503'
-            raise StandardError.new(ERROR_MESSAGE_503)
-          else
-            raise UnexpectedStatusCodeException.new(response.code)
-        end
+        get_response_with_retries(coordinates, get_artifact_info_endpoint(coordinates), nil)
       end
 
-      def pull_artifact(coordinates ,destination)
-        logger.debug "Entered - Pull artifact, coordinates: #{coordinates}"
+      def pull_artifact(coordinates, destination)
         file_name = get_file_name(coordinates)
-        destination = File.join(File.expand_path(destination || "."), file_name)
-        logger.debug "destination: #{destination}"
-        response = get_response(coordinates, PULL_ARTIFACT_ENDPOINT, nil)
+        destination = File.join(File.expand_path(destination || '.'), file_name)
+        logger.debug { "Downloading to destination: #{destination}" }
 
-        case response.code
-          when '301', '307'
-            location = response['Location'].gsub!(configuration[:url],'')
-            logger.debug 'fetching artifact'
-            file_response = get_response(nil,location, nil)
-
-            File.open(destination, "wb") do |io|
-                io.write(file_response.body)
-            end
-          when 404
-            raise StandardError.new(ERROR_MESSAGE_404)
-          else
-            raise UnexpectedStatusCodeException.new(response.code)
+        File.open(destination, 'wb') do |io|
+          io.write(get_response_with_retries(coordinates, pull_artifact_endpoint(coordinates), nil))
         end
+
         {
-            :file_name => file_name,
-            :file_path => File.expand_path(destination),
-            :version   => version,
-            :size      => File.size(File.expand_path(destination))
+          file_name: file_name,
+          file_path: File.expand_path(destination),
+          version: version,
+          size: File.size(File.expand_path(destination))
         }
       end
 
-      private
-        def parse_coordinates(coordinates)
+      def pull_artifact_endpoint(_coordinates)
+        '/service/local/artifact/maven/redirect'
+      end
 
-          if coordinates.nil?
-            raise ArtifactMalformedException
-          end
+      def get_artifact_info_endpoint(_coordinates)
+        '/service/local/artifact/maven/resolve'
+      end
 
-          split_coordinates = coordinates.split(":")
-          if (split_coordinates.size == 0 or split_coordinates.size > 5)
-            raise ArtifactMalformedException
-          end
+      def search_for_artifact_endpoint(_coordinates)
+        '/service/local/lucene/search'
+      end
 
-          artifact = Hash.new
+      def build_query_params(coordinates, what_parameters = nil)
+        artifact = parse_coordinates(coordinates)
+        @version = artifact[:version].to_s.upcase
 
-          artifact[:group_id] = split_coordinates[0]
-          artifact[:artifact_id] = split_coordinates[1]
-          artifact[:extension] = split_coordinates.size > 3 ? split_coordinates[2] : "jar"
-          artifact[:classifier] = split_coordinates.size > 4 ? split_coordinates[3] : nil
-          artifact[:version] = split_coordinates[-1]
+        query = { g: artifact[:group_id], a: artifact[:artifact_id], e: artifact[:extension], v: version, r: configuration[:repository] }
+        query.merge!(c: artifact[:classifier]) unless artifact[:classifier].nil?
 
-          artifact[:version].upcase! if version == "latest"
+        params = what_parameters.nil? ? query : {}
+        what_parameters.each { |key| params[key] = query[key] unless query[key].nil? } unless what_parameters.nil?
 
-          return artifact
-        end
+        params.map { |key, value| "#{key}=#{value}" }.join('&')
+      end
 
-        def get_file_name(coordinates)
-          artifact = parse_coordinates(coordinates)
+      private
 
-          if artifact[:version].casecmp("latest")
-             artifact[:version] = REXML::Document.new(get_artifact_info(coordinates)).elements["//version"].text
-          end
+      def parse_coordinates(coordinates)
+        raise ArtifactMalformedException if coordinates.nil?
 
-          if artifact[:classifier].nil?
-            "#{artifact[:artifact_id]}-#{artifact[:version]}.#{artifact[:extension]}"
-          else
-            "#{artifact[:artifact_id]}-#{artifact[:version]}-#{artifact[:classifier]}.#{artifact[:extension]}"
-          end
-        end
+        split_coordinates = coordinates.split(':')
+        raise ArtifactMalformedException if split_coordinates.empty? || (split_coordinates.size > 5)
 
-        def get_query_params(coordinates, what_parameters = nil)
-          artifact = parse_coordinates(coordinates)
-          @version = artifact[:version].to_s.upcase
+        artifact = {}
 
-          query = {:g => artifact[:group_id], :a => artifact[:artifact_id], :e => artifact[:extension], :v => version, :r => configuration[:repository]}
-          query.merge!({:c => artifact[:classifier]}) unless artifact[:classifier].nil?
+        artifact[:group_id] = split_coordinates[0]
+        artifact[:artifact_id] = split_coordinates[1]
+        artifact[:extension] = split_coordinates.size > 3 ? split_coordinates[2] : 'jar'
+        artifact[:classifier] = split_coordinates.size > 4 ? split_coordinates[3] : nil
+        artifact[:version] = split_coordinates[-1]
 
-          params = what_parameters.nil? ? query : Hash.new
-          what_parameters.each {|key| params[key] = query[key] unless query[key].nil? } unless what_parameters.nil?
+        artifact[:version].upcase! if version == 'latest'
 
-          params.map{|key,value| "#{key}=#{value}"}.join('&')
-        end
+        artifact
+      end
 
-        def get_response(coordinates, endpoint, what_parameters)
-          http = get_http
-          query_params = get_query_params(coordinates, what_parameters) unless coordinates.nil?
-          endpoint = get_endpoint_with_params(endpoint, query_params) unless coordinates.nil?
-          request = Net::HTTP::Get.new(endpoint)
+      def get_file_name(coordinates)
+        artifact = parse_coordinates(coordinates)
 
-          logger.debug "request endpoint: #{endpoint}"
+        artifact[:version] = REXML::Document.new(get_artifact_info(coordinates)).elements['//version'].text if artifact[:version].casecmp('latest')
 
-          response = http.request(request)
-          response
+        if artifact[:classifier].nil?
+          "#{artifact[:artifact_id]}-#{artifact[:version]}.#{artifact[:extension]}"
+        else
+          "#{artifact[:artifact_id]}-#{artifact[:version]}-#{artifact[:classifier]}.#{artifact[:extension]}"
+        end
+      end
+
+      def get_response_with_retries(coordinates, endpoint, what_parameters)
+        logger.debug { "Fetching coordinates=#{coordinates}, endpoint=#{endpoint}, params=#{what_parameters}" }
+        response = get_response(coordinates, endpoint, what_parameters)
+        logger.debug { "Response body: #{response.body}" }
+        process_response_with_retries(response)
+      end
+
+      def process_response_with_retries(response)
+        case response.code
+        when '200'
+          response.body
+        when '301', '307'
+          location = response['Location']
+          logger.debug { "Following redirect to #{location}" }
+
+          new_path = location.gsub!(configuration[:url], '')
+          if new_path.nil?
+            # Redirect to another domain (e.g. CDN)
+            get_raw_response_with_retries(location)
+          else
+            get_response_with_retries(nil, location, nil)
+          end
+        when '404'
+          raise StandardError, ERROR_MESSAGE_404
+        else
+          raise UnexpectedStatusCodeException, response.code
         end
+      end
 
-        def get_http
-          uri = URI.parse(configuration[:url])
-          http = Net::HTTP.new(uri.host,uri.port)
-          http.open_timeout = configuration[:open_timeout] || OPEN_TIMEOUT_DEFAULT #seconds
-          http.read_timeout = configuration[:read_timeout] || READ_TIMEOUT_DEFAULT #seconds
-          http.use_ssl = (ssl_verify != false)
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless ssl_verify
-          http
+      def get_response(coordinates, endpoint, what_parameters)
+        http = build_http
+        query_params = build_query_params(coordinates, what_parameters) unless coordinates.nil?
+        endpoint = endpoint_with_params(endpoint, query_params) unless coordinates.nil?
+        request = Net::HTTP::Get.new(endpoint)
+        if configuration.key?(:username) && configuration.key?(:password)
+          request.basic_auth(configuration[:username], configuration[:password])
+        elsif configuration.key?(:token)
+          request['Authorization'] = "token #{configuration[:token]}"
         end
 
-        def get_endpoint_with_params(endpoint,query_params)
-          "#{endpoint}?#{URI::DEFAULT_PARSER.escape(query_params)}"
+        logger.debug do
+          http.set_debug_output(logger)
+          "HTTP path: #{endpoint}"
         end
 
+        http.request(request)
+      end
+
+      def build_http
+        uri = URI.parse(configuration[:url])
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.open_timeout = configuration[:open_timeout] || OPEN_TIMEOUT_DEFAULT # seconds
+        http.read_timeout = configuration[:read_timeout] || READ_TIMEOUT_DEFAULT # seconds
+        http.use_ssl = (ssl_verify != false)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless ssl_verify
+
+        logger.debug { "HTTP connection: #{http.inspect}" }
+
+        http
+      end
+
+      def get_raw_response_with_retries(location)
+        response = Net::HTTP.get_response(URI(location))
+        logger.debug { "Response body: #{response.body}" }
+        process_response_with_retries(response)
+      end
+
+      def endpoint_with_params(endpoint, query_params)
+        "#{endpoint}?#{URI::DEFAULT_PARSER.escape(query_params)}"
+      end
     end
   end
 end