vanagon 0.3.19 → 0.4.0

data/lib/vanagon/platform/rpm/aix.rb

@@ -0,0 +1,28 @@
+# AIX is special. This subclassing gives us the chance to define some sane
+# defaults for aix without cluttering the main rpm class in if statements.
+class Vanagon
+  class Platform
+    class RPM
+      class AIX < Vanagon::Platform::RPM
+        def rpm_defines
+          %(--define '_topdir $(tempdir)/rpmbuild' )
+        end
+
+        # Constructor. Sets up some defaults for the aix platform and calls the parent constructor
+        #
+        # @param name [String] name of the platform
+        # @return [Vanagon::Platform::RPM::AIX] the rpm derived platform with the given name
+        def initialize(name)
+          @name = name
+          @make = "/usr/bin/gmake"
+          @tar = "/opt/freeware/bin/tar"
+          @patch = "/opt/freeware/bin/patch"
+          @num_cores = "lsdev -Cc processor |wc -l"
+          @install = "/opt/freeware/bin/install"
+          @rpmbuild = "/usr/bin/rpm"
+          super(name)
+        end
+      end
+    end
+  end
+end

data/lib/vanagon/platform/rpm/sles.rb

@@ -0,0 +1,35 @@
+# SLES is special, mainly in the differences between yum and zypper,
+# so here we subclass SLES off of rpm.
+class Vanagon
+  class Platform
+    class RPM
+      class SLES < Vanagon::Platform::RPM
+        # Helper to setup a zypper repository on a target system
+        #
+        # @param definition [String] the repo setup URI or RPM file
+        # @return [Array] A list of commands to add a zypper repo for the build system
+        def add_repository(definition)
+          definition = URI.parse(definition)
+          if @os_version == '10'
+            flag = 'sa'
+          else
+            flag = 'ar'
+          end
+
+          commands = []
+
+          if definition.scheme =~ /^(http|ftp)/
+            if File.extname(definition.path) == '.rpm'
+              # repo definition is an rpm (like puppetlabs-release)
+              commands << "curl -o local.rpm '#{definition}'; rpm -Uvh local.rpm; rm -f local.rpm"
+            else
+              commands << "yes | zypper -n --no-gpg-checks #{flag} -t YUM --repo '#{definition}'"
+            end
+          end
+
+          commands
+        end
+      end
+    end
+  end
+end

data/lib/vanagon/platform/solaris_10.rb

@@ -10,6 +10,18 @@ class Vanagon
         name_and_version = "#{project.name}-#{project.version}"
         pkg_name = package_name(project)
 
+        # Here we maintain backward compatibility with older vanagon versions
+        # that did this by default.  This shim should get removed at some point
+        # in favor of just letting the makefile deliver the bill-of-materials
+        # to the correct directory. This shouldn't be required at all then.
+        if project.bill_of_materials.nil?
+          bom_install = [# Move bill-of-materials into a docdir
+          "mkdir -p $(tempdir)/#{name_and_version}/usr/share/doc/#{project.name}",
+          "mv $(tempdir)/#{name_and_version}/bill-of-materials $(tempdir)/#{name_and_version}/usr/share/doc/#{project.name}/bill-of-materials",]
+        else
+          bom_install = []
+        end
+
         [
           # Set up our needed directories
           "mkdir -p $(tempdir)/#{name_and_version}",
@@ -19,9 +31,7 @@ class Vanagon
           # Unpack the project and stage the packaging artifacts
           "gunzip -c #{name_and_version}.tar.gz | '#{@tar}' -C '$(tempdir)' -xf -",
 
-          # Move bill-of-materials into a docdir
-          "mkdir -p $(tempdir)/#{name_and_version}/usr/share/doc/#{project.name}",
-          "mv $(tempdir)/#{name_and_version}/bill-of-materials $(tempdir)/#{name_and_version}/usr/share/doc/#{project.name}/bill-of-materials",
+          bom_install,
 
           "rm #{name_and_version}.tar.gz",
           "cp -r packaging $(tempdir)/",
@@ -46,7 +56,7 @@ class Vanagon
           "pkgmk -f $(tempdir)/packaging/proto -b $(tempdir)/#{name_and_version} -o -d $(tempdir)/pkg/",
           "pkgtrans -s $(tempdir)/pkg/ $(tempdir)/pkg/#{pkg_name.gsub(/\.gz$/, '')} #{project.name}",
           "gzip -c $(tempdir)/pkg/#{pkg_name.gsub(/\.gz$/, '')} > output/#{target_dir}/#{pkg_name}",
-        ]
+        ].flatten.compact
       end
 
       # Method to generate the files required to build a solaris package for the project

data/lib/vanagon/project.rb

@@ -11,6 +11,7 @@ class Vanagon
     attr_accessor :version, :directories, :license, :description, :vendor
     attr_accessor :homepage, :requires, :user, :repo, :noarch, :identifier
     attr_accessor :cleanup, :version_file, :release, :replaces, :provides
+    attr_accessor :bill_of_materials
 
     # Loads a given project from the configdir
     #
@@ -110,18 +111,69 @@ class Vanagon
       provides.flatten.uniq
     end
 
-    # Collects the pre-install actions for the project and it's components
+    # Collects the preinstall packaging actions for the project and it's components
+    # for the specified packaging state
     #
-    # @return [Array] array of Bourne shell compatible scriptlets to execute
-    def get_preinstall_actions
-      @components.map(&:preinstall_actions).flatten
+    # @param pkg_state [String] the package state we want to run the given scripts for.
+    #   Can be one or more of 'install' or 'upgrade'
+    # @return [String] string of Bourne shell compatible scriptlets to execute during the preinstall
+    #   phase of packaging during the state of the system defined by pkg_state (either install or upgrade)
+    def get_preinstall_actions(pkg_state)
+      scripts = @components.map(&:preinstall_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
+      if scripts.empty?
+        return ':'
+      else
+        return scripts.join("\n")
+      end
+    end
+
+
+    # Collects the postinstall packaging actions for the project and it's components
+    # for the specified packaging state
+    #
+    # @param pkg_state [String] the package state we want to run the given scripts for.
+    #   Can be one or more of 'install' or 'upgrade'
+    # @return [String] string of Bourne shell compatible scriptlets to execute during the postinstall
+    #   phase of packaging during the state of the system defined by pkg_state (either install or upgrade)
+    def get_postinstall_actions(pkg_state)
+      scripts = @components.map(&:postinstall_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
+      if scripts.empty?
+        return ':'
+      else
+        return scripts.join("\n")
+      end
     end
 
-    # Collects the post-install actions for the project and it's components
+    # Collects the preremove packaging actions for the project and it's components
+    # for the specified packaging state
     #
-    # @return [Array] array of Bourne shell compatible scriptlets to execute
-    def get_postinstall_actions
-      @components.map(&:postinstall_actions).flatten
+    # @param pkg_state [String] the package state we want to run the given scripts for.
+    #   Can be one or more of 'removal' or 'upgrade'
+    # @return [String] string of Bourne shell compatible scriptlets to execute during the preremove
+    #   phase of packaging during the state of the system defined by pkg_state (either removal or upgrade)
+    def get_preremove_actions(pkg_state)
+      scripts = @components.map(&:preremove_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
+      if scripts.empty?
+        return ':'
+      else
+        return scripts.join("\n")
+      end
+    end
+
+    # Collects the postremove packaging actions for the project and it's components
+    # for the specified packaging state
+    #
+    # @param pkg_state [String] the package state we want to run the given scripts for.
+    #   Can be one or more of 'removal' or 'upgrade'
+    # @return [String] string of Bourne shell compatible scriptlets to execute during the postremove
+    #   phase of packaging during the state of the system defined by pkg_state (either removal or upgrade)
+    def get_postremove_actions(pkg_state)
+      scripts = @components.map(&:postremove_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
+      if scripts.empty?
+        return ':'
+      else
+        return scripts.join("\n")
+      end
     end
 
     # Collects any configfiles supplied by components

data/lib/vanagon/project/dsl.rb

@@ -208,11 +208,17 @@ class Vanagon
         @project.cleanup = true
       end
 
-      # This method will write the projects version to a designated file during package creation
+      # This method will write the project's version to a designated file during package creation
       # @param target [String] a full path to the version file for the project
       def write_version_file(target)
         @project.version_file = Vanagon::Common::Pathname.file(target)
       end
+
+      # This method will write the project's bill-of-materials to a designated directory during package creation.
+      # @param target [String] a full path to the directory for the bill-of-materials for the project
+      def bill_of_materials(target)
+        @project.bill_of_materials = Vanagon::Common::Pathname.new(target)
+      end
     end
   end
 end

data/lib/vanagon/utilities.rb

@@ -241,21 +241,17 @@ class Vanagon
     #                        output of the command if return_command_output is true
     # @raise [RuntimeError] If there is no target given or the command fails an exception is raised
     def remote_ssh_command(target, command, port = 22, return_command_output: false)
-      if target
-        puts "Executing '#{command}' on #{target}"
-        if return_command_output
-          ret = %x(#{ssh_command(port)} -T #{target} '#{command.gsub("'", "'\\\\''")}').chomp
-          if $?.success?
-            return ret
-          else
-            raise "Remote ssh command (#{command}) failed on '#{target}'."
-          end
+      puts "Executing '#{command}' on '#{target}'"
+      if return_command_output
+        ret = %x(#{ssh_command(port)} -T #{target} '#{command.gsub("'", "'\\\\''")}').chomp
+        if $?.success?
+          return ret
         else
-          Kernel.system("#{ssh_command(port)} -T #{target} '#{command.gsub("'", "'\\\\''")}'")
-          $?.success? or raise "Remote ssh command (#{command}) failed on '#{target}'."
+          raise "Remote ssh command (#{command}) failed on '#{target}'."
         end
       else
-        fail "Need a target to ssh to. Received none."
+        Kernel.system("#{ssh_command(port)} -T #{target} '#{command.gsub("'", "'\\\\''")}'")
+        $?.success? or raise "Remote ssh command (#{command}) failed on '#{target}'."
       end
     end
 

data/spec/lib/vanagon/component/dsl_spec.rb

@@ -196,16 +196,116 @@ end" }
   end
 
   describe '#add_actions' do
-    it 'adds the corect preinstall action to the component for rpm platforms' do
+    it 'adds the corect preinstall action to the component' do
       comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
-      comp.add_preinstall_action('chkconfig --list')
-      expect(comp._component.preinstall_actions).to include("chkconfig --list")
+      comp.add_preinstall_action(['install', 'upgrade'], ['chkconfig --list', '/bin/true'])
+      comp.add_preinstall_action('install', 'echo "hello, world"')
+      expect(comp._component.preinstall_actions.count).to eq(2)
+      expect(comp._component.preinstall_actions.first.scripts.count).to eq(2)
+      expect(comp._component.preinstall_actions.first.pkg_state.count).to eq(2)
+      expect(comp._component.preinstall_actions.first.pkg_state.first).to eq('install')
+      expect(comp._component.preinstall_actions.first.pkg_state.last).to eq('upgrade')
+      expect(comp._component.preinstall_actions.first.scripts.first).to eq('chkconfig --list')
+      expect(comp._component.preinstall_actions.first.scripts.last).to eq('/bin/true')
+
+      expect(comp._component.preinstall_actions.last.scripts.count).to eq(1)
+      expect(comp._component.preinstall_actions.last.pkg_state.count).to eq(1)
+      expect(comp._component.preinstall_actions.last.pkg_state.first).to eq('install')
+      expect(comp._component.preinstall_actions.last.scripts.first).to eq('echo "hello, world"')
+    end
+
+    it 'fails with bad preinstall action' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      expect { comp.add_preinstall_action('foo', '/bin/true') }.to raise_error(Vanagon::Error)
+    end
+
+    it 'fails with empty preinstall action' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      expect { comp.add_preinstall_action([], '/bin/true') }.to raise_error(Vanagon::Error)
+    end
+
+    it 'adds the corect postinstall action to the component' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      comp.add_postinstall_action(['install', 'upgrade'], ['chkconfig --list', '/bin/true'])
+      comp.add_postinstall_action('install', 'echo "hello, world"')
+      expect(comp._component.postinstall_actions.count).to eq(2)
+      expect(comp._component.postinstall_actions.first.scripts.count).to eq(2)
+      expect(comp._component.postinstall_actions.first.pkg_state.count).to eq(2)
+      expect(comp._component.postinstall_actions.first.pkg_state.first).to eq('install')
+      expect(comp._component.postinstall_actions.first.pkg_state.last).to eq('upgrade')
+      expect(comp._component.postinstall_actions.first.scripts.first).to eq('chkconfig --list')
+      expect(comp._component.postinstall_actions.first.scripts.last).to eq('/bin/true')
+
+      expect(comp._component.postinstall_actions.last.scripts.count).to eq(1)
+      expect(comp._component.postinstall_actions.last.pkg_state.count).to eq(1)
+      expect(comp._component.postinstall_actions.last.pkg_state.first).to eq('install')
+      expect(comp._component.postinstall_actions.last.scripts.first).to eq('echo "hello, world"')
+    end
+
+    it 'fails with bad postinstall action' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      expect { comp.add_postinstall_action('foo', '/bin/true') }.to raise_error(Vanagon::Error)
+    end
+
+    it 'fails with empty postinstall action' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      expect { comp.add_postinstall_action([], '/bin/true') }.to raise_error(Vanagon::Error)
+    end
+
+    it 'adds the corect preremove action to the component' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      comp.add_preremove_action(['removal', 'upgrade'], ['chkconfig --list', '/bin/true'])
+      comp.add_preremove_action('removal', 'echo "hello, world"')
+      expect(comp._component.preremove_actions.count).to eq(2)
+      expect(comp._component.preremove_actions.first.scripts.count).to eq(2)
+      expect(comp._component.preremove_actions.first.pkg_state.count).to eq(2)
+      expect(comp._component.preremove_actions.first.pkg_state.first).to eq('removal')
+      expect(comp._component.preremove_actions.first.pkg_state.last).to eq('upgrade')
+      expect(comp._component.preremove_actions.first.scripts.first).to eq('chkconfig --list')
+      expect(comp._component.preremove_actions.first.scripts.last).to eq('/bin/true')
+
+      expect(comp._component.preremove_actions.last.scripts.count).to eq(1)
+      expect(comp._component.preremove_actions.last.pkg_state.count).to eq(1)
+      expect(comp._component.preremove_actions.last.pkg_state.first).to eq('removal')
+      expect(comp._component.preremove_actions.last.scripts.first).to eq('echo "hello, world"')
+    end
+
+    it 'fails with bad preremove action' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      expect { comp.add_preremove_action('foo', '/bin/true') }.to raise_error(Vanagon::Error)
+    end
+
+    it 'fails with empty preremove action' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      expect { comp.add_preremove_action([], '/bin/true') }.to raise_error(Vanagon::Error)
+    end
+
+    it 'adds the corect postremove action to the component' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      comp.add_postremove_action(['removal', 'upgrade'], ['chkconfig --list', '/bin/true'])
+      comp.add_postremove_action('removal', 'echo "hello, world"')
+      expect(comp._component.postremove_actions.count).to eq(2)
+      expect(comp._component.postremove_actions.first.scripts.count).to eq(2)
+      expect(comp._component.postremove_actions.first.pkg_state.count).to eq(2)
+      expect(comp._component.postremove_actions.first.pkg_state.first).to eq('removal')
+      expect(comp._component.postremove_actions.first.pkg_state.last).to eq('upgrade')
+      expect(comp._component.postremove_actions.first.scripts.first).to eq('chkconfig --list')
+      expect(comp._component.postremove_actions.first.scripts.last).to eq('/bin/true')
+
+      expect(comp._component.postremove_actions.last.scripts.count).to eq(1)
+      expect(comp._component.postremove_actions.last.pkg_state.count).to eq(1)
+      expect(comp._component.postremove_actions.last.pkg_state.first).to eq('removal')
+      expect(comp._component.postremove_actions.last.scripts.first).to eq('echo "hello, world"')
+    end
+
+    it 'fails with bad postremove action' do
+      comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
+      expect { comp.add_postremove_action('foo', '/bin/true') }.to raise_error(Vanagon::Error)
     end
 
-    it 'adds the corect postinstall action to the component for rpm platforms' do
+    it 'fails with empty postremove action' do
       comp = Vanagon::Component::DSL.new('action-test', {}, dummy_platform_sysv)
-      comp.add_postinstall_action('chkconfig --list')
-      expect(comp._component.postinstall_actions).to include("chkconfig --list")
+      expect { comp.add_postremove_action([], '/bin/true') }.to raise_error(Vanagon::Error)
     end
   end
 

data/spec/lib/vanagon/engine/pooler_spec.rb

@@ -38,6 +38,8 @@ describe 'Vanagon::Engine::Pooler' do
     end
 
     it 'returns nil if there is no env var or file' do
+      expect(File).to receive(:expand_path).with('~/.vanagon-token').and_return(token_filename)
+      expect(File).to receive(:exist?).with(token_filename).and_return(false)
       expect(Vanagon::Engine::Pooler.new(platform).token).to be_nil
     end
   end

data/spec/lib/vanagon/platform/dsl_spec.rb

@@ -5,7 +5,7 @@ describe 'Vanagon::Platform::DSL' do
   let (:el_5_platform_block)   { "platform 'el-5-fixture'        do |plat| end" }
   let (:el_6_platform_block)   { "platform 'el-6-fixture'        do |plat| end" }
   let (:sles_platform_block)   { "platform 'sles-test-fixture'   do |plat| end" }
-  let (:nxos_5_platform_block) { "platform 'nxos-5-fixture'      do |plat| end" }
+  let (:cicso_wrlinux_platform_block) { "platform 'cisco-wrlinux-fixture'      do |plat| end" }
   let (:solaris_10_platform_block) { "platform 'solaris-10-fixture'      do |plat| end" }
   let (:solaris_11_platform_block) { "platform 'solaris-11-fixture'      do |plat| end" }
 
@@ -15,11 +15,12 @@ describe 'Vanagon::Platform::DSL' do
   let(:el_definition) { "http://builds.delivery.puppetlabs.net/puppet-agent/0.2.1/repo_configs/rpm/pl-puppet-agent-0.2.1-el-7-x86_64" }
   let(:el_definition_rpm) { "http://builds.delivery.puppetlabs.net/puppet-agent/0.2.1/repo_configs/rpm/pl-puppet-agent-0.2.1-release.rpm" }
   let(:sles_definition) { "http://builds.delivery.puppetlabs.net/puppet-agent/0.2.2/repo_configs/rpm/pl-puppet-agent-0.2.2-sles-12-x86_64" }
-  let(:sles_definition_rpm) { "http://builds.delivery.puppetlabs.net/puppet-agent/0.2.1/repo_configs/rpm/pl-puppet-agent-0.2.1-release.rpm" }
-  let(:nxos_definition) { "http://builds.delivery.puppetlabs.net/puppet-agent/0.2.1/repo_configs/rpm/pl-puppet-agent-0.2.1-nxos-5-x86_64.repo" }
+  let(:sles_definition_rpm) { "http://builds.delivery.puppetlabs.net/puppet-agent/0.2.1/repo_configs/rpm/pl-puppet-agent-0.2.1-release-sles.rpm" }
+  let(:cisco_wrlinux_definition) { "http://builds.delivery.puppetlabs.net/puppet-agent/0.2.1/repo_configs/rpm/pl-puppet-agent-0.2.1-cisco-wrlinux-5-x86_64.repo" }
 
   let(:hex_value) { "906264d248061b0edb1a576cc9c8f6c7" }
 
+  # These apt_repo, yum_repo, and zypper_repo methods are all deprecated.
   describe '#apt_repo' do
     it "grabs the file and adds .list to it" do
       plat = Vanagon::Platform::DSL.new('debian-test-fixture')
@@ -54,26 +55,21 @@ describe 'Vanagon::Platform::DSL' do
       expect(plat._platform.provisioning).to include("curl -o '/etc/yum.repos.d/#{hex_value}-pl-puppet-agent-0.2.1-el-7-x86_64.repo' '#{el_definition}'")
     end
 
-    it "downloads the repo file to the correct yum location for nxos" do
-      plat = Vanagon::Platform::DSL.new('nxos-5-fixture')
+    # This test currently covers wrlinux 5 and 7
+    it "downloads the repo file to the correct yum location for wrlinux" do
+      plat = Vanagon::Platform::DSL.new('cisco-wrlinux-fixture')
       expect(SecureRandom).to receive(:hex).and_return(hex_value)
-      plat.instance_eval(nxos_5_platform_block)
-      plat.yum_repo(nxos_definition)
-      expect(plat._platform.provisioning).to include("curl -o '/etc/yum/repos.d/#{hex_value}-pl-puppet-agent-0.2.1-nxos-5-x86_64.repo' '#{nxos_definition}'")
+      plat.instance_eval(cicso_wrlinux_platform_block)
+      plat.yum_repo(cisco_wrlinux_definition)
+      expect(plat._platform.provisioning).to include("curl -o '/etc/yum/repos.d/#{hex_value}-pl-puppet-agent-0.2.1-cisco-wrlinux-5-x86_64.repo' '#{cisco_wrlinux_definition}'")
     end
 
     describe "installs a rpm when given a rpm" do
-      it 'uses yum on el 6 and higher' do
-        plat = Vanagon::Platform::DSL.new('el-6-fixture')
-        plat.instance_eval(el_6_platform_block)
-        plat.yum_repo(el_definition_rpm)
-        expect(plat._platform.provisioning).to include("yum localinstall -y '#{el_definition_rpm}'")
-      end
-
-      it 'uses rpm on el 5 and lower' do
+      it 'uses rpm everywhere' do
         plat = Vanagon::Platform::DSL.new('el-5-fixture')
         plat.instance_eval(el_5_platform_block)
         plat.yum_repo(el_definition_rpm)
+        expect(plat._platform.provisioning).to include("rpm -q curl > /dev/null || yum -y install curl")
         expect(plat._platform.provisioning).to include("curl -o local.rpm '#{el_definition_rpm}'; rpm -Uvh local.rpm; rm -f local.rpm")
       end
     end

data/spec/lib/vanagon/platform/rpm/aix_spec.rb

@@ -0,0 +1,29 @@
+require 'vanagon/platform'
+
+describe "Vanagon::Platform::RPM::AIX" do
+  let(:block) {
+    %Q[ platform "aix-5.3-ppc" do |plat|
+    end
+    ]
+  }
+  let(:plat) { Vanagon::Platform::DSL.new('aix-5.3-ppc') }
+
+  before do
+    plat.instance_eval(block)
+  end
+
+  describe '#rpm_defines' do
+    it "doesn't include dist on aix" do
+      expect(plat._platform.rpm_defines).to_not include('dist')
+    end
+  end
+
+  describe "aix puts commands in weird places" do
+    it "uses /opt/freeware/bin everwhere" do
+      ['tar', 'patch', 'install'].each do |cmd|
+        expect(plat._platform.send(cmd.to_sym)).to eq(File.join('/opt/freeware/bin', cmd))
+      end
+    end
+  end
+end
+