simp-rake-helpers 5.6.2 → 5.7.0

data/spec/acceptance/20_pkg_rpm_upgrade_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper_acceptance'
+require_relative 'support/pkg_rpm_helpers'
+
+require 'beaker/puppet_install_helper'
+require 'json'
+
+RSpec.configure do |c|
+  c.include Simp::BeakerHelpers::SimpRakeHelpers::PkgRpmHelpers
+  c.extend  Simp::BeakerHelpers::SimpRakeHelpers::PkgRpmHelpers
+end
+
+# This tests RPM upgrade scenarios for components that use
+# simp-adapter's simp_rpm_helper to copy files from the RPM install
+# directory to a second destination directory
+
+
+shared_examples_for 'RPM generator' do
+  it 'should create RPMs' do
+    testpackages.each do |package|
+      on host, %Q(#{run_cmd} "cd #{pkg_root_dir}/#{package}; ) +
+                      %Q(rvm use default; bundle update --local || bundle update")
+      rpm_name = package.sub(/-[^-]+$/,'')
+      # In case previous tests haven't been clean
+      on host, "rpm -q #{rpm_name} && rpm -e #{rpm_name}; :"
+
+      on host, %(#{run_cmd} "cd #{pkg_root_dir}/#{package}; #{rake_cmd} pkg:rpm")
+    end
+  end
+end
+
+shared_examples_for 'an upgrade path that works safely with simp_rpm_helper' do |first_package_file, second_package_file|
+  let( :rpm_regex ) do
+    /^(?<name>pupmod-[a-z0-9_]+-[a-z0-9_]+)-(?<version>\d+\.\d+\.\d+)-(?<release>\d+)\..*\.rpm$/
+  end
+
+  let( :first_package_version ){ first_package_file.match(rpm_regex)['version'] }
+  let( :first_package_name ){ first_package_file.match(rpm_regex)['name'] }
+  let( :first_package_forge_name ){ first_package_name.sub(/^[^-]+-/,'') }
+  let( :first_package_module_name ){ first_package_forge_name.sub(/^[^-]+-/,'') }
+  let( :first_package_dir_name ){ first_package_name + '-' + first_package_version.sub(/\.\d+-\d+$/,'') }
+
+  let( :second_package_name ){ second_package_file.match(rpm_regex)['name'] }
+  let( :second_package_forge_name ){ second_package_name.sub(/^[^-]+-/,'') }
+  let( :second_package_module_name ){ second_package_forge_name.sub(/^[^-]+-/,'') }
+  let( :second_package_version ){ second_package_file.match(rpm_regex)['version'] }
+  let( :second_package_dir_name ){ second_package_name + '-' + second_package_version.sub(/\.\d+-\d+$/,'') }
+
+  context "When upgrading from #{first_package_file} to #{second_package_file}" do
+    it "should clean out any old installs" do
+      on host, "rpm -e #{first_package_name} &> /dev/null; " +
+               "rpm -e #{second_package_name} &> /dev/null ",
+               accept_all_exit_codes: true
+    end
+
+    it "should install #{first_package_file}" do
+      on host, "cd #{pkg_root_dir}/#{first_package_dir_name.gsub(/\.\d+$/,'')}; "+
+               "rpm -Uvh dist/#{first_package_file}"
+    end
+
+    it "should transfer contents of #{first_package_file} into the code directory" do
+      result = on host, "cat /opt/test/puppet/code/#{first_package_module_name}/metadata.json"
+      metadata = JSON.parse(result.stdout)
+      expect(metadata['name']).to eq first_package_forge_name
+      expect(metadata['version']).to eq first_package_version
+
+      # This verifies all files/dirs from the first package are copied
+      on host, "diff -r /usr/share/simp/modules/#{first_package_module_name} /opt/test/puppet/code/#{first_package_module_name}"
+    end
+
+    it "should upgrade to #{second_package_file}" do
+      on host, "cd #{pkg_root_dir}/#{second_package_dir_name.gsub(/\.\d+$/,'')}; rpm -Uvh dist/#{second_package_file}"
+    end
+
+    it "should transfer contents of #{second_package_file} into the code directory" do
+      result = on host, "cat /opt/test/puppet/code/#{second_package_module_name}/metadata.json"
+      metadata = JSON.parse(result.stdout)
+      expect(metadata['name']).to eq second_package_forge_name
+      expect(metadata['version']).to eq second_package_version
+
+      # This verifies all files/dirs from the second package are copied and
+      # no files/dirs onyn in the old package remain
+      on host, "diff -r /usr/share/simp/modules/#{second_package_module_name} /opt/test/puppet/code/#{second_package_module_name}"
+    end
+
+  end
+end
+
+describe 'rake pkg:rpm + component upgrade scenarios' do
+
+  before :all do
+    copy_host_files_into_build_user_homedir(hosts)
+
+    comment 'ensure the Puppet AIO is installed'
+#FIXME Should install Puppet 5
+    ENV['PUPPET_INSTALL_TYPE'] ||= 'agent'
+    ENV['PUPPET_INSTALL_VERSION'] ||= '1.10.6'
+    run_puppet_install_helper_on(hosts)
+
+    comment 'configure puppet agent to look like a Puppet server for simp_rpm_helper'
+    on hosts, '/opt/puppetlabs/bin/puppet config --section master set user root; ' +
+              '/opt/puppetlabs/bin/puppet config --section master set group root; ' +
+              '/opt/puppetlabs/bin/puppet config --section master set codedir /opt/test/puppet/code; ' +
+              '/opt/puppetlabs/bin/puppet config --section master set confdir /opt/test/puppet/code'
+
+
+    comment 'build and install mock RPMs'
+    mock_pkg_dir = '/home/build_user/host_files/spec/acceptance/files/mock_packages'
+    on hosts, %Q[#{run_cmd} "cd #{mock_pkg_dir}; rm -rf pkg"]
+    on hosts, %Q[#{run_cmd} "cd #{mock_pkg_dir}; bash rpmbuild.sh simp-adapter.spec"]
+    on hosts, %Q[#{run_cmd} "cd #{mock_pkg_dir}; bash rpmbuild.sh pupmod-puppetlabs-stdlib.spec"]
+    on hosts, %Q[#{run_cmd} "cd #{mock_pkg_dir}; bash rpmbuild.sh pupmod-simp-simplib.spec"]
+    on hosts, %Q[#{run_cmd} "cd #{mock_pkg_dir}; bash rpmbuild.sh pupmod-simp-foo.spec"]
+
+    on hosts, %Q[rpm -Uvh "#{mock_pkg_dir}/pkg/dist/*.noarch.rpm"], acceptable_exit_codes: [0,1]
+  end
+
+  hosts.each do |_host|
+    context "on #{_host}" do
+      let!(:host){ _host }
+
+      # This tests standard upgrades, which should 
+      context 'with normal module RPM upgrades' do
+        let(:pkg_root_dir) do
+          '/home/build_user/host_files/spec/acceptance/files/package_upgrades'
+        end
+
+        let(:testpackages) do
+          [
+            'pupmod-simp-testpackage-1.0',
+            'pupmod-simp-testpackage-2.0',
+          ]
+        end
+
+        context 'RPM build' do
+          it_should_behave_like('RPM generator')
+        end
+
+        context 'RPM upgrades' do
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-simp-testpackage-1.0.0-0.noarch.rpm',
+                                'pupmod-simp-testpackage-2.0.0-0.noarch.rpm')
+        end
+
+        context 'RPM erase' do
+          it 'should remove copied files on an erase' do
+            on host, 'rpm -e pupmod-simp-testpackage'
+            on host, 'ls /opt/test/puppet/code/testpackage', acceptable_exit_codes: [2]
+          end
+        end
+      end
+
+      # These tests demonstrate custom RPM triggers that work around the obsolete
+      # module RPM upgrate + simp_rpm_helper problem described in SIMP-3895:
+      #
+      #    https://simp-project.atlassian.net/browse/SIMP-3988
+      #
+      # The expected outcome is that simp_rpm_helper always ensures the correct
+      # content is installed after an upgrade, even during after a package has been
+      # obsoleted.  This is accomplished via %triggerpostun -- <name of old package>
+      #
+      # old 1.0 -> old 2.0 = no need for a trigger
+      # old 1.0 -> new 2.0 = must re-run simp_rpm_helper
+      # old 1.0 -> new 3.0 = must re-run simp_rpm_helper
+      # old 2.0 -> new 2.0 = must re-run simp_rpm_helper
+      # old 2.0 -> new 3.0 = must re-run simp_rpm_helper
+      # new 2.0 -> new 3.0 = no need for a trigger
+      #
+      context 'with module RPMs that are susceptible to SIMP-3895' do
+        let(:pkg_root_dir) do
+          '/home/build_user/host_files/spec/acceptance/files/custom_scriptlet_triggers'
+        end
+
+        let(:testpackages) do
+          [
+            'pupmod-old-package-1.0',
+            'pupmod-old-package-2.0',
+            'pupmod-old-package-2.2',
+            'pupmod-new-package-2.1',
+            'pupmod-new-package-3.0',
+          ]
+        end
+
+        context 'RPM build' do
+          it_should_behave_like('RPM generator')
+        end
+
+        context 'RPM upgrades' do
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-old-package-1.0.0-0.noarch.rpm',
+                                'pupmod-old-package-2.0.0-0.noarch.rpm')
+
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-old-package-1.0.0-0.noarch.rpm',
+                                'pupmod-new-package-2.1.0-0.noarch.rpm')
+
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-new-package-2.1.0-0.noarch.rpm',
+                                'pupmod-old-package-2.2.0-0.noarch.rpm')
+
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-old-package-1.0.0-0.noarch.rpm',
+                                'pupmod-new-package-3.0.0-0.noarch.rpm')
+
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-old-package-2.0.0-0.noarch.rpm',
+                                'pupmod-new-package-2.1.0-0.noarch.rpm')
+
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-old-package-2.0.0-0.noarch.rpm',
+                                'pupmod-new-package-3.0.0-0.noarch.rpm')
+
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-old-package-2.2.0-0.noarch.rpm',
+                                'pupmod-new-package-3.0.0-0.noarch.rpm')
+
+          it_should_behave_like('an upgrade path that works safely with simp_rpm_helper',
+                                'pupmod-new-package-2.1.0-0.noarch.rpm',
+                                'pupmod-new-package-3.0.0-0.noarch.rpm')
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/files/mock_packages/simp-adapter/usr/local/sbin/simp_rpm_helper

@@ -3,8 +3,8 @@
 # Purpose
 # -------
 #
-# This script is meant to be called by the %preun and %post sections of the
-# various SIMP Puppet module RPMs.
+# This script is meant to be called by the %preun and %postttrans sections of
+# the various SIMP Puppet module RPMs.
 #
 # The purpose of the script is to provide helper methods that correctly
 # scaffold the system in such a way that all SIMP Puppet Modules can be
@@ -56,279 +56,307 @@ require 'find'
 # Make sure we can find the Puppet executables
 ENV['PATH'] += ':/opt/puppetlabs/bin'
 
-# Get the Puppet configuration parameters currently in use
-def get_puppet_config
-  system_config = %x{puppet config --section master print}
+class SimpRpmHelper
+  def initialize
+    @program_name = File.basename(__FILE__)
 
-  config_hash = Hash.new
-
-  system_config.each_line do |line|
-    k,v = line.split('=')
-    config_hash[k.strip] = v.strip
+    # A list of modules that should never be touched once installed
+    @safe_modules = ['site']
   end
 
-  return config_hash
-end
-
-# A more friendly failure message
-def fail(msg)
-  $stderr.puts(msg)
-  exit(1)
-end
+  def debug(msg)
+    # SIMP RPMs do not enable debug when they call this script.  So, if
+    # you want to debug an RPM problem with this script, comment out
+    # the line below.
+    return unless @options.debug
+    msg.split("\n").each do |line|
+      puts ">>>#{@program_name} DEBUG: #{line}"
+    end
+  end
 
-# Determine whether the passed path is under management by git or svn
-def is_managed?(path)
-  # Short circuit if the directory is not present
-  return false unless File.directory?(path)
+  def info(msg)
+    # When these messages get written out in an RPM upgrade, name of program
+    # is helpful to end user
+    puts "#{@program_name}: #{msg}"
+  end
 
-  git = Facter::Core::Execution.which('git')
-  svn = Facter::Core::Execution.which('svn')
+  # Get the Puppet configuration parameters currently in use
+  def get_puppet_config
+    system_config = %x{puppet config --section master print}
 
-  Dir.chdir(path) do
-    if git
-      %x{#{git} ls-files . --error-unmatch &> /dev/null}
+    config_hash = Hash.new
 
-      return true if $?.success?
+    system_config.each_line do |line|
+      k,v = line.split('=')
+      config_hash[k.strip] = v.strip
     end
 
-    if svn
-      %x{#{svn} info &> /dev/null}
-
-      return true if $?.success?
-    end
+    return config_hash
   end
 
-  return false
-end
+  # Determine whether the passed path is under management by git or svn
+  def is_managed?(path)
+    # Short circuit if the directory is not present
+    return false unless File.directory?(path)
 
-def parse_options
-  options = OpenStruct.new
-  options.config_file = '/etc/simp/adapter_config.yaml'
-  options.preserve = false
-  # These are not settable, but it's nice to have all this material in one place
-  options.puppet_user = @puppet_config['user']
-  options.puppet_group = @puppet_config['group']
-
-  all_opts = OptionParser.new do |opts|
-    opts.banner = "Usage: #{$0} [options]"
-
-    opts.separator ""
-
-    opts.on(
-      "--rpm_dir PATH",
-      "The directory into which the RPM source material is installed"
-    ) do |arg|
-      options.rpm_dir = arg.strip
-      options.module_name = File.basename(options.rpm_dir)
-    end
+    git = Facter::Core::Execution.which('git')
+    svn = Facter::Core::Execution.which('svn')
 
-    opts.on(
-      "--rpm_section SECTION",
-      "The section of the RPM from which the script is being called.",
-      "    Must be one of 'pre', 'post', 'preun', 'postun'"
-    ) do |arg|
-      options.rpm_section = arg.strip
-    end
+    Dir.chdir(path) do
+      if git
+        %x{#{git} ls-files . --error-unmatch &> /dev/null}
 
-    opts.on(
-      "--rpm_status STATUS",
-      "The status code passed to the RPM section"
-    ) do |arg|
-      options.rpm_status = arg.strip
-    end
+        return true if $?.success?
+      end
 
-    opts.on(
-      "-f CONFIG_FILE",
-      "--config CONFIG_FILE",
-      "The configuration file to use",
-      "    Default: #{options.config_file}"
-    ) do |arg|
-      options.config_file = arg.strip
-    end
+      if svn
+        %x{#{svn} info &> /dev/null}
 
-    opts.on(
-      "-p",
-      "--preserve",
-      "Preserve material in 'target_dir' that is not in 'rpm_dir'"
-    ) do |arg|
-      options.preserve = true
+        return true if $?.success?
+      end
     end
 
-    opts.on(
-      "-e",
-      "--enforce",
-      "If set, enforce the copy, regardless of the setting in the config file",
-      "    Default: false"
-    ) do |arg|
-      options.copy_rpm_data = true
-    end
+    return false
+  end
 
-    opts.on(
-      "-t DIR",
-      "--target_dir DIR",
-      "The subdirectory of #{simp_target_dir('')}",
-      "into which to copy the materials.",
-      "    Default: #{simp_target_dir.gsub(/#{simp_target_dir('')}/,'')}"
-    ) do |arg|
-      options.target_dir = simp_target_dir(arg.strip)
-    end
+  def parse_options(args)
 
-    opts.on(
-      "-h",
-      "--help",
-      "Help Message"
-    ) do
-      puts opts
-      exit(0)
-    end
-  end
+    @options = OpenStruct.new
+    @options.config_file = '/etc/simp/adapter_config.yaml'
+    @options.preserve = false
 
-  begin
-    all_opts.parse!(ARGV)
-  rescue OptionParser::ParseError => e
-    puts e
-    puts all_opts
-    exit 1
-  end
+    all_opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #{@program_name} [options]"
 
-  validate_options(options, all_opts.to_s)
+      opts.separator ''
 
-  return options
-end
+      opts.on(
+        '--rpm_dir PATH',
+        'The directory into which the RPM source material is installed'
+      ) do |arg|
+        @options.rpm_dir = arg.strip
+        @options.module_name = File.basename(@options.rpm_dir)
+      end
 
-# Process the config, validate the entries and do some munging
-# Return an options hash
-def process_config(config_file, options=OpenStruct.new)
-  # Defaults
-  config = {
-    'target_directory' => 'auto',
-    'copy_rpm_data'    => false
-  }
+      opts.on(
+        '--rpm_section SECTION',
+        'The section of the RPM from which the script is being called.',
+        "    Must be one of 'pre', 'preun', 'postun', 'posttrans'"
+      ) do |arg|
+        @options.rpm_section = arg.strip
+      end
 
-  if File.exist?(config_file)
-    begin
-      system_config = YAML.load_file(config_file)
-      if system_config
-        config.merge!(system_config)
+      opts.on(
+        '--rpm_status STATUS',
+        'The status code passed to the RPM section'
+      ) do |arg|
+        @options.rpm_status = arg.strip
       end
-    rescue
-      fail("Error: Config file '#{config_file}' could not be processed")
-    end
-  end
 
-  if options.copy_rpm_data.nil?
-    options.copy_rpm_data = (config['copy_rpm_data'].to_s == 'true')
-  end
+      opts.on(
+        '-f CONFIG_FILE',
+        '--config CONFIG_FILE',
+        'The configuration file to use.',
+        "    Default: #{@options.config_file}"
+      ) do |arg|
+        @options.config_file = arg.strip
+      end
 
-  if options.target_dir.nil? && config['target_directory']
-    if config['target_directory'] == 'auto'
-      options.target_dir = simp_target_dir
-    else
-      unless config['target_directory'][0].chr == '/'
-        fail("Error: 'target_directory' in '#{config_file}' must be an absolute path")
+      opts.on(
+        '-p',
+        '--preserve',
+        "Preserve material in 'target_dir' that is not in 'rpm_dir'"
+      ) do |arg|
+        @options.preserve = true
       end
 
-      options.target_dir = config['target_directory'].strip
-    end
-  end
+      opts.on(
+        '-e',
+        '--enforce',
+        'If set, enforce the copy, regardless of the setting in the config file',
+        '    Default: false'
+      ) do |arg|
+        @options.copy_rpm_data = true
+      end
 
-  return options
-end
+      opts.on(
+        '-t DIR',
+        '--target_dir DIR',
+        "The subdirectory of #{simp_target_dir('')}",
+        'into which to copy the materials.',
+        "    Default: #{simp_target_dir.gsub(/#{simp_target_dir('')}/,'')}"
+      ) do |arg|
+        @options.target_dir = simp_target_dir(arg.strip)
+      end
 
-def puppet_codedir
-  # Figure out where the Puppet code should go
-  # Puppet 4+
-  code_dir = @puppet_config['codedir']
-  if !code_dir || code_dir.empty?
-    code_dir = @puppet_config['confdir']
-  end
+      opts.on(
+        '-v',
+        '--verbose',
+        'Print out debug info when processing.'
+      ) do
+        @options.debug = true
+      end
 
-  return code_dir
-end
+      opts.on(
+        '-h',
+        '--help',
+        'Help Message'
+      ) do
+        puts opts
+        @options.help_requested = true
+      end
+    end
 
-# Return the target installation directory
-def simp_target_dir(subdir=File.join('simp','modules'))
-  install_target = puppet_codedir
+    begin
+      all_opts.parse!(args)
+    rescue OptionParser::ParseError => e
+      msg = "Error: #{e}\n\n#{all_opts}"
+      raise(msg)
+    end
 
-  if install_target.empty?
-    fail('Error: Could not find a Puppet code directory for installation')
+    validate_options(all_opts.to_s)
   end
 
-  install_target = File.join(install_target,'environments', subdir)
+  # Process the config, validate the entries and do some munging
+  # Sets @options hash.
+  def process_config
+    # Defaults
+    config = {
+      'target_directory' => 'auto',
+      'copy_rpm_data'    => false
+    }
+
+    if File.exist?(@options.config_file)
+      begin
+        system_config = YAML.load_file(@options.config_file)
+        if system_config
+          config.merge!(system_config)
+        end
+      rescue
+        raise("Error: Config file '#{@options.config_file}' could not be processed")
+      end
+    end
 
-  return install_target
-end
+    if @options.copy_rpm_data.nil?
+      @options.copy_rpm_data = (config['copy_rpm_data'].to_s == 'true')
+    end
 
-# Input Validation
-def validate_options(options, usage)
+    if @options.target_dir.nil? && config['target_directory']
+      if config['target_directory'] == 'auto'
+        @options.target_dir = simp_target_dir
+      else
+        unless config['target_directory'][0].chr == '/'
+          raise("Error: 'target_directory' in '#{@options.config_file}' must be an absolute path")
+        end
 
-  unless options.rpm_dir
-    fail("Error: 'rpm_dir' is required\n#{usage}")
+        @options.target_dir = config['target_directory'].strip
+      end
+    end
   end
 
-  unless options.rpm_status
-    fail("Error: 'rpm_status' is required\n#{usage}")
+  def puppet_codedir
+    # Figure out where the Puppet code should go
+    # Puppet 4+
+    code_dir = puppet_config['codedir']
+    if !code_dir || code_dir.empty?
+      code_dir = puppet_config['confdir']
+    end
+
+    return code_dir
   end
 
-  unless options.rpm_section
-    fail("Error: 'rpm_section' is required\n#{usage}")
+  def puppet_config
+    unless @puppet_config
+      @puppet_config = get_puppet_config
+    end
+    @puppet_config
   end
 
-  valid_rpm_sections = ['pre','post','preun','postun']
 
-  unless valid_rpm_sections.include?(options.rpm_section)
-    fail("Error: 'rpm_section' must be one of '#{valid_rpm_sections.join("', '")}'\n#{usage}")
+  def puppet_group
+    puppet_config['group']
   end
 
-  if (options.rpm_section == 'post') || (options.rpm_section == 'preun')
-    unless File.directory?(options.rpm_dir)
-      fail("Error: Could not find 'rpm_dir': '#{options.rpm_dir}'")
+  # Return the target installation directory
+  def simp_target_dir(subdir=File.join('simp','modules'))
+    install_target = puppet_codedir
+
+    if install_target.empty?
+      raise('Error: Could not find a Puppet code directory for installation')
     end
-  end
 
-  unless options.rpm_status =~ /^\d+$/
-    fail("Error: 'rpm_status' must be an integer\n#{usage}")
+    install_target = File.join(install_target,'environments', subdir)
+
+    return install_target
   end
 
-  fail('Error: Could not determine puppet user') if options.puppet_user.empty?
-  fail('Error: Could not determine puppet group') if options.puppet_group.empty?
-end
+  # Input Validation
+  def validate_options(usage)
+    return if @options.help_requested
 
-### Main Code
+    unless @options.rpm_dir
+      raise("Error: 'rpm_dir' is required\n#{usage}")
+    end
 
-@puppet_config = get_puppet_config
-options = parse_options
-options = process_config(options.config_file, options)
+    unless @options.rpm_status
+      raise("Error: 'rpm_status' is required\n#{usage}")
+    end
 
-# A list of modules that should never be touched once installed
-safe_modules = ['site']
+    unless @options.rpm_section
+      raise("Error: 'rpm_section' is required\n#{usage}")
+    end
 
-# If the target directory is managed, we're done
-unless is_managed?(File.join(options.target_dir, options.module_name)) || !options.copy_rpm_data
+    # We allow 'post' for backward compatibility with SIMP RPMs that use
+    # this, but copying over files in the 'post' during an upgrade is
+    # problematic.  If the old package has files that are not in the new
+    # package, these files will not be removed in the destination directory.
+    # This is because during %post, the old package files have not yet
+    # been removed from the source directory by RPM. So, the 'rsync'
+    # operation copies over the OBE files from the old package.
+    valid_rpm_sections = ['pre','post','preun','postun', 'posttrans']
+
+    unless valid_rpm_sections.include?(@options.rpm_section)
+      raise("Error: 'rpm_section' must be one of '#{valid_rpm_sections.join("', '")}'\n#{usage}")
+    end
 
-  rsync = Facter::Core::Execution.which('rsync')
-  fail("Error: Could not find 'rsync' command!") unless rsync
+    if (@options.rpm_section == 'posttrans') || (@options.rpm_section == 'preun') || (@options.rpm_section == 'post')
+      unless File.directory?(@options.rpm_dir)
+        raise("Error: Could not find 'rpm_dir': '#{@options.rpm_dir}'")
+      end
+    end
 
-  # A regular installation or upgrade
-  if options.rpm_section == 'post'
-    if safe_modules.include?(options.module_name)
+    unless @options.rpm_status =~ /^\d+$/
+      raise("Error: 'rpm_status' must be an integer\n#{usage}")
+    end
+
+  end
+
+  def handle_install
+    debug("Processing install, upgrade, or downgrade of #{@options.module_name}")
+    if @safe_modules.include?(@options.module_name)
       # Make sure that we preserve anything in the safe modules on installation
-      options.preserve = true
+      @options.preserve = true
 
-      if options.rpm_status == '2'
+      if @options.rpm_status == '2'
         # Short circuit on upgrading safe modules, just don't touch them!
-        if File.directory?(File.join(options.target_dir, options.module_name))
-          exit(0)
+        target_module_dir = File.join(@options.target_dir, @options.module_name)
+        if File.directory?(target_module_dir)
+          debug("Skipping upgrade of 'safe' module directory #{target_module_dir}")
+          return
         end
       end
     end
 
+    raise('Error: Could not determine puppet group') if puppet_group.empty?
+    rsync = Facter::Core::Execution.which('rsync')
+    raise("Error: Could not find 'rsync' command!") unless rsync
+
     # Create the directories, with the proper mode, all the way down
-    dir_paths = options.target_dir.split(File::SEPARATOR).reject(&:empty?)
+    dir_paths = @options.target_dir.split(File::SEPARATOR).reject(&:empty?)
     top_dir = File::SEPARATOR + dir_paths.shift
     unless File.directory?(top_dir)
       FileUtils.mkdir(top_dir, :mode => 0750)
-      FileUtils.chown('root', options.puppet_group, top_dir)
+      FileUtils.chown('root', puppet_group, top_dir)
     end
 
     orig_dir = Dir.pwd
@@ -336,7 +364,7 @@ unless is_managed?(File.join(options.target_dir, options.module_name)) || !optio
     dir_paths.each do |dir|
       unless File.directory?(dir)
         FileUtils.mkdir(dir, :mode => 0750)
-        FileUtils.chown('root', options.puppet_group, dir)
+        FileUtils.chown('root', puppet_group, dir)
       end
 
       Dir.chdir(dir)
@@ -345,62 +373,123 @@ unless is_managed?(File.join(options.target_dir, options.module_name)) || !optio
 
     cmd = %(#{rsync} -a --force)
 
-    if options.preserve
+    if @options.preserve
       cmd += %( --ignore-existing)
     else
-     cmd += %( --delete)
+      cmd += %( --delete)
     end
 
-    cmd += %( #{options.rpm_dir} #{options.target_dir})
+    cmd += %( --verbose) if @options.debug
+
+    cmd += %( #{@options.rpm_dir} #{@options.target_dir})
     cmd += %( 2>&1)
 
+    info("Copying '#{@options.module_name}' files into '#{@options.target_dir}'")
+    debug("Executing: #{cmd}")
     output = %x{#{cmd}}
+    debug("Output:\n#{output}")
     unless $?.success?
-      fail(%(Error: Copy of '#{options.module_name}' into '#{options.target_dir}' using '#{cmd}' failed with the following error:\n    #{output.gsub("\n","\n    ")}))
+      raise(%(Error: Copy of '#{@options.module_name}' into '#{@options.target_dir}' using '#{cmd}' failed with the following error:\n    #{output.gsub("\n","\n    ")}))
     end
 
-    FileUtils.chown_R(nil, "#{options.puppet_group}", options.target_dir)
+    FileUtils.chown_R(nil, "#{puppet_group}", @options.target_dir)
   end
 
-  # A regular uninstall or downgrade
-  # This needs to happen *before* we uninstall since we need to compare with what's on disk
-  if options.rpm_section == 'preun' && options.rpm_status == '0'
+  def handle_uninstall
+    debug("Processing uninstall of #{@options.module_name}")
     # Play it safe, this needs to have at least 'environments/simp' in it!
-    if options.target_dir.split(File::SEPARATOR).reject(&:empty?).size < 3
-      fail("Error: Not removing directory '#{options.target_dir}' for safety")
-    else
-      unless safe_modules.include?(options.module_name)
-        # Find out what we have
-        ref_list = []
-        Dir.chdir(options.rpm_dir) do
-          Find.find('.').each do |file|
-            if File.symlink?(file)
-              ref_list << file
-              Find.prune
-            end
-
-            ref_list << file
-          end
+    if @options.target_dir.split(File::SEPARATOR).reject(&:empty?).size < 3
+      raise("Error: Not removing directory '#{@options.target_dir}' for safety")
+    end
+
+    if @safe_modules.include?(@options.module_name)
+      target_module_dir = File.join(@options.target_dir, @options.module_name)
+      debug("Skipping removal of 'safe' module directory #{target_module_dir}")
+      return
+    end
+
+    info("Removing '#{@options.module_name}' files from '#{@options.target_dir}'")
+
+    # Find out what we have
+    ref_list = []
+    Dir.chdir(@options.rpm_dir) do
+      Find.find('.').each do |file|
+        if File.symlink?(file)
+          ref_list << file
+          Find.prune
         end
 
-        # Delete from the bottom up to clear out the directories first
-        ref_list.reverse!
-        ref_list.map{|x| x.sub!(/^./, options.module_name)}
-
-        # Only delete items that are in the reference repo
-        Dir.chdir(options.target_dir) do
-          ref_list.each do |to_rm|
-            if File.symlink?(to_rm)
-              FileUtils.rm_f(to_rm)
-            elsif File.directory?(to_rm) && (Dir.entries(to_rm).delete_if {|dir|
-                dir == '.' || dir == '..'}.size == 0)
-              FileUtils.rmdir(to_rm)
-            elsif File.exist?(to_rm)
-              FileUtils.rm_f(to_rm)
-            end
-          end
+        ref_list << file
+      end
+    end
+
+    # Delete from the bottom up to clear out the directories first
+    # before removing them
+    ref_list.reverse!
+    ref_list.map{|x| x.sub!(/^./, @options.module_name)}
+
+    # Only delete items that are in the reference repo
+    Dir.chdir(@options.target_dir) do
+      ref_list.each do |to_rm|
+        if File.symlink?(to_rm)
+          debug("Removing symlink #{to_rm}")
+          FileUtils.rm_f(to_rm)
+        elsif File.directory?(to_rm) && (Dir.entries(to_rm).delete_if {|dir|
+            dir == '.' || dir == '..'}.size == 0)
+          debug("Removing directory #{to_rm}")
+          FileUtils.rmdir(to_rm)
+        elsif File.exist?(to_rm)
+          debug("Removing file #{to_rm}")
+          FileUtils.rm_f(to_rm)
         end
       end
     end
   end
+
+  def run(args)
+    parse_options(args)
+    return 0 if @options.help_requested
+
+    process_config
+    debug("Running with config=#{@options.to_s}")
+
+    # If the target directory is managed, we're done
+    target_module_dir = File.join(@options.target_dir, @options.module_name)
+    unless is_managed?(target_module_dir) || !@options.copy_rpm_data
+
+      debug("Processing unmanaged target directory #{target_module_dir}")
+
+      if (@options.rpm_section == 'posttrans') || (@options.rpm_section == 'post')
+        # A regular installation, upgrade or downgrade
+        # This *should* happen in the RPM %posttrans, but we allow this to
+        # occur in the %post for backward compatibility with SIMP RPMs that
+        # erroneously try to affect a copy in the %post. (Copying over the
+        # files in the RPM %post during an upgrade/downgrade is problematic.
+        # If the old package has files that are not in the new package,
+        # these files will not yet have been removed in the source
+        # directory, and thus end up in the target directory.)
+        handle_install
+      elsif @options.rpm_section == 'preun' && @options.rpm_status == '0'
+        # A regular uninstall
+        # This needs to happen *before* RPM removes the files (%preun with
+        # status 0), since we need to compare with what's on disk to undo
+        # the copy done during the RPM install via handle_install()
+        handle_uninstall
+      end
+    end
+    return 0
+  rescue RuntimeError => e
+    $stderr.puts(e)
+    return 1
+  rescue Exception => e
+    $stderr.puts(e)
+    e.backtrace.first(10).each{|l| $stderr.puts l }
+    return 1
+  end
 end
+
+if __FILE__ == $0
+  helper = SimpRpmHelper.new
+  exit helper.run(ARGV)
+end
+