chef 12.10.24-universal-mingw32 → 12.11.18-universal-mingw32

data/lib/chef/provider/systemd_unit.rb

@@ -0,0 +1,238 @@
+#
+# Author:: Nathan Williams (<nath.e.will@gmail.com>)
+# Copyright:: Copyright 2016, Nathan Williams
+# 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 "chef/provider"
+require "chef/mixin/which"
+require "chef/mixin/shell_out"
+require "chef/resource/file"
+require "iniparse"
+
+class Chef
+  class Provider
+    class SystemdUnit < Chef::Provider
+      include Chef::Mixin::Which
+      include Chef::Mixin::ShellOut
+
+      provides :systemd_unit, os: "linux"
+
+      def load_current_resource
+        @current_resource = Chef::Resource::SystemdUnit.new(new_resource.name)
+
+        current_resource.content(::File.read(unit_path)) if ::File.exist?(unit_path)
+        current_resource.user(new_resource.user)
+        current_resource.enabled(enabled?)
+        current_resource.active(active?)
+        current_resource.masked(masked?)
+        current_resource.static(static?)
+        current_resource.triggers_reload(new_resource.triggers_reload)
+
+        current_resource
+      end
+
+      def define_resource_requirements
+        super
+
+        requirements.assert(:create) do |a|
+          a.assertion { IniParse.parse(new_resource.to_ini) }
+          a.failure_message "Unit content is not valid INI text"
+        end
+      end
+
+      def action_create
+        if current_resource.content != new_resource.to_ini
+          converge_by("creating unit: #{new_resource.name}") do
+            manage_unit_file(:create)
+            daemon_reload if new_resource.triggers_reload
+          end
+        end
+      end
+
+      def action_delete
+        if ::File.exist?(unit_path)
+          converge_by("deleting unit: #{new_resource.name}") do
+            manage_unit_file(:delete)
+            daemon_reload if new_resource.triggers_reload
+          end
+        end
+      end
+
+      def action_enable
+        if current_resource.static
+          Chef::Log.debug("#{new_resource.name} is a static unit, enabling is a NOP.")
+        end
+
+        unless current_resource.enabled || current_resource.static
+          converge_by("enabling unit: #{new_resource.name}") do
+            systemctl_execute!(:enable, new_resource.name)
+          end
+        end
+      end
+
+      def action_disable
+        if current_resource.static
+          Chef::Log.debug("#{new_resource.name} is a static unit, disabling is a NOP.")
+        end
+
+        if current_resource.enabled && !current_resource.static
+          converge_by("disabling unit: #{new_resource.name}") do
+            systemctl_execute!(:disable, new_resource.name)
+          end
+        end
+      end
+
+      def action_mask
+        unless current_resource.masked
+          converge_by("masking unit: #{new_resource.name}") do
+            systemctl_execute!(:mask, new_resource.name)
+          end
+        end
+      end
+
+      def action_unmask
+        if current_resource.masked
+          converge_by("unmasking unit: #{new_resource.name}") do
+            systemctl_execute!(:unmask, new_resource.name)
+          end
+        end
+      end
+
+      def action_start
+        unless current_resource.active
+          converge_by("starting unit: #{new_resource.name}") do
+            systemctl_execute!(:start, new_resource.name)
+          end
+        end
+      end
+
+      def action_stop
+        if current_resource.active
+          converge_by("stopping unit: #{new_resource.name}") do
+            systemctl_execute!(:stop, new_resource.name)
+          end
+        end
+      end
+
+      def action_restart
+        converge_by("restarting unit: #{new_resource.name}") do
+          systemctl_execute!(:restart, new_resource.name)
+        end
+      end
+
+      def action_reload
+        if current_resource.active
+          converge_by("reloading unit: #{new_resource.name}") do
+            systemctl_execute!(:reload, new_resource.name)
+          end
+        else
+          Chef::Log.debug("#{new_resource.name} is not active, skipping reload.")
+        end
+      end
+
+      def action_try_restart
+        converge_by("try-restarting unit: #{new_resource.name}") do
+          systemctl_execute!("try-restart", new_resource.name)
+        end
+      end
+
+      def action_reload_or_restart
+        converge_by("reload-or-restarting unit: #{new_resource.name}") do
+          systemctl_execute!("reload-or-restart", new_resource.name)
+        end
+      end
+
+      def action_reload_or_try_restart
+        converge_by("reload-or-try-restarting unit: #{new_resource.name}") do
+          systemctl_execute!("reload-or-try-restart", new_resource.name)
+        end
+      end
+
+      def active?
+        systemctl_execute("is-active", new_resource.name).exitstatus == 0
+      end
+
+      def enabled?
+        systemctl_execute("is-enabled", new_resource.name).exitstatus == 0
+      end
+
+      def masked?
+        systemctl_execute(:status, new_resource.name).stdout.include?("masked")
+      end
+
+      def static?
+        systemctl_execute("is-enabled", new_resource.name).stdout.include?("static")
+      end
+
+      private
+
+      def unit_path
+        if new_resource.user
+          "/etc/systemd/user/#{new_resource.name}"
+        else
+          "/etc/systemd/system/#{new_resource.name}"
+        end
+      end
+
+      def manage_unit_file(action = :nothing)
+        Chef::Resource::File.new(unit_path, run_context).tap do |f|
+          f.owner "root"
+          f.group "root"
+          f.mode "0644"
+          f.content new_resource.to_ini
+        end.run_action(action)
+      end
+
+      def daemon_reload
+        shell_out_with_systems_locale!("#{systemctl_path} daemon-reload")
+      end
+
+      def systemctl_execute!(action, unit)
+        shell_out_with_systems_locale!("#{systemctl_cmd} #{action} #{unit}", systemctl_opts)
+      end
+
+      def systemctl_execute(action, unit)
+        shell_out("#{systemctl_cmd} #{action} #{unit}", systemctl_opts)
+      end
+
+      def systemctl_cmd
+        @systemctl_cmd ||= "#{systemctl_path} #{systemctl_args}"
+      end
+
+      def systemctl_path
+        @systemctl_path ||= which("systemctl")
+      end
+
+      def systemctl_args
+        @systemctl_args ||= new_resource.user ? "--user" : "--system"
+      end
+
+      def systemctl_opts
+        @systemctl_opts ||=
+          if new_resource.user
+            {
+              "user" => new_resource.user,
+              "environment" => {
+                "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/#{node['etc']['passwd'][new_resource.user]['uid']}/bus",
+              },
+            }
+          else
+            {}
+          end
+      end
+    end
+  end
+end

data/lib/chef/providers.rb

@@ -54,6 +54,7 @@ require "chef/provider/ruby_block"
 require "chef/provider/script"
 require "chef/provider/service"
 require "chef/provider/subversion"
+require "chef/provider/systemd_unit"
 require "chef/provider/template"
 require "chef/provider/user"
 require "chef/provider/whyrun_safe_ruby_block"

data/lib/chef/reserved_names.rb

@@ -1,9 +1,9 @@
-class Chef
-
-  # This module exists to hide conflicting constant names from the DSL.
-  # Hopefully we'll have a better/prettier/more sustainable solution in the
-  # future, but for now this will fix a regression introduced in Chef 0.10.10
-  # (conflict with the Win32 namespace)
-  module ReservedNames
-  end
-end
+class Chef
+
+  # This module exists to hide conflicting constant names from the DSL.
+  # Hopefully we'll have a better/prettier/more sustainable solution in the
+  # future, but for now this will fix a regression introduced in Chef 0.10.10
+  # (conflict with the Win32 namespace)
+  module ReservedNames
+  end
+end

data/lib/chef/resource.rb

@@ -19,7 +19,6 @@
 #
 
 require "chef/exceptions"
-require "chef/dsl/platform_introspection"
 require "chef/dsl/data_query"
 require "chef/dsl/registry_helper"
 require "chef/dsl/reboot_pending"
@@ -42,8 +41,7 @@ require "set"
 require "chef/mixin/deprecation"
 require "chef/mixin/properties"
 require "chef/mixin/provides"
-require "chef/mixin/shell_out"
-require "chef/mixin/powershell_out"
+require "chef/dsl/universal"
 
 class Chef
   class Resource
@@ -53,14 +51,11 @@ class Chef
     #
 
     include Chef::DSL::DataQuery
-    include Chef::DSL::PlatformIntrospection
     include Chef::DSL::RegistryHelper
     include Chef::DSL::RebootPending
     extend Chef::Mixin::Provides
 
-    # This lets user code do things like `not_if { shell_out!("command") }`
-    include Chef::Mixin::ShellOut
-    include Chef::Mixin::PowershellOut
+    include Chef::DSL::Universal
 
     # Bring in `property` and `property_type`
     include Chef::Mixin::Properties

data/lib/chef/resource/file.rb

@@ -21,6 +21,7 @@ require "chef/resource"
 require "chef/platform/query_helpers"
 require "chef/mixin/securable"
 require "chef/resource/file/verification"
+require "pathname"
 
 class Chef
   class Resource
@@ -49,7 +50,7 @@ class Chef
       allowed_actions :create, :delete, :touch, :create_if_missing
 
       property :path, String, name_property: true, identity: true
-      property :atomic_update, [ true, false ], desired_state: false, default: lazy { Chef::Config[:file_atomic_update] }
+      property :atomic_update, [ true, false ], desired_state: false, default: lazy { |r| r.docker? && r.special_docker_files?(r.path) ? false : Chef::Config[:file_atomic_update] }
       property :backup, [ Integer, false ], desired_state: false, default: 5
       property :checksum, [ /^[a-zA-Z0-9]{64}$/, nil ]
       property :content, [ String, nil ], desired_state: false
@@ -78,6 +79,10 @@ class Chef
         end
         state_attrs
       end
+
+      def special_docker_files?(file)
+        %w{/etc/hosts /etc/hostname /etc/resolv.conf}.include?(Pathname(file).cleanpath.to_path)
+      end
     end
   end
 end

data/lib/chef/resource/systemd_unit.rb

@@ -0,0 +1,63 @@
+#
+# Author:: Nathan Williams (<nath.e.will@gmail.com>)
+# Copyright:: Copyright 2016, Nathan Williams
+# 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 "chef/resource"
+require "iniparse"
+
+class Chef
+  class Resource
+    class SystemdUnit < Chef::Resource
+      resource_name :systemd_unit
+
+      default_action :nothing
+      allowed_actions :create, :delete,
+                      :enable, :disable,
+                      :mask, :unmask,
+                      :start, :stop,
+                      :restart, :reload,
+                      :try_restart, :reload_or_restart,
+                      :reload_or_try_restart
+
+      property :enabled, [TrueClass, FalseClass]
+      property :active, [TrueClass, FalseClass]
+      property :masked, [TrueClass, FalseClass]
+      property :static, [TrueClass, FalseClass]
+      property :user, String, desired_state: false
+      property :content, [String, Hash]
+      property :triggers_reload, [TrueClass, FalseClass],
+                                 default: true, desired_state: false
+
+      def to_ini
+        case content
+        when Hash
+          IniParse.gen do |doc|
+            content.each_pair do |sect, opts|
+              doc.section(sect) do |section|
+                opts.each_pair do |opt, val|
+                  section.option(opt, val)
+                end
+              end
+            end
+          end.to_s
+        else
+          content.to_s
+        end
+      end
+    end
+  end
+end

data/lib/chef/resources.rb

@@ -75,6 +75,7 @@ require "chef/resource/ruby_block"
 require "chef/resource/scm"
 require "chef/resource/script"
 require "chef/resource/service"
+require "chef/resource/systemd_unit"
 require "chef/resource/windows_service"
 require "chef/resource/subversion"
 require "chef/resource/smartos_package"

data/lib/chef/sandbox.rb

@@ -1,20 +1,20 @@
-class Chef
-  class Sandbox
-    # I DO NOTHING!!
-
-    # So, the reason we have a completely empty class here is so that
-    # Chef 11 clients do not choke when interacting with Chef 10
-    # servers.  The original Chef::Sandbox class (that actually did
-    # things) has been removed since its functionality is no longer
-    # needed for Chef 11.  However, since we still use the JSON gem
-    # and make use of its "auto-inflation" of classes (driven by the
-    # contents of the 'json_class' key in all of our JSON), any
-    # sandbox responses from a Chef 10 server to a Chef 11 client
-    # would cause knife to crash.  The JSON gem would attempt to
-    # auto-inflate based on a "json_class": "Chef::Sandbox" hash
-    # entry, but would not be able to find a Chef::Sandbox class!
-    #
-    # This is a workaround until such time as we can completely remove
-    # the reliance on the "json_class" field.
-  end
-end
+class Chef
+  class Sandbox
+    # I DO NOTHING!!
+
+    # So, the reason we have a completely empty class here is so that
+    # Chef 11 clients do not choke when interacting with Chef 10
+    # servers.  The original Chef::Sandbox class (that actually did
+    # things) has been removed since its functionality is no longer
+    # needed for Chef 11.  However, since we still use the JSON gem
+    # and make use of its "auto-inflation" of classes (driven by the
+    # contents of the 'json_class' key in all of our JSON), any
+    # sandbox responses from a Chef 10 server to a Chef 11 client
+    # would cause knife to crash.  The JSON gem would attempt to
+    # auto-inflate based on a "json_class": "Chef::Sandbox" hash
+    # entry, but would not be able to find a Chef::Sandbox class!
+    #
+    # This is a workaround until such time as we can completely remove
+    # the reliance on the "json_class" field.
+  end
+end

data/lib/chef/shell/shell_session.rb

@@ -150,7 +150,7 @@ module Shell
     private
 
     def rebuild_node
-      Chef::Config[:solo] = true
+      Chef::Config[:solo_legacy_mode] = true
       @client = Chef::Client.new(nil, Chef::Config[:shell_config])
       @client.run_ohai
       @client.load_node
@@ -182,7 +182,7 @@ module Shell
 
     def rebuild_node
       # Tell the client we're chef solo so it won't try to contact the server
-      Chef::Config[:solo] = true
+      Chef::Config[:solo_legacy_mode] = true
       @client = Chef::Client.new(nil, Chef::Config[:shell_config])
       @client.run_ohai
       @client.load_node
@@ -213,7 +213,7 @@ module Shell
 
     def rebuild_node
       # Make sure the client knows this is not chef solo
-      Chef::Config[:solo] = false
+      Chef::Config[:solo_legacy_mode] = false
       @client = Chef::Client.new(nil, Chef::Config[:shell_config])
       @client.run_ohai
       @client.register