ohai 13.12.6 → 14.0.28

data/lib/ohai/plugins/virtualization.rb

@@ -1,83 +0,0 @@
-#
-# Author:: Benjamin Black (<bb@chef.io>)
-# Copyright:: Copyright (c) 2009-2016 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# Note: despite the name this is really a libvirt plugin.
-#       perhaps we'd be better off renaming it? -tsmith
-
-Ohai.plugin(:VirtualizationInfo) do
-  %w{ uri capabilities nodeinfo domains networks storage }.each do |info|
-    provides "virtualization/#{info}"
-  end
-
-  collect_data do
-    unless virtualization.nil? || !(virtualization[:role].eql?("host"))
-      begin
-        require "libvirt" # this is the ruby-libvirt gem not the libvirt gem
-
-        emu = (virtualization[:system].eql?("kvm") ? "qemu" : virtualization[:system])
-        virtualization[:libvirt_version] = Libvirt.version(emu)[0].to_s
-
-        virtconn = Libvirt.open_read_only("#{emu}:///system")
-
-        virtualization[:uri] = virtconn.uri
-        virtualization[:capabilities] = Mash.new
-
-        virtualization[:nodeinfo] = Mash.new
-        ni = virtconn.node_get_info
-        %w{cores cpus memory mhz model nodes sockets threads}.each { |a| virtualization[:nodeinfo][a] = ni.send(a) }
-
-        virtualization[:domains] = Mash.new
-        virtconn.list_domains.each do |d|
-          dv = virtconn.lookup_domain_by_id d
-          virtualization[:domains][dv.name] = Mash.new
-          virtualization[:domains][dv.name][:id] = d
-          %w{os_type uuid}.each { |a| virtualization[:domains][dv.name][a] = dv.send(a) }
-          %w{cpu_time max_mem memory nr_virt_cpu state}.each { |a| virtualization[:domains][dv.name][a] = dv.info.send(a) }
-
-        end
-
-        virtualization[:networks] = Mash.new
-        virtconn.list_networks.each do |n|
-          nv = virtconn.lookup_network_by_name n
-          virtualization[:networks][n] = Mash.new
-          %w{bridge_name uuid}.each { |a| virtualization[:networks][n][a] = nv.send(a) }
-        end
-
-        virtualization[:storage] = Mash.new
-        virtconn.list_storage_pools.each do |pool|
-          sp = virtconn.lookup_storage_pool_by_name pool
-          virtualization[:storage][pool] = Mash.new
-          %w{autostart uuid}.each { |a| virtualization[:storage][pool][a] = sp.send(a) }
-          %w{allocation available capacity state}.each { |a| virtualization[:storage][pool][a] = sp.info.send(a) }
-
-          virtualization[:storage][pool][:volumes] = Mash.new
-          sp.list_volumes.each do |v|
-            virtualization[:storage][pool][:volumes][v] = Mash.new
-            sv = sp.lookup_volume_by_name v
-            %w{key name path}.each { |a| virtualization[:storage][pool][:volumes][v][a] = sv.send(a) }
-            %w{allocation capacity type}.each { |a| virtualization[:storage][pool][:volumes][v][a] = sv.info.send(a) }
-          end
-        end
-
-        virtconn.close
-      rescue LoadError => e
-        Ohai::Log.debug("Plugin Virtualization: Can't load gem: #{e}. Cannot continue.")
-      end
-    end
-  end
-end

data/spec/data/plugins/messages.rb

@@ -1,8 +0,0 @@
-require_plugin 'v6message'
-require_plugin 'v7message'
-
-provides 'messages'
-
-messages Mash.new
-messages[:v6message] = v6message
-messages[:v7message] = v7message

data/spec/data/plugins/v6message.rb

@@ -1,2 +0,0 @@
-provides 'v6message'
-v6message "update me!"

data/spec/unit/plugins/bsd/filesystem2_spec.rb

@@ -1,126 +0,0 @@
-#
-# Author:: Matthew Kent (<mkent@magoazul.com>)
-# Author:: Tim Smith (<tsmith@chef.io>)
-# Copyright:: Copyright (c) 2011-2016 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require_relative "../../../spec_helper.rb"
-
-describe Ohai::System, "BSD filesystem2 plugin" do
-  let(:plugin) { get_plugin("bsd/filesystem2") }
-  before(:each) do
-    allow(plugin).to receive(:collect_os).and_return(:freebsd)
-
-    allow(plugin).to receive(:shell_out).with("df").and_return(mock_shell_out(0, "", ""))
-    allow(plugin).to receive(:shell_out).with("df -iP").and_return(mock_shell_out(0, "", ""))
-    allow(plugin).to receive(:shell_out).with("mount -l").and_return(mock_shell_out(0, "", ""))
-  end
-
-  describe "when gathering filesystem usage data from df" do
-    before(:each) do
-      @stdout = <<-DF
-Filesystem  1K-blocks    Used   Avail Capacity  Mounted on
-/dev/ada0p2   9637788 3313504 5553264    37%    /
-devfs               1       1       0   100%    /dev
-DF
-      allow(plugin).to receive(:shell_out).with("df").and_return(mock_shell_out(0, @stdout, ""))
-
-      @inode_stdout = <<-DFi
-Filesystem  512-blocks    Used   Avail Capacity iused  ifree %iused  Mounted on
-/dev/ada0p2   15411832 5109256 9069632    36%  252576 790750   24%   /
-devfs                2       2       0   100%       0      0  100%   /dev
-DFi
-      allow(plugin).to receive(:shell_out).with("df -iP").and_return(mock_shell_out(0, @inode_stdout, ""))
-    end
-
-    it "should run df and df -iP" do
-      expect(plugin).to receive(:shell_out).ordered.with("df").and_return(mock_shell_out(0, @stdout, ""))
-      expect(plugin).to receive(:shell_out).ordered.with("df -iP").and_return(mock_shell_out(0, @inode_stdout, ""))
-      plugin.run
-    end
-
-    it "should set kb_size to value from df" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:kb_size]).to eq("9637788")
-    end
-
-    it "should set kb_used to value from df" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:kb_used]).to eq("3313504")
-    end
-
-    it "should set kb_available to value from df" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:kb_available]).to eq("5553264")
-    end
-
-    it "should set percent_used to value from df" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:percent_used]).to eq("37%")
-    end
-
-    it "should set mount to value from df" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:mount]).to eq("/")
-    end
-
-    it "should set total_inodes to value from df -iP" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:total_inodes]).to eq("1043326")
-    end
-
-    it "should set inodes_used to value from df -iP" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:inodes_used]).to eq("252576")
-    end
-
-    it "should set inodes_available to value from df -iP" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:inodes_available]).to eq("790750")
-    end
-  end
-
-  describe "when gathering mounted filesystem data from mount" do
-    before(:each) do
-      @stdout = <<-MOUNT
-/dev/ada0p2 on / (ufs, local, journaled soft-updates)
-devfs on /dev (devfs, local, multilabel)
-MOUNT
-      allow(plugin).to receive(:shell_out).with("mount -l").and_return(mock_shell_out(0, @stdout, ""))
-    end
-
-    it "should run mount" do
-      expect(plugin).to receive(:shell_out).with("mount -l").and_return(mock_shell_out(0, @stdout, ""))
-      plugin.run
-    end
-
-    it "should set mount to value from mount" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:mount]).to eq("/")
-    end
-
-    it "should set fs_type to value from mount" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:fs_type]).to eq("ufs")
-    end
-
-    it "should set mount_options to an array of values from mount" do
-      plugin.run
-      expect(plugin[:filesystem2]["by_pair"]["/dev/ada0p2,/"][:mount_options]).to eq(["local", "journaled soft-updates"])
-    end
-  end
-
-end

data/spec/unit/plugins/ip_scopes_spec.rb

@@ -1,139 +0,0 @@
-#
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require_relative "../../spec_helper.rb"
-require "ipaddr_extensions"
-
-describe Ohai::System, "plugin ip_scopes" do
-  let(:plugin) { get_plugin("ip_scopes") }
-  let(:network) { Mash.new(:interfaces => interfaces) }
-  let(:interfaces) do
-    Hash[
-      interface1, { :addresses => addresses1, :type => interface1_type },
-      interface2, { :addresses => addresses2, :type => interface2_type },
-      interface3, { :addresses => addresses3, :type => interface3_type }] end
-  let(:interface1) { :eth0 }
-  let(:interface2) { :eth1 }
-  let(:interface3) { :eth2 }
-  let(:addresses1) { {} }
-  let(:addresses2) { {} }
-  let(:addresses3) { {} }
-  let(:interface1_type) { "eth" }
-  let(:interface2_type) { "eth" }
-  let(:interface3_type) { "eth" }
-
-  before { plugin[:network] = network }
-
-  if defined?(IPAddrExtensions)
-    context "with ipaddr_extensions gem" do
-      let(:ip1) { "10.0.0.1" }
-      let(:ip2) { "1.2.3.4" }
-      let(:ip3) { "fe80::8638:35ff:fe4e:dc74" }
-
-      let(:addresses1) { Hash[ip1, {}] }
-      let(:addresses2) { Hash[ip2, {}, ip3, {}] }
-
-      it "adds ip_scope to each address's information hash" do
-        plugin.run
-        expect(plugin[:network][:interfaces][:eth0][:addresses]["10.0.0.1"][:ip_scope]).to eq("RFC1918 PRIVATE")
-        expect(plugin[:network][:interfaces][:eth1][:addresses]["1.2.3.4"][:ip_scope]).to eq("GLOBAL UNICAST")
-        expect(plugin[:network][:interfaces][:eth1][:addresses]["fe80::8638:35ff:fe4e:dc74"][:ip_scope]).to eq("LINK LOCAL UNICAST")
-      end
-
-      describe "privateaddress attribute" do
-        before { plugin.run }
-
-        context "when host has multiple RFC1918 ethernet addresses" do
-          let(:ip1) { "10.0.0.1" }
-          let(:ip2) { "192.168.1.1" }
-          let(:interface1_type) { "eth" }
-          let(:interface2_type) { "eth" }
-
-          it "picks the last RFC1918 address" do
-            expect(plugin[:privateaddress]).to eq("192.168.1.1")
-          end
-        end
-
-        context "when host has virtual and ethernet RFC1918 addresses" do
-          let(:ip1) { "10.0.0.1" }
-          let(:ip2) { "192.168.1.1" }
-          let(:interface1_type) { "eth" }
-          let(:interface2_type) { "ppp" }
-
-          it "picks the non-virtual address" do
-            expect(plugin[:privateaddress]).to eq("10.0.0.1")
-          end
-        end
-
-        context "when host has tunl" do
-          let(:ip1) { "10.0.0.1" }
-          let(:ip2) { "192.168.1.1" }
-          let(:interface1_type) { "eth" }
-          let(:interface2_type) { "tunl" }
-
-          it "picks the non-virtual address" do
-            expect(plugin[:privateaddress]).to eq("10.0.0.1")
-          end
-        end
-
-        context "when host has docker" do
-          let(:ip1) { "10.0.0.1" }
-          let(:ip2) { "192.168.1.1" }
-          let(:interface1_type) { "eth" }
-          let(:interface2_type) { "docker" }
-
-          it "picks the non-virtual address" do
-            expect(plugin[:privateaddress]).to eq("10.0.0.1")
-          end
-        end
-
-        context "when host only has virtual RFC1918 addresses" do
-          let(:ip1) { "10.0.0.1" }
-          let(:ip2) { "192.168.1.1" }
-          let(:ip3) { "172.16.1.1" }
-
-          let(:interface1_type) { "ppp" }
-          let(:interface2_type) { "tunl" }
-          let(:interface3_type) { "docker" }
-
-          it "ignores them" do
-            expect(plugin[:privateaddress]).to be nil
-          end
-        end
-      end
-    end
-  end
-
-  unless defined?(IPAddrExtensions)
-    context "without the ipaddr_extensions gem" do
-      let(:addresses1) { Hash["10.0.0.1", {}] }
-
-      before do
-        # standin for raising on `require 'ipaddr_extensions'`
-        allow(plugin[:network][:interfaces]).to receive(:keys).and_raise(LoadError)
-        plugin.run
-      end
-
-      it "does not add ip_scope to addresses" do
-        expect(plugin[:network][:interfaces][:eth0][:addresses]["10.0.0.1"][:ip_scope]).to be nil
-      end
-
-      it "does not add a privateaddress attribute" do
-        expect(plugin[:privateaddress]).to be nil
-      end
-    end
-  end
-end