Merge pull request #112 from adangel:exitcode

Make stdout/stderr and exit code available #112

Author: adangel

History.md

@@ -5,6 +5,7 @@
 ## Enhancements
 
 * [#108](https://github.com/pmd/pmd-regression-tester/issues/108): Disable progress bar for PMD 7
+* [#109](https://github.com/pmd/pmd-regression-tester/issues/109): Make stdout/stderr and exit code available
 
 ## Fixed Issues
 

lib/pmdtester/builders/liquid_renderer.rb

@@ -60,6 +60,11 @@ def write_project_index(project, root)
       # copy original pmd reports
       copy_file("#{root}/base_pmd_report.xml", project.report_diff.base_report.file)
       copy_file("#{root}/patch_pmd_report.xml", project.report_diff.patch_report.file)
+      # copy stdout and stderr outputs
+      copy_file("#{root}/base_stdout.txt", "#{project.report_diff.base_report.report_folder}/stdout.txt")
+      copy_file("#{root}/base_stderr.txt", "#{project.report_diff.base_report.report_folder}/stderr.txt")
+      copy_file("#{root}/patch_stdout.txt", "#{project.report_diff.patch_report.report_folder}/stdout.txt")
+      copy_file("#{root}/patch_stderr.txt", "#{project.report_diff.patch_report.report_folder}/stderr.txt")
       # render full pmd reports
       write_file("#{root}/base_pmd_report.html",
                  render_liquid('project_pmd_report.html', pmd_report_liquid_env(project, BASE)))
@@ -120,6 +125,7 @@ def report_to_h(project, report)
 
         'execution_time' => PmdReportDetail.convert_seconds(report.exec_time),
         'timestamp' => report.timestamp,
+        'exit_code' => report.exit_code,
 
         'rules' => report.rule_summaries,
         'errors' => report.errors_by_file.all_values.map { |e| error_to_hash(e, project) },

lib/pmdtester/builders/pmd_report_builder.rb

@@ -25,7 +25,7 @@ def initialize(projects, options, branch_config, branch_name)
     def get_pmd_binary_file
       logger.info "#{@pmd_branch_name}: Start packaging PMD"
       Dir.chdir(@local_git_repo) do
-        build_branch_sha = Cmd.execute("git rev-parse #{@pmd_branch_name}^{commit}")
+        build_branch_sha = Cmd.execute_successfully("git rev-parse #{@pmd_branch_name}^{commit}")
 
         checkout_build_branch # needs a clean working tree, otherwise fails
 
@@ -70,28 +70,28 @@ def build_pmd(into_dir:)
                       ' -Dcheckstyle.skip=true' \
                       ' -Dpmd.skip=true' \
                       ' -T1C -B'
-        Cmd.execute(package_cmd)
+        Cmd.execute_successfully(package_cmd)
       end
 
       logger.info "#{@pmd_branch_name}: Extracting the zip"
-      Cmd.execute("unzip -qo #{pmd_dist_target} -d pmd-dist/target/exploded")
-      Cmd.execute("mv pmd-dist/target/exploded/pmd-bin-#{@pmd_version} #{into_dir}")
+      Cmd.execute_successfully("unzip -qo #{pmd_dist_target} -d pmd-dist/target/exploded")
+      Cmd.execute_successfully("mv pmd-dist/target/exploded/pmd-bin-#{@pmd_version} #{into_dir}")
     end
 
     def determine_pmd_version
       version_cmd = "./mvnw -q -Dexec.executable=\"echo\" -Dexec.args='${project.version}' " \
                     '--non-recursive org.codehaus.mojo:exec-maven-plugin:1.5.0:exec'
-      Cmd.execute(version_cmd)
+      Cmd.execute_successfully(version_cmd)
     end
 
     def get_last_commit_sha
       get_last_commit_sha_cmd = 'git rev-parse HEAD^{commit}'
-      Cmd.execute(get_last_commit_sha_cmd)
+      Cmd.execute_successfully(get_last_commit_sha_cmd)
     end
 
     def get_last_commit_message
       get_last_commit_message_cmd = 'git log -1 --pretty=%B'
-      Cmd.execute(get_last_commit_message_cmd)
+      Cmd.execute_successfully(get_last_commit_message_cmd)
     end
 
     def generate_pmd_report(project)
@@ -107,14 +107,16 @@ def generate_pmd_report(project)
                 "#{auxclasspath_option}" \
                 "#{pmd7? ? ' --no-progress' : ''}"
       start_time = Time.now
+      exit_code = nil
       if File.exist?(project.get_pmd_report_path(@pmd_branch_name))
         logger.warn "#{@pmd_branch_name}: Skipping PMD run - report " \
                     "#{project.get_pmd_report_path(@pmd_branch_name)} already exists"
       else
-        Cmd.execute(pmd_cmd)
+        status = Cmd.execute(pmd_cmd, project.get_project_target_dir(@pmd_branch_name))
+        exit_code = status.exitstatus
       end
       end_time = Time.now
-      [end_time - start_time, end_time]
+      [end_time - start_time, end_time, exit_code]
     end
 
     def generate_config_for(project)
@@ -141,12 +143,12 @@ def generate_pmd_reports
         progress_logger = SimpleProgressLogger.new("generating #{project.name}'s PMD report")
         progress_logger.start
         generate_config_for(project)
-        execution_time, end_time = generate_pmd_report(project)
+        execution_time, end_time, exit_code = generate_pmd_report(project)
         progress_logger.stop
         sum_time += execution_time
 
-        report_details = PmdReportDetail.new(execution_time: execution_time, timestamp: end_time)
-        report_details.save(project.get_report_info_path(@pmd_branch_name))
+        PmdReportDetail.create(execution_time: execution_time, timestamp: end_time,
+                               exit_code: exit_code, report_info_path: project.get_report_info_path(@pmd_branch_name))
         logger.info "#{project.name}'s PMD report was generated successfully"
       end
 
@@ -169,7 +171,7 @@ def build
     def checkout_build_branch
       logger.info "#{@pmd_branch_name}: Checking out the branch"
       # note that this would fail if the tree is dirty
-      Cmd.execute("git checkout #{@pmd_branch_name}")
+      Cmd.execute_successfully("git checkout #{@pmd_branch_name}")
 
       # determine the version
       @pmd_version = determine_pmd_version
@@ -195,7 +197,7 @@ def saved_distro_path(build_sha)
     end
 
     def wd_has_dirty_git_changes
-      !Cmd.execute('git status --porcelain').empty?
+      !Cmd.execute_successfully('git status --porcelain').empty?
     end
 
     def should_use_long_cli_options

lib/pmdtester/builders/project_builder.rb

@@ -30,7 +30,7 @@ def clone_projects
           # once but may be used with several tags.
           clone_cmd = "git clone --no-single-branch --depth 1 #{project.connection} #{path}"
 
-          Cmd.execute(clone_cmd)
+          Cmd.execute_successfully(clone_cmd)
         end
 
         Dir.chdir(path) do
@@ -87,7 +87,7 @@ def run_as_script(path, command)
         if command.start_with?('#!')
           shell = command.lines[0].chomp[2..] # remove leading "#!"
         end
-        stdout = Cmd.execute("#{shell} #{script.path}")
+        stdout = Cmd.execute_successfully("#{shell} #{script.path}")
       ensure
         script.unlink
       end
@@ -99,7 +99,7 @@ def execute_reset_cmd(type, tag)
 
       reset_cmd = "git checkout #{tag}; git reset --hard #{tag}"
 
-      Cmd.execute(reset_cmd)
+      Cmd.execute_successfully(reset_cmd)
     end
   end
 end

lib/pmdtester/builders/project_hasher.rb

@@ -21,6 +21,9 @@ def report_diff_to_h(rdiff)
         'base_timestamp' => rdiff.base_report.timestamp,
         'patch_timestamp' => rdiff.patch_report.timestamp,
 
+        'base_exit_code' => rdiff.base_report.exit_code,
+        'patch_exit_code' => rdiff.patch_report.exit_code,
+
         'rule_diffs' => rdiff.rule_summaries
       }
     end

lib/pmdtester/builders/rule_set_builder.rb

@@ -176,7 +176,7 @@ def diff_filenames(languages)
 
         # We only need to support git here, since PMD's repo is using git.
         diff_cmd = "git diff --name-only #{base}..#{patch} #{filepath_filter}"
-        filenames = Cmd.execute(diff_cmd)
+        filenames = Cmd.execute_successfully(diff_cmd)
       end
       filenames.split("\n")
     end

lib/pmdtester/cmd.rb

@@ -6,9 +6,35 @@ module PmdTester
   # Containing the common method for executing shell command
   class Cmd
     extend PmdTester
-    def self.execute(cmd)
-      stdout, _stderr, _status = internal_execute(cmd)
-      stdout&.chomp!
+
+    #
+    # Executes the given command and returns the process status.
+    # stdout and stderr are written to the files "stdout.txt" and "stderr.txt"
+    # in path.
+    #
+    def self.execute(cmd, path)
+      stdout, stderr, status = internal_execute(cmd)
+
+      file = File.new("#{path}/stdout.txt", 'w')
+      file.puts stdout
+      file.close
+
+      file = File.new("#{path}/stderr.txt", 'w')
+      file.puts stderr
+      file.close
+
+      status
+    end
+
+    def self.execute_successfully(cmd)
+      stdout, stderr, status = internal_execute(cmd)
+
+      unless status.success?
+        logger.error stdout
+        logger.error stderr
+        raise CmdException.new(cmd, stdout, stderr, status)
+      end
+
       stdout
     end
 
@@ -22,14 +48,12 @@ def self.internal_execute(cmd)
 
       stdout, stderr, status = Open3.capture3("#{cmd};")
 
-      logger.debug stdout
-      unless status.success?
-        logger.error stdout
-        logger.error stderr
-        raise CmdException.new(cmd, stderr)
-      end
+      logger.debug "status: #{status}"
+      logger.debug "stdout: #{stdout}"
+      logger.debug "stderr: #{stderr}"
 
       stdout&.chomp!
+      stderr&.chomp!
 
       [stdout, stderr, status]
     end
@@ -40,15 +64,19 @@ def self.internal_execute(cmd)
   # The exception should be raised when the shell command failed.
   class CmdException < StandardError
     attr_reader :cmd
+    attr_reader :stdout
     attr_reader :error
+    attr_reader :status
     attr_reader :message
 
     COMMON_MSG = 'An error occurred while executing the shell command'
 
-    def initialize(cmd, error)
+    def initialize(cmd, stdout, error, status)
       @cmd = cmd
+      @stdout = stdout
       @error = error
-      @message = "#{COMMON_MSG} '#{cmd}'"
+      @status = status
+      @message = "#{COMMON_MSG} '#{cmd}' #{status}"
     end
   end
 end

lib/pmdtester/pmd_report_detail.rb

@@ -8,15 +8,22 @@ class PmdReportDetail
     attr_accessor :execution_time
     attr_accessor :timestamp
     attr_accessor :working_dir
+    attr_accessor :exit_code
 
-    def initialize(execution_time: 0, timestamp: '', working_dir: Dir.getwd)
+    def initialize(execution_time: 0, timestamp: '', working_dir: Dir.getwd, exit_code: nil)
       @execution_time = execution_time
       @timestamp = timestamp
       @working_dir = working_dir
+      @exit_code = exit_code.nil? ? '?' : exit_code.to_s
     end
 
     def save(report_info_path)
-      hash = { execution_time: @execution_time, timestamp: @timestamp, working_dir: @working_dir }
+      hash = {
+        execution_time: @execution_time,
+        timestamp: @timestamp,
+        working_dir: @working_dir,
+        exit_code: @exit_code
+      }
       file = File.new(report_info_path, 'w')
       file.puts JSON.generate(hash)
       file.close
@@ -36,6 +43,13 @@ def format_execution_time
       self.class.convert_seconds(@execution_time)
     end
 
+    def self.create(execution_time: 0, timestamp: '', working_dir: Dir.getwd, exit_code: nil, report_info_path:)
+      detail = PmdReportDetail.new(execution_time: execution_time, timestamp: timestamp,
+                                   working_dir: working_dir, exit_code: exit_code)
+      detail.save(report_info_path)
+      detail
+    end
+
     # convert seconds into HH::MM::SS
     def self.convert_seconds(seconds)
       Time.at(seconds.abs).utc.strftime('%H:%M:%S')

lib/pmdtester/pmd_tester_utils.rb

@@ -32,7 +32,8 @@ def parse_pmd_report(report_file, branch, report_details, filter_set = nil)
         file: report_file,
 
         timestamp: report_details.timestamp,
-        exec_time: report_details.execution_time
+        exec_time: report_details.execution_time,
+        exit_code: report_details.exit_code
       )
     end
 

lib/pmdtester/project.rb

@@ -123,6 +123,9 @@ def compute_report_diff(base_branch, patch_branch, filter_set)
                                            get_report_info_path(base_branch),
                                            get_report_info_path(patch_branch),
                                            filter_set)
+
+      report_diff.base_report.report_folder = get_project_target_dir(base_branch)
+      report_diff.patch_report.report_folder = get_project_target_dir(patch_branch)
     end
   end
 end