codeclimate 0.2.7 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89202f61cd85559f4e0531916fa59183a2ea9a01
-  data.tar.gz: 1d7073a763b74d1813b28d2b892f43c2e3ffeced
+  metadata.gz: b5b6caa0a6dc7642c6e5abb6533c8c24c7bd49f4
+  data.tar.gz: 98bb65ce704a03ba8ed98a4ff697d2a424ef0fd3
 SHA512:
-  metadata.gz: 2ec65cca81cf694dd51200dc44367bba0044afca7c48f90f5305b1ba8685f29da5b3c993f98350b36b64832321fd4521c017e8b09e75e8d11eb09c4c6d026251
-  data.tar.gz: 1833d8881ea7881a34bc9ed565af19fee320755b1b7a739610dcecb00f845ec404fb8229a84e7d40c373eccacc64c2fccde076e37533275bccc0a5879d1c3a82
+  metadata.gz: 17ecabe1ace73fbd5f37c83a78b2bd1e5a683aa1b518684a33ebd8885246c8bb289f804c692d63bd443b35ef1f0f576cfbc382691c6c89368516c8aa8a6edc1c
+  data.tar.gz: f62c7be59d492698e22496c265b4f6c3c9993100ec861bce94227f9e4ffceda8bc8809ba2c75be9fae94a3d7d355c5b167ba30119e03ee42835d0e80b77e6906

data/lib/cc/analyzer.rb

@@ -2,6 +2,7 @@ module CC
   module Analyzer
     autoload :Accumulator,        "cc/analyzer/accumulator"
     autoload :Config,             "cc/analyzer/config"
+    autoload :Container,          "cc/analyzer/container"
     autoload :Engine,             "cc/analyzer/engine"
     autoload :EngineClient,       "cc/analyzer/engine_client"
     autoload :EngineOutputFilter, "cc/analyzer/engine_output_filter"
@@ -12,6 +13,7 @@ module CC
     autoload :IssueSorter,        "cc/analyzer/issue_sorter"
     autoload :LocationDescription,"cc/analyzer/location_description"
     autoload :NullConfig,         "cc/analyzer/null_config"
+    autoload :NullContainerLog,   "cc/analyzer/null_container_log"
     autoload :PathPatterns,       "cc/analyzer/path_patterns"
     autoload :SourceBuffer,       "cc/analyzer/source_buffer"
     autoload :UnitName,           "cc/analyzer/unit_name"

data/lib/cc/analyzer/container.rb

@@ -0,0 +1,98 @@
+require "posix/spawn"
+
+module CC
+  module Analyzer
+    class Container
+      DEFAULT_TIMEOUT = 15 * 60 # 15m
+
+      def initialize(
+        image:,
+        name:,
+        command: nil,
+        log: NullContainerLog.new,
+        timeout: DEFAULT_TIMEOUT
+      )
+        @image = image
+        @name = name
+        @command = command
+        @log = log
+        @timeout = timeout
+
+        @output_delimeter = "\n"
+        @on_output = ->(*) { }
+
+        @timed_out = false
+        @stderr_io = StringIO.new
+      end
+
+      def on_output(delimeter = "\n", &block)
+        @output_delimeter = delimeter
+        @on_output = block
+      end
+
+      def run(options = [])
+        @log.started(@image, @name)
+
+        pid, _, out, err = POSIX::Spawn.popen4(*docker_run_command(options))
+
+        t_out = read_stdout(out)
+        t_err = read_stderr(err)
+        t_timeout = timeout_thread(pid)
+
+        _, status = Process.waitpid2(pid)
+
+        @log.finished(@image, @name, status, @stderr_io.string)
+
+        t_timeout.kill
+      ensure
+        t_timeout.kill if t_timeout
+
+        if @timed_out
+          @log.timed_out(@image, @name, @timeout)
+          t_out.kill if t_out
+          t_err.kill if t_err
+        else
+          t_out.join if t_out
+          t_err.join if t_err
+        end
+      end
+
+      private
+
+      def docker_run_command(options)
+        [
+          "docker", "run",
+          "--rm",
+          "--name", @name,
+          options,
+          @image,
+          @command,
+        ].flatten.compact
+      end
+
+      def read_stdout(out)
+        Thread.new do
+          out.each_line(@output_delimeter) do |chunk|
+            output = chunk.chomp(@output_delimeter)
+
+            @on_output.call(output)
+          end
+        end
+      end
+
+      def read_stderr(err)
+        Thread.new do
+          err.each_line { |line| @stderr_io.write(line) }
+        end
+      end
+
+      def timeout_thread(pid)
+        Thread.new do
+          sleep @timeout
+          @timed_out = true
+          Process.kill("KILL", pid)
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/engine.rb

@@ -1,12 +1,11 @@
-require "posix/spawn"
 require "securerandom"
 
 module CC
   module Analyzer
     class Engine
-      attr_reader :name
+      autoload :ContainerLog, "cc/analyzer/engine/container_log"
 
-      TIMEOUT = 15 * 60 # 15m
+      attr_reader :name
 
       def initialize(name, metadata, code_path, config, label)
         @name = name
@@ -16,88 +15,40 @@ module CC
         @label = label.to_s
       end
 
-      def run(stdout_io, stderr_io = StringIO.new)
-        timed_out = false
-        pid, _, out, err = POSIX::Spawn.popen4(*docker_run_command)
-        Analyzer.statsd.increment("cli.engines.started")
-
-        t_out = Thread.new do
-          out.each_line("\0") do |chunk|
-            output = chunk.chomp("\0")
-
-            unless output_filter.filter?(output)
-              stdout_io.write(output)
-            end
-          end
-        end
-
-        t_err = Thread.new do
-          err.each_line do |line|
-            if stderr_io
-              stderr_io.write(line)
-            end
+      def run(stdout_io:, container_log: NullContainerLog.new)
+        container = Container.new(
+          image: @metadata["image"],
+          command: @metadata["command"],
+          name: container_name,
+          log: ContainerLog.new(name, container_log)
+        )
+
+        container.on_output("\0") do |output|
+          unless output_filter.filter?(output)
+            stdout_io.write(output)
           end
         end
 
-        t_timeout = Thread.new do
-          sleep TIMEOUT
-          run_command("docker kill #{container_name} || true")
-          timed_out = true
-        end
-
-        pid, status = Process.waitpid2(pid)
-        t_timeout.kill
-
-        Analyzer.statsd.increment("cli.engines.finished")
-
-        if timed_out
-          Analyzer.statsd.increment("cli.engines.result.error")
-          Analyzer.statsd.increment("cli.engines.result.error.timeout")
-          Analyzer.statsd.increment("cli.engines.names.#{name}.result.error")
-          Analyzer.statsd.increment("cli.engines.names.#{name}.result.error.timeout")
-          raise EngineTimeout, "engine #{name} ran past #{TIMEOUT} seconds and was killed"
-        elsif status.success?
-          Analyzer.statsd.increment("cli.engines.names.#{name}.result.success")
-          Analyzer.statsd.increment("cli.engines.result.success")
-        else
-          Analyzer.statsd.increment("cli.engines.names.#{name}.result.error")
-          Analyzer.statsd.increment("cli.engines.result.error")
-          raise EngineFailure, "engine #{name} failed with status #{status.exitstatus} and stderr \n#{stderr_io.string}"
-        end
-      ensure
-        t_timeout.kill if t_timeout
-
-        if timed_out
-          t_out.kill if t_out
-          t_err.kill if t_err
-        else
-          t_out.join if t_out
-          t_err.join if t_err
-        end
+        container.run(container_options)
       end
 
       private
 
-      def container_name
-        @container_name ||= "cc-engines-#{name}-#{SecureRandom.uuid}"
-      end
-
-      def docker_run_command
+      def container_options
         [
-          "docker", "run",
-          "--rm",
           "--cap-drop", "all",
           "--label", "com.codeclimate.label=#{@label}",
-          "--name", container_name,
           "--memory", 512_000_000.to_s, # bytes
           "--memory-swap", "-1",
           "--net", "none",
           "--volume", "#{@code_path}:/code:ro",
           "--volume", "#{config_file}:/config.json:ro",
           "--user", "9000:9000",
-          @metadata["image"],
-          @metadata["command"], # String or Array
-        ].flatten.compact
+        ]
+      end
+
+      def container_name
+        @container_name ||= "cc-engines-#{name}-#{SecureRandom.uuid}"
       end
 
       def config_file
@@ -106,21 +57,9 @@ module CC
         path
       end
 
-      def run_command(command)
-        spawn = POSIX::Spawn::Child.new(command)
-
-        unless spawn.status.success?
-          raise CommandFailure, "command '#{command}' failed with status #{spawn.status.exitstatus} and output #{spawn.err}"
-        end
-      end
-
       def output_filter
         @output_filter ||= EngineOutputFilter.new(@config)
       end
-
-      CommandFailure = Class.new(StandardError)
-      EngineFailure = Class.new(StandardError)
-      EngineTimeout = Class.new(StandardError)
     end
   end
 end

data/lib/cc/analyzer/engine/container_log.rb

@@ -0,0 +1,48 @@
+module CC
+  module Analyzer
+    class Engine
+      EngineFailure = Class.new(StandardError)
+      EngineTimeout = Class.new(StandardError)
+
+      class ContainerLog
+        def initialize(name, inner_log)
+          @name = name
+          @inner_log = inner_log
+        end
+
+        def started(image, name)
+          @inner_log.started(image, name)
+
+          Analyzer.statsd.increment("cli.engines.started")
+        end
+
+        def timed_out(image, name, timeout)
+          @inner_log.timed_out(image, name, timeout)
+
+          Analyzer.statsd.increment("cli.engines.result.error")
+          Analyzer.statsd.increment("cli.engines.result.error.timeout")
+          Analyzer.statsd.increment("cli.engines.names.#{@name}.result.error")
+          Analyzer.statsd.increment("cli.engines.names.#{@name}.result.error.timeout")
+
+          raise EngineTimeout, "engine #{@name} ran past #{timeout} seconds and was killed"
+        end
+
+        def finished(image, name, status, stderr)
+          @inner_log.finished(image, name, status, stderr)
+
+          Analyzer.statsd.increment("cli.engines.finished")
+
+          if status.success?
+            Analyzer.statsd.increment("cli.engines.result.success")
+            Analyzer.statsd.increment("cli.engines.names.#{@name}.result.success")
+          else
+            Analyzer.statsd.increment("cli.engines.result.error")
+            Analyzer.statsd.increment("cli.engines.names.#{@name}.result.error")
+
+            raise EngineFailure, "engine #{@name} failed with status #{status.exitstatus} and stderr \n#{stderr}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cc/analyzer/engines_runner.rb

@@ -14,14 +14,14 @@ module CC
         @container_label = container_label
       end
 
-      def run
+      def run(container_log = NullContainerLog.new)
         raise NoEnabledEngines if engines.empty?
 
         Analyzer.logger.info("running #{engines.size} engines")
 
         @formatter.started
 
-        engines.each { |engine| run_engine(engine) }
+        engines.each { |engine| run_engine(engine, container_log) }
 
         @formatter.finished
       ensure
@@ -30,13 +30,16 @@ module CC
 
       private
 
-      def run_engine(engine)
+      def run_engine(engine, container_log)
         Analyzer.logger.info("starting engine #{engine.name}")
 
         Analyzer.statsd.time("engines.time") do
           Analyzer.statsd.time("engines.names.#{engine.name}.time") do
             @formatter.engine_running(engine) do
-              engine.run(@formatter)
+              engine.run(
+                stdout_io: @formatter,
+                container_log: container_log
+              )
             end
           end
         end
@@ -80,7 +83,15 @@ module CC
       end
 
       def exclude_paths
-        PathPatterns.new(@config.exclude_paths || []).expanded
+        PathPatterns.new(@config.exclude_paths || []).expanded + gitignore_paths
+      end
+
+      def gitignore_paths
+        if File.exist?(".gitignore")
+          `git ls-files --others -i -z --exclude-from .gitignore`.split("\0")
+        else
+          []
+        end
       end
     end
   end

data/lib/cc/analyzer/null_container_log.rb

@@ -0,0 +1,14 @@
+module CC
+  module Analyzer
+    class NullContainerLog
+      def started(_image, _name)
+      end
+
+      def timed_out(_image, _name, _seconds)
+      end
+
+      def finished(_image, _name, _status, _stderr)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codeclimate
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.9
 platform: ruby
 authors:
 - Code Climate
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-03 00:00:00.000000000 Z
+date: 2015-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -191,7 +191,9 @@ files:
 - config/engines.yml
 - lib/cc/analyzer.rb
 - lib/cc/analyzer/config.rb
+- lib/cc/analyzer/container.rb
 - lib/cc/analyzer/engine.rb
+- lib/cc/analyzer/engine/container_log.rb
 - lib/cc/analyzer/engine_output_filter.rb
 - lib/cc/analyzer/engine_registry.rb
 - lib/cc/analyzer/engines_runner.rb
@@ -204,6 +206,7 @@ files:
 - lib/cc/analyzer/issue_sorter.rb
 - lib/cc/analyzer/location_description.rb
 - lib/cc/analyzer/null_config.rb
+- lib/cc/analyzer/null_container_log.rb
 - lib/cc/analyzer/path_patterns.rb
 - lib/cc/analyzer/source_buffer.rb
 - lib/cc/analyzer/unit_name.rb