diffend-monitor 0.2.27

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Verifies voting verdicts for gems
+  module Voting
+    class << self
+      # 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, config, definition)
+        Versions::Remote
+          .call(command, config, definition)
+          .tap { |response| build_message(command, config, response) }
+      end
+
+      # @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, config, response)
+        else
+          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))
+
+        raise Diffend::Errors::HandledException
+      end
+
+      # @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
+          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
+          #{response['error']}\n
+        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
+          #{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
+          #{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

data/lib/diffend/voting/versions/local.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module Diffend
+  module Voting
+    # Module responsible for handling both local and remote gem versions
+    module Versions
+      # Module responsible for preparing current or current/new versions of gems
+      class Local
+        # Definition of a local path, if it matches it means that we are the source
+        ME_PATH = '.'
+        # Sources that we expect to match ourselves too
+        ME_SOURCES = [
+          Bundler::Source::Gemspec,
+          Bundler::Source::Path
+        ].freeze
+        # List of dependency types
+        DEPENDENCIES_TYPES = {
+          direct: 0,
+          dependency: 1
+        }.freeze
+        # List of sources types
+        SOURCES_TYPES = {
+          valid: 0,
+          multiple_primary: 1
+        }.freeze
+        # List of gem sources types
+        GEM_SOURCES_TYPES = {
+          local: 0,
+          gemfile_source: 1,
+          gemfile_git: 2,
+          gemfile_path: 3
+        }.freeze
+
+        class << self
+          # @param command [String] either install or update
+          # @param definition [Bundler::Definition] definition for your source
+          def call(command, definition)
+            Bundler.ui.silence { definition.resolve_remotely! }
+
+            instance = new(definition)
+
+            case command
+            when Commands::INSTALL, Commands::EXEC then instance.build_install
+            when Commands::UPDATE then instance.build_update
+            else
+              raise ArgumentError, "invalid command: #{command}"
+            end
+          end
+        end
+
+        # @param definition [Bundler::Definition] definition for your source
+        #
+        # @return [Hash] local dependencies
+        def initialize(definition)
+          @definition = definition
+          @direct_dependencies = Hash[definition.dependencies.map { |val| [val.name, val] }]
+          # Support case without Gemfile.lock
+          @locked_specs = @definition.locked_gems ? @definition.locked_gems.specs : []
+        end
+
+        # Build install specification
+        #
+        # @return [Hash]
+        def build_install
+          hash = build_main
+
+          @definition.specs.each do |spec|
+            next if skip?(spec.source)
+
+            locked_spec = @locked_specs.find { |s| s.name == spec.name }
+
+            hash['dependencies'][spec.name] = {
+              'platform' => build_spec_platform(spec, locked_spec),
+              'source' => build_spec_source(spec),
+              'type' => build_dependency_type(spec.name),
+              'versions' => build_versions(spec, locked_spec)
+            }
+          end
+
+          hash
+        end
+
+        # Build update specification
+        #
+        # @return [Hash]
+        def build_update
+          hash = build_main
+
+          @definition.specs.each do |spec|
+            next if skip?(spec.source)
+
+            locked_spec = @locked_specs.find { |s| s.name == spec.name }
+
+            hash['dependencies'][spec.name] = {
+              'platform' => build_spec_platform(spec, locked_spec),
+              'source' => build_spec_source(spec),
+              'type' => build_dependency_type(spec.name),
+              'versions' => build_versions(spec, locked_spec)
+            }
+          end
+
+          hash
+        end
+
+        private
+
+        # Build default specification
+        #
+        # @return [Hash]
+        def build_main
+          {
+            'dependencies' => {},
+            'sources' => build_sources,
+            'plugins' => {},
+            'platforms' => @definition.platforms.map(&:to_s)
+          }
+        end
+
+        # Build gem versions
+        #
+        # @param spec [Bundler::StubSpecification, Bundler::LazySpecification, Gem::Specification]
+        # @param locked_spec [Bundler::LazySpecification, Gem::Specification, NilClass]
+        #
+        # @return [Array<String>]
+        def build_versions(spec, locked_spec = nil)
+          if locked_spec && locked_spec.version.to_s != spec.version.to_s
+            [locked_spec.version.to_s, spec.version.to_s]
+          else
+            [spec.version.to_s]
+          end
+        end
+
+        # @param specs [Array] specs that are direct dependencies
+        # @param name [String] spec name
+        #
+        # @return [Boolean] dependency type
+        def build_dependency_type(name)
+          if @direct_dependencies.key?(name)
+            DEPENDENCIES_TYPES[:direct]
+          else
+            DEPENDENCIES_TYPES[:dependency]
+          end
+        end
+
+        # Build gem platform
+        #
+        # @param spec [Bundler::StubSpecification, Bundler::LazySpecification, Gem::Specification]
+        # @param locked_spec [Bundler::LazySpecification, Gem::Specification, NilClass]
+        #
+        # @return [String]
+        def build_spec_platform(spec, locked_spec)
+          parse_platform(
+            spec.platform || locked_spec&.platform || spec.send(:generic_local_platform)
+          )
+        end
+
+        # Parse gem platform
+        #
+        # @param platform [String, Gem::Platform]
+        #
+        # @return [String]
+        def parse_platform(platform)
+          case platform
+          when String then platform
+          when Gem::Platform then platform.os
+          end
+        end
+
+        # Build gem source type
+        #
+        # @param source [Bundler::Source] gem source type
+        #
+        # @return [Integer] internal gem source type
+        def build_spec_gem_source_type(source)
+          case source
+          when Bundler::Source::Metadata
+            GEM_SOURCES_TYPES[:local]
+          when Bundler::Source::Rubygems, Bundler::Source::Rubygems::Remote
+            GEM_SOURCES_TYPES[:gemfile_source]
+          when Bundler::Source::Git
+            GEM_SOURCES_TYPES[:gemfile_git]
+          when Bundler::Source::Path
+            GEM_SOURCES_TYPES[:gemfile_path]
+          else
+            raise ArgumentError, "unknown source #{source.class}"
+          end
+        end
+
+        # Build gem source
+        #
+        # @param spec [Bundler::StubSpecification, Bundler::LazySpecification, Gem::Specification]
+        #
+        # @return [Hash]
+        def build_spec_source(spec)
+          source = source_for_spec(spec)
+
+          {
+            'type' => build_spec_gem_source_type(source),
+            'value' => source_name_from_source(source)
+          }
+        end
+
+        # Figure out source for gem
+        #
+        # @param spec [Bundler::StubSpecification, Bundler::LazySpecification, Gem::Specification]
+        #
+        # @return [Bundler::Source] gem source type
+        def source_for_spec(spec)
+          return spec.remote if spec.remote
+
+          case spec.source
+          when Bundler::Source::Rubygems
+            spec
+              .source
+              .send(:remote_specs)
+              .search(Bundler::Dependency.new(spec.name, spec.version))
+              .last
+              .remote
+          when Bundler::Source::Metadata, Bundler::Source::Git, Bundler::Source::Path
+            spec.source
+          else
+            raise ArgumentError, "unknown source #{spec.source.class}"
+          end
+        end
+
+        # Build gem source name
+        #
+        # @param source [Bundler::Source] gem source type
+        #
+        # @return [String]
+        def source_name_from_source(source)
+          case source
+          when Bundler::Source::Metadata
+            ''
+          when Bundler::Source::Rubygems::Remote
+            source_name(source.anonymized_uri)
+          when Bundler::Source::Git
+            source.instance_variable_get(:@safe_uri)
+          when Bundler::Source::Path
+            source.path
+          else
+            raise ArgumentError, "unknown source #{source.class}"
+          end
+        end
+
+        # @param uri [Bundler::URI]
+        #
+        # @return [String]
+        def source_name(uri)
+          uri.to_s[0...-1]
+        end
+
+        # Build sources used in the Gemfile
+        #
+        # @return [Array<Hash>]
+        def build_sources
+          sources = @definition.send(:sources).rubygems_sources
+          hash = {}
+
+          sources.each do |source|
+            type = build_source_type(source.remotes)
+
+            source.remotes.each do |src|
+              hash[source_name(src)] = type
+            end
+          end
+
+          hash.map { |name, type| { 'name' => name, 'type' => type } }
+        end
+
+        # Build gem source type
+        #
+        # @param remotes [Array<Bundler::URI>]
+        #
+        # @return [Integer] internal source type
+        def build_source_type(remotes)
+          remotes.count > 1 ? SOURCES_TYPES[:multiple_primary] : SOURCES_TYPES[:valid]
+        end
+
+        # Checks if we should skip a source
+        #
+        # @param source [Bundler::Source] gem source type
+        #
+        # @return [Boolean] true if we should skip this source, false otherwise
+        def skip?(source)
+          return true if me?(source)
+
+          false
+        end
+
+        # Checks if it's a self source, this happens for repositories that are a gem
+        #
+        # @param source [Bundler::Source] gem source type
+        #
+        # @return [Boolean] true if it's a self source, false otherwise
+        def me?(source)
+          return false unless ME_SOURCES.include?(source.class)
+
+          source.path.to_s == ME_PATH
+        end
+      end
+    end
+  end
+end