chef 0.9.18 → 0.10.0.beta.0

data/lib/chef/run_list.rb

@@ -3,7 +3,8 @@
 # Author:: Nuo Yan (<nuoyan@opscode.com>)
 # Author:: Tim Hinderliter (<tim@opscode.com>)
 # Author:: Christopher Walters (<cw@opscode.com>)
-# Copyright:: Copyright (c) 2008-2010 Opscode, Inc.
+# 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");
@@ -20,10 +21,13 @@
 
 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
@@ -38,8 +42,8 @@ class Chef
     # For backwards compat
     alias :run_list :run_list_items
 
-    def initialize
-      @run_list_items = Array.new
+    def initialize(*run_list_items)
+      @run_list_items = run_list_items.map { |i| coerce_to_run_list_item(i) }
     end
 
     def role_names
@@ -57,11 +61,13 @@ class Chef
     # 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 = run_list_item.kind_of?(RunListItem) ? run_list_item : parse_entry(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 :<<
+
     def ==(other)
       if other.kind_of?(Chef::RunList)
         other.run_list_items == @run_list_items
@@ -69,7 +75,7 @@ class Chef
         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| item.kind_of?(RunListItem) ? item : RunListItem.new(item) }
+        other_run_list_items.map! { |item| coerce_to_run_list_item(item) }
         other_run_list_items == @run_list_items
       end
     end
@@ -78,6 +84,10 @@ class Chef
       @run_list_items.join(", ")
     end
 
+    def to_json(*args)
+      to_a.to_json(*args)
+    end
+
     def empty?
       @run_list_items.length == 0 ? true : false
     end
@@ -118,33 +128,38 @@ class Chef
       @run_list_items.delete_if{|i| i == item}
       self
     end
+    alias :delete :remove
 
-    def expand(data_source='server', couchdb=nil, rest=nil)
-      couchdb = couchdb ? couchdb : Chef::CouchDB.new
-
-      expansion = expansion_for_data_source(data_source, :couchdb => couchdb, :rest => rest)
+    # 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.
-    # TODO: 5/27/2010 cw: this method has become nothing more than a proxy, revisit its necessity
     def parse_entry(entry)
       RunListItem.new(entry)
     end
 
-    def expansion_for_data_source(data_source, opts={})
-      data_source = 'disk' if Chef::Config[:solo]
+    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(@run_list_items)
+        RunListExpansionFromDisk.new(environment, @run_list_items)
       when 'server'
-        RunListExpansionFromAPI.new(@run_list_items, opts[:rest])
+        RunListExpansionFromAPI.new(environment, @run_list_items, opts[:rest])
       when 'couchdb'
-        RunListExpansionFromCouchDB.new(@run_list_items, opts[:couchdb])
+        RunListExpansionFromCouchDB.new(environment, @run_list_items, opts[:couchdb])
       end
     end
 
+
   end
 end
 

data/lib/chef/run_list/run_list_expansion.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# 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");
@@ -15,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'extlib'
+require 'chef/mash'
 
 require 'chef/mixin/deep_merge'
 
@@ -31,6 +32,8 @@ class Chef
 
       attr_reader :run_list_items
 
+      # A VersionedRecipeList of recipes. Populated only after #expand
+      # is called.
       attr_reader :recipes
 
       attr_reader :default_attrs
@@ -39,12 +42,15 @@ class Chef
 
       attr_reader :errors
 
+      attr_reader :environment
+
       # 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
 
-      def initialize(run_list_items, source=nil)
+      def initialize(environment, run_list_items, source=nil)
+        @environment = environment
         @errors = Array.new
 
         @run_list_items = run_list_items.dup
@@ -53,7 +59,7 @@ class Chef
         @default_attrs = Mash.new
         @override_attrs = Mash.new
 
-        @recipes = []
+        @recipes = Chef::RunList::VersionedRecipeList.new
 
         @applied_roles = {}
       end
@@ -65,20 +71,11 @@ class Chef
 
       alias :invalid? :errors?
 
-      # Iterates over the run list items, expanding roles. After this,
+      # Recurses over the run list items, expanding roles. After this,
       # +recipes+ will contain the fully expanded recipe list
       def expand
-        @run_list_items.each_with_index do |entry, index|
-          case entry.type
-          when :recipe
-            recipes << entry.name unless recipes.include?(entry.name)
-          when :role
-            if role = inflate_role(entry.name)
-              apply_role_attributes(role)
-              @run_list_items.insert(index + 1, *role.run_list.run_list_items)
-            end
-          end
-        end
+        # Sure do miss function arity when being recursive
+        expand_run_list_items(@run_list_items)
       end
 
       # Fetches and inflates a role
@@ -101,10 +98,10 @@ class Chef
         @applied_roles.has_key?(role_name)
       end
 
-      def applied_role(role_name)
-        @applied_roles[role_name] = true
-      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
@@ -123,6 +120,30 @@ class Chef
         @errors << name
         nil
       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)
+        if entry = items.shift
+          case entry.type
+          when :recipe
+            recipes.add_recipe(entry.name, entry.version)
+          when :role
+            if role = inflate_role(entry.name)
+              expand_run_list_items(role.run_list_for(@environment).run_list_items)
+              apply_role_attributes(role)
+            end
+          end
+          expand_run_list_items(items)
+        end
+      end
+
     end
 
     # Expand a run list from disk. Suitable for chef-solo

data/lib/chef/run_list/run_list_item.rb

@@ -18,27 +18,41 @@
 class Chef
   class RunList
     class RunListItem
-      QUALIFIED_RECIPE = %r{^recipe\[([^\]]+)\]$}
-      QUALIFIED_ROLE   = %r{^role\[([^\]]+)\]$}
+      QUALIFIED_RECIPE             = %r{^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$}
+      QUALIFIED_ROLE               = %r{^role\[([^\]]+)\]$}
+      VERSIONED_UNQUALIFIED_RECIPE = %r{^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$}
 
-      attr_reader :name
+      attr_reader :name, :type, :version
 
-      attr_reader :type
 
       def initialize(item)
+        @version = nil
         case item
         when Hash
           assert_hash_is_valid_run_list_item!(item)
           @type = (item['type'] || item[:type]).to_sym
           @name = item['name'] || item[:name]
+          if (item.has_key?('version') || item.has_key?(:version))
+            @version = item['version'] || item[:version]
+          end
         when String
           if match = QUALIFIED_RECIPE.match(item)
+            # recipe[recipe_name]
+            # recipe[recipe_name@1.0.0]
             @type = :recipe
             @name = match[1]
+            @version = match[3] if match[3]
           elsif match = QUALIFIED_ROLE.match(item)
+            # role[role_name]
             @type = :role
             @name = match[1]
+          elsif match = VERSIONED_UNQUALIFIED_RECIPE.match(item)
+            # recipe_name@1.0.0
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
           else
+            # recipe_name
             @type = :recipe
             @name = item
           end
@@ -48,7 +62,7 @@ class Chef
       end
 
       def to_s
-        "#{@type}[#{@name}]"
+        "#{@type}[#{@name}#{@version ? "@#{@version}" :""}]"
       end
 
       def role?
@@ -63,7 +77,7 @@ class Chef
         if other.kind_of?(String)
           self.to_s == other.to_s
         else
-          other.respond_to?(:type) && other.respond_to?(:name) && other.type == @type && other.name == @name
+          other.respond_to?(:type) && other.respond_to?(:name) && other.respond_to?(:version) && other.type == @type && other.name == @name && other.version == @version
         end
       end
 

data/lib/chef/run_list/versioned_recipe_list.rb

@@ -0,0 +1,68 @@
+#
+# Author:: Stephen Delano (<stephen@opscode.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright 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/version_class'
+require 'chef/version_constraint'
+
+# Why does this class exist?
+# Why did we not just modify RunList/RunListItem?
+class Chef
+  class RunList
+    class VersionedRecipeList < Array
+
+      def initialize
+        super
+        @versions = Hash.new
+      end
+
+      def add_recipe(name, version=nil)
+        if version && @versions.has_key?(name)
+          unless Chef::Version.new(@versions[name]) == Chef::Version.new(version)
+            raise Chef::Exceptions::CookbookVersionConflict, "Run list requires #{name} at versions #{@versions[name]} and #{version}"
+          end
+        end
+        @versions[name] = version if version
+        self << name unless self.include?(name)
+      end
+
+      def with_versions
+        self.map {|recipe_name| {:name => recipe_name, :version => @versions[recipe_name]}}
+      end
+
+      # Return an Array of Hashes, each of the form:
+      #  {:name => RECIPE_NAME, :version_constraint => Chef::VersionConstraint }
+      def with_version_constraints
+        self.map do |recipe_name|
+          constraint = Chef::VersionConstraint.new(@versions[recipe_name])
+          { :name => recipe_name, :version_constraint => constraint }
+        end
+      end
+
+      # Return an Array of Strings, each of the form:
+      #  "NAME@VERSION"
+      def with_version_constraints_strings
+        self.map do |recipe_name|
+          if @versions[recipe_name]
+            "#{recipe_name}@#{@versions[recipe_name]}"
+          else
+            recipe_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/runner.rb

@@ -8,9 +8,9 @@
 # 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.
@@ -27,7 +27,7 @@ class Chef
   # == Chef::Runner
   # This class is responsible for executing the steps in a Chef run.
   class Runner
-    
+
     attr_reader :run_context
 
     attr_reader :delayed_actions
@@ -38,15 +38,7 @@ class Chef
       @run_context      = run_context
       @delayed_actions  = []
     end
-    
-    def build_provider(resource)
-      provider_class = Chef::Platform.find_provider_for_node(run_context.node, resource)
-      Chef::Log.debug("#{resource} using #{provider_class.to_s}")
-      provider = provider_class.new(resource, run_context)
-      provider.load_current_resource
-      provider
-    end
-    
+
     # Determine the appropriate provider for the given resource, then
     # execute it.
     def run_action(resource, action)
@@ -71,7 +63,7 @@ class Chef
         end
       end
     end
-    
+
     # Iterates over the +resource_collection+ in the +run_context+ calling
     # +run_action+ for each resource in turn.
     def converge
@@ -84,7 +76,7 @@ class Chef
       run_context.resource_collection.execute_each_resource do |resource|
         begin
           Chef::Log.debug("Processing #{resource} on #{run_context.node.name}")
-          
+
           # Execute each of this resource's actions.
           Array(resource.action).each {|action| run_action(resource, action)}
         rescue => e
@@ -92,7 +84,7 @@ class Chef
           raise e unless resource.ignore_failure
         end
       end
-      
+
       # Run all our :delayed actions
       delayed_actions.each do |notification|
         Chef::Log.info( "#{notification.notifying_resource} sending #{notification.action}"\

data/lib/chef/search/query.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -18,10 +18,15 @@
 
 require 'chef/config'
 require 'uri'
+require 'chef/rest'
+require 'chef/node'
+require 'chef/role'
+require 'chef/data_bag'
+require 'chef/data_bag_item'
 
 class Chef
   class Search
-    class Query 
+    class Query
 
       attr_accessor :rest
 
@@ -33,7 +38,7 @@ class Chef
       # it a block, it will handle the paging for you dynamically.
       def search(type, query="*:*", sort='X_CHEF_id_CHEF_X asc', start=0, rows=1000, &block)
         raise ArgumentError, "Type must be a string or a symbol!" unless (type.kind_of?(String) || type.kind_of?(Symbol))
-        
+
         response = @rest.get_rest("search/#{type}?q=#{escape(query)}&sort=#{escape(sort)}&start=#{escape(start)}&rows=#{escape(rows)}")
         if block
           response["rows"].each { |o| block.call(o) unless o.nil?}
@@ -46,14 +51,14 @@ class Chef
           [ response["rows"], response["start"], response["total"] ]
         end
       end
-      
+
       def list_indexes
         response = @rest.get_rest("search")
-      end 
+      end
 
       private
         def escape(s)
-          s && URI.escape(s.to_s) 
+          s && URI.escape(s.to_s)
         end
     end
   end