diffend 0.2.19 → 0.2.27

data/lib/diffend/handle_errors/report.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Diffend
+  module HandleErrors
+    # Module responsible for reporting errors to diffend
+    module Report
+      class << self
+        # Execute request to Diffend
+        #
+        # @param exception [Exception] expection that was raised
+        # @param payload [Hash] with versions to check
+        # @param config [OpenStruct] Diffend config
+        # @param message [Symbol] message that we want to display
+        # @param report [Boolean] if true we will report the issue to diffend
+        # @param raise_exception [Boolean] if true we will raise an exception
+        #
+        # @return [Net::HTTPResponse] response from Diffend
+        def call(config:, message:, exception: nil, payload: {}, report: false, raise_exception: true)
+          exception_payload = prepare_exception_payload(exception, payload)
+
+          Bundler.ui.error(Diffend::HandleErrors::Messages::PAYLOAD_DUMP)
+          Bundler.ui.error(Diffend::HandleErrors::Messages.const_get(message.to_s.upcase))
+
+          if report
+            Diffend::Request.call(
+              build_request_object(config, exception_payload)
+            )
+          end
+
+          raise Diffend::Errors::HandledException if raise_exception
+        end
+
+        # @param config [OpenStruct] diffend config
+        # @param payload [Hash]
+        #
+        # @return [Diffend::RequestObject]
+        def build_request_object(config, payload)
+          Diffend::RequestObject.new(
+            config: config,
+            url: errors_url(config.project_id),
+            payload: payload,
+            request_method: :post
+          )
+        end
+
+        # Prepare exception payload and display it to stdout
+        #
+        # @param exception [Exception] expection that was raised
+        # @param payload [Hash] with versions to check
+        #
+        # @return [Hash]
+        def prepare_exception_payload(exception, payload)
+          Diffend::HandleErrors::BuildExceptionPayload
+            .call(exception, payload)
+            .tap(&Diffend::HandleErrors::DisplayToStdout.method(:call))
+        end
+
+        # Provides diffend errors endpoint url
+        #
+        # @param project_id [String] diffend project_id
+        #
+        # @return [String] diffend endpoint
+        def errors_url(project_id)
+          return ENV['DIFFEND_ERROR_URL'] if ENV.key?('DIFFEND_ERROR_URL')
+
+          "https://my.diffend.io/api/projects/#{project_id}/errors"
+        end
+      end
+    end
+  end
+end

data/lib/diffend/monitor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+%w[
+  build_bundler_definition
+  errors
+  config/fetcher
+  config/file_finder
+  config/validator
+  commands
+  handle_errors/messages
+  handle_errors/build_exception_payload
+  handle_errors/display_to_stdout
+  handle_errors/report
+  request_object
+  request
+  voting
+  track
+].each { |file| require "diffend/#{file}" }
+
+%w[
+  versions/local
+  versions/remote
+].each { |file| require "diffend/voting/#{file}" }
+
+Thread.new do
+  track = Diffend::Track.new
+  track.start
+end

data/lib/diffend/request.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+require 'json'
+
+module Diffend
+  # Module responsible for doing request to Diffend
+  module Request
+    # Message displayed when connection issue occured and we will retry
+    CONNECTION_MESSAGE = 'We experienced a connection issue, retrying...'
+    # List of connection exceptions
+    CONNECTION_EXCEPTIONS = [
+      Errno::ECONNRESET,
+      Errno::ENETUNREACH,
+      Errno::EHOSTUNREACH,
+      Errno::ECONNREFUSED
+    ].freeze
+    # Message displayed when timeout occured and we will retry
+    TIMEOUT_MESSAGE = 'We experienced a connection issue, retrying...'
+    # List of timeout exceptions
+    TIMEOUT_EXCEPTIONS = [
+      Net::OpenTimeout,
+      Net::ReadTimeout
+    ].freeze
+    # Message displayed when server issue occured and we will retry
+    SERVER_ERROR_MESSAGE = 'We experienced a server-side issue, retrying...'
+    # List of server issues
+    #
+    # 500 - Internal Server Error
+    # 502 - Bad Gateway
+    # 503 - Service Unavailable
+    # 504 - Gateway Timeout
+    SERVER_ERRORS = [500, 502, 503, 504].freeze
+    # Number of retries
+    RETRIES = 3
+    # Request headers
+    HEADERS = { 'Content-Type': 'application/json' }.freeze
+
+    private_constant :HEADERS
+
+    class << self
+      # Execute request
+      #
+      # @param request_object [Diffend::RequestObject]
+      #
+      # @return [Net::HTTPResponse] response from Diffend
+      def call(request_object)
+        retry_count ||= -1
+
+        build_http(request_object.url) do |http, uri|
+          response = http.request(
+            build_request(
+              uri,
+              request_object.request_method,
+              request_object.config,
+              request_object.payload
+            )
+          )
+
+          if SERVER_ERRORS.include?(response.code.to_i)
+            raise Diffend::Errors::RequestServerError, response.code.to_i
+          end
+
+          response
+        end
+      rescue Diffend::Errors::RequestServerError => e
+        retry_count += 1
+
+        retry if handle_retry(SERVER_ERROR_MESSAGE, retry_count)
+
+        Diffend::HandleErrors::Report.call(
+          exception: e,
+          payload: request_object.payload,
+          config: request_object.config,
+          message: :request_error
+        )
+      rescue *CONNECTION_EXCEPTIONS => e
+        retry_count += 1
+
+        retry if handle_retry(CONNECTION_MESSAGE, retry_count)
+
+        Diffend::HandleErrors::Report.call(
+          exception: e,
+          payload: request_object.payload,
+          config: request_object.config,
+          message: :request_error
+        )
+      rescue *TIMEOUT_EXCEPTIONS => e
+        retry_count += 1
+
+        retry if handle_retry(TIMEOUT_MESSAGE, retry_count)
+
+        Diffend::HandleErrors::Report.call(
+          exception: e,
+          payload: request_object.payload,
+          config: request_object.config,
+          message: :request_error
+        )
+      end
+
+      # Handle retry
+      #
+      # @param message [String] message we want to display
+      # @param retry_count [Integer]
+      def handle_retry(message, retry_count)
+        return false if retry_count == RETRIES
+
+        Bundler.ui.error(message)
+        sleep(exponential_backoff(retry_count))
+
+        retry_count < RETRIES
+      end
+
+      # Builds http connection object
+      #
+      # @param url [String] command endpoint url
+      def build_http(url)
+        uri = URI(url)
+
+        Net::HTTP.start(
+          uri.host,
+          uri.port,
+          use_ssl: uri.scheme == 'https',
+          verify_mode: OpenSSL::SSL::VERIFY_NONE,
+          open_timeout: 5,
+          read_timeout: 5
+        ) { |http| yield(http, uri) }
+      end
+
+      # Build http post request and assigns headers and payload
+      #
+      # @param uri [URI::HTTPS]
+      # @param request_method [Symbol]
+      # @param config [OpenStruct] Diffend config
+      # @param payload [Hash] with versions to check
+      #
+      # @return [Net::HTTP::Post, Net::HTTP::Put]
+      def build_request(uri, request_method, config, payload)
+        pick_request_method(request_method)
+          .new(uri.request_uri, HEADERS)
+          .tap { |request| assign_auth(request, config) }
+          .tap { |request| assign_payload(request, payload) }
+      end
+
+      # Pick request method
+      #
+      # @param request_method [Symbol]
+      #
+      # @return [Net::HTTP::Post, Net::HTTP::Put]
+      def pick_request_method(request_method)
+        case request_method
+        when :post
+          Net::HTTP::Post
+        when :put
+          Net::HTTP::Put
+        end
+      end
+
+      # Assigns basic authorization if provided in the config
+      #
+      # @param request [Net::HTTP::Post] prepared http post
+      # @param config [OpenStruct] Diffend config
+      def assign_auth(request, config)
+        return unless config
+        return unless config.shareable_id
+        return unless config.shareable_key
+
+        request.basic_auth(config.shareable_id, config.shareable_key)
+      end
+
+      # Assigns payload as json
+      #
+      # @param request [Net::HTTP::Post] prepared http post
+      # @param payload [Hash] with versions to check
+      def assign_payload(request, payload)
+        request.body = JSON.dump(payload: payload)
+      end
+
+      def exponential_backoff(retry_count)
+        2**(retry_count + 1)
+      end
+    end
+  end
+end

data/lib/diffend/request_object.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Class responsible for preparing diffend request object
+  RequestObject = Struct.new(:config, :url, :payload, :request_method, keyword_init: true)
+end

data/lib/diffend/track.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Track what is run in production
+  class Track
+    # Time that we want to wait between track requests
+    TRACK_SLEEP = 15
+    # Time that we want to wait before we retry
+    RETRY_SLEEP = 15
+
+    # Initialize tracking
+    def initialize
+      @mutex = Mutex.new
+      @config = fetch_config
+    end
+
+    # Start tracking
+    def start
+      response = exec_request
+
+      perform(response['id'])
+    rescue Diffend::Errors::HandledException
+      sleep(RETRY_SLEEP)
+
+      retry
+    rescue StandardError => e
+      Diffend::HandleErrors::Report.call(
+        exception: e,
+        config: @config,
+        message: :unhandled_exception,
+        report: true,
+        raise_exception: false
+      )
+
+      sleep(RETRY_SLEEP)
+
+      retry
+    end
+
+    # @param request_id [String]
+    def perform(request_id)
+      loop do
+        @mutex.synchronize do
+          track_request(request_id)
+        end
+
+        sleep(TRACK_SLEEP)
+      end
+    end
+
+    # Perform an exec request
+    def exec_request
+      Diffend::Voting.call(
+        Diffend::Commands::EXEC,
+        @config,
+        Diffend::BuildBundlerDefinition.call(
+          Diffend::Commands::EXEC,
+          Bundler.default_gemfile,
+          Bundler.default_lockfile
+        )
+      )
+    end
+
+    # Perform a track request
+    #
+    # @param request_id [String]
+    def track_request(request_id)
+      Diffend::Request.call(
+        build_request_object(request_id)
+      )
+    end
+
+    # @param request_id [String]
+    #
+    # @return [Diffend::RequestObject]
+    def build_request_object(request_id)
+      Diffend::RequestObject.new(
+        config: @config,
+        url: track_url(@config.project_id, request_id),
+        payload: { id: request_id }.freeze,
+        request_method: :put
+      ).freeze
+    end
+
+    # Fetch diffend config file
+    #
+    # @return [OpenStruct, nil] configuration object
+    #
+    # @raise [Errors::MissingConfigurationFile] when no config file
+    def fetch_config
+      Config::Fetcher.call(
+        File.expand_path('..', Bundler.bin_path)
+      )
+    end
+
+    # @param project_id [String] diffend project_id
+    # @param request_id [String]
+    #
+    # @return [String]
+    def track_url(project_id, request_id)
+      "https://my.diffend.io/api/projects/#{project_id}/bundle/#{request_id}/track"
+    end
+  end
+end

data/lib/diffend/voting.rb

@@ -7,45 +7,69 @@ module Diffend
       # Build verdict
       #
       # @param command [String] either install or update
+      # @param config [OpenStruct] diffend config
       # @param definition [Bundler::Definition] definition for your source
-      def call(command, definition)
+      def call(command, config, definition)
         Versions::Remote
-          .call(command, definition)
-          .tap { |response| build_message(command, response) }
+          .call(command, config, definition)
+          .tap { |response| build_message(command, config, response) }
       end
 
-      def build_message(command, response)
+      # @param command [String] either install or update
+      # @param config [OpenStruct] diffend config
+      # @param response [Hash] response from diffend API
+      def build_message(command, config, response)
         if response.key?('error')
           build_error(response)
         elsif response.key?('action')
-          build_verdict(command, response)
+          build_verdict(command, config, response)
         else
-          raise UnsupportedResponse, response['action']
+          Diffend::HandleErrors::Report.call(
+            config: config,
+            message: :unsupported_response,
+            payload: response,
+            report: true
+          )
         end
       end
 
+      # @param response [Hash] response from diffend API
       def build_error(response)
         build_error_message(response)
           .tap(&Bundler.ui.method(:error))
 
-        exit 1
+        raise Diffend::Errors::HandledException
       end
 
-      def build_verdict(command, response)
+      # @param command [String] either install or update
+      # @param config [OpenStruct] diffend config
+      # @param response [Hash] response from diffend API
+      def build_verdict(command, config, response)
         case response['action']
         when 'allow'
           build_allow_message(command, response)
             .tap(&Bundler.ui.method(:confirm))
+        when 'warn'
+          build_warn_message(command, response)
+            .tap(&Bundler.ui.method(:warn))
         when 'deny'
           build_deny_message(command, response)
             .tap(&Bundler.ui.method(:error))
 
           exit 1
         else
-          raise UnsupportedAction, response['action']
+          Diffend::HandleErrors::Report.call(
+            config: config,
+            message: :unsupported_verdict,
+            payload: response,
+            report: true
+          )
         end
       end
 
+      # @param response [Hash] response from diffend API
+      #
+      # @return [String]
       def build_error_message(response)
         <<~MSG
           \nDiffend returned an error for your request.\n
@@ -53,21 +77,56 @@ module Diffend
         MSG
       end
 
+      # @param command [String] either install or update
+      # @param response [Hash] response from diffend API
+      #
+      # @return [String]
       def build_allow_message(command, response)
         <<~MSG
-          \nDiffend reported an allow verdict for #{command} command for this project.\n
-          All of our #{response['allows_count'] + response['denies_count']} checks succeeded.\n
+          #{build_message_header('an allow', command)}
+          #{build_message_info(response)}\n
           #{response['review_url']}\n
         MSG
       end
 
+      # @param command [String] either install or update
+      # @param response [Hash] response from diffend API
+      #
+      # @return [String]
+      def build_warn_message(command, response)
+        <<~MSG
+          #{build_message_header('a warn', command)}
+          #{build_message_info(response)} Please go to the url below and review the issues.\n
+          #{response['review_url']}\n
+        MSG
+      end
+
+      # @param command [String] either install or update
+      # @param response [Hash] response from diffend API
+      #
+      # @return [String]
       def build_deny_message(command, response)
         <<~MSG
-          \nDiffend reported a deny verdict for #{command} command for this project.\n
-          #{response['denies_count']} out of our #{response['allows_count'] + response['denies_count']} checks failed. Please go to the url below and review the issues.\n
+          #{build_message_header('a deny', command)}
+          #{build_message_info(response)} Please go to the url below and review the issues.\n
           #{response['review_url']}\n
         MSG
       end
+
+      # @param type [String] verdict type
+      # @param command [String] either install or update
+      #
+      # @return [String]
+      def build_message_header(type, command)
+        "\nDiffend reported #{type} verdict for #{command} command for this project."
+      end
+
+      # @param response [Hash] response from diffend API
+      #
+      # @return [String]
+      def build_message_info(response)
+        "\nQuality score: #{response['quality_score']}, allows: #{response['allows_count']}, warnings: #{response['warns_count']}, denies: #{response['denies_count']}."
+      end
     end
   end
 end