(FACT-2638) Use puppet AIO VERSION file to specify AIO version

.github/workflows/checks.yaml

@@ -29,7 +29,7 @@ jobs:
     name: RuboCop TODO
     steps:
       - uses: actions/checkout@v1
-      - uses: gimmyxd/[email protected].0
+      - uses: gimmyxd/[email protected].1
         env:
           RTC_TOKEN: ${{ secrets.RTC_TOKEN }}
           UPDATE_PR: false

lib/facts/aix/aio_agent_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    class AioAgentVersion
+      FACT_NAME = 'aio_agent_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::AioAgentVersion.resolve(:aio_agent_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

lib/facts/linux/aio_agent_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    class AioAgentVersion
+      FACT_NAME = 'aio_agent_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::AioAgentVersion.resolve(:aio_agent_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

lib/facts/macosx/aio_agent_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Macosx
+    class AioAgentVersion
+      FACT_NAME = 'aio_agent_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::AioAgentVersion.resolve(:aio_agent_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

lib/facts/solaris/aio_agent_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class AioAgentVersion
+      FACT_NAME = 'aio_agent_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::AioAgentVersion.resolve(:aio_agent_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

lib/facts/windows/aio_agent_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class AioAgentVersion
+      FACT_NAME = 'aio_agent_version'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Windows::AioAgentVersion.resolve(:aio_version)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

lib/resolvers/agent_resolver.rb → lib/resolvers/aio_agent_version.rb

@@ -2,7 +2,7 @@
 
 module Facter
   module Resolvers
-    class Agent < BaseResolver
+    class AioAgentVersion < BaseResolver
       @semaphore = Mutex.new
       @fact_list ||= {}
 
@@ -14,8 +14,8 @@ def post_resolve(fact_name)
         end
 
         def read_agent_version
-          version_file = ::File.join(ROOT_DIR, 'lib/puppet/VERSION')
-          @fact_list[:aio_agent_version] = ::File.read(version_file)
+          aio_agent_version = Util::FileHelper.safe_read('/opt/puppetlabs/puppet/VERSION', nil).chomp
+          @fact_list[:aio_agent_version] = aio_agent_version
         end
       end
     end

lib/resolvers/windows/aio_agent_version.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class AioAgentVersion < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_version(fact_name) }
+          end
+
+          def read_version(fact_name)
+            reg = ::Win32::Registry::HKEY_LOCAL_MACHINE.open('SOFTWARE\\Puppet Labs\\Puppet')
+            build_fact_list(reg)
+            reg.close
+
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(reg)
+            puppet_aio_path = read_for_64_bit(reg) || read_for_32_bit(reg)
+
+            return unless puppet_aio_path
+
+            puppet_aio_version_path = File.join(puppet_aio_path, 'VERSION')
+            @fact_list[:aio_version] = Util::FileHelper.safe_read(puppet_aio_version_path, nil).chomp
+          end
+
+          def read_for_64_bit(reg)
+            reg.read('RememberedInstallDir64')[1]
+          rescue Win32::Registry::Error
+            log.debug('Could not read Puppet AIO path from 64 bit registry')
+            nil
+          end
+
+          def read_for_32_bit(reg)
+            reg.read('RememberedInstallDir')[1]
+          rescue Win32::Registry::Error
+            log.debug('Could not read Puppet AIO path from 32 bit registry')
+            nil
+          end
+        end
+      end
+    end
+  end
+end

spec/facter/facts/aix/aio_agent_version_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe Facts::Aix::AioAgentVersion do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Aix::AioAgentVersion.new }
+
+    let(:value) { '1.2.3' }
+
+    before do
+      allow(Facter::Resolvers::AioAgentVersion).to receive(:resolve).with(:aio_agent_version).and_return(value)
+    end
+
+    it 'calls Facter::Resolvers::Agent' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::AioAgentVersion).to have_received(:resolve).with(:aio_agent_version)
+    end
+
+    it 'returns aio_agent_version fact' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'aio_agent_version', value: value)
+    end
+  end
+end

spec/facter/facts/linux/aio_agent_version_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe Facts::Linux::AioAgentVersion do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Linux::AioAgentVersion.new }
+
+    let(:value) { '1.2.3' }
+
+    before do
+      allow(Facter::Resolvers::AioAgentVersion).to receive(:resolve).with(:aio_agent_version).and_return(value)
+    end
+
+    it 'calls Facter::Resolvers::Agent' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::AioAgentVersion).to have_received(:resolve).with(:aio_agent_version)
+    end
+
+    it 'returns aio_agent_version fact' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'aio_agent_version', value: value)
+    end
+  end
+end

spec/facter/facts/macosx/aio_agent_version_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe Facts::Macosx::AioAgentVersion do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Macosx::AioAgentVersion.new }
+
+    let(:value) { '1.2.3' }
+
+    before do
+      allow(Facter::Resolvers::AioAgentVersion).to receive(:resolve).with(:aio_agent_version).and_return(value)
+    end
+
+    it 'calls Facter::Resolvers::Agent' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::AioAgentVersion).to have_received(:resolve).with(:aio_agent_version)
+    end
+
+    it 'returns aio_agent_version fact' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'aio_agent_version', value: value)
+    end
+  end
+end

spec/facter/facts/solaris/aio_agent_version_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe Facts::Solaris::AioAgentVersion do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Solaris::AioAgentVersion.new }
+
+    let(:value) { '1.2.3' }
+
+    before do
+      allow(Facter::Resolvers::AioAgentVersion).to receive(:resolve).with(:aio_agent_version).and_return(value)
+    end
+
+    it 'calls Facter::Resolvers::Agent' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::AioAgentVersion).to have_received(:resolve).with(:aio_agent_version)
+    end
+
+    it 'returns aio_agent_version fact' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'aio_agent_version', value: value)
+    end
+  end
+end

spec/facter/resolvers/aio_agent_version_spec.rb

@@ -1,10 +1,22 @@
 # frozen_string_literal: true
 
-describe Facter::Resolvers::Agent do
+describe Facter::Resolvers::AioAgentVersion do
   describe '#resolve' do
+    before do
+      allow(Facter::Util::FileHelper)
+        .to receive(:safe_read)
+        .with('/opt/puppetlabs/puppet/VERSION', nil)
+        .and_return('7.0.1')
+    end
+
+    it 'calls FileHelper.safe_read' do
+      Facter::Resolvers::AioAgentVersion.resolve(:aio_agent_version)
+
+      expect(Facter::Util::FileHelper).to have_received(:safe_read).with('/opt/puppetlabs/puppet/VERSION', nil)
+    end
+
     it 'detects puppet version' do
-      allow(File).to receive(:read).with("#{ROOT_DIR}/lib/puppet/VERSION").and_return('7.0.1')
-      expect(Facter::Resolvers::Agent.resolve(:aio_agent_version)).to eql('7.0.1')
+      expect(Facter::Resolvers::AioAgentVersion.resolve(:aio_agent_version)).to eql('7.0.1')
     end
   end
 end

spec/facter/resolvers/windows/aio_agent_version_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+describe Facter::Resolvers::Windows::AioAgentVersion do
+  describe '#resolve' do
+    subject(:aio_agent_resolver) { Facter::Resolvers::Windows::AioAgentVersion }
+
+    let(:puppet_version) { '7.0.1' }
+    let(:reg) { instance_spy(Win32::Registry::HKEY_LOCAL_MACHINE) }
+    let(:log) { instance_spy(Facter::Log) }
+
+    before do
+      allow(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open).with('SOFTWARE\\Puppet Labs\\Puppet').and_return(reg)
+      allow(reg).to receive(:close)
+      allow(Facter::Util::FileHelper)
+        .to receive(:safe_read).with('path_to_puppet/VERSION', nil)
+                               .and_return(puppet_version)
+    end
+
+    after do
+      Facter::Resolvers::Windows::AioAgentVersion.invalidate_cache
+    end
+
+    context 'when windows is 64 bit edition' do
+      before do
+        allow(reg).to receive(:read).with('RememberedInstallDir64').and_return([1, 'path_to_puppet'])
+      end
+
+      it 'returns path from registry specific to 64 bit windows' do
+        expect(aio_agent_resolver.resolve(:aio_version)).to eq(puppet_version)
+      end
+    end
+
+    context 'when windows is 32 bit edition' do
+      before do
+        allow(reg).to receive(:read).with('RememberedInstallDir64').and_raise(Win32::Registry::Error)
+        allow(reg).to receive(:read).with('RememberedInstallDir').and_return([1, 'path_to_puppet'])
+        allow(Facter::Resolvers::BaseResolver).to receive(:log).and_return(log)
+      end
+
+      it 'logs debug message for 64 bit register' do
+        aio_agent_resolver.resolve(:aio_version)
+
+        expect(log).to have_received(:debug).with('Could not read Puppet AIO path from 64 bit registry')
+      end
+
+      it 'returns path from registry specific to 32 bit windows' do
+        expect(aio_agent_resolver.resolve(:aio_version)).to eq(puppet_version)
+      end
+
+      context 'when there is no registry entry for 32 bit version' do
+        before do
+          allow(reg).to receive(:read).with('RememberedInstallDir').and_raise(Win32::Registry::Error)
+        end
+
+        it 'logs debug error for 32 bit registry' do
+          aio_agent_resolver.resolve(:aio_version)
+
+          expect(log).to have_received(:debug).with('Could not read Puppet AIO path from 32 bit registry')
+        end
+      end
+    end
+  end
+end

spec/mocks/win32_mock.rb

@@ -14,6 +14,8 @@ def each; end
       def [](*); end
 
       def keys; end
+
+      def read(*); end
     end
   end
 end

spec/mocks/win32_registry_error_mock.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Win32
+  module Registry
+    class Error < RuntimeError
+    end
+  end
+end