(FACT-2693) Add systemd_nspawn fact

lib/facts/linux/hypervisors/docker.rb

@@ -12,7 +12,7 @@ def call_the_resolver
         end
 
         def check_docker
-          info = Facter::Resolvers::DockerLxc.resolve(:hypervisor)
+          info = Facter::Resolvers::Containers.resolve(:hypervisor)
           info[:docker] if info
         end
       end

lib/facts/linux/hypervisors/lxc.rb

@@ -12,7 +12,7 @@ def call_the_resolver
         end
 
         def check_lxc
-          info = Facter::Resolvers::DockerLxc.resolve(:hypervisor)
+          info = Facter::Resolvers::Containers.resolve(:hypervisor)
           info[:lxc] if info
         end
       end

lib/facts/linux/hypervisors/systemd_nspawn.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class SystemdNspawn
+        FACT_NAME = 'hypervisors.systemd_nspawn'
+
+        def call_the_resolver
+          fact_value = check_nspawn
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+
+        def check_nspawn
+          info = Facter::Resolvers::Containers.resolve(:hypervisor)
+          info[:systemd_nspawn] if info
+        end
+      end
+    end
+  end
+end

lib/facts/linux/is_virtual.rb

@@ -20,7 +20,7 @@ def check_gce
       end
 
       def check_docker_lxc
-        Facter::Resolvers::DockerLxc.resolve(:vm)
+        Facter::Resolvers::Containers.resolve(:vm)
       end
 
       def check_vmware

lib/facts/linux/virtual.rb

@@ -18,7 +18,7 @@ def check_gce
       end
 
       def check_docker_lxc
-        Facter::Resolvers::DockerLxc.resolve(:vm)
+        Facter::Resolvers::Containers.resolve(:vm)
       end
 
       def check_vmware

lib/resolvers/docker_lxc.rb → lib/resolvers/containers.rb

@@ -2,7 +2,7 @@
 
 module Facter
   module Resolvers
-    class DockerLxc < BaseResolver
+    class Containers < BaseResolver
       # :virtual
       # :hypervisor
 
@@ -20,13 +20,14 @@ def post_resolve(fact_name)
         def read_cgroup(fact_name)
           output_cgroup = Util::FileHelper.safe_read('/proc/1/cgroup', nil)
           output_environ = Util::FileHelper.safe_read('/proc/1/environ', nil)
-          return if output_cgroup.nil? || output_environ.nil?
+          return unless output_cgroup && output_environ
 
           output_docker = %r{docker/(.+)}.match(output_cgroup)
           output_lxc = %r{^/lxc/([^/]+)}.match(output_cgroup)
           lxc_from_environ = /container=lxc/ =~ output_environ
 
           info, vm = extract_vm_and_info(output_docker, output_lxc, lxc_from_environ)
+          info, vm = extract_for_nspawn(output_environ) unless vm
           @fact_list[:vm] = vm
           @fact_list[:hypervisor] = { vm.to_sym => info } if vm
           @fact_list[fact_name]
@@ -43,6 +44,15 @@ def extract_vm_and_info(output_docker, output_lxc, lxc_from_environ)
 
           [info ? { INFO[vm] => info } : {}, vm]
         end
+
+        def extract_for_nspawn(output_environ)
+          nspawn = /container=systemd-nspawn/ =~ output_environ
+          if nspawn
+            vm = 'systemd_nspawn'
+            info = Util::FileHelper.safe_read('/etc/machine-id', nil)
+          end
+          [info ? { 'id' => info.strip } : {}, vm]
+        end
       end
     end
   end

spec/facter/facts/linux/hypervisors/docker_spec.rb

@@ -5,17 +5,17 @@
     subject(:fact) { Facts::Linux::Hypervisors::Docker.new }
 
     before do
-      allow(Facter::Resolvers::DockerLxc).to \
+      allow(Facter::Resolvers::Containers).to \
         receive(:resolve).with(:hypervisor).and_return(hv)
     end
 
     context 'when resolver returns docker' do
       let(:hv) { { docker: { 'id' => 'testid' } } }
       let(:value) { { 'id' => 'testid' } }
 
-      it 'calls Facter::Resolvers::DockerLxc' do
+      it 'calls Facter::Resolvers::Containers' do
         fact.call_the_resolver
-        expect(Facter::Resolvers::DockerLxc).to have_received(:resolve).with(:hypervisor)
+        expect(Facter::Resolvers::Containers).to have_received(:resolve).with(:hypervisor)
       end
 
       it 'returns virtual fact' do

spec/facter/facts/linux/hypervisors/lxc_spec.rb

@@ -5,17 +5,17 @@
     subject(:fact) { Facts::Linux::Hypervisors::Lxc.new }
 
     before do
-      allow(Facter::Resolvers::DockerLxc).to \
+      allow(Facter::Resolvers::Containers).to \
         receive(:resolve).with(:hypervisor).and_return(hv)
     end
 
     context 'when resolver returns lxc' do
       let(:hv) { { lxc: { 'name' => 'test_name' } } }
       let(:value) { { 'name' => 'test_name' } }
 
-      it 'calls Facter::Resolvers::DockerLxc' do
+      it 'calls Facter::Resolvers::Containers' do
         fact.call_the_resolver
-        expect(Facter::Resolvers::DockerLxc).to have_received(:resolve).with(:hypervisor)
+        expect(Facter::Resolvers::Containers).to have_received(:resolve).with(:hypervisor)
       end
 
       it 'returns virtual fact' do

spec/facter/facts/linux/hypervisors/systemd_nspawn_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+describe Facts::Linux::Hypervisors::SystemdNspawn do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Linux::Hypervisors::SystemdNspawn.new }
+
+    before do
+      allow(Facter::Resolvers::Containers).to \
+        receive(:resolve).with(:hypervisor).and_return(hv)
+    end
+
+    context 'when resolver returns systemd_nspawn' do
+      let(:hv) { { systemd_nspawn: { 'id' => 'testid00' } } }
+      let(:value) { { 'id' => 'testid00' } }
+
+      it 'calls Facter::Resolvers::Containers' do
+        fact.call_the_resolver
+        expect(Facter::Resolvers::Containers).to have_received(:resolve).with(:hypervisor)
+      end
+
+      it 'returns virtual fact' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'hypervisors.systemd_nspawn', value: value)
+      end
+    end
+
+    context 'when resolver returns docker' do
+      let(:hv) { { docker: { 'id' => 'testid' } } }
+
+      it 'returns virtual fact as nil' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'hypervisors.systemd_nspawn', value: nil)
+      end
+    end
+
+    context 'when resolver returns nil' do
+      let(:hv) { nil }
+
+      it 'returns virtual fact as nil' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'hypervisors.systemd_nspawn', value: hv)
+      end
+    end
+
+    context 'when systemd_nspawn info is empty' do
+      let(:hv) { { systemd_nspawn: {} } }
+      let(:value) { {} }
+
+      it 'returns virtual fact as empty array' do
+        expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+          have_attributes(name: 'hypervisors.systemd_nspawn', value: value)
+      end
+    end
+  end
+end

spec/facter/facts/linux/is_virtual_spec.rb

@@ -8,13 +8,13 @@
     let(:value) { true }
 
     before do
-      allow(Facter::Resolvers::DockerLxc).to \
+      allow(Facter::Resolvers::Containers).to \
         receive(:resolve).with(:vm).and_return(vm)
     end
 
-    it 'calls Facter::Resolvers::DockerLxc' do
+    it 'calls Facter::Resolvers::Containers' do
       fact.call_the_resolver
-      expect(Facter::Resolvers::DockerLxc).to have_received(:resolve).with(:vm)
+      expect(Facter::Resolvers::Containers).to have_received(:resolve).with(:vm)
     end
 
     it 'returns virtual fact' do

spec/facter/facts/linux/virtual_spec.rb

@@ -7,13 +7,13 @@
     let(:vm) { 'docker' }
 
     before do
-      allow(Facter::Resolvers::DockerLxc).to \
+      allow(Facter::Resolvers::Containers).to \
         receive(:resolve).with(:vm).and_return(vm)
     end
 
-    it 'calls Facter::Resolvers::DockerLxc' do
+    it 'calls Facter::Resolvers::Containers' do
       fact.call_the_resolver
-      expect(Facter::Resolvers::DockerLxc).to have_received(:resolve).with(:vm)
+      expect(Facter::Resolvers::Containers).to have_received(:resolve).with(:vm)
     end
 
     it 'returns virtual fact' do

spec/facter/resolvers/docker_lxc_spec.rb → spec/facter/resolvers/containers_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-describe Facter::Resolvers::DockerLxc do
-  subject(:docker_lxc_resolver) { Facter::Resolvers::DockerLxc }
+describe Facter::Resolvers::Containers do
+  subject(:containers_resolver) { Facter::Resolvers::Containers }
 
   before do
     allow(Facter::Util::FileHelper).to receive(:safe_read)
@@ -13,7 +13,7 @@
   end
 
   after do
-    docker_lxc_resolver.invalidate_cache
+    containers_resolver.invalidate_cache
   end
 
   context 'when hypervisor is docker' do
@@ -22,11 +22,31 @@
     let(:result) { { docker: { 'id' => 'ee6e3c05422f1273c9b41a26f2b4ec64bdb4480d63a1ad9741e05cafc1651b90' } } }
 
     it 'return docker for vm' do
-      expect(docker_lxc_resolver.resolve(:vm)).to eq('docker')
+      expect(containers_resolver.resolve(:vm)).to eq('docker')
     end
 
     it 'return docker info for hypervisor' do
-      expect(docker_lxc_resolver.resolve(:hypervisor)).to eq(result)
+      expect(containers_resolver.resolve(:hypervisor)).to eq(result)
+    end
+  end
+
+  context 'when hypervisor is nspawn' do
+    let(:cgroup_output) { load_fixture('cgroup_file').read }
+    let(:environ_output) { 'PATH=/usr/local/sbin:/bincontainer=systemd-nspawnTERM=xterm-256color' }
+    let(:result) { { systemd_nspawn: { 'id' => 'ee6e3c05422f1273c9b41a26f2b4ec64bdb4480d63a1ad9741e05cafc1651b90' } } }
+
+    before do
+      allow(Facter::Util::FileHelper).to receive(:safe_read)
+        .with('/etc/machine-id', nil)
+        .and_return("ee6e3c05422f1273c9b41a26f2b4ec64bdb4480d63a1ad9741e05cafc1651b90\n")
+    end
+
+    it 'return nspawn for vm' do
+      expect(containers_resolver.resolve(:vm)).to eq('systemd_nspawn')
+    end
+
+    it 'return nspawn info for hypervisor' do
+      expect(containers_resolver.resolve(:hypervisor)).to eq(result)
     end
   end
 
@@ -36,11 +56,11 @@
     let(:result) { { lxc: { 'name' => 'lxc_container' } } }
 
     it 'return lxc for vm' do
-      expect(docker_lxc_resolver.resolve(:vm)).to eq('lxc')
+      expect(containers_resolver.resolve(:vm)).to eq('lxc')
     end
 
     it 'return lxc info for hypervisor' do
-      expect(docker_lxc_resolver.resolve(:hypervisor)).to eq(result)
+      expect(containers_resolver.resolve(:hypervisor)).to eq(result)
     end
   end
 
@@ -50,11 +70,11 @@
     let(:result) { { lxc: {} } }
 
     it 'return lxc for vm' do
-      expect(docker_lxc_resolver.resolve(:vm)).to eq('lxc')
+      expect(containers_resolver.resolve(:vm)).to eq('lxc')
     end
 
     it 'return lxc info for hypervisor' do
-      expect(docker_lxc_resolver.resolve(:hypervisor)).to eq(result)
+      expect(containers_resolver.resolve(:hypervisor)).to eq(result)
     end
   end
 
@@ -64,11 +84,11 @@
     let(:result) { nil }
 
     it 'return lxc for vm' do
-      expect(docker_lxc_resolver.resolve(:vm)).to eq(nil)
+      expect(containers_resolver.resolve(:vm)).to eq(nil)
     end
 
     it 'return lxc info for hypervisor' do
-      expect(docker_lxc_resolver.resolve(:hypervisor)).to eq(result)
+      expect(containers_resolver.resolve(:hypervisor)).to eq(result)
     end
   end
 end