chef 10.12.0 → 10.14.0.beta.1

data/lib/chef/event_dispatch/dispatcher.rb

@@ -0,0 +1,42 @@
+require 'chef/event_dispatch/base'
+
+class Chef
+  module EventDispatch
+
+    # == EventDispatch::Dispatcher
+    # The Dispatcher handles receiving event data from the sources
+    # (Chef::Client, Resources and Providers, etc.) and publishing the data to
+    # the registered subscribers.
+    class Dispatcher < Base
+
+      def initialize(*subscribers)
+        @subscribers = subscribers
+      end
+
+      # Add a new subscriber to the list of registered subscribers
+      def register(subscriber)
+        @subscribers << subscriber
+      end
+
+      ####
+      # All messages are unconditionally forwarded to all subscribers, so just
+      # define the forwarding in one go:
+      #
+
+      # Define a method that will be forwarded to all 
+      def self.def_forwarding_method(method_name)
+        class_eval(<<-END_OF_METHOD, __FILE__, __LINE__)
+          def #{method_name}(*args)
+            @subscribers.each {|s| s.#{method_name}(*args)}
+          end
+        END_OF_METHOD
+      end
+
+      (Base.instance_methods - Object.instance_methods).each do |method_name|
+        def_forwarding_method(method_name)
+      end
+
+    end
+  end
+end
+

data/lib/chef/exceptions.rb

@@ -34,7 +34,6 @@ class Chef
     class Override < RuntimeError; end
     class UnsupportedAction < RuntimeError; end
     class MissingLibrary < RuntimeError; end
-    class MissingRole < RuntimeError; end
     class CannotDetermineNodeName < RuntimeError; end
     class User < RuntimeError; end
     class Group < RuntimeError; end
@@ -70,6 +69,7 @@ class Chef
     class CookbookVersionNameMismatch < ArgumentError; end
     class MissingParentDirectory < RuntimeError; end
     class UnresolvableGitReference < RuntimeError; end
+    class InvalidRemoteGitReference < RuntimeError; end
     class InvalidEnvironmentRunListSpecification < ArgumentError; end
     class InvalidDataBagItemID < ArgumentError; end
     class InvalidDataBagName < ArgumentError; end
@@ -94,10 +94,38 @@ class Chef
     # match OP VERSION. ArgumentError?
     class InvalidVersionConstraint < ArgumentError; end
 
+    # File operation attempted but no permissions to perform it
+    class InsufficientPermissions < RuntimeError; end
+   
+    # Ifconfig failed
+    class Ifconfig < RuntimeError; end
+
     # Backcompat with Chef::ShellOut code:
     require 'mixlib/shellout/exceptions'
     class ShellCommandFailed < Mixlib::ShellOut::ShellCommandFailed; end
 
+    class MissingRole < RuntimeError
+      NULL = Object.new
+
+      attr_reader :expansion
+
+      def initialize(message_or_expansion=NULL)
+        @expansion = nil
+        case message_or_expansion
+        when NULL
+          super()
+        when String
+          super
+        when RunList::RunListExpansion
+          @expansion = message_or_expansion
+          missing_roles = @expansion.errors.join(', ')
+          super("The expanded run list includes nonexistent roles: #{missing_roles}")
+        end
+      end
+
+
+    end
+
     class CookbookVersionSelection
 
       # Compound exception: In run_list expansion and resolution,

data/lib/chef/file_access_control.rb

@@ -34,7 +34,9 @@ class Chef
       include FileAccessControl::Unix
     end
 
+    attr_reader :current_resource
     attr_reader :resource
+    attr_reader :provider
     attr_reader :file
 
     # FileAccessControl objects set the owner, group and mode of +file+ to
@@ -47,8 +49,11 @@ class Chef
     #             and +mode+
     # file:       The file whose access control settings you wish to modify,
     #             given as a String.
-    def initialize(resource, file)
-      @resource, @file = resource, file
+    #
+    # TODO requiring current_resource will break cookbook_file template_file
+    def initialize(current_resource, new_resource, provider)
+      @current_resource, @resource, @provider = current_resource, new_resource, provider
+      @file = @current_resource.path
       @modified = false
     end
 

data/lib/chef/file_access_control/unix.rb

@@ -26,47 +26,65 @@ class Chef
       UINT = (1 << 32)
       UID_MAX = (1 << 32) - 10
 
+      def set_all!
+        set_owner!
+        set_group!
+        set_mode!
+      end
+
       def set_all
         set_owner
         set_group
         set_mode
       end
 
-      # Workaround the fact that Ruby's Etc module doesn't believe in negative
-      # uids, so negative uids show up as the diminished radix complement of
-      # a uint. For example, a uid of -2 is reported as 4294967294
-      def diminished_radix_complement(int)
-        if int > UID_MAX
-          int - UINT
-        else
-          int
-        end
+      # TODO factor this up
+      def requires_changes?
+        should_update_mode? || should_update_owner? || should_update_group?
+      end
+
+      def describe_changes
+        changes = []
+        changes << "change mode from '#{mode_to_s(current_mode)}' to '#{mode_to_s(target_mode)}'" if should_update_mode?
+        changes << "change owner from '#{current_resource.owner}' to '#{resource.owner}'" if should_update_owner?
+        changes << "change group from '#{current_resource.group}' to '#{resource.group}'" if should_update_group?
+        changes
       end
 
       def target_uid
-        return nil if resource.owner.nil?
-        if resource.owner.kind_of?(String)
-          diminished_radix_complement( Etc.getpwnam(resource.owner).uid )
-        elsif resource.owner.kind_of?(Integer)
-          resource.owner
-        else
-          Chef::Log.error("The `owner` parameter of the #@resource resource is set to an invalid value (#{resource.owner.inspect})")
-          raise ArgumentError, "cannot resolve #{resource.owner.inspect} to uid, owner must be a string or integer"
-        end
-      rescue ArgumentError
-        raise Chef::Exceptions::UserIDNotFound, "cannot determine user id for '#{resource.owner}', does the user exist on this system?"
+        uid_from_resource(resource)
       end
 
-      def set_owner
-        if (uid = target_uid) && (uid != stat.uid)
-          chown(uid, nil, file)
-          Chef::Log.info("#{log_string} owner changed to #{uid}")
+      def current_uid
+        uid_from_resource(current_resource)
+      end
+
+      def should_update_owner?
+        target_uid != current_uid
+      end
+
+      def set_owner!
+        unless target_uid.nil?
+          chown(target_uid, nil, file)
+          Chef::Log.info("#{log_string} owner changed to #{target_uid}")
           modified
         end
       end
 
+      def set_owner
+        set_owner! if should_update_owner?
+      end
+
       def target_gid
-        return nil if resource.group.nil?
+        gid_from_resource(resource)
+      end
+
+      def current_gid
+        gid_from_resource(current_resource)
+      end
+
+      def gid_from_resource(resource)
+        return nil if resource == nil or resource.group.nil?
         if resource.group.kind_of?(String)
           diminished_radix_complement( Etc.getgrnam(resource.group).gid )
         elsif resource.group.kind_of?(Integer)
@@ -76,30 +94,63 @@ class Chef
           raise ArgumentError, "cannot resolve #{resource.group.inspect} to gid, group must be a string or integer"
         end
       rescue ArgumentError
-        raise Chef::Exceptions::GroupIDNotFound, "cannot determine group id for '#{resource.group}', does the group exist on this system?"
+        provider.requirements.assert(:create, :create_if_missing, :touch) do |a|
+          a.assertion { false }
+          a.failure_message(Chef::Exceptions::GroupIDNotFound, "cannot determine group id for '#{resource.group}', does the group exist on this system?")
+          a.whyrun("Assuming group #{resource.group} would have been created")
+        end
+        return nil
       end
 
-      def set_group
-        if (gid = target_gid) && (gid != stat.gid)
-          chown(nil, gid, file)
-          Chef::Log.info("#{log_string} group changed to #{gid}")
+      def should_update_group?
+        target_gid != current_gid
+      end
+
+      def set_group!
+        unless target_gid.nil?
+          chown(nil, target_gid, file)
+          Chef::Log.info("#{log_string} group changed to #{target_gid}")
           modified
         end
       end
 
+      def set_group
+        set_group! if should_update_group?
+      end
+
+      def mode_from_resource(res)
+        return nil if res == nil or res.mode.nil?
+        (res.mode.respond_to?(:oct) ? res.mode.oct : res.mode.to_i) & 007777
+      end
+
       def target_mode
-        return nil if resource.mode.nil?
-        (resource.mode.respond_to?(:oct) ? resource.mode.oct : resource.mode.to_i) & 007777
+        mode_from_resource(resource)
       end
 
-      def set_mode
-        if (mode = target_mode) && (mode != (stat.mode & 007777))
+      def mode_to_s(mode)
+        mode.nil? ? "" : "0#{mode.to_s(8)}"
+      end
+
+      def current_mode
+        mode_from_resource(current_resource)
+      end
+
+      def should_update_mode?
+        current_mode != target_mode
+      end
+
+      def set_mode!
+        unless target_mode.nil?
           chmod(target_mode, file)
-          Chef::Log.info("#{log_string} mode changed to #{mode.to_s(8)}")
+          Chef::Log.info("#{log_string} mode changed to #{target_mode.to_s(8)}")
           modified
         end
       end
 
+      def set_mode
+        set_mode! if should_update_mode?
+      end
+
       def stat
         if File.symlink?(file)
           @stat ||= File.lstat(file)
@@ -129,6 +180,37 @@ class Chef
           File.chown(uid, gid, file)
         end
       end
+
+      # Workaround the fact that Ruby's Etc module doesn't believe in negative
+      # uids, so negative uids show up as the diminished radix complement of
+      # a uint. For example, a uid of -2 is reported as 4294967294
+      def diminished_radix_complement(int)
+        if int > UID_MAX
+          int - UINT
+        else
+          int
+        end
+      end
+
+      def uid_from_resource(resource) 
+        return nil if resource == nil or resource.owner.nil?
+        if resource.owner.kind_of?(String)
+          diminished_radix_complement( Etc.getpwnam(resource.owner).uid )
+        elsif resource.owner.kind_of?(Integer)
+          resource.owner
+        else
+          Chef::Log.error("The `owner` parameter of the #@resource resource is set to an invalid value (#{resource.owner.inspect})")
+          raise ArgumentError, "cannot resolve #{resource.owner.inspect} to uid, owner must be a string or integer"
+        end
+      rescue ArgumentError
+        provider.requirements.assert(:create, :create_if_missing, :touch) do |a|
+          a.assertion { false }
+          a.failure_message(Chef::Exceptions::UserIDNotFound, "cannot determine user id for '#{resource.owner}', does the user exist on this system?")
+          a.whyrun("Assuming user #{resource.owner} would have been created")
+        end
+        return nil
+      end
+
     end
   end
 end

data/lib/chef/file_access_control/windows.rb

@@ -29,12 +29,31 @@ class Chef
       ACE = Security::ACE
       SID = Security::SID
 
+      def set_all!
+        set_owner!
+        set_group!
+        set_dacl
+      end
+
       def set_all
         set_owner
         set_group
         set_dacl
       end
 
+      def requires_changes?
+        should_update_dacl? || should_update_owner? || should_update_group?
+      end
+
+      def describe_changes
+        # FIXME: describe what these are changing from and to
+        changes = []
+        changes << "change dacl" if should_update_dacl?
+        changes << "change owner" if should_update_owner?
+        changes << "change group" if should_update_group?
+        changes
+      end
+
       private
 
       # Compare the actual ACL on a resource with the ACL we want.  This
@@ -90,6 +109,18 @@ class Chef
         end
       end
 
+      def should_update_dacl?
+        return true unless ::File.exists?(file)
+        dacl = target_dacl
+        existing_dacl = existing_descriptor.dacl
+        inherits = target_inherits
+        ( ! inherits.nil? && inherits != existing_descriptor.dacl_inherits? ) || ( dacl && !acls_equal(dacl, existing_dacl) )
+      end
+
+      def set_dacl!
+        set_dacl
+      end
+
       def set_dacl
         dacl = target_dacl
         existing_dacl = existing_descriptor.dacl
@@ -111,22 +142,44 @@ class Chef
         end
       end
 
-      def set_group
-        if (group = target_group) && (group != existing_descriptor.group)
+      def should_update_group?
+        return true unless ::File.exists?(file)
+        (group = target_group) && (group != existing_descriptor.group)
+      end
+
+      def set_group!
+        if (group = target_group)
           Chef::Log.info("#{log_string} group changed to #{group}")
           securable_object.group = group
           modified
         end
       end
 
-      def set_owner
-        if (owner = target_owner) && (owner != existing_descriptor.owner)
+      def set_group
+        if (group = target_group) && (group != existing_descriptor.group)
+          set_group!
+        end
+      end
+
+      def should_update_owner?
+        return true unless ::File.exists?(file)
+        (owner = target_owner) && (owner != existing_descriptor.owner)
+      end
+
+      def set_owner!
+        if owner = target_owner
           Chef::Log.info("#{log_string} owner changed to #{owner}")
           securable_object.owner = owner
           modified
         end
       end
 
+      def set_owner
+        if (owner = target_owner) && (owner != existing_descriptor.owner)
+          set_owner!
+        end
+      end
+
       def mode_ace(sid, mode)
         mask = 0
         mask |= GENERIC_READ if mode & 4 != 0

data/lib/chef/file_cache.rb

@@ -33,10 +33,12 @@ class Chef
       # path<String>:: The path to the file you want to put in the cache - should
       #   be relative to file_cache_path
       # contents<String>:: A string with the contents you want written to the file
+      # perm<String>:: Sets file permission bits. Permission bits are platform
+      #   dependent; on Unix systems, see open(2) for details.
       #
       # === Returns
       # true
-      def store(path, contents)
+      def store(path, contents, perm=0640)
         validate(
           {
             :path => path,
@@ -51,7 +53,7 @@ class Chef
         file_path_array = File.split(path)
         file_name = file_path_array.pop
         cache_path = create_cache_path(File.join(file_path_array))
-        File.open(File.join(cache_path, file_name), "w") do |io|
+        File.open(File.join(cache_path, file_name), "w", perm) do |io|
           io.print(contents)
         end
         true

data/lib/chef/formatters/base.rb

@@ -0,0 +1,260 @@
+require 'chef/event_dispatch/base'
+require 'chef/formatters/error_inspectors'
+
+class Chef
+
+  # == Chef::Formatters
+  # Formatters handle printing output about the progress/status of a chef
+  # client run to the user's screen.
+  module Formatters
+
+    class UnknownFormatter < StandardError; end
+
+    def self.formatters_by_name
+      @formatters_by_name ||= {}
+    end
+
+    def self.register(name, formatter)
+      formatters_by_name[name.to_s] = formatter
+    end
+
+    def self.by_name(name)
+      formatters_by_name[name]
+    end
+
+    def self.available_formatters
+      formatters_by_name.keys
+    end
+
+    #--
+    # TODO: is it too clever to be defining new() on a module like this?
+    def self.new(name, out, err)
+      formatter_class = by_name(name) or
+        raise UnknownFormatter, "No output formatter found for #{name} (available: #{available_formatters.join(', ')})"
+
+      formatter_class.new(out, err)
+    end
+
+    # == Outputter
+    # Handles basic printing tasks like colorizing.
+    # --
+    # TODO: Duplicates functionality from knife, upfactor.
+    class Outputter
+
+      def initialize(out, err)
+        @out, @err = out, err
+      end
+
+      def highline
+        @highline ||= begin
+          require 'highline'
+          HighLine.new
+        end
+      end
+
+      def color(string, *colors)
+        if Chef::Config[:color]
+          @out.print highline.color(string, *colors)
+        else
+          @out.print string
+        end
+      end
+
+      alias :print :color
+
+      def puts(string, *colors)
+        if Chef::Config[:color]
+          @out.puts highline.color(string, *colors)
+        else
+          @out.puts string
+        end
+      end
+
+    end
+
+    class ErrorDescription
+
+      attr_reader :sections
+
+      def initialize(title)
+        @title = title
+        @sections = []
+      end
+
+      def section(heading, text)
+        @sections << [heading, text]
+      end
+
+      def display(out)
+        out.puts "=" * 80
+        out.puts @title, :red
+        out.puts "=" * 80
+        out.puts "\n"
+        sections.each do |section|
+          display_section(section, out)
+        end
+      end
+
+      private
+
+      def display_section(section, out)
+        heading, text = section
+        out.puts heading
+        out.puts "-" * heading.size
+        out.puts text
+        out.puts "\n"
+      end
+
+    end
+
+    # == Formatters::Base
+    # Base class that all formatters should inherit from.
+    class Base < EventDispatch::Base
+
+      def self.cli_name(name)
+        Chef::Formatters.register(name, self)
+      end
+
+      attr_reader :out
+      attr_reader :err
+      attr_reader :output
+
+      def initialize(out, err)
+        @output = Outputter.new(out, err)
+      end
+
+      def puts(*args)
+        @output.puts(*args)
+      end
+
+      def print(*args)
+        @output.print(*args)
+      end
+
+      def describe_error(headline, error_inspector)
+        description = ErrorDescription.new(headline)
+        error_inspector.add_explanation(description)
+        puts("")
+        description.display(output)
+      end
+
+      # Failed to register this client with the server.
+      def registration_failed(node_name, exception, config)
+        error_inspector = ErrorInspectors::RegistrationErrorInspector.new(node_name, exception, config)
+        headline = "Chef encountered an error attempting to create the client \"#{node_name}\""
+        describe_error(headline, error_inspector)
+      end
+
+      def node_load_failed(node_name, exception, config)
+        error_inspector = ErrorInspectors::NodeLoadErrorInspector.new(node_name, exception, config)
+        headline = "Chef encountered an error attempting to load the node data for \"#{node_name}\""
+        describe_error(headline, error_inspector)
+      end
+
+      def run_list_expand_failed(node, exception)
+        error_inspector = ErrorInspectors::RunListExpansionErrorInspector.new(node, exception)
+        headline = "Error expanding the run_list:"
+        describe_error(headline, error_inspector)
+      end
+
+      def cookbook_resolution_failed(expanded_run_list, exception)
+        error_inspector = ErrorInspectors::CookbookResolveErrorInspector.new(expanded_run_list, exception)
+        headline = "Error Resolving Cookbooks for Run List:"
+        describe_error(headline, error_inspector)
+      end
+
+      def cookbook_sync_failed(cookbooks, exception)
+        error_inspector = ErrorInspectors::CookbookSyncErrorInspector.new(cookbooks, exception)
+        headline = "Error Syncing Cookbooks:"
+        describe_error(headline, error_inspector)
+      end
+
+      def resource_failed(resource, action, exception)
+        error_inspector = ErrorInspectors::ResourceFailureInspector.new(resource, action, exception)
+        headline = "Error executing action `#{action}` on resource '#{resource}'"
+        describe_error(headline, error_inspector)
+      end
+
+      # Generic callback for any attribute/library/lwrp/recipe file in a
+      # cookbook getting loaded. The per-filetype callbacks for file load are
+      # overriden so that they call this instead. This means that a subclass of
+      # Formatters::Base can implement #file_loaded to do the same thing for
+      # every kind of file that Chef loads from a recipe instead of
+      # implementing all the per-filetype callbacks.
+      def file_loaded(path)
+      end
+
+      # Generic callback for any attribute/library/lwrp/recipe file throwing an
+      # exception when loaded. Default behavior is to use CompileErrorInspector
+      # to print contextual info about the failure.
+      def file_load_failed(path, exception)
+        error_inspector = ErrorInspectors::CompileErrorInspector.new(path, exception)
+        headline = "Error compiling #{path}"
+        describe_error(headline, error_inspector)
+      end
+
+      # Delegates to #file_loaded
+      def library_file_loaded(path)
+        file_loaded(path)
+      end
+
+      # Delegates to #file_load_failed
+      def library_file_load_failed(path, exception)
+        file_load_failed(path, exception)
+      end
+
+      # Delegates to #file_loaded
+      def lwrp_file_loaded(path)
+        file_loaded(path)
+      end
+
+      # Delegates to #file_load_failed
+      def lwrp_file_load_failed(path, exception)
+        file_load_failed(path, exception)
+      end
+
+      # Delegates to #file_loaded
+      def attribute_file_loaded(path)
+        file_loaded(path)
+      end
+
+      # Delegates to #file_load_failed
+      def attribute_file_load_failed(path, exception)
+        file_load_failed(path, exception)
+      end
+
+      # Delegates to #file_loaded
+      def definition_file_loaded(path)
+        file_loaded(path)
+      end
+
+      # Delegates to #file_load_failed
+      def definition_file_load_failed(path, exception)
+        file_load_failed(path, exception)
+      end
+
+      # Delegates to #file_loaded
+      def recipe_file_loaded(path)
+        file_loaded(path)
+      end
+
+      # Delegates to #file_load_failed
+      def recipe_file_load_failed(path, exception)
+        file_load_failed(path, exception)
+      end
+
+    end
+
+
+    # == NullFormatter
+    # Formatter that doesn't actually produce any ouput. You can use this to
+    # disable the use of output formatters.
+    class NullFormatter < Base
+
+      cli_name(:null)
+
+    end
+
+  end
+end
+