kpm 0.7.2 → 0.8.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,14 +15,15 @@ module KPM
         versions
       end
 
-      def info(version='LATEST', sha1_file=nil, force_download=false, verify_sha1=true, 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
 
-        version = KPM::Installer.get_kb_latest_stable_version if version == 'LATEST'
-
+        # 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 = {}
         Dir.mktmpdir do |dir|
           # Retrieve the main Kill Bill pom
@@ -61,7 +64,7 @@ module KPM
 
           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
 
@@ -71,12 +74,10 @@ module KPM
       rescue StandardError => e
         # Network down? Hopefully, we have something in the cache
         cached_version = sha1_checker ? sha1_checker.killbill_info(version) : nil
-        if force_download || !cached_version
-          raise e
-        else
-          # Use the cache
-          return cached_version
-        end
+        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}")
@@ -71,8 +72,8 @@ module KPM
         end
 
         migrations << {
-            :name => migration_name,
-            :sql => sql
+          name: migration_name,
+          sql: sql
         }
       end
 

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 'nexus_api_calls_v3'
 
 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,47 @@ 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)
+        @logger = logger
+
+        # 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)
       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/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
@@ -34,7 +35,6 @@ module KPM
       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
@@ -49,14 +49,16 @@ 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, %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}"
+          return response.body
+        when '404'
+          raise StandardError, ERROR_MESSAGE_404
+        else
+          raise UnexpectedStatusCodeException, response.code
         end
       end
 
@@ -65,125 +67,116 @@ module KPM
         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)
+        when '200'
+          logger.debug "response body: #{response.body}"
+          return response.body
+        when '404'
+          raise StandardError, ERROR_MESSAGE_404
+        else
+          raise UnexpectedStatusCodeException, response.code
         end
       end
 
-      def pull_artifact(coordinates ,destination)
+      def pull_artifact(coordinates, destination)
         logger.debug "Entered - Pull artifact, coordinates: #{coordinates}"
         file_name = get_file_name(coordinates)
-        destination = File.join(File.expand_path(destination || "."), file_name)
+        destination = File.join(File.expand_path(destination || '.'), file_name)
         logger.debug "destination: #{destination}"
         response = get_response(coordinates, PULL_ARTIFACT_ENDPOINT, nil)
 
         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)
+        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, ERROR_MESSAGE_404
+        else
+          raise UnexpectedStatusCodeException, response.code
         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)
 
-          if coordinates.nil?
-            raise ArtifactMalformedException
-          end
+      def parse_coordinates(coordinates)
+        raise ArtifactMalformedException if coordinates.nil?
 
-          split_coordinates = coordinates.split(":")
-          if (split_coordinates.size == 0 or split_coordinates.size > 5)
-            raise ArtifactMalformedException
-          end
+        split_coordinates = coordinates.split(':')
+        raise ArtifactMalformedException if split_coordinates.empty? || (split_coordinates.size > 5)
 
-          artifact = Hash.new
+        artifact = {}
 
-          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]
+        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]
 
-          artifact[:version].upcase! if version == "latest"
+        artifact[:version].upcase! if version == 'latest'
 
-          return artifact
-        end
+        artifact
+      end
 
-        def get_file_name(coordinates)
-          artifact = parse_coordinates(coordinates)
+      def get_file_name(coordinates)
+        artifact = parse_coordinates(coordinates)
 
-          if artifact[:version].casecmp("latest")
-             artifact[:version] = REXML::Document.new(get_artifact_info(coordinates)).elements["//version"].text
-          end
+        artifact[:version] = REXML::Document.new(get_artifact_info(coordinates)).elements['//version'].text if artifact[:version].casecmp('latest')
 
-          if artifact[:classifier].nil?
-            "#{artifact[:artifact_id]}-#{artifact[:version]}.#{artifact[:extension]}"
-          else
-            "#{artifact[:artifact_id]}-#{artifact[:version]}-#{artifact[:classifier]}.#{artifact[:extension]}"
-          end
+        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_query_params(coordinates, what_parameters = nil)
-          artifact = parse_coordinates(coordinates)
-          @version = artifact[:version].to_s.upcase
-
-          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?
+      def build_query_params(coordinates, what_parameters = nil)
+        artifact = parse_coordinates(coordinates)
+        @version = artifact[:version].to_s.upcase
 
-          params = what_parameters.nil? ? query : Hash.new
-          what_parameters.each {|key| params[key] = query[key] unless query[key].nil? } unless what_parameters.nil?
+        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?
 
-          params.map{|key,value| "#{key}=#{value}"}.join('&')
-        end
+        params = what_parameters.nil? ? query : {}
+        what_parameters.each { |key| params[key] = query[key] unless query[key].nil? } unless what_parameters.nil?
 
-        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)
+        params.map { |key, value| "#{key}=#{value}" }.join('&')
+      end
 
-          logger.debug "request endpoint: #{endpoint}"
+      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)
 
-          response = http.request(request)
-          response
-        end
+        logger.debug "request endpoint: #{endpoint}"
 
-        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
-        end
+        response = http.request(request)
+        response
+      end
 
-        def get_endpoint_with_params(endpoint,query_params)
-          "#{endpoint}?#{URI::DEFAULT_PARSER.escape(query_params)}"
-        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
+        http
+      end
 
+      def endpoint_with_params(endpoint, query_params)
+        "#{endpoint}?#{URI::DEFAULT_PARSER.escape(query_params)}"
+      end
     end
   end
 end