codeclimate 0.69.0 → 0.70.0

data/lib/cc/analyzer.rb

@@ -2,17 +2,14 @@ require "yaml"
 
 module CC
   module Analyzer
+    autoload :Bridge, "cc/analyzer/bridge"
     autoload :CompositeContainerListener, "cc/analyzer/composite_container_listener"
-    autoload :Config, "cc/analyzer/config"
     autoload :Container, "cc/analyzer/container"
     autoload :ContainerListener, "cc/analyzer/container_listener"
     autoload :Engine, "cc/analyzer/engine"
     autoload :EngineOutput, "cc/analyzer/engine_output"
     autoload :EngineOutputFilter, "cc/analyzer/engine_output_filter"
     autoload :EngineOutputOverrider, "cc/analyzer/engine_output_overrider"
-    autoload :EngineRegistry, "cc/analyzer/engine_registry"
-    autoload :EnginesConfigBuilder, "cc/analyzer/engines_config_builder"
-    autoload :EnginesRunner, "cc/analyzer/engines_runner"
     autoload :Filesystem, "cc/analyzer/filesystem"
     autoload :Formatters, "cc/analyzer/formatters"
     autoload :Issue, "cc/analyzer/issue"
@@ -21,12 +18,16 @@ module CC
     autoload :IssueValidator, "cc/analyzer/issue_validator"
     autoload :LocationDescription, "cc/analyzer/location_description"
     autoload :LoggingContainerListener, "cc/analyzer/logging_container_listener"
+    autoload :Measurement, "cc/analyzer/measurement"
+    autoload :MeasurementValidations, "cc/analyzer/measurement_validations"
+    autoload :MeasurementValidator, "cc/analyzer/measurement_validator"
     autoload :MountedPath, "cc/analyzer/mounted_path"
     autoload :RaisingContainerListener, "cc/analyzer/raising_container_listener"
     autoload :SourceBuffer, "cc/analyzer/source_buffer"
     autoload :SourceExtractor, "cc/analyzer/source_extractor"
     autoload :SourceFingerprint, "cc/analyzer/source_fingerprint"
     autoload :StatsdContainerListener, "cc/analyzer/statsd_container_listener"
+    autoload :Validator, "cc/analyzer/validator"
 
     class DummyStatsd
       def method_missing(*)

data/lib/cc/analyzer/bridge.rb

@@ -0,0 +1,106 @@
+module CC
+  module Analyzer
+    # The shared interface, invoked by Builder or CLI::Analyze
+    #
+    # Input:
+    #   - config
+    #     - engines
+    #     - exclude_patterns
+    #     - development?
+    #     - analysis_paths
+    #   - formatter
+    #     - started
+    #     - engine_running
+    #     - finished
+    #     - close
+    #   - listener
+    #     - started(engine, details)
+    #     - finished(engine, details, result)
+    #   - registry
+    #
+    # Only raises if Listener raises
+    #
+    class Bridge
+      def initialize(config:, formatter:, listener:, registry:)
+        @config = config
+        @formatter = formatter
+        @listener = listener
+        @registry = registry
+      end
+
+      def run
+        formatter.started
+
+        config.engines.each do |engine|
+          next unless engine.enabled?
+
+          formatter.engine_running(engine) do
+            result = nil
+            engine_details = nil
+
+            begin
+              engine_details = registry.fetch_engine_details(
+                engine,
+                development: config.development?,
+              )
+              listener.started(engine, engine_details)
+              result = run_engine(engine, engine_details)
+            rescue CC::EngineRegistry::EngineDetailsNotFoundError => ex
+              result = Container::Result.skipped(ex)
+            end
+
+            listener.finished(engine, engine_details, result)
+            result
+          end
+        end
+
+        formatter.finished
+      ensure
+        formatter.close
+      end
+
+      private
+
+      attr_reader :config, :formatter, :listener, :registry
+
+      def run_engine(engine, engine_details)
+        # Analyzer::Engine doesn't have the best interface, but we're limiting
+        # our refactors for now.
+        Engine.new(
+          engine.name,
+          {
+            "image" => engine_details.image,
+            "command" => engine_details.command,
+            "memory" => engine_details.memory,
+          },
+          engine.config.merge(
+            "channel" => engine.channel,
+            "include_paths" => engine_workspace(engine).paths,
+          ),
+          engine.container_label,
+        ).run(formatter)
+      end
+
+      def engine_workspace(engine)
+        if engine.exclude_patterns.any?
+          workspace.clone.tap do |engine_workspace|
+            engine_workspace.remove(engine.exclude_patterns)
+          end
+        else
+          workspace
+        end
+      end
+
+      def workspace
+        @workspace ||= Workspace.new.tap do |workspace|
+          workspace.add(config.analysis_paths)
+
+          unless config.analysis_paths.any?
+            workspace.remove([".git"])
+            workspace.remove(config.exclude_patterns)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/composite_container_listener.rb

@@ -5,16 +5,12 @@ module CC
         @listeners = listeners
       end
 
-      def started(data)
-        listeners.each { |listener| listener.started(data) }
+      def started(*args)
+        listeners.each { |listener| listener.started(*args) }
       end
 
-      def timed_out(data)
-        listeners.each { |listener| listener.timed_out(data) }
-      end
-
-      def finished(data)
-        listeners.each { |listener| listener.finished(data) }
+      def finished(*args)
+        listeners.each { |listener| listener.finished(*args) }
       end
 
       private

data/lib/cc/analyzer/container.rb

@@ -1,42 +1,47 @@
 require "posix/spawn"
 require "thread"
 
+require "cc/analyzer/container/result"
+
 module CC
   module Analyzer
+    #
+    # Running an abstract docker container
+    #
+    # Input:
+    #   - image
+    #   - name
+    #   - command (Optional)
+    #
+    # Output:
+    #   - Result
+    #     - exit_status
+    #     - timed_out?
+    #     - duration
+    #     - maximum_output_exceeded?
+    #     - output_byte_count
+    #     - stderr
+    #
+    # Never raises (unless broken)
+    #
     class Container
-      ContainerData = Struct.new(
-        :image, # image used to create the container
-        :name, # name given to the container when created
-        :duration, # duration, for a finished event
-        :status, # status, for a finished event
-        :stderr, # stderr, for a finished event
-      )
-      ImageRequired = Class.new(StandardError)
-      Result = Struct.new(
-        :exit_status,
-        :timed_out?,
-        :duration,
-        :maximum_output_exceeded?,
-        :output_byte_count,
-        :stderr,
-      )
-
       DEFAULT_TIMEOUT = 15 * 60 # 15m
       DEFAULT_MAXIMUM_OUTPUT_BYTES = 500_000_000
 
-      def initialize(image:, name:, command: nil, listener: ContainerListener.new)
-        raise ImageRequired if image.blank?
+      def initialize(image:, name:, command: nil)
         @image = image
         @name = name
         @command = command
-        @listener = listener
-        @output_delimeter = "\n"
-        @on_output = ->(*) {}
         @timed_out = false
         @maximum_output_exceeded = false
+        @stdout_io = StringIO.new
         @stderr_io = StringIO.new
         @output_byte_count = 0
         @counter_mutex = Mutex.new
+
+        # By default accumulate and include stdout in result
+        @output_delimeter = "\n"
+        @on_output = ->(output) { @stdout_io.puts(output) }
       end
 
       def on_output(delimeter = "\n", &block)
@@ -46,10 +51,9 @@ module CC
 
       def run(options = [])
         started = Time.now
-        @listener.started(container_data)
 
         command = docker_run_command(options)
-        CLI.debug("docker run: #{command.inspect}")
+        Analyzer.logger.debug("docker run: #{command.inspect}")
         pid, _, out, err = POSIX::Spawn.popen4(*command)
 
         @t_out = read_stdout(out)
@@ -70,21 +74,22 @@ module CC
         # will unblock with the correct value in @timed_out
         [@t_out, @t_err].each(&:join)
 
-        if @timed_out
-          duration = timeout * 1000
-          @listener.timed_out(container_data(duration: duration))
-        else
-          duration = ((Time.now - started) * 1000).round
-          @listener.finished(container_data(duration: duration, status: @status))
-        end
+        duration =
+          if @timed_out
+            timeout * 1000
+          else
+            ((Time.now - started) * 1000).round
+          end
 
         Result.new(
-          @status && @status.exitstatus,
-          @timed_out,
-          duration,
-          @maximum_output_exceeded,
-          output_byte_count,
-          @stderr_io.string,
+          container_name: @name,
+          duration: duration,
+          exit_status: @status && @status.exitstatus,
+          maximum_output_exceeded: @maximum_output_exceeded,
+          output_byte_count: output_byte_count,
+          stderr: @stderr_io.string,
+          stdout: @stdout_io.string,
+          timed_out: @timed_out,
         )
       ensure
         kill_reader_threads
@@ -117,6 +122,7 @@ module CC
             out.each_line(@output_delimeter) do |chunk|
               output = chunk.chomp(@output_delimeter)
 
+              Analyzer.logger.debug("engine stdout: #{output}")
               @on_output.call(output)
               check_output_bytes(output.bytesize)
             end
@@ -130,6 +136,7 @@ module CC
         Thread.new do
           begin
             err.each_line do |line|
+              Analyzer.logger.debug("engine stderr: #{line.chomp}")
               @stderr_io.write(line)
               check_output_bytes(line.bytesize)
             end
@@ -166,10 +173,6 @@ module CC
         end
       end
 
-      def container_data(duration: nil, status: nil)
-        ContainerData.new(@image, @name, duration, status, @stderr_io.string)
-      end
-
       def kill_reader_threads
         @t_out.kill if @t_out
         @t_err.kill if @t_err

data/lib/cc/analyzer/container/result.rb

@@ -0,0 +1,74 @@
+module CC
+  module Analyzer
+    class Container
+      class Result
+        attr_reader \
+          :container_name,
+          :duration,
+          :exit_status,
+          :output_byte_count,
+          :stderr,
+          :stdout
+
+        def initialize(
+          container_name: "",
+          duration: 0,
+          exit_status: 0,
+          maximum_output_exceeded: false,
+          output_byte_count: 0,
+          skipped: false,
+          stderr: "",
+          stdout: "",
+          timed_out: false
+        )
+          @container_name = container_name
+          @duration = duration
+          @exit_status = exit_status
+          @maximum_output_exceeded = maximum_output_exceeded
+          @output_byte_count = output_byte_count
+          @skipped = skipped
+          @stderr = stderr
+          @stdout = stdout
+          @timed_out = timed_out
+        end
+
+        def self.skipped(ex)
+          new(
+            exit_status: 0,
+            skipped: true,
+            stderr: ex.message,
+          )
+        end
+
+        def merge_from_exception(ex)
+          self.exit_status = 99
+          self.stderr = ex.message
+          self
+        end
+
+        def timed_out?
+          @timed_out
+        end
+
+        def maximum_output_exceeded?
+          @maximum_output_exceeded
+        end
+
+        def errored?
+          timed_out? ||
+            maximum_output_exceeded? ||
+            exit_status.nil? ||
+            exit_status.nonzero?
+        end
+
+        def skipped?
+          @skipped
+        end
+
+        private
+
+        attr_writer :exit_status, :stderr
+      end
+    end
+  end
+end

data/lib/cc/analyzer/container_listener.rb

@@ -1,14 +1,9 @@
 module CC
   module Analyzer
     class ContainerListener
-      def started(_data)
-      end
+      def started(_engine, _details); end
 
-      def timed_out(_data)
-      end
-
-      def finished(_data)
-      end
+      def finished(_engine, _details, _result); end
     end
   end
 end

data/lib/cc/analyzer/engine.rb

@@ -2,67 +2,73 @@ require "securerandom"
 
 module CC
   module Analyzer
+    #
+    # Running specifically an Engine container
+    #
+    # Input:
+    #   - name
+    #   - metadata
+    #     - image
+    #     - command (optional)
+    #   - config (becomes /config.json)
+    #   - label
+    #   - io (to write filtered, validated output)
+    #
+    # Output:
+    #   - Container::Result
+    #
     class Engine
-      EngineFailure = Class.new(StandardError)
-      EngineTimeout = Class.new(StandardError)
+      Error = Class.new(StandardError)
 
-      attr_reader :name
-
-      DEFAULT_MEMORY_LIMIT = 512_000_000.freeze
-
-      def initialize(name, metadata, code_path, config, label)
+      def initialize(name, metadata, config, label)
         @name = name
         @metadata = metadata
-        @code_path = code_path
         @config = config
         @label = label.to_s
+        @error = nil
       end
 
-      def run(stdout_io, container_listener)
-        composite_listener = CompositeContainerListener.new(
-          container_listener,
-          LoggingContainerListener.new(qualified_name, Analyzer.logger),
-          StatsdContainerListener.new(qualified_name.tr(":", "."), Analyzer.statsd),
-          RaisingContainerListener.new(qualified_name, EngineFailure, EngineTimeout),
-        )
+      def run(io)
+        write_config_file
 
         container = Container.new(
-          image: @metadata["image"],
-          command: @metadata["command"],
+          image: metadata.fetch("image"),
+          command: metadata["command"],
           name: container_name,
-          listener: composite_listener,
         )
 
-        container.on_output("\0") do |raw_output|
-          CLI.debug("#{qualified_name} engine output: #{raw_output.strip}")
-          output = EngineOutput.new(raw_output)
-
-          unless output.valid?
-            stdout_io.failed("#{qualified_name} produced invalid output: #{output.error[:message]}")
-            container.stop
-          end
-
-          unless output_filter.filter?(output)
-            stdout_io.write(output_overrider.apply(output).to_json) || container.stop
-          end
+        container.on_output("\0") do |output|
+          handle_output(container, io, output)
         end
 
-        write_config_file
-        CLI.debug("#{qualified_name} engine config: #{config_file.read}")
         container.run(container_options).tap do |result|
-          CLI.debug("#{qualified_name} engine stderr: #{result.stderr}")
+          result.merge_from_exception(error) if error.present?
         end
-      rescue Container::ImageRequired
-        # Provide a clearer message given the context we have
-        message = "Unable to find an image for #{qualified_name}."
-        message << " Available channels: #{@metadata["channels"].keys.inspect}."
-        raise Container::ImageRequired, message
       ensure
         delete_config_file
       end
 
       private
 
+      attr_reader :name, :metadata
+      attr_accessor :error
+
+      def handle_output(container, io, raw_output)
+        output = EngineOutput.new(name, raw_output)
+
+        return if output_filter.filter?(output)
+
+        unless output.valid?
+          self.error = Error.new("engine produced invalid output: #{output.error}")
+          container.stop("output invalid")
+        end
+
+        unless io.write(output_overrider.apply(output).to_json)
+          self.error = Error.new("#{io.class}#write returned false, indicating an error")
+          container.stop("output error")
+        end
+      end
+
       def qualified_name
         "#{name}:#{@config.fetch("channel", "stable")}"
       end
@@ -71,11 +77,12 @@ module CC
         [
           "--cap-drop", "all",
           "--label", "com.codeclimate.label=#{@label}",
-          "--memory", memory_limit,
+          "--log-driver", "none",
+          "--memory", metadata["memory"].to_s,
           "--memory-swap", "-1",
           "--net", "none",
           "--rm",
-          "--volume", "#{@code_path}:/code:ro",
+          "--volume", "#{code.host_path}:/code:ro",
           "--volume", "#{config_file.host_path}:/config.json:ro",
           "--user", "9000:9000"
         ]
@@ -86,6 +93,8 @@ module CC
       end
 
       def write_config_file
+        @config["debug"] = ENV["CODECLIMATE_DEBUG"]
+        Analyzer.logger.debug "/config.json content: #{@config.inspect}"
         config_file.write(@config.to_json)
       end
 
@@ -93,6 +102,10 @@ module CC
         config_file.delete if config_file.file?
       end
 
+      def code
+        @code ||= MountedPath.code
+      end
+
       def config_file
         @config_file ||= MountedPath.tmp.join(SecureRandom.uuid)
       end
@@ -104,11 +117,6 @@ module CC
       def output_overrider
         @output_overrider ||= EngineOutputOverrider.new(@config)
       end
-
-      # Memory limit for a running engine in bytes
-      def memory_limit
-        (ENV["ENGINE_MEMORY_LIMIT_BYTES"] || DEFAULT_MEMORY_LIMIT).to_s
-      end
     end
   end
 end