chef 10.28.2-x86-mingw32

data/lib/chef/mixin/securable.rb

@@ -0,0 +1,180 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, 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.
+#
+
+class Chef
+  module Mixin
+    module Securable
+
+      def owner(arg=nil)
+        set_or_return(
+          :owner,
+          arg,
+          :regex => Chef::Config[:user_valid_regex]
+        )
+      end
+
+      alias :user :owner
+
+      def group(arg=nil)
+        set_or_return(
+          :group,
+          arg,
+          :regex => Chef::Config[:group_valid_regex]
+        )
+      end
+
+      def mode(arg=nil)
+        set_or_return(
+          :mode,
+          arg,
+          :callbacks => {
+            "not in valid numeric range" => lambda { |m|
+              if m.kind_of?(String)
+                m =~ /^0/ || m="0#{m}"
+              end
+
+              # Windows does not support the sticky or setuid bits
+              if Chef::Platform.windows?
+                Integer(m)<=0777 && Integer(m)>=0
+              else
+                Integer(m)<=07777 && Integer(m)>=0
+              end
+            },
+          }
+        )
+      end
+
+      # TODO should this be separated into different files?
+      if RUBY_PLATFORM =~ /mswin|mingw|windows/
+
+        # === rights_attribute
+        # "meta-method" for dynamically creating rights attributes on resources.
+        #
+        # Multiple rights attributes can be declared. This enables resources to
+        # have multiple rights attributes with separate runtime states.
+        #
+        # For example, +Chef::Resource::RemoteDirectory+ supports different
+        # rights on the directories and files by declaring separate rights
+        # attributes for each (rights and files_rights).
+        #
+        # ==== User Level API
+        # Given a resource that calls
+        #
+        #   rights_attribute(:rights)
+        #
+        # Then the resource DSL could be used like this:
+        #
+        #   rights :read, ["Administrators","Everyone"]
+        #   rights :deny, "Pinky"
+        #   rights :full_control, "Users", :applies_to_children => true
+        #   rights :write, "John Keiser", :applies_to_children => :containers_only, :applies_to_self => false, :one_level_deep => true
+        #
+        # ==== Internal Data Structure
+        # rights attributes support multiple right declarations
+        # in a single resource block--the data will be merged
+        # into a single internal hash.
+        #
+        # The internal representation is a hash with the following keys:
+        #
+        # * `:permissions`: Integer of Windows permissions flags, 1..2^32
+        # or one of `[:full_control, :modify, :read_execute, :read, :write]`
+        # * `:principals`:  String or Array of Strings represnting usernames on
+        # the system.
+        # * `:applies_to_children` (optional): Boolean
+        # * `:applies_to_self` (optional): Boolean
+        # * `:one_level_deep` (optional): Boolean
+        #
+        def self.rights_attribute(name)
+
+          # equivalent to something like:
+          # def rights(permissions=nil, principals=nil, args_hash=nil)
+          define_method(name) do |*args|
+            # Ruby 1.8 compat: default the arguments
+            permissions = args.length >= 1 ? args[0] : nil
+            principals = args.length >= 2 ? args[1] : nil
+            args_hash = args.length >= 3 ? args[2] : nil
+            raise ArgumentError.new("wrong number of arguments (#{args.length} for 3)") if args.length >= 4
+
+            rights = self.instance_variable_get("@#{name.to_s}".to_sym)
+            unless permissions.nil?
+              input = {
+                :permissions => permissions,
+                :principals => principals
+              }
+              input.merge!(args_hash) unless args_hash.nil?
+
+              validations = {:permissions => { :required => true },
+                             :principals => { :required => true, :kind_of => [String, Array] },
+                             :applies_to_children => { :equal_to => [ true, false, :containers_only, :objects_only ]},
+                             :applies_to_self => { :kind_of => [ TrueClass, FalseClass ] },
+                             :one_level_deep => { :kind_of => [ TrueClass, FalseClass ] }
+                            }
+              validate(input, validations)
+
+              [ permissions ].flatten.each do |permission|
+                if permission.is_a?(Integer)
+                  if permission < 0 || permission > 1<<32
+                    raise ArgumentError, "permissions flags must be positive and <= 32 bits (#{permission})"
+                  end
+                elsif !([:full_control, :modify, :read_execute, :read, :write].include?(permission.to_sym))
+                  raise ArgumentError, "permissions parameter must be :full_control, :modify, :read_execute, :read, :write or an integer representing Windows permission flags"
+                end
+              end
+
+              [ principals ].flatten.each do |principal|
+                if !principal.is_a?(String)
+                  raise ArgumentError, "principals parameter must be a string or array of strings representing usernames"
+                end
+              end
+
+              if input[:applies_to_children] == false
+                if input[:applies_to_self] == false
+                  raise ArgumentError, "'rights' attribute must specify either :applies_to_children or :applies_to_self."
+                end
+                if input[:one_level_deep] == true
+                  raise ArgumentError, "'rights' attribute specified :one_level_deep without specifying :applies_to_children."
+                end
+              end
+              rights ||= []
+              rights << input
+            end
+            set_or_return(
+              name,
+              rights,
+              {}
+            )
+          end
+        end
+
+        # create a default 'rights' attribute
+        rights_attribute(:rights)
+        rights_attribute(:deny_rights)
+
+        def inherits(arg=nil)
+          set_or_return(
+            :inherits,
+            arg,
+            :kind_of => [ TrueClass, FalseClass ]
+          )
+        end
+
+      end # Windows-specific
+
+    end
+  end
+end

data/lib/chef/mixin/shell_out.rb

@@ -0,0 +1,69 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010 Opscode, 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 'chef/shell_out'
+require 'chef/config'
+
+class Chef
+  module Mixin
+    module ShellOut
+
+      def shell_out(*command_args)
+        cmd = Mixlib::ShellOut.new(*run_command_compatible_options(command_args))
+        if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.debug?
+          cmd.live_stream = STDOUT
+        end
+        cmd.run_command
+        cmd
+      end
+
+      def shell_out!(*command_args)
+        cmd= shell_out(*command_args)
+        cmd.error!
+        cmd
+      end
+
+      DEPRECATED_OPTIONS =
+        [ [:command_log_level,   :log_level],
+          [:command_log_prepend, :log_tag] ]
+
+      # CHEF-3090: Deprecate command_log_level and command_log_prepend
+      # Patterned after https://github.com/opscode/chef/commit/e1509990b559984b43e428d4d801c394e970f432
+      def run_command_compatible_options(command_args)
+        return command_args unless command_args.last.is_a?(Hash)
+
+        _command_args = command_args.dup
+        _options = _command_args.last
+
+        DEPRECATED_OPTIONS.each do |old_option, new_option|
+          # Edge case: someone specifies :command_log_level and 'command_log_level' in the option hash
+          next unless value = _options.delete(old_option) || _options.delete(old_option.to_s)
+          deprecate_option old_option, new_option
+          _options[new_option] = value
+        end
+
+        return _command_args
+      end
+
+      private
+
+      def deprecate_option(old_option, new_option)
+        Chef::Log.logger.warn "DEPRECATION: Chef::Mixin::ShellOut option :#{old_option} is deprecated. Use :#{new_option}"
+      end
+    end
+  end
+end

data/lib/chef/mixin/template.rb

@@ -0,0 +1,100 @@
+#--
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, 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 'tempfile'
+require 'erubis'
+
+class Chef
+  module Mixin
+    module Template
+      
+      module ChefContext
+        def node
+          return @node if @node
+          raise "Could not find a value for node. If you are explicitly setting variables in a template, " +
+                "include a node variable if you plan to use it."
+        end
+      end
+      
+      ::Erubis::Context.send(:include, ChefContext)
+      
+      # Render a template with Erubis.  Takes a template as a string, and a 
+      # context hash.  
+      def render_template(template, context)
+        begin
+          eruby = Erubis::Eruby.new(template)
+          output = eruby.evaluate(context)
+        rescue Object => e
+          raise TemplateError.new(e, template, context)
+        end
+        Tempfile.open("chef-rendered-template") do |tempfile|
+          tempfile.print(output)
+          tempfile.close
+          yield tempfile
+        end
+      end
+      
+      class TemplateError < RuntimeError
+        attr_reader :original_exception, :context
+        SOURCE_CONTEXT_WINDOW = 2
+        
+        def initialize(original_exception, template, context)
+          @original_exception, @template, @context = original_exception, template, context
+        end
+        
+        def message
+          @original_exception.message
+        end
+        
+        def line_number
+          @line_number ||= $1.to_i if original_exception.backtrace.find {|line| line =~ /\(erubis\):(\d+)/ }
+        end
+        
+        def source_location
+          "on line ##{line_number}"
+        end
+        
+        def source_listing
+          @source_listing ||= begin
+            lines = @template.split(/\n/)
+            if line_number
+              line_index = line_number - 1
+              beginning_line = line_index <= SOURCE_CONTEXT_WINDOW ? 0 : line_index - SOURCE_CONTEXT_WINDOW
+              source_size = SOURCE_CONTEXT_WINDOW * 2 + 1
+            else
+              beginning_line = 0
+              source_size    = lines.length
+            end
+            contextual_lines = lines[beginning_line, source_size]
+            output = []
+            contextual_lines.each_with_index do |line, index|
+              line_number = (index+beginning_line+1).to_s.rjust(3)
+              output << "#{line_number}: #{line}"
+            end
+            output.join("\n")
+          end
+        end
+        
+        def to_s
+          "\n\n#{self.class} (#{message}) #{source_location}:\n\n" +
+            "#{source_listing}\n\n  #{original_exception.backtrace.join("\n  ")}\n\n"
+        end
+      end
+    end
+  end
+end

data/lib/chef/mixin/why_run.rb

@@ -0,0 +1,332 @@
+#
+# Author:: Dan DeLeo ( <dan@opscode.com> )
+# Author:: Marc Paradise ( <marc@opscode.com> )
+# Copyright:: Copyright (c) 2012 Opscode, 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.
+#
+
+class Chef
+  module Mixin
+    module WhyRun
+
+      # ==ConvergeActions
+      # ConvergeActions implements the logic for why run. A ConvergeActions
+      # object wraps a collection of actions, which consist of a descriptive
+      # string and a block/Proc. Actions are executed by calling #converge!
+      # When why_run mode is enabled, each action's description will be
+      # printed, but the block will not be called. Conversely, in normal mode,
+      # the block is called, but the message is not printed.
+      #
+      # In general, this class should be accessed through the API provided by
+      # Chef::Provider.
+      class ConvergeActions
+        attr_reader :actions
+
+        def initialize(resource, run_context, action)
+          @resource, @run_context = resource, run_context
+          @actions = []
+        end
+
+        def events
+          @run_context.events
+        end
+
+        # Adds an action to the list. +descriptions+ can either be an Array of
+        # Strings, or a single String describing the action; +block+ is a
+        # block/proc that implements the action.
+        def add_action(descriptions, &block)
+          @actions << [descriptions, block]
+          if !Chef::Config[:why_run]
+            block.call
+          end
+          events.resource_update_applied(@resource, @action, descriptions)
+        end
+
+        # True if there are no actions to execute.
+        def empty?
+          @actions.empty?
+        end
+      end
+
+      # == ResourceRequirements
+      # ResourceRequirements provides a framework for making assertions about
+      # the host system's state. It also provides a mechanism for making
+      # assumptions about what the system's state might have been when running
+      # in why run mode.
+      #
+      # For example, consider a recipe that consists of a package resource and
+      # a service resource. If the service's init script is installed by the
+      # package, and Chef is running in why run mode, then the service resource
+      # would fail when attempting to run `/etc/init.d/software-name status`.
+      # In order to provide a more useful approximation of what would happen in
+      # a real chef run, we want to instead assume that the service was created
+      # but isn't running. The logic would look like this:
+      #
+      #     # Hypothetical service provider demonstrating why run assumption logic.
+      #     # This isn't the actual API, it just shows the logic.
+      #     class HypotheticalServiceProvider < Chef::Provider
+      #
+      #       def load_current_resource
+      #         # Make sure we have the init script available:
+      #         if ::File.exist?("/etc/init.d/some-service"
+      #           # If the init script exists, proceed as normal:
+      #           status_cmd = shell_out("/etc/init.d/some-service status")
+      #           if status_cmd.success?
+      #             @current_resource.status(:running)
+      #           else
+      #             @current_resource.status(:stopped)
+      #           end
+      #         else
+      #           if whyrun_mode?
+      #             # If the init script is not available, and we're in why run mode,
+      #             # assume that some previous action would've created it:
+      #             log("warning: init script '/etc/init.d/some-service' is not available")
+      #             log("warning: assuming that the init script would have been created, assuming the state of 'some-service' is 'stopped'")
+      #             @current_resource.status(:stopped)
+      #           else
+      #             raise "expected init script /etc/init.d/some-service doesn't exist"
+      #           end
+      #         end
+      #       end
+      #
+      #     end
+      #
+      # In short, the code above does the following:
+      # * runs a test to determine if a requirement is met:
+      #   `::File.exist?("/etc/init.d/some-service"`
+      # * raises an error if the requirement is not met, and we're not in why
+      #   run mode.
+      # * if we *are* in why run mode, print a message explaining the
+      #   situation, and run some code that makes an assumption about what the
+      #   state of the system would be. In this case, we also skip the normal
+      #   `load_current_resource` logic
+      # * when the requirement *is* met, we run the normal `load_current_resource`
+      #   logic
+      #
+      # ResourceRequirements encapsulates the above logic in a more declarative API.
+      #
+      # === Examples
+      # Assertions and assumptions should be created through the WhyRun#assert
+      # method, which gets mixed in to providers. See that method's
+      # documentation for examples.
+      class ResourceRequirements
+
+        # Implements the logic for a single assertion/assumption. See the
+        # documentation for ResourceRequirements for full discussion.
+        class Assertion
+          class AssertionFailure < RuntimeError
+          end
+
+          def initialize
+            @block_action = false
+            @assertion_proc = nil
+            @failure_message = nil
+            @whyrun_message = nil
+            @resource_modifier = nil
+            @assertion_failed = false
+            @exception_type = AssertionFailure
+          end
+
+          # Defines the code block that determines if a requirement is met. The
+          # block should return a truthy value to indicate that the requirement
+          # is met, and a falsey value if the requirement is not met.
+          #   # in a provider:
+          #   assert(:some_action) do |a|
+          #     # This provider requires the file /tmp/foo to exist:
+          #     a.assertion { ::File.exist?("/tmp/foo") }
+          #   end
+          def assertion(&assertion_proc)
+            @assertion_proc = assertion_proc
+          end
+
+          # Defines the failure message, and optionally the Exception class to
+          # use when a requirement is not met. It works like `raise`:
+          #   # in a provider:
+          #   assert(:some_action) do |a|
+          #     # This example shows usage with 1 or 2 args by calling #failure_message twice.
+          #     # In practice you should only call this once per Assertion.
+          #
+          #     # Set the Exception class explicitly
+          #     a.failure_message(Chef::Exceptions::MissingRequiredFile, "File /tmp/foo doesn't exist")
+          #     # Fallback to the default error class (AssertionFailure)
+          #     a.failure_message("File /tmp/foo" doesn't exist")
+          #   end
+          def failure_message(*args)
+            case args.size
+            when 1
+              @failure_message = args[0]
+            when 2
+              @exception_type, @failure_message = args[0], args[1]
+            else
+              raise ArgumentError, "#{self.class}#failure_message takes 1 or 2 arguments, you gave #{args.inspect}"
+            end
+          end
+
+          # Defines a message and optionally provides a code block to execute
+          # when the requirement is not met and Chef is executing in why run
+          # mode
+          #
+          # If no failure_message is provided (above), then execution 
+          # will be allowed to continue in both whyrun an dnon-whyrun
+          # mode
+          #
+          # With a service resource that requires /etc/init.d/service-name to exist:
+          #   # in a provider
+          #   assert(:start, :restart) do |a|
+          #     a.assertion { ::File.exist?("/etc/init.d/service-name") }
+          #     a.whyrun("Init script '/etc/init.d/service-name' doesn't exist, assuming a prior action would have created it.") do
+          #       # blindly assume that the service exists but is stopped in why run mode:
+          #       @new_resource.status(:stopped)
+          #     end
+          #   end
+          def whyrun(message, &resource_modifier)
+            @whyrun_message = message
+            @resource_modifier = resource_modifier
+          end
+
+          # Prevents associated actions from being invoked in whyrun mode. 
+          # This will also stop further processing of assertions for a given action. 
+          # 
+          # An example from the template provider: if the source template doesn't exist 
+          # we can't parse it in the action_create block of template - something that we do 
+          # even in whyrun mode.  Because the soruce template may have been created in an earlier 
+          # step, we still want to keep going in whyrun mode.
+          # 
+          # assert(:create, :create_if_missing) do |a|
+          #   a.assertion { File::exists?(@new_resource.source) } 
+          #   a.whyrun "Template source file does not exist, assuming it would have been created."
+          #   a.block_action!
+          # end
+          #
+          def block_action!
+            @block_action = true
+          end
+
+          def block_action? 
+            @block_action
+          end
+
+          def assertion_failed?
+            @assertion_failed
+          end
+
+
+          # Runs the assertion/assumption logic. Will raise an Exception of the
+          # type specified in #failure_message (or AssertionFailure by default)
+          # if the requirement is not met and Chef is not running in why run
+          # mode. An exception will also be raised if running in why run mode
+          # and no why run message or block has been declared.
+          def run(action, events, resource)
+            if !@assertion_proc || !@assertion_proc.call
+              @assertion_failed = true
+              if Chef::Config[:why_run] && @whyrun_message
+                events.provider_requirement_failed(action, resource, @exception_type, @failure_message)
+                events.whyrun_assumption(action, resource, @whyrun_message) if @whyrun_message
+                @resource_modifier.call if @resource_modifier
+              else
+                if @failure_message
+                  events.provider_requirement_failed(action, resource, @exception_type, @failure_message)
+                  raise @exception_type, @failure_message
+                end
+              end
+            end
+          end
+        end
+
+        def initialize(resource, run_context)
+          @resource, @run_context = resource, run_context
+          @assertions = Hash.new {|h,k| h[k] = [] }
+          @blocked_actions = []
+        end
+
+        def events
+          @run_context.events
+        end
+
+        # Check to see if a given action is blocked by a failed assertion
+        #
+        # Takes the action name to be verified.
+        def action_blocked?(action) 
+          @blocked_actions.include?(action)
+        end
+
+        # Define a new Assertion.
+        #
+        # Takes a list of action names for which the assertion should be made.
+        # ==== Examples:
+        # A File provider that requires the parent directory to exist:
+        #
+        #   assert(:create, :create_if_missing) do |a|
+        #     parent_dir = File.basename(@new_resource.path)
+        #     a.assertion { ::File.directory?(parent_dir) }
+        #     a.failure_message(Exceptions::ParentDirectoryDoesNotExist,
+        #                       "Can't create file #{@new_resource.path}: parent directory #{parent_dir} doesn't exist")
+        #     a.why_run("assuming parent directory #{parent_dir} would have been previously created"
+        #   end
+        #
+        # A service provider that requires the init script to exist:
+        #
+        #   assert(:start, :restart) do |a|
+        #     a.assertion { ::File.exist?(@new_resource.init_script) }
+        #     a.failure_message(Exceptions::MissingInitScript,
+        #                       "Can't check status of #{@new_resource}: init script #{@new_resource.init_script} is missing")
+        #     a.why_run("Assuming init script would have been created and service is stopped") do
+        #       @current_resource.status(:stopped)
+        #     end
+        #   end
+        #
+        # A File provider that will error out if you don't have permissions do
+        # delete the file, *even in why run mode*:
+        #
+        #   assert(:delete) do |a|
+        #     a.assertion { ::File.writable?(@new_resource.path) }
+        #     a.failure_message(Exceptions::InsufficientPrivileges,
+        #                       "You don't have sufficient privileges to delete #{@new_resource.path}")
+        #   end
+        #
+        # A Template provider that will prevent action execution but continue the run in 
+        # whyrun mode if the template source is not available.
+        #   assert(:create, :create_if_missing) do |a| 
+        #     a.assertion { File::exist?(@new_resource.source) }
+        #     a.failure_message Chef::Exceptions::TemplateError, "Template #{@new_resource.source} could not be found exist."
+        #     a.whyrun "Template source #{@new_resource.source} does not exist. Assuming it would have been created."
+        #     a.block_action!
+        #   end
+        #
+        #   assert(:delete) do |a|
+        #     a.assertion { ::File.writable?(@new_resource.path) }
+        #     a.failure_message(Exceptions::InsufficientPrivileges,
+        #                       "You don't have sufficient privileges to delete #{@new_resource.path}")
+        #   end
+        def assert(*actions)
+          assertion = Assertion.new
+          yield assertion
+          actions.each {|action| @assertions[action] << assertion }
+        end
+
+        # Run the assertion and assumption logic.
+        def run(action)
+          @assertions[action.to_sym].each do |a| 
+            a.run(action, events, @resource)
+            if a.assertion_failed? and a.block_action? 
+              @blocked_actions << action
+              return
+            end
+          end
+        end
+      end
+    end
+  end
+end