chef 10.28.2-x86-mingw32

data/lib/chef/run_context.rb

@@ -0,0 +1,236 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008-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/resource_collection'
+require 'chef/node'
+require 'chef/role'
+require 'chef/log'
+require 'chef/mixin/language_include_recipe'
+
+class Chef
+  # == Chef::RunContext
+  # Value object that loads and tracks the context of a Chef run
+  class RunContext
+
+    # Used to load the node's recipes after expanding its run list
+    include Chef::Mixin::LanguageIncludeRecipe
+
+    attr_reader :node, :cookbook_collection, :definitions
+
+    # Needs to be settable so deploy can run a resource_collection independent
+    # of any cookbooks.
+    attr_accessor :resource_collection, :immediate_notification_collection, :delayed_notification_collection
+
+    attr_reader :events
+
+    # Creates a new Chef::RunContext object and populates its fields. This object gets
+    # used by the Chef Server to generate a fully compiled recipe list for a node.
+    #
+    # === Returns
+    # object<Chef::RunContext>:: Duh. :)
+    def initialize(node, cookbook_collection, events)
+      @node = node
+      @cookbook_collection = cookbook_collection
+      @resource_collection = Chef::ResourceCollection.new
+      @immediate_notification_collection = Hash.new {|h,k| h[k] = []}
+      @delayed_notification_collection = Hash.new {|h,k| h[k] = []}
+      @definitions = Hash.new
+      @events = events
+
+      # TODO: 5/18/2010 cw/timh - See note on Chef::Node's
+      # cookbook_collection attr_accessor
+      node.cookbook_collection = cookbook_collection
+    end
+
+    def load(run_list_expansion)
+      load_libraries
+
+      load_lwrps
+      load_attributes
+      load_resource_definitions
+
+      # Precendence rules state that roles' attributes come after
+      # cookbooks. Now we've loaded attributes from cookbooks with
+      # load_attributes, apply the expansion attributes (loaded from
+      # roles) to the node.
+      @node.apply_expansion_attributes(run_list_expansion)
+
+      @events.recipe_load_start(run_list_expansion.recipes.size)
+      run_list_expansion.recipes.each do |recipe|
+        begin
+          # TODO: timh/cw, 5-14-2010: It's distasteful to be including
+          # the DSL in a class outside the context of the DSL
+          include_recipe(recipe)
+        rescue Chef::Exceptions::RecipeNotFound => e
+          @events.recipe_not_found(e)
+          raise
+        rescue Exception => e
+          path = resolve_recipe(recipe)
+          @events.recipe_file_load_failed(path, e)
+          raise
+        end
+      end
+      @events.recipe_load_complete
+    end
+
+    def resolve_recipe(recipe_name)
+      cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name)
+      cookbook = cookbook_collection[cookbook_name]
+      cookbook.recipe_filenames_by_name[recipe_short_name]
+    end
+
+    def notifies_immediately(notification)
+      nr = notification.notifying_resource
+      if nr.instance_of?(Chef::Resource)
+        @immediate_notification_collection[nr.name] << notification
+      else
+        @immediate_notification_collection[nr.to_s] << notification
+      end
+    end
+
+    def notifies_delayed(notification)
+      nr = notification.notifying_resource
+      if nr.instance_of?(Chef::Resource)
+        @delayed_notification_collection[nr.name] << notification
+      else
+        @delayed_notification_collection[nr.to_s] << notification
+      end
+    end
+
+    def immediate_notifications(resource)
+      if resource.instance_of?(Chef::Resource)
+        return @immediate_notification_collection[resource.name]
+      else
+        return @immediate_notification_collection[resource.to_s]
+      end
+    end
+
+    def delayed_notifications(resource)
+      if resource.instance_of?(Chef::Resource)
+        return @delayed_notification_collection[resource.name]
+      else
+        return @delayed_notification_collection[resource.to_s]
+      end
+    end
+
+    private
+
+    def load_libraries
+      @events.library_load_start(count_files_by_segment(:libraries))
+
+      foreach_cookbook_load_segment(:libraries) do |cookbook_name, filename|
+        begin
+          Chef::Log.debug("Loading cookbook #{cookbook_name}'s library file: #{filename}")
+          Kernel.load(filename)
+          @events.library_file_loaded(filename)
+        rescue Exception => e
+          # TODO wrap/munge exception to highlight syntax/name/no method errors.
+          @events.library_file_load_failed(filename, e)
+          raise
+        end
+      end
+
+      @events.library_load_complete
+    end
+
+    def load_lwrps
+      lwrp_file_count = count_files_by_segment(:providers) + count_files_by_segment(:resources)
+      @events.lwrp_load_start(lwrp_file_count)
+      load_lwrp_providers
+      load_lwrp_resources
+      @events.lwrp_load_complete
+    end
+
+    def load_lwrp_providers
+      foreach_cookbook_load_segment(:providers) do |cookbook_name, filename|
+        begin
+          Chef::Log.debug("Loading cookbook #{cookbook_name}'s providers from #{filename}")
+          Chef::Provider.build_from_file(cookbook_name, filename, self)
+          @events.lwrp_file_loaded(filename)
+        rescue Exception => e
+          # TODO: wrap exception with helpful info
+          @events.lwrp_file_load_failed(filename, e)
+          raise
+        end
+      end
+    end
+
+    def load_lwrp_resources
+      foreach_cookbook_load_segment(:resources) do |cookbook_name, filename|
+        begin
+          Chef::Log.debug("Loading cookbook #{cookbook_name}'s resources from #{filename}")
+          Chef::Resource.build_from_file(cookbook_name, filename, self)
+          @events.lwrp_file_loaded(filename)
+        rescue Exception => e
+          @events.lwrp_file_load_failed(filename, e)
+          raise
+        end
+      end
+    end
+
+    def load_attributes
+      @events.attribute_load_start(count_files_by_segment(:attributes))
+      foreach_cookbook_load_segment(:attributes) do |cookbook_name, filename|
+        begin
+          Chef::Log.debug("Node #{@node.name} loading cookbook #{cookbook_name}'s attribute file #{filename}")
+          @node.from_file(filename)
+        rescue Exception => e
+          @events.attribute_file_load_failed(filename, e)
+          raise
+        end
+      end
+      @events.attribute_load_complete
+    end
+
+    def load_resource_definitions
+      @events.definition_load_start(count_files_by_segment(:definitions))
+      foreach_cookbook_load_segment(:definitions) do |cookbook_name, filename|
+        begin
+          Chef::Log.debug("Loading cookbook #{cookbook_name}'s definitions from #{filename}")
+          resourcelist = Chef::ResourceDefinitionList.new
+          resourcelist.from_file(filename)
+          definitions.merge!(resourcelist.defines) do |key, oldval, newval|
+            Chef::Log.info("Overriding duplicate definition #{key}, new definition found in #{filename}")
+            newval
+          end
+          @events.definition_file_loaded(filename)
+        rescue Exception => e
+          @events.definition_file_load_failed(filename, e)
+        end
+      end
+      @events.definition_load_complete
+    end
+
+    def count_files_by_segment(segment)
+      cookbook_collection.inject(0) do |count, ( cookbook_name, cookbook )|
+        count + cookbook.segment_filenames(segment).size
+      end
+    end
+
+    def foreach_cookbook_load_segment(segment, &block)
+      cookbook_collection.each do |cookbook_name, cookbook|
+        segment_filenames = cookbook.segment_filenames(segment)
+        segment_filenames.each do |segment_filename|
+          block.call(cookbook_name, segment_filename)
+        end
+      end
+    end
+
+  end
+end

data/lib/chef/run_list.rb

@@ -0,0 +1,165 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuoyan@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright (c) 2008-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.
+
+require 'chef/run_list/run_list_item'
+require 'chef/run_list/run_list_expansion'
+require 'chef/run_list/versioned_recipe_list'
+require 'chef/mixin/params_validate'
+
+class Chef
+  class RunList
+    include Enumerable
+    include Chef::Mixin::ParamsValidate
+
+    # @run_list_items is an array of RunListItems that describe the items to
+    # execute in order. RunListItems can load from and convert to the string
+    # forms users set on roles and nodes.
+    # For example:
+    #   @run_list_items = ['recipe[foo::bar]', 'role[webserver]']
+    # Thus,
+    #   self.role_names would return ['webserver']
+    #   self.recipe_names would return ['foo::bar']
+    attr_reader :run_list_items
+
+    # For backwards compat
+    alias :run_list :run_list_items
+
+    def initialize(*run_list_items)
+      @run_list_items = run_list_items.map { |i| coerce_to_run_list_item(i) }
+    end
+
+    def role_names
+      @run_list_items.inject([]){|memo, run_list_item| memo << run_list_item.name if run_list_item.role? ; memo}
+    end
+
+    alias :roles :role_names
+
+    def recipe_names
+      @run_list_items.inject([]){|memo, run_list_item| memo << run_list_item.name if run_list_item.recipe? ; memo}
+    end
+
+    alias :recipes :recipe_names
+
+    # Add an item of the form "recipe[foo::bar]" or "role[webserver]";
+    # takes a String or a RunListItem
+    def <<(run_list_item)
+      run_list_item = coerce_to_run_list_item(run_list_item)
+      @run_list_items << run_list_item unless @run_list_items.include?(run_list_item)
+      self
+    end
+
+    alias :push :<<
+    alias :add :<<
+
+    def ==(other)
+      if other.kind_of?(Chef::RunList)
+        other.run_list_items == @run_list_items
+      else
+        return false unless other.respond_to?(:size) && (other.size == @run_list_items.size)
+        other_run_list_items = other.dup
+
+        other_run_list_items.map! { |item| coerce_to_run_list_item(item) }
+        other_run_list_items == @run_list_items
+      end
+    end
+
+    def to_s
+      @run_list_items.join(", ")
+    end
+
+    def to_json(*args)
+      to_a.map { |item| item.to_s}.to_json(*args)
+    end
+
+    def empty?
+      @run_list_items.length == 0 ? true : false
+    end
+
+    def [](pos)
+      @run_list_items[pos]
+    end
+
+    def []=(pos, item)
+      @run_list_items[pos] = parse_entry(item)
+    end
+
+    def each(&block)
+      @run_list_items.each { |i| block.call(i) }
+    end
+
+    def each_index(&block)
+      @run_list_items.each_index { |i| block.call(i) }
+    end
+
+    def include?(item)
+      @run_list_items.include?(parse_entry(item))
+    end
+
+    def reset!(*args)
+      @run_list_items.clear
+      args.flatten.each do |item|
+        if item.kind_of?(Chef::RunList)
+          item.each { |r| self << r }
+        else
+          self << item
+        end
+      end
+      self
+    end
+
+    def remove(item)
+      @run_list_items.delete_if{|i| i == item}
+      self
+    end
+    alias :delete :remove
+
+    # Expands this run_list: recursively expand roles into their included
+    # recipes.
+    # Returns a RunListExpansion object.
+    def expand(environment, data_source='server', expansion_opts={})
+      expansion = expansion_for_data_source(environment, data_source, expansion_opts)
+      expansion.expand
+      expansion
+    end
+
+    # Converts a string run list entry to a RunListItem object.
+    def parse_entry(entry)
+      RunListItem.new(entry)
+    end
+
+    def coerce_to_run_list_item(item)
+      item.kind_of?(RunListItem) ? item : parse_entry(item)
+    end
+
+    def expansion_for_data_source(environment, data_source, opts={})
+      case data_source.to_s
+      when 'disk'
+        RunListExpansionFromDisk.new(environment, @run_list_items)
+      when 'server'
+        RunListExpansionFromAPI.new(environment, @run_list_items, opts[:rest])
+      when 'couchdb'
+        RunListExpansionFromCouchDB.new(environment, @run_list_items, opts[:couchdb])
+      end
+    end
+
+
+  end
+end

data/lib/chef/run_list/run_list_expansion.rb

@@ -0,0 +1,206 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2010, 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.
+
+require 'chef/mash'
+
+require 'chef/mixin/deep_merge'
+
+require 'chef/role'
+require 'chef/couchdb'
+require 'chef/rest'
+
+class Chef
+  class RunList
+    # Abstract Base class for expanding a run list. Subclasses must handle
+    # fetching roles from a data source by defining +fetch_role+
+    class RunListExpansion
+
+      attr_reader :run_list_items
+
+      # A VersionedRecipeList of recipes. Populated only after #expand
+      # is called.
+      attr_reader :recipes
+
+      attr_reader :default_attrs
+
+      attr_reader :override_attrs
+
+      attr_reader :environment
+
+      attr_reader :missing_roles_with_including_role
+
+      # The data source passed to the constructor. Not used in this class.
+      # In subclasses, this is a couchdb or Chef::REST object pre-configured
+      # to fetch roles from their correct location.
+      attr_reader :source
+
+      # Returns a Hash of the form "including_role" => "included_role_or_recipe".
+      # This can be used to show the expanded run list (ordered) graph.
+      # ==== Caveats
+      # * Duplicate roles are not shown.
+      attr_reader :run_list_trace
+
+      def initialize(environment, run_list_items, source=nil)
+        @environment = environment
+        @missing_roles_with_including_role = Array.new
+
+        @run_list_items = run_list_items.dup
+        @source = source
+
+        @default_attrs = Mash.new
+        @override_attrs = Mash.new
+
+        @recipes = Chef::RunList::VersionedRecipeList.new
+
+        @applied_roles = {}
+        @run_list_trace = Hash.new {|h, key| h[key] = [] }
+      end
+
+      # Did we find any errors (expanding roles)?
+      def errors?
+        @missing_roles_with_including_role.length > 0
+      end
+
+      alias :invalid? :errors?
+
+      # Recurses over the run list items, expanding roles. After this,
+      # +recipes+ will contain the fully expanded recipe list
+      def expand
+        # Sure do miss function arity when being recursive
+        expand_run_list_items(@run_list_items)
+      end
+
+      # Fetches and inflates a role
+      # === Returns
+      # Chef::Role  in most cases
+      # false       if the role has already been applied
+      # nil         if the role does not exist
+      def inflate_role(role_name, included_by)
+        return false if applied_role?(role_name) # Prevent infinite loops
+        applied_role(role_name)
+        fetch_role(role_name, included_by)
+      end
+
+      def apply_role_attributes(role)
+        @default_attrs = Chef::Mixin::DeepMerge.role_merge(@default_attrs, role.default_attributes)
+        @override_attrs = Chef::Mixin::DeepMerge.role_merge(@override_attrs, role.override_attributes)
+      end
+
+      def applied_role?(role_name)
+        @applied_roles.has_key?(role_name)
+      end
+
+      # Returns an array of role names that were expanded; this
+      # includes any roles that were in the original, pre-expansion
+      # run_list as well as roles processed during
+      # expansion. Populated only after #expand is called.
+      def roles
+        @applied_roles.keys
+      end
+
+      # In subclasses, this method will fetch the role from the data source.
+      def fetch_role(name, included_by)
+        raise NotImplementedError
+      end
+
+      # When a role is not found, an error message is logged, but no
+      # exception is raised.  We do add an entry in the errors collection.
+      # === Returns
+      # nil
+      def role_not_found(name, included_by)
+        Chef::Log.error("Role #{name} (included by '#{included_by}') is in the runlist but does not exist. Skipping expand.")
+        @missing_roles_with_including_role << [name, included_by]
+        nil
+      end
+
+      def errors
+        @missing_roles_with_including_role.map {|item| item.first }
+      end
+
+      private
+
+      # these methods modifies internal state based on arguments, so hide it.
+
+      def applied_role(role_name)
+        @applied_roles[role_name] = true
+      end
+
+      def expand_run_list_items(items, included_by="top level")
+        if entry = items.shift
+          @run_list_trace[included_by.to_s] << entry.to_s
+
+          case entry.type
+          when :recipe
+            recipes.add_recipe(entry.name, entry.version)
+          when :role
+            if role = inflate_role(entry.name, included_by)
+              expand_run_list_items(role.run_list_for(@environment).run_list_items, role)
+              apply_role_attributes(role)
+            end
+          end
+          expand_run_list_items(items, included_by)
+        end
+      end
+
+    end
+
+    # Expand a run list from disk. Suitable for chef-solo
+    class RunListExpansionFromDisk < RunListExpansion
+
+      def fetch_role(name, included_by)
+        Chef::Role.from_disk(name)
+      rescue Chef::Exceptions::RoleNotFound
+        role_not_found(name, included_by)
+      end
+
+    end
+
+    # Expand a run list from the chef-server API.
+    class RunListExpansionFromAPI < RunListExpansion
+
+      def rest
+        @rest ||= (source || Chef::REST.new(Chef::Config[:role_url]))
+      end
+
+      def fetch_role(name, included_by)
+        rest.get_rest("roles/#{name}")
+      rescue Net::HTTPServerException => e
+        if e.message == '404 "Not Found"'
+          role_not_found(name, included_by)
+        else
+          raise
+        end
+      end
+    end
+
+    # Expand a run list from couchdb. Used in chef-server-api
+    class RunListExpansionFromCouchDB < RunListExpansion
+
+      def couchdb
+        source
+      end
+
+      def fetch_role(name, included_by)
+        Chef::Role.cdb_load(name, couchdb)
+      rescue Chef::Exceptions::CouchDBNotFound
+        role_not_found(name, included_by)
+      end
+
+    end
+  end
+end