chef 14.14.25-universal-mingw32 → 14.14.29-universal-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a5e957d884065cd875deb8c9835497ea27aec899ae717d47d2e872ea2c54813
-  data.tar.gz: b6405e9aa26b48d38a39681dca0f6ae9638a5b6103f67e11e28735a3eb234c9c
+  metadata.gz: bd40eeb7dfb7ae7084b93a40561e37f0c6e5bef18012dc55f35c00c2ea331639
+  data.tar.gz: fccae76a20ea0ee2d61b783c910d400d4eea9f547f6b57704c6d75a3ade58dc4
 SHA512:
-  metadata.gz: c940099dd3ec238a4df1a8a356685c03a726f9830374bab3aeab4585379412af0ab02066972c9f5541dca5dad566d1d845915682a9af148a532c6b5963b5ea04
-  data.tar.gz: 6028227f5e6142bc61e6007b8c159a092524c440218541bdfe5b3bd1801cf07a30c4a25bc82d20a83b97a0d69d48d4c79fd657b834762b3bf589db89e9c78472
+  metadata.gz: 4f5c2dd2f7b8fbe1847fdedc866a5080c3c0844cdc50f1bbf22020c13b6dd1ea67086dce5bc4132eeed38278e63d78e9a04e12c5e9310e1cf8c51bc016e5ae14
+  data.tar.gz: 97bfcca00a020126d16e2d1b3ce27b9f3122b17126bfc1643526502ff7fc78fca94cfa2467ed1cba5b70bcb33b0650f6cf9602c81415f839abfc579663222d69

data/lib/chef/knife/config_get.rb

@@ -47,9 +47,10 @@ class Chef
           if wcl.config_location
             loading_from("configuration", wcl.config_location)
           end
+
           if Chef::Config[:config_d_dir]
             wcl.find_dot_d(Chef::Config[:config_d_dir]).each do |path|
-              loading_from(".d/ configuration", wcl.config_location)
+              loading_from(".d/ configuration", path)
             end
           end
         end

data/lib/chef/provider/service/systemd.rb

@@ -51,6 +51,7 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
         current_resource.running(false)
         current_resource.enabled(false)
         current_resource.masked(false)
+        current_resource.indirect(false)
       end
     else
       current_resource.running(is_active?)
@@ -58,6 +59,7 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
 
     current_resource.enabled(is_enabled?)
     current_resource.masked(is_masked?)
+    current_resource.indirect(is_indirect?)
     current_resource
   end
 
@@ -142,11 +144,19 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
   end
 
   def enable_service
+    if current_resource.masked || current_resource.indirect
+      logger.trace("#{new_resource} cannot be enabled: it is masked or indirect")
+      return
+    end
     options, args = get_systemctl_options_args
     shell_out!("#{systemctl_path} #{args} enable #{Shellwords.escape(new_resource.service_name)}", **options)
   end
 
   def disable_service
+    if current_resource.masked || current_resource.indirect
+      logger.trace("#{new_resource} cannot be disabled: it is masked or indirect")
+      return
+    end
     options, args = get_systemctl_options_args
     shell_out!("#{systemctl_path} #{args} disable #{Shellwords.escape(new_resource.service_name)}", **options)
   end
@@ -171,6 +181,12 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
     shell_out("#{systemctl_path} #{args} is-enabled #{Shellwords.escape(new_resource.service_name)} --quiet", **options).exitstatus == 0
   end
 
+  def is_indirect?
+    options, args = get_systemctl_options_args
+    s = shell_out("#{systemctl_path} #{args} is-enabled #{Shellwords.escape(new_resource.service_name)}", **options)
+    s.stdout.include?("indirect")
+  end
+
   def is_masked?
     options, args = get_systemctl_options_args
     s = shell_out("#{systemctl_path} #{args} is-enabled #{Shellwords.escape(new_resource.service_name)}", **options)

data/lib/chef/provider/systemd_unit.rb

@@ -42,6 +42,7 @@ class Chef
         current_resource.active(active?)
         current_resource.masked(masked?)
         current_resource.static(static?)
+        current_resource.indirect(indirect?)
         current_resource.triggers_reload(new_resource.triggers_reload)
 
         current_resource
@@ -90,10 +91,14 @@ class Chef
         if current_resource.static
           logger.trace("#{new_resource.unit_name} is a static unit, enabling is a NOP.")
         end
+        if current_resource.indirect
+          logger.trace("#{new_resource.unit_name} is an indirect unit, enabling is a NOP.")
+        end
 
-        unless current_resource.enabled || current_resource.static
+        unless current_resource.enabled || current_resource.static || current_resource.indirect
           converge_by("enabling unit: #{new_resource.unit_name}") do
             systemctl_execute!(:enable, new_resource.unit_name)
+            logger.info("#{new_resource} enabled")
           end
         end
       end
@@ -103,9 +108,14 @@ class Chef
           logger.trace("#{new_resource.unit_name} is a static unit, disabling is a NOP.")
         end
 
-        if current_resource.enabled && !current_resource.static
+        if current_resource.indirect
+          logger.trace("#{new_resource.unit_name} is an indirect unit, enabling is a NOP.")
+        end
+
+        if current_resource.enabled && !current_resource.static && !current_resource.indirect
           converge_by("disabling unit: #{new_resource.unit_name}") do
             systemctl_execute!(:disable, new_resource.unit_name)
+            logger.info("#{new_resource} disabled")
           end
         end
       end
@@ -113,6 +123,7 @@ class Chef
       def action_reenable
         converge_by("reenabling unit: #{new_resource.unit_name}") do
           systemctl_execute!(:reenable, new_resource.unit_name)
+          logger.info("#{new_resource} reenabled")
         end
       end
 
@@ -120,6 +131,7 @@ class Chef
         unless current_resource.masked
           converge_by("masking unit: #{new_resource.unit_name}") do
             systemctl_execute!(:mask, new_resource.unit_name)
+            logger.info("#{new_resource} masked")
           end
         end
       end
@@ -128,6 +140,7 @@ class Chef
         if current_resource.masked
           converge_by("unmasking unit: #{new_resource.unit_name}") do
             systemctl_execute!(:unmask, new_resource.unit_name)
+            logger.info("#{new_resource} unmasked")
           end
         end
       end
@@ -136,6 +149,7 @@ class Chef
         unless current_resource.active
           converge_by("starting unit: #{new_resource.unit_name}") do
             systemctl_execute!(:start, new_resource.unit_name, default_env: false)
+            logger.info("#{new_resource} started")
           end
         end
       end
@@ -144,6 +158,7 @@ class Chef
         if current_resource.active
           converge_by("stopping unit: #{new_resource.unit_name}") do
             systemctl_execute!(:stop, new_resource.unit_name, default_env: false)
+            logger.info("#{new_resource} stopped")
           end
         end
       end
@@ -151,6 +166,7 @@ class Chef
       def action_restart
         converge_by("restarting unit: #{new_resource.unit_name}") do
           systemctl_execute!(:restart, new_resource.unit_name, default_env: false)
+          logger.info("#{new_resource} restarted")
         end
       end
 
@@ -158,6 +174,7 @@ class Chef
         if current_resource.active
           converge_by("reloading unit: #{new_resource.unit_name}") do
             systemctl_execute!(:reload, new_resource.unit_name, default_env: false)
+            logger.info("#{new_resource} reloaded")
           end
         else
           logger.trace("#{new_resource.unit_name} is not active, skipping reload.")
@@ -167,18 +184,21 @@ class Chef
       def action_try_restart
         converge_by("try-restarting unit: #{new_resource.unit_name}") do
           systemctl_execute!("try-restart", new_resource.unit_name, default_env: false)
+          logger.info("#{new_resource} try-restarted")
         end
       end
 
       def action_reload_or_restart
         converge_by("reload-or-restarting unit: #{new_resource.unit_name}") do
           systemctl_execute!("reload-or-restart", new_resource.unit_name, default_env: false)
+          logger.info("#{new_resource} reload-or-restarted")
         end
       end
 
       def action_reload_or_try_restart
         converge_by("reload-or-try-restarting unit: #{new_resource.unit_name}") do
           systemctl_execute!("reload-or-try-restart", new_resource.unit_name, default_env: false)
+          logger.info("#{new_resource} reload-or-try-restarted")
         end
       end
 
@@ -198,6 +218,10 @@ class Chef
         systemctl_execute("is-enabled", new_resource.unit_name).stdout.include?("static")
       end
 
+      def indirect?
+        systemctl_execute("is-enabled", new_resource.unit_name).stdout.include?("indirect")
+      end
+
       private
 
       def unit_path

data/lib/chef/resource/service.rb

@@ -159,6 +159,15 @@ class Chef
         )
       end
 
+      # if the service is indirect or not
+      def indirect(arg = nil)
+        set_or_return(
+          :indirect,
+          arg,
+          kind_of: [ TrueClass, FalseClass ]
+        )
+      end
+
       def options(arg = nil)
         set_or_return(
           :options,

data/lib/chef/resource/systemd_unit.rb

@@ -42,6 +42,7 @@ class Chef
       property :active, [TrueClass, FalseClass], skip_docs: true
       property :masked, [TrueClass, FalseClass], skip_docs: true
       property :static, [TrueClass, FalseClass], skip_docs: true
+      property :indirect, [TrueClass, FalseClass], skip_docs: true
 
       # User-provided properties
       property :user, String, desired_state: false,

data/lib/chef/version.rb

@@ -23,7 +23,7 @@ require "chef/version_string"
 
 class Chef
   CHEF_ROOT = File.expand_path("../..", __FILE__)
-  VERSION = Chef::VersionString.new("14.14.25")
+  VERSION = Chef::VersionString.new("14.14.29")
 end
 
 #

data/spec/integration/knife/config_get_spec.rb

@@ -110,6 +110,13 @@ describe "knife config get", :workstation do
     it { is_expected.to match(/^node_name:\s+one$/) }
   end
 
+  context "with a config dot d files" do
+    before { file(".chef/config.d/abc.rb", "node_name 'one'\n") }
+
+    it { is_expected.to match(%r{^Loading from .d/ configuration file .*/#{File.basename(path_to("."))}/.chef/config.d/abc.rb$}) }
+    it { is_expected.to match(/^node_name:\s+one$/) }
+  end
+
   context "with a credentials file and CHEF_HOME" do
     before do
       file(".chef/credentials", "[default]\nclient_name = \"three\"\n")

data/spec/unit/provider/service/systemd_service_spec.rb

@@ -36,11 +36,11 @@ describe Chef::Provider::Service::Systemd do
   let(:provider) { Chef::Provider::Service::Systemd.new(new_resource, run_context) }
 
   let(:shell_out_success) do
-    double("shell_out", exitstatus: 0, error?: false)
+    double("shell_out", exitstatus: 0, error?: false, stdout: "")
   end
 
   let(:shell_out_failure) do
-    double("shell_out", exitstatus: 1, error?: true)
+    double("shell_out", exitstatus: 1, error?: true, stdout: "")
   end
 
   let(:current_resource) { Chef::Resource::Service.new(service_name) }
@@ -56,6 +56,7 @@ describe Chef::Provider::Service::Systemd do
       allow(provider).to receive(:is_active?).and_return(false)
       allow(provider).to receive(:is_enabled?).and_return(false)
       allow(provider).to receive(:is_masked?).and_return(false)
+      allow(provider).to receive(:is_indirect?).and_return(false)
     end
 
     it "should create a current resource with the name of the new resource" do
@@ -359,6 +360,29 @@ describe Chef::Provider::Service::Systemd do
           expect(provider.is_masked?).to be false
         end
       end
+
+      describe "is_indirect?" do
+        before(:each) do
+          provider.current_resource = current_resource
+          current_resource.service_name(service_name)
+          allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
+        end
+
+        it "should return true if '#{systemctl_path} --system is-enabled service_name' returns 'indirect'" do
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "indirect", exitstatus: shell_out_success))
+          expect(provider.is_indirect?).to be true
+        end
+
+        it "should return false if '#{systemctl_path} --system is-enabled service_name' returns 0 and outputs something other than 'indirect'" do
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "enabled", exitstatus: shell_out_success))
+          expect(provider.is_indirect?).to be false
+        end
+
+        it "should return false if '#{systemctl_path} --system is-enabled service_name' returns anything except 0 and outputs somethign other than 'indirect''" do
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "enabled", exitstatus: shell_out_failure))
+          expect(provider.is_indirect?).to be false
+        end
+      end
     end
   end
 end

data/spec/unit/provider/systemd_unit_spec.rb

@@ -65,11 +65,19 @@ describe Chef::Provider::SystemdUnit do
   end
 
   let(:shell_out_masked) do
-    double("shell_out", exit_status: 0, error?: false, stdout: "masked")
+    double("shell_out", exitstatus: 0, error?: false, stdout: "masked")
   end
 
   let(:shell_out_static) do
-    double("shell_out", exit_status: 0, error?: false, stdout: "static")
+    double("shell_out", exitstatus: 0, error?: false, stdout: "static")
+  end
+
+  let(:shell_out_disabled) do
+    double("shell_out", exitstatus: 1, error?: true, stdout: "disabled")
+  end
+
+  let(:shell_out_indirect) do
+    double("shell_out", exitstatus: 0, error?: true, stdout: "indirect")
   end
 
   before(:each) do
@@ -858,8 +866,8 @@ describe Chef::Provider::SystemdUnit do
           it "returns false when unit is not enabled" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_failure)
+              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
+              .and_return(shell_out_disabled)
             expect(provider.enabled?).to be false
           end
         end
@@ -874,8 +882,8 @@ describe Chef::Provider::SystemdUnit do
 
           it "returns false when unit is not enabled" do
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--system", "is-enabled", unit_name)
-                                  .and_return(shell_out_failure)
+              .with(systemctl_path, "--system", "is-enabled", unit_name)
+              .and_return(shell_out_disabled)
             expect(provider.enabled?).to be false
           end
         end
@@ -962,6 +970,47 @@ describe Chef::Provider::SystemdUnit do
           end
         end
       end
+
+      describe "#indirect?" do
+        before(:each) do
+          provider.current_resource = current_resource
+          allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
+        end
+
+        context "when a user is specified" do
+          it "returns true when the unit is indirect" do
+            current_resource.user(user_name)
+            expect(provider).to receive(:shell_out_compacted)
+              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
+              .and_return(shell_out_indirect)
+            expect(provider.indirect?).to be true
+          end
+
+          it "returns false when the unit is not indirect" do
+            current_resource.user(user_name)
+            expect(provider).to receive(:shell_out_compacted)
+              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
+              .and_return(shell_out_static)
+            expect(provider.indirect?).to be false
+          end
+        end
+
+        context "when no user is specified" do
+          it "returns true when the unit is indirect" do
+            expect(provider).to receive(:shell_out_compacted)
+              .with(systemctl_path, "--system", "is-enabled", unit_name)
+              .and_return(shell_out_indirect)
+            expect(provider.indirect?).to be true
+          end
+
+          it "returns false when the unit is not indirect" do
+            expect(provider).to receive(:shell_out_compacted)
+              .with(systemctl_path, "--system", "is-enabled", unit_name)
+              .and_return(shell_out_static)
+            expect(provider.indirect?).to be false
+          end
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef
 version: !ruby/object:Gem::Version
-  version: 14.14.25
+  version: 14.14.29
 platform: universal-mingw32
 authors:
 - Adam Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-14 00:00:00.000000000 Z
+date: 2019-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-config
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 14.14.25
+        version: 14.14.29
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 14.14.25
+        version: 14.14.29
 - !ruby/object:Gem::Dependency
   name: mixlib-cli
   requirement: !ruby/object:Gem::Requirement