chef 12.4.0.rc.0-universal-mingw32

data/lib/chef/mixin/template.rb

@@ -0,0 +1,215 @@
+#--
+# 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
+
+      # == ChefContext
+      # ChefContext was previously used to mix behavior into Erubis::Context so
+      # that it would be available to templates. This behavior has now moved to
+      # TemplateContext, but this module is still mixed in to the
+      # TemplateContext class so that any user code that modified ChefContext
+      # will continue to work correctly.
+      module ChefContext
+      end
+
+      # == TemplateContext
+      # TemplateContext is the base context class for all templates in Chef. It
+      # defines user-facing extensions to the base Erubis::Context to provide
+      # enhanced features. Individual instances of TemplateContext can be
+      # extended to add logic to a specific template.
+      #
+      class TemplateContext < Erubis::Context
+
+        include ChefContext
+
+        attr_reader :_extension_modules
+
+        def initialize(variables)
+          super
+          @_extension_modules = []
+        end
+
+        ###
+        # USER FACING API
+        ###
+
+        # Returns the current node object, or raises an error if it's not set.
+        # Provides API consistency, allowing users to reference the node object
+        # by the bare `node` everywhere.
+        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
+
+        #
+        # Takes the name of the partial, plus a hash of options. Returns a
+        # string that contains the result of the evaluation of the partial.
+        #
+        # All variables from the parent template will be propagated down to
+        # the partial, unless you pass the +variables+ option (see below).
+        #
+        # Valid options are:
+        #
+        # :local:: If true then the partial name will be interpreted as the
+        #          path to a file on the local filesystem; if false (the
+        #          default) it will be looked up in the cookbook according to
+        #          the normal rules for templates.
+        # :source:: If specified then the partial will be looked up with this
+        #           name or path (according to the +local+ option) instead of
+        #           +partial_name+.
+        # :cookbook:: Search for the partial in the provided cookbook instead
+        #             of the cookbook that contains the top-level template.
+        # :variables:: A Hash of variable_name => value that will be made
+        #              available to the partial. If specified, none of the
+        #              variables from the master template will be, so if you
+        #              need them you will need to propagate them explicitly.
+        #
+        def render(partial_name, options = {})
+          raise "You cannot render partials in this context" unless @template_finder
+
+          partial_variables = options.delete(:variables) || _public_instance_variables
+          partial_context = self.class.new(partial_variables)
+          partial_context._extend_modules(@_extension_modules)
+
+          template_location = @template_finder.find(partial_name, options)
+          _render_template(IO.binread(template_location), partial_context)
+        end
+
+        def render_template(template_location)
+          _render_template(IO.binread(template_location), self)
+        end
+
+        def render_template_from_string(template)
+          _render_template(template, self)
+        end
+
+        ###
+        # INTERNAL PUBLIC API
+        ###
+
+        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
+
+          # CHEF-4399
+          # Erubis always emits unix line endings during template
+          # rendering. Chef used to convert line endings to the
+          # original line endings in the template. However this
+          # created problems in cases when cookbook developer is
+          # coding the cookbook on windows but using it on non-windows
+          # platforms.
+          # The safest solution is to make sure that native to the
+          # platform we are running on is used in order to minimize
+          # potential issues for the applications that will consume
+          # this template.
+
+          if Chef::Platform.windows?
+            output = output.gsub(/\r?\n/,"\r\n")
+          end
+
+          output
+        end
+
+        def _extend_modules(module_names)
+          module_names.each do |mod|
+            context_methods = [:node, :render, :render_template, :render_template_from_string]
+            context_methods.each do |core_method|
+              if mod.method_defined?(core_method) or mod.private_method_defined?(core_method)
+                Chef::Log.warn("Core template method `#{core_method}' overridden by extension module #{mod}")
+              end
+            end
+            extend(mod)
+            @_extension_modules << mod
+          end
+        end
+
+        # Collects instance variables set on the current object as a Hash
+        # suitable for creating a new TemplateContext. Instance variables that
+        # are only valid for this specific instance are omitted from the
+        # collection.
+        def _public_instance_variables
+          all_ivars = instance_variables
+          all_ivars.delete(:@_extension_modules)
+          all_ivars.inject({}) do |ivar_map, ivar_symbol_name|
+            value = instance_variable_get(ivar_symbol_name)
+            name_without_at = ivar_symbol_name.to_s[1..-1].to_sym
+            ivar_map[name_without_at] = value
+            ivar_map
+          end
+        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/unformatter.rb

@@ -0,0 +1,32 @@
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software
+# 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 Unformatter
+
+      def write(message)
+        data = message.match(/(\[.+?\] )?([\w]+):(.*)$/)
+        self.send(data[2].downcase.chomp.to_sym, data[3].strip)
+      rescue NoMethodError
+        self.send(:info, message)
+      end
+
+    end
+  end
+end

data/lib/chef/mixin/uris.rb

@@ -0,0 +1,33 @@
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, 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 'uri'
+
+class Chef
+  module Mixin
+    module Uris
+      # uri_scheme? returns true if the string starts with
+      # scheme://
+      # For example, it will match http://foo.bar.com
+      def uri_scheme?(source)
+        # From open-uri
+        !!(%r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ source)
+      end
+    end
+  end
+end

data/lib/chef/mixin/which.rb

@@ -0,0 +1,37 @@
+#--
+# Author:: Lamont Granquist <lamont@getchef.io>
+# 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.
+
+class Chef
+  module Mixin
+    module Which
+      def which(cmd, opts = {})
+        extra_path =
+          if opts[:extra_path].nil?
+            [ '/bin', '/usr/bin', '/sbin', '/usr/sbin' ]
+          else
+            [ opts[:extra_path] ].flatten
+          end
+        paths = ENV['PATH'].split(File::PATH_SEPARATOR) + extra_path
+        paths.each do |path|
+          filename = File.join(path, cmd)
+          return filename if File.executable?(filename)
+        end
+        false
+      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 (@resource.respond_to?(:is_guard_interpreter) && @resource.is_guard_interpreter) || !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 and non-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 source 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