(gh-20) Add a task to check the version of the puppet binary

jpartlow · jpartlow · commit efc33cf2a31a · 2025-05-31T15:31:56.000-07:00
Provides a consistent way of verifying the installed version for
acceptance testing.

Version comparison is handled by Ruby's Gem::Version class.
The agent's ruby is used to run the task.
If Bolt knows the target has the puppet-agent, then the check.rb is run.
If Bolt doesn't know whether puppet-agent is in place, the shell script
is run, which will check for the puppet binary and either fail or kick
off the check.rb if found.
diff --git a/spec/tasks/check_spec.rb b/spec/tasks/check_spec.rb
@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../../tasks/check'
+
+describe 'openvox_bootstrap::check' do
+  before do
+    allow(OpenvoxBootstrap::Check).to receive(:puppet_version).and_return('8.0.0')
+  end
+
+  describe '.run' do
+    let(:input) do
+      {
+        version: nil
+      }
+    end
+    let(:expected_output) do
+      {
+        puppet_version: '8.0.0',
+        valid: true
+      }
+    end
+
+    def validate_task_run(input:, expected: {}, code: 0)
+      old_stdin = $stdin
+      $stdin = StringIO.new(input.to_json)
+      old_stdout = $stdout
+      $stdout = StringIO.new
+
+      begin
+        OpenvoxBootstrap::Check.run
+      rescue SystemExit => e
+        expect(e.status).to eq(code)
+      end
+
+      output = JSON.parse($stdout.string, symbolize_names: true)
+      expect(output).to eq(expected)
+    ensure
+      $stdin = old_stdin
+      $stdout = old_stdout
+    end
+
+    it 'raises for empty input' do
+      expect do
+        validate_task_run(input: nil)
+      end.to raise_error(ArgumentError)
+    end
+
+    it 'returns version without test if given no args' do
+      validate_task_run(input: input, expected: expected_output)
+    end
+
+    context 'testing valid version' do
+      it 'returns successfully' do
+        input[:version] = '8.0.0'
+
+        expected_output[:test] = 'eq'
+        expected_output[:test_version] = '8.0.0'
+
+        validate_task_run(input: input, expected: expected_output)
+      end
+    end
+
+    context 'testing invalid version' do
+      it 'returns non-zero' do
+        input[:version] = '8.1.0'
+        input[:test] = 'gt'
+
+        expected_output[:valid] = false
+        expected_output[:test] = 'gt'
+        expected_output[:test_version] = '8.1.0'
+
+        validate_task_run(input: input, expected: expected_output, code: 1)
+      end
+    end
+  end
+
+  describe '#task' do
+    let(:check) { OpenvoxBootstrap::Check.new }
+
+    context 'eq' do
+      it 'returns true for equal versions' do
+        expect(check.task(version: '8.0.0')).to(
+          eq(
+            {
+              puppet_version: '8.0.0',
+              valid: true,
+              test: 'eq',
+              test_version: '8.0.0'
+            }
+          )
+        )
+      end
+
+      it 'returns false for unequal versions' do
+        expect(check.task(version: '8.0.1')).to(
+          eq(
+            {
+              puppet_version: '8.0.0',
+              valid: false,
+              test: 'eq',
+              test_version: '8.0.1'
+            }
+          )
+        )
+      end
+    end
+
+    context 'ge' do
+      it 'returns true for greater than versions' do
+        expect(check.task(version: '7.0.0', test: 'ge')).to(
+          eq(
+            {
+              puppet_version: '8.0.0',
+              valid: true,
+              test: 'ge',
+              test_version: '7.0.0'
+            }
+          )
+        )
+      end
+
+      it 'returns true for equal versions' do
+        expect(check.task(version: '8.0.0', test: 'ge')).to(include(valid: true))
+      end
+
+      it 'returns false for less than versions' do
+        expect(check.task(version: '9.0.0', test: 'ge')).to(
+          eq(
+            {
+              puppet_version: '8.0.0',
+              valid: false,
+              test: 'ge',
+              test_version: '9.0.0'
+            }
+          )
+        )
+      end
+    end
+
+    context 'gt' do
+      it 'is valid for greater than versions' do
+        expect(check.task(version: '7.0.0', test: 'gt')).to(include(valid: true))
+      end
+
+      it 'is invalid for equal versions or less than versions' do
+        expect(check.task(version: '8.0.0', test: 'gt')).to(include(valid: false))
+        expect(check.task(version: '8.0.1', test: 'gt')).to(include(valid: false))
+      end
+    end
+
+    context 'lt' do
+      it 'is valid for less than versions' do
+        expect(check.task(version: '8.0.1', test: 'lt')).to(include(valid: true))
+      end
+
+      it 'is invalid for equal versions or greater than versions' do
+        expect(check.task(version: '8.0.0', test: 'lt')).to(include(valid: false))
+        expect(check.task(version: '7.0.0', test: 'lt')).to(include(valid: false))
+      end
+    end
+
+    context 'le' do
+      it 'is valid for less than or equal versions' do
+        expect(check.task(version: '9.0.0', test: 'le')).to(include(valid: true))
+        expect(check.task(version: '8.0.0', test: 'le')).to(include(valid: true))
+      end
+
+      it 'is invalid for greater than versions' do
+        expect(check.task(version: '7.0.0', test: 'le')).to(include(valid: false))
+      end
+    end
+  end
+end
diff --git a/tasks/check.json b/tasks/check.json
@@ -0,0 +1,29 @@
+{
+  "description": "Check whether a Puppet(tm) implementation is installed. Optionally checks the version.",
+  "parameters": {
+    "version": {
+      "description": "The version of the implementation to check. To check if version meets a minimum, set test to 'ge' and version to x, x.y or x.y.z",
+      "type": "Optional[String]"
+    },
+    "test": {
+      "description": "Version comparison operator.",
+      "type": "Enum['eq', 'lt', 'le', 'gt', 'ge']",
+      "default": "eq"
+    }
+  },
+  "implementations": [
+    {
+      "name": "check.rb",
+      "input_method": "stdin",
+      "requirements": ["puppet-agent"]
+    },
+    {
+      "name": "check_linux.sh",
+      "input_method": "environment",
+      "requirements": ["shell"],
+      "files": [
+        "openvox_bootstrap/tasks/check.rb"
+      ]
+    }
+  ]
+}
diff --git a/tasks/check.rb b/tasks/check.rb
@@ -0,0 +1,71 @@
+#! /opt/puppetlabs/puppet/bin/ruby
+# frozen_string_literal: true
+
+require 'json'
+
+module OpenvoxBootstrap
+  class Check
+    # Get the Puppet version from the installed Puppet library.
+    #
+    # "require 'puppet/version'" can be fooled by the Ruby environment
+    # if the gem is installed. For example:
+    #
+    #   bolt task run openvox_bootstrap::check --targets localhost
+    #
+    # will be executed using the bolt package's Ruby environment,
+    # which includes a puppet gem that will mostly likely be out of
+    # sync with the installed Puppet version.
+    def self.puppet_version
+      require '/opt/puppetlabs/puppet/lib/ruby/vendor_ruby/puppet/version'
+      Puppet.version
+    end
+
+    # Run the task and print the result as JSON.
+    def self.run
+      params = JSON.parse($stdin.read)
+      raise(ArgumentError, <<~ERR) unless params.is_a?(Hash)
+        Expected a Hash, got #{params.class}: #{params.inspect}
+      ERR
+
+      params.transform_keys!(&:to_sym)
+      # Clean out empty params so that task defaults are used.
+      params.delete_if { |_, v| v.nil? || v == '' }
+
+      result = Check.new.task(**params)
+      puts JSON.pretty_generate(result)
+      result[:valid] ? exit(0) : exit(1)
+    end
+
+    def task(version: nil, test: 'eq', **_kwargs)
+      puppet_version = Gem::Version.new(OpenvoxBootstrap::Check.puppet_version)
+      result = {
+        puppet_version: puppet_version.to_s,
+      }
+      result[:valid] = if version.nil? || version.empty?
+                         true
+                       else
+                         test_version = Gem::Version.new(version)
+                         result[:test] = test
+                         result[:test_version] = version
+                         case test
+                         when 'eq'
+                           puppet_version == test_version
+                         when 'lt'
+                           puppet_version < test_version
+                         when 'le'
+                           puppet_version <= test_version
+                         when 'gt'
+                           puppet_version > test_version
+                         when 'ge'
+                           puppet_version >= test_version
+                         else
+                           raise ArgumentError, "Unknown test: '#{test}'"
+                         end
+                       end
+
+      result
+    end
+  end
+end
+
+OpenvoxBootstrap::Check.run if __FILE__ == $PROGRAM_NAME
diff --git a/tasks/check_linux.sh b/tasks/check_linux.sh
@@ -0,0 +1,21 @@
+#! /usr/bin/env bash
+
+set -e
+
+declare PT__installdir
+declare PT_version
+declare PT_test
+
+bindir='/opt/puppetlabs/puppet/bin'
+
+if ! [ -f "${bindir}/puppet" ]; then
+  echo "Error: No puppet binary found at '${bindir}/puppet'. Is the package installed?"
+  exit 1
+fi
+
+"${bindir}/ruby" "${PT__installdir}/openvox_bootstrap/tasks/check.rb" <<JSON
+{
+  "version": "${PT_version}",
+  "test": "${PT_test}"
+}
+JSON
