chef 12.4.0.rc.0-universal-mingw32

data/lib/chef/policy_builder/policyfile.rb

@@ -0,0 +1,387 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright 2008-2014 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 'chef/log'
+require 'chef/rest'
+require 'chef/run_context'
+require 'chef/config'
+require 'chef/node'
+
+class Chef
+  module PolicyBuilder
+
+    # Policyfile is an experimental policy builder implementation that gets run
+    # list and cookbook version information from a single document.
+    #
+    # == WARNING
+    # This implementation is experimental. It may be changed in incompatible
+    # ways in minor or even patch releases, or even abandoned altogether. If
+    # using this with other tools, you may be forced to upgrade those tools in
+    # lockstep with chef-client because of incompatible behavior changes.
+    #
+    # == Unsupported Options:
+    # * override_runlist:: This could potentially be integrated into the
+    # policyfile, or replaced with a similar feature that has different
+    # semantics.
+    # * specific_recipes:: put more design thought into this use case.
+    # * run_list in json_attribs:: would be ignored anyway, so it raises an error.
+    # * chef-solo:: not currently supported. Need more design thought around
+    # how this should work.
+    class Policyfile
+
+      class UnsupportedFeature < StandardError; end
+
+      class PolicyfileError < StandardError; end
+
+      RunListExpansionIsh = Struct.new(:recipes, :roles)
+
+      attr_reader :events
+      attr_reader :node
+      attr_reader :node_name
+      attr_reader :ohai_data
+      attr_reader :json_attribs
+      attr_reader :run_context
+
+      def initialize(node_name, ohai_data, json_attribs, override_runlist, events)
+        @node_name = node_name
+        @ohai_data = ohai_data
+        @json_attribs = json_attribs
+        @events = events
+
+        @node = nil
+
+        Chef::Log.warn("Using experimental Policyfile feature")
+
+        if Chef::Config[:solo]
+          raise UnsupportedFeature, "Policyfile does not support chef-solo at this time."
+        end
+
+        if override_runlist
+          raise UnsupportedFeature, "Policyfile does not support override run lists at this time"
+        end
+
+        if json_attribs && json_attribs.key?("run_list")
+          raise UnsupportedFeature, "Policyfile does not support setting the run_list in json data at this time"
+        end
+
+        if Chef::Config[:environment] && !Chef::Config[:environment].chomp.empty?
+          raise UnsupportedFeature, "Policyfile does not work with Chef Environments"
+        end
+      end
+
+      ## API Compat ##
+      # Methods related to unsupported features
+
+      # Override run_list is not supported.
+      def original_runlist
+        nil
+      end
+
+      # Override run_list is not supported.
+      def override_runlist
+        nil
+      end
+
+      # Policyfile gives you the run_list already expanded, but users of this
+      # class may expect to get a run_list expansion compatible object by
+      # calling this method.
+      #
+      # === Returns
+      # RunListExpansionIsh:: A RunListExpansion duck type
+      def run_list_expansion
+        run_list_expansion_ish
+      end
+
+      ## PolicyBuilder API ##
+
+      # Loads the node state from the server.
+      def load_node
+        events.node_load_start(node_name, Chef::Config)
+        Chef::Log.debug("Building node object for #{node_name}")
+
+        @node = Chef::Node.find_or_create(node_name)
+        validate_policyfile
+        node
+      rescue Exception => e
+        events.node_load_failed(node_name, e, Chef::Config)
+        raise
+      end
+
+      # Applies environment, external JSON attributes, and override run list to
+      # the node, Then expands the run_list.
+      #
+      # === Returns
+      # node<Chef::Node>:: The modified node object. node is modified in place.
+      def build_node
+        # consume_external_attrs may add items to the run_list. Save the
+        # expanded run_list, which we will pass to the server later to
+        # determine which versions of cookbooks to use.
+        node.reset_defaults_and_overrides
+
+        node.consume_external_attrs(ohai_data, json_attribs)
+
+        expand_run_list
+        apply_policyfile_attributes
+
+        Chef::Log.info("Run List is [#{run_list}]")
+        Chef::Log.info("Run List expands to [#{run_list_with_versions_for_display.join(', ')}]")
+
+
+        events.node_load_completed(node, run_list_with_versions_for_display, Chef::Config)
+
+        node
+      rescue Exception => e
+        events.node_load_failed(node_name, e, Chef::Config)
+        raise
+      end
+
+      def setup_run_context(specific_recipes=nil)
+        Chef::Cookbook::FileVendor.fetch_from_remote(http_api)
+        sync_cookbooks
+        cookbook_collection = Chef::CookbookCollection.new(cookbooks_to_sync)
+        run_context = Chef::RunContext.new(node, cookbook_collection, events)
+
+        run_context.load(run_list_expansion_ish)
+
+        run_context
+      end
+
+      def expand_run_list
+        node.run_list(run_list)
+        node.automatic_attrs[:roles] = []
+        node.automatic_attrs[:recipes] = run_list_expansion_ish.recipes
+        run_list_expansion_ish
+      end
+
+
+      def sync_cookbooks
+        Chef::Log.debug("Synchronizing cookbooks")
+        synchronizer = Chef::CookbookSynchronizer.new(cookbooks_to_sync, events)
+        synchronizer.sync_cookbooks
+
+        # register the file cache path in the cookbook path so that CookbookLoader actually picks up the synced cookbooks
+        Chef::Config[:cookbook_path] = File.join(Chef::Config[:file_cache_path], "cookbooks")
+
+        cookbooks_to_sync
+      end
+
+      # Whether or not this is a temporary policy. Since PolicyBuilder doesn't
+      # support override_runlist, this is always false.
+      def temporary_policy?
+        false
+      end
+
+      ## Internal Public API ##
+
+      def run_list_with_versions_for_display
+        run_list.map do |recipe_spec|
+          cookbook, recipe = parse_recipe_spec(recipe_spec)
+          lock_data = cookbook_lock_for(cookbook)
+          display = "#{cookbook}::#{recipe}@#{lock_data["version"]} (#{lock_data["identifier"][0...7]})"
+          display
+        end
+      end
+
+      def run_list_expansion_ish
+        recipes = run_list.map do |recipe_spec|
+          cookbook, recipe = parse_recipe_spec(recipe_spec)
+          "#{cookbook}::#{recipe}"
+        end
+        RunListExpansionIsh.new(recipes, [])
+      end
+
+      def apply_policyfile_attributes
+        node.attributes.role_default = policy["default_attributes"]
+        node.attributes.role_override = policy["override_attributes"]
+      end
+
+      def parse_recipe_spec(recipe_spec)
+        rmatch = recipe_spec.match(/recipe\[([^:]+)::([^:]+)\]/)
+        if rmatch.nil?
+          raise PolicyfileError, "invalid recipe specification #{recipe_spec} in Policyfile from #{policyfile_location}"
+        else
+          [rmatch[1], rmatch[2]]
+        end
+      end
+
+      def cookbook_lock_for(cookbook_name)
+        cookbook_locks[cookbook_name]
+      end
+
+      def run_list
+        policy["run_list"]
+      end
+
+      def policy
+        @policy ||= http_api.get(policyfile_location)
+      rescue Net::HTTPServerException => e
+        raise ConfigurationError, "Error loading policyfile from `#{policyfile_location}': #{e.class} - #{e.message}"
+      end
+
+      def policyfile_location
+        if Chef::Config[:policy_document_native_api]
+          validate_policy_config!
+          "policy_groups/#{policy_group}/policies/#{policy_name}"
+        else
+          "data/policyfiles/#{deployment_group}"
+        end
+      end
+
+      # Do some mimimal validation of the policyfile we fetched from the
+      # server. Compatibility mode relies on using data bags to store policy
+      # files; therefore no real validation will be performed server-side and
+      # we need to make additional checks to ensure the data will be formatted
+      # correctly.
+      def validate_policyfile
+        errors = []
+        unless run_list
+          errors << "Policyfile is missing run_list element"
+        end
+        unless policy.key?("cookbook_locks")
+          errors << "Policyfile is missing cookbook_locks element"
+        end
+        if run_list.kind_of?(Array)
+          run_list_errors = run_list.select do |maybe_recipe_spec|
+            validate_recipe_spec(maybe_recipe_spec)
+          end
+          errors += run_list_errors
+        else
+          errors << "Policyfile run_list is malformed, must be an array of `recipe[cb_name::recipe_name]` items: #{policy["run_list"]}"
+        end
+
+        unless errors.empty?
+          raise PolicyfileError, "Policyfile fetched from #{policyfile_location} was invalid:\n#{errors.join("\n")}"
+        end
+      end
+
+      def validate_recipe_spec(recipe_spec)
+        parse_recipe_spec(recipe_spec)
+        nil
+      rescue PolicyfileError => e
+        e.message
+      end
+
+      class ConfigurationError < StandardError; end
+
+      def deployment_group
+        Chef::Config[:deployment_group] or
+          raise ConfigurationError, "Setting `deployment_group` is not configured."
+      end
+
+      def validate_policy_config!
+        policy_group or
+          raise ConfigurationError, "Setting `policy_group` is not configured."
+
+        policy_name or
+          raise ConfigurationError, "Setting `policy_name` is not configured."
+      end
+
+      def policy_group
+        Chef::Config[:policy_group]
+      end
+
+      def policy_name
+        Chef::Config[:policy_name]
+      end
+
+      # Builds a 'cookbook_hash' map of the form
+      #   "COOKBOOK_NAME" => "IDENTIFIER"
+      #
+      # This can be passed to a Chef::CookbookSynchronizer object to
+      # synchronize the cookbooks.
+      #
+      # TODO: Currently this makes N API calls to the server to get the
+      # cookbook objects. With server support (bulk API or the like), this
+      # should be reduced to a single call.
+      def cookbooks_to_sync
+        @cookbook_to_sync ||= begin
+          events.cookbook_resolution_start(run_list_with_versions_for_display)
+
+          cookbook_versions_by_name = cookbook_locks.inject({}) do |cb_map, (name, lock_data)|
+            cb_map[name] = manifest_for(name, lock_data)
+            cb_map
+          end
+          events.cookbook_resolution_complete(cookbook_versions_by_name)
+
+          cookbook_versions_by_name
+        end
+      rescue Exception => e
+        # TODO: wrap/munge exception to provide helpful error output
+        events.cookbook_resolution_failed(run_list_with_versions_for_display, e)
+        raise
+      end
+
+      # Fetches the CookbookVersion object for the given name and identifer
+      # specified in the lock_data.
+      # TODO: This only implements Chef 11 compatibility mode, which means that
+      # cookbooks are fetched by the "dotted_decimal_identifier": a
+      # representation of a SHA1 in the traditional x.y.z version format.
+      def manifest_for(cookbook_name, lock_data)
+        if Chef::Config[:policy_document_native_api]
+          artifact_manifest_for(cookbook_name, lock_data)
+        else
+          compat_mode_manifest_for(cookbook_name, lock_data)
+        end
+      end
+
+      def cookbook_locks
+        policy["cookbook_locks"]
+      end
+
+      def http_api
+        @api_service ||= Chef::REST.new(config[:chef_server_url])
+      end
+
+      def config
+        Chef::Config
+      end
+
+      private
+
+      def compat_mode_manifest_for(cookbook_name, lock_data)
+        xyz_version = lock_data["dotted_decimal_identifier"]
+        rel_url = "cookbooks/#{cookbook_name}/#{xyz_version}"
+        http_api.get(rel_url)
+      rescue Exception => e
+        message = "Error loading cookbook #{cookbook_name} at version #{xyz_version} from #{rel_url}: #{e.class} - #{e.message}"
+        err = Chef::Exceptions::CookbookNotFound.new(message)
+        err.set_backtrace(e.backtrace)
+        raise err
+      end
+
+      def artifact_manifest_for(cookbook_name, lock_data)
+        identifier = lock_data["identifier"]
+        rel_url = "cookbook_artifacts/#{cookbook_name}/#{identifier}"
+        inflate_cbv_object(http_api.get(rel_url))
+      rescue Exception => e
+        message = "Error loading cookbook #{cookbook_name} with identifier #{identifier} from #{rel_url}: #{e.class} - #{e.message}"
+        err = Chef::Exceptions::CookbookNotFound.new(message)
+        err.set_backtrace(e.backtrace)
+        raise err
+      end
+
+      def inflate_cbv_object(raw_manifest)
+        Chef::CookbookVersion.from_cb_artifact_data(raw_manifest)
+      end
+
+    end
+  end
+end

data/lib/chef/provider.rb

@@ -0,0 +1,228 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009 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/mixin/from_file'
+require 'chef/mixin/convert_to_class_name'
+require 'chef/mixin/enforce_ownership_and_permissions'
+require 'chef/mixin/why_run'
+require 'chef/mixin/shell_out'
+require 'chef/mixin/provides'
+require 'chef/platform/service_helpers'
+require 'chef/node_map'
+
+class Chef
+  class Provider
+    include Chef::Mixin::WhyRun
+    include Chef::Mixin::ShellOut
+    extend Chef::Mixin::Provides
+
+    # supports the given resource and action (late binding)
+    def self.supports?(resource, action)
+      true
+    end
+
+    attr_accessor :new_resource
+    attr_accessor :current_resource
+    attr_accessor :run_context
+
+    attr_reader :recipe_name
+    attr_reader :cookbook_name
+
+    #--
+    # TODO: this should be a reader, and the action should be passed in the
+    # constructor; however, many/most subclasses override the constructor so
+    # changing the arity would be a breaking change. Change this at the next
+    # break, e.g., Chef 11.
+    attr_accessor :action
+
+    def initialize(new_resource, run_context)
+      @new_resource = new_resource
+      @action = action
+      @current_resource = nil
+      @run_context = run_context
+      @converge_actions = nil
+
+      @recipe_name = nil
+      @cookbook_name = nil
+    end
+
+    def whyrun_mode?
+      Chef::Config[:why_run]
+    end
+
+    def whyrun_supported?
+      false
+    end
+
+    def node
+      run_context && run_context.node
+    end
+
+    # Used by providers supporting embedded recipes
+    def resource_collection
+      run_context && run_context.resource_collection
+    end
+
+    def cookbook_name
+      new_resource.cookbook_name
+    end
+
+    def check_resource_semantics!
+    end
+
+    def load_current_resource
+      raise Chef::Exceptions::Override, "You must override load_current_resource in #{self.to_s}"
+    end
+
+    def define_resource_requirements
+    end
+
+    def cleanup_after_converge
+    end
+
+    def action_nothing
+      Chef::Log.debug("Doing nothing for #{@new_resource.to_s}")
+      true
+    end
+
+    def events
+      run_context.events
+    end
+
+    def run_action(action=nil)
+      @action = action unless action.nil?
+
+      # TODO: it would be preferable to get the action to be executed in the
+      # constructor...
+
+      check_resource_semantics!
+
+      # user-defined LWRPs may include unsafe load_current_resource methods that cannot be run in whyrun mode
+      if !whyrun_mode? || whyrun_supported?
+        load_current_resource
+        events.resource_current_state_loaded(@new_resource, @action, @current_resource)
+      elsif whyrun_mode? && !whyrun_supported?
+        events.resource_current_state_load_bypassed(@new_resource, @action, @current_resource)
+      end
+
+      define_resource_requirements
+      process_resource_requirements
+
+      # user-defined providers including LWRPs may
+      # not include whyrun support - if they don't support it
+      # we can't execute any actions while we're running in
+      # whyrun mode. Instead we 'fake' whyrun by documenting that
+      # we can't execute the action.
+      # in non-whyrun mode, this will still cause the action to be
+      # executed normally.
+      if whyrun_supported? && !requirements.action_blocked?(@action)
+        send("action_#{@action}")
+      elsif whyrun_mode?
+        events.resource_bypassed(@new_resource, @action, self)
+      else
+        send("action_#{@action}")
+      end
+
+      set_updated_status
+
+      cleanup_after_converge
+    end
+
+    def process_resource_requirements
+      requirements.run(:all_actions) unless @action == :nothing
+      requirements.run(@action)
+    end
+
+    def resource_updated?
+      !converge_actions.empty? || @new_resource.updated_by_last_action?
+    end
+
+    def set_updated_status
+      if !resource_updated?
+        events.resource_up_to_date(@new_resource, @action)
+      else
+        events.resource_updated(@new_resource, @action)
+        new_resource.updated_by_last_action(true)
+      end
+    end
+
+    def requirements
+      @requirements ||= ResourceRequirements.new(@new_resource, run_context)
+    end
+
+    def converge_by(descriptions, &block)
+      converge_actions.add_action(descriptions, &block)
+    end
+
+    protected
+
+    def converge_actions
+      @converge_actions ||= ConvergeActions.new(@new_resource, run_context, @action)
+    end
+
+    def recipe_eval(&block)
+      # This block has new resource definitions within it, which
+      # essentially makes it an in-line Chef run. Save our current
+      # run_context and create one anew, so the new Chef run only
+      # executes the embedded resources.
+      #
+      # TODO: timh,cw: 2010-5-14: This means that the resources within
+      # this block cannot interact with resources outside, e.g.,
+      # manipulating notifies.
+
+      converge_by ("evaluate block and run any associated actions") do
+        saved_run_context = @run_context
+        @run_context = @run_context.dup
+        @run_context.resource_collection = Chef::ResourceCollection.new
+        instance_eval(&block)
+        Chef::Runner.new(@run_context).converge
+        @run_context = saved_run_context
+      end
+    end
+
+    module DeprecatedLWRPClass
+      def const_missing(class_name)
+        if deprecated_constants[class_name.to_sym]
+          Chef::Log.deprecation("Using an LWRP provider by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::ProviderResolver.new(node, resource, action) instead.")
+          deprecated_constants[class_name.to_sym]
+        else
+          raise NameError, "uninitialized constant Chef::Provider::#{class_name}"
+        end
+      end
+
+      # @api private
+      def register_deprecated_lwrp_class(provider_class, class_name)
+        # Register Chef::Provider::MyProvider with deprecation warnings if you
+        # try to access it
+        if Chef::Provider.const_defined?(class_name, false)
+          Chef::Log.warn "Chef::Provider::#{class_name} already exists!  Cannot create deprecation class for #{provider_class}"
+        else
+          deprecated_constants[class_name.to_sym] = provider_class
+        end
+      end
+
+      private
+
+      def deprecated_constants
+        @deprecated_constants ||= {}
+      end
+    end
+    extend DeprecatedLWRPClass
+  end
+end