chef 12.0.0.rc.0 → 12.0.0

data/lib/chef/node/attribute_collections.rb

@@ -63,7 +63,7 @@ class Chef
       MUTATOR_METHODS.each do |mutator|
         class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
           def #{mutator}(*args, &block)
-            root.reset_cache
+            root.reset_cache(root.top_level_breadcrumb)
             super
           end
         METHOD_DEFN
@@ -128,7 +128,7 @@ class Chef
       MUTATOR_METHODS.each do |mutator|
         class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
           def #{mutator}(*args, &block)
-            root.reset_cache
+            root.reset_cache(root.top_level_breadcrumb)
             super
           end
         METHOD_DEFN
@@ -140,6 +140,7 @@ class Chef
       end
 
       def [](key)
+        root.top_level_breadcrumb ||= key
         value = super
         if !key?(key)
           value = self.class.new(root)
@@ -150,10 +151,11 @@ class Chef
       end
 
       def []=(key, value)
+        root.top_level_breadcrumb ||= key
         if set_unless? && key?(key)
           self[key]
         else
-          root.reset_cache
+          root.reset_cache(root.top_level_breadcrumb)
           super
         end
       end
@@ -209,5 +211,117 @@ class Chef
 
     end
 
+    # == MultiMash
+    # This is a Hash-like object that contains multiple VividMashes in it.  Its
+    # purpose is so that the user can descend into the mash and delete a subtree
+    # from all of the Mash objects (used to delete all values in a subtree from
+    # default, force_default, role_default and env_default at the same time).  The
+    # assignment operator strictly does assignment (does no merging) and works
+    # by deleting the subtree and then assigning to the last mash which passed in
+    # the initializer.
+    #
+    # A lot of the complexity of this class comes from the fact that at any key
+    # value some or all of the mashes may walk off their ends and become nil or
+    # true or something.  The schema may change so that one precidence leve may
+    # be 'true' object and another may be a VividMash.  It is also possible that
+    # one or many of them may transition from VividMashes to Hashes or Arrays.
+    #
+    # It also supports the case where you may be deleting a key using node.rm
+    # in which case if intermediate keys all walk off into nil then you don't want
+    # to be autovivifying keys as you go.  On the other hand you may be using
+    # node.force_default! in which case you'll wind up with a []= operator at the
+    # end and you want autovivification, so we conditionally have to support either
+    # operation.
+    #
+    # @todo: can we have an autovivify class that decorates a class that doesn't
+    # autovivify or something so that the code is less awful?
+    #
+    class MultiMash
+      attr_reader :root
+      attr_reader :mashes
+      attr_reader :opts
+      attr_reader :primary_mash
+
+      # Initialize with an array of mashes.  For the delete return value to work
+      # properly the mashes must come from the same attribute level (i.e. all
+      # override or all default, but not a mix of both).
+      def initialize(root, primary_mash, mashes, opts={})
+        @root = root
+        @primary_mash = primary_mash
+        @mashes = mashes
+        @opts = opts
+        @opts[:autovivify] = true if @opts[:autovivify].nil?
+      end
+
+      def [](key)
+        # handle the secondary mashes
+        new_mashes = []
+        mashes.each do |mash|
+          new_mash = safe_evalute_key(mash, key)
+          # secondary mashes never autovivify so once they fall into nil, we just stop tracking them
+          new_mashes.push(new_mash) unless new_mash.nil?
+        end
+
+        new_primary_mash = safe_evalute_key(primary_mash, key)
+
+        if new_primary_mash.nil? && @opts[:autovivify]
+          primary_mash[key] = VividMash.new(root)
+          new_primary_mash = primary_mash[key]
+        end
+
+        MultiMash.new(root, new_primary_mash, new_mashes, opts)
+      end
+
+      def []=(key, value)
+        if primary_mash.nil?
+          # This theoretically should never happen since node#force_default! setter methods will autovivify and
+          # node#rm methods do not end in #[]= operators.
+          raise TypeError, "No autovivification was specified initially on a method chain ending in assignment"
+        end
+        ret = delete(key)
+        primary_mash[key] = value
+        ret
+      end
+
+      # mash.element('foo', 'bar') is the same as mash['foo']['bar']
+      def element(key = nil, *subkeys)
+        return self if key.nil?
+        submash = self[key]
+        subkeys.empty? ? submash : submash.element(*subkeys)
+      end
+
+      def delete(key)
+        # the return value is a deep merge which is correct semantics when
+        # merging between attributes on the same level (this would be incorrect
+        # if passed both override and default attributes which would need hash_only
+        # merging).
+        ret = mashes.inject(Mash.new) do |merged, mash|
+          Chef::Mixin::DeepMerge.merge(merged, mash)
+        end
+        ret = Chef::Mixin::DeepMerge.merge(ret, primary_mash)
+        mashes.each do |mash|
+          mash.delete(key) if mash.respond_to?(:delete)
+        end
+        primary_mash.delete(key) if primary_mash.respond_to?(:delete)
+        ret[key]
+      end
+
+      private
+
+      def safe_evalute_key(mash, key)
+        if mash.respond_to?(:[])
+          if mash.respond_to?(:has_key?)
+            if mash.has_key?(key)
+              return mash[key] if mash[key].respond_to?(:[])
+            end
+          elsif !mash[key].nil?
+            return mash[key] if mash[key].respond_to?(:[])
+          end
+        end
+        return nil
+      end
+
+    end
+
   end
 end

data/lib/chef/node/immutable_collections.rb

@@ -78,9 +78,7 @@ class Chef
         # Ruby 1.8 blocks can't have block arguments, so we must use string eval:
         class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
           def #{mutator_method_name}(*args, &block)
-            msg = "Node attributes are read-only when you do not specify which precedence level to set. " +
-            %Q(To set an attribute use code like `node.default["key"] = "value"')
-            raise Exceptions::ImmutableAttributeModification, msg
+            raise Exceptions::ImmutableAttributeModification
           end
         METHOD_DEFN
       end
@@ -157,6 +155,10 @@ class Chef
         end
       end
 
+      def public_method_that_only_deep_merge_should_use(key, value)
+        internal_set(key, immutablize(value))
+      end
+
       alias :attribute? :has_key?
 
       # Redefine all of the methods that mutate a Hash to raise an error when called.
@@ -165,9 +167,7 @@ class Chef
         # Ruby 1.8 blocks can't have block arguments, so we must use string eval:
         class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
         def #{mutator_method_name}(*args, &block)
-          msg = "Node attributes are read-only when you do not specify which precedence level to set. " +
-          %Q(To set an attribute use code like `node.default["key"] = "value"')
-          raise Exceptions::ImmutableAttributeModification, msg
+          raise Exceptions::ImmutableAttributeModification
         end
         METHOD_DEFN
       end

data/lib/chef/platform/provider_priority_map.rb

@@ -34,9 +34,10 @@ class Chef
         ], platform_family: "gentoo"
 
         priority :service, [
-          # on debian-ish system if an upstart script exists that always wins
-          Chef::Provider::Service::Upstart,
+          # we can determine what systemd supports accurately
           Chef::Provider::Service::Systemd,
+          # on debian-ish system if an upstart script exists that must win over sysv types
+          Chef::Provider::Service::Upstart,
           Chef::Provider::Service::Insserv,
           Chef::Provider::Service::Debian,
           Chef::Provider::Service::Invokercd,

data/lib/chef/platform/service_helpers.rb

@@ -18,6 +18,7 @@
 
 # XXX: mixing shellout into a mixin into classes has to be code smell
 require 'chef/mixin/shell_out'
+require 'chef/mixin/which'
 
 class Chef
   class Platform
@@ -25,12 +26,21 @@ class Chef
       class << self
 
         include Chef::Mixin::ShellOut
+        include Chef::Mixin::Which
 
         # This helper is mostly used to sort out the mess of different
         # linux mechanisms that can be used to start services.  It does
         # not necessarily need to linux-specific, but currently all our
         # other service providers are narrowly platform-specific with no
         # alternatives.
+        #
+        # NOTE: if a system has (for example) chkconfig installed then we
+        # should report that chkconfig is installed.  The fact that a system
+        # may also have systemd installed does not mean that we do not
+        # report that systemd is also installed.  This module is purely for
+        # discovery of all the alternatives, handling the priority of the
+        # different services is NOT a design concern of this module.
+        #
         def service_resource_providers
           service_resource_providers = []
 
@@ -55,8 +65,7 @@ class Chef
             service_resource_providers << :redhat
           end
 
-          if ::File.exist?("/bin/systemctl")
-            # FIXME: look for systemd as init provider
+          if systemd_sanity_check?
             service_resource_providers << :systemd
           end
 
@@ -86,7 +95,7 @@ class Chef
             configs << :usr_local_etc_rcd
           end
 
-          if ::File.exist?("/bin/systemctl") && platform_has_systemd_unit?(service_name)
+          if systemd_sanity_check? && platform_has_systemd_unit?(service_name)
             configs << :systemd
           end
 
@@ -95,17 +104,37 @@ class Chef
 
         private
 
-        def extract_systemd_services(output)
+        def systemctl_path
+          if @systemctl_path.nil?
+            @systemctl_path = which("systemctl")
+          end
+          @systemctl_path
+        end
+
+        def systemd_sanity_check?
+          systemctl_path && File.exist?("/proc/1/comm") && File.open("/proc/1/comm").gets.chomp == "systemd"
+        end
+
+        def extract_systemd_services(command)
+          output = shell_out!(command).stdout
           # first line finds e.g. "sshd.service"
-          services = output.lines.split.map { |l| l.split[0] }
+          services = []
+          output.each_line do |line|
+            fields = line.split
+            services << fields[0] if fields[1] == "loaded" || fields[1] == "not-found"
+          end
           # this splits off the suffix after the last dot to return "sshd"
-          services += services.map { |s| s.sub(/(.*)\..*/, '\1') }
+          services += services.select {|s| s.match(/\.service$/) }.map { |s| s.sub(/(.*)\.service$/, '\1') }
+        rescue Mixlib::ShellOut::ShellCommandFailed
+          false
         end
 
         def platform_has_systemd_unit?(service_name)
-          services = extract_systemd_services(shell_out!("systemctl --all").stdout) +
-            extract_systemd_services(shell_out!("systemctl --list-unit-files").stdout)
+          services = extract_systemd_services("#{systemctl_path} --all") +
+            extract_systemd_services("#{systemctl_path} list-unit-files")
           services.include?(service_name)
+        rescue Mixlib::ShellOut::ShellCommandFailed
+          false
         end
       end
     end

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

@@ -114,4 +114,4 @@ class Chef
       end
     end
   end
-end
+end

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

@@ -23,7 +23,7 @@ class Chef::Provider::Service::Arch < Chef::Provider::Service::Init
   provides :service, platform_family: "arch"
 
   def self.supports?(resource, action)
-    ::File.exist?("/etc/rc.d/#{resource.service_name}")
+    Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:etc_rcd)
   end
 
   def initialize(new_resource, run_context)

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

@@ -27,8 +27,12 @@ class Chef
 
         provides :service, platform_family: "debian"
 
+        def self.provides?(node, resource)
+          super && Chef::Platform::ServiceHelpers.service_resource_providers.include?(:debian)
+        end
+
         def self.supports?(resource, action)
-          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:debian)
+          Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:initd)
         end
 
         def load_current_resource

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

@@ -28,6 +28,10 @@ class Chef
 
         provides :service, os: "!windows"
 
+        def self.supports?(resource, action)
+          Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:initd)
+        end
+
         def initialize(new_resource, run_context)
           super
           @init_command = "/etc/init.d/#{@new_resource.service_name}"

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

@@ -26,8 +26,12 @@ class Chef
 
         provides :service, os: "linux"
 
+        def self.provides?(node, resource)
+          super && Chef::Platform::ServiceHelpers.service_resource_providers.include?(:insserv)
+        end
+
         def self.supports?(resource, action)
-          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:insserv)
+          Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:initd)
         end
 
         def load_current_resource

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

@@ -25,8 +25,12 @@ class Chef
 
         provides :service, platform_family: "debian"
 
+        def self.provides?(node, resource)
+          super && Chef::Platform::ServiceHelpers.service_resource_providers.include?(:invokercd)
+        end
+
         def self.supports?(resource, action)
-          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:invokerc)
+          Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:initd)
         end
 
         def initialize(new_resource, run_context)

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

@@ -28,8 +28,12 @@ class Chef
 
         provides :service, platform_family: [ "rhel", "fedora", "suse" ]
 
+        def self.provides?(node, resource)
+          super && Chef::Platform::ServiceHelpers.service_resource_providers.include?(:redhat)
+        end
+
         def self.supports?(resource, action)
-          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:redhat)
+          Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:initd)
         end
 
         def initialize(new_resource, run_context)

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

@@ -18,87 +18,95 @@
 
 require 'chef/resource/service'
 require 'chef/provider/service/simple'
+require 'chef/mixin/which'
 
 class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
 
+  include Chef::Mixin::Which
+
   provides :service, os: "linux"
 
+  attr_accessor :status_check_success
+
+  def self.provides?(node, resource)
+    super && Chef::Platform::ServiceHelpers.service_resource_providers.include?(:systemd)
+  end
+
   def self.supports?(resource, action)
-    Chef::Platform::ServiceHelpers.service_resource_providers.include?(:systemd)
+    Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:systemd)
   end
 
   def load_current_resource
-    @current_resource = Chef::Resource::Service.new(@new_resource.name)
-    @current_resource.service_name(@new_resource.service_name)
+    @current_resource = Chef::Resource::Service.new(new_resource.name)
+    current_resource.service_name(new_resource.service_name)
     @status_check_success = true
 
-    if @new_resource.status_command
-      Chef::Log.debug("#{@new_resource} you have specified a status command, running..")
+    if new_resource.status_command
+      Chef::Log.debug("#{new_resource} you have specified a status command, running..")
 
-      unless shell_out(@new_resource.status_command).error?
-        @current_resource.running(true)
+      unless shell_out(new_resource.status_command).error?
+        current_resource.running(true)
       else
         @status_check_success = false
-        @current_resource.running(false)
-        @current_resource.enabled(false)
-        nil
+        current_resource.running(false)
+        current_resource.enabled(false)
       end
     else
-      @current_resource.running(is_active?)
+      current_resource.running(is_active?)
     end
 
-    @current_resource.enabled(is_enabled?)
-    @current_resource
+    current_resource.enabled(is_enabled?)
+    current_resource
   end
 
   def define_resource_requirements
     shared_resource_requirements
     requirements.assert(:all_actions) do |a|
-      a.assertion { @status_check_success }
+      a.assertion { status_check_success }
       # We won't stop in any case, but in whyrun warn and tell what we're doing.
-      a.whyrun ["Failed to determine status of #{@new_resource}, using command #{@new_resource.status_command}.",
+      a.whyrun ["Failed to determine status of #{new_resource}, using command #{new_resource.status_command}.",
         "Assuming service would have been installed and is disabled"]
     end
   end
 
   def start_service
-    if @current_resource.running
-      Chef::Log.debug("#{@new_resource} already running, not starting")
+    if current_resource.running
+      Chef::Log.debug("#{new_resource} already running, not starting")
     else
-      if @new_resource.start_command
+      if new_resource.start_command
         super
       else
-        shell_out_with_systems_locale!("/bin/systemctl start #{@new_resource.service_name}")
+        shell_out_with_systems_locale!("#{systemctl_path} start #{new_resource.service_name}")
       end
     end
   end
 
   def stop_service
-    unless @current_resource.running
-      Chef::Log.debug("#{@new_resource} not running, not stopping")
+    unless current_resource.running
+      Chef::Log.debug("#{new_resource} not running, not stopping")
     else
-      if @new_resource.stop_command
+      if new_resource.stop_command
         super
       else
-        shell_out_with_systems_locale!("/bin/systemctl stop #{@new_resource.service_name}")
+        shell_out_with_systems_locale!("#{systemctl_path} stop #{new_resource.service_name}")
       end
     end
   end
 
   def restart_service
-    if @new_resource.restart_command
+    if new_resource.restart_command
       super
     else
-      shell_out_with_systems_locale!("/bin/systemctl restart #{@new_resource.service_name}")
+      shell_out_with_systems_locale!("#{systemctl_path} restart #{new_resource.service_name}")
     end
   end
 
   def reload_service
-    if @new_resource.reload_command
+    if new_resource.reload_command
       super
     else
-      if @current_resource.running
-        shell_out_with_systems_locale!("/bin/systemctl reload #{@new_resource.service_name}")
+      if current_resource.running
+        shell_out_with_systems_locale!("#{systemctl_path} reload #{new_resource.service_name}")
       else
         start_service
       end
@@ -106,18 +114,28 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
   end
 
   def enable_service
-    shell_out!("/bin/systemctl enable #{@new_resource.service_name}")
+    shell_out!("#{systemctl_path} enable #{new_resource.service_name}")
   end
 
   def disable_service
-    shell_out!("/bin/systemctl disable #{@new_resource.service_name}")
+    shell_out!("#{systemctl_path} disable #{new_resource.service_name}")
   end
 
   def is_active?
-    shell_out("/bin/systemctl is-active #{@new_resource.service_name} --quiet").exitstatus == 0
+    shell_out("#{systemctl_path} is-active #{new_resource.service_name} --quiet").exitstatus == 0
   end
 
   def is_enabled?
-    shell_out("/bin/systemctl is-enabled #{@new_resource.service_name} --quiet").exitstatus == 0
+    shell_out("#{systemctl_path} is-enabled #{new_resource.service_name} --quiet").exitstatus == 0
   end
+
+  private
+
+  def systemctl_path
+    if @systemctl_path.nil?
+      @systemctl_path = which("systemctl")
+    end
+    @systemctl_path
+  end
+
 end